@kelpie/server 0.8.0 → 0.10.0

package/dist/modules/forms/submission.js

@@ -1,3 +1,4 @@
+import { UNIQUE_VIOLATION, postgresErrorCode } from '../../lib/database.js';
 import { AppError } from '../../lib/errors.js';
 import { requireCapability } from '../../runtime/entitlements.js';
 import { moduleCapabilityName } from '../../runtime/moduleConfig.js';
@@ -6,14 +7,26 @@ import '../companies/events.js';
 import * as companyRepository from '../companies/repository.js';
 import * as dealRepository from '../deals/repository.js';
 import '../deals/events.js';
+import * as enquiryRepository from '../enquiries/repository.js';
+import '../enquiries/events.js';
+import '../lists/events.js';
+import * as listsRepository from '../lists/repository.js';
+import * as opportunityRepository from '../opportunities/repository.js';
+import '../opportunities/events.js';
+import * as partnershipRepository from '../partnerships/repository.js';
+import '../partnerships/events.js';
+import * as consentPurposesRepository from '../consent-purposes/repository.js';
 import '../people/events.js';
+import { upsertPersonConsent } from '../people/personConsentWrites.js';
 import * as peopleRepository from '../people/repository.js';
+import * as personLinks from '../personLinks.js';
 import * as pipelineRepository from '../pipelines/repository.js';
 import '../positions/events.js';
 import * as positionRepository from '../positions/repository.js';
+import { targetExists } from '../recordTargets.js';
 import * as workspaceRepository from '../workspace/repository.js';
 import './events.js';
-import { DEAL_CLOSE_HORIZON_DAYS, companyNameFrom, describeAnswers, expandDealNameTemplate, expectedCloseFrom, fillBlank, findAnswerProblems, mapAnswers, readIntent, } from './mapping.js';
+import { DEAL_CLOSE_HORIZON_DAYS, companyNameFrom, describeAnswers, expandNameTemplate, expectedCloseFrom, fillBlank, findAnswerProblems, mapAnswers, mergeTags, readConsentGrants, readIntent, } from './mapping.js';
 import * as repository from './repository.js';
 /**
  * The public submit: `forms.md` rules 1 to 7, server-side.
@@ -63,30 +76,24 @@ const NEW_PERSON_DEFAULTS = {
     influence: 'influencer',
 };
 /**
- * One `record.created` per record this submit invented, and one
- * `record.updated` per record it filled a blank on.
+ * One `record.created` per record this submit invented (person, company,
+ * position), and one `record.updated` per record it filled a blank on. The
+ * pipeline creates (deal, opportunity, partnership) publish their own
+ * `*.created` events from inside their action's shim so a rolled-back
+ * savepoint drops the event alongside the row.
  *
- * A submit that matched an existing person and changed nothing about them emits
- * neither: a consumer mirroring the CRM has nothing to mirror, and
+ * A submit that matched an existing person and changed nothing about them
+ * emits neither: a consumer mirroring the CRM has nothing to mirror, and
  * `form.submitted` already says the submission happened.
- *
- * The Deal has no `Upserted` because it is only ever created, and its people
- * link rides along with it rather than as a separate `record.updated`, the same
- * way the deals service treats a create.
  */
 function emitRecordEvents(events, workspaceId, touched) {
-    if (touched.person !== undefined) {
-        emitUpsertEvent(events, 'person', touched.person);
-    }
+    emitUpsertEvent(events, 'person', touched.person);
     if (touched.company !== undefined) {
         emitUpsertEvent(events, 'company', touched.company);
     }
     if (touched.position !== undefined) {
         emitUpsertEvent(events, 'position', touched.position);
     }
-    if (touched.dealId !== null) {
-        events.emit('deals.deal.created', { type: 'deal', id: touched.dealId }, {});
-    }
     // workspaceId is used by the transaction scope's envelope stamping; the
     // parameter stays on the signature so future call sites keep the same shape.
     void workspaceId;
@@ -144,22 +151,34 @@ export function createFormSubmitService(dependencies) {
                 id: dependencies.createId('person'),
                 workspaceId,
                 name: intent.personName,
+                firstName: intent.personFirstName ?? null,
+                lastName: intent.personLastName ?? null,
                 email: intent.email,
                 lastContactedAt: now,
                 ...NEW_PERSON_DEFAULTS,
             });
             return { record: created, created: true, filled: [] };
         }
