@voyantjs/extras 0.1.0

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,sBAAsB,mGAKjC,CAAA;AAEF,eAAO,MAAM,oBAAoB,yHAO/B,CAAA;AAEF,eAAO,MAAM,sBAAsB,oGAMjC,CAAA;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBzB,CAAA;AAED,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4B9B,CAAA;AAED,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqCzB,CAAA;AAED,MAAM,MAAM,YAAY,GAAG,OAAO,aAAa,CAAC,YAAY,CAAA;AAC5D,MAAM,MAAM,eAAe,GAAG,OAAO,aAAa,CAAC,YAAY,CAAA;AAC/D,MAAM,MAAM,iBAAiB,GAAG,OAAO,kBAAkB,CAAC,YAAY,CAAA;AACtE,MAAM,MAAM,oBAAoB,GAAG,OAAO,kBAAkB,CAAC,YAAY,CAAA;AACzE,MAAM,MAAM,YAAY,GAAG,OAAO,aAAa,CAAC,YAAY,CAAA;AAC5D,MAAM,MAAM,eAAe,GAAG,OAAO,aAAa,CAAC,YAAY,CAAA;AAE/D,eAAO,MAAM,sBAAsB;;;EAGhC,CAAA;AAEH,eAAO,MAAM,2BAA2B;;;EAMrC,CAAA;AAEH,eAAO,MAAM,sBAAsB;;;EAShC,CAAA"}

package/dist/schema.js

