@the-inkwell/shared 0.2.0 → 0.2.2

package/src/schema/core.ts

@@ -1,1906 +0,0 @@
-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)
-}))