@voyant-travel/distribution 0.127.0 → 0.127.1

package/dist/booking-extension.d.ts

@@ -79,7 +79,7 @@ export declare const bookingDistributionDetails: import("drizzle-orm/pg-core").P
             tableName: "booking_distribution_details";
             dataType: "string";
             columnType: "PgEnumColumn";
-            data: "split" | "operator" | "channel";
+            data: "operator" | "channel" | "split";
             driverParam: string;
             notNull: true;
             hasDefault: true;
@@ -135,9 +135,9 @@ declare const bookingDistributionDetailSchema: z.ZodObject<{
     sourceChannelId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
     fxRateSetId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
     paymentOwner: z.ZodDefault<z.ZodEnum<{
-        split: "split";
         operator: "operator";
         channel: "channel";
+        split: "split";
     }>>;
 }, z.core.$strip>;
 export declare const bookingDistributionExtensionService: {
@@ -146,18 +146,18 @@ export declare const bookingDistributionExtensionService: {
         marketId: string | null;
         sourceChannelId: string | null;
         fxRateSetId: string | null;
-        paymentOwner: "split" | "operator" | "channel";
+        paymentOwner: "operator" | "channel" | "split";
         createdAt: Date;
         updatedAt: Date;
     } | null>;
     upsert(db: PostgresJsDatabase, bookingId: string, data: z.infer<typeof bookingDistributionDetailSchema>): Promise<{
-        createdAt: Date;
-        updatedAt: Date;
         bookingId: string;
         marketId: string | null;
         sourceChannelId: string | null;
         fxRateSetId: string | null;
-        paymentOwner: "split" | "operator" | "channel";
+        paymentOwner: "operator" | "channel" | "split";
+        createdAt: Date;
+        updatedAt: Date;
     } | null>;
     remove(db: PostgresJsDatabase, bookingId: string): Promise<{
         bookingId: string;

package/dist/booking-extension.js

@@ -98,5 +98,5 @@ const distributionBookingExtensionDef = {
 };
 export const distributionBookingExtension = {
     extension: distributionBookingExtensionDef,
-    routes: bookingDistributionExtensionRoutes,
+    adminRoutes: bookingDistributionExtensionRoutes,
 };

package/dist/external-refs/index.js

@@ -5,7 +5,7 @@ export const externalRefsModule = {
 };
 export const externalRefsHonoModule = {
     module: externalRefsModule,
-    routes: externalRefsRoutes,
+    adminRoutes: externalRefsRoutes,
 };
 export { externalRefStatusEnum, externalRefs } from "./schema.js";
 export { externalRefListQuerySchema, externalRefStatusSchema, insertExternalRefForEntitySchema, insertExternalRefSchema, selectExternalRefSchema, updateExternalRefSchema, } from "./validation.js";

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

@@ -1,3 +1,18 @@
+/**
+ * External-reference admin routes — the cross-system id mapping registry
+ * (`external_refs`): list/create/get/patch/delete plus the entity-scoped
+ * list/create legs. Migrated to `@hono/zod-openapi` for the OpenAPI admin
+ * backfill (voyant#2114 — distribution sub-batch) via the same NON-BREAKING
+ * dual-mount: the exported `externalRefsRoutes` `OpenAPIHono` instance is
+ * mounted by the framework on BOTH the legacy `/v1/external-refs/*` surface (the
+ * dashboard still calls those paths) AND the documented staff surface at
+ * `/v1/admin/external-refs/*` (see `external-refs/index.ts`). Request schemas
+ * reuse the exported `validation.ts` schemas; the response row schema is
+ * authored from the Drizzle `$inferSelect` shape (§17 timestamps → strings).
+ * Handlers read `c.req.valid(...)`; the entity-scoped list still re-parses the
+ * merged params via the full list-query schema.
+ */
+import { OpenAPIHono } from "@hono/zod-openapi";
 import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
 type Env = {
     Variables: {
@@ -5,10 +20,22 @@ type Env = {
         userId?: string;
     };
 };
-export declare const externalRefsRoutes: import("hono/hono-base").HonoBase<Env, {
+export declare const externalRefsRoutes: OpenAPIHono<Env, {
     "/refs": {
         $get: {
-            input: {};
+            input: {
+                query: {
+                    limit?: unknown;
+                    offset?: unknown;
+                    entityType?: string | undefined;
+                    entityId?: string | undefined;
+                    sourceSystem?: string | undefined;
+                    objectType?: string | undefined;
+                    namespace?: string | undefined;
+                    status?: "active" | "inactive" | "archived" | undefined;
+                    search?: string | undefined;
+                };
+            };
             output: {
                 data: {
                     id: string;
@@ -33,51 +60,75 @@ export declare const externalRefsRoutes: import("hono/hono-base").HonoBase<Env,
                 offset: number;
             };
             outputFormat: "json";
-            status: import("hono/utils/http-status").ContentfulStatusCode;
+            status: 200;
         };
     };
 } & {
     "/refs": {
         $post: {
-            input: {};
+            input: {
+                json: {
+                    entityType: string;
+                    entityId: string;
+                    sourceSystem: string;
+                    objectType: string;
+                    externalId: string;
+                    namespace?: string | undefined;
+                    externalParentId?: string | null | undefined;
+                    isPrimary?: boolean | undefined;
+                    status?: "active" | "inactive" | "archived" | undefined;
+                    lastSyncedAt?: string | null | undefined;
+                    metadata?: Record<string, unknown> | null | undefined;
+                };
+            };
             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;
-                    status: "active" | "inactive" | "archived";
-                    id: string;
                     createdAt: string;
                     updatedAt: string;
+                };
+            };
+            outputFormat: "json";
+            status: 201;
+        } | {
+            input: {
+                json: {
                     entityType: string;
                     entityId: string;
-                    isPrimary: boolean;
-                    lastSyncedAt: string | null;
                     sourceSystem: string;
                     objectType: string;
                     externalId: string;
-                    externalParentId: string | null;
-                } | null;
+                    namespace?: string | undefined;
+                    externalParentId?: string | null | undefined;
+                    isPrimary?: boolean | undefined;
+                    status?: "active" | "inactive" | "archived" | undefined;
+                    lastSyncedAt?: string | null | undefined;
+                    metadata?: Record<string, unknown> | null | undefined;
+                };
+            };
+            output: {
+                error: string;
             };
             outputFormat: "json";
-            status: 201;
+            status: 400;
         };
     };
 } & {
     "/refs/:id": {
         $get: {
-            input: {
-                param: {
-                    id: string;
-                };
-            };
-            output: {
-                error: string;
-            };
-            outputFormat: "json";
-            status: 404;
-        } | {
             input: {
                 param: {
                     id: string;
@@ -104,7 +155,18 @@ export declare const externalRefsRoutes: import("hono/hono-base").HonoBase<Env,
                 };
             };
             outputFormat: "json";
-            status: import("hono/utils/http-status").ContentfulStatusCode;
+            status: 200;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
         };
     };
 } & {
@@ -114,6 +176,45 @@ export declare const externalRefsRoutes: import("hono/hono-base").HonoBase<Env,
                 param: {
                     id: string;
                 };
+            } & {
+                json: {
+                    entityType?: string | undefined;
+                    entityId?: string | undefined;
+                    sourceSystem?: string | undefined;
+                    objectType?: string | undefined;
+                    namespace?: string | undefined;
+                    externalId?: string | undefined;
+                    externalParentId?: string | null | undefined;
+                    isPrimary?: boolean | undefined;
+                    status?: "active" | "inactive" | "archived" | undefined;
+                    lastSyncedAt?: string | null | undefined;
+                    metadata?: Record<string, unknown> | null | undefined;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            } & {
+                json: {
+                    entityType?: string | undefined;
+                    entityId?: string | undefined;
+                    sourceSystem?: string | undefined;
+                    objectType?: string | undefined;
+                    namespace?: string | undefined;
+                    externalId?: string | undefined;
+                    externalParentId?: string | null | undefined;
+                    isPrimary?: boolean | undefined;
+                    status?: "active" | "inactive" | "archived" | undefined;
+                    lastSyncedAt?: string | null | undefined;
+                    metadata?: Record<string, unknown> | null | undefined;
+                };
             };
             output: {
                 error: string;
@@ -125,6 +226,20 @@ export declare const externalRefsRoutes: import("hono/hono-base").HonoBase<Env,
                 param: {
                     id: string;
                 };
+            } & {
+                json: {
+                    entityType?: string | undefined;
+                    entityId?: string | undefined;
+                    sourceSystem?: string | undefined;
+                    objectType?: string | undefined;
+                    namespace?: string | undefined;
+                    externalId?: string | undefined;
+                    externalParentId?: string | null | undefined;
+                    isPrimary?: boolean | undefined;
+                    status?: "active" | "inactive" | "archived" | undefined;
+                    lastSyncedAt?: string | null | undefined;
+                    metadata?: Record<string, unknown> | null | undefined;
+                };
             };
             output: {
                 data: {
@@ -147,7 +262,7 @@ export declare const externalRefsRoutes: import("hono/hono-base").HonoBase<Env,
                 };
             };
             outputFormat: "json";
-            status: import("hono/utils/http-status").ContentfulStatusCode;
+            status: 200;
         };
     };
 } & {
@@ -173,7 +288,7 @@ export declare const externalRefsRoutes: import("hono/hono-base").HonoBase<Env,
                 success: true;
             };
             outputFormat: "json";
