@voyant-travel/custom-fields 0.2.0

package/dist/service.test.js

@@ -0,0 +1,251 @@
+import { describe, expect, it, vi } from "vitest";
+import { customFieldDefinitionInputSchema } from "./contracts.js";
+import { createAppCustomFieldDefinitionOwner, createCustomFieldsService, createPlatformCustomFieldDefinitionOwner, } from "./service.js";
+import { createCustomFieldTargetRegistry } from "./targets.js";
+const targets = createCustomFieldTargetRegistry([
+    {
+        id: "booking",
+        namespace: "bookings",
+        label: "Booking",
+        fieldTypes: ["text"],
+        capabilities: ["read", "write"],
+        ownerUnitId: "@voyant-travel/bookings",
+    },
+]);
+const input = customFieldDefinitionInputSchema.parse({
+    entityType: "booking",
+    key: "external_id",
+    label: "External ID",
+    fieldType: "text",
+});
+function postgresStub(implementation) {
+    const db = Object.create(null);
+    Object.assign(db, implementation);
+    if (!("transaction" in db)) {
+        Object.assign(db, {
+            transaction: async (callback) => callback(db),
+        });
+    }
+    return db;
+}
+function insertDb() {
+    const rows = [];
+    return {
+        rows,
+        db: postgresStub({
+            insert: () => ({
+                values: (value) => ({
+                    onConflictDoNothing: () => ({
+                        returning: async () => {
+                            const duplicate = rows.some((row) => row.entityType === value.entityType &&
+                                row.namespace === value.namespace &&
+                                row.key === value.key);
+                            if (duplicate)
+                                return [];
+                            const row = { id: `definition_${rows.length + 1}`, ...value };
+                            rows.push(row);
+                            return [row];
+                        },
+                    }),
+                }),
+            }),
+        }),
+    };
+}
+describe("custom-field definition ownership", () => {
+    it("allows the same key in operator and app namespaces", async () => {
+        const { db, rows } = insertDb();
+        const service = createCustomFieldsService(targets);
+        const app = createAppCustomFieldDefinitionOwner({
+            appId: "app_acme",
+            namespace: "app--acme-7f3",
+        });
+        await service.create(db, input);
+        await service.createForOwner(db, app, input);
+        expect(rows).toEqual(expect.arrayContaining([
+            expect.objectContaining({ namespace: "custom", ownerKind: "operator", ownerId: null }),
+            expect.objectContaining({
+                namespace: "app--acme-7f3",
+                ownerKind: "app",
+                ownerId: "app_acme",
+            }),
+        ]));
+    });
+    it("rejects cross-owner mutation before issuing an update", async () => {
+        const service = createCustomFieldsService(targets);
+        const app = createAppCustomFieldDefinitionOwner({
+            appId: "app_acme",
+            namespace: "app--acme-7f3",
+        });
+        const db = postgresStub({
+            select: () => ({
+                from: () => ({
+                    where: () => ({
+                        for: () => ({
+                            limit: async () => [
+                                {
+                                    id: "definition_1",
+                                    entityType: "booking",
+                                    namespace: "app--other-92c",
+                                    ownerKind: "app",
+                                    ownerId: "app_other",
+                                },
+                            ],
+                        }),
+                    }),
+                }),
+            }),
+            update: () => {
+                throw new Error("must not update a foreign definition");
+            },
+        });
+        await expect(service.updateForOwner(db, app, "definition_1", { label: "Changed" })).rejects.toMatchObject({
+            status: 403,
+            code: "custom_field_definition_read_only",
+        });
+    });
+    it("renames definitions and stored values in one transaction", async () => {
+        const existing = {
+            id: "definition_1",
+            ...input,
+            namespace: "custom",
+            ownerKind: "operator",
+            ownerId: null,
+            lifecycleState: "active",
+        };
+        const renameDefinitionKey = vi.fn(async () => undefined);
+        const tx = postgresStub({
+            select: () => ({
+                from: () => ({
+                    where: () => ({
+                        for: () => ({ limit: async () => [existing] }),
+                    }),
+                }),
+            }),
+            update: () => ({
+                set: (value) => ({
+                    where: () => ({
+                        returning: async () => [{ ...existing, ...value }],
+                    }),
+                }),
+            }),
+        });
+        const transaction = vi.fn(async (callback) => callback(tx));
+        const db = postgresStub({ transaction });
+        const service = createCustomFieldsService(targets, [
+            {
+                supports: (entityType) => entityType === "booking",
+                renameDefinitionKey,
+                deleteDefinitionValues: vi.fn(async () => undefined),
+            },
+        ]);
+        await service.update(db, existing.id, { key: "renamed_external_id" });
+        expect(transaction).toHaveBeenCalledOnce();
+        expect(renameDefinitionKey).toHaveBeenCalledWith(tx, existing, "renamed_external_id");
+    });
+    it("fails closed when multiple lifecycle providers claim one target", async () => {
+        const existing = {
+            id: "definition_1",
+            ...input,
+            namespace: "custom",
+            ownerKind: "operator",
+            ownerId: null,
+            lifecycleState: "active",
+        };
+        const tx = postgresStub({
+            select: () => ({
+                from: () => ({
+                    where: () => ({
+                        for: () => ({ limit: async () => [existing] }),
+                    }),
+                }),
+            }),
+        });
+        const lifecycle = {
+            supports: (entityType) => entityType === "booking",
+            renameDefinitionKey: vi.fn(async () => undefined),
+            deleteDefinitionValues: vi.fn(async () => undefined),
+        };
+        const service = createCustomFieldsService(targets, [lifecycle, lifecycle]);
+        await expect(service.update(postgresStub({
+            transaction: async (callback) => callback(tx),
+        }), existing.id, { key: "renamed_external_id" })).rejects.toThrow(/exactly one.*found 2/);
+        expect(lifecycle.renameDefinitionKey).not.toHaveBeenCalled();
+    });
+    it("maps rename key collisions to the definition conflict response", async () => {
+        const existing = {
+            id: "definition_1",
+            ...input,
+            namespace: "custom",
+            ownerKind: "operator",
+            ownerId: null,
+            lifecycleState: "active",
+        };
+        const tx = postgresStub({
+            select: () => ({
+                from: () => ({
+                    where: () => ({
+                        for: () => ({ limit: async () => [existing] }),
+                    }),
+                }),
+            }),
+            update: () => ({
+                set: () => ({
+                    where: () => ({
+                        returning: async () => {
+                            throw {
+                                code: "23505",
+                                constraint: "uidx_custom_field_definitions_namespace_key",
+                            };
+                        },
+                    }),
+                }),
+            }),
+        });
+        const db = postgresStub({
+            transaction: async (callback) => callback(tx),
+        });
+        const service = createCustomFieldsService(targets, [
+            {
+                supports: (entityType) => entityType === "booking",
+                renameDefinitionKey: vi.fn(async () => undefined),
+                deleteDefinitionValues: vi.fn(async () => undefined),
+            },
+        ]);
+        await expect(service.update(db, existing.id, { key: "duplicate_external_id" })).rejects.toMatchObject({
+            status: 409,
+            code: "duplicate_custom_field_key",
+        });
+    });
+    it("requires a platform-assigned app namespace", () => {
+        expect(() => createAppCustomFieldDefinitionOwner({ appId: "app_acme", namespace: "custom" })).toThrow(/platform-assigned/);
+    });
+    it("derives platform ownership from the selected target", async () => {
+        const { db, rows } = insertDb();
+        const service = createCustomFieldsService(targets);
+        const target = targets.get("booking");
+        expect(target).toBeDefined();
+        if (!target)
+            throw new Error("booking target missing");
+        await service.createForOwner(db, createPlatformCustomFieldDefinitionOwner(target), input);
+        expect(rows).toEqual([
+            expect.objectContaining({
+                namespace: "bookings",
+                ownerKind: "platform",
+                ownerId: "@voyant-travel/bookings",
+            }),
+        ]);
+    });
+    it("rejects a platform owner crossing its graph target boundary", async () => {
+        const { db } = insertDb();
+        const service = createCustomFieldsService(targets);
+        const foreignOwner = createPlatformCustomFieldDefinitionOwner({
+            namespace: "relationships",
+            ownerUnitId: "@voyant-travel/relationships",
+        });
+        await expect(service.createForOwner(db, foreignOwner, input)).rejects.toMatchObject({
+            status: 403,
+            code: "custom_field_definition_read_only",
+        });
+    });
+});

