@kernhq/module-inventory 0.1.0

package/dist/server/_impl.d.ts

@@ -0,0 +1,427 @@
+import { defineModule, defineServerModule, type Kernel, packageVersion, type RequestContext } from '@kernhq/kernel';
+/**
+ * The router, kept apart from `index.ts` so `module.test.ts` can walk it without booting a kernel.
+ *
+ * Two middlewares on every procedure, and the test fails if either is missing:
+ * `workspaceScoped` (a real membership, and the module switched on for that workspace) and
+ * `requires` (the permission this particular call needs).
+ */
+export { defineModule, defineServerModule, packageVersion };
+export declare function implement_(kernel: Kernel): {
+    assets: {
+        list: import("@orpc/server").Procedure<import("@orpc/server").MergedInitialContext<RequestContext & Record<never, never>, RequestContext & Record<never, never> & Omit<RequestContext & Record<never, never>, keyof RequestContext> & Omit<RequestContext & Record<never, never>, "workspaceId" | "kernel" | "principal" | "requestId" | "ip" | "headers">, RequestContext>, Omit<import("@orpc/server").MergedCurrentContext<RequestContext, {
+            workspaceId: string;
+            kernel: Kernel;
+            principal: {
+                kind: "service" | "user" | "api_key" | "anonymous";
+                userId: (string & import("zod").$brand<"UserId">) | null;
+                email: string | null;
+                name: string | null;
+                locale: "en" | "fa" | "ar" | "de";
+                instanceAdmin: boolean;
+                service: string | null;
+                memberships: {
+                    workspaceId: string & import("zod").$brand<"WorkspaceId">;
+                    role: "owner" | "admin" | "member" | "guest";
+                    roleIds: string[];
+                    groupIds: string[];
+                    status: "active" | "invited" | "suspended";
+                }[];
+                permissionVersion: number;
+            };
+            requestId: string;
+            ip: string;
+            headers: Record<string, string | string[] | undefined>;
+        }>, never> & Record<never, never>, import("zod").ZodObject<{
+            workspaceId: import("zod/v4/core").$ZodBranded<import("zod").ZodUUID, "WorkspaceId", "out">;
+            q: import("zod").ZodOptional<import("zod").ZodString>;
+            categoryId: import("zod").ZodOptional<import("zod").ZodUUID>;
+            status: import("zod").ZodOptional<import("zod").ZodEnum<{
+                in_stock: "in_stock";
+                assigned: "assigned";
+                under_repair: "under_repair";
+                retired: "retired";
+            }>>;
+            sort: import("zod").ZodDefault<import("zod").ZodEnum<{
+                code: "code";
+                name: "name";
+                recent: "recent";
+            }>>;
+            cursor: import("zod").ZodOptional<import("zod").ZodString>;
+            limit: import("zod").ZodDefault<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            items: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodUUID;
+                workspaceId: import("zod/v4/core").$ZodBranded<import("zod").ZodUUID, "WorkspaceId", "out">;
+                code: import("zod").ZodString;
+                name: import("zod").ZodString;
+                description: import("zod").ZodString;
+                categoryId: import("zod").ZodNullable<import("zod").ZodUUID>;
+                status: import("zod").ZodEnum<{
+                    in_stock: "in_stock";
+                    assigned: "assigned";
+                    under_repair: "under_repair";
+                    retired: "retired";
+                }>;
+                custodianUserId: import("zod").ZodNullable<import("zod").ZodUUID>;
+                custodySince: import("zod").ZodNullable<import("zod").ZodString>;
+                serialNumber: import("zod").ZodNullable<import("zod").ZodString>;
+                location: import("zod").ZodNullable<import("zod").ZodString>;
+                purchasedOn: import("zod").ZodNullable<import("zod").ZodString>;
+                purchasedFrom: import("zod").ZodNullable<import("zod").ZodString>;
+                priceMinor: import("zod").ZodNullable<import("zod").ZodNumber>;
+                currency: import("zod").ZodNullable<import("zod").ZodString>;
+                warrantyUntil: import("zod").ZodNullable<import("zod").ZodString>;
+                photoFileId: import("zod").ZodNullable<import("zod").ZodUUID>;
+                createdAt: import("zod").ZodString;
+                updatedAt: import("zod").ZodString;
+                archivedAt: import("zod").ZodNullable<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>>;
+            nextCursor: import("zod").ZodNullable<import("zod").ZodString>;
+            total: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>, import("@orpc/server").MergedErrorMap<Record<never, never>, import("@orpc/server").MergedErrorMap<Record<never, never>, {
+            BAD_REQUEST: {
+                data: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+            };
+            UNAUTHORIZED: {};
+            FORBIDDEN: {
+                data: import("zod").ZodOptional<import("zod").ZodObject<{
+                    permission: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>;
+            };
+            NOT_FOUND: {};
+            CONFLICT: {
+                data: import("zod").ZodOptional<import("zod").ZodObject<{
+                    reason: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>;
+            };
+            RATE_LIMITED: {};
+            MODULE_DISABLED: {
+                data: import("zod").ZodObject<{
+                    module: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+            };
+        }>>, Record<never, never>>;
+        get: import("@orpc/server").Procedure<import("@orpc/server").MergedInitialContext<RequestContext & Record<never, never>, RequestContext & Record<never, never> & Omit<RequestContext & Record<never, never>, keyof RequestContext> & Omit<RequestContext & Record<never, never>, "workspaceId" | "kernel" | "principal" | "requestId" | "ip" | "headers">, RequestContext>, Omit<import("@orpc/server").MergedCurrentContext<RequestContext, {
+            workspaceId: string;
+            kernel: Kernel;
+            principal: {
+                kind: "service" | "user" | "api_key" | "anonymous";
+                userId: (string & import("zod").$brand<"UserId">) | null;
+                email: string | null;
+                name: string | null;
+                locale: "en" | "fa" | "ar" | "de";
+                instanceAdmin: boolean;
+                service: string | null;
+                memberships: {
+                    workspaceId: string & import("zod").$brand<"WorkspaceId">;
+                    role: "owner" | "admin" | "member" | "guest";
+                    roleIds: string[];
+                    groupIds: string[];
+                    status: "active" | "invited" | "suspended";
+                }[];
+                permissionVersion: number;
+            };
+            requestId: string;
+            ip: string;
+            headers: Record<string, string | string[] | undefined>;
+        }>, never> & Record<never, never>, import("zod").ZodObject<{
+            workspaceId: import("zod/v4/core").$ZodBranded<import("zod").ZodUUID, "WorkspaceId", "out">;
+            assetId: import("zod").ZodUUID;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            id: import("zod").ZodUUID;
+            workspaceId: import("zod/v4/core").$ZodBranded<import("zod").ZodUUID, "WorkspaceId", "out">;
+            code: import("zod").ZodString;
+            name: import("zod").ZodString;
+            description: import("zod").ZodString;
+            categoryId: import("zod").ZodNullable<import("zod").ZodUUID>;
+            status: import("zod").ZodEnum<{
+                in_stock: "in_stock";
+                assigned: "assigned";
+                under_repair: "under_repair";
+                retired: "retired";
+            }>;
+            custodianUserId: import("zod").ZodNullable<import("zod").ZodUUID>;
+            custodySince: import("zod").ZodNullable<import("zod").ZodString>;
+            serialNumber: import("zod").ZodNullable<import("zod").ZodString>;
+            location: import("zod").ZodNullable<import("zod").ZodString>;
+            purchasedOn: import("zod").ZodNullable<import("zod").ZodString>;
+            purchasedFrom: import("zod").ZodNullable<import("zod").ZodString>;
+            priceMinor: import("zod").ZodNullable<import("zod").ZodNumber>;
+            currency: import("zod").ZodNullable<import("zod").ZodString>;
+            warrantyUntil: import("zod").ZodNullable<import("zod").ZodString>;
+            photoFileId: import("zod").ZodNullable<import("zod").ZodUUID>;
+            createdAt: import("zod").ZodString;
+            updatedAt: import("zod").ZodString;
+            archivedAt: import("zod").ZodNullable<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>, import("@orpc/server").MergedErrorMap<Record<never, never>, import("@orpc/server").MergedErrorMap<Record<never, never>, {
+            BAD_REQUEST: {
+                data: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+            };
+            UNAUTHORIZED: {};
+            FORBIDDEN: {
+                data: import("zod").ZodOptional<import("zod").ZodObject<{
+                    permission: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>;
+            };
+            NOT_FOUND: {};
+            CONFLICT: {
+                data: import("zod").ZodOptional<import("zod").ZodObject<{
+                    reason: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>;
+            };
+            RATE_LIMITED: {};
+            MODULE_DISABLED: {
+                data: import("zod").ZodObject<{
+                    module: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+            };
+        }>>, Record<never, never>>;
+        create: import("@orpc/server").Procedure<import("@orpc/server").MergedInitialContext<RequestContext & Record<never, never>, RequestContext & Record<never, never> & Omit<RequestContext & Record<never, never>, keyof RequestContext> & Omit<RequestContext & Record<never, never>, "workspaceId" | "kernel" | "principal" | "requestId" | "ip" | "headers">, RequestContext>, Omit<import("@orpc/server").MergedCurrentContext<RequestContext, {
+            workspaceId: string;
+            kernel: Kernel;
+            principal: {
+                kind: "service" | "user" | "api_key" | "anonymous";
+                userId: (string & import("zod").$brand<"UserId">) | null;
+                email: string | null;
+                name: string | null;
+                locale: "en" | "fa" | "ar" | "de";
+                instanceAdmin: boolean;
+                service: string | null;
+                memberships: {
+                    workspaceId: string & import("zod").$brand<"WorkspaceId">;
+                    role: "owner" | "admin" | "member" | "guest";
+                    roleIds: string[];
+                    groupIds: string[];
+                    status: "active" | "invited" | "suspended";
+                }[];
+                permissionVersion: number;
+            };
+            requestId: string;
+            ip: string;
+            headers: Record<string, string | string[] | undefined>;
+        }>, never> & Record<never, never>, import("zod").ZodObject<{
+            workspaceId: import("zod/v4/core").$ZodBranded<import("zod").ZodUUID, "WorkspaceId", "out">;
+            name: import("zod").ZodString;
+            description: import("zod").ZodDefault<import("zod").ZodString>;
+            categoryId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodUUID>>;
+            serialNumber: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            location: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            purchasedFrom: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            purchasedOn: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodISODate>>;
+            warrantyUntil: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodISODate>>;
+            priceMinor: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNumber>>;
+            currency: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            id: import("zod").ZodUUID;
+            workspaceId: import("zod/v4/core").$ZodBranded<import("zod").ZodUUID, "WorkspaceId", "out">;
+            code: import("zod").ZodString;
+            name: import("zod").ZodString;
+            description: import("zod").ZodString;
+            categoryId: import("zod").ZodNullable<import("zod").ZodUUID>;
+            status: import("zod").ZodEnum<{
+                in_stock: "in_stock";
+                assigned: "assigned";
+                under_repair: "under_repair";
+                retired: "retired";
+            }>;
+            custodianUserId: import("zod").ZodNullable<import("zod").ZodUUID>;
+            custodySince: import("zod").ZodNullable<import("zod").ZodString>;
+            serialNumber: import("zod").ZodNullable<import("zod").ZodString>;
+            location: import("zod").ZodNullable<import("zod").ZodString>;
+            purchasedOn: import("zod").ZodNullable<import("zod").ZodString>;
+            purchasedFrom: import("zod").ZodNullable<import("zod").ZodString>;
+            priceMinor: import("zod").ZodNullable<import("zod").ZodNumber>;
+            currency: import("zod").ZodNullable<import("zod").ZodString>;
+            warrantyUntil: import("zod").ZodNullable<import("zod").ZodString>;
+            photoFileId: import("zod").ZodNullable<import("zod").ZodUUID>;
+            createdAt: import("zod").ZodString;
+            updatedAt: import("zod").ZodString;
+            archivedAt: import("zod").ZodNullable<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>, import("@orpc/server").MergedErrorMap<Record<never, never>, import("@orpc/server").MergedErrorMap<Record<never, never>, {
+            BAD_REQUEST: {
+                data: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+            };
+            UNAUTHORIZED: {};
+            FORBIDDEN: {
+                data: import("zod").ZodOptional<import("zod").ZodObject<{
+                    permission: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>;
+            };
+            NOT_FOUND: {};
+            CONFLICT: {
+                data: import("zod").ZodOptional<import("zod").ZodObject<{
+                    reason: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>;
+            };
+            RATE_LIMITED: {};
+            MODULE_DISABLED: {
+                data: import("zod").ZodObject<{
+                    module: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+            };
+        }>>, Record<never, never>>;
+        update: import("@orpc/server").Procedure<import("@orpc/server").MergedInitialContext<RequestContext & Record<never, never>, RequestContext & Record<never, never> & Omit<RequestContext & Record<never, never>, keyof RequestContext> & Omit<RequestContext & Record<never, never>, "workspaceId" | "kernel" | "principal" | "requestId" | "ip" | "headers">, RequestContext>, Omit<import("@orpc/server").MergedCurrentContext<RequestContext, {
+            workspaceId: string;
+            kernel: Kernel;
+            principal: {
+                kind: "service" | "user" | "api_key" | "anonymous";
+                userId: (string & import("zod").$brand<"UserId">) | null;
+                email: string | null;
+                name: string | null;
+                locale: "en" | "fa" | "ar" | "de";
+                instanceAdmin: boolean;
+                service: string | null;
+                memberships: {
+                    workspaceId: string & import("zod").$brand<"WorkspaceId">;
+                    role: "owner" | "admin" | "member" | "guest";
+                    roleIds: string[];
+                    groupIds: string[];
+                    status: "active" | "invited" | "suspended";
+                }[];
+                permissionVersion: number;
+            };
+            requestId: string;
+            ip: string;
+            headers: Record<string, string | string[] | undefined>;
+        }>, never> & Record<never, never>, import("zod").ZodObject<{
+            workspaceId: import("zod/v4/core").$ZodBranded<import("zod").ZodUUID, "WorkspaceId", "out">;
+            name: import("zod").ZodOptional<import("zod").ZodString>;
+            description: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodString>>;
+            categoryId: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodUUID>>>;
+            serialNumber: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>>;
+            location: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>>;
+            purchasedFrom: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>>;
+            purchasedOn: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodISODate>>>;
+            warrantyUntil: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodISODate>>>;
+            priceMinor: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNumber>>>;
+            currency: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>>;
+            assetId: import("zod").ZodUUID;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            id: import("zod").ZodUUID;
+            workspaceId: import("zod/v4/core").$ZodBranded<import("zod").ZodUUID, "WorkspaceId", "out">;
+            code: import("zod").ZodString;
+            name: import("zod").ZodString;
+            description: import("zod").ZodString;
+            categoryId: import("zod").ZodNullable<import("zod").ZodUUID>;
+            status: import("zod").ZodEnum<{
+                in_stock: "in_stock";
+                assigned: "assigned";
+                under_repair: "under_repair";
+                retired: "retired";
+            }>;
+            custodianUserId: import("zod").ZodNullable<import("zod").ZodUUID>;
+            custodySince: import("zod").ZodNullable<import("zod").ZodString>;
+            serialNumber: import("zod").ZodNullable<import("zod").ZodString>;
+            location: import("zod").ZodNullable<import("zod").ZodString>;
+            purchasedOn: import("zod").ZodNullable<import("zod").ZodString>;
+            purchasedFrom: import("zod").ZodNullable<import("zod").ZodString>;
+            priceMinor: import("zod").ZodNullable<import("zod").ZodNumber>;
+            currency: import("zod").ZodNullable<import("zod").ZodString>;
+            warrantyUntil: import("zod").ZodNullable<import("zod").ZodString>;
+            photoFileId: import("zod").ZodNullable<import("zod").ZodUUID>;
+            createdAt: import("zod").ZodString;
+            updatedAt: import("zod").ZodString;
+            archivedAt: import("zod").ZodNullable<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>, import("@orpc/server").MergedErrorMap<Record<never, never>, import("@orpc/server").MergedErrorMap<Record<never, never>, {
+            BAD_REQUEST: {
+                data: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+            };
+            UNAUTHORIZED: {};
+            FORBIDDEN: {
+                data: import("zod").ZodOptional<import("zod").ZodObject<{
+                    permission: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>;
+            };
+            NOT_FOUND: {};
+            CONFLICT: {
+                data: import("zod").ZodOptional<import("zod").ZodObject<{
+                    reason: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>;
+            };
+            RATE_LIMITED: {};
+            MODULE_DISABLED: {
+                data: import("zod").ZodObject<{
+                    module: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+            };
+        }>>, Record<never, never>>;
+        archive: import("@orpc/server").Procedure<import("@orpc/server").MergedInitialContext<RequestContext & Record<never, never>, RequestContext & Record<never, never> & Omit<RequestContext & Record<never, never>, keyof RequestContext> & Omit<RequestContext & Record<never, never>, "workspaceId" | "kernel" | "principal" | "requestId" | "ip" | "headers">, RequestContext>, Omit<import("@orpc/server").MergedCurrentContext<RequestContext, {
+            workspaceId: string;
+            kernel: Kernel;
+            principal: {
+                kind: "service" | "user" | "api_key" | "anonymous";
+                userId: (string & import("zod").$brand<"UserId">) | null;
+                email: string | null;
+                name: string | null;
+                locale: "en" | "fa" | "ar" | "de";
+                instanceAdmin: boolean;
+                service: string | null;
+                memberships: {
+                    workspaceId: string & import("zod").$brand<"WorkspaceId">;
+                    role: "owner" | "admin" | "member" | "guest";
+                    roleIds: string[];
+                    groupIds: string[];
+                    status: "active" | "invited" | "suspended";
+                }[];
+                permissionVersion: number;
+            };
+            requestId: string;
+            ip: string;
+            headers: Record<string, string | string[] | undefined>;
+        }>, never> & Record<never, never>, import("zod").ZodObject<{
+            workspaceId: import("zod/v4/core").$ZodBranded<import("zod").ZodUUID, "WorkspaceId", "out">;
+            assetId: import("zod").ZodUUID;
+            archived: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            id: import("zod").ZodUUID;
+            workspaceId: import("zod/v4/core").$ZodBranded<import("zod").ZodUUID, "WorkspaceId", "out">;
+            code: import("zod").ZodString;
+            name: import("zod").ZodString;
+            description: import("zod").ZodString;
+            categoryId: import("zod").ZodNullable<import("zod").ZodUUID>;
+            status: import("zod").ZodEnum<{
+                in_stock: "in_stock";
+                assigned: "assigned";
+                under_repair: "under_repair";
+                retired: "retired";
+            }>;
+            custodianUserId: import("zod").ZodNullable<import("zod").ZodUUID>;
+            custodySince: import("zod").ZodNullable<import("zod").ZodString>;
+            serialNumber: import("zod").ZodNullable<import("zod").ZodString>;
+            location: import("zod").ZodNullable<import("zod").ZodString>;
+            purchasedOn: import("zod").ZodNullable<import("zod").ZodString>;
+            purchasedFrom: import("zod").ZodNullable<import("zod").ZodString>;
+            priceMinor: import("zod").ZodNullable<import("zod").ZodNumber>;
+            currency: import("zod").ZodNullable<import("zod").ZodString>;
+            warrantyUntil: import("zod").ZodNullable<import("zod").ZodString>;
+            photoFileId: import("zod").ZodNullable<import("zod").ZodUUID>;
+            createdAt: import("zod").ZodString;
+            updatedAt: import("zod").ZodString;
+            archivedAt: import("zod").ZodNullable<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>, import("@orpc/server").MergedErrorMap<Record<never, never>, import("@orpc/server").MergedErrorMap<Record<never, never>, {
+            BAD_REQUEST: {
+                data: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+            };
+            UNAUTHORIZED: {};
+            FORBIDDEN: {
+                data: import("zod").ZodOptional<import("zod").ZodObject<{
+                    permission: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>;
+            };
+            NOT_FOUND: {};
+            CONFLICT: {
+                data: import("zod").ZodOptional<import("zod").ZodObject<{
+                    reason: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>;
+            };
+            RATE_LIMITED: {};
+            MODULE_DISABLED: {
+                data: import("zod").ZodObject<{
+                    module: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+            };
+        }>>, Record<never, never>>;
+    };
+};
+//# sourceMappingURL=_impl.d.ts.map

package/dist/server/_impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_impl.d.ts","sourceRoot":"","sources":["../../src/server/_impl.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,kBAAkB,EAElB,KAAK,MAAM,EACX,cAAc,EACd,KAAK,cAAc,EAKpB,MAAM,gBAAgB,CAAA;AAMvB;;;;;;GAMG;AACH,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,cAAc,EAAE,CAAA;AAkD3D,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwMxC"}

package/dist/server/_impl.js

@@ -0,0 +1,204 @@
+import { defineModule, defineServerModule, KernError, packageVersion, requires, uuidv7, workspaceScoped, } from '@kernhq/kernel';
+import { implement } from '@orpc/server';
+import { and, desc, eq, ilike, or, sql } from 'drizzle-orm';
+import { inventoryContract, inventoryEvents, MODULE_ID } from '../contract.js';
+import { assetHistory, assets, counters } from './schema.js';
+/**
+ * The router, kept apart from `index.ts` so `module.test.ts` can walk it without booting a kernel.
+ *
+ * Two middlewares on every procedure, and the test fails if either is missing:
+ * `workspaceScoped` (a real membership, and the module switched on for that workspace) and
+ * `requires` (the permission this particular call needs).
+ */
+export { defineModule, defineServerModule, packageVersion };
+const os = implement(inventoryContract).$context();
+/** The wire shape: drizzle gives Date objects for timestamps, the contract promises ISO strings. */
+function toAsset(row) {
+    return {
+        id: row.id,
+        workspaceId: row.workspaceId,
+        code: row.code,
+        name: row.name,
+        description: row.description,
+        categoryId: row.categoryId,
+        status: row.status,
+        custodianUserId: row.custodianUserId,
+        custodySince: row.custodySince?.toISOString() ?? null,
+        serialNumber: row.serialNumber,
+        location: row.location,
+        purchasedOn: row.purchasedOn ?? null,
+        purchasedFrom: row.purchasedFrom,
+        priceMinor: row.priceMinor,
+        currency: row.currency,
+        warrantyUntil: row.warrantyUntil ?? null,
+        photoFileId: row.photoFileId,
+        createdAt: row.createdAt.toISOString(),
+        updatedAt: row.updatedAt.toISOString(),
+        archivedAt: row.archivedAt?.toISOString() ?? null,
+    };
+}
+/**
+ * The next asset tag for a workspace. One narrow row per workspace and key, incremented under the
+ * insert's conflict lock — two concurrent creates each read the value their own update returned, so
+ * codes stay unique without a retry loop. `INV-0042`, because people say asset tags out loud.
+ */
+async function nextCode(tx, workspaceId) {
+    const [row] = await tx
+        .insert(counters)
+        .values({ workspaceId, key: 'asset_code', value: 1 })
+        .onConflictDoUpdate({
+        target: [counters.workspaceId, counters.key],
+        set: { value: sql `${counters.value} + 1` },
+    })
+        .returning();
+    return `INV-${String(row.value).padStart(4, '0')}`;
+}
+export function implement_(kernel) {
+    const scoped = os.use(workspaceScoped(MODULE_ID));
+    const changed = (workspaceId, id, op) => kernel.realtime.change(workspaceId, { module: MODULE_ID, entity: 'asset', id, op });
+    async function record(tx, input, assetId, actorId, action, changes = [], data) {
+        await tx.insert(assetHistory).values({
+            id: uuidv7(),
+            workspaceId: input.workspaceId,
+            assetId,
+            actorId: actorId ?? null,
+            action,
+            changes,
+            data: data ?? null,
+        });
+    }
+    return os.router({
+        assets: {
+            list: scoped.assets.list.use(requires('inventory.asset.view')).handler(({ input }) => kernel.database.withWorkspace(input.workspaceId, async (tx) => {
+                const filters = [eq(assets.workspaceId, input.workspaceId)];
+                if (input.q) {
+                    // A code is something somebody reads off a sticker; matching name, code and serial
+                    // loosely matters more than word-splitting here. Full-text arrives with the core indexer.
+                    filters.push(or(ilike(assets.name, `%${input.q}%`), ilike(assets.code, `%${input.q}%`), ilike(sql `coalesce(${assets.serialNumber}, '')`, `%${input.q}%`)));
+                }
+                if (input.categoryId)
+                    filters.push(eq(assets.categoryId, input.categoryId));
+                if (input.status)
+                    filters.push(eq(assets.status, input.status));
+                const order = input.sort === 'name' ? assets.name : input.sort === 'code' ? assets.code : desc(assets.createdAt);
+                const rows = await tx
+                    .select()
+                    .from(assets)
+                    .where(and(...filters))
+                    .orderBy(order)
+                    .limit(input.limit);
+                return { items: rows.map(toAsset), nextCursor: null };
+            })),
+            get: scoped.assets.get.use(requires('inventory.asset.view')).handler(({ input }) => kernel.database.withWorkspace(input.workspaceId, async (tx) => {
+                const [row] = await tx
+                    .select()
+                    .from(assets)
+                    .where(and(eq(assets.workspaceId, input.workspaceId), eq(assets.id, input.assetId)));
+                if (!row)
+                    throw KernError.notFound('Asset');
+                return toAsset(row);
+            })),
+            create: scoped.assets.create
+                .use(requires('inventory.asset.manage'))
+                .handler(async ({ input, context }) => {
+                const row = await kernel.database.withWorkspace(input.workspaceId, async (tx) => {
+                    const [r] = await tx
+                        .insert(assets)
+                        .values({
+                        id: uuidv7(),
+                        workspaceId: input.workspaceId,
+                        code: await nextCode(tx, input.workspaceId),
+                        name: input.name,
+                        description: input.description,
+                        categoryId: input.categoryId ?? null,
+                        serialNumber: input.serialNumber ?? null,
+                        location: input.location ?? null,
+                        purchasedFrom: input.purchasedFrom ?? null,
+                        purchasedOn: input.purchasedOn ?? null,
+                        warrantyUntil: input.warrantyUntil ?? null,
+                        priceMinor: input.priceMinor ?? null,
+                        currency: input.currency ?? null,
+                    })
+                        .returning();
+                    await record(tx, input, r.id, context.principal.userId, 'created');
+                    return r;
+                });
+                // Both, every time. The event is for anything that reacts later; the realtime change is
+                // what redraws a screen somebody is looking at now. A mutation that does neither leaves
+                // the rest of the product believing the old answer.
+                await kernel.emit(inventoryEvents.assetCreated, { assetId: row.id, workspaceId: input.workspaceId }, { workspaceId: input.workspaceId, actorId: context.principal.userId });
+                await changed(input.workspaceId, row.id, 'created');
+                return toAsset(row);
+            }),
+            update: scoped.assets.update
+                .use(requires('inventory.asset.manage'))
+                .handler(async ({ input, context }) => {
+                const row = await kernel.database.withWorkspace(input.workspaceId, async (tx) => {
+                    const [prev] = await tx
+                        .select()
+                        .from(assets)
+                        .where(and(eq(assets.workspaceId, input.workspaceId), eq(assets.id, input.assetId)))
+                        .for('update');
+                    if (!prev)
+                        throw KernError.notFound('Asset');
+                    const patch = {
+                        name: input.name ?? prev.name,
+                        description: input.description ?? prev.description,
+                        categoryId: input.categoryId !== undefined ? (input.categoryId ?? null) : prev.categoryId,
+                        serialNumber: input.serialNumber !== undefined ? (input.serialNumber ?? null) : prev.serialNumber,
+                        location: input.location !== undefined ? (input.location ?? null) : prev.location,
+                        purchasedFrom: input.purchasedFrom !== undefined ? (input.purchasedFrom ?? null) : prev.purchasedFrom,
+                        purchasedOn: input.purchasedOn !== undefined ? (input.purchasedOn ?? null) : prev.purchasedOn,
+                        warrantyUntil: input.warrantyUntil !== undefined ? (input.warrantyUntil ?? null) : prev.warrantyUntil,
+                        priceMinor: input.priceMinor !== undefined ? (input.priceMinor ?? null) : prev.priceMinor,
+                        currency: input.currency !== undefined ? (input.currency ?? null) : prev.currency,
+                        updatedAt: new Date(),
+                    };
+                    const [r] = await tx.update(assets).set(patch).where(eq(assets.id, input.assetId)).returning();
+                    // Field-level diffs are the timeline — write only what actually moved.
+                    const fields = [
+                        'name',
+                        'description',
+                        'categoryId',
+                        'serialNumber',
+                        'location',
+                        'purchasedFrom',
+                        'purchasedOn',
+                        'warrantyUntil',
+                        'priceMinor',
+                        'currency',
+                    ];
+                    const iso = (v) => (v instanceof Date ? v.toISOString() : v) ?? null;
+                    const changes = fields
+                        .filter((f) => iso(patch[f]) !== iso(prev[f]))
+                        .map((f) => ({ field: f, from: iso(prev[f]), to: iso(patch[f]) }));
+                    if (changes.length > 0)
+                        await record(tx, input, input.assetId, context.principal.userId, 'updated', changes);
+                    return r;
+                });
+                await kernel.emit(inventoryEvents.assetUpdated, { assetId: row.id, workspaceId: input.workspaceId }, { workspaceId: input.workspaceId, actorId: context.principal.userId });
+                await changed(input.workspaceId, row.id, 'updated');
+                return toAsset(row);
+            }),
+            archive: scoped.assets.archive
+                .use(requires('inventory.asset.manage'))
+                .handler(async ({ input, context }) => {
+                const row = await kernel.database.withWorkspace(input.workspaceId, async (tx) => {
+                    const [r] = await tx
+                        .update(assets)
+                        .set({ archivedAt: input.archived ? new Date() : null, updatedAt: new Date() })
+                        .where(and(eq(assets.workspaceId, input.workspaceId), eq(assets.id, input.assetId)))
+                        .returning();
+                    if (!r)
+                        throw KernError.notFound('Asset');
+                    await record(tx, input, input.assetId, context.principal.userId, input.archived ? 'retired' : 'restored');
+                    return r;
+                });
+                await kernel.emit(inventoryEvents.assetArchived, { assetId: row.id, workspaceId: input.workspaceId }, { workspaceId: input.workspaceId, actorId: context.principal.userId });
+                await changed(input.workspaceId, row.id, 'updated');
+                return toAsset(row);
+            }),
+        },
+    });
+}
+//# sourceMappingURL=_impl.js.map