@the-inkwell/shared 0.1.164 → 0.2.0

package/src/schema/admin/persons/index.ts

@@ -0,0 +1,294 @@
+import {
+  createInsertSchema,
+  createSelectSchema,
+  createUpdateSchema
+} from 'drizzle-zod'
+import {
+  client,
+  education,
+  experience,
+  industry,
+  jobFunction,
+  person,
+  skill,
+  tag
+} from '../../core'
+import { ListQuerySchema, type ListResponse } from '../../../utils'
+import { z } from 'zod/v4'
+import {
+  LIST_REQUEST_SORT_DIRECTIONS,
+  PERSON_LIST_OPERATORS
+} from '../../../constants'
+import phone from 'phone'
+
+//// validators
+
+const emailSchema = z.string().trim().toLowerCase().email()
+const phoneSchema = z
+  .string()
+  .transform((val) => phone(val.trim()).phoneNumber)
+  .pipe(z.string().startsWith('+'))
+  .nullable()
+
+export const AdminPersonEducationSelectSchema = createSelectSchema(education, {
+  field: (schema) => schema.describe('Field of study'),
+  graduatedAt: z
+    .date()
+    .nullable()
+    .describe('Graduation date, use June 1 if exact date unknown')
+}).pick({
+  id: true,
+  degree: true,
+  field: true,
+  school: true,
+  graduatedAt: true
+})
+
+export const AdminPersonExperienceSelectSchema = createSelectSchema(
+  experience,
+  {
+    startDate: z.date().nullable(),
+    endDate: z.date().nullable()
+  }
+)
+  .pick({
+    id: true,
+    title: true,
+    company: true,
+    level: true,
+    salary: true,
+    startDate: true,
+    endDate: true,
+    isCurrent: true
+  })
+  .extend({
+    jobFunction: z.string().nullable(),
+    industry: z.string().nullable()
+  })
+
+export const AdminPersonCreateSchema = createInsertSchema(person).extend({
+  email: emailSchema
+})
+export const AdminPersonSelectSchema = createSelectSchema(person).extend({
+  skills: z.array(
+    createSelectSchema(skill).pick({
+      id: true,
+      name: true
+    })
+  ),
+  tags: z.array(
+    createSelectSchema(tag).pick({
+      id: true,
+      name: true
+    })
+  ),
+  client: createSelectSchema(client).pick({
+    id: true,
+    name: true
+  }),
+  educations: z.array(AdminPersonEducationSelectSchema),
+  experiences: z.array(AdminPersonExperienceSelectSchema),
+  _referralsCount: z.number().nullable().optional(),
+  _referredIndustries: z.array(z.string()).nullable().optional(),
+  _referredLocations: z.array(z.string()).nullable().optional(),
+  _referredSkills: z.array(z.string()).nullable().optional(),
+  _currentTitle: z.string().nullable().optional(),
+  _currentEmployer: z.string().nullable().optional(),
+  _currentSalary: z.number().nullable().optional(),
+  _careerLevel: z.number().nullable().optional(),
+  _currentJobFunction: z.string().nullable().optional(),
+  _currentIndustry: z.string().nullable().optional(),
+  _calculatedIsMember: z.boolean().optional(),
+  industries: z.array(
+    createSelectSchema(industry).pick({
+      id: true,
+      name: true,
+      slug: true
+    })
+  ),
+  jobFunctions: z.array(
+    createSelectSchema(jobFunction).pick({
+      id: true,
+      name: true,
+      slug: true
+    })
+  )
+})
+
+export const AdminPersonUpdateSchema = createUpdateSchema(person).extend({
+  email: emailSchema.optional(),
+  addedAt: z.coerce.date().optional(),
+  phone: phoneSchema.optional()
+})
+
+export const AdminPersonParamsSchema = AdminPersonSelectSchema.pick({
+  id: true,
+  email: true,
+  phone: true
+}).partial()
+
+export const AdminPersonUpdateParamsSchema = AdminPersonSelectSchema.pick({
+  id: true
+})
+
+export const AdminPersonDeleteParamsSchema = AdminPersonSelectSchema.pick({
+  id: true
+})
+
+const FilterSchema = z.object({
+  field: z.string(),
+  isDynamicColumn: z.boolean(),
+  operator: z.enum(PERSON_LIST_OPERATORS),
+  value: z.union([z.string(), z.number(), z.boolean(), z.array(z.string())])
+})
+const GeoSchema = z.object({
+  operator: z.string(),
+  referenceLat: z.number(),
+  referenceLon: z.number(),
+  radius: z.number()
+})
+const CustomQuerySchema = z.object({
+  custom: z.string(),
+  value: z.union([z.string(), z.number(), z.boolean(), z.array(z.string())])
+})
+// TODO - add type
+const NestedFilterSchema: z.ZodType<any> = z.lazy(() =>
+  z.object({
+    and: z
+      .array(
+        z.union([
+          FilterSchema,
+          GeoSchema,
+          CustomQuerySchema,
+          NestedFilterSchema
+        ])
+      )
+      .optional(),
+    or: z
+      .array(
+        z.union([
+          FilterSchema,
+          GeoSchema,
+          CustomQuerySchema,
+          NestedFilterSchema
+        ])
+      )
+      .optional()
+  })
+)
+
+export const AdminPersonListQuerySchema = ListQuerySchema.extend({
+  sort: z
+    .array(
+      z.object({
+        field: z.string(),
+        direction: z.enum(LIST_REQUEST_SORT_DIRECTIONS)
+      })
+    )
+    .optional(),
+  filter: z
+    .union([FilterSchema, GeoSchema, CustomQuerySchema, NestedFilterSchema])
+    .optional()
+})
+
+export const AdminPersonConnectionsParamsSchema = AdminPersonSelectSchema.pick({
+  id: true
+})
+export const AdminPersonConnectionsPersonSchema = AdminPersonSelectSchema.pick({
+  id: true,
+  email: true,
+  fullName: true
+})
+export const AdminPersonConnectionsResultSchema = z.object({
+  sourcedPersons: z.array(AdminPersonConnectionsPersonSchema),
+  sourcedBy: AdminPersonConnectionsPersonSchema.nullable(),
+  bestPersons: z.array(
+    z.object({ bestPerson: AdminPersonConnectionsPersonSchema })
+  ),
+  bestiedBy: z.array(
+    z.object({ bestiedBy: AdminPersonConnectionsPersonSchema })
+  ),
+  referrals: z.array(
+    z.object({
+      candidacy: z.object({ person: AdminPersonConnectionsPersonSchema })
+    })
+  ),
+  candidacies: z.array(
+    z.object({
+      referral: z
+        .object({ referrer: AdminPersonConnectionsPersonSchema })
+        .nullable()
+    })
+  )
+})
+
+//// types
+
+type AdminPerson = z.infer<typeof AdminPersonSelectSchema>
+
+export type AdminPersonExperienceResult = z.infer<
+  typeof AdminPersonExperienceSelectSchema
+>
+export type AdminPersonEducationResult = z.infer<
+  typeof AdminPersonEducationSelectSchema
+>
+
+// detail
+export type AdminPersonParams = z.infer<typeof AdminPersonParamsSchema>
+export type AdminPersonResult = AdminPerson
+
+// list
+export type AdminPersonListQuery = z.infer<typeof AdminPersonListQuerySchema>
+export type AdminPersonListResult = ListResponse<
+  z.infer<typeof AdminPersonSelectSchema>
+>
+
+// create
+export type AdminPersonCreateInput = z.infer<typeof AdminPersonCreateSchema>
+export type AdminPersonCreateResult = Pick<AdminPerson, 'id'>
+
+// update
+export type AdminPersonUpdateParams = z.infer<
+  typeof AdminPersonUpdateParamsSchema
+>
+export type AdminPersonUpdateInput = Partial<AdminPerson>
+
+// delete
+export type AdminPersonDeleteParams = z.infer<
+  typeof AdminPersonDeleteParamsSchema
+>
+
+export const ResumeParserSchema = AdminPersonSelectSchema.pick({
+  firstName: true,
+  lastName: true,
+  email: true,
+  phone: true,
+  city: true,
+  state: true,
+  country: true,
+  gender: true,
+  linkedInUrl: true,
+  websiteUrl: true,
+  skills: true,
+  experiences: true,
+  educations: true
+}).extend({
+  skills: z.array(z.string()),
+  experiences: z.array(
+    AdminPersonExperienceSelectSchema.extend({
+      jobFunction: z.string().nullable()
+    })
+  )
+})
+
+export type AdminPersonResumeParseResult = z.infer<typeof ResumeParserSchema>
+
+export type AdminPersonConnectionsParams = z.infer<
+  typeof AdminPersonConnectionsParamsSchema
+>
+export type AdminPersonConnectionsPerson = z.infer<
+  typeof AdminPersonConnectionsPersonSchema
+>
+export type AdminPersonConnectionsResult = z.infer<
+  typeof AdminPersonConnectionsResultSchema
+>

