@voyant-travel/relationships 0.119.2

package/dist/schema-signals.js

@@ -0,0 +1,80 @@
+/**
+ * Customer signals — lighter than `quotes` (no deal value or
+ * stages), heavier than `segments` (lifecycle + assignment). Records
+ * "person X expressed interest in product/departure Y from source Z,
+ * status pending". The most common use cases:
+ *
+ *   - Notify-availability ("ping me when this departure opens up")
+ *   - Wishlist / saved trips
+ *   - Inquiry captured by an operator (phone call, web form)
+ *   - Request-offer pre-pipeline that may or may not become a booking
+ *   - Abandoned-cart recovery
+ *
+ * Cross-module IDs (`productId`, `optionUnitId`, `resolvedBookingId`)
+ * are intentionally plain `text()` columns rather than FK references
+ * — voyant's project-wide rule is that cross-module FKs go through
+ * link tables or stay loose. The signal is owned by CRM; products
+ * and bookings reference its id, not the other way around.
+ */
+import { typeId, typeIdRef } from "@voyant-travel/db/lib/typeid-column";
+import { index, jsonb, pgEnum, pgTable, text, timestamp } from "drizzle-orm/pg-core";
+import { people } from "./schema-accounts.js";
+export const customerSignalKindEnum = pgEnum("customer_signal_kind", [
+    "wishlist",
+    "notify",
+    "inquiry",
+    "request_offer",
+    "referral",
+]);
+export const customerSignalSourceEnum = pgEnum("customer_signal_source", [
+    "form",
+    "phone",
+    "admin",
+    "abandoned_cart",
+    "website",
+    "booking",
+]);
+export const customerSignalStatusEnum = pgEnum("customer_signal_status", [
+    "new",
+    "contacted",
+    "qualified",
+    "converted",
+    "lost",
+    "expired",
+]);
+export const customerSignals = pgTable("customer_signals", {
+    id: typeId("customer_signals"),
+    personId: typeIdRef("person_id")
+        .notNull()
+        .references(() => people.id, { onDelete: "cascade" }),
+    /** Optional reference into `@voyant-travel/inventory`. Plain text — no FK. */
+    productId: text("product_id"),
+    /** Optional reference into a product's `option_units` row (the "departure"-equivalent). Plain text — no FK. */
+    optionUnitId: text("option_unit_id"),
+    kind: customerSignalKindEnum("kind").notNull(),
+    source: customerSignalSourceEnum("source").notNull(),
+    status: customerSignalStatusEnum("status").notNull().default("new"),
+    /**
+     * Free-form priority. The validation layer constrains input to
+     * `low | normal | high | urgent`; storing as text keeps room for
+     * deployment-specific values without a DB migration.
+     */
+    priority: text("priority").notNull().default("normal"),
+    notes: text("notes"),
+    tags: jsonb("tags").$type().notNull().default([]),
+    /** User id (Better Auth user) of the staff member assigned to follow up. */
+    assignedToUserId: text("assigned_to_user_id"),
+    followUpAt: timestamp("follow_up_at", { withTimezone: true }),
+    /** Set when the signal was converted into a real booking. Plain text — cross-module FK. */
+    resolvedBookingId: text("resolved_booking_id"),
+    /** Free-form provenance id (form-submission id, abandoned-cart key, ...). */
+    sourceSubmissionId: text("source_submission_id"),
+    metadata: jsonb("metadata").$type(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_customer_signals_person_status_created").on(table.personId, table.status, table.createdAt),
+    index("idx_customer_signals_assignee_status").on(table.assignedToUserId, table.status),
+    index("idx_customer_signals_kind").on(table.kind),
+    index("idx_customer_signals_resolved_booking").on(table.resolvedBookingId),
+]);

package/dist/schema.d.ts

@@ -0,0 +1,6 @@
+export * from "./schema-accounts.js";
+export * from "./schema-activities.js";
+export * from "./schema-relations.js";
+export * from "./schema-shared.js";
+export * from "./schema-signals.js";
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAA;AACpC,cAAc,wBAAwB,CAAA;AACtC,cAAc,uBAAuB,CAAA;AACrC,cAAc,oBAAoB,CAAA;AAClC,cAAc,qBAAqB,CAAA"}

package/dist/schema.js

@@ -0,0 +1,5 @@
+export * from "./schema-accounts.js";
+export * from "./schema-activities.js";
+export * from "./schema-relations.js";
+export * from "./schema-shared.js";
+export * from "./schema-signals.js";

package/dist/service/accounts-merge.d.ts

@@ -0,0 +1,63 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+export declare class RelationshipsMergeError extends Error {
+    readonly status: 400 | 404;
+    constructor(message: string, status: 400 | 404);
+}
+export declare const accountMergeService: {
+    mergePerson(db: PostgresJsDatabase, keepId: string, mergeId: string): Promise<{
+        id: string;
+        organizationId: string | null;
+        firstName: string;
+        middleName: string | null;
+        lastName: string;
+        gender: string | null;
+        jobTitle: string | null;
+        relation: "other" | "partner" | "supplier" | "client" | null;
+        preferredLanguage: string | null;
+        preferredCurrency: string | null;
+        ownerId: string | null;
+        status: "active" | "inactive" | "archived";
+        source: string | null;
+        sourceRef: string | null;
+        tags: string[];
+        dateOfBirth: string | null;
+        notes: string | null;
+        accessibilityEncrypted: {
+            enc: string;
+        } | null;
+        dietaryEncrypted: {
+            enc: string;
+        } | null;
+        loyaltyEncrypted: {
+            enc: string;
+        } | null;
+        insuranceEncrypted: {
+            enc: string;
+        } | null;
+        createdAt: Date;
+        updatedAt: Date;
+        archivedAt: Date | null;
+    }>;
+    mergeOrganization(db: PostgresJsDatabase, keepId: string, mergeId: string): Promise<{
+        id: string;
+        name: string;
+        legalName: string | null;
+        website: string | null;
+        taxId: string | null;
+        industry: string | null;
+        relation: "other" | "partner" | "supplier" | "client" | null;
+        ownerId: string | null;
+        defaultCurrency: string | null;
+        preferredLanguage: string | null;
+        paymentTerms: number | null;
+        status: "active" | "inactive" | "archived";
+        source: string | null;
+        sourceRef: string | null;
+        tags: string[];
+        notes: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+        archivedAt: Date | null;
+    }>;
+};
+//# sourceMappingURL=accounts-merge.d.ts.map

package/dist/service/accounts-merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accounts-merge.d.ts","sourceRoot":"","sources":["../../src/service/accounts-merge.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAmBjE,qBAAa,uBAAwB,SAAQ,KAAK;IAChD,QAAQ,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,CAAA;gBAEd,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,GAAG;CAK/C;AA+VD,eAAO,MAAM,mBAAmB;oBACR,kBAAkB,UAAU,MAAM,WAAW,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BA2H7C,kBAAkB,UAAU,MAAM,WAAW,MAAM;;;;;;;;;;;;;;;;;;;;;CAiFhF,CAAA"}

package/dist/service/accounts-merge.js

@@ -0,0 +1,382 @@
+// agent-quality: file-size exception -- owner: relationships; existing service module stays co-located until a dedicated split preserves behavior and tests.
+import { identityAddresses, identityContactPoints, identityNamedContacts, } from "@voyant-travel/identity/schema";
+import { and, eq, inArray, ne, or, sql } from "drizzle-orm";
+import { activityLinks, activityParticipants, communicationLog, customerSignals, customFieldValues, organizationNotes, organizations, people, personDocuments, personNotes, personPaymentMethods, personRelationships, segmentMembers, } from "../schema.js";
+import { hydratePeople, organizationEntityType, personEntityType } from "./accounts-shared.js";
+export class RelationshipsMergeError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.name = "RelationshipsMergeError";
+        this.status = status;
+    }
+}
+const OPTIONAL_PERSON_REFERENCES = [
+    { table: "bookings", column: "person_id" },
+    { table: "booking_travelers", column: "person_id" },
+    { table: "booking_staff_assignments", column: "person_id" },
+    { table: "offers", column: "person_id" },
+    { table: "offer_participants", column: "person_id" },
+    { table: "offer_contact_assignments", column: "person_id" },
+    { table: "offer_staff_assignments", column: "person_id" },
+    { table: "orders", column: "person_id" },
+    { table: "order_participants", column: "person_id" },
+    { table: "order_contact_assignments", column: "person_id" },
+    { table: "order_staff_assignments", column: "person_id" },
+    { table: "order_terms", column: "accepted_by" },
+    { table: "invoices", column: "person_id" },
+    { table: "vouchers", column: "issued_to_person_id" },
+    { table: "payment_instruments", column: "person_id" },
+    { table: "payment_sessions", column: "payer_person_id" },
+    { table: "contracts", column: "person_id" },
+    { table: "contract_signatures", column: "person_id" },
+    { table: "policy_acceptances", column: "person_id" },
+    { table: "policy_acceptances", column: "accepted_by" },
+    { table: "notification_deliveries", column: "person_id" },
+    { table: "notification_reminder_runs", column: "person_id" },
+    { table: "quotes", column: "person_id" },
+    { table: "quote_participants", column: "person_id" },
+];
+const OPTIONAL_ORGANIZATION_REFERENCES = [
+    { table: "bookings", column: "organization_id" },
+    { table: "offers", column: "organization_id" },
+    { table: "orders", column: "organization_id" },
+    { table: "invoices", column: "organization_id" },
+    { table: "vouchers", column: "issued_to_organization_id" },
+    { table: "payment_instruments", column: "organization_id" },
+    { table: "payment_sessions", column: "payer_organization_id" },
+    { table: "contracts", column: "organization_id" },
+    { table: "policy_assignments", column: "organization_id" },
+    { table: "notification_deliveries", column: "organization_id" },
+    { table: "notification_reminder_runs", column: "organization_id" },
+    { table: "quotes", column: "organization_id" },
+];
+const OPTIONAL_PERSON_ENTITY_TARGET_REFERENCES = [
+    { table: "notification_deliveries", entityType: "person" },
+];
+const OPTIONAL_ORGANIZATION_ENTITY_TARGET_REFERENCES = [
+    { table: "notification_deliveries", entityType: "organization" },
+];
+function quoteIdentifier(identifier) {
+    return `"${identifier.replaceAll('"', '""')}"`;
+}
+function mergeTags(keepTags, mergeTags) {
+    return [...new Set([...(keepTags ?? []), ...(mergeTags ?? [])])];
+}
+function backfill(keep, merge, keys) {
+    const patch = {};
+    for (const key of keys) {
+        const keepValue = keep[key];
+        const mergeValue = merge[key];
+        if ((keepValue === null || keepValue === undefined || keepValue === "") &&
+            mergeValue !== null &&
+            mergeValue !== undefined &&
+            mergeValue !== "") {
+            patch[key] = mergeValue;
+        }
+    }
+    return patch;
+}
+async function tableHasColumn(db, table, column) {
+    const rows = await db.execute(sql `
+    SELECT EXISTS (
+      SELECT 1
+      FROM information_schema.columns
+      WHERE table_schema = 'public'
+        AND table_name = ${table}
+        AND column_name = ${column}
+    ) AS "exists"
+  `);
+    return Boolean(rows[0]?.exists);
+}
+async function updateOptionalReference(db, reference, keepId, mergeId) {
+    if (!(await tableHasColumn(db, reference.table, reference.column)))
+        return;
+    const hasUpdatedAt = await tableHasColumn(db, reference.table, "updated_at");
+    if (hasUpdatedAt) {
+        await db.execute(sql `
+      UPDATE ${sql.raw(quoteIdentifier(reference.table))}
+      SET ${sql.raw(quoteIdentifier(reference.column))} = ${keepId},
+          updated_at = NOW()
+      WHERE ${sql.raw(quoteIdentifier(reference.column))} = ${mergeId}
+    `);
+        return;
+    }
+    await db.execute(sql `
+      UPDATE ${sql.raw(quoteIdentifier(reference.table))}
+      SET ${sql.raw(quoteIdentifier(reference.column))} = ${keepId}
+      WHERE ${sql.raw(quoteIdentifier(reference.column))} = ${mergeId}
+    `);
+}
+async function updateOptionalReferences(db, references, keepId, mergeId) {
+    for (const reference of references) {
+        await updateOptionalReference(db, reference, keepId, mergeId);
+    }
+}
+async function updateOptionalEntityTargetReference(db, reference, keepId, mergeId) {
+    const hasTargetType = await tableHasColumn(db, reference.table, "target_type");
+    const hasTargetId = await tableHasColumn(db, reference.table, "target_id");
+    if (!hasTargetType || !hasTargetId)
+        return;
+    await db.execute(sql `
+    UPDATE ${sql.raw(quoteIdentifier(reference.table))}
+    SET target_id = ${keepId}
+    WHERE target_type = ${reference.entityType}
+      AND target_id = ${mergeId}
+  `);
+}
+async function updateOptionalEntityTargetReferences(db, references, keepId, mergeId) {
+    for (const reference of references) {
+        await updateOptionalEntityTargetReference(db, reference, keepId, mergeId);
+    }
+}
+async function dedupeOptionalPersonJoinTable(db, reference, keepId, mergeId) {
+    const hasOwner = await tableHasColumn(db, reference.table, reference.ownerColumn);
+    const hasPerson = await tableHasColumn(db, reference.table, reference.personColumn);
+    if (!hasOwner || !hasPerson)
+        return;
+    const table = sql.raw(quoteIdentifier(reference.table));
+    const ownerColumn = sql.raw(quoteIdentifier(reference.ownerColumn));
+    const personColumn = sql.raw(quoteIdentifier(reference.personColumn));
+    await db.execute(sql `
+    DELETE FROM ${table} merge_row
+    WHERE merge_row.${personColumn} = ${mergeId}
+      AND EXISTS (
+        SELECT 1
+        FROM ${table} keep_row
+        WHERE keep_row.${ownerColumn} = merge_row.${ownerColumn}
+          AND keep_row.${personColumn} = ${keepId}
+      )
+  `);
+}
+async function mergeIdentityRows(db, entityType, keepId, mergeId) {
+    await db.delete(identityContactPoints).where(and(eq(identityContactPoints.entityType, entityType), eq(identityContactPoints.entityId, mergeId), sql `EXISTS (
+          SELECT 1
+          FROM identity_contact_points keep_point
+          WHERE keep_point.entity_type = ${entityType}
+            AND keep_point.entity_id = ${keepId}
+            AND keep_point.kind = ${identityContactPoints.kind}
+            AND keep_point.value = ${identityContactPoints.value}
+        )`));
+    await db
+        .update(identityContactPoints)
+        .set({ entityId: keepId, updatedAt: new Date() })
+        .where(and(eq(identityContactPoints.entityType, entityType), eq(identityContactPoints.entityId, mergeId)));
+    await db
+        .update(identityAddresses)
+        .set({ entityId: keepId, updatedAt: new Date() })
+        .where(and(eq(identityAddresses.entityType, entityType), eq(identityAddresses.entityId, mergeId)));
+    await db
+        .update(identityNamedContacts)
+        .set({ entityId: keepId, updatedAt: new Date() })
+        .where(and(eq(identityNamedContacts.entityType, entityType), eq(identityNamedContacts.entityId, mergeId)));
+}
+async function mergeEntityLinks(db, entityType, keepId, mergeId) {
+    await db
+        .update(activityLinks)
+        .set({ entityId: keepId })
+        .where(and(eq(activityLinks.entityType, entityType), eq(activityLinks.entityId, mergeId)));
+    await db.delete(customFieldValues).where(and(eq(customFieldValues.entityType, entityType), eq(customFieldValues.entityId, mergeId), sql `EXISTS (
+          SELECT 1
+          FROM custom_field_values keep_value
+          WHERE keep_value.definition_id = ${customFieldValues.definitionId}
+            AND keep_value.entity_type = ${entityType}
+            AND keep_value.entity_id = ${keepId}
+        )`));
+    await db
+        .update(customFieldValues)
+        .set({ entityId: keepId, updatedAt: new Date() })
+        .where(and(eq(customFieldValues.entityType, entityType), eq(customFieldValues.entityId, mergeId)));
+}
+async function dedupePersonJoinTables(db, keepId, mergeId) {
+    await dedupeOptionalPersonJoinTable(db, { table: "quote_participants", ownerColumn: "quote_id", personColumn: "person_id" }, keepId, mergeId);
+    await db.delete(activityParticipants).where(and(eq(activityParticipants.personId, mergeId), sql `EXISTS (
+          SELECT 1
+          FROM activity_participants keep_participant
+          WHERE keep_participant.activity_id = ${activityParticipants.activityId}
+            AND keep_participant.person_id = ${keepId}
+        )`));
+    await db
+        .delete(personRelationships)
+        .where(or(and(eq(personRelationships.fromPersonId, mergeId), eq(personRelationships.toPersonId, keepId)), and(eq(personRelationships.fromPersonId, keepId), eq(personRelationships.toPersonId, mergeId)), and(eq(personRelationships.fromPersonId, mergeId), eq(personRelationships.toPersonId, mergeId))));
+    await db.delete(personRelationships).where(and(eq(personRelationships.fromPersonId, mergeId), ne(personRelationships.toPersonId, mergeId), sql `EXISTS (
+          SELECT 1
+          FROM person_relationships keep_relationship
+          WHERE keep_relationship.from_person_id = ${keepId}
+            AND keep_relationship.to_person_id = ${personRelationships.toPersonId}
+            AND keep_relationship.kind = ${personRelationships.kind}
+        )`));
+    await db.delete(personRelationships).where(and(eq(personRelationships.toPersonId, mergeId), ne(personRelationships.fromPersonId, mergeId), sql `EXISTS (
+          SELECT 1
+          FROM person_relationships keep_relationship
+          WHERE keep_relationship.from_person_id = ${personRelationships.fromPersonId}
+            AND keep_relationship.to_person_id = ${keepId}
+            AND keep_relationship.kind = ${personRelationships.kind}
+        )`));
+}
+export const accountMergeService = {
+    async mergePerson(db, keepId, mergeId) {
+        if (keepId === mergeId) {
+            throw new RelationshipsMergeError("Cannot merge a person into itself", 400);
+        }
+        return db.transaction(async (tx) => {
+            const [keep, merge] = await tx
+                .select()
+                .from(people)
+                .where(inArray(people.id, [keepId, mergeId]))
+                .for("update");
+            const keepPerson = keep?.id === keepId ? keep : merge?.id === keepId ? merge : null;
+            const mergePerson = keep?.id === mergeId ? keep : merge?.id === mergeId ? merge : null;
+            if (!keepPerson)
+                throw new RelationshipsMergeError("Person to keep not found", 404);
+            if (!mergePerson)
+                throw new RelationshipsMergeError("Person to merge not found", 404);
+            await tx
+                .update(people)
+                .set({
+                ...backfill(keepPerson, mergePerson, [
+                    "organizationId",
+                    "middleName",
+                    "gender",
+                    "jobTitle",
+                    "relation",
+                    "preferredLanguage",
+                    "preferredCurrency",
+                    "ownerId",
+                    "source",
+                    "sourceRef",
+                    "dateOfBirth",
+                    "notes",
+                    "accessibilityEncrypted",
+                    "dietaryEncrypted",
+                    "loyaltyEncrypted",
+                    "insuranceEncrypted",
+                ]),
+                tags: mergeTags(keepPerson.tags, mergePerson.tags),
+                updatedAt: new Date(),
+            })
+                .where(eq(people.id, keepId));
+            await dedupePersonJoinTables(tx, keepId, mergeId);
+            await mergeIdentityRows(tx, personEntityType, keepId, mergeId);
+            await mergeEntityLinks(tx, "person", keepId, mergeId);
+            await tx
+                .update(personNotes)
+                .set({ personId: keepId })
+                .where(eq(personNotes.personId, mergeId));
+            await tx
+                .update(personDocuments)
+                .set({ isPrimary: false, updatedAt: new Date() })
+                .where(and(eq(personDocuments.personId, mergeId), eq(personDocuments.isPrimary, true), sql `EXISTS (
+              SELECT 1
+              FROM person_documents keep_document
+              WHERE keep_document.person_id = ${keepId}
+                AND keep_document.type = ${personDocuments.type}
+                AND keep_document.is_primary = true
+            )`));
+            await tx
+                .update(personDocuments)
+                .set({ personId: keepId, updatedAt: new Date() })
+                .where(eq(personDocuments.personId, mergeId));
+            await tx
+                .update(personPaymentMethods)
+                .set({ personId: keepId })
+                .where(eq(personPaymentMethods.personId, mergeId));
+            await tx
+                .update(communicationLog)
+                .set({ personId: keepId })
+                .where(eq(communicationLog.personId, mergeId));
+            await tx
+                .update(activityParticipants)
+                .set({ personId: keepId })
+                .where(eq(activityParticipants.personId, mergeId));
+            await tx
+                .update(personRelationships)
+                .set({ fromPersonId: keepId, updatedAt: new Date() })
+                .where(eq(personRelationships.fromPersonId, mergeId));
+            await tx
+                .update(personRelationships)
+                .set({ toPersonId: keepId, updatedAt: new Date() })
+                .where(eq(personRelationships.toPersonId, mergeId));
+            await tx
+                .update(segmentMembers)
+                .set({ personId: keepId })
+                .where(eq(segmentMembers.personId, mergeId));
+            await tx
+                .update(customerSignals)
+                .set({ personId: keepId, updatedAt: new Date() })
+                .where(eq(customerSignals.personId, mergeId));
+            await updateOptionalReferences(tx, OPTIONAL_PERSON_REFERENCES, keepId, mergeId);
+            await updateOptionalEntityTargetReferences(tx, OPTIONAL_PERSON_ENTITY_TARGET_REFERENCES, keepId, mergeId);
+            await tx.delete(people).where(eq(people.id, mergeId));
+            const [row] = await tx.select().from(people).where(eq(people.id, keepId)).limit(1);
+            if (!row)
+                throw new Error("Merged person disappeared");
+            const [hydrated] = await hydratePeople(tx, [row]);
+            return hydrated ?? row;
+        });
+    },
+    async mergeOrganization(db, keepId, mergeId) {
+        if (keepId === mergeId) {
+            throw new RelationshipsMergeError("Cannot merge an organization into itself", 400);
+        }
+        return db.transaction(async (tx) => {
+            const [keep, merge] = await tx
+                .select()
+                .from(organizations)
+                .where(inArray(organizations.id, [keepId, mergeId]))
+                .for("update");
+            const keepOrganization = keep?.id === keepId ? keep : merge?.id === keepId ? merge : null;
+            const mergeOrganization = keep?.id === mergeId ? keep : merge?.id === mergeId ? merge : null;
+            if (!keepOrganization)
+                throw new RelationshipsMergeError("Organization to keep not found", 404);
+            if (!mergeOrganization)
+                throw new RelationshipsMergeError("Organization to merge not found", 404);
+            await tx
+                .update(organizations)
+                .set({
+                ...backfill(keepOrganization, mergeOrganization, [
+                    "legalName",
+                    "website",
+                    "taxId",
+                    "industry",
+                    "relation",
+                    "ownerId",
+                    "defaultCurrency",
+                    "preferredLanguage",
+                    "paymentTerms",
+                    "source",
+                    "sourceRef",
+                    "notes",
+                ]),
+                tags: mergeTags(keepOrganization.tags, mergeOrganization.tags),
+                updatedAt: new Date(),
+            })
+                .where(eq(organizations.id, keepId));
+            await mergeIdentityRows(tx, organizationEntityType, keepId, mergeId);
+            await mergeEntityLinks(tx, "organization", keepId, mergeId);
+            await tx
+                .update(people)
+                .set({ organizationId: keepId, updatedAt: new Date() })
+                .where(eq(people.organizationId, mergeId));
+            await tx
+                .update(organizationNotes)
+                .set({ organizationId: keepId })
+                .where(eq(organizationNotes.organizationId, mergeId));
+            await tx
+                .update(communicationLog)
+                .set({ organizationId: keepId })
+                .where(eq(communicationLog.organizationId, mergeId));
+            await updateOptionalReferences(tx, OPTIONAL_ORGANIZATION_REFERENCES, keepId, mergeId);
+            await updateOptionalEntityTargetReferences(tx, OPTIONAL_ORGANIZATION_ENTITY_TARGET_REFERENCES, keepId, mergeId);
+            await tx.delete(organizations).where(eq(organizations.id, mergeId));
+            const [row] = await tx
+                .select()
+                .from(organizations)
+                .where(eq(organizations.id, keepId))
+                .limit(1);
+            if (!row)
+                throw new Error("Merged organization disappeared");
+            return row;
+        });
+    },
+};