@@ -0,0 +1,123 @@
+import { typeId, typeIdRef } from "@voyantjs/db/lib/typeid-column";
+import { relations } from "drizzle-orm";
+import { boolean, index, integer, jsonb, pgEnum, pgTable, text, timestamp, uniqueIndex, } from "drizzle-orm/pg-core";
+export const extraSelectionTypeEnum = pgEnum("extra_selection_type", [
+    "optional",
+    "required",
+    "default_selected",
+    "unavailable",
+]);
+export const extraPricingModeEnum = pgEnum("extra_pricing_mode", [
+    "included",
+    "per_person",
+    "per_booking",
+    "quantity_based",
+    "on_request",
+    "free",
+]);
+export const bookingExtraStatusEnum = pgEnum("booking_extra_status", [
+    "draft",
+    "selected",
+    "confirmed",
+    "cancelled",
+    "fulfilled",
+]);
+export const productExtras = pgTable("product_extras", {
+    id: typeId("product_extras"),
+    productId: text("product_id").notNull(),
+    code: text("code"),
+    name: text("name").notNull(),
+    description: text("description"),
+    selectionType: extraSelectionTypeEnum("selection_type").notNull().default("optional"),
+    pricingMode: extraPricingModeEnum("pricing_mode").notNull().default("per_booking"),
+    pricedPerPerson: boolean("priced_per_person").notNull().default(false),
+    minQuantity: integer("min_quantity"),
+    maxQuantity: integer("max_quantity"),
+    defaultQuantity: integer("default_quantity"),
+    active: boolean("active").notNull().default(true),
+    sortOrder: integer("sort_order").notNull().default(0),
+    metadata: jsonb("metadata").$type(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_product_extras_product").on(table.productId),
+    index("idx_product_extras_active").on(table.active),
+    uniqueIndex("uidx_product_extras_product_code").on(table.productId, table.code),
+]);
+export const optionExtraConfigs = pgTable("option_extra_configs", {
+    id: typeId("option_extra_configs"),
+    optionId: text("option_id").notNull(),
+    productExtraId: typeIdRef("product_extra_id")
+        .notNull()
+        .references(() => productExtras.id, { onDelete: "cascade" }),
+    selectionType: extraSelectionTypeEnum("selection_type"),
+    pricingMode: extraPricingModeEnum("pricing_mode"),
+    pricedPerPerson: boolean("priced_per_person"),
+    minQuantity: integer("min_quantity"),
+    maxQuantity: integer("max_quantity"),
+    defaultQuantity: integer("default_quantity"),
+    isDefault: boolean("is_default").notNull().default(false),
+    active: boolean("active").notNull().default(true),
+    sortOrder: integer("sort_order").notNull().default(0),
+    notes: text("notes"),
+    metadata: jsonb("metadata").$type(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_option_extra_configs_option").on(table.optionId),
+    index("idx_option_extra_configs_extra").on(table.productExtraId),
+    index("idx_option_extra_configs_active").on(table.active),
+    uniqueIndex("uidx_option_extra_configs_option_extra").on(table.optionId, table.productExtraId),
+]);
+export const bookingExtras = pgTable("booking_extras", {
+    id: typeId("booking_extras"),
+    bookingId: text("booking_id").notNull(),
+    productExtraId: typeIdRef("product_extra_id").references(() => productExtras.id, {
+        onDelete: "set null",
+    }),
+    optionExtraConfigId: typeIdRef("option_extra_config_id").references(() => optionExtraConfigs.id, {
+        onDelete: "set null",
+    }),
+    name: text("name").notNull(),
+    description: text("description"),
+    status: bookingExtraStatusEnum("status").notNull().default("draft"),
+    pricingMode: extraPricingModeEnum("pricing_mode").notNull().default("per_booking"),
+    pricedPerPerson: boolean("priced_per_person").notNull().default(false),
+    quantity: integer("quantity").notNull().default(1),
+    sellCurrency: text("sell_currency").notNull(),
+    unitSellAmountCents: integer("unit_sell_amount_cents"),
+    totalSellAmountCents: integer("total_sell_amount_cents"),
+    costCurrency: text("cost_currency"),
+    unitCostAmountCents: integer("unit_cost_amount_cents"),
+    totalCostAmountCents: integer("total_cost_amount_cents"),
+    notes: text("notes"),
+    metadata: jsonb("metadata").$type(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_booking_extras_booking").on(table.bookingId),
+    index("idx_booking_extras_product_extra").on(table.productExtraId),
+    index("idx_booking_extras_option_extra_config").on(table.optionExtraConfigId),
+    index("idx_booking_extras_status").on(table.status),
+]);
+export const productExtrasRelations = relations(productExtras, ({ many }) => ({
+    optionConfigs: many(optionExtraConfigs),
+    bookingExtras: many(bookingExtras),
+}));
+export const optionExtraConfigsRelations = relations(optionExtraConfigs, ({ one, many }) => ({
+    productExtra: one(productExtras, {
+        fields: [optionExtraConfigs.productExtraId],
+        references: [productExtras.id],
+    }),
+    bookingExtras: many(bookingExtras),
+}));
+export const bookingExtrasRelations = relations(bookingExtras, ({ one }) => ({
+    productExtra: one(productExtras, {
+        fields: [bookingExtras.productExtraId],
+        references: [productExtras.id],
+    }),
+    optionExtraConfig: one(optionExtraConfigs, {
+        fields: [bookingExtras.optionExtraConfigId],
+        references: [optionExtraConfigs.id],
+    }),
+}));

package/dist/service.d.ts

@@ -0,0 +1,272 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { z } from "zod";
+import type { bookingExtraListQuerySchema, insertBookingExtraSchema, insertOptionExtraConfigSchema, insertProductExtraSchema, optionExtraConfigListQuerySchema, productExtraListQuerySchema, updateBookingExtraSchema, updateOptionExtraConfigSchema, updateProductExtraSchema } from "./validation.js";
+type ProductExtraListQuery = z.infer<typeof productExtraListQuerySchema>;
+type OptionExtraConfigListQuery = z.infer<typeof optionExtraConfigListQuerySchema>;
+type BookingExtraListQuery = z.infer<typeof bookingExtraListQuerySchema>;
+type CreateProductExtraInput = z.infer<typeof insertProductExtraSchema>;
+type UpdateProductExtraInput = z.infer<typeof updateProductExtraSchema>;
+type CreateOptionExtraConfigInput = z.infer<typeof insertOptionExtraConfigSchema>;
+type UpdateOptionExtraConfigInput = z.infer<typeof updateOptionExtraConfigSchema>;
+type CreateBookingExtraInput = z.infer<typeof insertBookingExtraSchema>;
+type UpdateBookingExtraInput = z.infer<typeof updateBookingExtraSchema>;
+export declare const extrasService: {
+    listProductExtras(db: PostgresJsDatabase, query: ProductExtraListQuery): Promise<{
+        data: {
+            id: string;
+            productId: string;
+            code: string | null;
+            name: string;
+            description: string | null;
+            selectionType: "optional" | "required" | "default_selected" | "unavailable";
+            pricingMode: "included" | "per_person" | "per_booking" | "quantity_based" | "on_request" | "free";
+            pricedPerPerson: boolean;
+            minQuantity: number | null;
+            maxQuantity: number | null;
+            defaultQuantity: number | null;
+            active: boolean;
+            sortOrder: number;
+            metadata: Record<string, unknown> | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getProductExtraById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        productId: string;
+        code: string | null;
+        name: string;
+        description: string | null;
+        selectionType: "optional" | "required" | "default_selected" | "unavailable";
+        pricingMode: "included" | "per_person" | "per_booking" | "quantity_based" | "on_request" | "free";
+        pricedPerPerson: boolean;
+        minQuantity: number | null;
+        maxQuantity: number | null;
+        defaultQuantity: number | null;
+        active: boolean;
+        sortOrder: number;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createProductExtra(db: PostgresJsDatabase, data: CreateProductExtraInput): Promise<{
+        id: string;
+        name: string;
+        productId: string;
+        code: string | null;
+        description: string | null;
+        selectionType: "optional" | "required" | "default_selected" | "unavailable";
+        pricingMode: "included" | "per_person" | "per_booking" | "quantity_based" | "on_request" | "free";
+        pricedPerPerson: boolean;
+        minQuantity: number | null;
+        maxQuantity: number | null;
+        defaultQuantity: number | null;
+        active: boolean;
+        sortOrder: number;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    updateProductExtra(db: PostgresJsDatabase, id: string, data: UpdateProductExtraInput): Promise<{
+        id: string;
+        productId: string;
+        code: string | null;
+        name: string;
+        description: string | null;
+        selectionType: "optional" | "required" | "default_selected" | "unavailable";
+        pricingMode: "included" | "per_person" | "per_booking" | "quantity_based" | "on_request" | "free";
+        pricedPerPerson: boolean;
+        minQuantity: number | null;
+        maxQuantity: number | null;
+        defaultQuantity: number | null;
+        active: boolean;
+        sortOrder: number;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteProductExtra(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    listOptionExtraConfigs(db: PostgresJsDatabase, query: OptionExtraConfigListQuery): Promise<{
+        data: {
+            id: string;
+            optionId: string;
+            productExtraId: string;
+            selectionType: "optional" | "required" | "default_selected" | "unavailable" | null;
+            pricingMode: "included" | "per_person" | "per_booking" | "quantity_based" | "on_request" | "free" | null;
+            pricedPerPerson: boolean | null;
+            minQuantity: number | null;
+            maxQuantity: number | null;
+            defaultQuantity: number | null;
+            isDefault: boolean;
+            active: boolean;
+            sortOrder: number;
+            notes: string | null;
+            metadata: Record<string, unknown> | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getOptionExtraConfigById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        optionId: string;
+        productExtraId: string;
+        selectionType: "optional" | "required" | "default_selected" | "unavailable" | null;
+        pricingMode: "included" | "per_person" | "per_booking" | "quantity_based" | "on_request" | "free" | null;
+        pricedPerPerson: boolean | null;
+        minQuantity: number | null;
+        maxQuantity: number | null;
+        defaultQuantity: number | null;
+        isDefault: boolean;
+        active: boolean;
+        sortOrder: number;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createOptionExtraConfig(db: PostgresJsDatabase, data: CreateOptionExtraConfigInput): Promise<{
+        id: string;
+        selectionType: "optional" | "required" | "default_selected" | "unavailable" | null;
+        pricingMode: "included" | "per_person" | "per_booking" | "quantity_based" | "on_request" | "free" | null;
+        pricedPerPerson: boolean | null;
+        minQuantity: number | null;
+        maxQuantity: number | null;
+        defaultQuantity: number | null;
+        active: boolean;
+        sortOrder: number;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+        optionId: string;
+        productExtraId: string;
+        isDefault: boolean;
+        notes: string | null;
+    } | null>;
+    updateOptionExtraConfig(db: PostgresJsDatabase, id: string, data: UpdateOptionExtraConfigInput): Promise<{
+        id: string;
+        optionId: string;
+        productExtraId: string;
+        selectionType: "optional" | "required" | "default_selected" | "unavailable" | null;
+        pricingMode: "included" | "per_person" | "per_booking" | "quantity_based" | "on_request" | "free" | null;
+        pricedPerPerson: boolean | null;
+        minQuantity: number | null;
+        maxQuantity: number | null;
+        defaultQuantity: number | null;
+        isDefault: boolean;
+        active: boolean;
+        sortOrder: number;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteOptionExtraConfig(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    listBookingExtras(db: PostgresJsDatabase, query: BookingExtraListQuery): Promise<{
+        data: {
+            id: string;
+            bookingId: string;
+            productExtraId: string | null;
+            optionExtraConfigId: string | null;
+            name: string;
+            description: string | null;
+            status: "draft" | "selected" | "confirmed" | "cancelled" | "fulfilled";
+            pricingMode: "included" | "per_person" | "per_booking" | "quantity_based" | "on_request" | "free";
+            pricedPerPerson: boolean;
+            quantity: number;
+            sellCurrency: string;
+            unitSellAmountCents: number | null;
+            totalSellAmountCents: number | null;
+            costCurrency: string | null;
+            unitCostAmountCents: number | null;
+            totalCostAmountCents: number | null;
+            notes: string | null;
+            metadata: Record<string, unknown> | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getBookingExtraById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        bookingId: string;
+        productExtraId: string | null;
+        optionExtraConfigId: string | null;
+        name: string;
+        description: string | null;
+        status: "draft" | "selected" | "confirmed" | "cancelled" | "fulfilled";
+        pricingMode: "included" | "per_person" | "per_booking" | "quantity_based" | "on_request" | "free";
+        pricedPerPerson: boolean;
+        quantity: number;
+        sellCurrency: string;
+        unitSellAmountCents: number | null;
+        totalSellAmountCents: number | null;
+        costCurrency: string | null;
+        unitCostAmountCents: number | null;
+        totalCostAmountCents: number | null;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createBookingExtra(db: PostgresJsDatabase, data: CreateBookingExtraInput): Promise<{
+        id: string;
+        name: string;
+        description: string | null;
+        pricingMode: "included" | "per_person" | "per_booking" | "quantity_based" | "on_request" | "free";
+        pricedPerPerson: boolean;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+        productExtraId: string | null;
+        notes: string | null;
+        bookingId: string;
+        optionExtraConfigId: string | null;
+        status: "draft" | "selected" | "confirmed" | "cancelled" | "fulfilled";
+        quantity: number;
+        sellCurrency: string;
+        unitSellAmountCents: number | null;
+        totalSellAmountCents: number | null;
+        costCurrency: string | null;
+        unitCostAmountCents: number | null;
+        totalCostAmountCents: number | null;
+    } | null>;
+    updateBookingExtra(db: PostgresJsDatabase, id: string, data: UpdateBookingExtraInput): Promise<{
+        id: string;
+        bookingId: string;
+        productExtraId: string | null;
+        optionExtraConfigId: string | null;
+        name: string;
+        description: string | null;
+        status: "draft" | "selected" | "confirmed" | "cancelled" | "fulfilled";
+        pricingMode: "included" | "per_person" | "per_booking" | "quantity_based" | "on_request" | "free";
+        pricedPerPerson: boolean;
+        quantity: number;
+        sellCurrency: string;
+        unitSellAmountCents: number | null;
+        totalSellAmountCents: number | null;
+        costCurrency: string | null;
+        unitCostAmountCents: number | null;
+        totalCostAmountCents: number | null;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteBookingExtra(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+};
+export {};
+//# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAG5B,OAAO,KAAK,EACV,2BAA2B,EAC3B,wBAAwB,EACxB,6BAA6B,EAC7B,wBAAwB,EACxB,gCAAgC,EAChC,2BAA2B,EAC3B,wBAAwB,EACxB,6BAA6B,EAC7B,wBAAwB,EACzB,MAAM,iBAAiB,CAAA;AAExB,KAAK,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AACxE,KAAK,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAA;AAClF,KAAK,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AACxE,KAAK,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AACvE,KAAK,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AACvE,KAAK,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AACjF,KAAK,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AACjF,KAAK,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AACvE,KAAK,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAYvE,eAAO,MAAM,aAAa;0BACI,kBAAkB,SAAS,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;4BAuB9C,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;;;;2BAK/B,kBAAkB,QAAQ,uBAAuB;;;;;;;;;;;;;;;;;;2BAKjD,kBAAkB,MAAM,MAAM,QAAQ,uBAAuB;;;;;;;;;;;;;;;;;;2BAS7D,kBAAkB,MAAM,MAAM;;;+BAQ1B,kBAAkB,SAAS,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;iCAqBnD,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;;;;gCAS/B,kBAAkB,QAAQ,4BAA4B;;;;;;;;;;;;;;;;;;gCAMlF,kBAAkB,MAClB,MAAM,QACJ,4BAA4B;;;;;;;;;;;;;;;;;;gCAUF,kBAAkB,MAAM,MAAM;;;0BAQpC,kBAAkB,SAAS,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAuB9C,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;2BAK/B,kBAAkB,QAAQ,uBAAuB;;;;;;;;;;;;;;;;;;;;;;2BAKjD,kBAAkB,MAAM,MAAM,QAAQ,uBAAuB;;;;;;;;;;;;;;;;;;;;;;2BAS7D,kBAAkB,MAAM,MAAM;;;CAO5D,CAAA"}

package/dist/service.js

@@ -0,0 +1,136 @@
+import { and, asc, desc, eq, ilike, or, sql } from "drizzle-orm";
+import { bookingExtras, optionExtraConfigs, productExtras } from "./schema.js";
+async function paginate(rowsQuery, countQuery, limit, offset) {
+    const [data, countResult] = await Promise.all([rowsQuery, countQuery]);
+    return { data, total: countResult[0]?.count ?? 0, limit, offset };
+}
+export const extrasService = {
+    async listProductExtras(db, query) {
+        const conditions = [];
+        if (query.productId)
+            conditions.push(eq(productExtras.productId, query.productId));
+        if (query.active !== undefined)
+            conditions.push(eq(productExtras.active, query.active));
+        if (query.search) {
+            const term = `%${query.search}%`;
+            conditions.push(or(ilike(productExtras.name, term), ilike(productExtras.code, term)));
+        }
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(productExtras)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(asc(productExtras.sortOrder), asc(productExtras.name)), db.select({ count: sql `count(*)::int` }).from(productExtras).where(where), query.limit, query.offset);
+    },
+    async getProductExtraById(db, id) {
+        const [row] = await db.select().from(productExtras).where(eq(productExtras.id, id)).limit(1);
+        return row ?? null;
+    },
+    async createProductExtra(db, data) {
+        const [row] = await db.insert(productExtras).values(data).returning();
+        return row ?? null;
+    },
+    async updateProductExtra(db, id, data) {
+        const [row] = await db
+            .update(productExtras)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(productExtras.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteProductExtra(db, id) {
+        const [row] = await db
+            .delete(productExtras)
+            .where(eq(productExtras.id, id))
+            .returning({ id: productExtras.id });
+        return row ?? null;
+    },
+    async listOptionExtraConfigs(db, query) {
+        const conditions = [];
+        if (query.optionId)
+            conditions.push(eq(optionExtraConfigs.optionId, query.optionId));
+        if (query.productExtraId)
+            conditions.push(eq(optionExtraConfigs.productExtraId, query.productExtraId));
+        if (query.active !== undefined)
+            conditions.push(eq(optionExtraConfigs.active, query.active));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(optionExtraConfigs)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(asc(optionExtraConfigs.sortOrder), desc(optionExtraConfigs.isDefault)), db.select({ count: sql `count(*)::int` }).from(optionExtraConfigs).where(where), query.limit, query.offset);
+    },
+    async getOptionExtraConfigById(db, id) {
+        const [row] = await db
+            .select()
+            .from(optionExtraConfigs)
+            .where(eq(optionExtraConfigs.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createOptionExtraConfig(db, data) {
+        const [row] = await db.insert(optionExtraConfigs).values(data).returning();
+        return row ?? null;
+    },
+    async updateOptionExtraConfig(db, id, data) {
+        const [row] = await db
+            .update(optionExtraConfigs)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(optionExtraConfigs.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteOptionExtraConfig(db, id) {
+        const [row] = await db
+            .delete(optionExtraConfigs)
+            .where(eq(optionExtraConfigs.id, id))
+            .returning({ id: optionExtraConfigs.id });
+        return row ?? null;
+    },
+    async listBookingExtras(db, query) {
+        const conditions = [];
+        if (query.bookingId)
+            conditions.push(eq(bookingExtras.bookingId, query.bookingId));
+        if (query.productExtraId)
+            conditions.push(eq(bookingExtras.productExtraId, query.productExtraId));
+        if (query.optionExtraConfigId)
+            conditions.push(eq(bookingExtras.optionExtraConfigId, query.optionExtraConfigId));
+        if (query.status)
+            conditions.push(eq(bookingExtras.status, query.status));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(bookingExtras)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(bookingExtras.updatedAt)), db.select({ count: sql `count(*)::int` }).from(bookingExtras).where(where), query.limit, query.offset);
+    },
+    async getBookingExtraById(db, id) {
+        const [row] = await db.select().from(bookingExtras).where(eq(bookingExtras.id, id)).limit(1);
+        return row ?? null;
+    },
+    async createBookingExtra(db, data) {
+        const [row] = await db.insert(bookingExtras).values(data).returning();
+        return row ?? null;
+    },
+    async updateBookingExtra(db, id, data) {
+        const [row] = await db
+            .update(bookingExtras)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(bookingExtras.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteBookingExtra(db, id) {
+        const [row] = await db
+            .delete(bookingExtras)
+            .where(eq(bookingExtras.id, id))
+            .returning({ id: bookingExtras.id });
+        return row ?? null;
+    },
+};