@voyant-travel/custom-fields 0.2.0

package/dist/runtime-contributor.d.ts

@@ -0,0 +1,10 @@
+import { createCustomFieldTargetRegistry } from "./targets.js";
+interface CustomFieldsRuntimeContributorHost {
+    customFieldTargets?: Parameters<typeof createCustomFieldTargetRegistry>[0];
+    getRuntimePorts?<T>(port: {
+        id: string;
+    }): readonly T[] | Promise<readonly T[]>;
+}
+/** The generic package, not an entity module, provides database-backed definitions. */
+export declare function createCustomFieldsRuntimePortContribution(host?: CustomFieldsRuntimeContributorHost): Readonly<Record<string, unknown>>;
+export {};

package/dist/runtime-contributor.js

@@ -0,0 +1,22 @@
+import { customFieldsRuntimePort, customFieldValueReaderRuntimePort, } from "@voyant-travel/core/runtime-port";
+import { loadCustomFieldRegistry, loadCustomFieldRegistryForWrite } from "./registry.js";
+import { createCustomFieldTargetRegistry } from "./targets.js";
+/** The generic package, not an entity module, provides database-backed definitions. */
+export function createCustomFieldsRuntimePortContribution(host = {}) {
+    const targets = createCustomFieldTargetRegistry(host.customFieldTargets ?? []);
+    const runtime = {
+        resolveRegistry: (db) => loadCustomFieldRegistry(db, targets),
+        resolveRegistryForWrite: (db, entity) => loadCustomFieldRegistryForWrite(db, entity, targets),
+        async resolveVisibleValues(db, entity, entityId, channel) {
+            const readers = await Promise.resolve(host.getRuntimePorts?.(customFieldValueReaderRuntimePort) ??
+                []);
+            for (const reader of readers) {
+                const values = await reader.resolveVisibleValues(db, entity, entityId, channel);
+                if (values)
+                    return values;
+            }
+            return {};
+        },
+    };
+    return { [customFieldsRuntimePort.id]: runtime };
+}

package/dist/runtime-contributor.test.d.ts

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

package/dist/runtime-contributor.test.js

@@ -0,0 +1,30 @@
+import { customFieldsRuntimePort, customFieldValueReaderRuntimePort, } from "@voyant-travel/core/runtime-port";
+import { describe, expect, it } from "vitest";
+import { createCustomFieldsRuntimePortContribution } from "./runtime-contributor.js";
+function runtimePortValues(values) {
+    return values;
+}
+describe("custom-fields runtime value readers", () => {
+    it("delegates visible values to selected entity readers", async () => {
+        const readers = [];
+        const reader = {
+            resolveVisibleValues: (_db, entity) => entity === "person" ? { custom: { loyalty: "gold" } } : undefined,
+        };
+        const runtime = createCustomFieldsRuntimePortContribution({
+            customFieldTargets: [
+                {
+                    id: "person",
+                    namespace: "relationships",
+                    label: "Person",
+                    fieldTypes: ["text"],
+                    capabilities: ["read", "invoice"],
+                    ownerUnitId: "@voyant-travel/relationships",
+                },
+            ],
+            getRuntimePorts: (port) => runtimePortValues(port.id === customFieldValueReaderRuntimePort.id ? readers : []),
+        })[customFieldsRuntimePort.id];
+        readers.push(reader);
+        await expect(runtime.resolveVisibleValues({}, "person", "person_1", "invoice")).resolves.toEqual({ custom: { loyalty: "gold" } });
+        await expect(runtime.resolveVisibleValues({}, "booking", "booking_1", "invoice")).resolves.toEqual({});
+    });
+});

package/dist/schema.d.ts