package/src/schema/admin/personsToBestPersons/index.ts

@@ -0,0 +1,67 @@
+import {
+  createInsertSchema,
+  createSelectSchema,
+  createUpdateSchema
+} from 'drizzle-zod'
+import { personToBestPerson } from '../../core'
+import { ListQuerySchema, type ListResponse } from '../../../utils'
+import { z } from 'zod/v4'
+
+const defaultParams = {
+  bestiedByPersonId: true,
+  bestPersonId: true
+} as const
+
+//// validators
+
+export const AdminPersonToBestPersonCreateSchema =
+  createInsertSchema(personToBestPerson)
+export const AdminPersonToBestPersonSelectSchema =
+  createSelectSchema(personToBestPerson)
+export const AdminPersonToBestPersonUpdateSchema =
+  createUpdateSchema(personToBestPerson)
+
+export const AdminPersonToBestPersonParamsSchema =
+  AdminPersonToBestPersonSelectSchema.pick(defaultParams)
+export const AdminPersonToBestPersonListQuerySchema = ListQuerySchema
+export const AdminPersonToBestPersonUpdateParamsSchema =
+  AdminPersonToBestPersonParamsSchema.pick(defaultParams)
+export const AdminPersonToBestPersonDeleteParamsSchema =
+  AdminPersonToBestPersonParamsSchema.pick(defaultParams)
+
+//// types
+
+type AdminPersonToBestPerson = z.infer<
+  typeof AdminPersonToBestPersonSelectSchema
+>
+
+// detail
+export type AdminPersonToBestPersonParams = z.infer<
+  typeof AdminPersonToBestPersonParamsSchema
+>
+export type AdminPersonToBestPersonResult = AdminPersonToBestPerson
+
+// list
+export type AdminPersonToBestPersonListQuery = z.infer<
+  typeof AdminPersonToBestPersonListQuerySchema
+>
+export type AdminPersonToBestPersonListResult = ListResponse<
+  z.infer<typeof AdminPersonToBestPersonSelectSchema>
+>
+
+// create
+export type AdminPersonToBestPersonCreateInput = z.infer<
+  typeof AdminPersonToBestPersonCreateSchema
+>
+
+// update
+export type AdminPersonToBestPersonUpdateParams = z.infer<
+  typeof AdminPersonToBestPersonUpdateParamsSchema
+>
+export type AdminPersonToBestPersonUpdateInput =
+  Partial<AdminPersonToBestPerson>
+
+// delete
+export type AdminPersonToBestPersonDeleteParams = z.infer<
+  typeof AdminPersonToBestPersonDeleteParamsSchema
+>