-            status: import("hono/utils/http-status").ContentfulStatusCode;
+            status: 200;
         };
     };
 } & {
@@ -182,9 +297,20 @@ export declare const externalRefsRoutes: import("hono/hono-base").HonoBase<Env,
             input: {
                 param: {
                     entityType: string;
-                } & {
                     entityId: string;
                 };
+            } & {
+                query: {
+                    limit?: unknown;
+                    offset?: unknown;
+                    entityType?: string | undefined;
+                    entityId?: string | undefined;
+                    sourceSystem?: string | undefined;
+                    objectType?: string | undefined;
+                    namespace?: string | undefined;
+                    status?: "active" | "inactive" | "archived" | undefined;
+                    search?: string | undefined;
+                };
             };
             output: {
                 data: {
@@ -210,7 +336,7 @@ export declare const externalRefsRoutes: import("hono/hono-base").HonoBase<Env,
                 offset: number;
             };
             outputFormat: "json";
-            status: import("hono/utils/http-status").ContentfulStatusCode;
+            status: 200;
         };
     };
 } & {
@@ -219,35 +345,70 @@ export declare const externalRefsRoutes: import("hono/hono-base").HonoBase<Env,
             input: {
                 param: {
                     entityType: string;
-                } & {
                     entityId: string;
                 };
+            } & {
+                json: {
+                    sourceSystem: string;
+                    objectType: string;
+                    externalId: string;
+                    metadata?: Record<string, unknown> | null | undefined;
+                    status?: "active" | "inactive" | "archived" | undefined;
+                    lastSyncedAt?: string | null | undefined;
+                    namespace?: string | undefined;
+                    externalParentId?: string | null | undefined;
+                    isPrimary?: boolean | undefined;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    entityType: string;
+                    entityId: string;
+                };
+            } & {
+                json: {
+                    sourceSystem: string;
+                    objectType: string;
+                    externalId: string;
+                    metadata?: Record<string, unknown> | null | undefined;
+                    status?: "active" | "inactive" | "archived" | undefined;
+                    lastSyncedAt?: string | null | undefined;
+                    namespace?: string | undefined;
+                    externalParentId?: string | null | undefined;
+                    isPrimary?: boolean | undefined;
+                };
             };
             output: {
                 data: {
-                    namespace: string;
-                    metadata: {
-                        [x: string]: import("hono/utils/types").JSONValue;
-                    } | null;
-                    status: "active" | "inactive" | "archived";
                     id: string;
-                    createdAt: string;
-                    updatedAt: string;
                     entityType: string;
                     entityId: string;
-                    isPrimary: boolean;
-                    lastSyncedAt: string | null;
                     sourceSystem: string;
                     objectType: string;
+                    namespace: string;
                     externalId: string;
                     externalParentId: string | null;
-                } | 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: 201;
         };
     };
