@voyant-travel/relationships 0.119.2

package/dist/routes/person-documents.js

@@ -0,0 +1,240 @@
+import { evaluateActionLedgerCapabilityAccess, ledgerSensitiveRead, } from "@voyant-travel/action-ledger";
+import { parseJsonBody, parseQuery } from "@voyant-travel/hono";
+import { encryptOptionalJsonEnvelope } from "@voyant-travel/utils";
+import { eq } from "drizzle-orm";
+import { Hono } from "hono";
+import { PERSON_DOCUMENT_REVEAL_ACTION_NAME, PERSON_DOCUMENT_REVEAL_ACTION_VERSION, PERSON_DOCUMENT_REVEAL_AUTHORIZATION_SOURCE, PERSON_DOCUMENT_REVEAL_CAPABILITY, PERSON_DOCUMENT_REVEAL_DECISION_POLICY, } from "../action-ledger-capabilities.js";
+import { RELATIONSHIPS_ROUTE_RUNTIME_CONTAINER_KEY, } from "../route-runtime.js";
+import { people } from "../schema.js";
+import { relationshipsService } from "../service/index.js";
+import { insertPersonDocumentFromPlaintextSchema, insertPersonDocumentSchema, personDocumentListQuerySchema, updatePersonDocumentFromPlaintextSchema, updatePersonDocumentSchema, updatePersonProfilePiiSchema, } from "../validation.js";
+function getRelationshipsActionLedgerContext(c) {
+    return {
+        userId: c.get("userId") ?? null,
+        agentId: null,
+        workflowPrincipalId: null,
+        principalSubtype: null,
+        sessionId: c.get("sessionId") ?? null,
+        apiTokenId: c.get("apiTokenId") ?? c.get("apiKeyId") ?? null,
+        callerType: c.get("callerType") ?? null,
+        actor: c.get("actor") ?? null,
+        isInternalRequest: c.get("isInternalRequest") ?? false,
+        organizationId: c.get("organizationId") ?? null,
+        workflowRunId: null,
+        workflowStepId: null,
+        correlationId: c.req.header("x-correlation-id") ?? c.req.header("x-request-id") ?? null,
+    };
+}
+const peopleKeyRef = { keyType: "people" };
+async function getRelationshipsKms(c) {
+    const runtime = c.var.container?.resolve(RELATIONSHIPS_ROUTE_RUNTIME_CONTAINER_KEY);
+    if (!runtime)
+        return null;
+    return runtime.getKmsProvider();
+}
+function kmsRequired(c) {
+    return c.json({ error: "KMS provider not configured — admin PII routes require a wired KMS key" }, 503);
+}
+export const personDocumentRoutes = new Hono()
+    .get("/people/:id/documents", async (c) => {
+    const query = parseQuery(c, personDocumentListQuerySchema);
+    return c.json({
+        data: await relationshipsService.listPersonDocuments(c.get("db"), c.req.param("id"), query),
+    });
+})
+    .post("/people/:id/documents", async (c) => {
+    const row = await relationshipsService.createPersonDocument(c.get("db"), c.req.param("id"), await parseJsonBody(c, insertPersonDocumentSchema));
+    if (!row)
+        return c.json({ error: "Person not found" }, 404);
+    return c.json({ data: row }, 201);
+})
+    .get("/person-documents/:id", async (c) => {
+    const row = await relationshipsService.getPersonDocument(c.get("db"), c.req.param("id"));
+    if (!row)
+        return c.json({ error: "Document not found" }, 404);
+    return c.json({ data: row });
+})
+    .patch("/person-documents/:id", async (c) => {
+    const row = await relationshipsService.updatePersonDocument(c.get("db"), c.req.param("id"), await parseJsonBody(c, updatePersonDocumentSchema));
+    if (!row)
+        return c.json({ error: "Document not found" }, 404);
+    return c.json({ data: row });
+})
+    .delete("/person-documents/:id", async (c) => {
+    const row = await relationshipsService.deletePersonDocument(c.get("db"), c.req.param("id"));
+    if (!row)
+        return c.json({ error: "Document not found" }, 404);
+    return c.json({ success: true });
+})
+    .post("/person-documents/:id/set-primary", async (c) => {
+    const row = await relationshipsService.setPrimaryPersonDocument(c.get("db"), c.req.param("id"));
+    if (!row)
+        return c.json({ error: "Document not found" }, 404);
+    return c.json({ data: row });
+})
+    // ── Admin PII conveniences (server-side encrypt/decrypt) ──────────────
+    // Operator UIs (booking-traveler dialog) need to read a person's
+    // primary passport + free-text PII in plaintext to pre-fill forms,
+    // and write changes back without round-tripping ciphertext through
+    // the browser. Endpoints below use the request-scoped Relationships runtime
+    // to access the people KMS key.
+    /**
+     * Decrypted snapshot of a person's primary passport + dietary +
+     * accessibility values. Used by the booking-traveler dialog to
+     * pre-fill snapshot fields when an operator picks an existing
+     * person. Returns 404 when person missing, 503 when KMS unwired.
+     */
+    .get("/people/:id/travel-snapshot", async (c) => {
+    const kms = await getRelationshipsKms(c);
+    if (!kms)
+        return kmsRequired(c);
+    const snapshot = await relationshipsService.loadPersonTravelSnapshot(c.get("db"), c.req.param("id"), {
+        kms,
+    });
+    if (!snapshot)
+        return c.json({ error: "Person not found" }, 404);
+    return c.json({ data: snapshot });
+})
+    /**
+     * Plaintext PATCH for the four free-text PII slots on
+     * `relationships.people`. The route encrypts each provided value server-side
+     * with the people KMS key. `null` clears a slot.
+     */
+    .patch("/people/:id/profile-pii", async (c) => {
+    const kms = await getRelationshipsKms(c);
+    if (!kms)
+        return kmsRequired(c);
+    const body = await parseJsonBody(c, updatePersonProfilePiiSchema);
+    const updates = {};
+    for (const [key, column] of [
+        ["accessibility", "accessibilityEncrypted"],
+        ["dietary", "dietaryEncrypted"],
+        ["loyalty", "loyaltyEncrypted"],
+        ["insurance", "insuranceEncrypted"],
+    ]) {
+        const value = body[key];
+        if (value === undefined)
+            continue;
+        if (value === null) {
+            updates[column] = null;
+        }
+        else {
+            updates[column] = await encryptOptionalJsonEnvelope(kms, peopleKeyRef, { text: value });
+        }
+    }
+    if (Object.keys(updates).length === 0) {
+        return c.json({ error: "Nothing to update" }, 400);
+    }
+    const [row] = await c
+        .get("db")
+        .update(people)
+        .set({ ...updates, updatedAt: new Date() })
+        .where(eq(people.id, c.req.param("id")))
+        .returning({ id: people.id });
+    if (!row)
+        return c.json({ error: "Person not found" }, 404);
+    return c.json({ success: true });
+})
+    /**
+     * Plaintext document create — accepts `number` as cleartext, the
+     * route encrypts via the people KMS key. Mirrors the existing
+     * `POST /people/:id/documents` shape but spares clients from
+     * holding KMS material.
+     */
+    .post("/people/:id/documents/from-plaintext", async (c) => {
+    const kms = await getRelationshipsKms(c);
+    if (!kms)
+        return kmsRequired(c);
+    const body = await parseJsonBody(c, insertPersonDocumentFromPlaintextSchema);
+    const { number, ...rest } = body;
+    const numberEncrypted = number == null ? null : await encryptOptionalJsonEnvelope(kms, peopleKeyRef, { number });
+    const row = await relationshipsService.createPersonDocument(c.get("db"), c.req.param("id"), {
+        ...rest,
+        ...(numberEncrypted !== undefined ? { numberEncrypted } : {}),
+    });
+    if (!row)
+        return c.json({ error: "Person not found" }, 404);
+    return c.json({ data: row }, 201);
+})
+    /**
+     * Plaintext document update — same encryption convention as the
+     * create variant. Only fields explicitly provided are written;
+     * `number: null` clears the encrypted slot.
+     */
+    .patch("/person-documents/:id/from-plaintext", async (c) => {
+    const kms = await getRelationshipsKms(c);
+    if (!kms)
+        return kmsRequired(c);
+    const body = await parseJsonBody(c, updatePersonDocumentFromPlaintextSchema);
+    const { number, ...rest } = body;
+    const updateInput = { ...rest };
+    if (number !== undefined) {
+        updateInput.numberEncrypted =
+            number === null ? null : await encryptOptionalJsonEnvelope(kms, peopleKeyRef, { number });
+    }
+    const row = await relationshipsService.updatePersonDocument(c.get("db"), c.req.param("id"), updateInput);
+    if (!row)
+        return c.json({ error: "Document not found" }, 404);
+    return c.json({ data: row });
+})
+    /**
+     * Decrypts and returns the plaintext document number for a single
+     * person document. Gated by the `relationships-pii:read` action-ledger
+     * capability; every successful reveal writes an action-ledger row
+     * tagged `relationships.person_document.reveal` so disclosures are auditable.
+     * Returns 403 when the caller lacks the grant, 404 when the document
+     * doesn't exist, 503 when KMS isn't wired.
+     */
+    .get("/person-documents/:id/reveal", async (c) => {
+    const documentId = c.req.param("id");
+    const access = evaluateActionLedgerCapabilityAccess({
+        definition: PERSON_DOCUMENT_REVEAL_CAPABILITY,
+        actor: c.get("actor") ?? null,
+        callerType: c.get("callerType") ?? null,
+        scopes: c.get("scopes") ?? null,
+        isInternalRequest: c.get("isInternalRequest") ?? false,
+    });
+    if (!access.allowed) {
+        return c.json({ error: "Forbidden", reason: access.reason }, 403);
+    }
+    const kms = await getRelationshipsKms(c);
+    if (!kms)
+        return kmsRequired(c);
+    const existing = await relationshipsService.getPersonDocument(c.get("db"), documentId);
+    if (!existing)
+        return c.json({ error: "Document not found" }, 404);
+    let revealed;
+    try {
+        revealed = await ledgerSensitiveRead(c.get("db"), {
+            context: getRelationshipsActionLedgerContext(c),
+            actionName: PERSON_DOCUMENT_REVEAL_ACTION_NAME,
+            actionVersion: PERSON_DOCUMENT_REVEAL_ACTION_VERSION,
+            status: "succeeded",
+            evaluatedRisk: access.evaluatedRisk ?? "high",
+            targetType: "person_document",
+            targetId: documentId,
+            routeOrToolName: "relationships.person-documents.reveal",
+            capabilityId: PERSON_DOCUMENT_REVEAL_CAPABILITY.id,
+            capabilityVersion: PERSON_DOCUMENT_REVEAL_CAPABILITY.version,
+            authorizationSource: access.authorizationSource ?? PERSON_DOCUMENT_REVEAL_AUTHORIZATION_SOURCE,
+            reasonCode: "person_document_reveal",
+            disclosedFieldSet: ["number"],
+            disclosureSummary: "Person document number reveal",
+            decisionPolicy: PERSON_DOCUMENT_REVEAL_DECISION_POLICY,
+        }, async () => {
+            const result = await relationshipsService.revealPersonDocumentNumber(c.get("db"), documentId, {
+                kms,
+            });
+            if (!result)
+                throw new Error("Document not found");
+            return result;
+        });
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === "Document not found") {
+            return c.json({ error: "Document not found" }, 404);
+        }
+        throw error;
+    }
+    return c.json({ data: revealed });
+});

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

