@unifiedcommerce/core 0.0.1

package/dist/interfaces/rest/schemas/inventory.js

@@ -0,0 +1,128 @@
+import { z, createRoute } from "@hono/zod-openapi";
+import { errorResponses } from "./shared";
+// ─── Request Schemas ─────────────────────────────────────────────────────────
+import { InventoryAdjustBodySchema, InventoryReserveBodySchema, InventoryReleaseBodySchema } from "../../../modules/inventory/schemas";
+export { InventoryAdjustBodySchema, InventoryReserveBodySchema, InventoryReleaseBodySchema };
+export const CreateWarehouseBodySchema = z.object({
+    name: z.string().openapi({ example: "Main Warehouse" }),
+    code: z.string().optional().openapi({ example: "WH-MAIN" }),
+    address: z.record(z.string(), z.unknown()).optional(),
+}).openapi("CreateWarehouseRequest");
+// ─── Route Definitions ──────────────────────────────────────────────────────
+export const inventoryCheckRoute = createRoute({
+    method: "get",
+    path: "/check",
+    tags: ["Inventory"],
+    summary: "Check inventory for entities",
+    request: {
+        query: z.object({
+            entityIds: z.string().optional().openapi({ example: "uuid1,uuid2" }),
+        }),
+    },
+    responses: {
+        200: {
+            content: { "application/json": { schema: z.object({ data: z.record(z.string(), z.unknown()) }) } },
+            description: "Inventory levels",
+        },
+    },
+});
+export const listWarehousesRoute = createRoute({
+    method: "get",
+    path: "/warehouses",
+    tags: ["Inventory"],
+    summary: "List all warehouses",
+    responses: {
+        200: {
+            content: { "application/json": { schema: z.object({ data: z.record(z.string(), z.unknown()) }) } },
+            description: "Warehouses",
+        },
+    },
+});
+export const inventoryAdjustRoute = createRoute({
+    method: "post",
+    path: "/adjust",
+    tags: ["Inventory"],
+    summary: "Adjust inventory levels",
+    description: "Adjusts the on-hand quantity for a given entity/variant in a warehouse.",
+    request: {
+        body: {
+            content: {
+                "application/json": { schema: InventoryAdjustBodySchema },
+            },
+            required: true,
+        },
+    },
+    responses: {
+        200: {
+            content: { "application/json": { schema: z.object({ data: z.record(z.string(), z.unknown()) }) } },
+            description: "Inventory adjusted.",
+        },
+        ...errorResponses,
+    },
+});
+export const inventoryReserveRoute = createRoute({
+    method: "post",
+    path: "/reserve",
+    tags: ["Inventory"],
+    summary: "Reserve inventory",
+    description: "Reserves inventory quantity for an order.",
+    request: {
+        body: {
+            content: {
+                "application/json": { schema: InventoryReserveBodySchema },
+            },
+            required: true,
+        },
+    },
+    responses: {
+        200: {
+            content: { "application/json": { schema: z.object({ data: z.object({ reserved: z.literal(true) }) }) } },
+            description: "Inventory reserved.",
+        },
+        ...errorResponses,
+    },
+});
+export const inventoryReleaseRoute = createRoute({
+    method: "post",
+    path: "/release",
+    tags: ["Inventory"],
+    summary: "Release reserved inventory",
+    description: "Releases previously reserved inventory back to available stock.",
+    request: {
+        body: {
+            content: {
+                "application/json": { schema: InventoryReleaseBodySchema },
+            },
+            required: true,
+        },
+    },
+    responses: {
+        200: {
+            content: { "application/json": { schema: z.object({ data: z.object({ released: z.literal(true) }) }) } },
+            description: "Inventory released.",
+        },
+        ...errorResponses,
+    },
+});
+export const createWarehouseRoute = createRoute({
+    method: "post",
+    path: "/warehouses",
+    tags: ["Inventory"],
+    summary: "Create a warehouse",
+    description: "Creates a new warehouse for inventory management.",
+    request: {
+        body: {
+            content: {
+                "application/json": { schema: CreateWarehouseBodySchema },
+            },
+            required: true,
+        },
+    },
+    responses: {
+        201: {
+            content: { "application/json": { schema: z.object({ data: z.record(z.string(), z.unknown()) }) } },
+            description: "Warehouse created.",
+        },
+        ...errorResponses,
+    },
+});

package/dist/interfaces/rest/schemas/media.d.ts

