@voyantjs/external-refs 0.1.0

package/LICENSE

@@ -0,0 +1,109 @@
+# Functional Source License, Version 1.1, Apache 2.0 Future License
+
+## Abbreviation
+
+FSL-1.1-Apache-2.0
+
+## Notice
+
+Copyright 2026 PixelMakers Studio SRL
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly
+display and redistribute the Software for any Permitted Purpose identified
+below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing
+Use means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe
+our patents, the license grant above includes a license under our patents.
+If you make a claim against any party that the Software infringes or
+contributes to the infringement of any patent, then your patent license to
+the Software ends immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives
+of the Software.
+
+If you redistribute any copies, modifications or derivatives of the
+Software, you must include a copy of or a link to these Terms and Conditions
+and not remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A
+PARTICULAR PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO
+THE SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL
+DAMAGES, EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin
+of the Software, you have no right under these Terms and Conditions to use
+our trademarks, trade names, service marks or product names.
+
+---
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software
+under the Apache License, Version 2.0 that is effective on the second
+anniversary of the date we make the Software available. On or after that
+date, you may use the Software under the Apache License, Version 2.0, in
+which case the following will apply:
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not
+use this file except in compliance with the License.
+
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+License for the specific language governing permissions and limitations
+under the License.

package/README.md

@@ -0,0 +1,34 @@
+# @voyantjs/external-refs
+
+External references module for Voyant. Cross-system external identity and mapping layer — correlates Voyant entities with IDs in third-party systems (channels, PMSs, OTAs).
+
+## Install
+
+```bash
+pnpm add @voyantjs/external-refs
+```
+
+## Usage
+
+```typescript
+import { externalRefsModule } from "@voyantjs/external-refs"
+import { createApp } from "@voyantjs/hono"
+
+const app = createApp({
+  modules: [externalRefsModule],
+  // ...
+})
+```
+
+## Exports
+
+| Entry | Description |
+| --- | --- |
+| `.` | Module export |
+| `./schema` | Drizzle tables |
+| `./validation` | Zod schemas |
+| `./routes` | Hono routes |
+
+## License
+
+FSL-1.1-Apache-2.0

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import type { Module } from "@voyantjs/core";
+import type { HonoModule } from "@voyantjs/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/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAGvD,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/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/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: {
+                    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;
+                } | 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: {
+                    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;
+                } | null;
+            };
+            outputFormat: "json";
+            status: 201;
+        };
+    };
+}, "/", "/entities/:entityType/:entityId/refs">;
+export type ExternalRefsRoutes = typeof externalRefsRoutes;
+export {};
+//# sourceMappingURL=routes.d.ts.map

package/dist/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../src/routes.ts"],"names":[],"mappings":"AAAA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+CA2D3B,CAAA;AAEJ,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAA"}

package/dist/routes.js

@@ -0,0 +1,51 @@
+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 = externalRefListQuerySchema.parse(Object.fromEntries(new URL(c.req.url).searchParams));
+    return c.json(await externalRefsService.listExternalRefs(c.get("db"), query));
+})
+    .post("/refs", async (c) => {
+    return c.json({
+        data: await externalRefsService.createExternalRef(c.get("db"), insertExternalRefSchema.parse(await c.req.json())),
+    }, 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"), updateExternalRefSchema.parse(await c.req.json()));
+    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({
+        ...Object.fromEntries(new URL(c.req.url).searchParams),
+        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 = insertExternalRefForEntitySchema.parse(await c.req.json());
+    return c.json({
+        data: await externalRefsService.createExternalRef(c.get("db"), {
+            ...body,
+            entityType: params.entityType,
+            entityId: params.entityId,
+        }),
+    }, 201);
+});

package/dist/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/schema.d.ts.map

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

package/dist/schema.js

@@ -0,0 +1,30 @@
+import { typeId } from "@voyantjs/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_entity").on(table.entityType, table.entityId),
+    index("idx_external_refs_source").on(table.sourceSystem, table.objectType),
+    index("idx_external_refs_external_id").on(table.externalId),
+    index("idx_external_refs_status").on(table.status),
+    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),
+]);

package/dist/service.d.ts

