@voyant-travel/distribution 0.109.8

package/dist/service/commercial.js

@@ -0,0 +1,248 @@
+import { and, desc, eq, sql } from "drizzle-orm";
+import { channelBookingLinks, channelCommissionRules, channelContracts, channelProductMappings, channelWebhookEvents, } from "../schema.js";
+import { paginate, toDateOrNull } from "./helpers.js";
+export const commercialServiceOperations = {
+    async listContracts(db, query) {
+        const conditions = [];
+        if (query.channelId)
+            conditions.push(eq(channelContracts.channelId, query.channelId));
+        if (query.supplierId)
+            conditions.push(eq(channelContracts.supplierId, query.supplierId));
+        if (query.status)
+            conditions.push(eq(channelContracts.status, query.status));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(channelContracts)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(channelContracts.createdAt)), db.select({ count: sql `count(*)::int` }).from(channelContracts).where(where), query.limit, query.offset);
+    },
+    async getContractById(db, id) {
+        const [row] = await db
+            .select()
+            .from(channelContracts)
+            .where(eq(channelContracts.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createContract(db, data) {
+        const [row] = await db.insert(channelContracts).values(data).returning();
+        return row;
+    },
+    async updateContract(db, id, data) {
+        const [row] = await db
+            .update(channelContracts)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(channelContracts.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteContract(db, id) {
+        const [row] = await db
+            .delete(channelContracts)
+            .where(eq(channelContracts.id, id))
+            .returning({ id: channelContracts.id });
+        return row ?? null;
+    },
+    async listCommissionRules(db, query) {
+        const conditions = [];
+        if (query.contractId)
+            conditions.push(eq(channelCommissionRules.contractId, query.contractId));
+        if (query.productId)
+            conditions.push(eq(channelCommissionRules.productId, query.productId));
+        if (query.scope)
+            conditions.push(eq(channelCommissionRules.scope, query.scope));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(channelCommissionRules)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(channelCommissionRules.createdAt)), db.select({ count: sql `count(*)::int` }).from(channelCommissionRules).where(where), query.limit, query.offset);
+    },
+    async getCommissionRuleById(db, id) {
+        const [row] = await db
+            .select()
+            .from(channelCommissionRules)
+            .where(eq(channelCommissionRules.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createCommissionRule(db, data) {
+        const [row] = await db.insert(channelCommissionRules).values(data).returning();
+        return row;
+    },
+    async updateCommissionRule(db, id, data) {
+        const [row] = await db
+            .update(channelCommissionRules)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(channelCommissionRules.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteCommissionRule(db, id) {
+        const [row] = await db
+            .delete(channelCommissionRules)
+            .where(eq(channelCommissionRules.id, id))
+            .returning({ id: channelCommissionRules.id });
+        return row ?? null;
+    },
+    async listProductMappings(db, query) {
+        const conditions = [];
+        if (query.channelId)
+            conditions.push(eq(channelProductMappings.channelId, query.channelId));
+        if (query.productId)
+            conditions.push(eq(channelProductMappings.productId, query.productId));
+        if (query.active !== undefined)
+            conditions.push(eq(channelProductMappings.active, query.active));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(channelProductMappings)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(channelProductMappings.createdAt)), db.select({ count: sql `count(*)::int` }).from(channelProductMappings).where(where), query.limit, query.offset);
+    },
+    async getProductMappingById(db, id) {
+        const [row] = await db
+            .select()
+            .from(channelProductMappings)
+            .where(eq(channelProductMappings.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createProductMapping(db, data) {
+        const [row] = await db.insert(channelProductMappings).values(data).returning();
+        return row;
+    },
+    async updateProductMapping(db, id, data) {
+        const [row] = await db
+            .update(channelProductMappings)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(channelProductMappings.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteProductMapping(db, id) {
+        const [row] = await db
+            .delete(channelProductMappings)
+            .where(eq(channelProductMappings.id, id))
+            .returning({ id: channelProductMappings.id });
+        return row ?? null;
+    },
+    async listBookingLinks(db, query) {
+        const conditions = [];
+        if (query.channelId)
+            conditions.push(eq(channelBookingLinks.channelId, query.channelId));
+        if (query.bookingId)
+            conditions.push(eq(channelBookingLinks.bookingId, query.bookingId));
+        if (query.externalBookingId)
+            conditions.push(eq(channelBookingLinks.externalBookingId, query.externalBookingId));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(channelBookingLinks)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(channelBookingLinks.createdAt)), db.select({ count: sql `count(*)::int` }).from(channelBookingLinks).where(where), query.limit, query.offset);
+    },
+    async getBookingLinkById(db, id) {
+        const [row] = await db
+            .select()
+            .from(channelBookingLinks)
+            .where(eq(channelBookingLinks.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createBookingLink(db, data) {
+        const [row] = await db
+            .insert(channelBookingLinks)
+            .values({
+            ...data,
+            bookedAtExternal: toDateOrNull(data.bookedAtExternal),
+            lastSyncedAt: toDateOrNull(data.lastSyncedAt),
+        })
+            .returning();
+        return row;
+    },
+    async updateBookingLink(db, id, data) {
+        const [row] = await db
+            .update(channelBookingLinks)
+            .set({
+            ...data,
+            bookedAtExternal: data.bookedAtExternal === undefined ? undefined : toDateOrNull(data.bookedAtExternal),
+            lastSyncedAt: data.lastSyncedAt === undefined ? undefined : toDateOrNull(data.lastSyncedAt),
+            updatedAt: new Date(),
+        })
+            .where(eq(channelBookingLinks.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteBookingLink(db, id) {
+        const [row] = await db
+            .delete(channelBookingLinks)
+            .where(eq(channelBookingLinks.id, id))
+            .returning({ id: channelBookingLinks.id });
+        return row ?? null;
+    },
+    async listWebhookEvents(db, query) {
+        const conditions = [];
+        if (query.channelId)
+            conditions.push(eq(channelWebhookEvents.channelId, query.channelId));
+        if (query.status)
+            conditions.push(eq(channelWebhookEvents.status, query.status));
+        if (query.eventType)
+            conditions.push(eq(channelWebhookEvents.eventType, query.eventType));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(channelWebhookEvents)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(channelWebhookEvents.receivedAt)), db.select({ count: sql `count(*)::int` }).from(channelWebhookEvents).where(where), query.limit, query.offset);
+    },
+    async getWebhookEventById(db, id) {
+        const [row] = await db
+            .select()
+            .from(channelWebhookEvents)
+            .where(eq(channelWebhookEvents.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createWebhookEvent(db, data) {
+        const [row] = await db
+            .insert(channelWebhookEvents)
+            .values({
+            ...data,
+            receivedAt: toDateOrNull(data.receivedAt) ?? new Date(),
+            processedAt: toDateOrNull(data.processedAt),
+        })
+            .returning();
+        return row;
+    },
+    async updateWebhookEvent(db, id, data) {
+        const [row] = await db
+            .update(channelWebhookEvents)
+            .set({
+            ...data,
+            receivedAt: data.receivedAt ? new Date(data.receivedAt) : undefined,
+            processedAt: data.processedAt === undefined ? undefined : toDateOrNull(data.processedAt),
+        })
+            .where(eq(channelWebhookEvents.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteWebhookEvent(db, id) {
+        const [row] = await db
+            .delete(channelWebhookEvents)
+            .where(eq(channelWebhookEvents.id, id))
+            .returning({ id: channelWebhookEvents.id });
+        return row ?? null;
+    },
+};

package/dist/service/helpers.d.ts

@@ -0,0 +1,10 @@
+export declare function paginate<T extends object>(rowsQuery: Promise<T[]>, countQuery: Promise<Array<{
+    count: number;
+}>>, limit: number, offset: number): Promise<{
+    data: T[];
+    total: number;
+    limit: number;
+    offset: number;
+}>;
+export declare function toDateOrNull(value: string | null | undefined): Date | null;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/service/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/service/helpers.ts"],"names":[],"mappings":"AAAA,wBAAsB,QAAQ,CAAC,CAAC,SAAS,MAAM,EAC7C,SAAS,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC,EACvB,UAAU,EAAE,OAAO,CAAC,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,EAC7C,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM;;;;;GAIf;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,eAE5D"}

package/dist/service/helpers.js

@@ -0,0 +1,7 @@
+export 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 function toDateOrNull(value) {
+    return value ? new Date(value) : null;
+}

package/dist/service/inventory.d.ts

@@ -0,0 +1,193 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { ChannelInventoryAllotmentListQuery, ChannelInventoryAllotmentTargetListQuery, ChannelInventoryReleaseRuleListQuery, CreateChannelInventoryAllotmentInput, CreateChannelInventoryAllotmentTargetInput, CreateChannelInventoryReleaseRuleInput, UpdateChannelInventoryAllotmentInput, UpdateChannelInventoryAllotmentTargetInput, UpdateChannelInventoryReleaseRuleInput } from "./types.js";
+export declare const inventoryServiceOperations: {
+    listInventoryAllotments(db: PostgresJsDatabase, query: ChannelInventoryAllotmentListQuery): Promise<{
+        data: {
+            id: string;
+            channelId: string;
+            contractId: string | null;
+            productId: string;
+            optionId: string | null;
+            startTimeId: string | null;
+            validFrom: string | null;
+            validTo: string | null;
+            guaranteedCapacity: number | null;
+            maxCapacity: number | null;
+            active: boolean;
+            notes: string | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getInventoryAllotmentById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        channelId: string;
+        contractId: string | null;
+        productId: string;
+        optionId: string | null;
+        startTimeId: string | null;
+        validFrom: string | null;
+        validTo: string | null;
+        guaranteedCapacity: number | null;
+        maxCapacity: number | null;
+        active: boolean;
+        notes: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createInventoryAllotment(db: PostgresJsDatabase, data: CreateChannelInventoryAllotmentInput): Promise<{
+        createdAt: Date;
+        updatedAt: Date;
+        id: string;
+        active: boolean;
+        channelId: string;
+        productId: string;
+        notes: string | null;
+        contractId: string | null;
+        optionId: string | null;
+        startTimeId: string | null;
+        validFrom: string | null;
+        validTo: string | null;
+        guaranteedCapacity: number | null;
+        maxCapacity: number | null;
+    } | undefined>;
+    updateInventoryAllotment(db: PostgresJsDatabase, id: string, data: UpdateChannelInventoryAllotmentInput): Promise<{
+        id: string;
+        channelId: string;
+        contractId: string | null;
+        productId: string;
+        optionId: string | null;
+        startTimeId: string | null;
+        validFrom: string | null;
+        validTo: string | null;
+        guaranteedCapacity: number | null;
+        maxCapacity: number | null;
+        active: boolean;
+        notes: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteInventoryAllotment(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    listInventoryAllotmentTargets(db: PostgresJsDatabase, query: ChannelInventoryAllotmentTargetListQuery): Promise<{
+        data: {
+            id: string;
+            allotmentId: string;
+            slotId: string | null;
+            startTimeId: string | null;
+            dateLocal: string | null;
+            guaranteedCapacity: number | null;
+            maxCapacity: number | null;
+            soldCapacity: number | null;
+            remainingCapacity: number | null;
+            active: boolean;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getInventoryAllotmentTargetById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        allotmentId: string;
+        slotId: string | null;
+        startTimeId: string | null;
+        dateLocal: string | null;
+        guaranteedCapacity: number | null;
+        maxCapacity: number | null;
+        soldCapacity: number | null;
+        remainingCapacity: number | null;
+        active: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createInventoryAllotmentTarget(db: PostgresJsDatabase, data: CreateChannelInventoryAllotmentTargetInput): Promise<{
+        createdAt: Date;
+        updatedAt: Date;
+        id: string;
+        active: boolean;
+        startTimeId: string | null;
+        guaranteedCapacity: number | null;
+        maxCapacity: number | null;
+        slotId: string | null;
+        allotmentId: string;
+        dateLocal: string | null;
+        soldCapacity: number | null;
+        remainingCapacity: number | null;
+    } | undefined>;
+    updateInventoryAllotmentTarget(db: PostgresJsDatabase, id: string, data: UpdateChannelInventoryAllotmentTargetInput): Promise<{
+        id: string;
+        allotmentId: string;
+        slotId: string | null;
+        startTimeId: string | null;
+        dateLocal: string | null;
+        guaranteedCapacity: number | null;
+        maxCapacity: number | null;
+        soldCapacity: number | null;
+        remainingCapacity: number | null;
+        active: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteInventoryAllotmentTarget(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    listInventoryReleaseRules(db: PostgresJsDatabase, query: ChannelInventoryReleaseRuleListQuery): Promise<{
+        data: {
+            id: string;
+            allotmentId: string;
+            releaseMode: "manual" | "automatic";
+            releaseDaysBeforeStart: number | null;
+            releaseHoursBeforeStart: number | null;
+            unsoldAction: "release_to_general_pool" | "expire" | "retain";
+            notes: string | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getInventoryReleaseRuleById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        allotmentId: string;
+        releaseMode: "manual" | "automatic";
+        releaseDaysBeforeStart: number | null;
+        releaseHoursBeforeStart: number | null;
+        unsoldAction: "release_to_general_pool" | "expire" | "retain";
+        notes: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createInventoryReleaseRule(db: PostgresJsDatabase, data: CreateChannelInventoryReleaseRuleInput): Promise<{
+        createdAt: Date;
+        updatedAt: Date;
+        id: string;
+        notes: string | null;
+        allotmentId: string;
+        releaseMode: "manual" | "automatic";
+        releaseDaysBeforeStart: number | null;
+        releaseHoursBeforeStart: number | null;
+        unsoldAction: "release_to_general_pool" | "expire" | "retain";
+    } | undefined>;
+    updateInventoryReleaseRule(db: PostgresJsDatabase, id: string, data: UpdateChannelInventoryReleaseRuleInput): Promise<{
+        id: string;
+        allotmentId: string;
+        releaseMode: "manual" | "automatic";
+        releaseDaysBeforeStart: number | null;
+        releaseHoursBeforeStart: number | null;
+        unsoldAction: "release_to_general_pool" | "expire" | "retain";
+        notes: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteInventoryReleaseRule(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+};
+//# sourceMappingURL=inventory.d.ts.map

package/dist/service/inventory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inventory.d.ts","sourceRoot":"","sources":["../../src/service/inventory.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAQjE,OAAO,KAAK,EACV,kCAAkC,EAClC,wCAAwC,EACxC,oCAAoC,EACpC,oCAAoC,EACpC,0CAA0C,EAC1C,sCAAsC,EACtC,oCAAoC,EACpC,0CAA0C,EAC1C,sCAAsC,EACvC,MAAM,YAAY,CAAA;AAEnB,eAAO,MAAM,0BAA0B;gCACH,kBAAkB,SAAS,kCAAkC;;;;;;;;;;;;;;;;;;;;;kCA6B3D,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;;iCAU5D,kBAAkB,QAChB,oCAAoC;;;;;;;;;;;;;;;;iCAOtC,kBAAkB,MAClB,MAAM,QACJ,oCAAoC;;;;;;;;;;;;;;;;iCAUT,kBAAkB,MAAM,MAAM;;;sCAS3D,kBAAkB,SACf,wCAAwC;;;;;;;;;;;;;;;;;;;wCA8BP,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;uCAUlE,kBAAkB,QAChB,0CAA0C;;;;;;;;;;;;;;uCAO5C,kBAAkB,MAClB,MAAM,QACJ,0CAA0C;;;;;;;;;;;;;;uCAUT,kBAAkB,MAAM,MAAM;;;kCASjE,kBAAkB,SACf,oCAAoC;;;;;;;;;;;;;;;;oCAyBP,kBAAkB,MAAM,MAAM;;;;;;;;;;;mCAU9D,kBAAkB,QAChB,sCAAsC;;;;;;;;;;;mCAOxC,kBAAkB,MAClB,MAAM,QACJ,sCAAsC;;;;;;;;;;;mCAUT,kBAAkB,MAAM,MAAM;;;CAOpE,CAAA"}

package/dist/service/inventory.js

@@ -0,0 +1,154 @@
+import { and, desc, eq, sql } from "drizzle-orm";
+import { channelInventoryAllotments, channelInventoryAllotmentTargets, channelInventoryReleaseRules, } from "../schema.js";
+import { paginate } from "./helpers.js";
+export const inventoryServiceOperations = {
+    async listInventoryAllotments(db, query) {
+        const conditions = [];
+        if (query.channelId)
+            conditions.push(eq(channelInventoryAllotments.channelId, query.channelId));
+        if (query.contractId)
+            conditions.push(eq(channelInventoryAllotments.contractId, query.contractId));
+        if (query.productId)
+            conditions.push(eq(channelInventoryAllotments.productId, query.productId));
+        if (query.optionId)
+            conditions.push(eq(channelInventoryAllotments.optionId, query.optionId));
+        if (query.startTimeId)
+            conditions.push(eq(channelInventoryAllotments.startTimeId, query.startTimeId));
+        if (query.active !== undefined)
+            conditions.push(eq(channelInventoryAllotments.active, query.active));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(channelInventoryAllotments)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(channelInventoryAllotments.updatedAt)), db
+            .select({ count: sql `count(*)::int` })
+            .from(channelInventoryAllotments)
+            .where(where), query.limit, query.offset);
+    },
+    async getInventoryAllotmentById(db, id) {
+        const [row] = await db
+            .select()
+            .from(channelInventoryAllotments)
+            .where(eq(channelInventoryAllotments.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createInventoryAllotment(db, data) {
+        const [row] = await db.insert(channelInventoryAllotments).values(data).returning();
+        return row;
+    },
+    async updateInventoryAllotment(db, id, data) {
+        const [row] = await db
+            .update(channelInventoryAllotments)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(channelInventoryAllotments.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteInventoryAllotment(db, id) {
+        const [row] = await db
+            .delete(channelInventoryAllotments)
+            .where(eq(channelInventoryAllotments.id, id))
+            .returning({ id: channelInventoryAllotments.id });
+        return row ?? null;
+    },
+    async listInventoryAllotmentTargets(db, query) {
+        const conditions = [];
+        if (query.allotmentId)
+            conditions.push(eq(channelInventoryAllotmentTargets.allotmentId, query.allotmentId));
+        if (query.slotId)
+            conditions.push(eq(channelInventoryAllotmentTargets.slotId, query.slotId));
+        if (query.startTimeId)
+            conditions.push(eq(channelInventoryAllotmentTargets.startTimeId, query.startTimeId));
+        if (query.dateLocal)
+            conditions.push(eq(channelInventoryAllotmentTargets.dateLocal, query.dateLocal));
+        if (query.active !== undefined)
+            conditions.push(eq(channelInventoryAllotmentTargets.active, query.active));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(channelInventoryAllotmentTargets)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(channelInventoryAllotmentTargets.updatedAt)), db
+            .select({ count: sql `count(*)::int` })
+            .from(channelInventoryAllotmentTargets)
+            .where(where), query.limit, query.offset);
+    },
+    async getInventoryAllotmentTargetById(db, id) {
+        const [row] = await db
+            .select()
+            .from(channelInventoryAllotmentTargets)
+            .where(eq(channelInventoryAllotmentTargets.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createInventoryAllotmentTarget(db, data) {
+        const [row] = await db.insert(channelInventoryAllotmentTargets).values(data).returning();
+        return row;
+    },
+    async updateInventoryAllotmentTarget(db, id, data) {
+        const [row] = await db
+            .update(channelInventoryAllotmentTargets)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(channelInventoryAllotmentTargets.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteInventoryAllotmentTarget(db, id) {
+        const [row] = await db
+            .delete(channelInventoryAllotmentTargets)
+            .where(eq(channelInventoryAllotmentTargets.id, id))
+            .returning({ id: channelInventoryAllotmentTargets.id });
+        return row ?? null;
+    },
+    async listInventoryReleaseRules(db, query) {
+        const conditions = [];
+        if (query.allotmentId)
+            conditions.push(eq(channelInventoryReleaseRules.allotmentId, query.allotmentId));
+        if (query.releaseMode)
+            conditions.push(eq(channelInventoryReleaseRules.releaseMode, query.releaseMode));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(channelInventoryReleaseRules)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(channelInventoryReleaseRules.updatedAt)), db
+            .select({ count: sql `count(*)::int` })
+            .from(channelInventoryReleaseRules)
+            .where(where), query.limit, query.offset);
+    },
+    async getInventoryReleaseRuleById(db, id) {
+        const [row] = await db
+            .select()
+            .from(channelInventoryReleaseRules)
+            .where(eq(channelInventoryReleaseRules.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createInventoryReleaseRule(db, data) {
+        const [row] = await db.insert(channelInventoryReleaseRules).values(data).returning();
+        return row;
+    },
+    async updateInventoryReleaseRule(db, id, data) {
+        const [row] = await db
+            .update(channelInventoryReleaseRules)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(channelInventoryReleaseRules.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteInventoryReleaseRule(db, id) {
+        const [row] = await db
+            .delete(channelInventoryReleaseRules)
+            .where(eq(channelInventoryReleaseRules.id, id))
+            .returning({ id: channelInventoryReleaseRules.id });
+        return row ?? null;
+    },
+};