@voyant-travel/inventory 0.1.0

package/dist/extras/service-content.js

@@ -0,0 +1,253 @@
+/**
+ * Extras content service — `getExtraContent` with locale-resolved
+ * cache reads, SWR refresh, and synthesizer fallback.
+ *
+ * Mirrors `service-content.ts` in the products / cruises / accommodations
+ * / charters packages but extras-shaped. The extras content aggregate
+ * (§3.2 / §3.6) is `{ extra, options[], media[], policies[] }` — one
+ * payload returned by a single getContent. Pricing stays out (volatile-
+ * live, flows through `liveResolve`).
+ *
+ * Extras don't appear in the search index (per the vertical's catalog-
+ * policy.ts), but sourced extras still need rich content for the
+ * booking-flow's add-on selection UI. The cache layer covers exactly
+ * that surface.
+ */
+import { createInvalidateOnDrift, fetchOverlaysForEntity, isStale, pickBestCachedLocale, readSourcedEntry, withContentRefreshLock, } from "@voyant-travel/catalog";
+import { and, eq } from "drizzle-orm";
+import { EXTRAS_CONTENT_SCHEMA_VERSION, extraContentSchema, mergeOverlaysIntoExtraContent, validateExtraContent, } from "./content-shape.js";
+import { EXTRAS_CONTENT_MARKET_ANY, extrasSourcedContentTable, } from "./schema-sourced-content.js";
+import { synthesizeExtraContent, } from "./service-content-synthesizer.js";
+/** Extras cache TTL is 24h — same as products. */
+const EXTRAS_DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
+export async function getExtraContent(db, entityId, scope, options) {
+    const sourcedEntry = await readSourcedEntry(db, "extras", entityId);
+    if (!sourcedEntry)
+        return null;
+    const provenance = {
+        kind: "sourced",
+        provenance: {
+            source_kind: sourcedEntry.source_kind,
+            source_provider: sourcedEntry.source_provider ?? undefined,
+            source_connection_id: sourcedEntry.source_connection_id ?? undefined,
+            source_ref: sourcedEntry.source_ref ?? undefined,
+            source_freshness: sourcedEntry.source_freshness,
+            last_sourced_at: sourcedEntry.last_sourced_at ?? undefined,
+        },
+        entry_id: sourcedEntry.id,
+        status: sourcedEntry.status,
+        projection: sourcedEntry.projection,
+        projection_etag: sourcedEntry.projection_etag,
+        projection_seen_at: sourcedEntry.projection_seen_at,
+        first_seen_at: sourcedEntry.first_seen_at,
+        last_seen_at: sourcedEntry.last_seen_at,
+    };
+    const adapter = sourcedEntry.source_connection_id
+        ? (options.registry.resolveByConnection(sourcedEntry.source_connection_id) ??
+            options.registry.byKind(sourcedEntry.source_kind)[0]?.adapter)
+        : options.registry.byKind(sourcedEntry.source_kind)[0]?.adapter;
+    const adapterCtx = options.buildAdapterContext?.(adapter) ?? {
+        connection_id: sourcedEntry.source_connection_id ?? sourcedEntry.source_kind,
+    };
+    const market = scope.market ?? EXTRAS_CONTENT_MARKET_ANY;
+    const acceptMT = scope.acceptMachineTranslated ?? true;
+    const cachedRows = await fetchCacheCandidates(db, entityId, market);
+    const eligibleRows = acceptMT ? cachedRows : cachedRows.filter((r) => !r.machine_translated);
+    const best = pickBestCachedLocale(eligibleRows.map((row) => ({ ...row, locale: row.locale })), scope.preferredLocales);
+    if (best && !isStale(best.candidate)) {
+        return finalizeFromCache(db, entityId, best, false, options);
+    }
+    if (best && isStale(best.candidate)) {
+        if (adapter?.getContent) {
+            void scheduleRefresh(db, adapter, adapterCtx, {
+                entity_module: "extras",
+                entity_id: entityId,
+                locale: scope.preferredLocales[0] ?? best.candidate.locale,
+                market,
+                currency: scope.currency,
+            });
+        }
+        return finalizeFromCache(db, entityId, best, true, options);
+    }
+    if (!adapter?.getContent) {
+        const overlays = await fetchOverlaysForEntity(db, "extras", entityId);
+        const synthesized = synthesizeExtraContent({ locale: scope.preferredLocales[0] ?? "en-GB" }, {
+            provenance,
+            overlays: overlays.map((o) => ({ field_path: o.field_path, value: o.value })),
+        });
+        return wrapSynthesized(synthesized, scope, false);
+    }
+    const fresh = await fetchFreshContent(db, adapter, adapterCtx, {
+        entity_module: "extras",
+        entity_id: entityId,
+        locale: scope.preferredLocales[0] ?? "en-GB",
+        market,
+        currency: scope.currency,
+    });
+    if (!fresh) {
+        const overlays = await fetchOverlaysForEntity(db, "extras", entityId);
+        const synthesized = synthesizeExtraContent({ locale: scope.preferredLocales[0] ?? "en-GB" }, {
+            provenance,
+            overlays: overlays.map((o) => ({ field_path: o.field_path, value: o.value })),
+        });
+        return wrapSynthesized(synthesized, scope, false);
+    }
+    return finalizeFresh(db, entityId, fresh, scope, options);
+}
+async function fetchCacheCandidates(db, entityId, market) {
+    return db
+        .select()
+        .from(extrasSourcedContentTable)
+        .where(and(eq(extrasSourcedContentTable.entity_id, entityId), eq(extrasSourcedContentTable.market, market), eq(extrasSourcedContentTable.content_schema_version, EXTRAS_CONTENT_SCHEMA_VERSION)));
+}
+async function fetchFreshContent(db, adapter, ctx, request) {
+    const result = await withContentRefreshLock(db, {
+        entityModule: request.entity_module,
+        entityId: request.entity_id,
+        locale: request.locale,
+        market: request.market,
+    }, async () => {
+        const got = await adapter.getContent(ctx, request);
+        const validation = validateExtraContent(got.content);
+        if (!validation.valid) {
+            throw new Error(`extras getContent for ${request.entity_id} failed validation: ${validation.reason}`);
+        }
+        await writeCacheRow(db, request, got);
+        return got;
+    });
+    return result ?? null;
+}
+function scheduleRefresh(db, adapter, ctx, request) {
+    void withContentRefreshLock(db, {
+        entityModule: request.entity_module,
+        entityId: request.entity_id,
+        locale: request.locale,
+        market: request.market,
+    }, async () => {
+        const got = await adapter.getContent(ctx, request);
+        const validation = validateExtraContent(got.content);
+        if (!validation.valid)
+            return;
+        await writeCacheRow(db, request, got);
+    }).catch(() => {
+        // intentional swallow — see §3.4 SWR refresh contract
+    });
+}
+async function writeCacheRow(db, request, result) {
+    const market = request.market ?? EXTRAS_CONTENT_MARKET_ANY;
+    const now = new Date();
+    // Coerce JSON-string dates to Date — see products writeCacheRow.
+    const sourceUpdatedAt = toDateOrNull(result.source_updated_at);
+    const freshUntil = toDateOrNull(result.fresh_until) ?? new Date(now.getTime() + EXTRAS_DEFAULT_TTL_MS);
+    await db
+        .insert(extrasSourcedContentTable)
+        .values({
+        entity_id: request.entity_id,
+        locale: request.locale,
+        market,
+        payload: result.content,
+        content_schema_version: result.content_schema_version,
+        returned_locale: result.returned_locale,
+        machine_translated: result.machine_translated ?? false,
+        source_updated_at: sourceUpdatedAt,
+        fetched_at: now,
+        fresh_until: freshUntil,
+        etag: result.etag ?? null,
+        fetch_status: "ok",
+        fetch_error: null,
+    })
+        .onConflictDoUpdate({
+        target: [
+            extrasSourcedContentTable.entity_id,
+            extrasSourcedContentTable.locale,
+            extrasSourcedContentTable.market,
+        ],
+        set: {
+            payload: result.content,
+            content_schema_version: result.content_schema_version,
+            returned_locale: result.returned_locale,
+            machine_translated: result.machine_translated ?? false,
+            source_updated_at: sourceUpdatedAt,
+            fetched_at: now,
+            fresh_until: freshUntil,
+            etag: result.etag ?? null,
+            fetch_status: "ok",
+            fetch_error: null,
+        },
+    });
+}
+async function finalizeFromCache(db, entityId, best, servedStale, options) {
+    const validation = validateExtraContent(best.candidate.payload);
+    if (!validation.valid) {
+        throw new Error(`extras cache row for ${entityId} (${best.candidate.locale}) failed validation: ${validation.reason}`);
+    }
+    const overlays = await fetchOverlaysForEntity(db, "extras", entityId);
+    const merged = mergeOverlaysIntoExtraContent(validation.content, overlays.map((o) => ({ field_path: o.field_path, value: o.value })), {
+        onOverlayError: options.onOverlayError
+            ? (e) => options.onOverlayError({
+                field_path: e.overlay.field_path,
+                reason: e.reason,
+            })
+            : undefined,
+    });
+    return {
+        content: merged,
+        resolution: {
+            candidate: { locale: best.candidate.locale, payload: merged },
+            served_locale: best.candidate.returned_locale,
+            match_kind: best.match_kind,
+        },
+        source: "sourced-cache",
+        served_stale: servedStale,
+        synthesized: false,
+        machine_translated: best.candidate.machine_translated,
+    };
+}
+async function finalizeFresh(db, entityId, fresh, scope, options) {
+    const cachedContent = extraContentSchema.parse(fresh.content);
+    const overlays = await fetchOverlaysForEntity(db, "extras", entityId);
+    const merged = mergeOverlaysIntoExtraContent(cachedContent, overlays.map((o) => ({ field_path: o.field_path, value: o.value })), {
+        onOverlayError: options.onOverlayError
+            ? (e) => options.onOverlayError({
+                field_path: e.overlay.field_path,
+                reason: e.reason,
+            })
+            : undefined,
+    });
+    return {
+        content: merged,
+        resolution: {
+            candidate: { locale: scope.preferredLocales[0] ?? fresh.returned_locale, payload: merged },
+            served_locale: fresh.returned_locale,
+            match_kind: scope.preferredLocales[0] === fresh.returned_locale ? "exact" : "language_match",
+        },
+        source: "sourced-fresh",
+        served_stale: false,
+        synthesized: false,
+        machine_translated: fresh.machine_translated ?? false,
+    };
+}
+function wrapSynthesized(synthesized, scope, servedStale) {
+    return {
+        content: synthesized.content,
+        resolution: {
+            candidate: { locale: synthesized.served_locale, payload: synthesized.content },
+            served_locale: synthesized.served_locale,
+            match_kind: scope.preferredLocales[0] === synthesized.served_locale ? "exact" : "any",
+        },
+        source: "synthesized",
+        served_stale: servedStale,
+        synthesized: true,
+        machine_translated: false,
+    };
+}
+/** Drift event consumer for the extras content cache. Per §3.4.1. */
+export const invalidateExtraContentOnDrift = createInvalidateOnDrift(extrasSourcedContentTable, { entityModule: "extras" });
+function toDateOrNull(value) {
+    if (!value)
+        return null;
+    if (value instanceof Date)
+        return value;
+    const parsed = new Date(value);
+    return Number.isNaN(parsed.getTime()) ? null : parsed;
+}