package/dist/target-capabilities.d.ts

@@ -0,0 +1,12 @@
+import type { VoyantGraphCustomFieldTargetDeclaration } from "@voyant-travel/core/project";
+type CustomFieldVisibilityInput = {
+    isSearchable?: boolean;
+    isExportable?: boolean;
+    isInvoiceable?: boolean;
+};
+/**
+ * Target manifests are the authority for whether a definition may participate
+ * in each reader. Unsupported visibility flags are always persisted as false.
+ */
+export declare function normalizeCustomFieldVisibility(target: Pick<VoyantGraphCustomFieldTargetDeclaration, "capabilities"> | undefined, visibility: CustomFieldVisibilityInput): CustomFieldVisibilityInput;
+export {};

package/dist/target-capabilities.js

@@ -0,0 +1,11 @@
+/**
+ * Target manifests are the authority for whether a definition may participate
+ * in each reader. Unsupported visibility flags are always persisted as false.
+ */
+export function normalizeCustomFieldVisibility(target, visibility) {
+    return {
+        isSearchable: target?.capabilities.includes("search") ? visibility.isSearchable : false,
+        isExportable: target?.capabilities.includes("export") ? visibility.isExportable : false,
+        isInvoiceable: target?.capabilities.includes("invoice") ? visibility.isInvoiceable : false,
+    };
+}

