@kelpie/server 0.9.0 → 0.11.0

package/src/modules/consent-purposes/service.ts

@@ -20,7 +20,6 @@ import type { Transaction, TransactionScope } from '../../runtime/transaction.ts
 import type { Actor } from '../auth/actor.ts'
 import { requireWorkspaceId } from '../auth/actor.ts'
 import { formFields } from '../forms/schema.ts'
-import { lists } from '../lists/schema.ts'
 import { roleAllows } from '../workspace/roles.ts'
 import { CONSENT_PURPOSES_LIMIT } from './capabilities.ts'
 import './events.ts'
@@ -39,7 +38,7 @@ import type {
  *
  * Reads are open to any workspace member — every capture site needs to list
  * them to render its purpose picker. Writes need the admin role: a purpose
- * change touches every form, list, and import job that names it, and it is
+ * change touches every form and import job that names it, and it is
  * team-wide config rather than a per-user preference.
  */
 
@@ -143,17 +142,16 @@ function validateDefaultStatus(status: string): void {
 }
 
 /**
- * A purpose still named by a form's consent field or a list's
- * `consent_purpose_id` cannot be deleted. Counted here so the 409 lists both
- * types; the FK on either side would refuse the delete on its own but only
- * name one.
+ * A purpose still named by a form's consent field cannot be deleted. Counted
+ * here so the 409 names the referencing type; the FK on either side would
+ * refuse the delete on its own but only name one.
  */
 async function referencingTypes(
   db: Database | Transaction,
   workspaceId: string,
   id: string,
 ): Promise<readonly string[]> {
-  const [fieldRow, listRow] = await Promise.all([
+  const [fieldRow] = await Promise.all([
     db
       .select({ count: sql<number>`count(*)::int` })
       .from(formFields)
@@ -165,19 +163,12 @@ async function referencingTypes(
           sql`${id} = ANY(${formFields.consentPurposeIds})`,
         ),
       ),
-    db
-      .select({ count: sql<number>`count(*)::int` })
-      .from(lists)
-      .where(and(eq(lists.workspaceId, workspaceId), eq(lists.consentPurposeId, id))),
   ])
 
   const referencing: string[] = []
   if (Number(fieldRow[0]?.count ?? 0) > 0) {
     referencing.push('form_field')
   }
-  if (Number(listRow[0]?.count ?? 0) > 0) {
-    referencing.push('list')
-  }
   return referencing
 }
 
@@ -390,7 +381,7 @@ export function createConsentPurposesService(
           const referencing = await referencingTypes(tx, workspaceId, id)
           if (referencing.length > 0) {
             throw AppError.conflict(
-              'Remove this purpose from every form and list that names it before deleting it',
+              'Remove this purpose from every form field that names it before deleting it',
               referencing.map((type) => ({ field: type, message: 'still references this purpose' })),
             )
           }
@@ -400,7 +391,7 @@ export function createConsentPurposesService(
           } catch (error: unknown) {
             if (postgresErrorCode(error) === FOREIGN_KEY_VIOLATION) {
               throw AppError.conflict(
-                'Remove this purpose from every form and list that names it before deleting it',
+                'Remove this purpose from every form field that names it before deleting it',
                 [{ field: 'id', message: 'still referenced' }],
               )
             }

package/src/modules/consent-purposes/starters.ts

@@ -5,7 +5,7 @@ import type { ConsentPurposeStatus } from '@kelpie/schemas'
  * owner may rename, reorder, or delete them, and add any others they need.
  *
  * Both starters default to `unknown` — silence about a person's wishes is not
- * a grant, and every capture site (forms, lists, imports, manual override)
+ * a grant, and every capture site (forms, imports, manual override)
  * writes an explicit `person_consents` row when consent is actually given.
  */
 

package/src/modules/consent-purposes/tools.ts

@@ -31,7 +31,7 @@ export function registerConsentPurposesTools(
     subject: 'consent purpose',
     about:
       'A workspace-defined consent purpose. Read these before writing a person ' +
-      'consent or setting a form/list/import purpose_id.',
+      'consent or setting a form/import purpose_id.',
     service,
     render: consentPurposeResponse,
     listArgs,

package/src/modules/conversions/clearPointers.ts

@@ -0,0 +1,81 @@
+import { and, eq } from 'drizzle-orm'
+import type { PipelineKind } from '@kelpie/schemas'
+
+import type { Queryable } from '../../runtime/transaction.ts'
+import { deals } from '../deals/schema.ts'
+import { enquiries } from '../enquiries/schema.ts'
+import { opportunities } from '../opportunities/schema.ts'
+import { partnerships } from '../partnerships/schema.ts'
+import { raises } from '../raises/schema.ts'
+
+/**
+ * Clears `converted_target_*` on every pipeline record that pointed at a target
+ * being deleted. Enquiries also lose `converted_deal_id` when the target is a
+ * deal, matching the legacy FK `on delete set null` behaviour and allowing a
+ * fresh conversion once the created record is gone.
+ */
+export async function clearConversionPointersToTarget(
+  tx: Queryable,
+  workspaceId: string,
+  targetKind: PipelineKind,
+  targetId: string,
+): Promise<void> {
+  const match = and(
+    eq(deals.workspaceId, workspaceId),
+    eq(deals.convertedTargetType, targetKind),
+    eq(deals.convertedTargetId, targetId),
+  )
+
+  await tx
+    .update(enquiries)
+    .set({
+      convertedTargetType: null,
+      convertedTargetId: null,
+      ...(targetKind === 'deal' ? { convertedDealId: null } : {}),
+    })
+    .where(
+      and(
+        eq(enquiries.workspaceId, workspaceId),
+        eq(enquiries.convertedTargetType, targetKind),
+        eq(enquiries.convertedTargetId, targetId),
+      ),
+    )
+
+  await tx
+    .update(deals)
+    .set({ convertedTargetType: null, convertedTargetId: null })
+    .where(match)
+
+  await tx
+    .update(opportunities)
+    .set({ convertedTargetType: null, convertedTargetId: null })
+    .where(
+      and(
+        eq(opportunities.workspaceId, workspaceId),
+        eq(opportunities.convertedTargetType, targetKind),
+        eq(opportunities.convertedTargetId, targetId),
+      ),
+    )
+
+  await tx
+    .update(raises)
+    .set({ convertedTargetType: null, convertedTargetId: null })
+    .where(
+      and(
+        eq(raises.workspaceId, workspaceId),
+        eq(raises.convertedTargetType, targetKind),
+        eq(raises.convertedTargetId, targetId),
+      ),
+    )
+
+  await tx
+    .update(partnerships)
+    .set({ convertedTargetType: null, convertedTargetId: null })
+    .where(
+      and(
+        eq(partnerships.workspaceId, workspaceId),
+        eq(partnerships.convertedTargetType, targetKind),
+        eq(partnerships.convertedTargetId, targetId),
+      ),
+    )
+}

package/src/modules/conversions/factory.ts

@@ -0,0 +1,20 @@
+import type { ModuleContext } from '../../runtime/module.ts'
+import { createActivityRecorder } from '../activities/index.ts'
+import { createCustomFieldValues } from '../custom-fields/index.ts'
+import { createConversionsService } from './service.ts'
+import type { ConversionsService } from './service.ts'
+
+/** Build the shared conversion service from a module registration context. */
+export function createConversionsFromContext(context: ModuleContext): ConversionsService {
+  return createConversionsService({
+    db: context.db,
+    transaction: context.transaction,
+    createId: context.createId,
+    now: context.now,
+    recordActivity: createActivityRecorder({
+      createId: context.createId,
+      now: context.now,
+    }),
+    customFields: createCustomFieldValues({ db: context.db }),
+  })
+}