@voyant-travel/inventory 0.1.0

package/dist/service-options.d.ts

@@ -0,0 +1,181 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { z } from "zod";
+import type { insertOptionUnitSchema, insertProductOptionSchema, optionUnitListQuerySchema, productOptionListQuerySchema, updateOptionUnitSchema, updateProductOptionSchema } from "./validation.js";
+type ProductOptionListQuery = z.infer<typeof productOptionListQuerySchema>;
+type CreateProductOptionInput = z.infer<typeof insertProductOptionSchema>;
+type UpdateProductOptionInput = z.infer<typeof updateProductOptionSchema>;
+type OptionUnitListQuery = z.infer<typeof optionUnitListQuerySchema>;
+type CreateOptionUnitInput = z.infer<typeof insertOptionUnitSchema>;
+type UpdateOptionUnitInput = z.infer<typeof updateOptionUnitSchema>;
+export declare const optionProductsService: {
+    listOptions(db: PostgresJsDatabase, query: ProductOptionListQuery): Promise<{
+        data: {
+            id: string;
+            productId: string;
+            name: string;
+            code: string | null;
+            description: string | null;
+            status: "draft" | "active" | "archived";
+            isDefault: boolean;
+            sortOrder: number;
+            availableFrom: string | null;
+            availableTo: string | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getOptionById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        productId: string;
+        name: string;
+        code: string | null;
+        description: string | null;
+        status: "draft" | "active" | "archived";
+        isDefault: boolean;
+        sortOrder: number;
+        availableFrom: string | null;
+        availableTo: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createOption(db: PostgresJsDatabase, productId: string, data: CreateProductOptionInput): Promise<{
+        id: string;
+        name: string;
+        status: "draft" | "active" | "archived";
+        description: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+        code: string | null;
+        productId: string;
+        isDefault: boolean;
+        sortOrder: number;
+        availableFrom: string | null;
+        availableTo: string | null;
+    } | null | undefined>;
+    updateOption(db: PostgresJsDatabase, id: string, data: UpdateProductOptionInput): Promise<{
+        id: string;
+        productId: string;
+        name: string;
+        code: string | null;
+        description: string | null;
+        status: "draft" | "active" | "archived";
+        isDefault: boolean;
+        sortOrder: number;
+        availableFrom: string | null;
+        availableTo: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteOption(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    listUnits(db: PostgresJsDatabase, query: OptionUnitListQuery): Promise<{
+        data: {
+            id: string;
+            optionId: string;
+            name: string;
+            code: string | null;
+            description: string | null;
+            unitType: "other" | "person" | "group" | "room" | "vehicle" | "service";
+            minQuantity: number | null;
+            maxQuantity: number | null;
+            minAge: number | null;
+            maxAge: number | null;
+            occupancyMin: number | null;
+            occupancyMax: number | null;
+            isRequired: boolean;
+            isHidden: boolean;
+            sortOrder: number;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getUnitById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        optionId: string;
+        name: string;
+        code: string | null;
+        description: string | null;
+        unitType: "other" | "person" | "group" | "room" | "vehicle" | "service";
+        minQuantity: number | null;
+        maxQuantity: number | null;
+        minAge: number | null;
+        maxAge: number | null;
+        occupancyMin: number | null;
+        occupancyMax: number | null;
+        isRequired: boolean;
+        isHidden: boolean;
+        sortOrder: number;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    getUnitForProductMutation(db: PostgresJsDatabase, id: string): Promise<{
+        productId: string;
+        id: string;
+        optionId: string;
+        name: string;
+        code: string | null;
+        description: string | null;
+        unitType: "other" | "person" | "group" | "room" | "vehicle" | "service";
+        minQuantity: number | null;
+        maxQuantity: number | null;
+        minAge: number | null;
+        maxAge: number | null;
+        occupancyMin: number | null;
+        occupancyMax: number | null;
+        isRequired: boolean;
+        isHidden: boolean;
+        sortOrder: number;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createUnit(db: PostgresJsDatabase, optionId: string, data: CreateOptionUnitInput): Promise<{
+        id: string;
+        name: string;
+        description: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+        code: string | null;
+        sortOrder: number;
+        optionId: string;
+        unitType: "other" | "person" | "group" | "room" | "vehicle" | "service";
+        minQuantity: number | null;
+        maxQuantity: number | null;
+        minAge: number | null;
+        maxAge: number | null;
+        occupancyMin: number | null;
+        occupancyMax: number | null;
+        isRequired: boolean;
+        isHidden: boolean;
+    } | null | undefined>;
+    updateUnit(db: PostgresJsDatabase, id: string, data: UpdateOptionUnitInput): Promise<{
+        id: string;
+        optionId: string;
+        name: string;
+        code: string | null;
+        description: string | null;
+        unitType: "other" | "person" | "group" | "room" | "vehicle" | "service";
+        minQuantity: number | null;
+        maxQuantity: number | null;
+        minAge: number | null;
+        maxAge: number | null;
+        occupancyMin: number | null;
+        occupancyMax: number | null;
+        isRequired: boolean;
+        isHidden: boolean;
+        sortOrder: number;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteUnit(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+};
+export {};
+//# sourceMappingURL=service-options.d.ts.map

package/dist/service-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-options.d.ts","sourceRoot":"","sources":["../src/service-options.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAE5B,OAAO,KAAK,EACV,sBAAsB,EACtB,yBAAyB,EACzB,yBAAyB,EACzB,4BAA4B,EAC5B,sBAAsB,EACtB,yBAAyB,EAC1B,MAAM,iBAAiB,CAAA;AAGxB,KAAK,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAC1E,KAAK,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AACzE,KAAK,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AACzE,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AACpE,KAAK,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACnE,KAAK,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAEnE,eAAO,MAAM,qBAAqB;oBACV,kBAAkB,SAAS,sBAAsB;;;;;;;;;;;;;;;;;;;sBAgC/C,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;qBAK/B,kBAAkB,aAAa,MAAM,QAAQ,wBAAwB;;;;;;;;;;;;;;qBA0BrE,kBAAkB,MAAM,MAAM,QAAQ,wBAAwB;;;;;;;;;;;;;;qBA2B9D,kBAAkB,MAAM,MAAM;;;kBASjC,kBAAkB,SAAS,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;oBAgC5C,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;;;;;kCAKhB,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;mBAW7C,kBAAkB,YAAY,MAAM,QAAQ,qBAAqB;;;;;;;;;;;;;;;;;;;mBAmBjE,kBAAkB,MAAM,MAAM,QAAQ,qBAAqB;;;;;;;;;;;;;;;;;;;mBAsC3D,kBAAkB,MAAM,MAAM;;;CAQpD,CAAA"}

package/dist/service-options.js

@@ -0,0 +1,179 @@
+import { RequestValidationError } from "@voyant-travel/hono";
+import { and, asc, eq, sql } from "drizzle-orm";
+import { optionUnits, productOptions, products } from "./schema.js";
+import { validateMergedOptionUnit } from "./validation-core.js";
+export const optionProductsService = {
+    async listOptions(db, query) {
+        const conditions = [];
+        if (query.productId) {
+            conditions.push(eq(productOptions.productId, query.productId));
+        }
+        if (query.status) {
+            conditions.push(eq(productOptions.status, query.status));
+        }
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        const [rows, countResult] = await Promise.all([
+            db
+                .select()
+                .from(productOptions)
+                .where(where)
+                .limit(query.limit)
+                .offset(query.offset)
+                .orderBy(asc(productOptions.sortOrder), asc(productOptions.createdAt)),
+            db.select({ count: sql `count(*)::int` }).from(productOptions).where(where),
+        ]);
+        return {
+            data: rows,
+            total: countResult[0]?.count ?? 0,
+            limit: query.limit,
+            offset: query.offset,
+        };
+    },
+    async getOptionById(db, id) {
+        const [row] = await db.select().from(productOptions).where(eq(productOptions.id, id)).limit(1);
+        return row ?? null;
+    },
+    async createOption(db, productId, data) {
+        const [product] = await db
+            .select({ id: products.id })
+            .from(products)
+            .where(eq(products.id, productId))
+            .limit(1);
+        if (!product) {
+            return null;
+        }
+        if (data.isDefault) {
+            await db
+                .update(productOptions)
+                .set({ isDefault: false, updatedAt: new Date() })
+                .where(eq(productOptions.productId, productId));
+        }
+        const [row] = await db
+            .insert(productOptions)
+            .values({ ...data, productId })
+            .returning();
+        return row;
+    },
+    async updateOption(db, id, data) {
+        const [current] = await db
+            .select({ id: productOptions.id, productId: productOptions.productId })
+            .from(productOptions)
+            .where(eq(productOptions.id, id))
+            .limit(1);
+        if (!current) {
+            return null;
+        }
+        if (data.isDefault) {
+            await db
+                .update(productOptions)
+                .set({ isDefault: false, updatedAt: new Date() })
+                .where(eq(productOptions.productId, current.productId));
+        }
+        const [row] = await db
+            .update(productOptions)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(productOptions.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteOption(db, id) {
+        const [row] = await db
+            .delete(productOptions)
+            .where(eq(productOptions.id, id))
+            .returning({ id: productOptions.id });
+        return row ?? null;
+    },
+    async listUnits(db, query) {
+        const conditions = [];
+        if (query.optionId) {
+            conditions.push(eq(optionUnits.optionId, query.optionId));
+        }
+        if (query.unitType) {
+            conditions.push(eq(optionUnits.unitType, query.unitType));
+        }
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        const [rows, countResult] = await Promise.all([
+            db
+                .select()
+                .from(optionUnits)
+                .where(where)
+                .limit(query.limit)
+                .offset(query.offset)
+                .orderBy(asc(optionUnits.sortOrder), asc(optionUnits.createdAt)),
+            db.select({ count: sql `count(*)::int` }).from(optionUnits).where(where),
+        ]);
+        return {
+            data: rows,
+            total: countResult[0]?.count ?? 0,
+            limit: query.limit,
+            offset: query.offset,
+        };
+    },
+    async getUnitById(db, id) {
+        const [row] = await db.select().from(optionUnits).where(eq(optionUnits.id, id)).limit(1);
+        return row ?? null;
+    },
+    async getUnitForProductMutation(db, id) {
+        const [row] = await db
+            .select({ unit: optionUnits, productId: productOptions.productId })
+            .from(optionUnits)
+            .innerJoin(productOptions, eq(optionUnits.optionId, productOptions.id))
+            .where(eq(optionUnits.id, id))
+            .limit(1);
+        return row ? { ...row.unit, productId: row.productId } : null;
+    },
+    async createUnit(db, optionId, data) {
+        const [option] = await db
+            .select({ id: productOptions.id })
+            .from(productOptions)
+            .where(eq(productOptions.id, optionId))
+            .limit(1);
+        if (!option) {
+            return null;
+        }
+        const [row] = await db
+            .insert(optionUnits)
+            .values({ ...data, optionId })
+            .returning();
+        return row;
+    },
+    async updateUnit(db, id, data) {
+        const [existing] = await db
+            .select({
+            unitType: optionUnits.unitType,
+            occupancyMin: optionUnits.occupancyMin,
+            occupancyMax: optionUnits.occupancyMax,
+        })
+            .from(optionUnits)
+            .where(eq(optionUnits.id, id))
+            .limit(1);
+        if (!existing) {
+            return null;
+        }
+        const merged = {
+            unitType: "unitType" in data ? data.unitType : existing.unitType,
+            occupancyMin: "occupancyMin" in data ? data.occupancyMin : existing.occupancyMin,
+            occupancyMax: "occupancyMax" in data ? data.occupancyMax : existing.occupancyMax,
+        };
+        const validation = validateMergedOptionUnit(merged);
+        if (!validation.ok) {
+            const first = validation.issues[0];
+            throw new RequestValidationError(first?.message ?? "Invalid option unit", {
+                issues: validation.issues,
+            });
+        }
+        const [row] = await db
+            .update(optionUnits)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(optionUnits.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteUnit(db, id) {
+        const [row] = await db
+            .delete(optionUnits)
+            .where(eq(optionUnits.id, id))
+            .returning({ id: optionUnits.id });
+        return row ?? null;
+    },
+};

package/dist/service-product-destinations.d.ts

@@ -0,0 +1,37 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { z } from "zod";
+import type { productDestinationListQuerySchema } from "./validation.js";
+type ProductDestinationListQuery = z.infer<typeof productDestinationListQuerySchema>;
+export declare const productDestinationProductsService: {
+    listProductDestinations(db: PostgresJsDatabase, query: ProductDestinationListQuery): Promise<{
+        data: {
+            productId: string;
+            destinationId: string;
+            sortOrder: number;
+            createdAt: Date;
+            updatedAt: Date;
+            destinationSlug: string;
+            destinationType: string;
+            destinationActive: boolean;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    assignProductDestination(db: PostgresJsDatabase, productId: string, input: {
+        destinationId: string;
+        sortOrder?: number;
+    }): Promise<{
+        createdAt: Date;
+        updatedAt: Date;
+        productId: string;
+        sortOrder: number;
+        destinationId: string;
+    } | null>;
+    removeProductDestination(db: PostgresJsDatabase, productId: string, destinationId: string): Promise<{
+        productId: string;
+        destinationId: string;
+    } | null>;
+};
+export {};
+//# sourceMappingURL=service-product-destinations.d.ts.map

package/dist/service-product-destinations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-product-destinations.d.ts","sourceRoot":"","sources":["../src/service-product-destinations.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAE5B,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,iBAAiB,CAAA;AAExE,KAAK,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAYpF,eAAO,MAAM,iCAAiC;gCACV,kBAAkB,SAAS,2BAA2B;;;;;;;;;;;;;;;iCA2ClF,kBAAkB,aACX,MAAM,SACV;QAAE,aAAa,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE;;;;;;;iCAqDnB,kBAAkB,aAAa,MAAM,iBAAiB,MAAM;;;;CAgBhG,CAAA"}

package/dist/service-product-destinations.js

@@ -0,0 +1,94 @@
+import { and, asc, eq, sql } from "drizzle-orm";
+import { destinations, productDestinations, products } from "./schema.js";
+async function ensureProductExists(db, productId) {
+    const [product] = await db
+        .select({ id: products.id })
+        .from(products)
+        .where(eq(products.id, productId))
+        .limit(1);
+    return product ?? null;
+}
+export const productDestinationProductsService = {
+    async listProductDestinations(db, query) {
+        const conditions = [];
+        if (query.productId) {
+            conditions.push(eq(productDestinations.productId, query.productId));
+        }
+        if (query.destinationId) {
+            conditions.push(eq(productDestinations.destinationId, query.destinationId));
+        }
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        const [rows, countResult] = await Promise.all([
+            db
+                .select({
+                productId: productDestinations.productId,
+                destinationId: productDestinations.destinationId,
+                sortOrder: productDestinations.sortOrder,
+                createdAt: productDestinations.createdAt,
+                updatedAt: productDestinations.updatedAt,
+                destinationSlug: destinations.slug,
+                destinationType: destinations.destinationType,
+                destinationActive: destinations.active,
+            })
+                .from(productDestinations)
+                .innerJoin(destinations, eq(destinations.id, productDestinations.destinationId))
+                .where(where)
+                .limit(query.limit)
+                .offset(query.offset)
+                .orderBy(asc(productDestinations.sortOrder), asc(destinations.slug)),
+            db.select({ count: sql `count(*)::int` }).from(productDestinations).where(where),
+        ]);
+        return {
+            data: rows,
+            total: countResult[0]?.count ?? 0,
+            limit: query.limit,
+            offset: query.offset,
+        };
+    },
+    async assignProductDestination(db, productId, input) {
+        const product = await ensureProductExists(db, productId);
+        if (!product) {
+            return null;
+        }
+        const [destination] = await db
+            .select({ id: destinations.id })
+            .from(destinations)
+            .where(eq(destinations.id, input.destinationId))
+            .limit(1);
+        if (!destination) {
+            return null;
+        }
+        const [existing] = await db
+            .select()
+            .from(productDestinations)
+            .where(and(eq(productDestinations.productId, productId), eq(productDestinations.destinationId, input.destinationId)))
+            .limit(1);
+        if (existing) {
+            const [row] = await db
+                .update(productDestinations)
+                .set({ sortOrder: input.sortOrder ?? existing.sortOrder, updatedAt: new Date() })
+                .where(and(eq(productDestinations.productId, productId), eq(productDestinations.destinationId, input.destinationId)))
+                .returning();
+            return row ?? null;
+        }
+        const [row] = await db
+            .insert(productDestinations)
+            .values({
+            productId,
+            destinationId: input.destinationId,
+            sortOrder: input.sortOrder ?? 0,
+        })
+            .returning();
+        return row ?? null;
+    },
+    async removeProductDestination(db, productId, destinationId) {
+        const [row] = await db
+            .delete(productDestinations)
+            .where(and(eq(productDestinations.productId, productId), eq(productDestinations.destinationId, destinationId)))
+            .returning({
+            productId: productDestinations.productId,
+            destinationId: productDestinations.destinationId,
+        });
+        return row ?? null;
+    },
+};