@@ -0,0 +1,303 @@
+import { z } from "@hono/zod-openapi";
+export declare const AttachMediaBodySchema: z.ZodObject<{
+    mediaAssetId: z.ZodString;
+    entityId: z.ZodString;
+    role: z.ZodEnum<{
+        primary: "primary";
+        gallery: "gallery";
+        thumbnail: "thumbnail";
+        video: "video";
+        document: "document";
+    }>;
+    variantId: z.ZodOptional<z.ZodString>;
+    sortOrder: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const getMediaRoute: {
+    method: "get";
+    path: "/{id}";
+    tags: string[];
+    summary: string;
+    request: {
+        params: z.ZodObject<{
+            id: z.ZodUUID;
+        }, z.core.$strip>;
+        query: z.ZodObject<{
+            signed: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    responses: {
+        400: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Business logic error.";
+        };
+        401: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Authentication required.";
+        };
+        403: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Insufficient permissions.";
+        };
+        404: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Resource not found.";
+        };
+        422: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Validation error.";
+        };
+        302: {
+            description: string;
+        };
+    };
+} & {
+    getRoutingPath(): "/:id";
+};
+export declare const deleteMediaRoute: {
+    method: "delete";
+    path: "/{id}";
+    tags: string[];
+    summary: string;
+    request: {
+        params: z.ZodObject<{
+            id: z.ZodUUID;
+        }, z.core.$strip>;
+    };
+    responses: {
+        400: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Business logic error.";
+        };
+        401: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Authentication required.";
+        };
+        403: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Insufficient permissions.";
+        };
+        404: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Resource not found.";
+        };
+        422: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Validation error.";
+        };
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        data: z.ZodObject<{
+                            deleted: z.ZodLiteral<true>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    getRoutingPath(): "/:id";
+};
+export declare const attachMediaRoute: {
+    method: "post";
+    path: "/attach";
+    tags: string[];
+    summary: string;
+    description: string;
+    request: {
+        body: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        mediaAssetId: z.ZodString;
+                        entityId: z.ZodString;
+                        role: z.ZodEnum<{
+                            primary: "primary";
+                            gallery: "gallery";
+                            thumbnail: "thumbnail";
+                            video: "video";
+                            document: "document";
+                        }>;
+                        variantId: z.ZodOptional<z.ZodString>;
+                        sortOrder: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strip>;
+                };
+            };
+            required: true;
+        };
+    };
+    responses: {
+        400: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Business logic error.";
+        };
+        401: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Authentication required.";
+        };
+        403: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Insufficient permissions.";
+        };
+        404: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Resource not found.";
+        };
+        422: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Validation error.";
+        };
+        201: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        data: z.ZodObject<{
+                            attached: z.ZodLiteral<true>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    getRoutingPath(): "/attach";
+};
+//# sourceMappingURL=media.d.ts.map

package/dist/interfaces/rest/schemas/media.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/rest/schemas/media.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAe,MAAM,mBAAmB,CAAC;AAKnD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;iBAMF,CAAC;AAIjC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiBxB,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiB3B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqB3B,CAAC"}

package/dist/interfaces/rest/schemas/media.js

@@ -0,0 +1,69 @@
+import { z, createRoute } from "@hono/zod-openapi";
+import { errorResponses } from "./shared";
+// ─── Request Schema ──────────────────────────────────────────────────────────
+export const AttachMediaBodySchema = z.object({
+    mediaAssetId: z.string().openapi({ example: "asset-uuid" }),
+    entityId: z.string().openapi({ example: "product-uuid" }),
+    role: z.enum(["primary", "gallery", "thumbnail", "video", "document"]).openapi({ example: "primary" }),
+    variantId: z.string().optional(),
+    sortOrder: z.number().optional().openapi({ example: 0 }),
+}).openapi("AttachMediaRequest");
+// ─── Route Definitions ──────────────────────────────────────────────────────
+export const getMediaRoute = createRoute({
+    method: "get",
+    path: "/{id}",
+    tags: ["Media"],
+    summary: "Get a media asset (redirects to URL)",
+    request: {
+        params: z.object({
+            id: z.uuid().openapi({ example: "550e8400-e29b-41d4-a716-446655440000" }),
+        }),
+        query: z.object({
+            signed: z.string().optional().openapi({ example: "true" }),
+        }),
+    },
+    responses: {
+        302: { description: "Redirect to media URL" },
+        ...errorResponses,
+    },
+});
+export const deleteMediaRoute = createRoute({
+    method: "delete",
+    path: "/{id}",
+    tags: ["Media"],
+    summary: "Delete a media asset",
+    request: {
+        params: z.object({
+            id: z.uuid().openapi({ example: "550e8400-e29b-41d4-a716-446655440000" }),
+        }),
+    },
+    responses: {
+        200: {
+            content: { "application/json": { schema: z.object({ data: z.object({ deleted: z.literal(true) }) }) } },
+            description: "Media deleted.",
+        },
+        ...errorResponses,
+    },
+});
+export const attachMediaRoute = createRoute({
+    method: "post",
+    path: "/attach",
+    tags: ["Media"],
+    summary: "Attach a media asset to an entity",
+    description: "Links an uploaded media asset to a catalog entity (product, variant, etc.).",
+    request: {
+        body: {
+            content: {
+                "application/json": { schema: AttachMediaBodySchema },
+            },
+            required: true,
+        },
+    },
+    responses: {
+        201: {
+            content: { "application/json": { schema: z.object({ data: z.object({ attached: z.literal(true) }) }) } },
+            description: "Media attached to entity.",
+        },
+        ...errorResponses,
+    },
+});