package/dist/target-capabilities.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/target-capabilities.test.js

@@ -0,0 +1,10 @@
+import { describe, expect, it } from "vitest";
+import { normalizeCustomFieldVisibility } from "./target-capabilities.js";
+describe("custom-field target capabilities", () => {
+    it("forces unsupported reader visibility flags off", () => {
+        expect(normalizeCustomFieldVisibility({ capabilities: ["read", "write"] }, { isSearchable: true, isExportable: true, isInvoiceable: true })).toEqual({ isSearchable: false, isExportable: false, isInvoiceable: false });
+    });
+    it("preserves flags that the selected target explicitly supports", () => {
+        expect(normalizeCustomFieldVisibility({ capabilities: ["read", "search", "export", "invoice"] }, { isSearchable: true, isExportable: true, isInvoiceable: true })).toEqual({ isSearchable: true, isExportable: true, isInvoiceable: true });
+    });
+});

package/dist/targets.d.ts

@@ -0,0 +1,10 @@
+import type { VoyantGraphCustomFieldTarget } from "@voyant-travel/core/project";
+import type { z } from "zod";
+import { customFieldTypeSchema } from "./contracts.js";
+type CustomFieldType = z.infer<typeof customFieldTypeSchema>;
+export type CustomFieldTarget = Omit<VoyantGraphCustomFieldTarget, "fieldTypes"> & {
+    fieldTypes: readonly CustomFieldType[];
+};
+/** Immutable, selected-graph-derived allowlist used by Settings and the API. */
+export declare function createCustomFieldTargetRegistry(targets: readonly VoyantGraphCustomFieldTarget[]): ReadonlyMap<string, CustomFieldTarget>;
+export {};

package/dist/targets.js

@@ -0,0 +1,17 @@
+import { customFieldTypeSchema } from "./contracts.js";
+/** Immutable, selected-graph-derived allowlist used by Settings and the API. */
+export function createCustomFieldTargetRegistry(targets) {
+    const byId = new Map();
+    for (const target of targets) {
+        if (byId.has(target.id))
+            throw new Error(`duplicate custom-field target "${target.id}"`);
+        byId.set(target.id, Object.freeze({
+            ...target,
+            fieldTypes: Object.freeze([
+                ...new Set(target.fieldTypes.map((fieldType) => customFieldTypeSchema.parse(fieldType))),
+            ].sort()),
+            capabilities: Object.freeze([...new Set(target.capabilities)].sort()),
+        }));
+    }
+    return byId;
+}

package/dist/targets.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/targets.test.js