package/src/schema/admin/personsToSkills/index.ts

@@ -0,0 +1,61 @@
+import {
+  createInsertSchema,
+  createSelectSchema,
+  createUpdateSchema
+} from 'drizzle-zod'
+import { personToSkill } from '../../core'
+import { ListQuerySchema, type ListResponse } from '../../../utils'
+import { z } from 'zod/v4'
+
+const defaultParams = {
+  personId: true,
+  skillId: true
+} as const
+
+//// validators
+
+export const AdminPersonToSkillCreateSchema = createInsertSchema(personToSkill)
+export const AdminPersonToSkillSelectSchema = createSelectSchema(personToSkill)
+export const AdminPersonToSkillUpdateSchema = createUpdateSchema(personToSkill)
+
+export const AdminPersonToSkillParamsSchema =
+  AdminPersonToSkillSelectSchema.pick(defaultParams)
+export const AdminPersonToSkillListQuerySchema = ListQuerySchema
+export const AdminPersonToSkillUpdateParamsSchema =
+  AdminPersonToSkillParamsSchema.pick(defaultParams)
+export const AdminPersonToSkillDeleteParamsSchema =
+  AdminPersonToSkillParamsSchema.pick(defaultParams)
+
+//// types
+
+type AdminPersonToSkill = z.infer<typeof AdminPersonToSkillSelectSchema>
+
+// detail
+export type AdminPersonToSkillParams = z.infer<
+  typeof AdminPersonToSkillParamsSchema
+>
+export type AdminPersonToSkillResult = AdminPersonToSkill
+
+// list
+export type AdminPersonToSkillListQuery = z.infer<
+  typeof AdminPersonToSkillListQuerySchema
+>
+export type AdminPersonToSkillListResult = ListResponse<
+  z.infer<typeof AdminPersonToSkillSelectSchema>
+>
+
+// create
+export type AdminPersonToSkillCreateInput = z.infer<
+  typeof AdminPersonToSkillCreateSchema
+>
+
+// update
+export type AdminPersonToSkillUpdateParams = z.infer<
+  typeof AdminPersonToSkillUpdateParamsSchema
+>
+export type AdminPersonToSkillUpdateInput = Partial<AdminPersonToSkill>
+
+// delete
+export type AdminPersonToSkillDeleteParams = z.infer<
+  typeof AdminPersonToSkillDeleteParamsSchema
+>