@@ -0,0 +1,189 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+type Env = {
+    Variables: {
+        db: PostgresJsDatabase;
+        userId?: string;
+    };
+};
+export declare const personRelationshipRoutes: import("hono/hono-base").HonoBase<Env, {
+    "/people/:id/relationships": {
+        $get: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    id: string;
+                    fromPersonId: string;
+                    toPersonId: string;
+                    kind: "partner" | "other" | "spouse" | "parent" | "child" | "sibling" | "guardian" | "ward" | "emergency_contact" | "friend" | "travel_companion";
+                    inverseKind: "partner" | "other" | "spouse" | "parent" | "child" | "sibling" | "guardian" | "ward" | "emergency_contact" | "friend" | "travel_companion" | null;
+                    startDate: string | null;
+                    endDate: string | null;
+                    isPrimary: boolean;
+                    notes: string | null;
+                    metadata: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | null;
+                    createdAt: string;
+                    updatedAt: string;
+                }[];
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/people/:id/relationships": {
+        $post: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    id: string;
+                    createdAt: string;
+                    updatedAt: string;
+                    notes: string | null;
+                    kind: "partner" | "other" | "spouse" | "parent" | "child" | "sibling" | "guardian" | "ward" | "emergency_contact" | "friend" | "travel_companion";
+                    isPrimary: boolean;
+                    metadata: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | null;
+                    toPersonId: string;
+                    inverseKind: "partner" | "other" | "spouse" | "parent" | "child" | "sibling" | "guardian" | "ward" | "emergency_contact" | "friend" | "travel_companion" | null;
+                    startDate: string | null;
+                    endDate: string | null;
+                    fromPersonId: string;
+                };
+            };
+            outputFormat: "json";
+            status: 201;
+        };
+    };
+} & {
+    "/person-relationships/:id": {
+        $get: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    id: string;
+                    fromPersonId: string;
+                    toPersonId: string;
+                    kind: "partner" | "other" | "spouse" | "parent" | "child" | "sibling" | "guardian" | "ward" | "emergency_contact" | "friend" | "travel_companion";
+                    inverseKind: "partner" | "other" | "spouse" | "parent" | "child" | "sibling" | "guardian" | "ward" | "emergency_contact" | "friend" | "travel_companion" | null;
+                    startDate: string | null;
+                    endDate: string | null;
+                    isPrimary: boolean;
+                    notes: string | null;
+                    metadata: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | null;
+                    createdAt: string;
+                    updatedAt: string;
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/person-relationships/:id": {
+        $patch: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    id: string;
+                    fromPersonId: string;
+                    toPersonId: string;
+                    kind: "partner" | "other" | "spouse" | "parent" | "child" | "sibling" | "guardian" | "ward" | "emergency_contact" | "friend" | "travel_companion";
+                    inverseKind: "partner" | "other" | "spouse" | "parent" | "child" | "sibling" | "guardian" | "ward" | "emergency_contact" | "friend" | "travel_companion" | null;
+                    startDate: string | null;
+                    endDate: string | null;
+                    isPrimary: boolean;
+                    notes: string | null;
+                    metadata: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | null;
+                    createdAt: string;
+                    updatedAt: string;
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/person-relationships/:id": {
+        $delete: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                success: true;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/", "/person-relationships/:id">;
+export {};
+//# sourceMappingURL=person-relationships.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"person-relationships.d.ts","sourceRoot":"","sources":["../../src/routes/person-relationships.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAUjE,KAAK,GAAG,GAAG;IACT,SAAS,EAAE;QACT,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,CAAA;CACF,CAAA;AAED,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAwCjC,CAAA"}

package/dist/routes/person-relationships.js

@@ -0,0 +1,36 @@
+import { parseJsonBody, parseQuery } from "@voyant-travel/hono";
+import { Hono } from "hono";
+import { relationshipsService } from "../service/index.js";
+import { insertPersonRelationshipSchema, personRelationshipListQuerySchema, updatePersonRelationshipSchema, } from "../validation.js";
+export const personRelationshipRoutes = new Hono()
+    .get("/people/:id/relationships", async (c) => {
+    const query = parseQuery(c, personRelationshipListQuerySchema);
+    return c.json({
+        data: await relationshipsService.listPersonRelationships(c.get("db"), c.req.param("id"), query),
+    });
+})
+    .post("/people/:id/relationships", async (c) => {
+    const row = await relationshipsService.createPersonRelationship(c.get("db"), c.req.param("id"), await parseJsonBody(c, insertPersonRelationshipSchema));
+    if (!row) {
+        return c.json({ error: "Person not found or self-relationship rejected" }, 400);
+    }
+    return c.json({ data: row }, 201);
+})
+    .get("/person-relationships/:id", async (c) => {
+    const row = await relationshipsService.getPersonRelationship(c.get("db"), c.req.param("id"));
+    if (!row)
+        return c.json({ error: "Relationship not found" }, 404);
+    return c.json({ data: row });
+})
+    .patch("/person-relationships/:id", async (c) => {
+    const row = await relationshipsService.updatePersonRelationship(c.get("db"), c.req.param("id"), await parseJsonBody(c, updatePersonRelationshipSchema));
+    if (!row)
+        return c.json({ error: "Relationship not found" }, 404);
+    return c.json({ data: row });
+})
+    .delete("/person-relationships/:id", async (c) => {
+    const row = await relationshipsService.deletePersonRelationship(c.get("db"), c.req.param("id"));
+    if (!row)
+        return c.json({ error: "Relationship not found" }, 404);
+    return c.json({ success: true });
+});