@unchainedshop/core 4.6.0 → 4.6.2

package/lib/bulk-exporter/createBulkExporter.d.ts

@@ -0,0 +1,33 @@
+import exportProductsHandler from './handlers/exportProductsHandler.ts';
+import exportAssortmentsHandler from './handlers/exportAssortmentsHandler.ts';
+import exportFiltersHandler from './handlers/exportFiltersHandler.ts';
+import { z } from 'zod';
+import type { CSVFileResult } from './handlers/generateCSVFileAndUrl.ts';
+export declare const EXPORTS_DIRECTORY = "exports";
+export type ExportFiles = Record<string, CSVFileResult | null>;
+export interface BulkExportOperationResult {
+    entity: string;
+    success: boolean;
+    files: ExportFiles;
+}
+export interface BulkExportHandler<T = unknown> {
+    payloadSchema?: z.ZodObject<z.ZodRawShape>;
+    (params: Record<string, unknown>, locales: string[], unchainedAPI: T): Promise<ExportFiles>;
+}
+export interface BulkExporterOptions {
+    handlers?: Record<string, BulkExportHandler>;
+}
+export default function createBulkExporterFactory(bulkExporterOptions?: BulkExporterOptions): {
+    createBulkExporter: ({ entity }: {
+        entity: string;
+    }) => {
+        validate: (payload: Record<string, unknown>) => Promise<void>;
+        execute: <T>(payload: Record<string, unknown>, locales: string[], unchainedApi: T) => Promise<({
+            entity: string;
+            success: boolean;
+            files: ExportFiles;
+        } | null)[]>;
+    };
+};
+export type BulkExporter = ReturnType<typeof createBulkExporterFactory>;
+export { exportAssortmentsHandler, exportProductsHandler, exportFiltersHandler };

package/lib/bulk-exporter/createBulkExporter.js

@@ -0,0 +1,46 @@
+import exportProductsHandler from "./handlers/exportProductsHandler.js";
+import exportAssortmentsHandler from "./handlers/exportAssortmentsHandler.js";
+import exportFiltersHandler from "./handlers/exportFiltersHandler.js";
+import { createLogger } from '@unchainedshop/logger';
+import { z } from 'zod';
+import exportUsersHandler from "./handlers/exportUsersHandler.js";
+const logger = createLogger('unchained:bulk-export');
+export const EXPORTS_DIRECTORY = 'exports';
+let bulkOperationHandlers = {};
+export default function createBulkExporterFactory(bulkExporterOptions) {
+    bulkOperationHandlers = {
+        ASSORTMENTS: exportAssortmentsHandler,
+        PRODUCTS: exportProductsHandler,
+        FILTERS: exportFiltersHandler,
+        USER: exportUsersHandler,
+        ...(bulkExporterOptions?.handlers || {}),
+    };
+    const createBulkExporter = ({ entity }) => {
+        const type = entity.toUpperCase();
+        const exportHandler = bulkOperationHandlers[type];
+        if (!exportHandler) {
+            throw new Error(`Export entity (${entity}) is not supported`);
+        }
+        return {
+            validate: async (payload) => {
+                logger.debug(`Validating ${type} export payload`);
+                try {
+                    if (exportHandler.payloadSchema) {
+                        exportHandler.payloadSchema.parse(payload);
+                    }
+                }
+                catch (e) {
+                    throw new Error(`${type}: ${e.message}`);
+                }
+            },
+            execute: async (payload, locales, unchainedApi) => {
+                const files = await exportHandler(payload, locales, unchainedApi);
+                return [{ entity: type, success: true, files }, null];
+            },
+        };
+    };
+    return {
+        createBulkExporter,
+    };
+}
+export { exportAssortmentsHandler, exportProductsHandler, exportFiltersHandler };

package/lib/bulk-exporter/handlers/exportAssortmentsHandler.d.ts