-}, "/", "/entities/:entityType/:entityId/refs">;
+}, "/">;
 export type ExternalRefsRoutes = typeof externalRefsRoutes;
 export {};
 //# sourceMappingURL=routes.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../src/external-refs/routes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAe,WAAW,EAAK,MAAM,mBAAmB,CAAA;AAG/D,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;AA8HD,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4C3B,CAAA;AAEJ,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAA"}

package/dist/external-refs/routes.js

@@ -1,52 +1,171 @@
-import { parseJsonBody, parseQuery } from "@voyant-travel/hono";
-import { Hono } from "hono";
+/**
+ * External-reference admin routes — the cross-system id mapping registry
+ * (`external_refs`): list/create/get/patch/delete plus the entity-scoped
+ * list/create legs. Migrated to `@hono/zod-openapi` for the OpenAPI admin
+ * backfill (voyant#2114 — distribution sub-batch) via the same NON-BREAKING
+ * dual-mount: the exported `externalRefsRoutes` `OpenAPIHono` instance is
+ * mounted by the framework on BOTH the legacy `/v1/external-refs/*` surface (the
+ * dashboard still calls those paths) AND the documented staff surface at
+ * `/v1/admin/external-refs/*` (see `external-refs/index.ts`). Request schemas
+ * reuse the exported `validation.ts` schemas; the response row schema is
+ * authored from the Drizzle `$inferSelect` shape (§17 timestamps → strings).
+ * Handlers read `c.req.valid(...)`; the entity-scoped list still re-parses the
+ * merged params via the full list-query schema.
+ */
+import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
+import { openApiValidationHook } from "@voyant-travel/hono";
+import { listResponseSchema } from "@voyant-travel/types";
 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);