@@ -0,0 +1,35 @@
+import { describe, expect, it } from "vitest";
+import { createCustomFieldTargetRegistry } from "./targets.js";
+describe("selected custom-field target registry", () => {
+    it("is immutable, de-duplicates types, and rejects duplicate target ownership", () => {
+        const registry = createCustomFieldTargetRegistry([
+            {
+                id: "booking",
+                namespace: "bookings",
+                label: "Booking",
+                fieldTypes: ["text", "text", "boolean"],
+                capabilities: ["read", "write"],
+                ownerUnitId: "@voyant-travel/bookings",
+            },
+        ]);
+        expect(registry.get("booking")?.fieldTypes).toEqual(["boolean", "text"]);
+        expect(() => createCustomFieldTargetRegistry([
+            {
+                id: "booking",
+                namespace: "bookings",
+                label: "Booking",
+                fieldTypes: ["text"],
+                capabilities: ["read"],
+                ownerUnitId: "@voyant-travel/bookings",
+            },
+            {
+                id: "booking",
+                namespace: "orders",
+                label: "Another booking",
+                fieldTypes: ["text"],
+                capabilities: ["read"],
+                ownerUnitId: "@voyant-travel/orders",
+            },
+        ])).toThrow(/duplicate custom-field target/);
+    });
+});

package/dist/value-contracts.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+export declare const upsertCustomFieldValueSchema: z.ZodObject<{
+    entityType: z.ZodString;
+    entityId: z.ZodString;
+    textValue: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    numberValue: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    dateValue: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    booleanValue: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    monetaryValueCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    currencyCode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    jsonValue: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodString>]>>>;
+}, z.core.$strip>;
+export declare const customFieldValueListQuerySchema: z.ZodObject<{
+    entityType: z.ZodOptional<z.ZodString>;
+    entityId: z.ZodOptional<z.ZodString>;
+    definitionId: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+/** Synthetic representation of an entity-column custom-field value. */
+export declare const customFieldValueSchema: z.ZodObject<{
+    id: z.ZodString;
+    definitionId: z.ZodString;
+    entityType: z.ZodString;
+    entityId: z.ZodString;
+    namespace: z.ZodString;
+    key: z.ZodString;
+    textValue: z.ZodNullable<z.ZodString>;
+    numberValue: z.ZodNullable<z.ZodNumber>;
+    dateValue: z.ZodNullable<z.ZodString>;
+    booleanValue: z.ZodNullable<z.ZodBoolean>;
+    monetaryValueCents: z.ZodNullable<z.ZodNumber>;
+    currencyCode: z.ZodNullable<z.ZodString>;
+    jsonValue: z.ZodNullable<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodString>]>>;
+}, z.core.$strip>;
+export type CustomFieldValueListQuery = z.infer<typeof customFieldValueListQuerySchema>;
+export type UpsertCustomFieldValueInput = z.infer<typeof upsertCustomFieldValueSchema>;

package/dist/value-contracts.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+export const upsertCustomFieldValueSchema = z.object({
+    entityType: z.string().min(1),
+    entityId: z.string().min(1),
+    textValue: z.string().nullable().optional(),
+    numberValue: z.number().finite().nullable().optional(),
+    dateValue: z.string().date().nullable().optional(),
+    booleanValue: z.boolean().nullable().optional(),
+    monetaryValueCents: z.number().int().nullable().optional(),
+    currencyCode: z.string().nullable().optional(),
+    jsonValue: z.record(z.string(), z.unknown()).or(z.array(z.string())).nullable().optional(),
+});
+export const customFieldValueListQuerySchema = z.object({
+    entityType: z.string().min(1).optional(),
+    entityId: z.string().min(1).optional(),
+    definitionId: z.string().min(1).optional(),
+    limit: z.coerce.number().int().min(1).max(200).default(50),
+    offset: z.coerce.number().int().min(0).default(0),
+});
+const jsonRecord = z.record(z.string(), z.unknown());
+/** Synthetic representation of an entity-column custom-field value. */
+export const customFieldValueSchema = z.object({
+    id: z.string(),
+    definitionId: z.string(),
+    entityType: z.string(),
+    entityId: z.string(),
+    namespace: z.string(),
+    key: z.string(),
+    textValue: z.string().nullable(),
+    numberValue: z.number().nullable(),
+    dateValue: z.string().nullable(),
+    booleanValue: z.boolean().nullable(),
+    monetaryValueCents: z.number().int().nullable(),
+    currencyCode: z.string().nullable(),
+    jsonValue: z.union([jsonRecord, z.array(z.string())]).nullable(),
+});

