@the-inkwell/shared 0.1.163 → 0.2.0

package/src/schema/core.ts

@@ -0,0 +1,1906 @@
+import {
+  pgTable,
+  timestamp,
+  text,
+  integer,
+  foreignKey,
+  uuid,
+  jsonb,
+  uniqueIndex,
+  serial,
+  boolean,
+  doublePrecision,
+  primaryKey,
+  pgEnum
+} from 'drizzle-orm/pg-core'
+import { relations, sql, SQL } from 'drizzle-orm'
+import { makeEnumFromObj } from '../utils'
+import {
+  ACTIONS,
+  CANDIDACY_ASSESSMENT_CATEGORIES,
+  CANDIDACY_REJECTORS,
+  CANDIDACY_SOURCES,
+  CANDIDACY_STAGES,
+  CLIENT_STATUSES,
+  COUNTRIES,
+  EDUCATION_DEGREES,
+  EDUCATION_FIELDS,
+  EMPLOYMENT_LOCATION_TYPES,
+  EMPLOYMENT_TYPES,
+  ENRICHMENT_SOURCES,
+  GENDERS,
+  JOB_LEVELS,
+  LIST_VIEW_MODELS,
+  MESSAGE_CHANNELS,
+  MESSAGE_STATUSES,
+  PERSON_SOURCES,
+  POSITION_CLOSED_REASONS,
+  REFERRAL_SOURCES,
+  STATES
+} from '../constants'
+
+// enums
+
+export const Actions = pgEnum('action', makeEnumFromObj(ACTIONS))
+
+export const CandidacyAssessmentCategories = pgEnum(
+  'candidacy_assessment_category',
+  makeEnumFromObj(CANDIDACY_ASSESSMENT_CATEGORIES)
+)
+
+export const CandidacyRejectors = pgEnum(
+  'candidacy_rejector',
+  makeEnumFromObj(CANDIDACY_REJECTORS)
+)
+
+export const CandidacySources = pgEnum(
+  'candidacy_source',
+  makeEnumFromObj(CANDIDACY_SOURCES)
+)
+
+export const CandidacyStages = pgEnum(
+  'candidacy_stage',
+  makeEnumFromObj(CANDIDACY_STAGES)
+)
+
+export const ClientStatuses = pgEnum(
+  'client_status',
+  makeEnumFromObj(CLIENT_STATUSES)
+)
+
+export const Countries = pgEnum('country', makeEnumFromObj(COUNTRIES))
+
+export const EducationDegrees = pgEnum(
+  'education_degree',
+  makeEnumFromObj(EDUCATION_DEGREES)
+)
+
+export const EducationFields = pgEnum(
+  'education_field',
+  makeEnumFromObj(EDUCATION_FIELDS)
+)
+
+export const EmploymentTypes = pgEnum(
+  'employment_type',
+  makeEnumFromObj(EMPLOYMENT_TYPES)
+)
+
+export const EmploymentLocationTypes = pgEnum(
+  'employment_location_type',
+  makeEnumFromObj(EMPLOYMENT_LOCATION_TYPES)
+)
+
+export const EnrichmentSources = pgEnum(
+  'enrichment_source',
+  makeEnumFromObj(ENRICHMENT_SOURCES)
+)
+
+export const Genders = pgEnum('gender', makeEnumFromObj(GENDERS))
+
+export const JobLevels = pgEnum('job_level', makeEnumFromObj(JOB_LEVELS))
+
+export const ListViewModels = pgEnum(
+  'list_view_model',
+  makeEnumFromObj(LIST_VIEW_MODELS)
+)
+
+export const MessageChannels = pgEnum(
+  'message_channel',
+  makeEnumFromObj(MESSAGE_CHANNELS)
+)
+
+export const MessageStatuses = pgEnum(
+  'message_status',
+  makeEnumFromObj(MESSAGE_STATUSES)
+)
+
+export const PersonSources = pgEnum(
+  'person_source',
+  makeEnumFromObj(PERSON_SOURCES)
+)
+
+export const PositionClosedReasons = pgEnum(
+  'position_closed_reason',
+  makeEnumFromObj(POSITION_CLOSED_REASONS)
+)
+
+export const ReferralSources = pgEnum(
+  'referral_source',
+  makeEnumFromObj(REFERRAL_SOURCES)
+)
+
+export const States = pgEnum('state', makeEnumFromObj(STATES))
+
+// tables
+
+export const action = pgTable(
+  'actions',
+  {
+    id: uuid().defaultRandom().primaryKey().notNull(),
+    candidacyId: uuid(),
+    clientId: uuid(),
+    messageId: uuid(),
+    campaignId: uuid(),
+    noteId: uuid(),
+    personId: uuid(),
+    positionId: uuid(),
+    referralId: uuid(),
+    data: jsonb().$type<any>().notNull(),
+    name: Actions().notNull(),
+    deletedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+    createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull(),
+    updatedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull()
+  },
+  (table) => [
+    foreignKey({
+      columns: [table.candidacyId],
+      foreignColumns: [candidacy.id],
+      name: 'Action_candidacyId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('set null'),
+    foreignKey({
+      columns: [table.clientId],
+      foreignColumns: [client.id],
+      name: 'Action_clientId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('set null'),
+    foreignKey({
+      columns: [table.messageId],
+      foreignColumns: [message.id],
+      name: 'Action_messageId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('set null'),
+    foreignKey({
+      columns: [table.noteId],
+      foreignColumns: [note.id],
+      name: 'Action_noteId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('set null'),
+    foreignKey({
+      columns: [table.positionId],
+      foreignColumns: [position.id],
+      name: 'Action_positionId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('set null'),
+    foreignKey({
+      columns: [table.referralId],
+      foreignColumns: [referral.id],
+      name: 'Action_referralId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('set null'),
+    foreignKey({
+      columns: [table.personId],
+      foreignColumns: [person.id],
+      name: 'Action_personId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('set null'),
+    foreignKey({
+      columns: [table.campaignId],
+      foreignColumns: [campaign.id],
+      name: 'Action_campaignId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('set null')
+  ]
+)
+
+export const admin = pgTable(
+  'admins',
+  {
+    id: uuid().defaultRandom().primaryKey().notNull(),
+    personId: uuid().notNull(),
+    deletedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+    createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull(),
+    updatedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull()
+  },
+  (table) => [
+    uniqueIndex('Admin_personId_key').using(
+      'btree',
+      table.personId.asc().nullsLast().op('uuid_ops')
+    ),
+    foreignKey({
+      columns: [table.personId],
+      foreignColumns: [person.id],
+      name: 'Admin_personId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict')
+  ]
+)
+
+export const certification = pgTable(
+  'certifications',
+  {
+    id: uuid().defaultRandom().primaryKey().notNull(),
+    slug: text().notNull(),
+    name: text().notNull(),
+    description: text(),
+    deletedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+    createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull(),
+    updatedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull()
+  },
+  (table) => [
+    uniqueIndex('Certification_slug_key').using(
+      'btree',
+      table.slug.asc().nullsLast().op('text_ops')
+    )
+  ]
+)
+
+export const client = pgTable('clients', {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  name: text().notNull(),
+  description: text(),
+  isLead: boolean().default(false).notNull(),
+  status: ClientStatuses().default('ACTIVE'),
+  deletedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+  createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+    .defaultNow()
+    .notNull(),
+  updatedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+    .defaultNow()
+    .notNull()
+})
+
+export const campaign = pgTable(
+  'campaigns',
+  {
+    id: uuid().defaultRandom().primaryKey().notNull(),
+    name: text().notNull(),
+    senderId: uuid(),
+    messageChannel: MessageChannels().notNull(),
+    content: jsonb().$type<any>(),
+    listViewId: uuid(),
+    externalId: text(),
+    sentAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+    deletedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+    createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull(),
+    updatedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull()
+  },
+  (table) => [
+    foreignKey({
+      columns: [table.senderId],
+      foreignColumns: [sender.id],
+      name: 'Campaign_senderId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('set null'),
+    foreignKey({
+      columns: [table.listViewId],
+      foreignColumns: [listView.id],
+      name: 'Campaign_listViewId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('set null')
+  ]
+)
+
+export const campaignToPosition = pgTable(
+  'campaigns_to_positions',
+  {
+    campaignId: uuid().notNull(),
+    positionId: uuid().notNull(),
+    createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull()
+  },
+  (table) => [
+    foreignKey({
+      columns: [table.campaignId],
+      foreignColumns: [campaign.id],
+      name: 'CampaignToPosition_campaignId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict'),
+    foreignKey({
+      columns: [table.positionId],
+      foreignColumns: [position.id],
+      name: 'CampaignToPosition_positionId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict'),
+    primaryKey({
+      columns: [table.campaignId, table.positionId],
+      name: 'CampaignToPosition_pkey'
+    })
+  ]
+)
+
+export const candidacy = pgTable(
+  'candidacies',
+  {
+    id: uuid().defaultRandom().primaryKey().notNull(),
+    stage: CandidacyStages().default('SUBMITTED'),
+    networkId: uuid(),
+    source: CandidacySources(),
+    personId: uuid().notNull(),
+    positionId: uuid().notNull(),
+    openedAt: timestamp({
+      precision: 3,
+      mode: 'date',
+      withTimezone: true
+    }).defaultNow(),
+    ratings: jsonb().$type<{
+      EXPERIENCE: number | null
+      INDUSTRY: number | null
+      SKILL: number | null
+      CULTURE: number | null
+      COMPENSATION: number | null
+      LOCATION: number | null
+      MOTIVATION: number | null
+    }>(),
+    rejector: CandidacyRejectors(),
+    rejectionReasons: CandidacyAssessmentCategories().array(),
+    closedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+    deletedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+    createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull(),
+    updatedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull()
+  },
+  (table) => [
+    uniqueIndex('Candidacy_personId_positionId_key').using(
+      'btree',
+      table.personId.asc().nullsLast().op('uuid_ops'),
+      table.positionId.asc().nullsLast().op('uuid_ops')
+    ),
+    foreignKey({
+      columns: [table.positionId],
+      foreignColumns: [position.id],
+      name: 'Candidacy_positionId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict'),
+    foreignKey({
+      columns: [table.personId],
+      foreignColumns: [person.id],
+      name: 'Candidacy_personId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict')
+  ]
+)
+
+export const candidacyFeedback = pgTable(
+  'candidacy_feedback',
+  {
+    id: uuid().defaultRandom().primaryKey().notNull(),
+    candidacyId: uuid().notNull(),
+    content: text().notNull(),
+    deletedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+    createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull(),
+    updatedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull()
+  },
+  (table) => [
+    foreignKey({
+      columns: [table.candidacyId],
+      foreignColumns: [candidacy.id],
+      name: 'CandidacyFeedback_candidacyId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict')
+  ]
+)
+
+export const contract = pgTable(
+  'contracts',
+  {
+    id: uuid().defaultRandom().primaryKey().notNull(),
+    data: jsonb().$type<any>().notNull(),
+    documentUri: text().notNull(),
+    positionId: uuid(),
+    clientId: uuid().notNull(),
+    deletedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+    createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull(),
+    updatedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull()
+  },
+  (table) => [
+    foreignKey({
+      columns: [table.positionId],
+      foreignColumns: [position.id],
+      name: 'Contract_positionId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('set null'),
+    foreignKey({
+      columns: [table.clientId],
+      foreignColumns: [client.id],
+      name: 'Contract_clientId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict')
+  ]
+)
+
+export const education = pgTable(
+  'educations',
+  {
+    id: uuid().defaultRandom().primaryKey().notNull(),
+    personId: uuid().notNull(),
+    degree: EducationDegrees(),
+    field: EducationFields(),
+    school: text(),
+    graduatedAt: timestamp({
+      precision: 3,
+      mode: 'date',
+      withTimezone: true
+    })
+  },
+  (table) => [
+    foreignKey({
+      columns: [table.personId],
+      foreignColumns: [person.id],
+      name: 'Education_personId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict')
+  ]
+)
+
+export const enrichment = pgTable(
+  'enrichments',
+  {
+    id: uuid().defaultRandom().primaryKey().notNull(),
+    data: jsonb().$type<any>(),
+    likelihood: doublePrecision(),
+    source: EnrichmentSources().notNull(),
+    personId: uuid().notNull(),
+    deletedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+    createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull(),
+    updatedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull()
+  },
+  (table) => [
+    uniqueIndex('Enrichment_personId_key').using(
+      'btree',
+      table.personId.asc().nullsLast().op('uuid_ops')
+    ),
+    foreignKey({
+      columns: [table.personId],
+      foreignColumns: [person.id],
+      name: 'Enrichment_personId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict')
+  ]
+)
+
+export const experience = pgTable(
+  'experiences',
+  {
+    id: uuid().defaultRandom().primaryKey().notNull(),
+    personId: uuid().notNull(),
+    jobFunctionId: uuid(),
+    industryId: uuid(),
+    company: text(),
+    level: JobLevels(),
+    title: text(),
+    salary: integer(),
+    isCurrent: boolean().default(false).notNull(),
+    startDate: timestamp({
+      precision: 3,
+      mode: 'date',
+      withTimezone: true
+    }),
+    endDate: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+  },
+  (table) => [
+    foreignKey({
+      columns: [table.personId],
+      foreignColumns: [person.id],
+      name: 'Experience_personId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict'),
+    foreignKey({
+      columns: [table.jobFunctionId],
+      foreignColumns: [jobFunction.id],
+      name: 'Experience_jobFunctionId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('set null'),
+    foreignKey({
+      columns: [table.industryId],
+      foreignColumns: [industry.id],
+      name: 'Experience_industryId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('set null')
+  ]
+)
+
+export const industry = pgTable(
+  'industries',
+  {
+    id: uuid().defaultRandom().primaryKey().notNull(),
+    slug: text().notNull(),
+    name: text().notNull(),
+    deletedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+    createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull(),
+    updatedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull()
+  },
+  (table) => [
+    uniqueIndex('Industry_slug_key').using(
+      'btree',
+      table.slug.asc().nullsLast().op('text_ops')
+    )
+  ]
+)
+
+export const jobFunction = pgTable(
+  'job_functions',
+  {
+    id: uuid().defaultRandom().primaryKey().notNull(),
+    slug: text().notNull(),
+    name: text().notNull(),
+    deletedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+    createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull(),
+    updatedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull()
+  },
+  (table) => [
+    uniqueIndex('JobFunction_slug_key').using(
+      'btree',
+      table.slug.asc().nullsLast().op('text_ops')
+    )
+  ]
+)
+
+export const jwt = pgTable(
+  'jwts',
+  {
+    id: serial().primaryKey().notNull(),
+    jti: text().notNull(),
+    personId: uuid().notNull(),
+    revokedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+    deletedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+    createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull(),
+    updatedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull()
+  },
+  (table) => [
+    uniqueIndex('Jwt_jti_key').using(
+      'btree',
+      table.jti.asc().nullsLast().op('text_ops')
+    ),
+    foreignKey({
+      columns: [table.personId],
+      foreignColumns: [person.id],
+      name: 'Jwt_personId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict')
+  ]
+)
+
+export const listView = pgTable('list_views', {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  model: ListViewModels().notNull(),
+  name: text(),
+  form: jsonb().$type<Record<any, any>>().notNull(),
+  query: jsonb().$type<Record<any, any>>().notNull(),
+  isGeneric: boolean().default(false),
+  archivedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+  deletedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+  createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+    .defaultNow()
+    .notNull(),
+  updatedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+    .defaultNow()
+    .notNull()
+})
+
+export const message = pgTable(
+  'messages',
+  {
+    id: uuid().defaultRandom().primaryKey().notNull(),
+    channel: MessageChannels().notNull(),
+    from: text().notNull(),
+    to: text().notNull(),
+    data: jsonb()
+      .$type<{
+        subject?: string
+        content?: string
+      }>()
+      .notNull(),
+    isReviewed: boolean().default(true).notNull(),
+    isOpened: boolean().default(false).notNull(),
+    isLinkClicked: boolean().default(false).notNull(),
+    outboundSenderId: uuid(),
+    personId: uuid().notNull(),
+    campaignId: uuid(),
+    attachments: jsonb().$type<
+      {
+        filename: string
+        contentType: string
+        uri: string | undefined
+      }[]
+    >(),
+    externalId: text(),
+    status: MessageStatuses().default('PENDING'),
+    statusReason: jsonb().$type<{
+      reason: string | undefined
+      response: string | undefined
+    }>(),
+    deletedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+    createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull(),
+    updatedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull()
+  },
+  (table) => [
+    foreignKey({
+      columns: [table.outboundSenderId],
+      foreignColumns: [sender.id],
+      name: 'Message_senderId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('set null'),
+    foreignKey({
+      columns: [table.campaignId],
+      foreignColumns: [campaign.id],
+      name: 'Message_campaignId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('set null'),
+    foreignKey({
+      columns: [table.personId],
+      foreignColumns: [person.id],
+      name: 'Message_personId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict')
+  ]
+)
+
+export const network = pgTable(
+  'networks',
+  {
+    id: uuid().defaultRandom().primaryKey().notNull(),
+    partnerId: uuid(),
+    slug: text().notNull(),
+    name: text().notNull(),
+    deletedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+    createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull(),
+    updatedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull()
+  },
+  (table) => [
+    uniqueIndex('Networks_slug_key').using(
+      'btree',
+      table.slug.asc().nullsLast().op('text_ops')
+    )
+  ]
+)
+
+export const note = pgTable(
+  'notes',
+  {
+    id: uuid().defaultRandom().primaryKey().notNull(),
+    content: text().notNull(),
+    adminId: uuid(),
+    candidacyId: uuid(),
+    personId: uuid(),
+    clientId: uuid(),
+    positionId: uuid(),
+    deletedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+    createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull(),
+    updatedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull()
+  },
+  (table) => [
+    foreignKey({
+      columns: [table.adminId],
+      foreignColumns: [admin.id],
+      name: 'Note_adminId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('set null'),
+    foreignKey({
+      columns: [table.candidacyId],
+      foreignColumns: [candidacy.id],
+      name: 'Note_candidacyId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('set null'),
+    foreignKey({
+      columns: [table.clientId],
+      foreignColumns: [client.id],
+      name: 'Note_clientId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('set null'),
+    foreignKey({
+      columns: [table.positionId],
+      foreignColumns: [position.id],
+      name: 'Note_positionId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('set null'),
+    foreignKey({
+      columns: [table.personId],
+      foreignColumns: [person.id],
+      name: 'Note_personId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('set null')
+  ]
+)
+
+export const otp = pgTable(
+  'otps',
+  {
+    id: serial().primaryKey().notNull(),
+    code: text().notNull(),
+    usedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+    personId: uuid().notNull(),
+    expiresAt: timestamp({
+      precision: 3,
+      mode: 'date',
+      withTimezone: true
+    }).notNull(),
+    deletedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+    createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull(),
+    updatedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull()
+  },
+  (table) => [
+    uniqueIndex('Otp_code_key').using(
+      'btree',
+      table.code.asc().nullsLast().op('text_ops')
+    ),
+    foreignKey({
+      columns: [table.personId],
+      foreignColumns: [person.id],
+      name: 'Otp_personId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict')
+  ]
+)
+
+export const partner = pgTable('partners', {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  name: text().notNull(),
+  websiteUrl: text(),
+  logoUri: text(),
+  description: text(),
+  deletedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+  createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+    .defaultNow()
+    .notNull(),
+  updatedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+    .defaultNow()
+    .notNull()
+})
+
+export const person = pgTable(
+  'persons',
+  {
+    id: uuid().defaultRandom().primaryKey().notNull(),
+    email: text().notNull(),
+    emailIsVerified: boolean().default(false).notNull(),
+    firstName: text(),
+    lastName: text(),
+    fullName: text().generatedAlwaysAs(
+      (): SQL =>
+        sql`NULLIF(TRIM(COALESCE(${person.firstName}, '') || ' ' || COALESCE(${person.lastName}, '')), '')`
+    ),
+    linkedInUrl: text(),
+    phone: text(),
+    phoneIsVerified: boolean().default(false).notNull(),
+    emailIsOptedOut: boolean().default(false).notNull(),
+    smsIsOptedOut: boolean().default(false).notNull(),
+    resumeUri: text(),
+    resumeText: text(),
+    resumeData: jsonb().$type<any>(),
+    photoUri: text(),
+    isMember: boolean(),
+    lat: doublePrecision(),
+    lon: doublePrecision(),
+    city: text(),
+    state: States(),
+    postalCode: text(),
+    country: Countries(),
+    additionalEmails: text().array(),
+    additionalPhones: text().array(),
+    source: PersonSources().default('SOURCED'),
+    sourcePersonId: uuid(),
+    websiteUrl: text(),
+    expectedSalary: integer(),
+    preferredEmploymentType: EmploymentTypes(),
+    preferredEmploymentLocationType: EmploymentLocationTypes(),
+    preferredMessageChannel: MessageChannels(),
+    isOpenToRelocate: boolean(),
+    gender: Genders(),
+    discoveredThrough: text(),
+    deactivatedAt: timestamp({
+      precision: 3,
+      mode: 'date',
+      withTimezone: true
+    }),
+    lastSignedInAt: timestamp({
+      precision: 3,
+      mode: 'date',
+      withTimezone: true
+    }),
+    signInCount: integer().default(0).notNull(),
+    clientId: uuid(),
+    addedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull(),
+    deletedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+    createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull(),
+    updatedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull()
+  },
+  (table) => [
+    uniqueIndex('Person_email_key').using(
+      'btree',
+      table.email.asc().nullsLast().op('text_ops')
+    ),
+    uniqueIndex('Person_phone_key').using(
+      'btree',
+      table.phone.asc().nullsLast().op('text_ops')
+    ),
+    foreignKey({
+      columns: [table.sourcePersonId],
+      foreignColumns: [table.id],
+      name: 'Person_sourcePersonId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('set null'),
+    foreignKey({
+      columns: [table.clientId],
+      foreignColumns: [client.id],
+      name: 'Person_clientId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('set null')
+  ]
+)
+
+export const personToBestPerson = pgTable(
+  'persons_to_best_persons',
+  {
+    bestiedByPersonId: uuid().notNull(),
+    bestPersonId: uuid().notNull(),
+    createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull()
+  },
+  (table) => [
+    foreignKey({
+      columns: [table.bestiedByPersonId],
+      foreignColumns: [person.id],
+      name: 'PersonToBestPerson_bestiedByPersonId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict'),
+    foreignKey({
+      columns: [table.bestPersonId],
+      foreignColumns: [person.id],
+      name: 'PersonToBestPerson_bestPersonId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict'),
+    primaryKey({
+      columns: [table.bestiedByPersonId, table.bestPersonId],
+      name: 'PersonToBestPerson_pkey'
+    })
+  ]
+)
+
+export const personToCertification = pgTable(
+  'persons_to_certifications',
+  {
+    personId: uuid().notNull(),
+    certificationId: uuid().notNull()
+  },
+  (table) => [
+    foreignKey({
+      columns: [table.personId],
+      foreignColumns: [person.id],
+      name: 'PersonToCertification_personId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict'),
+    foreignKey({
+      columns: [table.certificationId],
+      foreignColumns: [certification.id],
+      name: 'PersonToCertification_certificationId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict'),
+    primaryKey({
+      columns: [table.personId, table.certificationId],
+      name: 'PersonToCertification_pkey'
+    })
+  ]
+)
+
+export const personToNetwork = pgTable(
+  'persons_to_networks',
+  {
+    personId: uuid().notNull(),
+    networkId: uuid().notNull(),
+    createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull()
+  },
+  (table) => [
+    foreignKey({
+      columns: [table.networkId],
+      foreignColumns: [network.id],
+      name: 'PersonToNetwork_networkId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict'),
+    foreignKey({
+      columns: [table.personId],
+      foreignColumns: [person.id],
+      name: 'PersonToNetwork_personId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict'),
+    primaryKey({
+      columns: [table.personId, table.networkId],
+      name: 'PersonToNetwork_pkey'
+    })
+  ]
+)
+
+export const personToSkill = pgTable(
+  'persons_to_skills',
+  {
+    personId: uuid().notNull(),
+    skillId: uuid().notNull(),
+    createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull()
+  },
+  (table) => [
+    foreignKey({
+      columns: [table.skillId],
+      foreignColumns: [skill.id],
+      name: 'PersonToSkill_skillId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict'),
+    foreignKey({
+      columns: [table.personId],
+      foreignColumns: [person.id],
+      name: 'PersonToSkill_personId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict'),
+    primaryKey({
+      columns: [table.personId, table.skillId],
+      name: 'PersonToSkill_pkey'
+    })
+  ]
+)
+
+export const personToTag = pgTable(
+  'persons_to_tags',
+  {
+    personId: uuid().notNull(),
+    tagId: uuid().notNull(),
+    createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull()
+  },
+  (table) => [
+    foreignKey({
+      columns: [table.tagId],
+      foreignColumns: [tag.id],
+      name: 'PersonToTag_tagId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict'),
+    foreignKey({
+      columns: [table.personId],
+      foreignColumns: [person.id],
+      name: 'PersonToTag_personId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict'),
+    primaryKey({
+      columns: [table.personId, table.tagId],
+      name: 'PersonToTag_pkey'
+    })
+  ]
+)
+
+export const position = pgTable(
+  'positions',
+  {
+    id: uuid().defaultRandom().primaryKey().notNull(),
+    slug: text().notNull(),
+    name: text().notNull(),
+    jobFunctionId: uuid(),
+    industryId: uuid(),
+    jobDescription: jsonb().$type<{
+      intro?: string
+      role?: string
+      roleResponsibilities?: string[]
+      candidate?: string
+      candidateQualifications?: string[]
+    }>(),
+    teaser: text(),
+    city: text(),
+    state: States(),
+    postalCode: text(),
+    country: Countries(),
+    employmentType: EmploymentTypes(),
+    employmentLocationType: EmploymentLocationTypes(),
+    // TODO - deprecate once we move away from using referrer location search
+    location: text().generatedAlwaysAs((): SQL => sql`${position.city}`),
+    lat: doublePrecision(),
+    lon: doublePrecision(),
+    isHidden: boolean().default(false).notNull(),
+    isHiddenClient: boolean().default(false).notNull(),
+    salaryMin: integer(),
+    salaryMax: integer(),
+    ratings: jsonb().$type<{
+      COMPENSATION: number | null
+      INTEREST: number | null
+    }>(),
+    referralPlacementReward: integer().default(5000).notNull(),
+    referralInterviewReward: integer().default(100),
+    additionalBenefits: text(),
+    clientId: uuid().notNull(),
+    closedReason: PositionClosedReasons(),
+    openedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+    closedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+    deletedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+    createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull(),
+    updatedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull()
+  },
+  (table) => [
+    foreignKey({
+      columns: [table.jobFunctionId],
+      foreignColumns: [jobFunction.id],
+      name: 'Position_jobFunctionId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict'),
+    foreignKey({
+      columns: [table.industryId],
+      foreignColumns: [industry.id],
+      name: 'Position_industryId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict'),
+    foreignKey({
+      columns: [table.clientId],
+      foreignColumns: [client.id],
+      name: 'Position_clientId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict')
+  ]
+)
+
+export const positionToIndustry = pgTable(
+  'positions_to_industries',
+  {
+    positionId: uuid().notNull(),
+    industryId: uuid().notNull(),
+    createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull()
+  },
+  (table) => [
+    foreignKey({
+      columns: [table.industryId],
+      foreignColumns: [industry.id],
+      name: 'PositionToIndustry_industryId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict'),
+    foreignKey({
+      columns: [table.positionId],
+      foreignColumns: [position.id],
+      name: 'PositionToIndustry_positionId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict'),
+    primaryKey({
+      columns: [table.positionId, table.industryId],
+      name: 'PositionToIndustry_pkey'
+    })
+  ]
+)
+
+export const positionToSkill = pgTable(
+  'positions_to_skills',
+  {
+    positionId: uuid().notNull(),
+    skillId: uuid().notNull(),
+    createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull()
+  },
+  (table) => [
+    foreignKey({
+      columns: [table.skillId],
+      foreignColumns: [skill.id],
+      name: 'PositionToSkill_skillId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict'),
+    foreignKey({
+      columns: [table.positionId],
+      foreignColumns: [position.id],
+      name: 'PositionToSkill_positionId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict'),
+    primaryKey({
+      columns: [table.positionId, table.skillId],
+      name: 'PositionToSkill_pkey'
+    })
+  ]
+)
+
+export const positionToTag = pgTable(
+  'positions_to_tags',
+  {
+    positionId: uuid().notNull(),
+    tagId: uuid().notNull(),
+    createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull()
+  },
+  (table) => [
+    foreignKey({
+      columns: [table.tagId],
+      foreignColumns: [tag.id],
+      name: 'PositionToTag_tagId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict'),
+    foreignKey({
+      columns: [table.positionId],
+      foreignColumns: [position.id],
+      name: 'PositionToTag_personId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict'),
+    primaryKey({
+      columns: [table.positionId, table.tagId],
+      name: 'PositionToTag_pkey'
+    })
+  ]
+)
+
+export const referral = pgTable(
+  'referrals',
+  {
+    id: uuid().defaultRandom().primaryKey().notNull(),
+    source: ReferralSources().notNull(),
+    networkId: uuid(),
+    referrerId: uuid().notNull(),
+    candidacyId: uuid().notNull(),
+    campaignId: uuid(),
+    positionId: uuid().notNull(),
+    deletedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+    createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull(),
+    updatedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull()
+  },
+  (table) => [
+    uniqueIndex('Referral_candidacyId_key').using(
+      'btree',
+      table.candidacyId.asc().nullsLast().op('uuid_ops')
+    ),
+    uniqueIndex('Referral_referrerId_candidacyId_key').using(
+      'btree',
+      table.referrerId.asc().nullsLast().op('uuid_ops'),
+      table.candidacyId.asc().nullsLast().op('uuid_ops')
+    ),
+    foreignKey({
+      columns: [table.candidacyId],
+      foreignColumns: [candidacy.id],
+      name: 'Referral_candidacyId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict'),
+    foreignKey({
+      columns: [table.campaignId],
+      foreignColumns: [campaign.id],
+      name: 'Referral_campaignId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('set null'),
+    foreignKey({
+      columns: [table.positionId],
+      foreignColumns: [position.id],
+      name: 'Referral_positionId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict'),
+    foreignKey({
+      columns: [table.referrerId],
+      foreignColumns: [person.id],
+      name: 'Referral_referrerId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict')
+  ]
+)
+
+export const referralToMessage = pgTable(
+  'referrals_to_messages',
+  {
+    messageId: uuid().notNull(),
+    isIntro: boolean().default(false).notNull(),
+    referralId: uuid().notNull(),
+    createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull()
+  },
+  (table) => [
+    foreignKey({
+      columns: [table.messageId],
+      foreignColumns: [message.id],
+      name: 'ReferralToMessage_messageId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict'),
+    foreignKey({
+      columns: [table.referralId],
+      foreignColumns: [referral.id],
+      name: 'ReferralToMessage_referralId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('restrict'),
+    primaryKey({
+      columns: [table.messageId, table.referralId],
+      name: 'ReferralToMessage_pkey'
+    })
+  ]
+)
+
+export const referralPayout = pgTable(
+  'referral_payouts',
+  {
+    id: uuid().defaultRandom().primaryKey().notNull(),
+    referralId: uuid()
+  },
+  (table) => [
+    foreignKey({
+      columns: [table.referralId],
+      foreignColumns: [referral.id],
+      name: 'ReferralPayout_referralId_fkey'
+    })
+      .onUpdate('cascade')
+      .onDelete('set null')
+  ]
+)
+
+export const sender = pgTable('senders', {
+  id: uuid().defaultRandom().primaryKey().notNull(),
+  name: text().notNull(),
+  email: text().notNull(),
+  replyToEmail: text(),
+  smsNumber: text().notNull(),
+  deletedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+  createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+    .defaultNow()
+    .notNull(),
+  updatedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+    .defaultNow()
+    .notNull()
+})
+
+export const skill = pgTable(
+  'skills',
+  {
+    id: uuid().defaultRandom().primaryKey().notNull(),
+    slug: text().notNull(),
+    name: text().notNull(),
+    deletedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+    createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull(),
+    updatedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull()
+  },
+  (table) => [
+    uniqueIndex('Skill_slug_key').using(
+      'btree',
+      table.slug.asc().nullsLast().op('text_ops')
+    )
+  ]
+)
+
+export const tag = pgTable(
+  'tags',
+  {
+    id: uuid().defaultRandom().primaryKey().notNull(),
+    slug: text().notNull(),
+    name: text().notNull(),
+    deletedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+    createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull(),
+    updatedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull()
+  },
+  (table) => [
+    uniqueIndex('Tag_slug_key').using(
+      'btree',
+      table.slug.asc().nullsLast().op('text_ops')
+    )
+  ]
+)
+
+export const websiteBlock = pgTable(
+  'website_blocks',
+  {
+    id: uuid().defaultRandom().primaryKey().notNull(),
+    slug: text().notNull(),
+    name: text().notNull(),
+    content: text().notNull(),
+    contentType: text().notNull()
+  },
+  (table) => [
+    uniqueIndex('WebsiteBlock_slug_key').using(
+      'btree',
+      table.slug.asc().nullsLast().op('text_ops')
+    )
+  ]
+)
+
+export const websiteLandingPage = pgTable(
+  'website_landing_pages',
+  {
+    id: uuid().defaultRandom().primaryKey().notNull(),
+    tinyUri: text(),
+    slug: text().notNull(),
+    name: text().notNull(),
+    content: jsonb()
+      .$type<{
+        title?: string
+        body?: string
+        positionIds?: Record<string, boolean>
+      }>()
+      .default({})
+      .notNull(),
+    meta: jsonb()
+      .$type<{
+        title?: string
+        description?: string
+        keywords?: string
+      }>()
+      .default({})
+      .notNull(),
+    deletedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true }),
+    createdAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull(),
+    updatedAt: timestamp({ precision: 3, mode: 'date', withTimezone: true })
+      .defaultNow()
+      .notNull()
+  },
+  (table) => [
+    uniqueIndex('WebsiteLandingPage_tinyUri_key').using(
+      'btree',
+      table.tinyUri.asc().nullsLast().op('text_ops')
+    )
+  ]
+)
+
+export const websiteStaticPage = pgTable(
+  'website_static_pages',
+  {
+    id: uuid().defaultRandom().primaryKey().notNull(),
+    slug: text().notNull(),
+    name: text().notNull(),
+    path: text().notNull(),
+    content: jsonb().$type<Record<any, any>>().default({}).notNull(),
+    meta: jsonb()
+      .$type<{
+        title?: string
+        description?: string
+        keywords?: string
+      }>()
+      .default({})
+      .notNull()
+  },
+  (table) => [
+    uniqueIndex('WebsiteStaticPage_slug_key').using(
+      'btree',
+      table.slug.asc().nullsLast().op('text_ops')
+    )
+  ]
+)
+
+// relations
+
+export const actionRelations = relations(action, ({ one }) => ({
+  candidacy: one(candidacy, {
+    fields: [action.candidacyId],
+    references: [candidacy.id]
+  }),
+  client: one(client, {
+    fields: [action.clientId],
+    references: [client.id]
+  }),
+  message: one(message, {
+    fields: [action.messageId],
+    references: [message.id]
+  }),
+  note: one(note, {
+    fields: [action.noteId],
+    references: [note.id]
+  }),
+  position: one(position, {
+    fields: [action.positionId],
+    references: [position.id]
+  }),
+  referral: one(referral, {
+    fields: [action.referralId],
+    references: [referral.id]
+  }),
+  person: one(person, {
+    fields: [action.personId],
+    references: [person.id]
+  })
+}))
+
+export const adminRelations = relations(admin, ({ one, many }) => ({
+  notes: many(note),
+  person: one(person, {
+    fields: [admin.personId],
+    references: [person.id]
+  })
+}))
+
+export const campaignRelations = relations(campaign, ({ one, many }) => ({
+  referrals: many(referral),
+  messages: many(message),
+  positions: many(campaignToPosition),
+  listView: one(listView, {
+    fields: [campaign.listViewId],
+    references: [listView.id]
+  })
+}))
+
+export const campaignToPositionRelations = relations(
+  campaignToPosition,
+  ({ one }) => ({
+    campaign: one(campaign, {
+      fields: [campaignToPosition.campaignId],
+      references: [campaign.id]
+    }),
+    position: one(position, {
+      fields: [campaignToPosition.positionId],
+      references: [position.id]
+    })
+  })
+)
+
+export const candidacyFeedbackRelations = relations(
+  candidacyFeedback,
+  ({ one }) => ({
+    candidacy: one(candidacy, {
+      fields: [candidacyFeedback.candidacyId],
+      references: [candidacy.id]
+    })
+  })
+)
+
+export const candidacyRelations = relations(candidacy, ({ one, many }) => ({
+  actions: many(action),
+  position: one(position, {
+    fields: [candidacy.positionId],
+    references: [position.id]
+  }),
+  person: one(person, {
+    fields: [candidacy.personId],
+    references: [person.id]
+  }),
+  notes: many(note),
+  referral: one(referral),
+  feedbacks: many(candidacyFeedback),
+  network: one(network, {
+    fields: [candidacy.networkId],
+    references: [network.id]
+  })
+}))
+
+export const certificationRelations = relations(certification, ({ many }) => ({
+  persons: many(person)
+}))
+
+export const clientRelations = relations(client, ({ many }) => ({
+  actions: many(action),
+  positions: many(position),
+  notes: many(note),
+  contracts: many(contract),
+  persons: many(person)
+}))
+
+export const contractRelations = relations(contract, ({ one }) => ({
+  position: one(position, {
+    fields: [contract.positionId],
+    references: [position.id]
+  }),
+  client: one(client, {
+    fields: [contract.clientId],
+    references: [client.id]
+  })
+}))
+
+export const educationRelations = relations(education, ({ one }) => ({
+  person: one(person, {
+    fields: [education.personId],
+    references: [person.id]
+  })
+}))
+
+export const enrichmentRelations = relations(enrichment, ({ one }) => ({
+  person: one(person, {
+    fields: [enrichment.personId],
+    references: [person.id]
+  })
+}))
+
+export const experienceRelations = relations(experience, ({ one }) => ({
+  person: one(person, {
+    fields: [experience.personId],
+    references: [person.id]
+  }),
+  jobFunction: one(jobFunction, {
+    fields: [experience.jobFunctionId],
+    references: [jobFunction.id]
+  }),
+  industry: one(industry, {
+    fields: [experience.industryId],
+    references: [industry.id]
+  })
+}))
+
+export const industryRelations = relations(industry, ({ many }) => ({
+  experiences: many(experience)
+}))
+
+export const jobFunctionRelations = relations(jobFunction, ({ many }) => ({
+  experiences: many(experience),
+  positions: many(position)
+}))
+
+export const jwtRelations = relations(jwt, ({ one }) => ({
+  person: one(person, {
+    fields: [jwt.personId],
+    references: [person.id]
+  })
+}))
+
+export const messageRelations = relations(message, ({ one, many }) => ({
+  actions: many(action),
+  outboundSender: one(sender, {
+    fields: [message.outboundSenderId],
+    references: [sender.id]
+  }),
+  person: one(person, {
+    fields: [message.personId],
+    references: [person.id]
+  }),
+  campaign: one(campaign, {
+    fields: [message.campaignId],
+    references: [campaign.id]
+  }),
+  referrals: many(referralToMessage)
+}))
+
+export const networkRelations = relations(network, ({ many, one }) => ({
+  partner: one(partner, {
+    fields: [network.partnerId],
+    references: [partner.id]
+  }),
+  persons: many(personToNetwork),
+  referrals: many(referral),
+  candidacies: many(candidacy)
+}))
+
+export const noteRelations = relations(note, ({ one, many }) => ({
+  actions: many(action),
+  admin: one(admin, {
+    fields: [note.adminId],
+    references: [admin.id]
+  }),
+  candidacy: one(candidacy, {
+    fields: [note.candidacyId],
+    references: [candidacy.id]
+  }),
+  client: one(client, {
+    fields: [note.clientId],
+    references: [client.id]
+  }),
+  position: one(position, {
+    fields: [note.positionId],
+    references: [position.id]
+  }),
+  person: one(person, {
+    fields: [note.personId],
+    references: [person.id]
+  })
+}))
+
+export const otpRelations = relations(otp, ({ one }) => ({
+  person: one(person, {
+    fields: [otp.personId],
+    references: [person.id]
+  })
+}))
+
+export const partnerRelations = relations(partner, ({ many }) => ({
+  networks: many(network)
+}))
+
+export const personRelations = relations(person, ({ one, many }) => ({
+  experiences: many(experience),
+  actions: many(action),
+  candidacies: many(candidacy),
+  educations: many(education),
+  certifications: many(personToCertification),
+  messages: many(message),
+  notes: many(note),
+  referrals: many(referral),
+  admins: many(admin),
+  jwts: many(jwt),
+  otps: many(otp),
+  enrichments: many(enrichment),
+  sourcedBy: one(person, {
+    fields: [person.sourcePersonId],
+    references: [person.id],
+    relationName: 'sourcedPerson'
+  }),
+  sourcedPersons: many(person, {
+    relationName: 'sourcedPerson'
+  }),
+  client: one(client, {
+    fields: [person.clientId],
+    references: [client.id]
+  }),
+  tags: many(personToTag),
+  bestiedBy: many(personToBestPerson, {
+    relationName: 'bestiedBy'
+  }),
+  bestPersons: many(personToBestPerson, {
+    relationName: 'bestPersons'
+  }),
+  networks: many(personToNetwork),
+  skills: many(personToSkill)
+}))
+
+export const personToBestPersonRelations = relations(
+  personToBestPerson,
+  ({ one }) => ({
+    bestiedBy: one(person, {
+      fields: [personToBestPerson.bestiedByPersonId],
+      references: [person.id],
+      relationName: 'bestPersons'
+    }),
+    bestPerson: one(person, {
+      fields: [personToBestPerson.bestPersonId],
+      references: [person.id],
+      relationName: 'bestiedBy'
+    })
+  })
+)
+
+export const personToNetworkRelations = relations(
+  personToNetwork,
+  ({ one }) => ({
+    network: one(network, {
+      fields: [personToNetwork.networkId],
+      references: [network.id]
+    }),
+    person: one(person, {
+      fields: [personToNetwork.personId],
+      references: [person.id]
+    })
+  })
+)
+
+export const personToSkillRelations = relations(personToSkill, ({ one }) => ({
+  skill: one(skill, {
+    fields: [personToSkill.skillId],
+    references: [skill.id]
+  }),
+  person: one(person, {
+    fields: [personToSkill.personId],
+    references: [person.id]
+  })
+}))
+
+export const personToTagRelations = relations(personToTag, ({ one }) => ({
+  tag: one(tag, {
+    fields: [personToTag.tagId],
+    references: [tag.id]
+  }),
+  person: one(person, {
+    fields: [personToTag.personId],
+    references: [person.id]
+  })
+}))
+
+export const positionRelations = relations(position, ({ one, many }) => ({
+  actions: many(action),
+  client: one(client, {
+    fields: [position.clientId],
+    references: [client.id]
+  }),
+  jobFunction: one(jobFunction, {
+    fields: [position.jobFunctionId],
+    references: [jobFunction.id]
+  }),
+  candidacies: many(candidacy),
+  notes: many(note),
+  referrals: many(referral),
+  contracts: many(contract),
+  campaigns: many(campaignToPosition),
+  tags: many(positionToTag)
+}))
+
+export const positionToIndustryRelations = relations(industry, ({ many }) => ({
+  positions: many(positionToIndustry)
+}))
+
+export const positionToSkillRelations = relations(skill, ({ many }) => ({
+  positions: many(positionToSkill)
+}))
+
+export const referralPayoutRelations = relations(referralPayout, ({ one }) => ({
+  referral: one(referral, {
+    fields: [referralPayout.referralId],
+    references: [referral.id]
+  })
+}))
+
+export const referralRelations = relations(referral, ({ one, many }) => ({
+  actions: many(action),
+  candidacy: one(candidacy, {
+    fields: [referral.candidacyId],
+    references: [candidacy.id]
+  }),
+  campaign: one(campaign, {
+    fields: [referral.campaignId],
+    references: [campaign.id]
+  }),
+  position: one(position, {
+    fields: [referral.positionId],
+    references: [position.id]
+  }),
+  referrer: one(person, {
+    fields: [referral.referrerId],
+    references: [person.id]
+  }),
+  payouts: many(referralPayout),
+  messages: many(referralToMessage),
+  network: one(network, {
+    fields: [referral.networkId],
+    references: [network.id]
+  })
+}))
+
+export const referralToMessageRelations = relations(
+  referralToMessage,
+  ({ one }) => ({
+    message: one(message, {
+      fields: [referralToMessage.messageId],
+      references: [message.id]
+    }),
+    referral: one(referral, {
+      fields: [referralToMessage.referralId],
+      references: [referral.id]
+    })
+  })
+)
+
+export const senderRelations = relations(sender, ({ many }) => ({
+  messages: many(message)
+}))
+
+export const skillRelations = relations(skill, ({ many }) => ({
+  persons: many(personToSkill)
+}))
+
+export const tagRelations = relations(tag, ({ many }) => ({
+  persons: many(personToTag),
+  positions: many(positionToTag)
+}))