@voyant-travel/relationships 0.119.2

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

@@ -0,0 +1 @@
+{"version":3,"file":"accounts-people.d.ts","sourceRoot":"","sources":["../../src/service/accounts-people.ts"],"names":[],"mappings":"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"}

package/dist/service/accounts-people.js

@@ -0,0 +1,409 @@
+// agent-quality: file-size exception -- owner: crm; existing service module stays co-located until a dedicated split preserves behavior and tests.
+import { identityContactPoints } from "@voyant-travel/identity/schema";
+import { identityService } from "@voyant-travel/identity/service";
+import { toCsvRow } from "@voyant-travel/utils";
+import { and, asc, desc, eq, exists, gte, ilike, lte, or, sql } from "drizzle-orm";
+import { communicationLog, organizationNotes, organizations, people, personNotes, personPaymentMethods, segments, } from "../schema.js";
+import { deletePersonIdentity, hydratePeople, organizationEntityType, personBaseFields, personEntityType, syncPersonIdentity, } from "./accounts-shared.js";
+import { paginate } from "./helpers.js";
+function unaccentedIlike(column, term) {
+    // agent-quality: raw-sql reviewed -- owner: crm; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+    return sql `unaccent(coalesce(${column}, '')) ILIKE unaccent(${term})`;
+}
+function buildPersonSearchCondition(db, search) {
+    const trimmedSearch = search.trim();
+    if (!trimmedSearch)
+        return undefined;
+    const term = `%${trimmedSearch}%`;
+    const tokens = trimmedSearch.split(/\s+/).filter(Boolean);
+    const digits = trimmedSearch.replace(/\D/g, "");
+    const searchablePersonColumns = [
+        people.firstName,
+        people.middleName,
+        people.lastName,
+        people.jobTitle,
+    ];
+    const contactPointConditions = [
+        ilike(identityContactPoints.value, term),
+        ilike(identityContactPoints.normalizedValue, term),
+    ];
+    if (digits) {
+        const digitsTerm = `%${digits}%`;
+        contactPointConditions.push(
+        // agent-quality: raw-sql reviewed -- owner: crm; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+        sql `regexp_replace(${identityContactPoints.value}, '[^0-9]+', '', 'g') ILIKE ${digitsTerm}`, 
+        // agent-quality: raw-sql reviewed -- owner: crm; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+        sql `regexp_replace(coalesce(${identityContactPoints.normalizedValue}, ''), '[^0-9]+', '', 'g') ILIKE ${digitsTerm}`);
+    }
+    const tokenizedPersonCondition = tokens.length
+        ? and(...tokens.map((token) => or(...searchablePersonColumns.map((column) => unaccentedIlike(column, `%${token}%`)))))
+        : undefined;
+    return or(tokenizedPersonCondition, exists(db
+        .select({ one: sql `1` })
+        .from(identityContactPoints)
+        .where(and(eq(identityContactPoints.entityType, personEntityType), eq(identityContactPoints.entityId, people.id), or(eq(identityContactPoints.kind, "email"), eq(identityContactPoints.kind, "phone")), or(...contactPointConditions)))));
+}
+export const peopleAccountsService = {
+    async listPeople(db, query) {
+        const conditions = [];
+        if (query.organizationId)
+            conditions.push(eq(people.organizationId, query.organizationId));
+        if (query.ownerId)
+            conditions.push(eq(people.ownerId, query.ownerId));
+        if (query.relation)
+            conditions.push(eq(people.relation, query.relation));
+        if (query.status)
+            conditions.push(eq(people.status, query.status));
+        if (query.search) {
+            const searchCondition = buildPersonSearchCondition(db, query.search);
+            if (searchCondition)
+                conditions.push(searchCondition);
+        }
+        const where = conditions.length ? and(...conditions) : undefined;
+        const sortColumns = (() => {
+            switch (query.sortBy) {
+                case "name":
+                    return [people.firstName, people.lastName];
+                case "relation":
+                    return [people.relation];
+                case "status":
+                    return [people.status];
+                case "createdAt":
+                    return [people.createdAt];
+                default:
+                    return [people.updatedAt];
+            }
+        })();
+        const sortFn = query.sortDir === "asc" ? asc : desc;
+        const orderBy = [...sortColumns.map((col) => sortFn(col)), desc(people.updatedAt)];
+        const result = await paginate(db
+            .select()
+            .from(people)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(...orderBy), db.select({ count: sql `count(*)::int` }).from(people).where(where), query.limit, query.offset);
+        return {
+            ...result,
+            data: await hydratePeople(db, result.data, { fallbackOnError: true }),
+        };
+    },
+    async getPersonById(db, id) {
+        const [row] = await db.select().from(people).where(eq(people.id, id)).limit(1);
+        if (!row)
+            return null;
+        const [hydrated] = await hydratePeople(db, [row]);
+        return hydrated ?? null;
+    },
+    async createPerson(db, data) {
+        const [row] = await db
+            .insert(people)
+            .values({
+            ...personBaseFields(data),
+            firstName: data.firstName,
+            lastName: data.lastName,
+        })
+            .returning();
+        if (!row) {
+            throw new Error("Failed to create person");
+        }
+        await syncPersonIdentity(db, row.id, data);
+        return this.getPersonById(db, row.id);
+    },
+    async updatePerson(db, id, data) {
+        const existing = await this.getPersonById(db, id);
+        if (!existing)
+            return null;
+        await db
+            .update(people)
+            .set({ ...personBaseFields(data), updatedAt: new Date() })
+            .where(eq(people.id, id));
+        await syncPersonIdentity(db, id, {
+            email: data.email === undefined ? existing.email : data.email,
+            phone: data.phone === undefined ? existing.phone : data.phone,
+            website: data.website === undefined ? existing.website : data.website,
+        });
+        return this.getPersonById(db, id);
+    },
+    async deletePerson(db, id) {
+        await deletePersonIdentity(db, id);
+        const [row] = await db.delete(people).where(eq(people.id, id)).returning({ id: people.id });
+        return row ?? null;
+    },
+    listContactMethods(db, entityType, entityId) {
+        return identityService.listContactPointsForEntity(db, entityType === "organization" ? organizationEntityType : personEntityType, entityId);
+    },
+    async createContactMethod(db, entityType, entityId, data) {
+        return identityService.createContactPoint(db, {
+            ...data,
+            entityType: entityType === "organization" ? organizationEntityType : personEntityType,
+            entityId,
+        });
+    },
+    async updateContactMethod(db, id, data) {
+        return identityService.updateContactPoint(db, id, data);
+    },
+    async deleteContactMethod(db, id) {
+        return identityService.deleteContactPoint(db, id);
+    },
+    listAddresses(db, entityType, entityId) {
+        return identityService.listAddressesForEntity(db, entityType === "organization" ? organizationEntityType : personEntityType, entityId);
+    },
+    async createAddress(db, entityType, entityId, data) {
+        return identityService.createAddress(db, {
+            ...data,
+            entityType: entityType === "organization" ? organizationEntityType : personEntityType,
+            entityId,
+        });
+    },
+    async updateAddress(db, id, data) {
+        return identityService.updateAddress(db, id, data);
+    },
+    async deleteAddress(db, id) {
+        return identityService.deleteAddress(db, id);
+    },
+    listPersonNotes(db, personId) {
+        return db
+            .select()
+            .from(personNotes)
+            .where(eq(personNotes.personId, personId))
+            .orderBy(personNotes.createdAt);
+    },
+    async createPersonNote(db, personId, userId, data) {
+        const [existing] = await db
+            .select({ id: people.id })
+            .from(people)
+            .where(eq(people.id, personId))
+            .limit(1);
+        if (!existing)
+            return null;
+        const [row] = await db
+            .insert(personNotes)
+            .values({ personId, authorId: userId, content: data.content })
+            .returning();
+        return row;
+    },
+    listOrganizationNotes(db, organizationId) {
+        return db
+            .select()
+            .from(organizationNotes)
+            .where(eq(organizationNotes.organizationId, organizationId))
+            .orderBy(organizationNotes.createdAt);
+    },
+    async createOrganizationNote(db, organizationId, userId, data) {
+        const [existing] = await db
+            .select({ id: organizations.id })
+            .from(organizations)
+            .where(eq(organizations.id, organizationId))
+            .limit(1);
+        if (!existing)
+            return null;
+        const [row] = await db
+            .insert(organizationNotes)
+            .values({ organizationId, authorId: userId, content: data.content })
+            .returning();
+        return row;
+    },
+    async updatePersonNote(db, id, content) {
+        const [row] = await db
+            .update(personNotes)
+            .set({ content })
+            .where(eq(personNotes.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deletePersonNote(db, id) {
+        const [row] = await db.delete(personNotes).where(eq(personNotes.id, id)).returning();
+        return row ?? null;
+    },
+    // ── Payment methods ────────────────────────────────────────────────────
+    listPersonPaymentMethods(db, personId) {
+        return db
+            .select()
+            .from(personPaymentMethods)
+            .where(eq(personPaymentMethods.personId, personId))
+            .orderBy(desc(personPaymentMethods.isDefault), desc(personPaymentMethods.createdAt));
+    },
+    async createPersonPaymentMethod(db, personId, data) {
+        const [existing] = await db
+            .select({ id: people.id })
+            .from(people)
+            .where(eq(people.id, personId))
+            .limit(1);
+        if (!existing)
+            return null;
+        if (data.isDefault) {
+            // Only one default per person — clear the others first.
+            await db
+                .update(personPaymentMethods)
+                .set({ isDefault: false })
+                .where(eq(personPaymentMethods.personId, personId));
+        }
+        const [row] = await db
+            .insert(personPaymentMethods)
+            .values({ personId, ...data })
+            .returning();
+        return row ?? null;
+    },
+    async updatePersonPaymentMethod(db, id, data) {
+        if (data.isDefault) {
+            const [target] = await db
+                .select({ personId: personPaymentMethods.personId })
+                .from(personPaymentMethods)
+                .where(eq(personPaymentMethods.id, id))
+                .limit(1);
+            if (target) {
+                await db
+                    .update(personPaymentMethods)
+                    .set({ isDefault: false })
+                    .where(eq(personPaymentMethods.personId, target.personId));
+            }
+        }
+        const [row] = await db
+            .update(personPaymentMethods)
+            .set(data)
+            .where(eq(personPaymentMethods.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deletePersonPaymentMethod(db, id) {
+        const [row] = await db
+            .delete(personPaymentMethods)
+            .where(eq(personPaymentMethods.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async updateOrganizationNote(db, id, content) {
+        const [row] = await db
+            .update(organizationNotes)
+            .set({ content })
+            .where(eq(organizationNotes.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteOrganizationNote(db, id) {
+        const [row] = await db.delete(organizationNotes).where(eq(organizationNotes.id, id)).returning();
+        return row ?? null;
+    },
+    async listCommunications(db, personId, query) {
+        const conditions = [eq(communicationLog.personId, personId)];
+        if (query.channel)
+            conditions.push(eq(communicationLog.channel, query.channel));
+        if (query.direction)
+            conditions.push(eq(communicationLog.direction, query.direction));
+        if (query.dateFrom)
+            conditions.push(gte(communicationLog.createdAt, new Date(query.dateFrom)));
+        if (query.dateTo)
+            conditions.push(lte(communicationLog.createdAt, new Date(query.dateTo)));
+        return db
+            .select()
+            .from(communicationLog)
+            .where(and(...conditions))
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(communicationLog.createdAt));
+    },
+    async createCommunication(db, personId, data) {
+        const [existing] = await db
+            .select({ id: people.id })
+            .from(people)
+            .where(eq(people.id, personId))
+            .limit(1);
+        if (!existing)
+            return null;
+        const [row] = await db
+            .insert(communicationLog)
+            .values({
+            personId,
+            organizationId: data.organizationId ?? null,
+            channel: data.channel,
+            direction: data.direction,
+            subject: data.subject ?? null,
+            content: data.content ?? null,
+            sentAt: data.sentAt ? new Date(data.sentAt) : null,
+        })
+            .returning();
+        return row;
+    },
+    listSegments(db) {
+        return db.select().from(segments).orderBy(segments.createdAt);
+    },
+    async createSegment(db, data) {
+        const [row] = await db.insert(segments).values(data).returning();
+        return row;
+    },
+    async deleteSegment(db, segmentId) {
+        const [row] = await db
+            .delete(segments)
+            .where(eq(segments.id, segmentId))
+            .returning({ id: segments.id });
+        return row ?? null;
+    },
+    async exportPeopleCsv(db) {
+        const rows = await hydratePeople(db, await db.select().from(people).orderBy(people.createdAt));
+        const headers = [
+            "id",
+            "firstName",
+            "lastName",
+            "jobTitle",
+            "relation",
+            "preferredLanguage",
+            "preferredCurrency",
+            "email",
+            "phone",
+            "website",
+            "organizationId",
+        ];
+        const csvLines = [toCsvRow(headers)];
+        for (const row of rows) {
+            // toCsvRow quotes delimiters/quotes/newlines AND neutralizes
+            // spreadsheet formula-injection prefixes (= + - @ tab CR); see L4.
+            csvLines.push(toCsvRow(headers.map((header) => row[header])));
+        }
+        return csvLines.join("\n");
+    },
+    async importPeopleCsv(db, csvText) {
+        const lines = csvText.split("\n").filter((line) => line.trim());
+        if (lines.length < 2) {
+            return { error: "CSV must have a header row and at least one data row" };
+        }
+        const headers = lines[0].split(",").map((header) => header.trim());
+        const rows = [];
+        for (let i = 1; i < lines.length; i++) {
+            const values = lines[i].split(",").map((value) => value.trim());
+            const row = {};
+            for (let j = 0; j < headers.length; j++) {
+                const header = headers[j];
+                const value = values[j];
+                if (header && value) {
+                    row[header] = value;
+                }
+            }
+            rows.push(row);
+        }
+        const imported = [];
+        const errors = [];
+        for (let i = 0; i < rows.length; i++) {
+            const row = rows[i];
+            const result = (await import("../validation.js")).insertPersonSchema.safeParse({
+                firstName: row.firstName || "",
+                lastName: row.lastName || "",
+                jobTitle: row.jobTitle || null,
+                relation: row.relation || null,
+                preferredLanguage: row.preferredLanguage || null,
+                preferredCurrency: row.preferredCurrency || null,
+                email: row.email || null,
+                phone: row.phone || null,
+                website: row.website || null,
+                organizationId: row.organizationId || null,
+                tags: [],
+            });
+            if (!result.success) {
+                errors.push({ row: i + 2, error: result.error.message });
+                continue;
+            }
+            imported.push(await this.createPerson(db, result.data));
+        }
+        return { imported: imported.length, errors };
+    },
+};

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

@@ -0,0 +1,76 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { people } from "../schema.js";
+/**
+ * Best-effort contact snapshot used by booking/storefront flows to
+ * resolve (or upsert) a CRM person from billing or traveler payloads.
+ * Empty-string and whitespace-only fields are normalized to `null`.
+ */
+export interface PersonContactInput {
+    firstName?: string | null;
+    lastName?: string | null;
+    /**
+     * Single-string display name when first/last aren't provided
+     * separately — split on whitespace.
+     */
+    name?: string | null;
+    email?: string | null;
+    phone?: string | null;
+    preferredLanguage?: string | null;
+}
+export interface UpsertPersonFromContactOptions {
+    /** `source` recorded on the `people` row (`"storefront-booking"`, etc.). */
+    source?: string | null;
+    /** `source_ref` recorded on the `people` row — e.g. the session id. */
+    sourceRef?: string | null;
+    /** Tags propagated to the new person when one is created. */
+    tags?: string[];
+    /** Status override; defaults to `"active"`. */
+    status?: "active" | "inactive";
+    /**
+     * When true, returns `null` instead of creating a person if the
+     * snapshot has no email or phone dedupe key.
+     */
+    requireContactPoint?: boolean;
+}
+/**
+ * Derives `{ firstName, lastName }` for a CRM person from whatever
+ * contact bits the caller has. Mirrors the storefront-intake helpers
+ * (`personNameFromContact` / `personNameFromNewsletter`) so identity
+ * resolution from booking/traveler payloads stays symmetric. Falls
+ * back to the email local-part before resorting to literal placeholders
+ * — `people.first_name`/`last_name` are NOT NULL and the issue #961
+ * acceptance criteria call out that the literal `"Unknown"` should
+ * never be inserted.
+ */
+export declare function personNameFromContact(input: PersonContactInput): {
+    firstName: string;
+    lastName: string;
+};
+/**
+ * Returns the first person whose normalized contact point matches
+ * `(kind, value)`. Email and website are normalized to lowercase; phone
+ * is trimmed. Returns `null` when no match exists, the value resolves to
+ * an empty string, or the matching contact point is attached to a
+ * non-person entity (organizations share the same table).
+ */
+export declare function findPersonByContactPoint(db: PostgresJsDatabase, query: {
+    kind: "email" | "phone" | "website";
+    value: string | null | undefined;
+}): Promise<typeof people.$inferSelect | null>;
+/**
+ * Finds an existing CRM person by normalized email (then phone as a
+ * fallback) or creates a new one from the supplied contact snapshot.
+ * Used by booking session bootstrap + confirm flows so storefront
+ * bookings produce a real CRM record without each consumer reinventing
+ * the dedupe key. The created row carries the supplied `source` /
+ * `sourceRef` so the audit trail mirrors lead/newsletter signals.
+ *
+ * Lookup order: email → phone. The first hit wins; ties never happen
+ * because identity contact points are unique per `(kind, normalized)`
+ * for a given entity but consumers can re-use the same email across
+ * people via the unique-by-person sync logic. In that case the first
+ * person we see is returned — callers that need stricter ownership
+ * semantics should resolve themselves and pass a `personId` directly.
+ */
+export declare function upsertPersonFromContact(db: PostgresJsDatabase, contact: PersonContactInput, options?: UpsertPersonFromContactOptions): Promise<typeof people.$inferSelect | null>;
+//# sourceMappingURL=accounts-resolve.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"accounts-resolve.d.ts","sourceRoot":"","sources":["../../src/service/accounts-resolve.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAK1C;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAClC;AAED,MAAM,WAAW,8BAA8B;IAC7C,4EAA4E;IAC5E,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,uEAAuE;IACvE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,6DAA6D;IAC7D,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;IACf,+CAA+C;IAC/C,MAAM,CAAC,EAAE,QAAQ,GAAG,UAAU,CAAA;IAC9B;;;OAGG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAA;CAC9B;AAaD;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,kBAAkB,GAAG;IAChE,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;CACjB,CAUA;AAED;;;;;;GAMG;AACH,wBAAsB,wBAAwB,CAC5C,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE;IAAE,IAAI,EAAE,OAAO,GAAG,OAAO,GAAG,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAA;CAAE,GAC/E,OAAO,CAAC,OAAO,MAAM,CAAC,YAAY,GAAG,IAAI,CAAC,CAmB5C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,uBAAuB,CAC3C,EAAE,EAAE,kBAAkB,EACtB,OAAO,EAAE,kBAAkB,EAC3B,OAAO,GAAE,8BAAmC,GAC3C,OAAO,CAAC,OAAO,MAAM,CAAC,YAAY,GAAG,IAAI,CAAC,CAgC5C"}

package/dist/service/accounts-resolve.js

@@ -0,0 +1,103 @@
+import { identityContactPoints } from "@voyant-travel/identity/schema";
+import { and, eq } from "drizzle-orm";
+import { peopleAccountsService } from "./accounts-people.js";
+import { personEntityType } from "./accounts-shared.js";
+import { normalizeContactValue, toNullableTrimmed } from "./helpers.js";
+function splitName(name) {
+    if (!name)
+        return {};
+    const parts = name.trim().split(/\s+/);
+    if (parts.length === 0)
+        return {};
+    if (parts.length === 1)
+        return { firstName: parts[0] };
+    return { firstName: parts[0], lastName: parts.slice(1).join(" ") };
+}
+/**
+ * Derives `{ firstName, lastName }` for a CRM person from whatever
+ * contact bits the caller has. Mirrors the storefront-intake helpers
+ * (`personNameFromContact` / `personNameFromNewsletter`) so identity
+ * resolution from booking/traveler payloads stays symmetric. Falls
+ * back to the email local-part before resorting to literal placeholders
+ * — `people.first_name`/`last_name` are NOT NULL and the issue #961
+ * acceptance criteria call out that the literal `"Unknown"` should
+ * never be inserted.
+ */
+export function personNameFromContact(input) {
+    const split = splitName(input.name ?? null);
+    const emailLocalPart = input.email
+        ?.split("@")[0]
+        ?.replace(/[._-]+/g, " ")
+        .trim();
+    const firstName = toNullableTrimmed(input.firstName) ?? split.firstName ?? emailLocalPart ?? "Customer";
+    const lastName = toNullableTrimmed(input.lastName) ?? split.lastName ?? "Guest";
+    return { firstName, lastName };
+}
+/**
+ * Returns the first person whose normalized contact point matches
+ * `(kind, value)`. Email and website are normalized to lowercase; phone
+ * is trimmed. Returns `null` when no match exists, the value resolves to
+ * an empty string, or the matching contact point is attached to a
+ * non-person entity (organizations share the same table).
+ */
+export async function findPersonByContactPoint(db, query) {
+    const value = toNullableTrimmed(query.value);
+    if (!value)
+        return null;
+    const normalized = normalizeContactValue(query.kind, value);
+    const [row] = await db
+        .select({ personId: identityContactPoints.entityId })
+        .from(identityContactPoints)
+        .where(and(eq(identityContactPoints.entityType, personEntityType), eq(identityContactPoints.kind, query.kind), eq(identityContactPoints.normalizedValue, normalized)))
+        .limit(1);
+    if (!row)
+        return null;
+    return peopleAccountsService.getPersonById(db, row.personId);
+}
+/**
+ * Finds an existing CRM person by normalized email (then phone as a
+ * fallback) or creates a new one from the supplied contact snapshot.
+ * Used by booking session bootstrap + confirm flows so storefront
+ * bookings produce a real CRM record without each consumer reinventing
+ * the dedupe key. The created row carries the supplied `source` /
+ * `sourceRef` so the audit trail mirrors lead/newsletter signals.
+ *
+ * Lookup order: email → phone. The first hit wins; ties never happen
+ * because identity contact points are unique per `(kind, normalized)`
+ * for a given entity but consumers can re-use the same email across
+ * people via the unique-by-person sync logic. In that case the first
+ * person we see is returned — callers that need stricter ownership
+ * semantics should resolve themselves and pass a `personId` directly.
+ */
+export async function upsertPersonFromContact(db, contact, options = {}) {
+    const email = toNullableTrimmed(contact.email);
+    const phone = toNullableTrimmed(contact.phone);
+    if (email) {
+        const existing = await findPersonByContactPoint(db, { kind: "email", value: email });
+        if (existing)
+            return existing;
+    }
+    if (phone) {
+        const existing = await findPersonByContactPoint(db, { kind: "phone", value: phone });
+        if (existing)
+            return existing;
+    }
+    if (options.requireContactPoint && !email && !phone) {
+        return null;
+    }
+    // No match — create a new person. `personNameFromContact` ensures
+    // first/last name are populated even when only an email is on file.
+    const { firstName, lastName } = personNameFromContact(contact);
+    return peopleAccountsService.createPerson(db, {
+        firstName,
+        lastName,
+        email,
+        phone,
+        website: null,
+        status: options.status ?? "active",
+        source: options.source ?? null,
+        sourceRef: options.sourceRef ?? null,
+        preferredLanguage: toNullableTrimmed(contact.preferredLanguage),
+        tags: options.tags ?? [],
+    });
+}

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

@@ -0,0 +1,68 @@
+import type { insertAddressSchema, insertContactPointSchema, updateAddressSchema, updateContactPointSchema } from "@voyant-travel/identity/validation";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { z } from "zod";
+import type { communicationListQuerySchema, insertCommunicationLogSchema, insertOrganizationNoteSchema, insertOrganizationSchema, insertPersonNoteSchema, insertPersonSchema, insertSegmentSchema, organizationListQuerySchema, personListQuerySchema, updateOrganizationSchema, updatePersonSchema } from "../validation.js";
+export type OrganizationListQuery = z.infer<typeof organizationListQuerySchema>;
+export type CreateOrganizationInput = z.infer<typeof insertOrganizationSchema>;
+export type UpdateOrganizationInput = z.infer<typeof updateOrganizationSchema>;
+export type PersonListQuery = z.infer<typeof personListQuerySchema>;
+export type CreatePersonInput = z.infer<typeof insertPersonSchema>;
+export type UpdatePersonInput = z.infer<typeof updatePersonSchema>;
+export type CreateContactPointInput = z.infer<typeof insertContactPointSchema>;
+export type UpdateContactPointInput = z.infer<typeof updateContactPointSchema>;
+export type CreateAddressInput = z.infer<typeof insertAddressSchema>;
+export type UpdateAddressInput = z.infer<typeof updateAddressSchema>;
+export type CreatePersonNoteInput = z.infer<typeof insertPersonNoteSchema>;
+export type CreateOrganizationNoteInput = z.infer<typeof insertOrganizationNoteSchema>;
+export type CreateCommunicationLogInput = z.infer<typeof insertCommunicationLogSchema>;
+export type CommunicationListQuery = z.infer<typeof communicationListQuerySchema>;
+export type CreateSegmentInput = z.infer<typeof insertSegmentSchema>;
+export declare const organizationEntityType = "organization";
+export declare const personEntityType = "person";
+export declare const personBaseIdentitySource = "relationships.person.base";
+type PersonIdentityInput = Pick<CreatePersonInput, "email" | "phone" | "website">;
+export type PersonHydratedFields = {
+    email: string | null;
+    phone: string | null;
+    website: string | null;
+};
+type HydratePeopleOptions = {
+    fallbackOnError?: boolean;
+};
+export declare function personBaseFields(data: CreatePersonInput | UpdatePersonInput): {
+    organizationId: string | null | undefined;
+    firstName: string | undefined;
+    middleName: string | null | undefined;
+    lastName: string | undefined;
+    gender: "M" | "F" | "X" | null | undefined;
+    jobTitle: string | null | undefined;
+    relation: "other" | "partner" | "supplier" | "client" | null | undefined;
+    preferredLanguage: string | null | undefined;
+    preferredCurrency: string | null | undefined;
+    ownerId: string | null | undefined;
+    status: "active" | "inactive" | "archived" | undefined;
+    source: string | null | undefined;
+    sourceRef: string | null | undefined;
+    tags: string[] | undefined;
+    dateOfBirth: string | null | undefined;
+    notes: string | null | undefined;
+    accessibilityEncrypted: {
+        enc: string;
+    } | null | undefined;
+    dietaryEncrypted: {
+        enc: string;
+    } | null | undefined;
+    loyaltyEncrypted: {
+        enc: string;
+    } | null | undefined;
+    insuranceEncrypted: {
+        enc: string;
+    } | null | undefined;
+};
+export declare function syncPersonIdentity(db: PostgresJsDatabase, personId: string, data: PersonIdentityInput): Promise<void>;
+export declare function deletePersonIdentity(db: PostgresJsDatabase, personId: string): Promise<void>;
+export declare function hydratePeople<T extends {
+    id: string;
+}>(db: PostgresJsDatabase, rows: T[], options?: HydratePeopleOptions): Promise<Array<T & PersonHydratedFields>>;
+export {};
+//# sourceMappingURL=accounts-shared.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"accounts-shared.d.ts","sourceRoot":"","sources":["../../src/service/accounts-shared.ts"],"names":[],"mappings":"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"}