@voyant-travel/inventory 0.1.0

package/dist/service-itinerary-history.d.ts

@@ -0,0 +1,457 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { z } from "zod";
+import type { insertProductNoteSchema, insertVersionSchema } from "./validation.js";
+type CreateVersionInput = z.infer<typeof insertVersionSchema>;
+type CreateProductNoteInput = z.infer<typeof insertProductNoteSchema>;
+export declare const itineraryHistoryProductsService: {
+    listVersions(db: PostgresJsDatabase, productId: string): Omit<import("drizzle-orm/pg-core").PgSelectBase<"product_versions", {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "product_versions";
+            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;
+        }, {}, {}>;
+        productId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "product_versions";
+            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;
+        }, {}, {}>;
+        versionNumber: import("drizzle-orm/pg-core").PgColumn<{
+            name: "version_number";
+            tableName: "product_versions";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        snapshot: import("drizzle-orm/pg-core").PgColumn<{
+            name: "snapshot";
+            tableName: "product_versions";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        authorId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "author_id";
+            tableName: "product_versions";
+            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;
+        }, {}, {}>;
+        notes: import("drizzle-orm/pg-core").PgColumn<{
+            name: "notes";
+            tableName: "product_versions";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "product_versions";
+            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;
+        }, {}, {}>;
+    }, "single", Record<"product_versions", "not-null">, false, "where" | "orderBy", {
+        id: string;
+        productId: string;
+        versionNumber: number;
+        snapshot: unknown;
+        authorId: string;
+        notes: string | null;
+        createdAt: Date;
+    }[], {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "product_versions";
+            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;
+        }, {}, {}>;
+        productId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "product_versions";
+            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;
+        }, {}, {}>;
+        versionNumber: import("drizzle-orm/pg-core").PgColumn<{
+            name: "version_number";
+            tableName: "product_versions";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        snapshot: import("drizzle-orm/pg-core").PgColumn<{
+            name: "snapshot";
+            tableName: "product_versions";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        authorId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "author_id";
+            tableName: "product_versions";
+            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;
+        }, {}, {}>;
+        notes: import("drizzle-orm/pg-core").PgColumn<{
+            name: "notes";
+            tableName: "product_versions";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "product_versions";
+            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;
+        }, {}, {}>;
+    }>, "where" | "orderBy">;
+    createVersion(db: PostgresJsDatabase, productId: string, userId: string, data: CreateVersionInput): Promise<{
+        id: string;
+        createdAt: Date;
+        productId: string;
+        notes: string | null;
+        versionNumber: number;
+        snapshot: unknown;
+        authorId: string;
+    } | null | undefined>;
+    listNotes(db: PostgresJsDatabase, productId: string): Omit<import("drizzle-orm/pg-core").PgSelectBase<"product_notes", {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "product_notes";
+            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;
+        }, {}, {}>;
+        productId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "product_notes";
+            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;
+        }, {}, {}>;
+        authorId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "author_id";
+            tableName: "product_notes";
+            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;
+        }, {}, {}>;
+        content: import("drizzle-orm/pg-core").PgColumn<{
+            name: "content";
+            tableName: "product_notes";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "product_notes";
+            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;
+        }, {}, {}>;
+    }, "single", Record<"product_notes", "not-null">, false, "where" | "orderBy", {
+        id: string;
+        productId: string;
+        authorId: string;
+        content: string;
+        createdAt: Date;
+    }[], {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "product_notes";
+            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;
+        }, {}, {}>;
+        productId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "product_notes";
+            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;
+        }, {}, {}>;
+        authorId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "author_id";
+            tableName: "product_notes";
+            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;
+        }, {}, {}>;
+        content: import("drizzle-orm/pg-core").PgColumn<{
+            name: "content";
+            tableName: "product_notes";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "product_notes";
+            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;
+        }, {}, {}>;
+    }>, "where" | "orderBy">;
+    createNote(db: PostgresJsDatabase, productId: string, userId: string, data: CreateProductNoteInput): Promise<{
+        id: string;
+        createdAt: Date;
+        productId: string;
+        content: string;
+        authorId: string;
+    } | null | undefined>;
+    recalculate(db: PostgresJsDatabase, productId: string): Promise<{
+        costAmountCents: number;
+        marginPercent: number;
+    } | null>;
+};
+export {};
+//# sourceMappingURL=service-itinerary-history.d.ts.map

package/dist/service-itinerary-history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-itinerary-history.d.ts","sourceRoot":"","sources":["../src/service-itinerary-history.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAW5B,OAAO,KAAK,EAAE,uBAAuB,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAEnF,KAAK,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC7D,KAAK,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAkCrE,eAAO,MAAM,+BAA+B;qBACzB,kBAAkB,aAAa,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAShD,kBAAkB,aACX,MAAM,UACT,MAAM,QACR,kBAAkB;;;;;;;;;kBAqFZ,kBAAkB,aAAa,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAS7C,kBAAkB,aACX,MAAM,UACT,MAAM,QACR,sBAAsB;;;;;;;oBAwBR,kBAAkB,aAAa,MAAM;;;;CAa5D,CAAA"}