+import { externalRefListQuerySchema, externalRefStatusSchema, insertExternalRefForEntitySchema, insertExternalRefSchema, updateExternalRefSchema, } from "./validation.js";
+const jsonContent = (schema) => ({
+    content: { "application/json": { schema } },
+});
+const requiredJsonBody = (schema) => ({
+    body: { required: true, content: { "application/json": { schema } } },
+});
+const errorResponseSchema = z.object({ error: z.string() });
+const successResponseSchema = z.object({ success: z.literal(true) });
+const idParamSchema = z.object({ id: z.string() });
+const entityParamSchema = z.object({ entityType: z.string(), entityId: z.string() });
+// §17: `timestamp` columns are serialized to ISO strings over the wire.
+const externalRefSchema = z.object({
+    id: z.string(),
+    entityType: z.string(),
+    entityId: z.string(),
+    sourceSystem: z.string(),
+    objectType: z.string(),
+    namespace: z.string(),
+    externalId: z.string(),
+    externalParentId: z.string().nullable(),
+    isPrimary: z.boolean(),
+    status: externalRefStatusSchema,
+    lastSyncedAt: z.string().nullable(),
+    metadata: z.record(z.string(), z.unknown()).nullable(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+});
+const listExternalRefsRoute = createRoute({
+    method: "get",
+    path: "/refs",
+    request: { query: externalRefListQuerySchema },
+    responses: {
+        200: {
+            description: "Paginated external references",
+            ...jsonContent(listResponseSchema(externalRefSchema)),
+        },
+    },
+});
+const createExternalRefRoute = createRoute({
+    method: "post",
+    path: "/refs",
+    request: requiredJsonBody(insertExternalRefSchema),
+    responses: {
+        201: {
+            description: "The created external reference",
+            ...jsonContent(z.object({ data: externalRefSchema })),
+        },
+        400: { description: "invalid_request", ...jsonContent(errorResponseSchema) },
+    },
+});
+const getExternalRefRoute = createRoute({
+    method: "get",
+    path: "/refs/{id}",
+    request: { params: idParamSchema },
+    responses: {
+        200: {
+            description: "An external reference by id",
+            ...jsonContent(z.object({ data: externalRefSchema })),
+        },
+        404: { description: "External reference not found", ...jsonContent(errorResponseSchema) },
+    },
+});
+const updateExternalRefRoute = createRoute({
+    method: "patch",
+    path: "/refs/{id}",
+    request: { params: idParamSchema, ...requiredJsonBody(updateExternalRefSchema) },
+    responses: {
+        200: {
+            description: "The updated external reference",
+            ...jsonContent(z.object({ data: externalRefSchema })),
+        },
+        400: { description: "invalid_request", ...jsonContent(errorResponseSchema) },
+        404: { description: "External reference not found", ...jsonContent(errorResponseSchema) },
+    },
+});
+const deleteExternalRefRoute = createRoute({
+    method: "delete",
+    path: "/refs/{id}",
+    request: { params: idParamSchema },
+    responses: {
+        200: { description: "External reference deleted", ...jsonContent(successResponseSchema) },
+        404: { description: "External reference not found", ...jsonContent(errorResponseSchema) },
+    },
+});
+const listEntityExternalRefsRoute = createRoute({
+    method: "get",
+    path: "/entities/{entityType}/{entityId}/refs",
+    request: {
+        params: entityParamSchema,
+        query: externalRefListQuerySchema.partial(),
+    },
+    responses: {
+        200: {
+            description: "Paginated external references for an entity",
+            ...jsonContent(listResponseSchema(externalRefSchema)),
+        },
+    },
+});
+const createEntityExternalRefRoute = createRoute({
+    method: "post",
+    path: "/entities/{entityType}/{entityId}/refs",
+    request: {
+        params: entityParamSchema,
+        ...requiredJsonBody(insertExternalRefForEntitySchema),
+    },
+    responses: {
+        201: {
+            description: "The created external reference for an entity",
+            ...jsonContent(z.object({ data: externalRefSchema })),
+        },
+        400: { description: "invalid_request", ...jsonContent(errorResponseSchema) },
+    },
+});
+export const externalRefsRoutes = new OpenAPIHono({ defaultHook: openApiValidationHook })
+    .openapi(listExternalRefsRoute, async (c) => c.json(await externalRefsService.listExternalRefs(c.get("db"), c.req.valid("query")), 200))
+    .openapi(createExternalRefRoute, async (c) => {
+    const row = await externalRefsService.createExternalRef(c.get("db"), c.req.valid("json"));
+    return c.json({ data: row }, 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 });
+    .openapi(getExternalRefRoute, async (c) => {
+    const row = await externalRefsService.getExternalRefById(c.get("db"), c.req.valid("param").id);
+    return row ? c.json({ data: row }, 200) : c.json({ error: "External reference not found" }, 404);
 })
-    .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 });
+    .openapi(updateExternalRefRoute, async (c) => {
+    const row = await externalRefsService.updateExternalRef(c.get("db"), c.req.valid("param").id, c.req.valid("json"));
+    return row ? c.json({ data: row }, 200) : c.json({ error: "External reference not found" }, 404);
 })