package/dist/extras/service.d.ts

@@ -0,0 +1,185 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { z } from "zod";
+import type { insertOptionExtraConfigSchema, insertProductExtraSchema, optionExtraConfigListQuerySchema, productExtraListQuerySchema, updateOptionExtraConfigSchema, updateProductExtraSchema } from "./validation.js";
+type ProductExtraListQuery = z.infer<typeof productExtraListQuerySchema>;
+type OptionExtraConfigListQuery = z.infer<typeof optionExtraConfigListQuerySchema>;
+type CreateProductExtraInput = z.infer<typeof insertProductExtraSchema>;
+type UpdateProductExtraInput = z.infer<typeof updateProductExtraSchema>;
+type CreateOptionExtraConfigInput = z.infer<typeof insertOptionExtraConfigSchema>;
+type UpdateOptionExtraConfigInput = z.infer<typeof updateOptionExtraConfigSchema>;
+export declare const inventoryExtrasService: {
+    listProductExtras(db: PostgresJsDatabase, query: ProductExtraListQuery): Promise<{
+        data: {
+            id: string;
+            productId: string;
+            supplierId: string | null;
+            code: string | null;
+            name: string;
+            description: string | null;
+            selectionType: "required" | "optional" | "unavailable" | "default_selected";
+            pricingMode: "on_request" | "per_booking" | "included" | "per_person" | "quantity_based" | "free";
+            pricedPerPerson: boolean;
+            collectionMode: "none" | "external" | "included" | "booking_total" | "cash_on_trip";
+            showOnSlotManifest: 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;
+        supplierId: string | null;
+        code: string | null;
+        name: string;
+        description: string | null;
+        selectionType: "required" | "optional" | "unavailable" | "default_selected";
+        pricingMode: "on_request" | "per_booking" | "included" | "per_person" | "quantity_based" | "free";
+        pricedPerPerson: boolean;
+        collectionMode: "none" | "external" | "included" | "booking_total" | "cash_on_trip";
+        showOnSlotManifest: 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;
+        createdAt: Date;
+        description: string | null;
+        active: boolean;
+        supplierId: string | null;
+        updatedAt: Date;
+        productId: string;
+        code: string | null;
+        sortOrder: number;
+        minQuantity: number | null;
+        maxQuantity: number | null;
+        metadata: Record<string, unknown> | null;
+        selectionType: "required" | "optional" | "unavailable" | "default_selected";
+        pricingMode: "on_request" | "per_booking" | "included" | "per_person" | "quantity_based" | "free";
+        pricedPerPerson: boolean;
+        collectionMode: "none" | "external" | "included" | "booking_total" | "cash_on_trip";
+        showOnSlotManifest: boolean;
+        defaultQuantity: number | null;
+    } | null>;
+    updateProductExtra(db: PostgresJsDatabase, id: string, data: UpdateProductExtraInput): Promise<{
+        id: string;
+        productId: string;
+        supplierId: string | null;
+        code: string | null;
+        name: string;
+        description: string | null;
+        selectionType: "required" | "optional" | "unavailable" | "default_selected";
+        pricingMode: "on_request" | "per_booking" | "included" | "per_person" | "quantity_based" | "free";
+        pricedPerPerson: boolean;
+        collectionMode: "none" | "external" | "included" | "booking_total" | "cash_on_trip";
+        showOnSlotManifest: 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: "required" | "optional" | "unavailable" | "default_selected" | null;
+            pricingMode: "on_request" | "per_booking" | "included" | "per_person" | "quantity_based" | "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: "required" | "optional" | "unavailable" | "default_selected" | null;
+        pricingMode: "on_request" | "per_booking" | "included" | "per_person" | "quantity_based" | "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;
+        createdAt: Date;
+        active: boolean;
+        updatedAt: Date;
+        isDefault: boolean;
+        sortOrder: number;
+        optionId: string;
+        minQuantity: number | null;
+        maxQuantity: number | null;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        selectionType: "required" | "optional" | "unavailable" | "default_selected" | null;
+        pricingMode: "on_request" | "per_booking" | "included" | "per_person" | "quantity_based" | "free" | null;
+        pricedPerPerson: boolean | null;
+        defaultQuantity: number | null;
+        productExtraId: string;
+    } | null>;
+    updateOptionExtraConfig(db: PostgresJsDatabase, id: string, data: UpdateOptionExtraConfigInput): Promise<{
+        id: string;
+        optionId: string;
+        productExtraId: string;
+        selectionType: "required" | "optional" | "unavailable" | "default_selected" | null;
+        pricingMode: "on_request" | "per_booking" | "included" | "per_person" | "quantity_based" | "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>;
+};
+export {};
+//# sourceMappingURL=service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/extras/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,6BAA6B,EAC7B,wBAAwB,EACxB,gCAAgC,EAChC,2BAA2B,EAC3B,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,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;AAYjF,eAAO,MAAM,sBAAsB;0BACL,kBAAkB,SAAS,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;4BAwB9C,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;;;CAOjE,CAAA"}

package/dist/extras/service.js

@@ -0,0 +1,96 @@
+import { and, asc, desc, eq, ilike, or, sql } from "drizzle-orm";
+import { 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 inventoryExtrasService = {
+    async listProductExtras(db, query) {
+        const conditions = [];
+        if (query.productId)
+            conditions.push(eq(productExtras.productId, query.productId));
+        if (query.supplierId)
+            conditions.push(eq(productExtras.supplierId, query.supplierId));
+        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;
+    },
+};