package/src/schema/admin/personsToTags/index.ts

@@ -0,0 +1,61 @@
+import {
+  createInsertSchema,
+  createSelectSchema,
+  createUpdateSchema
+} from 'drizzle-zod'
+import { personToTag } from '../../core'
+import { ListQuerySchema, type ListResponse } from '../../../utils'
+import { z } from 'zod/v4'
+
+const defaultParams = {
+  personId: true,
+  tagId: true
+} as const
+
+//// validators
+
+export const AdminPersonToTagCreateSchema = createInsertSchema(personToTag)
+export const AdminPersonToTagSelectSchema = createSelectSchema(personToTag)
+export const AdminPersonToTagUpdateSchema = createUpdateSchema(personToTag)
+
+export const AdminPersonToTagParamsSchema =
+  AdminPersonToTagSelectSchema.pick(defaultParams)
+export const AdminPersonToTagListQuerySchema = ListQuerySchema
+export const AdminPersonToTagUpdateParamsSchema =
+  AdminPersonToTagParamsSchema.pick(defaultParams)
+export const AdminPersonToTagDeleteParamsSchema =
+  AdminPersonToTagParamsSchema.pick(defaultParams)
+
+//// types
+
+type AdminPersonToTag = z.infer<typeof AdminPersonToTagSelectSchema>
+
+// detail
+export type AdminPersonToTagParams = z.infer<
+  typeof AdminPersonToTagParamsSchema
+>
+export type AdminPersonToTagResult = AdminPersonToTag
+
+// list
+export type AdminPersonToTagListQuery = z.infer<
+  typeof AdminPersonToTagListQuerySchema
+>
+export type AdminPersonToTagListResult = ListResponse<
+  z.infer<typeof AdminPersonToTagSelectSchema>
+>
+
+// create
+export type AdminPersonToTagCreateInput = z.infer<
+  typeof AdminPersonToTagCreateSchema
+>
+
+// update
+export type AdminPersonToTagUpdateParams = z.infer<
+  typeof AdminPersonToTagUpdateParamsSchema
+>
+export type AdminPersonToTagUpdateInput = Partial<AdminPersonToTag>
+
+// delete
+export type AdminPersonToTagDeleteParams = z.infer<
+  typeof AdminPersonToTagDeleteParamsSchema
+>