-    .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 });
+    .openapi(deleteExternalRefRoute, async (c) => {
+    const row = await externalRefsService.deleteExternalRef(c.get("db"), c.req.valid("param").id);
+    return row
+        ? c.json({ success: true }, 200)
+        : c.json({ error: "External reference not found" }, 404);
 })
-    .get("/entities/:entityType/:entityId/refs", async (c) => {
-    const params = c.req.param();
+    .openapi(listEntityExternalRefsRoute, async (c) => {
+    const params = c.req.valid("param");
     const query = externalRefListQuerySchema.parse({
-        ...(await parseQuery(c, externalRefListQuerySchema.partial())),
+        ...c.req.valid("query"),
         entityType: params.entityType,
         entityId: params.entityId,
     });
-    return c.json(await externalRefsService.listExternalRefs(c.get("db"), query));
+    return c.json(await externalRefsService.listExternalRefs(c.get("db"), query), 200);
 })
-    .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);
+    .openapi(createEntityExternalRefRoute, async (c) => {
+    const params = c.req.valid("param");
+    const body = c.req.valid("json");
+    const row = await externalRefsService.createExternalRef(c.get("db"), {
+        ...body,
+        entityType: params.entityType,
+        entityId: params.entityId,
+    });
+    return c.json({ data: row }, 201);
 });

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

@@ -43,20 +43,20 @@ export declare const externalRefsService: {
         updatedAt: Date;
     } | null>;
     createExternalRef(db: PostgresJsDatabase, data: CreateExternalRefInput): Promise<{
-        namespace: string;
-        metadata: Record<string, unknown> | null;
-        status: "active" | "inactive" | "archived";
-        id: string;
         createdAt: Date;
         updatedAt: Date;
+        metadata: Record<string, unknown> | null;
+        id: string;
+        status: "active" | "inactive" | "archived";
+        lastSyncedAt: Date | null;
         entityType: string;
         entityId: string;
-        isPrimary: boolean;
-        lastSyncedAt: Date | null;
         sourceSystem: string;
         objectType: string;
+        namespace: string;
         externalId: string;
         externalParentId: string | null;
+        isPrimary: boolean;
     } | null>;
     updateExternalRef(db: PostgresJsDatabase, id: string, data: UpdateExternalRefInput): Promise<{
         id: string;