@voyant-travel/distribution 0.109.8

package/dist/external-refs/index.d.ts

@@ -0,0 +1,11 @@
+import type { Module } from "@voyant-travel/core";
+import type { HonoModule } from "@voyant-travel/hono/module";
+import { externalRefsService } from "./service.js";
+export type { ExternalRefsRoutes } from "./routes.js";
+export declare const externalRefsModule: Module;
+export declare const externalRefsHonoModule: HonoModule;
+export type { ExternalRef, NewExternalRef } from "./schema.js";
+export { externalRefStatusEnum, externalRefs } from "./schema.js";
+export { externalRefListQuerySchema, externalRefStatusSchema, insertExternalRefForEntitySchema, insertExternalRefSchema, selectExternalRefSchema, updateExternalRefSchema, } from "./validation.js";
+export { externalRefsService };
+//# sourceMappingURL=index.d.ts.map

package/dist/external-refs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/external-refs/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AACjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AAG5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAElD,YAAY,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAErD,eAAO,MAAM,kBAAkB,EAAE,MAEhC,CAAA;AAED,eAAO,MAAM,sBAAsB,EAAE,UAGpC,CAAA;AAED,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAC9D,OAAO,EAAE,qBAAqB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AACjE,OAAO,EACL,0BAA0B,EAC1B,uBAAuB,EACvB,gCAAgC,EAChC,uBAAuB,EACvB,uBAAuB,EACvB,uBAAuB,GACxB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,mBAAmB,EAAE,CAAA"}

package/dist/external-refs/index.js

@@ -0,0 +1,12 @@
+import { externalRefsRoutes } from "./routes.js";
+import { externalRefsService } from "./service.js";
+export const externalRefsModule = {
+    name: "external-refs",
+};
+export const externalRefsHonoModule = {
+    module: externalRefsModule,
+    routes: externalRefsRoutes,
+};
+export { externalRefStatusEnum, externalRefs } from "./schema.js";
+export { externalRefListQuerySchema, externalRefStatusSchema, insertExternalRefForEntitySchema, insertExternalRefSchema, selectExternalRefSchema, updateExternalRefSchema, } from "./validation.js";
+export { externalRefsService };

package/dist/external-refs/routes.d.ts