package/dist/value-contracts.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/value-contracts.test.js

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest";
+import { upsertCustomFieldValueSchema } from "./value-contracts.js";
+describe("custom-field value contracts", () => {
+    it("requires entity type and entity id", () => {
+        const value = upsertCustomFieldValueSchema.parse({
+            entityType: "organization",
+            entityId: "crm_org_abc",
+            textValue: "hello",
+        });
+        expect(value.entityType).toBe("organization");
+        expect(value.entityId).toBe("crm_org_abc");
+    });
+    it("rejects incomplete value targets", () => {
+        expect(() => upsertCustomFieldValueSchema.parse({ entityId: "crm_org_abc" })).toThrow();
+        expect(() => upsertCustomFieldValueSchema.parse({ entityType: "organization" })).toThrow();
+    });
+    it("accepts finite fractional values for double definitions", () => {
+        expect(upsertCustomFieldValueSchema.parse({
+            entityType: "person",
+            entityId: "pers_1",
+            numberValue: 1.25,
+        }).numberValue).toBe(1.25);
+    });
+});

package/dist/value-mapping.d.ts

@@ -0,0 +1,20 @@
+import type { UpsertCustomFieldValueInput } from "./value-contracts.js";
+/** A custom-field value is addressed by entity, physical namespace, and definition. */
+export declare function syntheticCustomFieldValueId(entityType: string, entityId: string, namespace: string, definitionId: string): string;
+export declare function parseSyntheticCustomFieldValueId(id: string): {
+    entityType: string;
+    entityId: string;
+    namespace: string;
+    definitionId: string;
+} | null;
+export interface TypedCustomFieldValueColumns {
+    textValue: string | null;
+    numberValue: number | null;
+    dateValue: string | null;
+    booleanValue: boolean | null;
+    monetaryValueCents: number | null;
+    currencyCode: string | null;
+    jsonValue: Record<string, unknown> | string[] | null;
+}
+export declare function jsonbValueFromTypedCustomFieldValue(fieldType: string, input: Partial<UpsertCustomFieldValueInput>): unknown;
+export declare function typedCustomFieldValueFromJsonb(fieldType: string, value: unknown): TypedCustomFieldValueColumns;

package/dist/value-mapping.js

@@ -0,0 +1,68 @@
+/** A custom-field value is addressed by entity, physical namespace, and definition. */
+export function syntheticCustomFieldValueId(entityType, entityId, namespace, definitionId) {
+    return `${entityType}::${entityId}::${namespace}::${definitionId}`;
+}
+export function parseSyntheticCustomFieldValueId(id) {
+    const parts = id.split("::");
+    if (parts.length !== 4 || parts.some((part) => part.length === 0))
+        return null;
+    return {
+        entityType: parts[0],
+        entityId: parts[1],
+        namespace: parts[2],
+        definitionId: parts[3],
+    };
+}
+const emptyTypedValue = {
+    textValue: null,
+    numberValue: null,
+    dateValue: null,
+    booleanValue: null,
+    monetaryValueCents: null,
+    currencyCode: null,
+    jsonValue: null,
+};
+export function jsonbValueFromTypedCustomFieldValue(fieldType, input) {
+    switch (fieldType) {
+        case "double":
+            return input.numberValue ?? null;
+        case "date":
+            return input.dateValue ?? null;
+        case "boolean":
+            return input.booleanValue ?? null;
+        case "monetary":
+            return input.monetaryValueCents == null
+                ? null
+                : { amountCents: input.monetaryValueCents, currency: input.currencyCode ?? null };
+        case "set":
+        case "json":
+        case "address":
+            return input.jsonValue ?? null;
+        default:
+            return input.textValue ?? null;
+    }
+}
+export function typedCustomFieldValueFromJsonb(fieldType, value) {
+    switch (fieldType) {
+        case "double":
+            return { ...emptyTypedValue, numberValue: value };
+        case "date":
+            return { ...emptyTypedValue, dateValue: value };
+        case "boolean":
+            return { ...emptyTypedValue, booleanValue: value };
+        case "monetary": {
+            const money = (value ?? {});
+            return {
+                ...emptyTypedValue,
+                monetaryValueCents: money.amountCents ?? null,
+                currencyCode: money.currency ?? null,
+            };
+        }
+        case "set":
+        case "json":
+        case "address":
+            return { ...emptyTypedValue, jsonValue: value };
+        default:
+            return { ...emptyTypedValue, textValue: value };
+    }
+}