package/src/schema/admin/positions/index.ts

@@ -0,0 +1,97 @@
+import {
+  createInsertSchema,
+  createSelectSchema,
+  createUpdateSchema
+} from 'drizzle-zod'
+import { client, industry, jobFunction, position, skill, tag } from '../../core'
+import { ListQuerySchema, type ListResponse } from '../../../utils'
+import { z } from 'zod/v4'
+
+//// validators
+
+export const AdminPositionCreateSchema = createInsertSchema(position)
+export const AdminPositionSelectSchema = createSelectSchema(position).extend({
+  client: createSelectSchema(client)
+    .pick({
+      id: true,
+      name: true
+    })
+    .nullable()
+    .optional(),
+  industry: createSelectSchema(industry)
+    .pick({
+      id: true,
+      name: true
+    })
+    .nullable(),
+  jobFunction: createSelectSchema(jobFunction)
+    .pick({
+      id: true,
+      name: true
+    })
+    .nullable(),
+  skills: z.array(
+    createSelectSchema(skill).pick({
+      id: true,
+      name: true
+    })
+  ),
+  tags: z.array(
+    createSelectSchema(tag).pick({
+      id: true,
+      name: true
+    })
+  ),
+  _referralsCount: z.number().optional(),
+  _openCandidaciesCount: z.number().optional()
+})
+export const AdminPositionUpdateSchema = createUpdateSchema(position, {
+  startedAt: z.coerce.date().nullable().optional(),
+  closedAt: z.coerce.date().nullable().optional()
+})
+
+export const AdminPositionParamsSchema = AdminPositionSelectSchema.pick({
+  id: true
+})
+export const AdminPositionListQuerySchema = ListQuerySchema.extend({
+  filter: z
+    .object({
+      isClosed: z.boolean().optional(),
+      clientId: z.string().optional()
+    })
+    .partial()
+    .optional()
+})
+export const AdminPositionUpdateParamsSchema = AdminPositionParamsSchema
+export const AdminPositionDeleteParamsSchema = AdminPositionParamsSchema
+
+//// types
+
+type AdminPosition = z.infer<typeof AdminPositionSelectSchema>
+
+// detail
+export type AdminPositionParams = z.infer<typeof AdminPositionParamsSchema>
+export type AdminPositionResult = AdminPosition
+
+// list
+export type AdminPositionListQuery = z.infer<
+  typeof AdminPositionListQuerySchema
+>
+export type AdminPositionListResult = ListResponse<
+  z.infer<typeof AdminPositionSelectSchema>
+>
+
+// create
+export type AdminPositionCreateInput = z.infer<typeof AdminPositionCreateSchema>
+export type AdminPositionCreateResult = Pick<AdminPosition, 'id'>
+
+// update
+export type AdminPositionUpdateParams = z.infer<
+  typeof AdminPositionUpdateParamsSchema
+>
+export type AdminPositionUpdateInput = z.infer<typeof AdminPositionUpdateSchema>
+
+// delete
+export type AdminPositionDeleteParams = z.infer<
+  typeof AdminPositionDeleteParamsSchema
+>

package/src/schema/admin/positionsToSkills/index.ts

