@voyant-travel/relationships 0.119.2

package/dist/service/person-relationships.d.ts

@@ -0,0 +1,502 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { z } from "zod";
+import type { insertPersonRelationshipSchema, personRelationshipListQuerySchema, updatePersonRelationshipSchema } from "../validation.js";
+export type CreatePersonRelationshipInput = z.infer<typeof insertPersonRelationshipSchema>;
+export type UpdatePersonRelationshipInput = z.infer<typeof updatePersonRelationshipSchema>;
+export type PersonRelationshipListQuery = z.infer<typeof personRelationshipListQuerySchema>;
+export type PersonRelationshipKind = CreatePersonRelationshipInput["kind"];
+export declare const personRelationshipsService: {
+    /**
+     * Lists relationships for a person. Default `direction: "both"`
+     * returns the union of outgoing and incoming edges — the typical
+     * "Jane's family" UI shape. Use `from` / `to` for one-sided lists.
+     */
+    listPersonRelationships(db: PostgresJsDatabase, personId: string, query?: PersonRelationshipListQuery): Omit<import("drizzle-orm/pg-core").PgSelectBase<"person_relationships", {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "person_relationships";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        fromPersonId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "person_relationships";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        toPersonId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "person_relationships";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        kind: import("drizzle-orm/pg-core").PgColumn<{
+            name: "kind";
+            tableName: "person_relationships";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "other" | "partner" | "spouse" | "parent" | "child" | "sibling" | "guardian" | "ward" | "emergency_contact" | "friend" | "travel_companion";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["spouse", "partner", "parent", "child", "sibling", "guardian", "ward", "emergency_contact", "friend", "travel_companion", "other"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        inverseKind: import("drizzle-orm/pg-core").PgColumn<{
+            name: "inverse_kind";
+            tableName: "person_relationships";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "other" | "partner" | "spouse" | "parent" | "child" | "sibling" | "guardian" | "ward" | "emergency_contact" | "friend" | "travel_companion";
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["spouse", "partner", "parent", "child", "sibling", "guardian", "ward", "emergency_contact", "friend", "travel_companion", "other"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        startDate: import("drizzle-orm/pg-core").PgColumn<{
+            name: "start_date";
+            tableName: "person_relationships";
+            dataType: "string";
+            columnType: "PgDateString";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        endDate: import("drizzle-orm/pg-core").PgColumn<{
+            name: "end_date";
+            tableName: "person_relationships";
+            dataType: "string";
+            columnType: "PgDateString";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        isPrimary: import("drizzle-orm/pg-core").PgColumn<{
+            name: "is_primary";
+            tableName: "person_relationships";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        notes: import("drizzle-orm/pg-core").PgColumn<{
+            name: "notes";
+            tableName: "person_relationships";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: import("drizzle-orm/pg-core").PgColumn<{
+            name: "metadata";
+            tableName: "person_relationships";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "person_relationships";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "person_relationships";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    }, "single", Record<"person_relationships", "not-null">, false, "where" | "orderBy" | "limit" | "offset", {
+        id: string;
+        fromPersonId: string;
+        toPersonId: string;
+        kind: "other" | "partner" | "spouse" | "parent" | "child" | "sibling" | "guardian" | "ward" | "emergency_contact" | "friend" | "travel_companion";
+        inverseKind: "other" | "partner" | "spouse" | "parent" | "child" | "sibling" | "guardian" | "ward" | "emergency_contact" | "friend" | "travel_companion" | null;
+        startDate: string | null;
+        endDate: string | null;
+        isPrimary: boolean;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }[], {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "person_relationships";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        fromPersonId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "person_relationships";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        toPersonId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "person_relationships";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        kind: import("drizzle-orm/pg-core").PgColumn<{
+            name: "kind";
+            tableName: "person_relationships";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "other" | "partner" | "spouse" | "parent" | "child" | "sibling" | "guardian" | "ward" | "emergency_contact" | "friend" | "travel_companion";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["spouse", "partner", "parent", "child", "sibling", "guardian", "ward", "emergency_contact", "friend", "travel_companion", "other"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        inverseKind: import("drizzle-orm/pg-core").PgColumn<{
+            name: "inverse_kind";
+            tableName: "person_relationships";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "other" | "partner" | "spouse" | "parent" | "child" | "sibling" | "guardian" | "ward" | "emergency_contact" | "friend" | "travel_companion";
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["spouse", "partner", "parent", "child", "sibling", "guardian", "ward", "emergency_contact", "friend", "travel_companion", "other"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        startDate: import("drizzle-orm/pg-core").PgColumn<{
+            name: "start_date";
+            tableName: "person_relationships";
+            dataType: "string";
+            columnType: "PgDateString";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        endDate: import("drizzle-orm/pg-core").PgColumn<{
+            name: "end_date";
+            tableName: "person_relationships";
+            dataType: "string";
+            columnType: "PgDateString";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        isPrimary: import("drizzle-orm/pg-core").PgColumn<{
+            name: "is_primary";
+            tableName: "person_relationships";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        notes: import("drizzle-orm/pg-core").PgColumn<{
+            name: "notes";
+            tableName: "person_relationships";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: import("drizzle-orm/pg-core").PgColumn<{
+            name: "metadata";
+            tableName: "person_relationships";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "person_relationships";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "person_relationships";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    }>, "where" | "orderBy" | "limit" | "offset">;
+    getPersonRelationship(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        fromPersonId: string;
+        toPersonId: string;
+        kind: "other" | "partner" | "spouse" | "parent" | "child" | "sibling" | "guardian" | "ward" | "emergency_contact" | "friend" | "travel_companion";
+        inverseKind: "other" | "partner" | "spouse" | "parent" | "child" | "sibling" | "guardian" | "ward" | "emergency_contact" | "friend" | "travel_companion" | null;
+        startDate: string | null;
+        endDate: string | null;
+        isPrimary: boolean;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    /**
+     * Inserts a directed edge `fromPerson → toPerson` of `data.kind`.
+     * When `data.inverseKind` is provided AND `data.autoInverse` is
+     * not explicitly false, also inserts the symmetric
+     * `toPerson → fromPerson` edge with `kind = inverseKind` (and
+     * `inverseKind` swapped back). The pair is written in a single
+     * transaction so a failed inverse rolls the primary back.
+     *
+     * The inverse insert is idempotent — if the symmetric edge
+     * already exists, the `(from, to, kind)` unique index would
+     * normally throw; we suppress that case so retrying a partially
+     * applied operation doesn't fail. Any other DB error still
+     * propagates.
+     */
+    createPersonRelationship(db: PostgresJsDatabase, fromPersonId: string, data: CreatePersonRelationshipInput): Promise<{
+        id: string;
+        createdAt: Date;
+        metadata: Record<string, unknown> | null;
+        startDate: string | null;
+        endDate: string | null;
+        notes: string | null;
+        updatedAt: Date;
+        kind: "other" | "partner" | "spouse" | "parent" | "child" | "sibling" | "guardian" | "ward" | "emergency_contact" | "friend" | "travel_companion";
+        isPrimary: boolean;
+        fromPersonId: string;
+        toPersonId: string;
+        inverseKind: "other" | "partner" | "spouse" | "parent" | "child" | "sibling" | "guardian" | "ward" | "emergency_contact" | "friend" | "travel_companion" | null;
+    } | null>;
+    updatePersonRelationship(db: PostgresJsDatabase, id: string, data: UpdatePersonRelationshipInput): Promise<{
+        id: string;
+        fromPersonId: string;
+        toPersonId: string;
+        kind: "other" | "partner" | "spouse" | "parent" | "child" | "sibling" | "guardian" | "ward" | "emergency_contact" | "friend" | "travel_companion";
+        inverseKind: "other" | "partner" | "spouse" | "parent" | "child" | "sibling" | "guardian" | "ward" | "emergency_contact" | "friend" | "travel_companion" | null;
+        startDate: string | null;
+        endDate: string | null;
+        isPrimary: boolean;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deletePersonRelationship(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+};
+//# sourceMappingURL=person-relationships.d.ts.map

package/dist/service/person-relationships.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"person-relationships.d.ts","sourceRoot":"","sources":["../../src/service/person-relationships.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAG5B,OAAO,KAAK,EACV,8BAA8B,EAC9B,iCAAiC,EACjC,8BAA8B,EAC/B,MAAM,kBAAkB,CAAA;AAEzB,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAC1F,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAC1F,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAC3F,MAAM,MAAM,sBAAsB,GAAG,6BAA6B,CAAC,MAAM,CAAC,CAAA;AAW1E,eAAO,MAAM,0BAA0B;IACrC;;;;OAIG;gCAEG,kBAAkB,YACZ,MAAM,UACR,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BA8BL,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;IAS9D;;;;;;;;;;;;;OAaG;iCAEG,kBAAkB,gBACR,MAAM,QACd,6BAA6B;;;;;;;;;;;;;;iCAiD/B,kBAAkB,MAClB,MAAM,QACJ,6BAA6B;;;;;;;;;;;;;;iCAUF,kBAAkB,MAAM,MAAM;;;CAOlE,CAAA"}

package/dist/service/person-relationships.js

@@ -0,0 +1,121 @@
+import { and, asc, eq, or } from "drizzle-orm";
+import { people, personRelationships } from "../schema.js";
+async function personExists(db, personId) {
+    const [row] = await db
+        .select({ id: people.id })
+        .from(people)
+        .where(eq(people.id, personId))
+        .limit(1);
+    return Boolean(row);
+}
+export const personRelationshipsService = {
+    /**
+     * Lists relationships for a person. Default `direction: "both"`
+     * returns the union of outgoing and incoming edges — the typical
+     * "Jane's family" UI shape. Use `from` / `to` for one-sided lists.
+     */
+    listPersonRelationships(db, personId, query) {
+        const direction = query?.direction ?? "both";
+        const directionFilter = direction === "from"
+            ? eq(personRelationships.fromPersonId, personId)
+            : direction === "to"
+                ? eq(personRelationships.toPersonId, personId)
+                : or(eq(personRelationships.fromPersonId, personId), eq(personRelationships.toPersonId, personId));
+        const conditions = [directionFilter];
+        if (query?.kind) {
+            conditions.push(eq(personRelationships.kind, query.kind));
+        }
+        const limit = query?.limit ?? 50;
+        const offset = query?.offset ?? 0;
+        return db
+            .select()
+            .from(personRelationships)
+            .where(and(...conditions))
+            .orderBy(asc(personRelationships.createdAt))
+            .limit(limit)
+            .offset(offset);
+    },
+    async getPersonRelationship(db, id) {
+        const [row] = await db
+            .select()
+            .from(personRelationships)
+            .where(eq(personRelationships.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    /**
+     * Inserts a directed edge `fromPerson → toPerson` of `data.kind`.
+     * When `data.inverseKind` is provided AND `data.autoInverse` is
+     * not explicitly false, also inserts the symmetric
+     * `toPerson → fromPerson` edge with `kind = inverseKind` (and
+     * `inverseKind` swapped back). The pair is written in a single
+     * transaction so a failed inverse rolls the primary back.
+     *
+     * The inverse insert is idempotent — if the symmetric edge
+     * already exists, the `(from, to, kind)` unique index would
+     * normally throw; we suppress that case so retrying a partially
+     * applied operation doesn't fail. Any other DB error still
+     * propagates.
+     */
+    async createPersonRelationship(db, fromPersonId, data) {
+        if (fromPersonId === data.toPersonId)
+            return null;
+        if (!(await personExists(db, fromPersonId)))
+            return null;
+        if (!(await personExists(db, data.toPersonId)))
+            return null;
+        const { toPersonId, autoInverse: autoInverseInput, inverseKind, ...rest } = data;
+        const autoInverse = autoInverseInput !== false;
+        return db.transaction(async (tx) => {
+            const [primary] = await tx
+                .insert(personRelationships)
+                .values({
+                ...rest,
+                inverseKind: inverseKind ?? null,
+                fromPersonId,
+                toPersonId,
+            })
+                .returning();
+            if (!primary)
+                return null;
+            if (autoInverse && inverseKind) {
+                await tx
+                    .insert(personRelationships)
+                    .values({
+                    fromPersonId: toPersonId,
+                    toPersonId: fromPersonId,
+                    kind: inverseKind,
+                    inverseKind: rest.kind,
+                    startDate: rest.startDate ?? null,
+                    endDate: rest.endDate ?? null,
+                    isPrimary: rest.isPrimary,
+                    notes: rest.notes ?? null,
+                    metadata: rest.metadata ?? null,
+                })
+                    .onConflictDoNothing({
+                    target: [
+                        personRelationships.fromPersonId,
+                        personRelationships.toPersonId,
+                        personRelationships.kind,
+                    ],
+                });
+            }
+            return primary;
+        });
+    },
+    async updatePersonRelationship(db, id, data) {
+        const [row] = await db
+            .update(personRelationships)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(personRelationships.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deletePersonRelationship(db, id) {
+        const [row] = await db
+            .delete(personRelationships)
+            .where(eq(personRelationships.id, id))
+            .returning({ id: personRelationships.id });
+        return row ?? null;
+    },
+};

package/dist/validation.d.ts

@@ -0,0 +1,3 @@
+export type { CustomerSignalInput, CustomerSignalListQueryInput, CustomerSignalUpdate, InsertPersonPaymentMethodInput, PersonDocumentInput, PersonDocumentPlaintextInput, PersonDocumentPlaintextUpdate, PersonDocumentUpdate, PersonRelationshipInput, PersonRelationshipListQueryInput, PersonRelationshipUpdate, ResolveCustomerSignalInput, UpdatePersonPaymentMethodInput, UpdatePersonProfilePiiInput, } from "@voyant-travel/crm-contracts";
+export { activityCoreSchema, activityLinkRoleSchema, activityListQuerySchema, activityStatusSchema, activityTypeSchema, communicationChannelSchema, communicationDirectionSchema, communicationListQuerySchema, customerSignalKindSchema, customerSignalListQuerySchema, customerSignalPrioritySchema, customerSignalSourceSchema, customerSignalStatusSchema, customFieldDefinitionCoreSchema, customFieldDefinitionListQuerySchema, customFieldTypeSchema, customFieldValueListQuerySchema, entityTypeSchema, insertActivityLinkSchema, insertActivityParticipantSchema, insertActivitySchema, insertCommunicationLogSchema, insertCustomerSignalSchema, insertCustomFieldDefinitionSchema, insertOrganizationNoteSchema, insertOrganizationSchema, insertPersonDocumentFromPlaintextSchema, insertPersonDocumentSchema, insertPersonNoteSchema, insertPersonPaymentMethodSchema, insertPersonRelationshipSchema, insertPersonSchema, insertSegmentSchema, mergeOrganizationSchema, mergePersonSchema, organizationCoreSchema, organizationListQuerySchema, organizationListSortDirSchema, organizationListSortFieldSchema, paymentMethodBrandSchema, personCoreSchema, personDocumentCoreSchema, personDocumentListQuerySchema, personDocumentTypeSchema, personListQuerySchema, personListSortDirSchema, personListSortFieldSchema, personRelationshipKindSchema, personRelationshipListQuerySchema, recordStatusSchema, relationTypeSchema, resolveCustomerSignalSchema, updateActivitySchema, updateCustomerSignalSchema, updateCustomFieldDefinitionSchema, updateOrganizationNoteSchema, updateOrganizationSchema, updatePersonDocumentFromPlaintextSchema, updatePersonDocumentSchema, updatePersonNoteSchema, updatePersonPaymentMethodSchema, updatePersonProfilePiiSchema, updatePersonRelationshipSchema, updatePersonSchema, upsertCustomFieldValueSchema, } from "@voyant-travel/crm-contracts";
+//# sourceMappingURL=validation.d.ts.map

package/dist/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,mBAAmB,EACnB,4BAA4B,EAC5B,oBAAoB,EACpB,8BAA8B,EAC9B,mBAAmB,EACnB,4BAA4B,EAC5B,6BAA6B,EAC7B,oBAAoB,EACpB,uBAAuB,EACvB,gCAAgC,EAChC,wBAAwB,EACxB,0BAA0B,EAC1B,8BAA8B,EAC9B,2BAA2B,GAC5B,MAAM,8BAA8B,CAAA;AACrC,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EACtB,uBAAuB,EACvB,oBAAoB,EACpB,kBAAkB,EAClB,0BAA0B,EAC1B,4BAA4B,EAC5B,4BAA4B,EAC5B,wBAAwB,EACxB,6BAA6B,EAC7B,4BAA4B,EAC5B,0BAA0B,EAC1B,0BAA0B,EAC1B,+BAA+B,EAC/B,oCAAoC,EACpC,qBAAqB,EACrB,+BAA+B,EAC/B,gBAAgB,EAChB,wBAAwB,EACxB,+BAA+B,EAC/B,oBAAoB,EACpB,4BAA4B,EAC5B,0BAA0B,EAC1B,iCAAiC,EACjC,4BAA4B,EAC5B,wBAAwB,EACxB,uCAAuC,EACvC,0BAA0B,EAC1B,sBAAsB,EACtB,+BAA+B,EAC/B,8BAA8B,EAC9B,kBAAkB,EAClB,mBAAmB,EACnB,uBAAuB,EACvB,iBAAiB,EACjB,sBAAsB,EACtB,2BAA2B,EAC3B,6BAA6B,EAC7B,+BAA+B,EAC/B,wBAAwB,EACxB,gBAAgB,EAChB,wBAAwB,EACxB,6BAA6B,EAC7B,wBAAwB,EACxB,qBAAqB,EACrB,uBAAuB,EACvB,yBAAyB,EACzB,4BAA4B,EAC5B,iCAAiC,EACjC,kBAAkB,EAClB,kBAAkB,EAClB,2BAA2B,EAC3B,oBAAoB,EACpB,0BAA0B,EAC1B,iCAAiC,EACjC,4BAA4B,EAC5B,wBAAwB,EACxB,uCAAuC,EACvC,0BAA0B,EAC1B,sBAAsB,EACtB,+BAA+B,EAC/B,4BAA4B,EAC5B,8BAA8B,EAC9B,kBAAkB,EAClB,4BAA4B,GAC7B,MAAM,8BAA8B,CAAA"}

package/dist/validation.js

@@ -0,0 +1 @@
+export { activityCoreSchema, activityLinkRoleSchema, activityListQuerySchema, activityStatusSchema, activityTypeSchema, communicationChannelSchema, communicationDirectionSchema, communicationListQuerySchema, customerSignalKindSchema, customerSignalListQuerySchema, customerSignalPrioritySchema, customerSignalSourceSchema, customerSignalStatusSchema, customFieldDefinitionCoreSchema, customFieldDefinitionListQuerySchema, customFieldTypeSchema, customFieldValueListQuerySchema, entityTypeSchema, insertActivityLinkSchema, insertActivityParticipantSchema, insertActivitySchema, insertCommunicationLogSchema, insertCustomerSignalSchema, insertCustomFieldDefinitionSchema, insertOrganizationNoteSchema, insertOrganizationSchema, insertPersonDocumentFromPlaintextSchema, insertPersonDocumentSchema, insertPersonNoteSchema, insertPersonPaymentMethodSchema, insertPersonRelationshipSchema, insertPersonSchema, insertSegmentSchema, mergeOrganizationSchema, mergePersonSchema, organizationCoreSchema, organizationListQuerySchema, organizationListSortDirSchema, organizationListSortFieldSchema, paymentMethodBrandSchema, personCoreSchema, personDocumentCoreSchema, personDocumentListQuerySchema, personDocumentTypeSchema, personListQuerySchema, personListSortDirSchema, personListSortFieldSchema, personRelationshipKindSchema, personRelationshipListQuerySchema, recordStatusSchema, relationTypeSchema, resolveCustomerSignalSchema, updateActivitySchema, updateCustomerSignalSchema, updateCustomFieldDefinitionSchema, updateOrganizationNoteSchema, updateOrganizationSchema, updatePersonDocumentFromPlaintextSchema, updatePersonDocumentSchema, updatePersonNoteSchema, updatePersonPaymentMethodSchema, updatePersonProfilePiiSchema, updatePersonRelationshipSchema, updatePersonSchema, upsertCustomFieldValueSchema, } from "@voyant-travel/crm-contracts";