@@ -0,0 +1,38 @@
+import type { UnchainedCore } from '../../core-index.ts';
+import { z } from 'zod';
+export declare const AssortmentExportPayloadSchema: z.ZodObject<{
+    exportAssortments: z.ZodOptional<z.ZodBoolean>;
+    exportLinks: z.ZodOptional<z.ZodBoolean>;
+    exportProducts: z.ZodOptional<z.ZodBoolean>;
+    exportFilters: z.ZodOptional<z.ZodBoolean>;
+    queryString: z.ZodOptional<z.ZodString>;
+    includeInactive: z.ZodOptional<z.ZodBoolean>;
+    includeLeaves: z.ZodOptional<z.ZodBoolean>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export interface AssortmentExportParams {
+    exportAssortments?: boolean;
+    exportLinks?: boolean;
+    exportProducts?: boolean;
+    exportFilters?: boolean;
+    [key: string]: any;
+}
+declare const exportAssortmentsHandler: {
+    ({ exportAssortments, exportFilters, exportLinks, exportProducts, ...params }: AssortmentExportParams, locales: string[], unchainedAPI: UnchainedCore): Promise<{
+        assortments: import("./generateCSVFileAndUrl.ts").CSVFileResult | null;
+        filters: import("./generateCSVFileAndUrl.ts").CSVFileResult | null;
+        products: import("./generateCSVFileAndUrl.ts").CSVFileResult | null;
+        children: import("./generateCSVFileAndUrl.ts").CSVFileResult | null;
+    }>;
+    payloadSchema: z.ZodObject<{
+        exportAssortments: z.ZodOptional<z.ZodBoolean>;
+        exportLinks: z.ZodOptional<z.ZodBoolean>;
+        exportProducts: z.ZodOptional<z.ZodBoolean>;
+        exportFilters: z.ZodOptional<z.ZodBoolean>;
+        queryString: z.ZodOptional<z.ZodString>;
+        includeInactive: z.ZodOptional<z.ZodBoolean>;
+        includeLeaves: z.ZodOptional<z.ZodBoolean>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+};
+export default exportAssortmentsHandler;

package/lib/bulk-exporter/handlers/exportAssortmentsHandler.js

@@ -0,0 +1,137 @@
+import generateCSVFileAndURL from "./generateCSVFileAndUrl.js";
+import { z } from 'zod';
+import { EXPORTS_DIRECTORY } from "../createBulkExporter.js";
+export const AssortmentExportPayloadSchema = z.object({
+    exportAssortments: z.boolean().optional(),
+    exportLinks: z.boolean().optional(),
+    exportProducts: z.boolean().optional(),
+    exportFilters: z.boolean().optional(),
+    queryString: z.string().optional(),
+    includeInactive: z.boolean().optional(),
+    includeLeaves: z.boolean().optional(),
+    tags: z.array(z.string()).optional(),
+});
+const ASSORTMENT_CSV_SCHEMA = {
+    base: ['_id', 'isActive', 'isBase', 'isRoot', 'sequence', 'tags'],
+    textFields: ['title', 'subtitle', 'description', 'slug'],
+    filterFields: ['_id', 'assortmentId', 'filterId', 'tags', 'sortKey'],
+    productFields: ['_id', 'assortmentId', 'productId', 'tags', 'sortKey'],
+    childrenFields: ['_id', 'assortmentId', 'childAssortmentId', 'tags', 'sortKey'],
+};
+const buildAssortmentHeaders = (locales) => [
+    ...ASSORTMENT_CSV_SCHEMA.base,
+    ...locales.flatMap((locale) => ASSORTMENT_CSV_SCHEMA.textFields.map((field) => `texts.${locale}.${field}`)),
+    'meta',
+];
+const buildFilterHeaders = () => ASSORTMENT_CSV_SCHEMA.filterFields;
+const buildProductHeaders = () => ASSORTMENT_CSV_SCHEMA.productFields;
+const buildChildrenHeaders = () => ASSORTMENT_CSV_SCHEMA.childrenFields;
+const fetchAssortmentTexts = async (modules, assortmentId) => {
+    const texts = await modules.assortments.texts.findTexts({ assortmentId });
+    return texts.reduce((acc, t) => ({ ...acc, [t.locale]: t }), {});
+};
+const exportAssortmentsHandler = async ({ exportAssortments, exportFilters, exportLinks, exportProducts, ...params }, locales, unchainedAPI) => {
+    const { modules } = unchainedAPI;
+    const assortments = await modules.assortments.findAssortments({ ...params });
+    const assortmentRows = [];
+    const filterRows = [];
+    const productRows = [];
+    const childrenRows = [];
+    for await (const assortment of assortments) {
+        if (exportAssortments) {
+            const texts = await fetchAssortmentTexts(modules, assortment._id);
+            const row = { ...assortment };
+            locales.forEach((locale) => {
+                const t = texts[locale] || {};
+                ASSORTMENT_CSV_SCHEMA.textFields.forEach((field) => {
+                    let value = t[field];
+                    if (Array.isArray(value))
+                        value = value.join(';');
+                    row[`texts.${locale}.${field}`] = value ?? '';
+                });
+            });
+            row['meta'] = typeof assortment?.meta === 'object' ? JSON.stringify(assortment.meta) : '';
+            assortmentRows.push(row);
+        }
+        if (exportFilters) {
+            const assortmentFilters = await modules.assortments.filters.findFilters({
+                assortmentId: assortment._id,
+            });
+            filterRows.push(...assortmentFilters.map(({ _id, filterId, tags, sortKey }) => ({
+                _id,
+                assortmentId: assortment._id,
+                filterId,
+                tags: tags || '',
+                sortKey,
+            })));
+        }
+        if (exportProducts) {
+            const assortmentProducts = await modules.assortments.products.findAssortmentProducts({
+                assortmentId: assortment._id,
+            });
+            productRows.push(...assortmentProducts.map(({ _id, productId, tags, sortKey }) => ({
+                _id,
+                assortmentId: assortment._id,
+                productId,
+                tags: tags || '',
+                sortKey,
+            })));
+        }
+        if (exportLinks) {
+            const links = await modules.assortments.links.findLinks({ assortmentId: assortment._id });
+            childrenRows.push(...links
+                .filter((l) => l.childAssortmentId !== assortment._id)
+                .map(({ _id, childAssortmentId, tags, sortKey }) => ({
+                _id,
+                assortmentId: assortment._id,
+                childAssortmentId,
+                tags: tags || '',
+                sortKey,
+            })));
+        }
+    }
+    const assortmentsCSV = exportAssortments
+        ? await generateCSVFileAndURL({
+            headers: buildAssortmentHeaders(locales),
+            rows: assortmentRows,
+            directoryName: EXPORTS_DIRECTORY,
+            fileName: 'assortments_export.csv',
+            unchainedAPI,
+        })
+        : null;
+    const filtersCSV = exportFilters
+        ? await generateCSVFileAndURL({
+            headers: buildFilterHeaders(),
+            rows: filterRows,
+            directoryName: EXPORTS_DIRECTORY,
+            fileName: 'assortment_filters_export.csv',
+            unchainedAPI,
+        })
+        : null;
+    const productsCSV = exportProducts
+        ? await generateCSVFileAndURL({
+            headers: buildProductHeaders(),
+            rows: productRows,
+            directoryName: EXPORTS_DIRECTORY,
+            fileName: 'assortment_products_export.csv',
+            unchainedAPI,
+        })
+        : null;
+    const childrenCSV = exportLinks
+        ? await generateCSVFileAndURL({
+            headers: buildChildrenHeaders(),
+            rows: childrenRows,
+            directoryName: EXPORTS_DIRECTORY,
+            fileName: 'assortment_links_export.csv',
+            unchainedAPI,
+        })
+        : null;
+    return {
+        assortments: assortmentsCSV,
+        filters: filtersCSV,
+        products: productsCSV,
+        children: childrenCSV,
+    };
+};
+export default exportAssortmentsHandler;
+exportAssortmentsHandler.payloadSchema = AssortmentExportPayloadSchema;

package/lib/bulk-exporter/handlers/exportFiltersHandler.d.ts

@@ -0,0 +1,26 @@
+import type { UnchainedCore } from '../../core-index.ts';
+import { z } from 'zod';
+export declare const FilterExportPayloadSchema: z.ZodObject<{
+    exportFilters: z.ZodOptional<z.ZodBoolean>;
+    exportFilterOptions: z.ZodOptional<z.ZodBoolean>;
+    queryString: z.ZodOptional<z.ZodString>;
+    includeInactive: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export interface FilterExportParams {
+    exportFilters?: boolean;
+    exportFilterOptions?: boolean;
+    [key: string]: any;
+}
+declare const exportFiltersHandler: {
+    ({ exportFilterOptions, exportFilters, ...params }: FilterExportParams, locales: string[], unchainedAPI: UnchainedCore): Promise<{
+        filters: import("./generateCSVFileAndUrl.ts").CSVFileResult | null;
+        filterOptions: import("./generateCSVFileAndUrl.ts").CSVFileResult | null;
+    }>;
+    payloadSchema: z.ZodObject<{
+        exportFilters: z.ZodOptional<z.ZodBoolean>;
+        exportFilterOptions: z.ZodOptional<z.ZodBoolean>;
+        queryString: z.ZodOptional<z.ZodString>;
+        includeInactive: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+};
+export default exportFiltersHandler;

package/lib/bulk-exporter/handlers/exportFiltersHandler.js

@@ -0,0 +1,88 @@
+import generateCSVFileAndURL from "./generateCSVFileAndUrl.js";
+import { z } from 'zod';
+import { EXPORTS_DIRECTORY } from "../createBulkExporter.js";
+export const FilterExportPayloadSchema = z.object({
+    exportFilters: z.boolean().optional(),
+    exportFilterOptions: z.boolean().optional(),
+    queryString: z.string().optional(),
+    includeInactive: z.boolean().optional(),
+});
+const FILTER_CSV_SCHEMA = {
+    filterFields: ['_id', 'key', 'type', 'isActive'],
+    optionFields: ['optionId', 'filterId', 'value'],
+    textFields: ['title', 'subtitle'],
+};
+const buildFilterHeaders = (locales) => [
+    ...FILTER_CSV_SCHEMA.filterFields,
+    ...locales.flatMap((locale) => FILTER_CSV_SCHEMA.textFields.map((field) => `texts.${locale}.${field}`)),
+    'meta',
+];
+const buildOptionHeaders = (locales) => [
+    ...FILTER_CSV_SCHEMA.optionFields,
+    ...locales.flatMap((locale) => FILTER_CSV_SCHEMA.textFields.map((field) => `texts.${locale}.${field}`)),
+];
+const mapTextsToRow = (row, texts, locales) => {
+    locales.forEach((locale) => {
+        const t = texts[locale] || {};
+        FILTER_CSV_SCHEMA.textFields.forEach((field) => {
+            row[`texts.${locale}.${field}`] = t[field] ?? '';
+        });
+    });
+};
+const fetchTexts = async (modules, filterId, filterOptionValue) => {
+    const texts = await modules.filters.texts.findTexts({ filterId, filterOptionValue });
+    return texts.reduce((acc, t) => ({ ...acc, [t.locale]: t }), {});
+};
+const exportFiltersHandler = async ({ exportFilterOptions, exportFilters, ...params }, locales, unchainedAPI) => {
+    const { modules } = unchainedAPI;
+    const filters = await modules.filters.findFilters({ ...params });
+    const filterRows = [];
+    const optionRows = [];
+    for await (const filter of filters) {
+        if (exportFilters) {
+            const filterTexts = await fetchTexts(modules, filter._id);
+            const row = {
+                _id: filter._id,
+                key: filter.key,
+                type: filter.type,
+                isActive: filter.isActive,
+                meta: typeof filter?.meta === 'object' ? JSON.stringify(filter.meta) : '',
+            };
+            mapTextsToRow(row, filterTexts, locales);
+            filterRows.push(row);
+        }
+        if (exportFilterOptions) {
+            for await (const optionValue of filter.options) {
+                const optionTexts = await fetchTexts(modules, filter._id, optionValue);
+                const optionRow = {
+                    optionId: `${filter._id}:${optionValue}`,
+                    filterId: filter._id,
+                    value: optionValue,
+                };
+                mapTextsToRow(optionRow, optionTexts, locales);
+                optionRows.push(optionRow);
+            }
+        }
+    }
+    const filtersCSV = exportFilters
+        ? await generateCSVFileAndURL({
+            headers: buildFilterHeaders(locales),
+            rows: filterRows,
+            directoryName: EXPORTS_DIRECTORY,
+            fileName: 'filters_export.csv',
+            unchainedAPI,
+        })
+        : null;
+    const optionsCSV = exportFilterOptions
+        ? await generateCSVFileAndURL({
+            headers: buildOptionHeaders(locales),
+            rows: optionRows,
+            directoryName: EXPORTS_DIRECTORY,
+            fileName: 'filter_options_export.csv',
+            unchainedAPI,
+        })
+        : null;
+    return { filters: filtersCSV, filterOptions: optionsCSV };
+};
+export default exportFiltersHandler;
+exportFiltersHandler.payloadSchema = FilterExportPayloadSchema;

package/lib/bulk-exporter/handlers/exportProductsHandler.d.ts

@@ -0,0 +1,40 @@
+import type { UnchainedCore } from '../../core-index.ts';
+import { z } from 'zod';
+export declare const ProductExportPayloadSchema: z.ZodObject<{
+    exportProducts: z.ZodOptional<z.ZodBoolean>;
+    exportBundleItems: z.ZodOptional<z.ZodBoolean>;
+    exportPrices: z.ZodOptional<z.ZodBoolean>;
+    exportVariations: z.ZodOptional<z.ZodBoolean>;
+    exportVariationOptions: z.ZodOptional<z.ZodBoolean>;
+    queryString: z.ZodOptional<z.ZodString>;
+    includeDrafts: z.ZodOptional<z.ZodBoolean>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export interface ProductExportParams {
+    exportProducts?: boolean;
+    exportBundleItems?: boolean;
+    exportPrices?: boolean;
+    exportVariations?: boolean;
+    exportVariationOptions?: boolean;
+    [key: string]: any;
+}
+declare const exportProductsHandler: {
+    ({ exportBundleItems, exportPrices, exportProducts, exportVariationOptions, exportVariations, ...params }: ProductExportParams, locales: string[], unchainedAPI: UnchainedCore): Promise<{
+        products: import("./generateCSVFileAndUrl.ts").CSVFileResult | null;
+        prices: import("./generateCSVFileAndUrl.ts").CSVFileResult | null;
+        bundles: import("./generateCSVFileAndUrl.ts").CSVFileResult | null;
+        variations: import("./generateCSVFileAndUrl.ts").CSVFileResult | null;
+        variationOptions: import("./generateCSVFileAndUrl.ts").CSVFileResult | null;
+    }>;
+    payloadSchema: z.ZodObject<{
+        exportProducts: z.ZodOptional<z.ZodBoolean>;
+        exportBundleItems: z.ZodOptional<z.ZodBoolean>;
+        exportPrices: z.ZodOptional<z.ZodBoolean>;
+        exportVariations: z.ZodOptional<z.ZodBoolean>;
+        exportVariationOptions: z.ZodOptional<z.ZodBoolean>;
+        queryString: z.ZodOptional<z.ZodString>;
+        includeDrafts: z.ZodOptional<z.ZodBoolean>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+};
+export default exportProductsHandler;

package/lib/bulk-exporter/handlers/exportProductsHandler.js

@@ -0,0 +1,238 @@
+import generateCSVFileAndURL from "./generateCSVFileAndUrl.js";
+import { z } from 'zod';
+import { EXPORTS_DIRECTORY } from "../createBulkExporter.js";
+export const ProductExportPayloadSchema = z.object({
+    exportProducts: z.boolean().optional(),
+    exportBundleItems: z.boolean().optional(),
+    exportPrices: z.boolean().optional(),
+    exportVariations: z.boolean().optional(),
+    exportVariationOptions: z.boolean().optional(),
+    queryString: z.string().optional(),
+    includeDrafts: z.boolean().optional(),
+    tags: z.array(z.string()).optional(),
+});
+const PRODUCT_CSV_SCHEMA = {
+    base: ['_id', 'sku', 'baseUnit', 'sequence', 'status', 'tags', 'updated', 'published', 'type'],
+    textFields: ['title', 'subtitle', 'description', 'vendor', 'brand', 'labels', 'slug'],
+    priceFields: [
+        'productId',
+        'amount',
+        'currencyCode',
+        'countryCode',
+        'isTaxable',
+        'isNetPrice',
+        'maxQuantity',
+    ],
+    bundleItemHeaders: ['productId', 'bundleItemProductId', 'quantity', 'configuration'],
+    variationItemHeaders: ['productId', 'variationId', 'key', 'type'],
+    variationTextFields: ['title', 'subtitle'],
+    variationOptionItemHeaders: ['variationId', 'value'],
+    variationOptionTextFields: ['title', 'subtitle'],
+};
+const buildProductHeaders = (locales) => [
+    ...PRODUCT_CSV_SCHEMA.base,
+    ...locales.flatMap((l) => PRODUCT_CSV_SCHEMA.textFields.map((f) => `texts.${l}.${f}`)),
+    'supply.weightInGram',
+    'supply.heightInMillimeters',
+    'supply.lengthInMillimeters',
+    'supply.widthInMillimeters',
+    'meta',
+];
+const buildPriceHeaders = () => PRODUCT_CSV_SCHEMA.priceFields;
+const buildBundleHeaders = () => PRODUCT_CSV_SCHEMA.bundleItemHeaders;
+const buildVariationHeaders = (locales) => [
+    ...PRODUCT_CSV_SCHEMA.variationItemHeaders,
+    ...locales.flatMap((l) => PRODUCT_CSV_SCHEMA.variationTextFields.map((f) => `texts.${l}.${f}`)),
+];
+const buildVariationOptionsHeaders = (locales) => [
+    ...PRODUCT_CSV_SCHEMA.variationOptionItemHeaders,
+    ...locales.flatMap((l) => PRODUCT_CSV_SCHEMA.variationOptionTextFields.map((f) => `texts.${l}.${f}`)),
+];
+const mapTextsToRow = (row, texts, locales, fields) => {
+    locales.forEach((locale) => {
+        const t = texts.find((x) => x.locale === locale) || {};
+        fields.forEach((f) => {
+            row[`texts.${locale}.${f}`] = Array.isArray(t[f]) ? t[f].join(';') : (t[f] ?? '');
+        });
+    });
+};
+const buildProductRow = (product, locales) => {
+    const row = {};
+    PRODUCT_CSV_SCHEMA.base.forEach((k) => (row[k] = product[k] ?? ''));
+    row['supply.weightInGram'] = product?.dimensions?.weight ?? '';
+    row['supply.heightInMillimeters'] = product?.dimensions?.height ?? '';
+    row['supply.lengthInMillimeters'] = product?.dimensions?.length ?? '';
+    row['supply.widthInMillimeters'] = product?.dimensions?.width ?? '';
+    row['meta'] =
+        typeof product?.meta === 'object'
+            ? JSON.stringify(product?.meta, Object.keys(product?.meta).sort())
+            : product?.meta;
+    mapTextsToRow(row, product.texts ?? [], locales, PRODUCT_CSV_SCHEMA.textFields);
+    return row;
+};
+const buildPriceRows = (productId, prices = []) => prices.map((p) => ({
+    productId,
+    amount: p.amount ?? '',
+    isNetPrice: p.isNetPrice ?? '',
+    isTaxable: p.isTaxable ?? '',
+    currencyCode: p.currency?.isoCode ?? '',
+    countryCode: p.country?.isoCode ?? '',
+    maxQuantity: p.maxQuantity ?? '',
+}));
+const buildBundleRows = (productId, bundles = []) => bundles.map((b) => ({
+    productId,
+    bundleItemProductId: b.productId,
+    quantity: b.quantity ?? 1,
+    configuration: (b.configuration || []).map((c) => Object.values(c).join(':')).join(';'),
+}));
+const buildVariationRows = (productId, variations = [], locales) => {
+    const variationRows = [];
+    const optionRows = [];
+    variations.forEach((v) => {
+        const row = {
+            productId,
+            variationId: v._id,
+            key: v.key,
+            type: v.type,
+        };
+        mapTextsToRow(row, Object.values(v.texts || {}), locales, PRODUCT_CSV_SCHEMA.variationTextFields);
+        variationRows.push(row);
+        const options = v.options?.[v._id] ?? [];
+        options.forEach((o) => {
+            const optRow = {
+                variationId: v._id,
+                value: o.productVariationOption,
+            };
+            mapTextsToRow(optRow, Object.values(o.texts || {}), locales, PRODUCT_CSV_SCHEMA.variationOptionTextFields);
+            optionRows.push(optRow);
+        });
+    });
+    return { variationRows, optionRows };
+};
+const exportProductsHandler = async ({ exportBundleItems, exportPrices, exportProducts, exportVariationOptions, exportVariations, ...params }, locales, unchainedAPI) => {
+    const { queryString, includeDrafts, tags } = params;
+    const products = await unchainedAPI.modules.products.findProducts({
+        includeDrafts,
+        queryString,
+        tags,
+    });
+    const normalized = { products: {}, prices: {}, bundles: {}, variations: {} };
+    for await (const p of products) {
+        const productId = p._id;
+        const productTexts = exportProducts
+            ? await unchainedAPI.modules.products.texts.findTexts({ productId })
+            : null;
+        const variations = exportVariations
+            ? await unchainedAPI.modules.products.variations.findProductVariations({ productId })
+            : [];
+        const normalizedVariations = [];
+        if (exportVariations) {
+            for await (const v of variations) {
+                const variationTexts = exportVariations
+                    ? await unchainedAPI.modules.products.variations.texts.findVariationTexts({
+                        productVariationId: v._id,
+                        productVariationOptionValue: null,
+                    })
+                    : [];
+                const options = [];
+                if (exportVariationOptions) {
+                    for await (const o of v.options || []) {
+                        const optionTexts = await unchainedAPI.modules.products.variations.texts.findVariationTexts({
+                            productVariationId: v._id,
+                            productVariationOptionValue: o,
+                        });
+                        options.push({
+                            _id: `${v._id}:${o}`,
+                            productVariationOption: o,
+                            texts: Object.fromEntries(optionTexts.map((t) => [t.locale, t])),
+                        });
+                    }
+                }
+                normalizedVariations.push({
+                    ...v,
+                    texts: exportVariations
+                        ? Object.fromEntries(variationTexts.map((t) => [t.locale, t]))
+                        : {},
+                    options: exportVariationOptions ? { [v._id]: options } : {},
+                });
+            }
+        }
+        normalized.products[productId] = exportProducts ? { ...p, texts: productTexts } : p;
+        normalized.prices[productId] = exportPrices ? (p.commerce?.pricing ?? []) : [];
+        normalized.bundles[productId] = exportBundleItems ? (p.bundleItems ?? []) : [];
+        normalized.variations[productId] = normalizedVariations;
+    }
+    const productRows = [];
+    const priceRows = [];
+    const bundleRows = [];
+    const variationRows = [];
+    const variationOptionRows = [];
+    for (const pid in normalized.products) {
+        if (exportProducts) {
+            productRows.push(buildProductRow(normalized.products[pid], locales));
+        }
+        if (exportPrices) {
+            priceRows.push(...buildPriceRows(pid, normalized.prices[pid]));
+        }
+        if (exportBundleItems) {
+            bundleRows.push(...buildBundleRows(pid, normalized.bundles[pid]));
+        }
+        const { variationRows: vr, optionRows: or } = buildVariationRows(pid, normalized.variations[pid], locales);
+        variationRows.push(...vr);
+        variationOptionRows.push(...or);
+    }
+    const productsCSV = exportProducts
+        ? await generateCSVFileAndURL({
+            headers: buildProductHeaders(locales),
+            rows: productRows,
+            directoryName: EXPORTS_DIRECTORY,
+            fileName: 'products_export.csv',
+            unchainedAPI,
+        })
+        : null;
+    const pricesCSV = exportPrices
+        ? await generateCSVFileAndURL({
+            headers: buildPriceHeaders(),
+            rows: priceRows,
+            directoryName: EXPORTS_DIRECTORY,
+            fileName: 'products_prices_export.csv',
+            unchainedAPI,
+        })
+        : null;
+    const bundlesCSV = exportBundleItems
+        ? await generateCSVFileAndURL({
+            headers: buildBundleHeaders(),
+            rows: bundleRows,
+            directoryName: EXPORTS_DIRECTORY,
+            fileName: 'products_bundle_items_export.csv',
+            unchainedAPI,
+        })
+        : null;
+    const variationsCSV = exportVariations
+        ? await generateCSVFileAndURL({
+            headers: buildVariationHeaders(locales),
+            rows: variationRows,
+            directoryName: EXPORTS_DIRECTORY,
+            fileName: 'products_variations_export.csv',
+            unchainedAPI,
+        })
+        : null;
+    const variationOptionsCSV = exportVariationOptions
+        ? await generateCSVFileAndURL({
+            headers: buildVariationOptionsHeaders(locales),
+            rows: variationOptionRows,
+            directoryName: EXPORTS_DIRECTORY,
+            fileName: 'products_variation_options_export.csv',
+            unchainedAPI,
+        })
+        : null;
+    return {
+        products: productsCSV,
+        prices: pricesCSV,
+        bundles: bundlesCSV,
+        variations: variationsCSV,
+        variationOptions: variationOptionsCSV,
+    };
+};
+export default exportProductsHandler;
+exportProductsHandler.payloadSchema = ProductExportPayloadSchema;