@voyant-travel/relationships 0.119.2

package/dist/service/accounts-shared.js

@@ -0,0 +1,149 @@
+import { identityService } from "@voyant-travel/identity/service";
+import { inArray } from "drizzle-orm";
+import { personDirectoryView } from "../schema.js";
+import { isManagedBySource, normalizeContactValue, toNullableTrimmed } from "./helpers.js";
+export const organizationEntityType = "organization";
+export const personEntityType = "person";
+export const personBaseIdentitySource = "relationships.person.base";
+function emptyPersonHydratedFields() {
+    return {
+        email: null,
+        phone: null,
+        website: null,
+    };
+}
+export function personBaseFields(data) {
+    return {
+        organizationId: data.organizationId,
+        firstName: data.firstName,
+        middleName: data.middleName,
+        lastName: data.lastName,
+        gender: data.gender,
+        jobTitle: data.jobTitle,
+        relation: data.relation,
+        preferredLanguage: data.preferredLanguage,
+        preferredCurrency: data.preferredCurrency,
+        ownerId: data.ownerId,
+        status: data.status,
+        source: data.source,
+        sourceRef: data.sourceRef,
+        tags: data.tags,
+        dateOfBirth: data.dateOfBirth,
+        notes: data.notes,
+        accessibilityEncrypted: data.accessibilityEncrypted,
+        dietaryEncrypted: data.dietaryEncrypted,
+        loyaltyEncrypted: data.loyaltyEncrypted,
+        insuranceEncrypted: data.insuranceEncrypted,
+    };
+}
+/**
+ * Reads the per-person `(email, phone, website)` triple from the
+ * `person_directory` view (replaces the old projection cache —
+ * see #446). The view is computed via indexed `LATERAL` joins on
+ * `identity_contact_points`, so callers no longer need a rebuild
+ * step after contact-point edits.
+ */
+async function loadPersonDirectoryMap(db, personIds) {
+    const ids = [...new Set(personIds)];
+    if (ids.length === 0) {
+        return new Map();
+    }
+    const rows = await db
+        .select()
+        .from(personDirectoryView)
+        .where(inArray(personDirectoryView.personId, ids));
+    const map = new Map();
+    for (const row of rows) {
+        map.set(row.personId, {
+            email: row.email,
+            phone: row.phone,
+            website: row.website,
+        });
+    }
+    for (const id of ids) {
+        if (!map.has(id)) {
+            map.set(id, emptyPersonHydratedFields());
+        }
+    }
+    return map;
+}
+export async function syncPersonIdentity(db, personId, data) {
+    const existingContactPoints = await identityService.listContactPointsForEntity(db, personEntityType, personId);
+    const existingAddresses = await identityService.listAddressesForEntity(db, personEntityType, personId);
+    const managedContactPoints = existingContactPoints.filter((point) => isManagedBySource(point.metadata, personBaseIdentitySource));
+    const managedAddress = existingAddresses.find((address) => isManagedBySource(address.metadata, personBaseIdentitySource));
+    for (const [kind, rawValue] of Object.entries({
+        email: data.email,
+        phone: data.phone,
+        website: data.website,
+    })) {
+        const value = toNullableTrimmed(rawValue);
+        const existing = managedContactPoints.find((point) => point.kind === kind) ??
+            existingContactPoints.find((point) => point.kind === kind && point.isPrimary);
+        if (!value) {
+            if (existing) {
+                await identityService.deleteContactPoint(db, existing.id);
+            }
+            continue;
+        }
+        const payload = {
+            entityType: personEntityType,
+            entityId: personId,
+            kind,
+            label: kind === "website" ? "website" : "primary",
+            value,
+            normalizedValue: normalizeContactValue(kind, value),
+            isPrimary: true,
+            metadata: { managedBy: personBaseIdentitySource },
+        };
+        if (existing) {
+            await identityService.updateContactPoint(db, existing.id, payload);
+        }
+        else {
+            await identityService.createContactPoint(db, payload);
+        }
+    }
+    if (managedAddress) {
+        await identityService.deleteAddress(db, managedAddress.id);
+    }
+}
+export async function deletePersonIdentity(db, personId) {
+    const [contactPoints, addresses] = await Promise.all([
+        identityService.listContactPointsForEntity(db, personEntityType, personId),
+        identityService.listAddressesForEntity(db, personEntityType, personId),
+    ]);
+    await Promise.all([
+        ...contactPoints.map((point) => identityService.deleteContactPoint(db, point.id)),
+        ...addresses.map((address) => identityService.deleteAddress(db, address.id)),
+    ]);
+}
+export async function hydratePeople(db, rows, options = {}) {
+    const emptyHydratedRows = () => rows.map((row) => ({
+        ...row,
+        ...emptyPersonHydratedFields(),
+    }));
+    if (rows.length === 0) {
+        return emptyHydratedRows();
+    }
+    const ids = rows.map((row) => row.id);
+    let directoryMap;
+    try {
+        directoryMap = await loadPersonDirectoryMap(db, ids);
+    }
+    catch (error) {
+        if (!options.fallbackOnError) {
+            throw error;
+        }
+        console.warn("[relationships] person identity hydration failed; returning base people rows", {
+            error,
+            personCount: rows.length,
+        });
+        return emptyHydratedRows();
+    }
+    return rows.map((row) => {
+        return {
+            ...row,
+            ...(directoryMap.get(row.id) ?? emptyPersonHydratedFields()),
+        };
+    });
+}