-        const name = fillBlank(existing.name, intent.personName);
+        // Each part fills its own blank. A stored first name is what the team has
+        // learned and an inbound one is what a visitor typed, so the rule that keeps
+        // an inbound "Alex" off a stored "Alex Rivera" covers these unchanged.
+        const filledName = fillBlank(existing.name, intent.personName);
+        const filledFirstName = fillBlank(existing.firstName, intent.personFirstName);
+        const filledLastName = fillBlank(existing.lastName, intent.personLastName);
+        const changes = {
+            ...(filledName === undefined ? {} : { name: filledName }),
+            ...(filledFirstName === undefined ? {} : { firstName: filledFirstName }),
+            ...(filledLastName === undefined ? {} : { lastName: filledLastName }),
+        };
         const updated = await peopleRepository.updatePerson(tx, workspaceId, existing.id, {
-            ...(name === undefined ? {} : { name }),
+            ...changes,
             lastContactedAt: now,
             updatedAt: now,
         });
         if (updated === undefined) {
             throw new Error(`Person ${existing.id} disappeared during a form submit`);
         }
-        return { record: updated, created: false, filled: name === undefined ? [] : ['name'] };
+        return { record: updated, created: false, filled: Object.keys(changes) };
     }
     /**
      * Upserts the Company, by domain when there is one and by name otherwise
@@ -233,20 +252,57 @@ export function createFormSubmitService(dependencies) {
         });
         return { record: created, created: true, filled: [] };
     }
-    /** The stage a form's deals open in: the one it names, or the pipeline's first open one. */
-    async function openingStageId(tx, workspaceId, form) {
-        if (form.dealStageId !== null) {
-            return form.dealStageId;
+    /**
+     * The stage a form's created record opens in: the one the form names, or
+     * the pipeline's first open stage. Shared by the three create-triggers.
+     */
+    async function openingStageId(tx, workspaceId, kind, configured) {
+        if (configured !== null) {
+            return configured;
         }
-        const stages = await pipelineRepository.listStagesOfKind(tx, workspaceId, 'deal');
+        const stages = await pipelineRepository.listStagesOfKind(tx, workspaceId, kind);
         const first = stages.find((stage) => stage.open) ?? stages[0];
         if (first === undefined) {
             // Unreachable through the API: a workspace seeds its stages at creation
             // and the last stage of a pipeline cannot be removed.
-            throw AppError.conflict('This workspace has no deal stages');
+            throw AppError.conflict(`This workspace has no ${kind} stages`);
         }
         return first.id;
     }
+    /**
+     * Runs `work` under a nested `tx.transaction()` — a SAVEPOINT in
+     * postgres-js — and captures every event the action emits into a local
+     * buffer. On success (`ok` or `skipped`) the events are forwarded to the
+     * real `BufferedEvents`; on throw the savepoint has already rolled back so
+     * the events are discarded and a `{status: 'error'}` entry lands on the log.
+     * Either way the outer transaction stays alive: the next action runs, and
+     * the visitor's 201 survives.
+     */
+    async function runAction(tx, events, log, action, work) {
+        const pending = [];
+        const emit = (name, target, data) => {
+            pending.push({ name, target, data });
+        };
+        try {
+            const result = await tx.transaction(async (inner) => work(inner, emit));
+            log.push({ action, status: result.status, detail: result.detail });
+            for (const event of pending) {
+                // The typed emit rejects an unrelated (name, data) pair; the shim
+                // captured them as one call so the pair is already validated.
+                events.emit(event.name, event.target, event.data);
+            }
+            return result.value;
+        }
+        catch (error) {
+            const detail = error instanceof AppError
+                ? error.message
+                : error instanceof Error
+                    ? error.message
+                    : 'unknown error';
+            log.push({ action, status: 'error', detail });
+            return undefined;
+        }
+    }
     /**
      * Creates the Deal, when the form makes them and a company was resolved.
      *
@@ -254,25 +310,144 @@ export function createFormSubmitService(dependencies) {
      * that resolved none creates no deal and says so through a null `deal_id` on
      * the submission rather than by inventing one.
      */
-    async function createDeal(tx, workspaceId, form, intent, company, personId) {
+    async function createDeal(tx, emit, workspaceId, form, intent, company, personId) {
         const id = dependencies.createId('deal');
         const owner = await workspaceRepository.findDefaultMember(tx, workspaceId);
         await dealRepository.insertDeal(tx, {
             id,
             workspaceId,
             name: intent.dealName ??
-                expandDealNameTemplate(form.dealNameTemplate ?? DEFAULT_DEAL_NAME_TEMPLATE, {
+                expandNameTemplate(form.dealNameTemplate ?? DEFAULT_DEAL_NAME_TEMPLATE, {
                     companyName: company.name,
                     personName: intent.personName,
                 }),
             companyId: company.id,
-            stageId: await openingStageId(tx, workspaceId, form),
+            stageId: await openingStageId(tx, workspaceId, 'deal', form.dealStageId),
             valueCents: 0,
             currency: null,
             ownerId: owner?.id ?? null,
             expectedClose: expectedCloseFrom(dependencies.now(), DEAL_CLOSE_HORIZON_DAYS),
         });
-        await dealRepository.insertDealPeople(tx, id, [personId]);
+        await personLinks.linkPeople(tx, dependencies.createId, workspaceId, { targetType: 'deal', targetId: id }, [personId]);
+        await dependencies.recordActivity(tx, workspaceId, FORM_ACTOR, {
+            targetType: 'deal',
+            targetId: id,
+            kind: 'created',
+            ...describeCreationVia('Deal', form.name),
+        });
+        emit('deals.deal.created', { type: 'deal', id }, {});
+        return id;
+    }
+    /**
+     * Creates the Opportunity, when the form makes them.
+     *
+     * `opportunities.company_id` is nullable, so a submit that resolved no
+     * company still creates the opportunity, with the company link null. The
+     * kind is required at form-write time (see `service.ts`), so it is always
+     * present here.
+     */
+    async function createOpportunity(tx, emit, workspaceId, form, intent, company, personId) {
+        const id = dependencies.createId('opportunity');
+        const owner = form.opportunityOwnerId === null
+            ? await workspaceRepository.findDefaultMember(tx, workspaceId)
+            : { id: form.opportunityOwnerId };
+        await opportunityRepository.insertOpportunity(tx, {
+            id,
+            workspaceId,
+            name: intent.opportunityName ??
+                expandNameTemplate(form.opportunityNameTemplate ?? DEFAULT_DEAL_NAME_TEMPLATE, {
+                    companyName: company?.name ?? '',
+                    personName: intent.personName,
+                }),
+            // requireKindWhenCreating refuses an empty kind at write; the ?? is a
+            // narrowing convenience, not a runtime fallback.
+            kind: form.opportunityKind ?? '',
+            stageId: await openingStageId(tx, workspaceId, 'opportunity', form.opportunityStageId),
+            companyId: company?.id ?? null,
+            ownerId: owner?.id ?? null,
+            expectedClose: expectedCloseFrom(dependencies.now(), DEAL_CLOSE_HORIZON_DAYS),
+        });
+        await personLinks.linkPeople(tx, dependencies.createId, workspaceId, { targetType: 'opportunity', targetId: id }, [personId]);
+        await dependencies.recordActivity(tx, workspaceId, FORM_ACTOR, {
+            targetType: 'opportunity',
+            targetId: id,
+            kind: 'created',
+            ...describeCreationVia('Opportunity', form.name),
+        });
+        emit('opportunities.opportunity.created', { type: 'opportunity', id }, {});
+        return id;
+    }
+    /**
+     * Creates the Partnership, when the form makes them and a company was
+     * resolved. `partnerships.company_id` is `NOT NULL`, matching Deal.
+     */
+    async function createPartnership(tx, emit, workspaceId, form, intent, company, personId) {
+        const id = dependencies.createId('partnership');
+        const owner = form.partnershipOwnerId === null
+            ? await workspaceRepository.findDefaultMember(tx, workspaceId)
+            : { id: form.partnershipOwnerId };
+        const nextTouchpoint = expectedCloseFrom(dependencies.now(), DEAL_CLOSE_HORIZON_DAYS);
+        await partnershipRepository.insertPartnership(tx, {
+            id,
+            workspaceId,
+            name: intent.partnershipName ??
+                expandNameTemplate(form.partnershipNameTemplate ?? DEFAULT_DEAL_NAME_TEMPLATE, {
+                    companyName: company.name,
+                    personName: intent.personName,
+                }),
+            companyId: company.id,
+            stageId: await openingStageId(tx, workspaceId, 'partnership', form.partnershipStageId),
+            kind: form.partnershipKind ?? '',
+            nextTouchpoint,
+            ownerId: owner?.id ?? null,
+            goals: '',
+            successLooksLike: '',
+        });
+        await personLinks.linkPeople(tx, dependencies.createId, workspaceId, { targetType: 'partnership', targetId: id }, [personId]);
+        await dependencies.recordActivity(tx, workspaceId, FORM_ACTOR, {
+            targetType: 'partnership',
+            targetId: id,
+            kind: 'created',
+            ...describeCreationVia('Partnership', form.name),
+        });
+        emit('partnerships.partnership.created', { type: 'partnership', id }, {});
+        return id;
+    }
+    /**
+     * Creates the Enquiry, when the form makes them.
+     *
+     * `enquiries.company_id` is nullable, so a submit that resolved no company
+     * still creates the enquiry. Enquiries have no `kind`; the form's optional
+     * `enquirySource` is written to the enquiry's `source` column, or empty when
+     * unset — an unclassified source reads as unclassified.
+     */
+    async function createEnquiry(tx, emit, workspaceId, form, intent, company, personId) {
+        const id = dependencies.createId('enquiry');
+        const owner = form.enquiryOwnerId === null
+            ? await workspaceRepository.findDefaultMember(tx, workspaceId)
+            : { id: form.enquiryOwnerId };
+        await enquiryRepository.insertEnquiry(tx, {
+            id,
+            workspaceId,
+            name: intent.enquiryName ??
+                expandNameTemplate(form.enquiryNameTemplate ?? DEFAULT_DEAL_NAME_TEMPLATE, {
+                    companyName: company?.name ?? '',
+                    personName: intent.personName,
+                }),
+            source: form.enquirySource ?? '',
+            stageId: await openingStageId(tx, workspaceId, 'enquiry', form.enquiryStageId),
+            companyId: company?.id ?? null,
+            ownerId: owner?.id ?? null,
+            convertedDealId: null,
+        });
+        await personLinks.linkPeople(tx, dependencies.createId, workspaceId, { targetType: 'enquiry', targetId: id }, [personId]);
+        await dependencies.recordActivity(tx, workspaceId, FORM_ACTOR, {
+            targetType: 'enquiry',
+            targetId: id,
+            kind: 'created',
+            ...describeCreationVia('Enquiry', form.name),
+        });
+        emit('enquiries.enquiry.created', { type: 'enquiry', id }, {});
         return id;
     }
     /**
@@ -310,21 +485,217 @@ export function createFormSubmitService(dependencies) {
         }
         return intent;
     }
+    /**
+     * The purposes any grants name, keyed by id, so the submit transaction
+     * knows the slug and label without a per-grant round trip.
+     */
+    async function loadPurposesForGrants(db, workspaceId, grants) {
+        if (grants.length === 0)
+            return new Map();
+        const ids = Array.from(new Set(grants.map((grant) => grant.purposeId)));
+        const rows = await consentPurposesRepository.listPurposesByIds(db, workspaceId, ids);
+        return new Map(rows.map((row) => [row.id, { slug: row.slug, label: row.label }]));
+    }
+    /**
+     * Writes each ticked grant as a `person_consents` row and appends an
+     * Activity to the person carrying the verbatim statement. A grant whose
+     * purpose has since been removed is silently skipped — the form's own
+     * consent field would have been left dangling anyway, and the submit
+     * cannot know that from the answer alone.
+     */
+    async function applyFormConsentGrants(tx, workspaceId, formId, formName, personId, grants, purposes, deps) {
+        if (grants.length === 0)
+            return;
+        const now = deps.now();
+        const source = `form:${formId}`;
+        for (const grant of grants) {
+            const purpose = purposes.get(grant.purposeId);
+            if (purpose === undefined)
+                continue;
+            await upsertPersonConsent(tx, workspaceId, personId, grant.purposeId, purpose.slug, purpose.label, 'granted', source, now);
+            // The exact text the visitor ticked — the field's per-purpose override
+            // when set, else the workspace purpose's label. Recorded as the
+            // Activity detail so the timeline shows what they actually saw.
+            const ticked = grant.customLabel.length > 0 ? grant.customLabel : purpose.label;
+            const detail = grant.statement.length > 0 ? `${grant.statement} — ${ticked}` : ticked;
+            await deps.recordActivity(tx, workspaceId, FORM_ACTOR, {
+                targetType: 'person',
+                targetId: personId,
+                kind: 'updated',
+                action: `granted ${purpose.label} consent via ${formName}`,
+                detail,
+            });
+        }
+    }
     return {
         async submit(publicKey, answers) {
             const form = await requireOpenForm(publicKey);
             const { workspaceId } = form;
             const fields = await repository.listFields(dependencies.db, form.id);
             const intent = readAnswers(fields, answers);
+            const consentGrants = readConsentGrants(fields, answers);
+            const [formListRows, attachTargets, consentPurposesForGrants] = await Promise.all([
+                repository.listFormLists(dependencies.db, form.id),
+                repository.listAttachTargets(dependencies.db, form.id),
+                loadPurposesForGrants(dependencies.db, workspaceId, consentGrants),
+            ]);
             return dependencies.transaction(async ({ tx, events }) => {
+                // 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 position = company === undefined || intent.positionTitle === undefined
                     ? undefined
                     : await upsertPosition(tx, workspaceId, person.record.id, company.record.id, intent.positionTitle);
-                const dealId = form.createDeal && company !== undefined
-                    ? await createDeal(tx, workspaceId, form, intent, company.record, person.record.id)
+                // Consent grants (from ticked `consent` fields) are core capture, not
+                // post-actions: they commit with the person, and an Activity records
+                // the exact statement text as it was shown to the visitor.
+                await applyFormConsentGrants(tx, workspaceId, form.id, form.name, person.record.id, consentGrants, consentPurposesForGrants, dependencies);
+                const actionLog = [];
+                // --- Create triggers ---
+                const dealId = form.createDeal
+                    ? ((await runAction(tx, events, actionLog, 'create_deal', async (inner, emit) => {
+                        if (company === undefined) {
+                            return { status: 'skipped', detail: 'no company resolved' };
+                        }
+                        const id = await createDeal(inner, emit, workspaceId, form, intent, company.record, person.record.id);
+                        return { status: 'ok', detail: id, value: id };
+                    })) ?? null)
+                    : null;
+                const opportunityId = form.createOpportunity
+                    ? ((await runAction(tx, events, actionLog, 'create_opportunity', async (inner, emit) => {
+                        const id = await createOpportunity(inner, emit, workspaceId, form, intent, company?.record, person.record.id);
+                        return { status: 'ok', detail: id, value: id };
+                    })) ?? null)
                     : null;
+                const partnershipId = form.createPartnership
+                    ? ((await runAction(tx, events, actionLog, 'create_partnership', async (inner, emit) => {
+                        if (company === undefined) {
+                            return { status: 'skipped', detail: 'no company resolved' };
+                        }
+                        const id = await createPartnership(inner, emit, workspaceId, form, intent, company.record, person.record.id);
+                        return { status: 'ok', detail: id, value: id };
+                    })) ?? null)
+                    : null;
+                const enquiryId = form.createEnquiry
+                    ? ((await runAction(tx, events, actionLog, 'create_enquiry', async (inner, emit) => {
+                        const id = await createEnquiry(inner, emit, workspaceId, form, intent, company?.record, person.record.id);
+                        return { status: 'ok', detail: id, value: id };
+                    })) ?? null)
+                    : null;
+                // --- Tag merges ---
+                if (form.personTags.length > 0) {
+                    await runAction(tx, events, actionLog, 'tag_person', async (inner, emit) => {
+                        const merged = mergeTags(person.record.tags, form.personTags);
+                        if (!merged.changed) {
+                            return { status: 'ok', detail: 'no new tags' };
+                        }
+                        const now = dependencies.now();
+                        await peopleRepository.updatePerson(inner, workspaceId, person.record.id, {
+                            tags: [...merged.next],
+                            updatedAt: now,
+                        });
+                        emit('people.person.updated', { type: 'person', id: person.record.id }, { changed: ['tags'] });
+                        return { status: 'ok', detail: `merged ${String(merged.next.length - person.record.tags.length)}` };
+                    });
+                }
+                if (form.companyTags.length > 0) {
+                    await runAction(tx, events, actionLog, 'tag_company', async (inner, emit) => {
+                        if (company === undefined) {
+                            return { status: 'skipped', detail: 'no company resolved' };
+                        }
+                        const merged = mergeTags(company.record.tags, form.companyTags);
+                        if (!merged.changed) {
+                            return { status: 'ok', detail: 'no new tags' };
+                        }
+                        const now = dependencies.now();
+                        await companyRepository.updateCompany(inner, workspaceId, company.record.id, {
+                            tags: [...merged.next],
+                            updatedAt: now,
+                        });
+                        emit('companies.company.updated', { type: 'company', id: company.record.id }, { changed: ['tags'] });
+                        return { status: 'ok', detail: `merged ${String(merged.next.length - company.record.tags.length)}` };
+                    });
+                }
+                // --- 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 !== null)));
+                const listConsentPurposes = listConsentPurposeIds.length === 0
+                    ? new Map()
+                    : 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(tx, events, actionLog, `add_list:${row.listId}`, async (inner, emit) => {
+                        const targetId = row.targetType === 'person'
+                            ? person.record.id
+                            : row.targetType === 'company' && company !== undefined
+                                ? company.record.id
+                                : undefined;
+                        if (targetId === undefined) {
+                            return { status: 'skipped', detail: 'no company resolved', value: false };
+                        }
+                        try {
+                            await listsRepository.insertListMember(inner, {
+                                id: dependencies.createId('listMember'),
+                                workspaceId,
+                                listId: row.listId,
+                                targetType: row.targetType,
+                                targetId,
+                                addedAt: dependencies.now(),
+                            });
+                        }
+                        catch (error) {
+                            if (postgresErrorCode(error) === UNIQUE_VIOLATION) {
+                                return { status: 'ok', detail: 'already a member', value: false };
+                            }
+                            throw error;
+                        }
+                        emit('lists.member.added', { type: row.targetType, id: targetId }, { listId: row.listId });
+                        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(tx, events, actionLog, `consent:${row.listId}`, async (inner) => {
+                                await upsertPersonConsent(inner, workspaceId, person.record.id, row.consentPurposeId, 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 ---
+                for (const target of attachTargets) {
+                    await runAction(tx, events, actionLog, `attach:${target.targetType}:${target.targetId}`, async (inner) => {
+                        // Racing a target delete would fail the FK-less insert with the
+                        // same effect as an existence check: log an error, continue.
+                        if (!(await targetExists(inner, workspaceId, target.targetType, target.targetId))) {
+                            throw AppError.notFound(`${target.targetType} ${target.targetId} not found`);
+                        }
+                        const inserted = await personLinks.linkPersonIfAbsent(inner, dependencies.createId, workspaceId, target, person.record.id);
+                        return {
+                            status: 'ok',
+                            detail: inserted ? 'linked' : 'already linked',
+                        };
+                    });
+                }
+                // --- Persist submission + core activity + record events ---
                 const submission = await repository.insertSubmission(tx, {
                     id: dependencies.createId('formSubmission'),
                     workspaceId,
@@ -334,7 +705,11 @@ export function createFormSubmitService(dependencies) {
                     companyId: company?.record.id ?? null,
                     positionId: position?.record.id ?? null,
                     dealId,
+                    opportunityId,
+                    partnershipId,
+                    enquiryId,
                     submittedAt: dependencies.now(),
+                    actionLog,
                 });
                 await dependencies.recordActivity(tx, workspaceId, FORM_ACTOR, {
                     targetType: 'person',
@@ -342,16 +717,15 @@ export function createFormSubmitService(dependencies) {
                     kind: 'created',
                     ...describeFormSubmission(form.name, describeAnswers(fields, answers)),
                 });
-                if (dealId !== null) {
-                    await dependencies.recordActivity(tx, workspaceId, FORM_ACTOR, {
-                        targetType: 'deal',
-                        targetId: dealId,
-                        kind: 'created',
-                        ...describeCreationVia('Deal', form.name),
-                    });
-                }
-                emitRecordEvents(events, workspaceId, { person, company, position, dealId });
-                events.emit('forms.submission.submitted', { type: 'submission', id: submission.id }, { formId: form.id, submissionId: submission.id });
+                emitRecordEvents(events, workspaceId, { person, company, position });
+                events.emit('forms.submission.submitted', { type: 'submission', id: submission.id }, {
+                    formId: form.id,
+                    submissionId: submission.id,
+                    opportunityId,
+                    partnershipId,
+                    enquiryId,
+                    actions: actionLog.map((entry) => ({ action: entry.action, status: entry.status })),
+                });
                 return {
                     submissionId: submission.id,
                     formId: form.id,
@@ -359,8 +733,12 @@ export function createFormSubmitService(dependencies) {
                     companyId: company?.record.id ?? null,
                     positionId: position?.record.id ?? null,
                     dealId,
+                    opportunityId,
+                    partnershipId,
+                    enquiryId,
                     submittedAt: submission.submittedAt,
                     thankYouMessage: form.thankYouMessage,
+                    actionLog,
                 };
             }, { workspaceId });
         },