@@ -0,0 +1,64 @@
+import {
+  createInsertSchema,
+  createSelectSchema,
+  createUpdateSchema
+} from 'drizzle-zod'
+import { positionToSkill } from '../../core'
+import { ListQuerySchema, type ListResponse } from '../../../utils'
+import { z } from 'zod/v4'
+
+const defaultParams = {
+  positionId: true,
+  skillId: true
+} as const
+
+//// validators
+
+export const AdminPositionToSkillCreateSchema =
+  createInsertSchema(positionToSkill)
+export const AdminPositionToSkillSelectSchema =
+  createSelectSchema(positionToSkill)
+export const AdminPositionToSkillUpdateSchema =
+  createUpdateSchema(positionToSkill)
+
+export const AdminPositionToSkillParamsSchema =
+  AdminPositionToSkillSelectSchema.pick(defaultParams)
+export const AdminPositionToSkillListQuerySchema = ListQuerySchema
+export const AdminPositionToSkillUpdateParamsSchema =
+  AdminPositionToSkillParamsSchema.pick(defaultParams)
+export const AdminPositionToSkillDeleteParamsSchema =
+  AdminPositionToSkillParamsSchema.pick(defaultParams)
+
+//// types
+
+type AdminPositionToSkill = z.infer<typeof AdminPositionToSkillSelectSchema>
+
+// detail
+export type AdminPositionToSkillParams = z.infer<
+  typeof AdminPositionToSkillParamsSchema
+>
+export type AdminPositionToSkillResult = AdminPositionToSkill
+
+// list
+export type AdminPositionToSkillListQuery = z.infer<
+  typeof AdminPositionToSkillListQuerySchema
+>
+export type AdminPositionToSkillListResult = ListResponse<
+  z.infer<typeof AdminPositionToSkillSelectSchema>
+>
+
+// create
+export type AdminPositionToSkillCreateInput = z.infer<
+  typeof AdminPositionToSkillCreateSchema
+>
+
+// update
+export type AdminPositionToSkillUpdateParams = z.infer<
+  typeof AdminPositionToSkillUpdateParamsSchema
+>
+export type AdminPositionToSkillUpdateInput = Partial<AdminPositionToSkill>
+
+// delete
+export type AdminPositionToSkillDeleteParams = z.infer<
+  typeof AdminPositionToSkillDeleteParamsSchema
+>

package/src/schema/admin/positionsToTags/index.ts

@@ -0,0 +1,61 @@
+import {
+  createInsertSchema,
+  createSelectSchema,
+  createUpdateSchema
+} from 'drizzle-zod'
+import { positionToTag } from '../../core'
+import { ListQuerySchema, type ListResponse } from '../../../utils'
+import { z } from 'zod/v4'
+
+const defaultParams = {
+  positionId: true,
+  tagId: true
+} as const
+
+//// validators
+
+export const AdminPositionToTagCreateSchema = createInsertSchema(positionToTag)
+export const AdminPositionToTagSelectSchema = createSelectSchema(positionToTag)
+export const AdminPositionToTagUpdateSchema = createUpdateSchema(positionToTag)
+
+export const AdminPositionToTagParamsSchema =
+  AdminPositionToTagSelectSchema.pick(defaultParams)
+export const AdminPositionToTagListQuerySchema = ListQuerySchema
+export const AdminPositionToTagUpdateParamsSchema =
+  AdminPositionToTagParamsSchema.pick(defaultParams)
+export const AdminPositionToTagDeleteParamsSchema =
+  AdminPositionToTagParamsSchema.pick(defaultParams)
+
+//// types
+
+type AdminPositionToTag = z.infer<typeof AdminPositionToTagSelectSchema>
+
+// detail
+export type AdminPositionToTagParams = z.infer<
+  typeof AdminPositionToTagParamsSchema
+>
+export type AdminPositionToTagResult = AdminPositionToTag
+
+// list
+export type AdminPositionToTagListQuery = z.infer<
+  typeof AdminPositionToTagListQuerySchema
+>
+export type AdminPositionToTagListResult = ListResponse<
+  z.infer<typeof AdminPositionToTagSelectSchema>
+>
+
+// create
+export type AdminPositionToTagCreateInput = z.infer<
+  typeof AdminPositionToTagCreateSchema
+>
+
+// update
+export type AdminPositionToTagUpdateParams = z.infer<
+  typeof AdminPositionToTagUpdateParamsSchema
+>
+export type AdminPositionToTagUpdateInput = Partial<AdminPositionToTag>
+
+// delete
+export type AdminPositionToTagDeleteParams = z.infer<
+  typeof AdminPositionToTagDeleteParamsSchema
+>