package/dist/value-mapping.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/value-mapping.test.js

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+import { jsonbValueFromTypedCustomFieldValue, parseSyntheticCustomFieldValueId, syntheticCustomFieldValueId, typedCustomFieldValueFromJsonb, } from "./value-mapping.js";
+describe("synthetic custom-field value ids", () => {
+    it("round-trips entity, namespace, and definition identity", () => {
+        const id = syntheticCustomFieldValueId("person", "pers_1", "custom", "cfd_2");
+        expect(parseSyntheticCustomFieldValueId(id)).toEqual({
+            entityType: "person",
+            entityId: "pers_1",
+            namespace: "custom",
+            definitionId: "cfd_2",
+        });
+    });
+    it("rejects malformed ids", () => {
+        expect(parseSyntheticCustomFieldValueId("not-an-id")).toBeNull();
+        expect(parseSyntheticCustomFieldValueId("a::b")).toBeNull();
+        expect(parseSyntheticCustomFieldValueId("a::::c")).toBeNull();
+    });
+});
+describe("typed custom-field value conversion", () => {
+    const cases = [
+        { fieldType: "text", input: { textValue: "hi" }, jsonb: "hi" },
+        { fieldType: "varchar", input: { textValue: "v" }, jsonb: "v" },
+        { fieldType: "enum", input: { textValue: "gold" }, jsonb: "gold" },
+        { fieldType: "phone", input: { textValue: "+40123" }, jsonb: "+40123" },
+        { fieldType: "double", input: { numberValue: 42 }, jsonb: 42 },
+        { fieldType: "date", input: { dateValue: "2026-06-17" }, jsonb: "2026-06-17" },
+        { fieldType: "boolean", input: { booleanValue: true }, jsonb: true },
+        {
+            fieldType: "monetary",
+            input: { monetaryValueCents: 1500, currencyCode: "EUR" },
+            jsonb: { amountCents: 1500, currency: "EUR" },
+        },
+        { fieldType: "set", input: { jsonValue: ["a", "b"] }, jsonb: ["a", "b"] },
+        { fieldType: "json", input: { jsonValue: { k: 1 } }, jsonb: { k: 1 } },
+        { fieldType: "address", input: { jsonValue: { city: "Cluj" } }, jsonb: { city: "Cluj" } },
+    ];
+    for (const { fieldType, input, jsonb } of cases) {
+        it(`round-trips ${fieldType}`, () => {
+            expect(jsonbValueFromTypedCustomFieldValue(fieldType, input)).toEqual(jsonb);
+            expect(jsonbValueFromTypedCustomFieldValue(fieldType, typedCustomFieldValueFromJsonb(fieldType, jsonb))).toEqual(jsonb);
+        });
+    }
+});

package/dist/value-service.d.ts

@@ -0,0 +1,29 @@
+import type { CustomFieldValueOperationsRuntime } from "@voyant-travel/core/runtime-port";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { type CustomFieldDefinitionOwner } from "./service.js";
+import type { CustomFieldValueListQuery, UpsertCustomFieldValueInput } from "./value-contracts.js";
+import { type TypedCustomFieldValueColumns } from "./value-mapping.js";
+export type CustomFieldValueRow = {
+    id: string;
+    definitionId: string;
+    entityType: string;
+    entityId: string;
+    namespace: string;
+    key: string;
+} & TypedCustomFieldValueColumns;
+/**
+ * Generic value orchestration. It owns definition authorization and locking,
+ * while additive runtime providers own only queries against their entity tables.
+ */
+export declare function createCustomFieldValueService(operations: readonly CustomFieldValueOperationsRuntime[]): {
+    listForOwner: (db: PostgresJsDatabase, owner: CustomFieldDefinitionOwner, query: CustomFieldValueListQuery) => Promise<{
+        data: CustomFieldValueRow[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    upsertForOwner: (db: PostgresJsDatabase, owner: CustomFieldDefinitionOwner, definitionId: string, input: UpsertCustomFieldValueInput) => Promise<CustomFieldValueRow>;
+    deleteForOwner: (db: PostgresJsDatabase, owner: CustomFieldDefinitionOwner, id: string) => Promise<{
+        id: string;
+    } | null>;
+};