@kelpie/server 0.9.0 → 0.11.0

package/src/modules/forms/submission.ts

@@ -24,6 +24,8 @@ import '../opportunities/events.ts'
 import * as partnershipRepository from '../partnerships/repository.ts'
 import '../partnerships/events.ts'
 import * as consentPurposesRepository from '../consent-purposes/repository.ts'
+import * as customFieldsRepository from '../custom-fields/repository.ts'
+import { CUSTOM_FIELD_OBJECT_TYPES } from '../custom-fields/schema.ts'
 import '../people/events.ts'
 import { upsertPersonConsent } from '../people/personConsentWrites.ts'
 import * as peopleRepository from '../people/repository.ts'
@@ -33,6 +35,8 @@ import * as pipelineRepository from '../pipelines/repository.ts'
 import '../positions/events.ts'
 import * as positionRepository from '../positions/repository.ts'
 import { targetExists } from '../recordTargets.ts'
+import * as raiseRepository from '../raises/repository.ts'
+import '../raises/events.ts'
 import * as workspaceRepository from '../workspace/repository.ts'
 import './events.ts'
 import {
@@ -42,6 +46,7 @@ import {
   expandNameTemplate,
   expectedCloseFrom,
   fillBlank,
+  fillPhonesBlank,
   findAnswerProblems,
   mapAnswers,
   mergeTags,
@@ -51,6 +56,15 @@ import {
 import type { Answers, ConsentGrant, SubmitIntent } from './mapping.ts'
 import * as repository from './repository.ts'
 import type { FormFieldRecord, FormRecord } from './repository.ts'
+import {
+  applyCompanyMappedFields,
+  applyDealMappedFields,
+  applyEnquiryMappedFields,
+  applyOpportunityMappedFields,
+  applyPartnershipMappedFields,
+  applyPersonMappedFields,
+  applyRaiseMappedFields,
+} from './applySubmissionFields.ts'
 
 /**
  * The public submit: `forms.md` rules 1 to 7, server-side.
@@ -290,6 +304,7 @@ export function createFormSubmitService(dependencies: SubmissionDependencies): F
     const existing = await peopleRepository.findPersonByEmail(tx, workspaceId, intent.email)
 
     if (existing === undefined) {
+      const phones = fillPhonesBlank([], intent.personPhone)
       const created = await peopleRepository.insertPerson(tx, {
         id: dependencies.createId('person'),
         workspaceId,
@@ -298,10 +313,11 @@ export function createFormSubmitService(dependencies: SubmissionDependencies): F
         lastName: intent.personLastName ?? null,
         email: intent.email,
         lastContactedAt: now,
+        ...(phones === undefined ? {} : { phones: [...phones] }),
         ...NEW_PERSON_DEFAULTS,
       })
 
-      return { record: created, created: true, filled: [] }
+      return { record: created, created: true, filled: phones === undefined ? [] : ['phones'] }
     }
 
     // Each part fills its own blank. A stored first name is what the team has
@@ -310,10 +326,12 @@ export function createFormSubmitService(dependencies: SubmissionDependencies): F
     const filledName = fillBlank(existing.name, intent.personName)
     const filledFirstName = fillBlank(existing.firstName, intent.personFirstName)
     const filledLastName = fillBlank(existing.lastName, intent.personLastName)
+    const filledPhones = fillPhonesBlank(existing.phones, intent.personPhone)
     const changes = {
       ...(filledName === undefined ? {} : { name: filledName }),
       ...(filledFirstName === undefined ? {} : { firstName: filledFirstName }),
       ...(filledLastName === undefined ? {} : { lastName: filledLastName }),
+      ...(filledPhones === undefined ? {} : { phones: [...filledPhones] }),
     }
     const updated = await peopleRepository.updatePerson(tx, workspaceId, existing.id, {
       ...changes,
@@ -847,7 +865,15 @@ export function createFormSubmitService(dependencies: SubmissionDependencies): F
       const { workspaceId } = form
       const fields = await repository.listFields(dependencies.db, form.id)
       const intent = readAnswers(fields, answers)
+      const mapped = mapAnswers(fields, answers)
       const consentGrants = readConsentGrants(fields, answers)
+      const customFieldDefinitions = (
+        await Promise.all(
+          CUSTOM_FIELD_OBJECT_TYPES.map((objectType) =>
+            customFieldsRepository.definitionsForObject(dependencies.db, workspaceId, objectType),
+          ),
+        )
+      ).flat()
       const [formListRows, attachTargets, consentPurposesForGrants] = await Promise.all([
         repository.listFormLists(dependencies.db, form.id),
         repository.listAttachTargets(dependencies.db, form.id),
@@ -855,10 +881,36 @@ export function createFormSubmitService(dependencies: SubmissionDependencies): F
       ])
 
       return dependencies.transaction(async ({ tx, events }) => {
+        const now = dependencies.now()
         // Core capture: atomic. A failure here fails the submit; every
         // post-action below runs under its own savepoint and logs.
-        const person = await upsertPerson(tx, workspaceId, intent)
-        const company = await upsertCompany(tx, workspaceId, intent)
+        const personUpserted = await upsertPerson(tx, workspaceId, intent)
+        const personRecord = await applyPersonMappedFields(
+          tx,
+          workspaceId,
+          personUpserted.record,
+          mapped,
+          customFieldDefinitions,
+          now,
+        )
+        const person = { ...personUpserted, record: personRecord }
+
+        const companyUpserted = await upsertCompany(tx, workspaceId, intent)
+        const companyRecord =
+          companyUpserted === undefined
+            ? undefined
+            : await applyCompanyMappedFields(
+                tx,
+                workspaceId,
+                companyUpserted.record,
+                mapped,
+                customFieldDefinitions,
+                now,
+              )
+        const company =
+          companyUpserted === undefined
+            ? undefined
+            : { ...companyUpserted, record: companyRecord ?? companyUpserted.record }
         const position =
           company === undefined || intent.positionTitle === undefined
             ? undefined
@@ -976,6 +1028,66 @@ export function createFormSubmitService(dependencies: SubmissionDependencies): F
             )) ?? null)
           : null
 
+        if (dealId !== null) {
+          const deal = await dealRepository.findDeal(tx, workspaceId, dealId)
+
+          if (deal !== undefined) {
+            await applyDealMappedFields(
+              tx,
+              workspaceId,
+              deal,
+              mapped,
+              customFieldDefinitions,
+              now,
+            )
+          }
+        }
+
+        if (opportunityId !== null) {
+          const opportunity = await opportunityRepository.findOpportunity(tx, workspaceId, opportunityId)
+
+          if (opportunity !== undefined) {
+            await applyOpportunityMappedFields(
+              tx,
+              workspaceId,
+              opportunity,
+              mapped,
+              customFieldDefinitions,
+              now,
+            )
+          }
+        }
+
+        if (partnershipId !== null) {
+          const partnership = await partnershipRepository.findPartnership(tx, workspaceId, partnershipId)
+
+          if (partnership !== undefined) {
+            await applyPartnershipMappedFields(
+              tx,
+              workspaceId,
+              partnership,
+              mapped,
+              customFieldDefinitions,
+              now,
+            )
+          }
+        }
+
+        if (enquiryId !== null) {
+          const enquiry = await enquiryRepository.findEnquiry(tx, workspaceId, enquiryId)
+
+          if (enquiry !== undefined) {
+            await applyEnquiryMappedFields(
+              tx,
+              workspaceId,
+              enquiry,
+              mapped,
+              customFieldDefinitions,
+              now,
+            )
+          }
+        }
+
         // --- Tag merges ---
 
         if (form.personTags.length > 0) {
@@ -1030,30 +1142,8 @@ export function createFormSubmitService(dependencies: SubmissionDependencies): F
 
         // --- List memberships ---
 
-        // Every purpose named by a person list on this form, so consent
-        // capture below needs no per-row round trip.
-        const listConsentPurposeIds = Array.from(
-          new Set(
-            formListRows
-              .map((row) => row.consentPurposeId)
-              .filter((id): id is string => id !== null),
-          ),
-        )
-        const listConsentPurposes =
-          listConsentPurposeIds.length === 0
-            ? new Map<string, { readonly slug: string; readonly label: string }>()
-            : new Map(
-                (
-                  await consentPurposesRepository.listPurposesByIds(
-                    tx,
-                    workspaceId,
-                    listConsentPurposeIds,
-                  )
-                ).map((row) => [row.id, { slug: row.slug, label: row.label }]),
-              )
-
         for (const row of formListRows) {
-          const inserted = await runAction<boolean>(
+          await runAction<boolean>(
             tx,
             events,
             actionLog,
@@ -1096,49 +1186,6 @@ export function createFormSubmitService(dependencies: SubmissionDependencies): F
               return { status: 'ok', detail: targetId, value: true }
             },
           )
-
-          // Consent capture rides with the add — only on person lists, only
-          // when the list carries a purpose, and only when we actually added
-          // (or the person was already on it, since a returning submitter
-          // did the same thing again). A record already on the list has
-          // already been consented for its purpose; the upsert reflects
-          // that a fresh submit is fresh evidence.
-          if (
-            row.targetType === 'person' &&
-            row.consentPurposeId !== null &&
-            inserted !== null
-          ) {
-            const purpose = listConsentPurposes.get(row.consentPurposeId)
-            if (purpose !== undefined) {
-              await runAction<void>(
-                tx,
-                events,
-                actionLog,
-                `consent:${row.listId}`,
-                async (inner) => {
-                  await upsertPersonConsent(
-                    inner,
-                    workspaceId,
-                    person.record.id,
-                    row.consentPurposeId as string,
-                    purpose.slug,
-                    purpose.label,
-                    'granted',
-                    `list:${row.listId}`,
-                    dependencies.now(),
-                  )
-                  await dependencies.recordActivity(inner, workspaceId, FORM_ACTOR, {
-                    targetType: 'person',
-                    targetId: person.record.id,
-                    kind: 'updated',
-                    action: `granted ${purpose.label} consent via ${form.name}`,
-                    detail: `Added to list membership`,
-                  })
-                  return { status: 'ok', detail: purpose.slug }
-                },
-              )
-            }
-          }
         }
 
         // --- Attach the submitter to pre-existing pipeline records ---
@@ -1172,6 +1219,25 @@ export function createFormSubmitService(dependencies: SubmissionDependencies): F
           )
         }
 
+        for (const target of attachTargets) {
+          if (target.targetType !== 'raise') {
+            continue
+          }
+
+          const raise = await raiseRepository.findRaise(tx, workspaceId, target.targetId)
+
+          if (raise !== undefined) {
+            await applyRaiseMappedFields(
+              tx,
+              workspaceId,
+              raise,
+              mapped,
+              customFieldDefinitions,
+              now,
+            )
+          }
+        }
+
         // --- Persist submission + core activity + record events ---
 
         const submission = await repository.insertSubmission(tx, {

package/src/modules/import-export/customFieldCsv.ts

@@ -0,0 +1,55 @@
+import type { CustomFieldValue } from '@kelpie/schemas'
+
+import type { CustomFieldDefinitionRecord } from '../custom-fields/repository.ts'
+import { centsToMoney } from './mapping.ts'
+
+/** Definition keys in workspace sort order — the extra CSV columns on a record export. */
+export function customFieldHeaderKeys(
+  definitions: readonly CustomFieldDefinitionRecord[],
+): readonly string[] {
+  return definitions.map((definition) => definition.key)
+}
+
+/** One custom field value as a single CSV cell. */
+export function serializeCustomFieldValue(value: CustomFieldValue | undefined): string {
+  if (value === undefined) {
+    return ''
+  }
+
+  if (typeof value === 'string' || typeof value === 'number') {
+    return String(value)
+  }
+
+  if (typeof value === 'boolean') {
+    return value ? 'true' : 'false'
+  }
+
+  if (Array.isArray(value)) {
+    return value.join('|')
+  }
+
+  if (typeof value === 'object' && 'amountCents' in value && 'currency' in value) {
+    return `${centsToMoney(value.amountCents)}|${value.currency}`
+  }
+
+  return ''
+}
+
+export function customFieldCells(
+  values: Readonly<Record<string, CustomFieldValue>> | undefined,
+  keys: readonly string[],
+): readonly string[] {
+  return keys.map((key) => serializeCustomFieldValue(values?.[key]))
+}
+
+export function customFieldDefinitionCells(row: CustomFieldDefinitionRecord): readonly string[] {
+  return [
+    row.objectType,
+    row.key,
+    row.label,
+    row.type,
+    row.options.join('|'),
+    row.description,
+    String(row.sortOrder),
+  ]
+}

package/src/modules/import-export/customFieldImport.ts

@@ -0,0 +1,111 @@
+import type { CustomFieldDefinitionRef, CustomFieldObjectType, CustomFieldType, CustomFieldWireValue } from '@kelpie/schemas'
+
+import { parseCustomFieldAnswer } from '../forms/applyMappedFields.ts'
+import type { CustomFieldDefinitionRecord } from '../custom-fields/repository.ts'
+import { moneyToCents } from './mapping.ts'
+
+/**
+ * Custom field columns on a record import: extract, parse, and validate keys.
+ *
+ * Extra CSV columns named by definition key round-trip with export. A blank cell
+ * says nothing about the field, the same additive rule every column follows.
+ */
+
+/** Kelpie columns declared for an object, not including workspace definition keys. */
+export function baseColumnKeySet(objectColumns: readonly { readonly key: string }[]): ReadonlySet<string> {
+  return new Set(objectColumns.map((column) => column.key))
+}
+
+/** Non-base, non-blank cells keyed by custom field definition key. */
+export function extractCustomFieldRaw(
+  mapped: Readonly<Record<string, string>>,
+  baseKeys: ReadonlySet<string>,
+): Readonly<Record<string, string>> {
+  const custom: Record<string, string> = {}
+
+  for (const [key, value] of Object.entries(mapped)) {
+    if (baseKeys.has(key)) {
+      continue
+    }
+
+    if (value.trim().length === 0) {
+      continue
+    }
+
+    custom[key] = value
+  }
+
+  return custom
+}
+
+function parseCurrency(raw: string): CustomFieldWireValue | undefined {
+  const trimmed = raw.trim()
+
+  if (trimmed.length === 0) {
+    return undefined
+  }
+
+  const [amountPart, currencyPart] = trimmed.split('|')
+  const currency = (currencyPart ?? 'USD').trim().toUpperCase()
+
+  if (!/^[A-Z]{3}$/u.test(currency)) {
+    return undefined
+  }
+
+  const cents = moneyToCents(amountPart)
+
+  if (cents === undefined || cents === null) {
+    return undefined
+  }
+
+  return { amount_cents: cents, currency }
+}
+
+/** Parses one inbound custom-field cell into a wire value for the validator. */
+export function parseCustomFieldWireValue(
+  definition: CustomFieldDefinitionRecord,
+  raw: string,
+): CustomFieldWireValue | undefined {
+  if (definition.type === 'currency') {
+    return parseCurrency(raw)
+  }
+
+  const ref: CustomFieldDefinitionRef = {
+    objectType: definition.objectType as CustomFieldObjectType,
+    key: definition.key,
+    label: definition.label,
+    type: definition.type as CustomFieldType,
+  }
+  const parsed = parseCustomFieldAnswer(ref, raw)
+
+  if (typeof parsed === 'string' && parsed.trim().length === 0) {
+    return undefined
+  }
+
+  return parsed as CustomFieldWireValue
+}
+
+/** Builds the wire map to pass to `createCustomFieldValues`. Unknown keys are omitted. */
+export function customFieldWireValues(
+  raw: Readonly<Record<string, string>>,
+  definitions: readonly CustomFieldDefinitionRecord[],
+): Readonly<Record<string, CustomFieldWireValue>> {
+  const byKey = new Map(definitions.map((definition) => [definition.key, definition]))
+  const out: Record<string, CustomFieldWireValue> = {}
+
+  for (const [key, value] of Object.entries(raw)) {
+    const definition = byKey.get(key)
+
+    if (definition === undefined) {
+      continue
+    }
+
+    const parsed = parseCustomFieldWireValue(definition, value)
+
+    if (parsed !== undefined) {
+      out[key] = parsed
+    }
+  }
+
+  return out
+}

package/src/modules/import-export/drafts.ts

@@ -9,6 +9,8 @@ import {
   composeName,
 } from '@kelpie/schemas'
 
+import type { CustomFieldWireValue } from '@kelpie/schemas'
+
 import { normaliseDomain, normaliseEmail } from '../../lib/normalisation.ts'
 import { moneyToCents, splitList } from './mapping.ts'
 import { canonicalEnum } from './validation.ts'
@@ -40,6 +42,7 @@ export interface CompanyDraft {
   readonly icpFit?: string
   readonly summary?: string
   readonly tags?: readonly string[]
+  readonly customFields?: Readonly<Record<string, CustomFieldWireValue>>
 }
 
 export interface PersonDraft {
@@ -57,6 +60,7 @@ export interface PersonDraft {
   readonly relationship?: string
   readonly summary?: string
   readonly tags?: readonly string[]
+  readonly customFields?: Readonly<Record<string, CustomFieldWireValue>>
 }
 
 /** The deal columns a row carries directly. Company, stage, owner and people are resolved. */
@@ -70,6 +74,57 @@ export interface DealFieldsDraft {
   readonly summary?: string
   readonly tags?: readonly string[]
   readonly externalId?: string
+  readonly customFields?: Readonly<Record<string, CustomFieldWireValue>>
+}
+
+export interface OpportunityFieldsDraft {
+  readonly name?: string
+  readonly kind?: string
+  readonly expectedClose?: string
+  readonly summary?: string
+  readonly tags?: readonly string[]
+  readonly customFields?: Readonly<Record<string, CustomFieldWireValue>>
+}
+
+export interface EnquiryFieldsDraft {
+  readonly name?: string
+  readonly source?: string
+  readonly summary?: string
+  readonly tags?: readonly string[]
+  readonly customFields?: Readonly<Record<string, CustomFieldWireValue>>
+}
+
+export interface PartnershipFieldsDraft {
+  readonly name?: string
+  readonly kind?: string
+  readonly nextTouchpoint?: string
+  readonly goals?: string
+  readonly successLooksLike?: string
+  readonly summary?: string
+  readonly tags?: readonly string[]
+  readonly customFields?: Readonly<Record<string, CustomFieldWireValue>>
+}
+
+export interface RaiseFieldsDraft {
+  readonly name?: string
+  readonly checkSizeCents?: number | null
+  readonly currency?: string
+  readonly thesisFit?: string
+  readonly passReason?: string
+  readonly expectedClose?: string
+  readonly summary?: string
+  readonly tags?: readonly string[]
+  readonly customFields?: Readonly<Record<string, CustomFieldWireValue>>
+}
+
+export interface CustomFieldDefinitionDraft {
+  readonly objectType?: string
+  readonly key?: string
+  readonly label?: string
+  readonly type?: string
+  readonly options?: readonly string[]
+  readonly description?: string
+  readonly sortOrder?: number
 }
 
 /**
@@ -143,7 +198,10 @@ function present<T extends object>(draft: Supplied<T>): T {
   return Object.fromEntries(Object.entries(draft).filter(([, value]) => value !== undefined)) as T
 }
 
-export function companyDraft(mapped: Readonly<Record<string, string>>): CompanyDraft {
+export function companyDraft(
+  mapped: Readonly<Record<string, string>>,
+  customFields: Readonly<Record<string, CustomFieldWireValue>> = {},
+): CompanyDraft {
   const domain = text(mapped, 'domain')
 
   return present<CompanyDraft>({
@@ -159,6 +217,7 @@ export function companyDraft(mapped: Readonly<Record<string, string>>): CompanyD
     icpFit: enumeration(mapped, 'icp_fit', ICP_FITS),
     summary: text(mapped, 'summary'),
     tags: list(mapped, 'tags'),
+    customFields: Object.keys(customFields).length === 0 ? undefined : customFields,
   })
 }
 
@@ -168,7 +227,10 @@ export function companyDraft(mapped: Readonly<Record<string, string>>): CompanyD
  * blank, and never the other way round: a `name` cell is never split to fill
  * `first_name`, since a guessed part is stored exactly like one somebody typed.
  */
-export function personDraft(mapped: Readonly<Record<string, string>>): PersonDraft {
+export function personDraft(
+  mapped: Readonly<Record<string, string>>,
+  customFields: Readonly<Record<string, CustomFieldWireValue>> = {},
+): PersonDraft {
   const email = text(mapped, 'email')
   const firstName = text(mapped, 'first_name')
   const lastName = text(mapped, 'last_name')
@@ -190,6 +252,7 @@ export function personDraft(mapped: Readonly<Record<string, string>>): PersonDra
     relationship: enumeration(mapped, 'relationship', RELATIONSHIP_LEVELS),
     summary: text(mapped, 'summary'),
     tags: list(mapped, 'tags'),
+    customFields: Object.keys(customFields).length === 0 ? undefined : customFields,
   })
 }
 
@@ -217,6 +280,7 @@ export function affiliationCompanyDraft(mapped: Readonly<Record<string, string>>
     icpFit: undefined,
     summary: undefined,
     tags: undefined,
+    customFields: undefined,
   })
 }
 
@@ -224,7 +288,10 @@ export function affiliationCompanyDraft(mapped: Readonly<Record<string, string>>
  * `value` is required, so `moneyToCents` has already been checked by
  * `validateRow` and cannot be undefined here.
  */
-export function dealFieldsDraft(mapped: Readonly<Record<string, string>>): DealFieldsDraft {
+export function dealFieldsDraft(
+  mapped: Readonly<Record<string, string>>,
+  customFields: Readonly<Record<string, CustomFieldWireValue>> = {},
+): DealFieldsDraft {
   const cents = moneyToCents(mapped.value)
 
   return present<DealFieldsDraft>({
@@ -237,5 +304,86 @@ export function dealFieldsDraft(mapped: Readonly<Record<string, string>>): DealF
     summary: text(mapped, 'summary'),
     tags: list(mapped, 'tags'),
     externalId: text(mapped, 'external_id'),
+    customFields: Object.keys(customFields).length === 0 ? undefined : customFields,
+  })
+}
+
+export function opportunityFieldsDraft(
+  mapped: Readonly<Record<string, string>>,
+  customFields: Readonly<Record<string, CustomFieldWireValue>> = {},
+): OpportunityFieldsDraft {
+  return present<OpportunityFieldsDraft>({
+    name: text(mapped, 'name'),
+    kind: text(mapped, 'kind'),
+    expectedClose: text(mapped, 'expected_close'),
+    summary: text(mapped, 'summary'),
+    tags: list(mapped, 'tags'),
+    customFields: Object.keys(customFields).length === 0 ? undefined : customFields,
+  })
+}
+
+export function enquiryFieldsDraft(
+  mapped: Readonly<Record<string, string>>,
+  customFields: Readonly<Record<string, CustomFieldWireValue>> = {},
+): EnquiryFieldsDraft {
+  return present<EnquiryFieldsDraft>({
+    name: text(mapped, 'name'),
+    source: text(mapped, 'source'),
+    summary: text(mapped, 'summary'),
+    tags: list(mapped, 'tags'),
+    customFields: Object.keys(customFields).length === 0 ? undefined : customFields,
+  })
+}
+
+export function partnershipFieldsDraft(
+  mapped: Readonly<Record<string, string>>,
+  customFields: Readonly<Record<string, CustomFieldWireValue>> = {},
+): PartnershipFieldsDraft {
+  return present<PartnershipFieldsDraft>({
+    name: text(mapped, 'name'),
+    kind: text(mapped, 'kind'),
+    nextTouchpoint: text(mapped, 'next_touchpoint'),
+    goals: text(mapped, 'goals'),
+    successLooksLike: text(mapped, 'success_looks_like'),
+    summary: text(mapped, 'summary'),
+    tags: list(mapped, 'tags'),
+    customFields: Object.keys(customFields).length === 0 ? undefined : customFields,
+  })
+}
+
+export function raiseFieldsDraft(
+  mapped: Readonly<Record<string, string>>,
+  customFields: Readonly<Record<string, CustomFieldWireValue>> = {},
+): RaiseFieldsDraft {
+  const cents = moneyToCents(mapped.check_size)
+
+  return present<RaiseFieldsDraft>({
+    name: text(mapped, 'name'),
+    checkSizeCents: cents === undefined ? undefined : cents,
+    currency: text(mapped, 'currency'),
+    thesisFit: text(mapped, 'thesis_fit'),
+    passReason: text(mapped, 'pass_reason'),
+    expectedClose: text(mapped, 'expected_close'),
+    summary: text(mapped, 'summary'),
+    tags: list(mapped, 'tags'),
+    customFields: Object.keys(customFields).length === 0 ? undefined : customFields,
+  })
+}
+
+export function customFieldDefinitionDraft(
+  mapped: Readonly<Record<string, string>>,
+): CustomFieldDefinitionDraft {
+  const sortOrderRaw = text(mapped, 'sort_order')
+  const sortOrder =
+    sortOrderRaw === undefined ? undefined : Number.parseInt(sortOrderRaw, 10)
+
+  return present<CustomFieldDefinitionDraft>({
+    objectType: text(mapped, 'object_type'),
+    key: text(mapped, 'key'),
+    label: text(mapped, 'label'),
+    type: text(mapped, 'type'),
+    options: list(mapped, 'options'),
+    description: text(mapped, 'description'),
+    sortOrder: sortOrder !== undefined && Number.isInteger(sortOrder) ? sortOrder : undefined,
   })
 }