@@ -0,0 +1,253 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+type Env = {
+    Variables: {
+        db: PostgresJsDatabase;
+        userId?: string;
+    };
+};
+export declare const externalRefsRoutes: import("hono/hono-base").HonoBase<Env, {
+    "/refs": {
+        $get: {
+            input: {};
+            output: {
+                data: {
+                    id: string;
+                    entityType: string;
+                    entityId: string;
+                    sourceSystem: string;
+                    objectType: string;
+                    namespace: string;
+                    externalId: string;
+                    externalParentId: string | null;
+                    isPrimary: boolean;
+                    status: "active" | "inactive" | "archived";
+                    lastSyncedAt: string | null;
+                    metadata: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | null;
+                    createdAt: string;
+                    updatedAt: string;
+                }[];
+                total: number;
+                limit: number;
+                offset: number;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/refs": {
+        $post: {
+            input: {};
+            output: {
+                data: {
+                    createdAt: string;
+                    updatedAt: string;
+                    metadata: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | null;
+                    id: string;
+                    status: "active" | "inactive" | "archived";
+                    lastSyncedAt: string | null;
+                    entityType: string;
+                    entityId: string;
+                    sourceSystem: string;
+                    objectType: string;
+                    namespace: string;
+                    externalId: string;
+                    externalParentId: string | null;
+                    isPrimary: boolean;
+                } | null;
+            };
+            outputFormat: "json";
+            status: 201;
+        };
+    };
+} & {
+    "/refs/:id": {
+        $get: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    id: string;
+                    entityType: string;
+                    entityId: string;
+                    sourceSystem: string;
+                    objectType: string;
+                    namespace: string;
+                    externalId: string;
+                    externalParentId: string | null;
+                    isPrimary: boolean;
+                    status: "active" | "inactive" | "archived";
+                    lastSyncedAt: string | null;
+                    metadata: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | null;
+                    createdAt: string;
+                    updatedAt: string;
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/refs/:id": {
+        $patch: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    id: string;
+                    entityType: string;
+                    entityId: string;
+                    sourceSystem: string;
+                    objectType: string;
+                    namespace: string;
+                    externalId: string;
+                    externalParentId: string | null;
+                    isPrimary: boolean;
+                    status: "active" | "inactive" | "archived";
+                    lastSyncedAt: string | null;
+                    metadata: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | null;
+                    createdAt: string;
+                    updatedAt: string;
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/refs/: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;
+        };
+    };
+} & {
+    "/entities/:entityType/:entityId/refs": {
+        $get: {
+            input: {
+                param: {
+                    entityType: string;
+                } & {
+                    entityId: string;
+                };
+            };
+            output: {
+                data: {
+                    id: string;
+                    entityType: string;
+                    entityId: string;
+                    sourceSystem: string;
+                    objectType: string;
+                    namespace: string;
+                    externalId: string;
+                    externalParentId: string | null;
+                    isPrimary: boolean;
+                    status: "active" | "inactive" | "archived";
+                    lastSyncedAt: string | null;
+                    metadata: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | null;
+                    createdAt: string;
+                    updatedAt: string;
+                }[];
+                total: number;
+                limit: number;
+                offset: number;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/entities/:entityType/:entityId/refs": {
+        $post: {
+            input: {
+                param: {
+                    entityType: string;
+                } & {
+                    entityId: string;
+                };
+            };
+            output: {
+                data: {
+                    createdAt: string;
+                    updatedAt: string;
+                    metadata: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | null;
+                    id: string;
+                    status: "active" | "inactive" | "archived";
+                    lastSyncedAt: string | null;
+                    entityType: string;
+                    entityId: string;
+                    sourceSystem: string;
+                    objectType: string;
+                    namespace: string;
+                    externalId: string;
+                    externalParentId: string | null;
+                    isPrimary: boolean;
+                } | null;
+            };
+            outputFormat: "json";
+            status: 201;
+        };
+    };
+}, "/", "/entities/:entityType/:entityId/refs">;
+export type ExternalRefsRoutes = typeof externalRefsRoutes;
+export {};
+//# sourceMappingURL=routes.d.ts.map

package/dist/external-refs/routes.d.ts.map

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

package/dist/external-refs/routes.js

@@ -0,0 +1,52 @@
+import { parseJsonBody, parseQuery } from "@voyant-travel/hono";
+import { Hono } from "hono";
+import { externalRefsService } from "./service.js";
+import { externalRefListQuerySchema, insertExternalRefForEntitySchema, insertExternalRefSchema, updateExternalRefSchema, } from "./validation.js";
+export const externalRefsRoutes = new Hono()
+    .get("/refs", async (c) => {
+    const query = await parseQuery(c, externalRefListQuerySchema);
+    return c.json(await externalRefsService.listExternalRefs(c.get("db"), query));
+})
+    .post("/refs", async (c) => {
+    return c.json({
+        data: await externalRefsService.createExternalRef(c.get("db"), await parseJsonBody(c, insertExternalRefSchema)),
+    }, 201);
+})
+    .get("/refs/:id", async (c) => {
+    const row = await externalRefsService.getExternalRefById(c.get("db"), c.req.param("id"));
+    if (!row)
+        return c.json({ error: "External reference not found" }, 404);
+    return c.json({ data: row });
+})
+    .patch("/refs/:id", async (c) => {
+    const row = await externalRefsService.updateExternalRef(c.get("db"), c.req.param("id"), await parseJsonBody(c, updateExternalRefSchema));
+    if (!row)
+        return c.json({ error: "External reference not found" }, 404);
+    return c.json({ data: row });
+})
+    .delete("/refs/:id", async (c) => {
+    const row = await externalRefsService.deleteExternalRef(c.get("db"), c.req.param("id"));
+    if (!row)
+        return c.json({ error: "External reference not found" }, 404);
+    return c.json({ success: true });
+})
+    .get("/entities/:entityType/:entityId/refs", async (c) => {
+    const params = c.req.param();
+    const query = externalRefListQuerySchema.parse({
+        ...(await parseQuery(c, externalRefListQuerySchema.partial())),
+        entityType: params.entityType,
+        entityId: params.entityId,
+    });
+    return c.json(await externalRefsService.listExternalRefs(c.get("db"), query));
+})
+    .post("/entities/:entityType/:entityId/refs", async (c) => {
+    const params = c.req.param();
+    const body = await parseJsonBody(c, insertExternalRefForEntitySchema);
+    return c.json({
+        data: await externalRefsService.createExternalRef(c.get("db"), {
+            ...body,
+            entityType: params.entityType,
+            entityId: params.entityId,
+        }),
+    }, 201);
+});

package/dist/external-refs/schema.d.ts

@@ -0,0 +1,251 @@
+export declare const externalRefStatusEnum: import("drizzle-orm/pg-core").PgEnum<["active", "inactive", "archived"]>;
+export declare const externalRefs: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "external_refs";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "external_refs";
+            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: "external_refs";
+            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;
+        }, {}, {}>;
+        entityId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "entity_id";
+            tableName: "external_refs";
+            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;
+        }, {}, {}>;
+        sourceSystem: import("drizzle-orm/pg-core").PgColumn<{
+            name: "source_system";
+            tableName: "external_refs";
+            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;
+        }, {}, {}>;
+        objectType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "object_type";
+            tableName: "external_refs";
+            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: "external_refs";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        externalId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "external_id";
+            tableName: "external_refs";
+            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;
+        }, {}, {}>;
+        externalParentId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "external_parent_id";
+            tableName: "external_refs";
+            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;
+        }, {}, {}>;
+        isPrimary: import("drizzle-orm/pg-core").PgColumn<{
+            name: "is_primary";
+            tableName: "external_refs";
+            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;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "external_refs";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "active" | "inactive" | "archived";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["active", "inactive", "archived"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastSyncedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_synced_at";
+            tableName: "external_refs";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: import("drizzle-orm/pg-core").PgColumn<{
+            name: "metadata";
+            tableName: "external_refs";
+            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: "external_refs";
+            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: "external_refs";
+            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 ExternalRef = typeof externalRefs.$inferSelect;
+export type NewExternalRef = typeof externalRefs.$inferInsert;
+//# sourceMappingURL=schema.d.ts.map

package/dist/external-refs/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/external-refs/schema.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,qBAAqB,0EAIhC,CAAA;AAEF,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2CxB,CAAA;AAED,MAAM,MAAM,WAAW,GAAG,OAAO,YAAY,CAAC,YAAY,CAAA;AAC1D,MAAM,MAAM,cAAc,GAAG,OAAO,YAAY,CAAC,YAAY,CAAA"}

package/dist/external-refs/schema.js

@@ -0,0 +1,32 @@
+import { typeId } from "@voyant-travel/db/lib/typeid-column";
+import { boolean, index, jsonb, pgEnum, pgTable, text, timestamp, uniqueIndex, } from "drizzle-orm/pg-core";
+export const externalRefStatusEnum = pgEnum("external_ref_status", [
+    "active",
+    "inactive",
+    "archived",
+]);
+export const externalRefs = pgTable("external_refs", {
+    id: typeId("external_refs"),
+    entityType: text("entity_type").notNull(),
+    entityId: text("entity_id").notNull(),
+    sourceSystem: text("source_system").notNull(),
+    objectType: text("object_type").notNull(),
+    namespace: text("namespace").notNull().default("default"),
+    externalId: text("external_id").notNull(),
+    externalParentId: text("external_parent_id"),
+    isPrimary: boolean("is_primary").notNull().default(false),
+    status: externalRefStatusEnum("status").notNull().default("active"),
+    lastSyncedAt: timestamp("last_synced_at", { withTimezone: true }),
+    metadata: jsonb("metadata").$type(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_external_refs_updated").on(table.updatedAt),
+    index("idx_external_refs_entity_updated").on(table.entityType, table.entityId, table.updatedAt),
+    index("idx_external_refs_source_updated").on(table.sourceSystem, table.objectType, table.updatedAt),
+    index("idx_external_refs_namespace_updated").on(table.namespace, table.updatedAt),
+    index("idx_external_refs_external_id").on(table.externalId),
+    index("idx_external_refs_status_updated").on(table.status, table.updatedAt),
+    uniqueIndex("uidx_external_refs_entity_source_external").on(table.entityType, table.entityId, table.sourceSystem, table.namespace, table.externalId),
+    uniqueIndex("uidx_external_refs_source_object_external").on(table.sourceSystem, table.objectType, table.namespace, table.externalId),
+]);