@voyant-travel/distribution 0.109.8

package/dist/service/channels.js

@@ -0,0 +1,305 @@
+import { identityService } from "@voyant-travel/identity/service";
+import { and, eq, inArray, sql } from "drizzle-orm";
+import { channelContactProjections, channels } from "../schema.js";
+const channelEntityType = "channel";
+const channelBaseIdentitySource = "distribution.base";
+const channelPrimaryNamedContactSource = "distribution.primary_contact";
+function emptyChannelHydratedFields() {
+    return {
+        website: null,
+        contactName: null,
+        contactEmail: null,
+    };
+}
+function normalizeWebsite(value) {
+    return value.trim().toLowerCase();
+}
+function isManagedBySource(metadata, source) {
+    return metadata?.managedBy === source;
+}
+function toNullableTrimmed(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : null;
+}
+function toCreateChannelBaseValues(data) {
+    return {
+        name: data.name,
+        description: data.description,
+        kind: data.kind,
+        status: data.status,
+        metadata: data.metadata,
+    };
+}
+function toUpdateChannelBaseValues(data) {
+    return {
+        name: data.name,
+        description: data.description,
+        kind: data.kind,
+        status: data.status,
+        metadata: data.metadata,
+    };
+}
+async function ensureChannelExists(db, channelId) {
+    const [row] = await db
+        .select({ id: channels.id })
+        .from(channels)
+        .where(eq(channels.id, channelId))
+        .limit(1);
+    return row ?? null;
+}
+async function syncChannelIdentity(db, channelId, data) {
+    const [existingContactPoints, existingNamedContacts] = await Promise.all([
+        identityService.listContactPointsForEntity(db, channelEntityType, channelId),
+        identityService.listNamedContactsForEntity(db, channelEntityType, channelId),
+    ]);
+    const managedWebsiteContact = existingContactPoints.find((point) => point.kind === "website" &&
+        isManagedBySource(point.metadata, channelBaseIdentitySource));
+    const managedPrimaryContact = existingNamedContacts.find((contact) => isManagedBySource(contact.metadata, channelPrimaryNamedContactSource));
+    const website = toNullableTrimmed(data.website);
+    if (!website) {
+        if (managedWebsiteContact) {
+            await identityService.deleteContactPoint(db, managedWebsiteContact.id);
+        }
+    }
+    else {
+        const websitePayload = {
+            entityType: channelEntityType,
+            entityId: channelId,
+            kind: "website",
+            label: "website",
+            value: website,
+            normalizedValue: normalizeWebsite(website),
+            isPrimary: true,
+            metadata: {
+                managedBy: channelBaseIdentitySource,
+            },
+        };
+        if (managedWebsiteContact) {
+            await identityService.updateContactPoint(db, managedWebsiteContact.id, websitePayload);
+        }
+        else {
+            await identityService.createContactPoint(db, websitePayload);
+        }
+    }
+    const contactName = toNullableTrimmed(data.contactName);
+    const contactEmail = toNullableTrimmed(data.contactEmail);
+    const hasPrimaryContact = Boolean(contactName || contactEmail);
+    if (!hasPrimaryContact) {
+        if (managedPrimaryContact) {
+            await identityService.deleteNamedContact(db, managedPrimaryContact.id);
+        }
+        await rebuildChannelContactProjection(db, channelId);
+        return;
+    }
+    const namedContactPayload = {
+        entityType: channelEntityType,
+        entityId: channelId,
+        role: "primary",
+        name: contactName ?? contactEmail ?? "Primary contact",
+        email: contactEmail,
+        isPrimary: true,
+        metadata: {
+            managedBy: channelPrimaryNamedContactSource,
+        },
+    };
+    if (managedPrimaryContact) {
+        await identityService.updateNamedContact(db, managedPrimaryContact.id, namedContactPayload);
+    }
+    else {
+        await identityService.createNamedContact(db, namedContactPayload);
+    }
+    await rebuildChannelContactProjection(db, channelId);
+}
+async function deleteChannelIdentity(db, channelId) {
+    const [contactPoints, namedContacts] = await Promise.all([
+        identityService.listContactPointsForEntity(db, channelEntityType, channelId),
+        identityService.listNamedContactsForEntity(db, channelEntityType, channelId),
+    ]);
+    await Promise.all([
+        ...contactPoints.map((point) => identityService.deleteContactPoint(db, point.id)),
+        ...namedContacts.map((contact) => identityService.deleteNamedContact(db, contact.id)),
+    ]);
+    await rebuildChannelContactProjection(db, channelId);
+}
+async function rebuildChannelContactProjection(db, channelId) {
+    const [contactPoints, namedContacts] = await Promise.all([
+        identityService.listContactPointsForEntity(db, channelEntityType, channelId),
+        identityService.listNamedContactsForEntity(db, channelEntityType, channelId),
+    ]);
+    const primaryWebsite = contactPoints.find((point) => point.kind === "website" && point.isPrimary) ??
+        contactPoints.find((point) => point.kind === "website") ??
+        null;
+    const primaryContact = namedContacts.find((contact) => contact.isPrimary) ?? namedContacts[0] ?? null;
+    await db
+        .delete(channelContactProjections)
+        .where(eq(channelContactProjections.channelId, channelId));
+    if (!primaryWebsite && !primaryContact) {
+        return;
+    }
+    await db.insert(channelContactProjections).values({
+        channelId,
+        websiteContactPointId: primaryWebsite?.id ?? null,
+        primaryNamedContactId: primaryContact?.id ?? null,
+        website: primaryWebsite?.value ?? null,
+        contactName: primaryContact?.name ?? null,
+        contactEmail: primaryContact?.email ?? null,
+    });
+}
+async function hydrateChannels(db, rows) {
+    if (rows.length === 0) {
+        return rows.map((row) => ({ ...row, ...emptyChannelHydratedFields() }));
+    }
+    const ids = rows.map((row) => row.id);
+    const projections = await db
+        .select()
+        .from(channelContactProjections)
+        .where(inArray(channelContactProjections.channelId, ids));
+    const projectionMap = new Map(projections.map((projection) => [projection.channelId, projection]));
+    return rows.map((row) => {
+        const projection = projectionMap.get(row.id);
+        return {
+            ...row,
+            website: projection?.website ?? null,
+            contactName: projection?.contactName ?? null,
+            contactEmail: projection?.contactEmail ?? null,
+        };
+    });
+}
+export const channelServiceOperations = {
+    async listChannels(db, query) {
+        const conditions = [];
+        if (query.kind)
+            conditions.push(eq(channels.kind, query.kind));
+        if (query.status)
+            conditions.push(eq(channels.status, query.status));
+        const where = conditions.length ? and(...conditions) : undefined;
+        const [rows, countResult] = await Promise.all([
+            db
+                .select()
+                .from(channels)
+                .where(where)
+                .limit(query.limit)
+                .offset(query.offset)
+                .orderBy(channels.createdAt),
+            db.select({ count: sql `count(*)::int` }).from(channels).where(where),
+        ]);
+        return {
+            data: await hydrateChannels(db, rows),
+            total: countResult[0]?.count ?? 0,
+            limit: query.limit,
+            offset: query.offset,
+        };
+    },
+    async getChannelById(db, id) {
+        const [row] = await db.select().from(channels).where(eq(channels.id, id)).limit(1);
+        if (!row) {
+            return null;
+        }
+        const [hydrated] = await hydrateChannels(db, [row]);
+        return hydrated ?? null;
+    },
+    async createChannel(db, data) {
+        const [row] = await db.insert(channels).values(toCreateChannelBaseValues(data)).returning();
+        if (!row) {
+            throw new Error("Failed to create channel");
+        }
+        await syncChannelIdentity(db, row.id, data);
+        return channelServiceOperations.getChannelById(db, row.id);
+    },
+    async updateChannel(db, id, data) {
+        const existing = await channelServiceOperations.getChannelById(db, id);
+        if (!existing) {
+            return null;
+        }
+        await db
+            .update(channels)
+            .set({ ...toUpdateChannelBaseValues(data), updatedAt: new Date() })
+            .where(eq(channels.id, id));
+        await syncChannelIdentity(db, id, {
+            website: data.website === undefined ? existing.website : data.website,
+            contactName: data.contactName === undefined ? existing.contactName : data.contactName,
+            contactEmail: data.contactEmail === undefined ? existing.contactEmail : data.contactEmail,
+        });
+        return channelServiceOperations.getChannelById(db, id);
+    },
+    async deleteChannel(db, id) {
+        await deleteChannelIdentity(db, id);
+        const [row] = await db
+            .delete(channels)
+            .where(eq(channels.id, id))
+            .returning({ id: channels.id });
+        return row ?? null;
+    },
+    async listChannelContactPoints(db, channelId) {
+        const channel = await ensureChannelExists(db, channelId);
+        if (!channel)
+            return null;
+        return identityService.listContactPointsForEntity(db, channelEntityType, channelId);
+    },
+    async createChannelContactPoint(db, channelId, data) {
+        const channel = await ensureChannelExists(db, channelId);
+        if (!channel)
+            return null;
+        const row = await identityService.createContactPoint(db, {
+            ...data,
+            entityType: channelEntityType,
+            entityId: channelId,
+        });
+        await rebuildChannelContactProjection(db, channelId);
+        return row;
+    },
+    async updateChannelContactPoint(db, id, data) {
+        const existing = await identityService.getContactPointById(db, id);
+        if (!existing)
+            return null;
+        const row = await identityService.updateContactPoint(db, id, data);
+        if (row?.entityType === channelEntityType) {
+            await rebuildChannelContactProjection(db, row.entityId);
+        }
+        return row;
+    },
+    async deleteChannelContactPoint(db, id) {
+        const existing = await identityService.getContactPointById(db, id);
+        const row = await identityService.deleteContactPoint(db, id);
+        if (row && existing?.entityType === channelEntityType) {
+            await rebuildChannelContactProjection(db, existing.entityId);
+        }
+        return row;
+    },
+    async listChannelContacts(db, channelId) {
+        const channel = await ensureChannelExists(db, channelId);
+        if (!channel)
+            return null;
+        return identityService.listNamedContactsForEntity(db, channelEntityType, channelId);
+    },
+    async createChannelContact(db, channelId, data) {
+        const channel = await ensureChannelExists(db, channelId);
+        if (!channel)
+            return null;
+        const row = await identityService.createNamedContact(db, {
+            ...data,
+            entityType: channelEntityType,
+            entityId: channelId,
+        });
+        await rebuildChannelContactProjection(db, channelId);
+        return row;
+    },
+    async updateChannelContact(db, id, data) {
+        const existing = await identityService.getNamedContactById(db, id);
+        if (!existing)
+            return null;
+        const row = await identityService.updateNamedContact(db, id, data);
+        if (row?.entityType === channelEntityType) {
+            await rebuildChannelContactProjection(db, row.entityId);
+        }
+        return row;
+    },
+    async deleteChannelContact(db, id) {
+        const existing = await identityService.getNamedContactById(db, id);
+        const row = await identityService.deleteNamedContact(db, id);
+        if (row && existing?.entityType === channelEntityType) {
+            await rebuildChannelContactProjection(db, existing.entityId);
+        }
+        return row;
+    },
+};