@@ -0,0 +1,82 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { z } from "zod";
+import type { externalRefListQuerySchema, insertExternalRefSchema, updateExternalRefSchema } from "./validation.js";
+type ExternalRefListQuery = z.infer<typeof externalRefListQuerySchema>;
+type CreateExternalRefInput = z.infer<typeof insertExternalRefSchema>;
+type UpdateExternalRefInput = z.infer<typeof updateExternalRefSchema>;
+export declare const externalRefsService: {
+    listExternalRefs(db: PostgresJsDatabase, query: ExternalRefListQuery): Promise<{
+        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: Date | null;
+            metadata: Record<string, unknown> | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getExternalRefById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        entityType: string;
+        entityId: string;
+        sourceSystem: string;
+        objectType: string;
+        namespace: string;
+        externalId: string;
+        externalParentId: string | null;
+        isPrimary: boolean;
+        status: "active" | "inactive" | "archived";
+        lastSyncedAt: Date | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createExternalRef(db: PostgresJsDatabase, data: CreateExternalRefInput): Promise<{
+        id: string;
+        entityType: string;
+        entityId: string;
+        sourceSystem: string;
+        objectType: string;
+        namespace: string;
+        externalId: string;
+        externalParentId: string | null;
+        isPrimary: boolean;
+        status: "active" | "inactive" | "archived";
+        lastSyncedAt: Date | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    updateExternalRef(db: PostgresJsDatabase, id: string, data: UpdateExternalRefInput): Promise<{
+        id: string;
+        entityType: string;
+        entityId: string;
+        sourceSystem: string;
+        objectType: string;
+        namespace: string;
+        externalId: string;
+        externalParentId: string | null;
+        isPrimary: boolean;
+        status: "active" | "inactive" | "archived";
+        lastSyncedAt: Date | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteExternalRef(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+};
+export {};
+//# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAG5B,OAAO,KAAK,EACV,0BAA0B,EAC1B,uBAAuB,EACvB,uBAAuB,EACxB,MAAM,iBAAiB,CAAA;AAExB,KAAK,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AACtE,KAAK,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AACrE,KAAK,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AA4BrE,eAAO,MAAM,mBAAmB;yBACH,kBAAkB,SAAS,oBAAoB;;;;;;;;;;;;;;;;;;;;;2BAiC7C,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;;0BAK/B,kBAAkB,QAAQ,sBAAsB;;;;;;;;;;;;;;;;0BAqBhD,kBAAkB,MAAM,MAAM,QAAQ,sBAAsB;;;;;;;;;;;;;;;;0BA+B5D,kBAAkB,MAAM,MAAM;;;CAO3D,CAAA"}

package/dist/service.js

@@ -0,0 +1,112 @@
+import { and, desc, eq, ilike, ne, sql } from "drizzle-orm";
+import { externalRefs } from "./schema.js";
+function toTimestamp(value) {
+    return value ? new Date(value) : null;
+}
+async function ensurePrimaryRef(db, params) {
+    const conditions = [
+        eq(externalRefs.entityType, params.entityType),
+        eq(externalRefs.entityId, params.entityId),
+        eq(externalRefs.sourceSystem, params.sourceSystem),
+    ];
+    if (params.id)
+        conditions.push(ne(externalRefs.id, params.id));
+    await db
+        .update(externalRefs)
+        .set({ isPrimary: false, updatedAt: new Date() })
+        .where(and(...conditions));
+}
+export const externalRefsService = {
+    async listExternalRefs(db, query) {
+        const conditions = [];
+        if (query.entityType)
+            conditions.push(eq(externalRefs.entityType, query.entityType));
+        if (query.entityId)
+            conditions.push(eq(externalRefs.entityId, query.entityId));
+        if (query.sourceSystem)
+            conditions.push(eq(externalRefs.sourceSystem, query.sourceSystem));
+        if (query.objectType)
+            conditions.push(eq(externalRefs.objectType, query.objectType));
+        if (query.namespace)
+            conditions.push(eq(externalRefs.namespace, query.namespace));
+        if (query.status)
+            conditions.push(eq(externalRefs.status, query.status));
+        if (query.search) {
+            const term = `%${query.search}%`;
+            conditions.push(ilike(externalRefs.externalId, term));
+        }
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        const [data, countResult] = await Promise.all([
+            db
+                .select()
+                .from(externalRefs)
+                .where(where)
+                .limit(query.limit)
+                .offset(query.offset)
+                .orderBy(desc(externalRefs.updatedAt)),
+            db.select({ count: sql `count(*)::int` }).from(externalRefs).where(where),
+        ]);
+        return {
+            data,
+            total: countResult[0]?.count ?? 0,
+            limit: query.limit,
+            offset: query.offset,
+        };
+    },
+    async getExternalRefById(db, id) {
+        const [row] = await db.select().from(externalRefs).where(eq(externalRefs.id, id)).limit(1);
+        return row ?? null;
+    },
+    async createExternalRef(db, data) {
+        if (data.isPrimary) {
+            await ensurePrimaryRef(db, {
+                entityType: data.entityType,
+                entityId: data.entityId,
+                sourceSystem: data.sourceSystem,
+            });
+        }
+        const [row] = await db
+            .insert(externalRefs)
+            .values({
+            ...data,
+            namespace: data.namespace ?? "default",
+            lastSyncedAt: toTimestamp(data.lastSyncedAt),
+        })
+            .returning();
+        return row ?? null;
+    },
+    async updateExternalRef(db, id, data) {
+        const existing = await this.getExternalRefById(db, id);
+        if (!existing)
+            return null;
+        const nextEntityType = data.entityType ?? existing.entityType;
+        const nextEntityId = data.entityId ?? existing.entityId;
+        const nextSourceSystem = data.sourceSystem ?? existing.sourceSystem;
+        if (data.isPrimary) {
+            await ensurePrimaryRef(db, {
+                id,
+                entityType: nextEntityType,
+                entityId: nextEntityId,
+                sourceSystem: nextSourceSystem,
+            });
+        }
+        const [row] = await db
+            .update(externalRefs)
+            .set({
+            ...data,
+            namespace: data.namespace ?? existing.namespace,
+            lastSyncedAt: data.lastSyncedAt === undefined ? undefined : toTimestamp(data.lastSyncedAt),
+            updatedAt: new Date(),
+        })
+            .where(eq(externalRefs.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteExternalRef(db, id) {
+        const [row] = await db
+            .delete(externalRefs)
+            .where(eq(externalRefs.id, id))
+            .returning({ id: externalRefs.id });
+        return row ?? null;
+    },
+};

package/dist/validation.d.ts

@@ -0,0 +1,91 @@
+import { z } from "zod";
+export declare const externalRefStatusSchema: z.ZodEnum<{
+    active: "active";
+    inactive: "inactive";
+    archived: "archived";
+}>;
+export declare const insertExternalRefSchema: z.ZodObject<{
+    entityType: z.ZodString;
+    entityId: z.ZodString;
+    sourceSystem: z.ZodString;
+    objectType: z.ZodString;
+    namespace: z.ZodDefault<z.ZodString>;
+    externalId: z.ZodString;
+    externalParentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    isPrimary: z.ZodDefault<z.ZodBoolean>;
+    status: z.ZodDefault<z.ZodEnum<{
+        active: "active";
+        inactive: "inactive";
+        archived: "archived";
+    }>>;
+    lastSyncedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+export declare const updateExternalRefSchema: z.ZodObject<{
+    entityType: z.ZodOptional<z.ZodString>;
+    entityId: z.ZodOptional<z.ZodString>;
+    sourceSystem: z.ZodOptional<z.ZodString>;
+    objectType: z.ZodOptional<z.ZodString>;
+    namespace: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+    externalId: z.ZodOptional<z.ZodString>;
+    externalParentId: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+    isPrimary: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    status: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+        active: "active";
+        inactive: "inactive";
+        archived: "archived";
+    }>>>;
+    lastSyncedAt: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+    metadata: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>>;
+}, z.core.$strip>;
+export declare const insertExternalRefForEntitySchema: z.ZodObject<{
+    sourceSystem: z.ZodString;
+    objectType: z.ZodString;
+    namespace: z.ZodDefault<z.ZodString>;
+    externalId: z.ZodString;
+    externalParentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    isPrimary: z.ZodDefault<z.ZodBoolean>;
+    status: z.ZodDefault<z.ZodEnum<{
+        active: "active";
+        inactive: "inactive";
+        archived: "archived";
+    }>>;
+    lastSyncedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+export declare const externalRefListQuerySchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    entityType: z.ZodOptional<z.ZodString>;
+    entityId: z.ZodOptional<z.ZodString>;
+    sourceSystem: z.ZodOptional<z.ZodString>;
+    objectType: z.ZodOptional<z.ZodString>;
+    namespace: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        inactive: "inactive";
+        archived: "archived";
+    }>>;
+    search: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const selectExternalRefSchema: z.ZodObject<{
+    entityType: z.ZodString;
+    entityId: z.ZodString;
+    sourceSystem: z.ZodString;
+    objectType: z.ZodString;
+    namespace: z.ZodDefault<z.ZodString>;
+    externalId: z.ZodString;
+    externalParentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    isPrimary: z.ZodDefault<z.ZodBoolean>;
+    status: z.ZodDefault<z.ZodEnum<{
+        active: "active";
+        inactive: "inactive";
+        archived: "archived";
+    }>>;
+    lastSyncedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    id: z.ZodString;
+    createdAt: z.ZodCoercedDate<unknown>;
+    updatedAt: z.ZodCoercedDate<unknown>;
+}, z.core.$strip>;
+//# sourceMappingURL=validation.d.ts.map

package/dist/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,uBAAuB;;;;EAA6C,CAAA;AAqBjF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;iBAAwB,CAAA;AAC5D,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;iBAAkC,CAAA;AACtE,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;iBAG3C,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;iBAQrC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;iBAIlC,CAAA"}

package/dist/validation.js

@@ -0,0 +1,40 @@
+import { typeIdSchema } from "@voyantjs/db/lib/typeid";
+import { z } from "zod";
+export const externalRefStatusSchema = z.enum(["active", "inactive", "archived"]);
+const paginationSchema = z.object({
+    limit: z.coerce.number().int().min(1).max(200).default(50),
+    offset: z.coerce.number().int().min(0).default(0),
+});
+const externalRefCoreSchema = z.object({
+    entityType: z.string().min(1).max(100),
+    entityId: z.string().min(1).max(100),
+    sourceSystem: z.string().min(1).max(100),
+    objectType: z.string().min(1).max(100),
+    namespace: z.string().min(1).max(100).default("default"),
+    externalId: z.string().min(1).max(255),
+    externalParentId: z.string().max(255).nullable().optional(),
+    isPrimary: z.boolean().default(false),
+    status: externalRefStatusSchema.default("active"),
+    lastSyncedAt: z.string().nullable().optional(),
+    metadata: z.record(z.string(), z.unknown()).nullable().optional(),
+});
+export const insertExternalRefSchema = externalRefCoreSchema;
+export const updateExternalRefSchema = externalRefCoreSchema.partial();
+export const insertExternalRefForEntitySchema = externalRefCoreSchema.omit({
+    entityType: true,
+    entityId: true,
+});
+export const externalRefListQuerySchema = paginationSchema.extend({
+    entityType: z.string().max(100).optional(),
+    entityId: z.string().max(100).optional(),
+    sourceSystem: z.string().max(100).optional(),
+    objectType: z.string().max(100).optional(),
+    namespace: z.string().max(100).optional(),
+    status: externalRefStatusSchema.optional(),
+    search: z.string().optional(),
+});
+export const selectExternalRefSchema = externalRefCoreSchema.extend({
+    id: typeIdSchema("external_refs"),
+    createdAt: z.coerce.date(),
+    updatedAt: z.coerce.date(),
+});

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@voyantjs/external-refs",
+  "version": "0.1.0",
+  "license": "FSL-1.1-Apache-2.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./schema": {
+      "types": "./dist/schema.d.ts",
+      "import": "./dist/schema.js"
+    },
+    "./validation": {
+      "types": "./dist/validation.d.ts",
+      "import": "./dist/validation.js"
+    },
+    "./routes": {
+      "types": "./dist/routes.d.ts",
+      "import": "./dist/routes.js"
+    }
+  },
+  "dependencies": {
+    "drizzle-orm": "^0.45.2",
+    "hono": "^4.12.10",
+    "zod": "^4.3.6",
+    "@voyantjs/core": "0.1.0",
+    "@voyantjs/hono": "0.1.0",
+    "@voyantjs/db": "0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^6.0.2",
+    "@voyantjs/voyant-typescript-config": "0.1.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check src/",
+    "test": "vitest run",
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts"
+}