@voyant-travel/inventory 0.1.0

package/dist/service-core.d.ts

@@ -0,0 +1,194 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { z } from "zod";
+import type { insertProductSchema, productListQuerySchema, updateProductSchema } from "./validation.js";
+type ProductListQuery = z.infer<typeof productListQuerySchema>;
+type CreateProductInput = z.infer<typeof insertProductSchema>;
+type UpdateProductInput = z.infer<typeof updateProductSchema>;
+export declare const coreProductsService: {
+    listProducts(db: PostgresJsDatabase, query: ProductListQuery): Promise<{
+        data: {
+            id: string;
+            name: string;
+            status: "draft" | "active" | "archived";
+            description: string | null;
+            inclusionsHtml: string | null;
+            exclusionsHtml: string | null;
+            termsHtml: string | null;
+            termsShowOnContract: boolean;
+            bookingMode: "date" | "date_time" | "open" | "stay" | "transfer" | "itinerary" | "other";
+            capacityMode: "free_sale" | "limited" | "on_request";
+            timezone: string | null;
+            defaultLanguageTag: string | null;
+            visibility: "public" | "private" | "hidden";
+            activated: boolean;
+            reservationTimeoutMinutes: number | null;
+            sellCurrency: string;
+            sellAmountCents: number | null;
+            costAmountCents: number | null;
+            marginPercent: number | null;
+            facilityId: string | null;
+            supplierId: string | null;
+            startDate: string | null;
+            endDate: string | null;
+            pax: number | null;
+            productTypeId: string | null;
+            contractTemplateId: string | null;
+            taxClassId: string | null;
+            customerPaymentPolicy: unknown;
+            tags: string[] | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getProductById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        name: string;
+        status: "draft" | "active" | "archived";
+        description: string | null;
+        inclusionsHtml: string | null;
+        exclusionsHtml: string | null;
+        termsHtml: string | null;
+        termsShowOnContract: boolean;
+        bookingMode: "date" | "date_time" | "open" | "stay" | "transfer" | "itinerary" | "other";
+        capacityMode: "free_sale" | "limited" | "on_request";
+        timezone: string | null;
+        defaultLanguageTag: string | null;
+        visibility: "public" | "private" | "hidden";
+        activated: boolean;
+        reservationTimeoutMinutes: number | null;
+        sellCurrency: string;
+        sellAmountCents: number | null;
+        costAmountCents: number | null;
+        marginPercent: number | null;
+        facilityId: string | null;
+        supplierId: string | null;
+        startDate: string | null;
+        endDate: string | null;
+        pax: number | null;
+        productTypeId: string | null;
+        contractTemplateId: string | null;
+        taxClassId: string | null;
+        customerPaymentPolicy: unknown;
+        tags: string[] | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    /**
+     * Same as `getProductById` but eagerly hydrates the `productType`
+     * relation so consumers (slot detail page, etc.) can render a
+     * category-style badge without a second round-trip. `productType` is
+     * `null` when the product has no type assigned.
+     */
+    getProductByIdWithType(db: PostgresJsDatabase, id: string): Promise<{
+        productType: {
+            id: string;
+            name: string;
+            code: string;
+        } | null;
+        id: string;
+        name: string;
+        status: "draft" | "active" | "archived";
+        description: string | null;
+        inclusionsHtml: string | null;
+        exclusionsHtml: string | null;
+        termsHtml: string | null;
+        termsShowOnContract: boolean;
+        bookingMode: "date" | "date_time" | "open" | "stay" | "transfer" | "itinerary" | "other";
+        capacityMode: "free_sale" | "limited" | "on_request";
+        timezone: string | null;
+        defaultLanguageTag: string | null;
+        visibility: "public" | "private" | "hidden";
+        activated: boolean;
+        reservationTimeoutMinutes: number | null;
+        sellCurrency: string;
+        sellAmountCents: number | null;
+        costAmountCents: number | null;
+        marginPercent: number | null;
+        facilityId: string | null;
+        supplierId: string | null;
+        startDate: string | null;
+        endDate: string | null;
+        pax: number | null;
+        productTypeId: string | null;
+        contractTemplateId: string | null;
+        taxClassId: string | null;
+        customerPaymentPolicy: unknown;
+        tags: string[] | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createProduct(db: PostgresJsDatabase, data: CreateProductInput): Promise<{
+        id: string;
+        name: string;
+        status: "draft" | "active" | "archived";
+        description: string | null;
+        inclusionsHtml: string | null;
+        exclusionsHtml: string | null;
+        termsHtml: string | null;
+        termsShowOnContract: boolean;
+        bookingMode: "date" | "date_time" | "open" | "stay" | "transfer" | "itinerary" | "other";
+        capacityMode: "free_sale" | "limited" | "on_request";
+        timezone: string | null;
+        defaultLanguageTag: string | null;
+        visibility: "public" | "private" | "hidden";
+        activated: boolean;
+        reservationTimeoutMinutes: number | null;
+        sellCurrency: string;
+        sellAmountCents: number | null;
+        costAmountCents: number | null;
+        marginPercent: number | null;
+        facilityId: string | null;
+        supplierId: string | null;
+        startDate: string | null;
+        endDate: string | null;
+        pax: number | null;
+        productTypeId: string | null;
+        contractTemplateId: string | null;
+        taxClassId: string | null;
+        customerPaymentPolicy: unknown;
+        tags: string[] | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    updateProduct(db: PostgresJsDatabase, id: string, data: UpdateProductInput): Promise<{
+        id: string;
+        name: string;
+        status: "draft" | "active" | "archived";
+        description: string | null;
+        inclusionsHtml: string | null;
+        exclusionsHtml: string | null;
+        termsHtml: string | null;
+        termsShowOnContract: boolean;
+        bookingMode: "date" | "date_time" | "open" | "stay" | "transfer" | "itinerary" | "other";
+        capacityMode: "free_sale" | "limited" | "on_request";
+        timezone: string | null;
+        defaultLanguageTag: string | null;
+        visibility: "public" | "private" | "hidden";
+        activated: boolean;
+        reservationTimeoutMinutes: number | null;
+        sellCurrency: string;
+        sellAmountCents: number | null;
+        costAmountCents: number | null;
+        marginPercent: number | null;
+        facilityId: string | null;
+        supplierId: string | null;
+        startDate: string | null;
+        endDate: string | null;
+        pax: number | null;
+        productTypeId: string | null;
+        contractTemplateId: string | null;
+        taxClassId: string | null;
+        customerPaymentPolicy: unknown;
+        tags: string[] | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteProduct(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+};
+export {};
+//# sourceMappingURL=service-core.d.ts.map

package/dist/service-core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-core.d.ts","sourceRoot":"","sources":["../src/service-core.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQ5B,OAAO,KAAK,EACV,mBAAmB,EACnB,sBAAsB,EACtB,mBAAmB,EACpB,MAAM,iBAAiB,CAAA;AAExB,KAAK,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAC9D,KAAK,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC7D,KAAK,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAwE7D,eAAO,MAAM,mBAAmB;qBACP,kBAAkB,SAAS,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAyHzC,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAKvD;;;;;OAKG;+BAC8B,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAqBvC,kBAAkB,QAAQ,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAU5C,kBAAkB,MAAM,MAAM,QAAQ,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAUxD,kBAAkB,MAAM,MAAM;;;CAQvD,CAAA"}

package/dist/service-core.js

@@ -0,0 +1,213 @@
+import { and, asc, desc, eq, gte, ilike, lte, or, sql } from "drizzle-orm";
+import { productCategoryProducts, productItineraries, productOptions, products, productTypes, } from "./schema.js";
+async function getDefaultItinerary(db, productId) {
+    const [itinerary] = await db
+        .select({ id: productItineraries.id })
+        .from(productItineraries)
+        .where(and(eq(productItineraries.productId, productId), eq(productItineraries.isDefault, true)))
+        .orderBy(asc(productItineraries.sortOrder), asc(productItineraries.createdAt))
+        .limit(1);
+    return itinerary ?? null;
+}
+async function ensureDefaultItinerary(db, productId) {
+    const existing = await getDefaultItinerary(db, productId);
+    if (existing) {
+        return existing;
+    }
+    const [row] = await db
+        .insert(productItineraries)
+        .values({
+        productId,
+        name: "Main itinerary",
+        isDefault: true,
+        sortOrder: 0,
+    })
+        .returning({ id: productItineraries.id });
+    if (!row) {
+        throw new Error(`Failed to create default itinerary for product ${productId}`);
+    }
+    return row;
+}
+// Every product needs at least one bookable option for the operator pricing
+// grid to have something to attach inventory and prices to. Seed a single
+// "Standard" default option on creation so a brand-new product opens straight
+async function ensureDefaultOption(db, productId) {
+    const [existing] = await db
+        .select({ id: productOptions.id })
+        .from(productOptions)
+        .where(eq(productOptions.productId, productId))
+        .limit(1);
+    if (existing) {
+        return existing;
+    }
+    const [row] = await db
+        .insert(productOptions)
+        .values({
+        productId,
+        name: "Standard",
+        code: "standard",
+        status: "active",
+        isDefault: true,
+        sortOrder: 0,
+    })
+        .returning({ id: productOptions.id });
+    if (!row) {
+        throw new Error(`Failed to create default option for product ${productId}`);
+    }
+    return row;
+}
+export const coreProductsService = {
+    async listProducts(db, query) {
+        const conditions = [];
+        if (query.status) {
+            conditions.push(eq(products.status, query.status));
+        }
+        if (query.bookingMode) {
+            conditions.push(eq(products.bookingMode, query.bookingMode));
+        }
+        if (query.visibility) {
+            conditions.push(eq(products.visibility, query.visibility));
+        }
+        if (query.activated !== undefined) {
+            conditions.push(eq(products.activated, query.activated));
+        }
+        if (query.facilityId) {
+            conditions.push(eq(products.facilityId, query.facilityId));
+        }
+        if (query.supplierId) {
+            conditions.push(eq(products.supplierId, query.supplierId));
+        }
+        if (query.productTypeId) {
+            conditions.push(eq(products.productTypeId, query.productTypeId));
+        }
+        if (query.contractTemplateId) {
+            conditions.push(eq(products.contractTemplateId, query.contractTemplateId));
+        }
+        if (query.categoryId) {
+            conditions.push(
+            // agent-quality: raw-sql reviewed -- owner: inventory; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+            sql `exists (select 1 from ${productCategoryProducts}
+          where ${productCategoryProducts.productId} = ${products.id}
+          and ${productCategoryProducts.categoryId} = ${query.categoryId})`);
+        }
+        if (query.tag) {
+            // Postgres jsonb `@>` containment: does the array include this string?
+            // Mirrors the pattern used in @voyant-travel/charters and @voyant-travel/cruises.
+            // agent-quality: raw-sql reviewed -- owner: inventory; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+            conditions.push(sql `${products.tags} @> ${JSON.stringify([query.tag])}::jsonb`);
+        }
+        if (query.search) {
+            const term = `%${query.search}%`;
+            conditions.push(or(ilike(products.name, term), ilike(products.description, term)));
+        }
+        if (query.dateFrom) {
+            conditions.push(gte(products.startDate, query.dateFrom));
+        }
+        if (query.dateTo) {
+            conditions.push(lte(products.startDate, query.dateTo));
+        }
+        if (query.paxMin !== undefined) {
+            conditions.push(gte(products.pax, query.paxMin));
+        }
+        if (query.paxMax !== undefined) {
+            conditions.push(lte(products.pax, query.paxMax));
+        }
+        if (query.sellAmountMin !== undefined) {
+            conditions.push(gte(products.sellAmountCents, query.sellAmountMin));
+        }
+        if (query.sellAmountMax !== undefined) {
+            conditions.push(lte(products.sellAmountCents, query.sellAmountMax));
+        }
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        const sortColumn = (() => {
+            switch (query.sortBy) {
+                case "name":
+                    return products.name;
+                case "status":
+                    return products.status;
+                case "sellAmount":
+                    return products.sellAmountCents;
+                case "pax":
+                    return products.pax;
+                case "startDate":
+                    return products.startDate;
+                case "endDate":
+                    return products.endDate;
+                default:
+                    return products.createdAt;
+            }
+        })();
+        const sortFn = query.sortDir === "asc" ? asc : desc;
+        const [rows, countResult] = await Promise.all([
+            db
+                .select()
+                .from(products)
+                .where(where)
+                .limit(query.limit)
+                .offset(query.offset)
+                .orderBy(sortFn(sortColumn), desc(products.createdAt)),
+            db.select({ count: sql `count(*)::int` }).from(products).where(where),
+        ]);
+        return {
+            data: rows,
+            total: countResult[0]?.count ?? 0,
+            limit: query.limit,
+            offset: query.offset,
+        };
+    },
+    async getProductById(db, id) {
+        const [row] = await db.select().from(products).where(eq(products.id, id)).limit(1);
+        return row ?? null;
+    },
+    /**
+     * Same as `getProductById` but eagerly hydrates the `productType`
+     * relation so consumers (slot detail page, etc.) can render a
+     * category-style badge without a second round-trip. `productType` is
+     * `null` when the product has no type assigned.
+     */
+    async getProductByIdWithType(db, id) {
+        const [row] = await db
+            .select({
+            product: products,
+            productType: {
+                id: productTypes.id,
+                name: productTypes.name,
+                code: productTypes.code,
+            },
+        })
+            .from(products)
+            .leftJoin(productTypes, eq(productTypes.id, products.productTypeId))
+            .where(eq(products.id, id))
+            .limit(1);
+        if (!row)
+            return null;
+        return {
+            ...row.product,
+            productType: row.productType?.id ? row.productType : null,
+        };
+    },
+    async createProduct(db, data) {
+        const [row] = await db.insert(products).values(data).returning();
+        if (!row) {
+            throw new Error("Failed to create product");
+        }
+        await ensureDefaultItinerary(db, row.id);
+        await ensureDefaultOption(db, row.id);
+        return row;
+    },
+    async updateProduct(db, id, data) {
+        const [row] = await db
+            .update(products)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(products.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteProduct(db, id) {
+        const [row] = await db
+            .delete(products)
+            .where(eq(products.id, id))
+            .returning({ id: products.id });
+        return row ?? null;
+    },
+};

package/dist/service-delivery-formats.d.ts

@@ -0,0 +1,58 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { z } from "zod";
+import type { insertProductDeliveryFormatSchema, productDeliveryFormatListQuerySchema, updateProductDeliveryFormatSchema } from "./validation.js";
+type ProductDeliveryFormatListQuery = z.infer<typeof productDeliveryFormatListQuerySchema>;
+type CreateProductDeliveryFormatInput = z.infer<typeof insertProductDeliveryFormatSchema>;
+type UpdateProductDeliveryFormatInput = z.infer<typeof updateProductDeliveryFormatSchema>;
+export declare const deliveryFormatProductsService: {
+    listDeliveryFormats(db: PostgresJsDatabase, query: ProductDeliveryFormatListQuery): Promise<{
+        data: {
+            id: string;
+            productId: string;
+            format: "none" | "voucher" | "ticket" | "pdf" | "qr_code" | "barcode" | "email" | "mobile";
+            isDefault: boolean;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getDeliveryFormatById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        productId: string;
+        format: "none" | "voucher" | "ticket" | "pdf" | "qr_code" | "barcode" | "email" | "mobile";
+        isDefault: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    getDeliveryFormatByProductAndFormat(db: PostgresJsDatabase, productId: string, format: CreateProductDeliveryFormatInput["format"]): Promise<{
+        id: string;
+        productId: string;
+        format: "none" | "voucher" | "ticket" | "pdf" | "qr_code" | "barcode" | "email" | "mobile";
+        isDefault: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createDeliveryFormat(db: PostgresJsDatabase, productId: string, data: CreateProductDeliveryFormatInput): Promise<{
+        format: "none" | "voucher" | "ticket" | "pdf" | "qr_code" | "barcode" | "email" | "mobile";
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        productId: string;
+        isDefault: boolean;
+    } | null>;
+    updateDeliveryFormat(db: PostgresJsDatabase, id: string, data: UpdateProductDeliveryFormatInput): Promise<{
+        id: string;
+        productId: string;
+        format: "none" | "voucher" | "ticket" | "pdf" | "qr_code" | "barcode" | "email" | "mobile";
+        isDefault: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteDeliveryFormat(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+};
+export {};
+//# sourceMappingURL=service-delivery-formats.d.ts.map

package/dist/service-delivery-formats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-delivery-formats.d.ts","sourceRoot":"","sources":["../src/service-delivery-formats.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAE5B,OAAO,KAAK,EACV,iCAAiC,EACjC,oCAAoC,EACpC,iCAAiC,EAClC,MAAM,iBAAiB,CAAA;AAExB,KAAK,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAA;AAC1F,KAAK,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AACzF,KAAK,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAYzF,eAAO,MAAM,6BAA6B;4BACV,kBAAkB,SAAS,8BAA8B;;;;;;;;;;;;;8BAgCvD,kBAAkB,MAAM,MAAM;;;;;;;;4CAWxD,kBAAkB,aACX,MAAM,UACT,gCAAgC,CAAC,QAAQ,CAAC;;;;;;;;6BAiB9C,kBAAkB,aACX,MAAM,QACX,gCAAgC;;;;;;;;6BA8BlC,kBAAkB,MAClB,MAAM,QACJ,gCAAgC;;;;;;;;6BA4BT,kBAAkB,MAAM,MAAM;;;CAQ9D,CAAA"}

package/dist/service-delivery-formats.js

@@ -0,0 +1,107 @@
+import { and, asc, desc, eq, sql } from "drizzle-orm";
+import { productDeliveryFormats, products } from "./schema.js";
+async function ensureProductExists(db, productId) {
+    const [product] = await db
+        .select({ id: products.id })
+        .from(products)
+        .where(eq(products.id, productId))
+        .limit(1);
+    return product ?? null;
+}
+export const deliveryFormatProductsService = {
+    async listDeliveryFormats(db, query) {
+        const conditions = [];
+        if (query.productId) {
+            conditions.push(eq(productDeliveryFormats.productId, query.productId));
+        }
+        if (query.format) {
+            conditions.push(eq(productDeliveryFormats.format, query.format));
+        }
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        const [rows, countResult] = await Promise.all([
+            db
+                .select()
+                .from(productDeliveryFormats)
+                .where(where)
+                .limit(query.limit)
+                .offset(query.offset)
+                .orderBy(desc(productDeliveryFormats.isDefault), asc(productDeliveryFormats.createdAt)),
+            db.select({ count: sql `count(*)::int` }).from(productDeliveryFormats).where(where),
+        ]);
+        return {
+            data: rows,
+            total: countResult[0]?.count ?? 0,
+            limit: query.limit,
+            offset: query.offset,
+        };
+    },
+    async getDeliveryFormatById(db, id) {
+        const [row] = await db
+            .select()
+            .from(productDeliveryFormats)
+            .where(eq(productDeliveryFormats.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async getDeliveryFormatByProductAndFormat(db, productId, format) {
+        const [row] = await db
+            .select()
+            .from(productDeliveryFormats)
+            .where(and(eq(productDeliveryFormats.productId, productId), eq(productDeliveryFormats.format, format)))
+            .limit(1);
+        return row ?? null;
+    },
+    async createDeliveryFormat(db, productId, data) {
+        const product = await ensureProductExists(db, productId);
+        if (!product) {
+            return null;
+        }
+        if (data.isDefault) {
+            await db
+                .update(productDeliveryFormats)
+                .set({ isDefault: false, updatedAt: new Date() })
+                .where(eq(productDeliveryFormats.productId, productId));
+        }
+        const [row] = await db
+            .insert(productDeliveryFormats)
+            .values({ productId, ...data })
+            .onConflictDoUpdate({
+            target: [productDeliveryFormats.productId, productDeliveryFormats.format],
+            set: {
+                isDefault: data.isDefault ?? false,
+                updatedAt: new Date(),
+            },
+        })
+            .returning();
+        return row ?? null;
+    },
+    async updateDeliveryFormat(db, id, data) {
+        const [current] = await db
+            .select({ id: productDeliveryFormats.id, productId: productDeliveryFormats.productId })
+            .from(productDeliveryFormats)
+            .where(eq(productDeliveryFormats.id, id))
+            .limit(1);
+        if (!current) {
+            return null;
+        }
+        if (data.isDefault) {
+            await db
+                .update(productDeliveryFormats)
+                .set({ isDefault: false, updatedAt: new Date() })
+                .where(eq(productDeliveryFormats.productId, current.productId));
+        }
+        const [row] = await db
+            .update(productDeliveryFormats)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(productDeliveryFormats.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteDeliveryFormat(db, id) {
+        const [row] = await db
+            .delete(productDeliveryFormats)
+            .where(eq(productDeliveryFormats.id, id))
+            .returning({ id: productDeliveryFormats.id });
+        return row ?? null;
+    },
+};