package/dist/service/commercial.d.ts

@@ -0,0 +1,385 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { ChannelBookingLinkListQuery, ChannelCommissionRuleListQuery, ChannelContractListQuery, ChannelProductMappingListQuery, ChannelWebhookEventListQuery, CreateChannelBookingLinkInput, CreateChannelCommissionRuleInput, CreateChannelContractInput, CreateChannelProductMappingInput, CreateChannelWebhookEventInput, UpdateChannelBookingLinkInput, UpdateChannelCommissionRuleInput, UpdateChannelContractInput, UpdateChannelProductMappingInput, UpdateChannelWebhookEventInput } from "./types.js";
+export declare const commercialServiceOperations: {
+    listContracts(db: PostgresJsDatabase, query: ChannelContractListQuery): Promise<{
+        data: {
+            id: string;
+            channelId: string;
+            supplierId: string | null;
+            status: "active" | "draft" | "expired" | "terminated";
+            startsAt: string;
+            endsAt: string | null;
+            paymentOwner: "operator" | "channel" | "split";
+            cancellationOwner: "operator" | "channel" | "mixed";
+            settlementTerms: string | null;
+            notes: string | null;
+            rateLimitRps: number | null;
+            rateLimitBurst: number | null;
+            rateLimitPriorityGates: Record<string, number> | null;
+            policy: Record<string, unknown> | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getContractById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        channelId: string;
+        supplierId: string | null;
+        status: "active" | "draft" | "expired" | "terminated";
+        startsAt: string;
+        endsAt: string | null;
+        paymentOwner: "operator" | "channel" | "split";
+        cancellationOwner: "operator" | "channel" | "mixed";
+        settlementTerms: string | null;
+        notes: string | null;
+        rateLimitRps: number | null;
+        rateLimitBurst: number | null;
+        rateLimitPriorityGates: Record<string, number> | null;
+        policy: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createContract(db: PostgresJsDatabase, data: CreateChannelContractInput): Promise<{
+        paymentOwner: "operator" | "channel" | "split";
+        createdAt: Date;
+        updatedAt: Date;
+        id: string;
+        status: "active" | "draft" | "expired" | "terminated";
+        rateLimitRps: number | null;
+        rateLimitBurst: number | null;
+        rateLimitPriorityGates: Record<string, number> | null;
+        channelId: string;
+        policy: Record<string, unknown> | null;
+        supplierId: string | null;
+        startsAt: string;
+        endsAt: string | null;
+        cancellationOwner: "operator" | "channel" | "mixed";
+        settlementTerms: string | null;
+        notes: string | null;
+    } | undefined>;
+    updateContract(db: PostgresJsDatabase, id: string, data: UpdateChannelContractInput): Promise<{
+        id: string;
+        channelId: string;
+        supplierId: string | null;
+        status: "active" | "draft" | "expired" | "terminated";
+        startsAt: string;
+        endsAt: string | null;
+        paymentOwner: "operator" | "channel" | "split";
+        cancellationOwner: "operator" | "channel" | "mixed";
+        settlementTerms: string | null;
+        notes: string | null;
+        rateLimitRps: number | null;
+        rateLimitBurst: number | null;
+        rateLimitPriorityGates: Record<string, number> | null;
+        policy: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteContract(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    listCommissionRules(db: PostgresJsDatabase, query: ChannelCommissionRuleListQuery): Promise<{
+        data: {
+            id: string;
+            contractId: string;
+            scope: "booking" | "product" | "rate" | "category";
+            productId: string | null;
+            externalRateId: string | null;
+            externalCategoryId: string | null;
+            commissionType: "fixed" | "percentage";
+            amountCents: number | null;
+            percentBasisPoints: number | null;
+            validFrom: string | null;
+            validTo: string | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getCommissionRuleById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        contractId: string;
+        scope: "booking" | "product" | "rate" | "category";
+        productId: string | null;
+        externalRateId: string | null;
+        externalCategoryId: string | null;
+        commissionType: "fixed" | "percentage";
+        amountCents: number | null;
+        percentBasisPoints: number | null;
+        validFrom: string | null;
+        validTo: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createCommissionRule(db: PostgresJsDatabase, data: CreateChannelCommissionRuleInput): Promise<{
+        createdAt: Date;
+        updatedAt: Date;
+        id: string;
+        productId: string | null;
+        externalRateId: string | null;
+        externalCategoryId: string | null;
+        contractId: string;
+        validFrom: string | null;
+        validTo: string | null;
+        scope: "booking" | "product" | "rate" | "category";
+        commissionType: "fixed" | "percentage";
+        amountCents: number | null;
+        percentBasisPoints: number | null;
+    } | undefined>;
+    updateCommissionRule(db: PostgresJsDatabase, id: string, data: UpdateChannelCommissionRuleInput): Promise<{
+        id: string;
+        contractId: string;
+        scope: "booking" | "product" | "rate" | "category";
+        productId: string | null;
+        externalRateId: string | null;
+        externalCategoryId: string | null;
+        commissionType: "fixed" | "percentage";
+        amountCents: number | null;
+        percentBasisPoints: number | null;
+        validFrom: string | null;
+        validTo: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteCommissionRule(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    listProductMappings(db: PostgresJsDatabase, query: ChannelProductMappingListQuery): Promise<{
+        data: {
+            id: string;
+            channelId: string;
+            productId: string;
+            externalProductId: string | null;
+            externalRateId: string | null;
+            externalCategoryId: string | null;
+            active: boolean;
+            sourceKind: string | null;
+            sourceConnectionId: string | null;
+            pushBookings: boolean;
+            pushAvailability: boolean;
+            pushContent: boolean;
+            policy: Record<string, unknown> | null;
+            lastPushedContentHash: string | null;
+            lastPushedContentAt: Date | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getProductMappingById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        channelId: string;
+        productId: string;
+        externalProductId: string | null;
+        externalRateId: string | null;
+        externalCategoryId: string | null;
+        active: boolean;
+        sourceKind: string | null;
+        sourceConnectionId: string | null;
+        pushBookings: boolean;
+        pushAvailability: boolean;
+        pushContent: boolean;
+        policy: Record<string, unknown> | null;
+        lastPushedContentHash: string | null;
+        lastPushedContentAt: Date | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createProductMapping(db: PostgresJsDatabase, data: CreateChannelProductMappingInput): Promise<{
+        createdAt: Date;
+        updatedAt: Date;
+        id: string;
+        active: boolean;
+        channelId: string;
+        sourceKind: string | null;
+        sourceConnectionId: string | null;
+        productId: string;
+        externalProductId: string | null;
+        externalRateId: string | null;
+        externalCategoryId: string | null;
+        pushBookings: boolean;
+        pushAvailability: boolean;
+        pushContent: boolean;
+        policy: Record<string, unknown> | null;
+        lastPushedContentHash: string | null;
+        lastPushedContentAt: Date | null;
+    } | undefined>;
+    updateProductMapping(db: PostgresJsDatabase, id: string, data: UpdateChannelProductMappingInput): Promise<{
+        id: string;
+        channelId: string;
+        productId: string;
+        externalProductId: string | null;
+        externalRateId: string | null;
+        externalCategoryId: string | null;
+        active: boolean;
+        sourceKind: string | null;
+        sourceConnectionId: string | null;
+        pushBookings: boolean;
+        pushAvailability: boolean;
+        pushContent: boolean;
+        policy: Record<string, unknown> | null;
+        lastPushedContentHash: string | null;
+        lastPushedContentAt: Date | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteProductMapping(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    listBookingLinks(db: PostgresJsDatabase, query: ChannelBookingLinkListQuery): Promise<{
+        data: {
+            id: string;
+            channelId: string;
+            bookingId: string;
+            bookingItemId: string | null;
+            externalBookingId: string | null;
+            externalReference: string | null;
+            externalStatus: string | null;
+            bookedAtExternal: Date | null;
+            lastSyncedAt: Date | null;
+            sourceKind: string | null;
+            sourceConnectionId: string | null;
+            pushStatus: string;
+            pushAttempts: number;
+            lastPushAt: Date | null;
+            lastError: string | null;
+            pushedPayloadHash: string | null;
+            idempotencyKey: string | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getBookingLinkById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        channelId: string;
+        bookingId: string;
+        bookingItemId: string | null;
+        externalBookingId: string | null;
+        externalReference: string | null;
+        externalStatus: string | null;
+        bookedAtExternal: Date | null;
+        lastSyncedAt: Date | null;
+        sourceKind: string | null;
+        sourceConnectionId: string | null;
+        pushStatus: string;
+        pushAttempts: number;
+        lastPushAt: Date | null;
+        lastError: string | null;
+        pushedPayloadHash: string | null;
+        idempotencyKey: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createBookingLink(db: PostgresJsDatabase, data: CreateChannelBookingLinkInput): Promise<{
+        bookingId: string;
+        createdAt: Date;
+        updatedAt: Date;
+        idempotencyKey: string | null;
+        id: string;
+        channelId: string;
+        bookingItemId: string | null;
+        externalBookingId: string | null;
+        externalReference: string | null;
+        externalStatus: string | null;
+        bookedAtExternal: Date | null;
+        lastSyncedAt: Date | null;
+        sourceKind: string | null;
+        sourceConnectionId: string | null;
+        pushStatus: string;
+        pushAttempts: number;
+        lastPushAt: Date | null;
+        lastError: string | null;
+        pushedPayloadHash: string | null;
+    } | undefined>;
+    updateBookingLink(db: PostgresJsDatabase, id: string, data: UpdateChannelBookingLinkInput): Promise<{
+        id: string;
+        channelId: string;
+        bookingId: string;
+        bookingItemId: string | null;
+        externalBookingId: string | null;
+        externalReference: string | null;
+        externalStatus: string | null;
+        bookedAtExternal: Date | null;
+        lastSyncedAt: Date | null;
+        sourceKind: string | null;
+        sourceConnectionId: string | null;
+        pushStatus: string;
+        pushAttempts: number;
+        lastPushAt: Date | null;
+        lastError: string | null;
+        pushedPayloadHash: string | null;
+        idempotencyKey: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteBookingLink(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    listWebhookEvents(db: PostgresJsDatabase, query: ChannelWebhookEventListQuery): Promise<{
+        data: {
+            id: string;
+            channelId: string;
+            eventType: string;
+            externalEventId: string | null;
+            payload: Record<string, unknown>;
+            receivedAt: Date;
+            processedAt: Date | null;
+            status: "pending" | "failed" | "processed" | "ignored";
+            errorMessage: string | null;
+            createdAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getWebhookEventById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        channelId: string;
+        eventType: string;
+        externalEventId: string | null;
+        payload: Record<string, unknown>;
+        receivedAt: Date;
+        processedAt: Date | null;
+        status: "pending" | "failed" | "processed" | "ignored";
+        errorMessage: string | null;
+        createdAt: Date;
+    } | null>;
+    createWebhookEvent(db: PostgresJsDatabase, data: CreateChannelWebhookEventInput): Promise<{
+        createdAt: Date;
+        id: string;
+        status: "pending" | "failed" | "processed" | "ignored";
+        channelId: string;
+        errorMessage: string | null;
+        eventType: string;
+        externalEventId: string | null;
+        payload: Record<string, unknown>;
+        receivedAt: Date;
+        processedAt: Date | null;
+    } | undefined>;
+    updateWebhookEvent(db: PostgresJsDatabase, id: string, data: UpdateChannelWebhookEventInput): Promise<{
+        id: string;
+        channelId: string;
+        eventType: string;
+        externalEventId: string | null;
+        payload: Record<string, unknown>;
+        receivedAt: Date;
+        processedAt: Date | null;
+        status: "pending" | "failed" | "processed" | "ignored";
+        errorMessage: string | null;
+        createdAt: Date;
+    } | null>;
+    deleteWebhookEvent(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+};
+//# sourceMappingURL=commercial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"commercial.d.ts","sourceRoot":"","sources":["../../src/service/commercial.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAUjE,OAAO,KAAK,EACV,2BAA2B,EAC3B,8BAA8B,EAC9B,wBAAwB,EACxB,8BAA8B,EAC9B,4BAA4B,EAC5B,6BAA6B,EAC7B,gCAAgC,EAChC,0BAA0B,EAC1B,gCAAgC,EAChC,8BAA8B,EAC9B,6BAA6B,EAC7B,gCAAgC,EAChC,0BAA0B,EAC1B,gCAAgC,EAChC,8BAA8B,EAC/B,MAAM,YAAY,CAAA;AAEnB,eAAO,MAAM,2BAA2B;sBACd,kBAAkB,SAAS,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;wBAoBjD,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;;;;uBAS/B,kBAAkB,QAAQ,0BAA0B;;;;;;;;;;;;;;;;;;uBAKpD,kBAAkB,MAAM,MAAM,QAAQ,0BAA0B;;;;;;;;;;;;;;;;;;uBAShE,kBAAkB,MAAM,MAAM;;;4BAQzB,kBAAkB,SAAS,8BAA8B;;;;;;;;;;;;;;;;;;;;8BAoBvD,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;6BAS/B,kBAAkB,QAAQ,gCAAgC;;;;;;;;;;;;;;;6BAMnF,kBAAkB,MAClB,MAAM,QACJ,gCAAgC;;;;;;;;;;;;;;;6BAUT,kBAAkB,MAAM,MAAM;;;4BAQ/B,kBAAkB,SAAS,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;8BAoBvD,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;;;;;6BAS/B,kBAAkB,QAAQ,gCAAgC;;;;;;;;;;;;;;;;;;;6BAMnF,kBAAkB,MAClB,MAAM,QACJ,gCAAgC;;;;;;;;;;;;;;;;;;;6BAUT,kBAAkB,MAAM,MAAM;;;yBAQlC,kBAAkB,SAAS,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;2BAqBpD,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;0BAS/B,kBAAkB,QAAQ,6BAA6B;;;;;;;;;;;;;;;;;;;;;0BAYvD,kBAAkB,MAAM,MAAM,QAAQ,6BAA6B;;;;;;;;;;;;;;;;;;;;;0BAenE,kBAAkB,MAAM,MAAM;;;0BAQ9B,kBAAkB,SAAS,4BAA4B;;;;;;;;;;;;;;;;;4BAoBrD,kBAAkB,MAAM,MAAM;;;;;;;;;;;;2BAS/B,kBAAkB,QAAQ,8BAA8B;;;;;;;;;;;;2BAa/E,kBAAkB,MAClB,MAAM,QACJ,8BAA8B;;;;;;;;;;;;2BAcT,kBAAkB,MAAM,MAAM;;;CAO5D,CAAA"}