delegateAllocation.ts

Filename	Percent	Threshold	Total	Covered	Uncovered
src/db/schema/delegateAllocation.ts	100.00%	80%	238	238	0

import { boolean, integer, timestamp, varchar } from 'drizzle-orm/pg-core';

import { candidate } from './candidate.js';
import { candidateRace } from './candidateRace.js';
import { county } from './county.js';
import { electionType } from './electionType.js';
import { jurisdiction } from './jurisdiction.js';
import { jurisdictionRace } from './jurisdictionRace.js';
import { jurisdictionType } from './jurisdictionType.js';
import { office } from './office.js';
import { officeRace } from './officeRace.js';
import { relations } from 'drizzle-orm';
import { schema } from './schema.js';
import { state } from './state.js';
import { state_electionType } from './state_electionType.js';

export const delegateAllocation = schema.table('DelegateAllocation', {
  uid: varchar('uid').primaryKey(),
  delegatesAllocated: integer('delegatesAllocated'),
  districtId: integer('districtId'),
  districtType: varchar('districtType'),
  isSummary: boolean('isSummary'),
  isNational: boolean('isNational'),
  totalPrecinctsReportingSoFar: integer('totalPrecinctsReportingSoFar'),
  totalPrecincts: integer('totalPrecincts'),
  provisionalVoteOutstanding: integer('provisionalVoteOutstanding'),
  totalVote: integer('totalVote'),
  transmissionSource: varchar('transmissionSource'),
  absenteeVoteProgress: varchar('absenteeVoteProgress'),
  complete: boolean('complete'),
  final: boolean('final'),
  voteTabulationProgress: varchar('voteTabulationProgress'),
  reportingSource: varchar('reportingSource'),
  verified: boolean('verified'),
  electionDate: timestamp('electionDate'),
  jurisdictionCode: integer('jurisdictionCode'),
  officeCode: varchar('officeCode'),
  scope: varchar('scope'),
  sequence: integer('sequence'),
  timestamp: timestamp('timestamp'),

  candidate: integer('candidate')
    .notNull()
    .references(() => candidate.uid),
  candidateRace: varchar('candidateRace')
    .notNull()
    .references(() => candidateRace.uid),
  county: varchar('county').references(() => county.uid),
  electionType: varchar('electionType')
    .notNull()
    .references(() => electionType.uid),
  jurisdiction: varchar('jurisdiction')
    .notNull()
    .references(() => jurisdiction.uid),
  jurisdictionRace: varchar('jurisdictionRace')
    .notNull()
    .references(() => jurisdictionRace.uid),
  jurisdictionType: varchar('jurisdictionType')
    .notNull()
    .references(() => jurisdictionType.uid),
  office: varchar('office')
    .notNull()
    .references(() => office.uid),
  officeRace: varchar('officeRace')
    .notNull()
    .references(() => officeRace.uid),
  state: integer('state')
    .notNull()
    .references(() => state.uid),
  state_electionType: varchar('state_electionType')
    .notNull()
    .references(() => state_electionType.uid),
});

export type NewDelegateAllocation = typeof delegateAllocation.$inferInsert;

export const delegateAllocationRelations = relations(
  delegateAllocation,
  ({ one }) => ({
    candidate: one(candidate, {
      fields: [delegateAllocation.candidate],
      references: [candidate.uid],
    }),
    candidateRace: one(candidateRace, {
      fields: [delegateAllocation.candidateRace],
      references: [candidateRace.uid],
    }),
    county: one(county, {
      fields: [delegateAllocation.county],
      references: [county.uid],
    }),
    electionType: one(electionType, {
      fields: [delegateAllocation.electionType],
      references: [electionType.uid],
    }),
    jurisdiction: one(jurisdiction, {
      fields: [delegateAllocation.jurisdiction],
      references: [jurisdiction.uid],
    }),
    jurisdictionRace: one(jurisdictionRace, {
      fields: [delegateAllocation.jurisdictionRace],
      references: [jurisdictionRace.uid],
    }),
    jurisdictionType: one(jurisdictionType, {
      fields: [delegateAllocation.jurisdictionType],
      references: [jurisdictionType.uid],
    }),
    office: one(office, {
      fields: [delegateAllocation.office],
      references: [office.uid],
    }),
    officeRace: one(officeRace, {
      fields: [delegateAllocation.officeRace],
      references: [officeRace.uid],
    }),
    state: one(state, {
      fields: [delegateAllocation.state],
      references: [state.uid],
    }),
    state_electionType: one(state_electionType, {
      fields: [delegateAllocation.state_electionType],
      references: [state_electionType.uid],
    }),
  })
);

[]

TypeScript coverage report