package/dist/service/accounts-organizations.d.ts

@@ -0,0 +1,97 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { CreateOrganizationInput, OrganizationListQuery, UpdateOrganizationInput } from "./accounts-shared.js";
+export declare const organizationAccountsService: {
+    listOrganizations(db: PostgresJsDatabase, query: OrganizationListQuery): Promise<{
+        data: {
+            id: string;
+            name: string;
+            legalName: string | null;
+            website: string | null;
+            taxId: string | null;
+            industry: string | null;
+            relation: "other" | "partner" | "supplier" | "client" | null;
+            ownerId: string | null;
+            defaultCurrency: string | null;
+            preferredLanguage: string | null;
+            paymentTerms: number | null;
+            status: "active" | "inactive" | "archived";
+            source: string | null;
+            sourceRef: string | null;
+            tags: string[];
+            notes: string | null;
+            createdAt: Date;
+            updatedAt: Date;
+            archivedAt: Date | null;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getOrganizationById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        name: string;
+        legalName: string | null;
+        website: string | null;
+        taxId: string | null;
+        industry: string | null;
+        relation: "other" | "partner" | "supplier" | "client" | null;
+        ownerId: string | null;
+        defaultCurrency: string | null;
+        preferredLanguage: string | null;
+        paymentTerms: number | null;
+        status: "active" | "inactive" | "archived";
+        source: string | null;
+        sourceRef: string | null;
+        tags: string[];
+        notes: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+        archivedAt: Date | null;
+    } | null>;
+    createOrganization(db: PostgresJsDatabase, data: CreateOrganizationInput): Promise<{
+        name: string;
+        id: string;
+        status: "active" | "inactive" | "archived";
+        createdAt: Date;
+        source: string | null;
+        tags: string[];
+        notes: string | null;
+        updatedAt: Date;
+        website: string | null;
+        legalName: string | null;
+        taxId: string | null;
+        industry: string | null;
+        relation: "other" | "partner" | "supplier" | "client" | null;
+        ownerId: string | null;
+        defaultCurrency: string | null;
+        preferredLanguage: string | null;
+        paymentTerms: number | null;
+        sourceRef: string | null;
+        archivedAt: Date | null;
+    } | undefined>;
+    updateOrganization(db: PostgresJsDatabase, id: string, data: UpdateOrganizationInput): Promise<{
+        id: string;
+        name: string;
+        legalName: string | null;
+        website: string | null;
+        taxId: string | null;
+        industry: string | null;
+        relation: "other" | "partner" | "supplier" | "client" | null;
+        ownerId: string | null;
+        defaultCurrency: string | null;
+        preferredLanguage: string | null;
+        paymentTerms: number | null;
+        status: "active" | "inactive" | "archived";
+        source: string | null;
+        sourceRef: string | null;
+        tags: string[];
+        notes: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+        archivedAt: Date | null;
+    } | null>;
+    deleteOrganization(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+};
+//# sourceMappingURL=accounts-organizations.d.ts.map

package/dist/service/accounts-organizations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accounts-organizations.d.ts","sourceRoot":"","sources":["../../src/service/accounts-organizations.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAGjE,OAAO,KAAK,EACV,uBAAuB,EACvB,qBAAqB,EACrB,uBAAuB,EACxB,MAAM,sBAAsB,CAAA;AAG7B,eAAO,MAAM,2BAA2B;0BACV,kBAAkB,SAAS,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;4BAsD9C,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;2BAK/B,kBAAkB,QAAQ,uBAAuB;;;;;;;;;;;;;;;;;;;;;2BAKjD,kBAAkB,MAAM,MAAM,QAAQ,uBAAuB;;;;;;;;;;;;;;;;;;;;;2BAS7D,kBAAkB,MAAM,MAAM;;;CAO5D,CAAA"}