package/dist/service-itinerary-history.js

@@ -0,0 +1,135 @@
+import { asc, desc, eq, sql } from "drizzle-orm";
+import { optionUnits, productDayServices, productDays, productItineraries, productNotes, productOptions, products, productVersions, } from "./schema.js";
+async function recalculateProductCost(db, productId) {
+    const [result] = await db
+        .select({
+        totalCost: sql `coalesce(sum(${productDayServices.costAmountCents} * ${productDayServices.quantity}), 0)::int`,
+    })
+        .from(productDayServices)
+        .innerJoin(productDays, eq(productDayServices.dayId, productDays.id))
+        .innerJoin(productItineraries, eq(productDays.itineraryId, productItineraries.id))
+        .where(eq(productItineraries.productId, productId));
+    const costAmountCents = result?.totalCost ?? 0;
+    const [product] = await db
+        .select({ sellAmountCents: products.sellAmountCents })
+        .from(products)
+        .where(eq(products.id, productId))
+        .limit(1);
+    const sellAmountCents = product?.sellAmountCents ?? 0;
+    const marginPercent = sellAmountCents > 0
+        ? Math.round(((sellAmountCents - costAmountCents) / sellAmountCents) * 100)
+        : 0;
+    await db
+        .update(products)
+        .set({ costAmountCents, marginPercent, updatedAt: new Date() })
+        .where(eq(products.id, productId));
+    return { costAmountCents, marginPercent };
+}
+export const itineraryHistoryProductsService = {
+    listVersions(db, productId) {
+        return db
+            .select()
+            .from(productVersions)
+            .where(eq(productVersions.productId, productId))
+            .orderBy(desc(productVersions.versionNumber));
+    },
+    async createVersion(db, productId, userId, data) {
+        const [product] = await db.select().from(products).where(eq(products.id, productId)).limit(1);
+        if (!product) {
+            return null;
+        }
+        const itineraries = await db
+            .select()
+            .from(productItineraries)
+            .where(eq(productItineraries.productId, productId))
+            .orderBy(desc(productItineraries.isDefault), asc(productItineraries.sortOrder));
+        const defaultItinerary = itineraries.find((itinerary) => itinerary.isDefault) ?? null;
+        const options = await db
+            .select()
+            .from(productOptions)
+            .where(eq(productOptions.productId, productId))
+            .orderBy(asc(productOptions.sortOrder), asc(productOptions.createdAt));
+        const optionsWithUnits = await Promise.all(options.map(async (option) => {
+            const units = await db
+                .select()
+                .from(optionUnits)
+                .where(eq(optionUnits.optionId, option.id))
+                .orderBy(asc(optionUnits.sortOrder), asc(optionUnits.createdAt));
+            return { ...option, units };
+        }));
+        const itinerariesWithDays = await Promise.all(itineraries.map(async (itinerary) => {
+            const days = await db
+                .select()
+                .from(productDays)
+                .where(eq(productDays.itineraryId, itinerary.id))
+                .orderBy(asc(productDays.dayNumber));
+            const daysWithServices = await Promise.all(days.map(async (day) => {
+                const services = await db
+                    .select()
+                    .from(productDayServices)
+                    .where(eq(productDayServices.dayId, day.id))
+                    .orderBy(asc(productDayServices.sortOrder));
+                return { ...day, services };
+            }));
+            return { ...itinerary, days: daysWithServices };
+        }));
+        const defaultDays = itinerariesWithDays.find((itinerary) => itinerary.id === defaultItinerary?.id)?.days ?? [];
+        const [maxVersion] = await db
+            .select({ max: sql `coalesce(max(${productVersions.versionNumber}), 0)` })
+            .from(productVersions)
+            .where(eq(productVersions.productId, productId));
+        const [row] = await db
+            .insert(productVersions)
+            .values({
+            productId,
+            versionNumber: (maxVersion?.max ?? 0) + 1,
+            snapshot: {
+                ...product,
+                options: optionsWithUnits,
+                itineraries: itinerariesWithDays,
+                days: defaultDays,
+            },
+            authorId: userId,
+            notes: data.notes,
+        })
+            .returning();
+        return row;
+    },
+    listNotes(db, productId) {
+        return db
+            .select()
+            .from(productNotes)
+            .where(eq(productNotes.productId, productId))
+            .orderBy(productNotes.createdAt);
+    },
+    async createNote(db, productId, userId, data) {
+        const [product] = await db
+            .select({ id: products.id })
+            .from(products)
+            .where(eq(products.id, productId))
+            .limit(1);
+        if (!product) {
+            return null;
+        }
+        const [row] = await db
+            .insert(productNotes)
+            .values({
+            productId,
+            authorId: userId,
+            content: data.content,
+        })
+            .returning();
+        return row;
+    },
+    async recalculate(db, productId) {
+        const [product] = await db
+            .select({ id: products.id })
+            .from(products)
+            .where(eq(products.id, productId))
+            .limit(1);
+        if (!product) {
+            return null;
+        }
+        return recalculateProductCost(db, productId);
+    },
+};