@@ -0,0 +1,316 @@
+export declare const customFieldTypeEnum: import("drizzle-orm/pg-core").PgEnum<["varchar", "text", "double", "monetary", "date", "boolean", "enum", "set", "json", "address", "phone"]>;
+export declare const customFieldOwnerKindEnum: import("drizzle-orm/pg-core").PgEnum<["platform", "operator", "app"]>;
+export declare const customFieldLifecycleStateEnum: import("drizzle-orm/pg-core").PgEnum<["active", "inactive", "deprecated"]>;
+/**
+ * The table was introduced by Relationships migration history.  This generic
+ * package is its sole runtime/schema access owner from #3398 onward; it does
+ * not replay or mutate that immutable history.
+ */
+export declare const customFieldDefinitions: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "custom_field_definitions";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "custom_field_definitions";
+            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;
+        }, {}, {}>;
+        entityType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "entity_type";
+            tableName: "custom_field_definitions";
+            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;
+        }, {}, {}>;
+        namespace: import("drizzle-orm/pg-core").PgColumn<{
+            name: "namespace";
+            tableName: "custom_field_definitions";
+            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;
+        }, {}, {}>;
+        ownerKind: import("drizzle-orm/pg-core").PgColumn<{
+            name: "owner_kind";
+            tableName: "custom_field_definitions";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "platform" | "operator" | "app";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["platform", "operator", "app"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        ownerId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "owner_id";
+            tableName: "custom_field_definitions";
+            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;
+        }, {}, {}>;
+        lifecycleState: import("drizzle-orm/pg-core").PgColumn<{
+            name: "lifecycle_state";
+            tableName: "custom_field_definitions";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "active" | "inactive" | "deprecated";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["active", "inactive", "deprecated"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        provenance: import("drizzle-orm/pg-core").PgColumn<{
+            name: "provenance";
+            tableName: "custom_field_definitions";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        key: import("drizzle-orm/pg-core").PgColumn<{
+            name: "key";
+            tableName: "custom_field_definitions";
+            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;
+        }, {}, {}>;
+        label: import("drizzle-orm/pg-core").PgColumn<{
+            name: "label";
+            tableName: "custom_field_definitions";
+            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;
+        }, {}, {}>;
+        fieldType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "field_type";
+            tableName: "custom_field_definitions";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "boolean" | "text" | "date" | "monetary" | "json" | "varchar" | "double" | "enum" | "set" | "address" | "phone";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["varchar", "text", "double", "monetary", "date", "boolean", "enum", "set", "json", "address", "phone"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        isRequired: import("drizzle-orm/pg-core").PgColumn<{
+            name: "is_required";
+            tableName: "custom_field_definitions";
+            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;
+        }, {}, {}>;
+        isSearchable: import("drizzle-orm/pg-core").PgColumn<{
+            name: "is_searchable";
+            tableName: "custom_field_definitions";
+            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;
+        }, {}, {}>;
+        isExportable: import("drizzle-orm/pg-core").PgColumn<{
+            name: "is_exportable";
+            tableName: "custom_field_definitions";
+            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;
+        }, {}, {}>;
+        isInvoiceable: import("drizzle-orm/pg-core").PgColumn<{
+            name: "is_invoiceable";
+            tableName: "custom_field_definitions";
+            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;
+        }, {}, {}>;
+        options: import("drizzle-orm/pg-core").PgColumn<{
+            name: "options";
+            tableName: "custom_field_definitions";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: {
+                label: string;
+                value: string;
+            }[];
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: {
+                label: string;
+                value: string;
+            }[];
+        }>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "custom_field_definitions";
+            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: "custom_field_definitions";
+            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;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export type CustomFieldDefinition = typeof customFieldDefinitions.$inferSelect;
+export type NewCustomFieldDefinition = typeof customFieldDefinitions.$inferInsert;

package/dist/schema.js

@@ -0,0 +1,72 @@
+import { typeId } from "@voyant-travel/db/lib/typeid-column";
+import { sql } from "drizzle-orm";
+import { boolean, check, index, jsonb, pgEnum, pgTable, text, timestamp, uniqueIndex, } from "drizzle-orm/pg-core";
+export const customFieldTypeEnum = pgEnum("custom_field_type", [
+    "varchar",
+    "text",
+    "double",
+    "monetary",
+    "date",
+    "boolean",
+    "enum",
+    "set",
+    "json",
+    "address",
+    "phone",
+]);
+export const customFieldOwnerKindEnum = pgEnum("custom_field_owner_kind", [
+    "platform",
+    "operator",
+    "app",
+]);
+export const customFieldLifecycleStateEnum = pgEnum("custom_field_lifecycle_state", [
+    "active",
+    "inactive",
+    "deprecated",
+]);
+/**
+ * The table was introduced by Relationships migration history.  This generic
+ * package is its sole runtime/schema access owner from #3398 onward; it does
+ * not replay or mutate that immutable history.
+ */
+export const customFieldDefinitions = pgTable("custom_field_definitions", {
+    id: typeId("custom_field_definitions"),
+    entityType: text("entity_type").notNull(),
+    namespace: text("namespace").notNull(),
+    ownerKind: customFieldOwnerKindEnum("owner_kind").notNull(),
+    ownerId: text("owner_id"),
+    lifecycleState: customFieldLifecycleStateEnum("lifecycle_state").notNull(),
+    provenance: jsonb("provenance").$type().notNull(),
+    key: text("key").notNull(),
+    label: text("label").notNull(),
+    fieldType: customFieldTypeEnum("field_type").notNull(),
+    isRequired: boolean("is_required").notNull().default(false),
+    isSearchable: boolean("is_searchable").notNull().default(false),
+    isExportable: boolean("is_exportable").notNull().default(true),
+    isInvoiceable: boolean("is_invoiceable").notNull().default(false),
+    options: jsonb("options").$type(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_custom_field_definitions_entity").on(table.entityType),
+    index("idx_custom_field_definitions_entity_label").on(table.entityType, table.label),
+    index("idx_custom_field_definitions_owner").on(table.ownerKind, table.ownerId, table.lifecycleState),
+    index("idx_custom_field_definitions_namespace").on(table.namespace, table.entityType),
+    check("custom_field_definitions_owner_identity", 
+    // agent-quality: raw-sql reviewed -- owner: custom-fields; identifiers are Drizzle-owned columns and all literals are static.
+    sql `(
+        (${table.ownerKind} = 'operator' AND ${table.ownerId} IS NULL AND ${table.namespace} = 'custom')
+        OR (
+          ${table.ownerKind} = 'platform'
+          AND ${table.ownerId} IS NOT NULL
+          AND ${table.namespace} <> 'custom'
+          AND ${table.namespace} NOT LIKE 'app--%'
+        )
+        OR (
+          ${table.ownerKind} = 'app'
+          AND ${table.ownerId} IS NOT NULL
+          AND ${table.namespace} LIKE 'app--%'
+        )
+      )`),
+    uniqueIndex("uidx_custom_field_definitions_namespace_key").on(table.entityType, table.namespace, table.key),
+]);