@unchainedshop/core 4.6.0 → 4.6.1

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;

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

@@ -0,0 +1,40 @@
+import type { UnchainedCore } from '../../core-index.ts';
+import { z } from 'zod';
+export declare const UserExportPayloadSchema: z.ZodObject<{
+    exportReviews: z.ZodOptional<z.ZodBoolean>;
+    exportOrders: z.ZodOptional<z.ZodBoolean>;
+    exportBookmarks: z.ZodOptional<z.ZodBoolean>;
+    exportEvents: z.ZodOptional<z.ZodBoolean>;
+    exportQuotations: z.ZodOptional<z.ZodBoolean>;
+    exportEnrollments: z.ZodOptional<z.ZodBoolean>;
+    userId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export interface UserExportParams {
+    exportReviews?: boolean;
+    exportOrders?: boolean;
+    exportBookmarks?: boolean;
+    exportEvents?: boolean;
+    exportQuotations?: boolean;
+    exportEnrollments?: boolean;
+    userId: string;
+}
+declare const exportUsersHandler: {
+    ({ userId, ...options }: UserExportParams, _: any, unchainedAPI: UnchainedCore): Promise<{
+        user: import("./generateCSVFileAndUrl.ts").CSVFileResult;
+        bookmarks: import("./generateCSVFileAndUrl.ts").CSVFileResult | null;
+        orders: import("./generateCSVFileAndUrl.ts").CSVFileResult | null;
+        reviews: import("./generateCSVFileAndUrl.ts").CSVFileResult | null;
+        quotations: import("./generateCSVFileAndUrl.ts").CSVFileResult | null;
+        enrollments: import("./generateCSVFileAndUrl.ts").CSVFileResult | null;
+    }>;
+    payloadSchema: z.ZodObject<{
+        exportReviews: z.ZodOptional<z.ZodBoolean>;
+        exportOrders: z.ZodOptional<z.ZodBoolean>;
+        exportBookmarks: z.ZodOptional<z.ZodBoolean>;
+        exportEvents: z.ZodOptional<z.ZodBoolean>;
+        exportQuotations: z.ZodOptional<z.ZodBoolean>;
+        exportEnrollments: z.ZodOptional<z.ZodBoolean>;
+        userId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+};
+export default exportUsersHandler;

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

@@ -0,0 +1,340 @@
+import generateCSVFileAndURL from "./generateCSVFileAndUrl.js";
+import { z } from 'zod';
+import { EXPORTS_DIRECTORY } from "../createBulkExporter.js";
+export const UserExportPayloadSchema = z.object({
+    exportReviews: z.boolean().optional(),
+    exportOrders: z.boolean().optional(),
+    exportBookmarks: z.boolean().optional(),
+    exportEvents: z.boolean().optional(),
+    exportQuotations: z.boolean().optional(),
+    exportEnrollments: z.boolean().optional(),
+    userId: z.string().optional(),
+});
+const USER_CSV_SCHEMA = {
+    userFields: [
+        '_id',
+        'emailAddresses',
+        'tags',
+        'roles',
+        'username',
+        'created',
+        'isGuest',
+        'displayName',
+        'birthday',
+        'phoneMobile',
+        'gender',
+        'address.addressLine',
+        'address.addressLine2',
+        'address.city',
+        'address.company',
+        'address.countryCode',
+        'address.firstName',
+        'address.lastName',
+        'address.postalCode',
+        'address.regionCode',
+        'meta',
+        'lastBillingAddress',
+        'lastContact',
+        'lastLogin',
+    ],
+    bookmarkFields: ['_id', 'productId', 'userId'],
+    orderFields: [
+        '_id',
+        'userId',
+        'orderNumber',
+        'status',
+        'billingAddress',
+        'contact',
+        'countryCode',
+        'currencyCode',
+        'deliveryId',
+        'paymentId',
+        'confirmed',
+        'ordered',
+        'fulfilled',
+        'products',
+    ],
+    reviewFields: [
+        '_id',
+        'productId',
+        'authorId',
+        'rating',
+        'title',
+        'review',
+        'vote.type',
+        'vote.timestamp',
+        'vote.meta',
+        'meta',
+    ],
+    quotationFields: [
+        '_id',
+        'userId',
+        'quotationNumber',
+        'productId',
+        'status',
+        'price',
+        'expires',
+        'fulfilled',
+        'rejected',
+        'deleted',
+        'meta',
+        'configuration',
+    ],
+    enrollmentFields: [
+        '_id',
+        'userId',
+        'productId',
+        'enrollmentNumber',
+        'status',
+        'countryCode',
+        'currencyCode',
+        'quantity',
+        'created',
+        'deleted',
+        'expires',
+        'configuration',
+        'billingAddress',
+        'contact.emailAddress',
+        'contact.telNumber',
+        'delivery.providerId',
+        'payment.providerId',
+        'delivery.meta',
+        'payment.meta',
+        'meta',
+    ],
+};
+const exportUsersHandler = async ({ userId, ...options }, _, unchainedAPI) => {
+    const { modules } = unchainedAPI;
+    const user = await modules.users.findUserById(userId);
+    const userRows = [];
+    const orderRows = [];
+    const bookmarkRows = [];
+    const quotationRows = [];
+    const reviewRows = [];
+    const enrollmentRows = [];
+    if (!user)
+        throw new Error(`User with ID ${userId} not found`);
+    userRows.push({
+        _id: user._id,
+        emailAddresses: user.emails ? user.emails.map((email) => email.address).join('; ') : '',
+        created: new Date(user.created).getTime(),
+        isGuest: user.guest || false,
+        tags: user.tags ? user.tags.join('; ') : '',
+        roles: user.roles ? user.roles.join('; ') : '',
+        username: user.username || '',
+        displayName: user.profile?.displayName || '',
+        birthday: user.profile?.birthday ? new Date(user.profile?.birthday).getTime() : '',
+        phoneMobile: user.profile?.phoneMobile || '',
+        gender: user.profile?.gender || '',
+        'address.addressLine': user.profile?.address?.addressLine || '',
+        'address.addressLine2': user.profile?.address?.addressLine2 || '',
+        'address.city': user.profile?.address?.city || '',
+        'address.company': user.profile?.address?.company || '',
+        'address.countryCode': user.profile?.address?.countryCode || '',
+        'address.firstName': user.profile?.address?.firstName || '',
+        'address.lastName': user.profile?.address?.lastName || '',
+        'address.postalCode': user.profile?.address?.postalCode || '',
+        'address.regionCode': user.profile?.address?.regionCode || '',
+        meta: user.meta ? JSON.stringify(user.meta) : '',
+        lastBillingAddress: user.lastBillingAddress ? JSON.stringify(user.lastBillingAddress) : '',
+        lastContact: user.lastContact ? JSON.stringify(user.lastContact) : '',
+        lastLogin: user.lastLogin ? JSON.stringify(user.lastLogin) : '',
+    });
+    if (options.exportBookmarks) {
+        const bookmarks = await modules.bookmarks.findBookmarksByUserId(userId);
+        for (const bookmark of bookmarks) {
+            const row = {};
+            USER_CSV_SCHEMA.bookmarkFields.forEach((field) => {
+                row[field] = bookmark[field] || '';
+            });
+            bookmarkRows.push(row);
+        }
+    }
+    if (options.exportOrders) {
+        const orders = await modules.orders.findOrders({ userId });
+        for await (const order of orders) {
+            const positions = await modules.orders.positions.findOrderPositions({ orderId: order._id });
+            const row = {};
+            USER_CSV_SCHEMA.orderFields.forEach((field) => {
+                if ((field === 'ordered' || field === 'confirmed' || field === 'fulfilled') && order[field]) {
+                    row[field] = new Date(order[field]).getTime();
+                }
+                else if (field === 'products') {
+                    row[field] = positions.map((pos) => `${pos.productId}~${pos.quantity}`).join('; ');
+                }
+                else if (field === 'billingAddress' && order.billingAddress) {
+                    row[field] = JSON.stringify(order.billingAddress);
+                }
+                else if (field === 'contact' && order.contact) {
+                    row[field] = JSON.stringify(order.contact);
+                }
+                else {
+                    row[field] = order[field] || '';
+                }
+            });
+            orderRows.push(row);
+        }
+    }
+    if (options.exportReviews) {
+        const reviews = await modules.products.reviews.findProductReviews({
+            authorId: userId,
+        });
+        for (const review of reviews) {
+            const row = {};
+            USER_CSV_SCHEMA.reviewFields.forEach((field) => {
+                if (field.startsWith('vote.')) {
+                    const voteField = field.split('.')[1];
+                    if (voteField === 'timestamp' && review.votes[0][voteField]) {
+                        row[field] = new Date(review.votes[0][voteField]).getTime();
+                    }
+                    else if (voteField === 'meta' && review.votes[0][voteField]) {
+                        row[field] = JSON.stringify(review.votes[0][voteField]);
+                    }
+                    else {
+                        row[field] = review.votes[0][voteField] || '';
+                    }
+                }
+                else {
+                    if (field === 'meta' && review.meta) {
+                        row[field] = JSON.stringify(review.meta);
+                    }
+                    else {
+                        row[field] = review[field] || '';
+                    }
+                }
+            });
+            reviewRows.push(row);
+        }
+    }
+    if (options.exportQuotations) {
+        const quotations = await modules.quotations.findQuotations({
+            userId,
+        });
+        for (const quotation of quotations) {
+            const row = {};
+            USER_CSV_SCHEMA.quotationFields.forEach((field) => {
+                if ((field === 'expires' ||
+                    field === 'fulfilled' ||
+                    field === 'rejected' ||
+                    field === 'deleted') &&
+                    quotation[field]) {
+                    row[field] = new Date(quotation[field]).getTime();
+                }
+                else if (field === 'configuration' || (field === 'meta' && quotation[field])) {
+                    row[field] = JSON.stringify(quotation.configuration);
+                }
+                else {
+                    row[field] = quotation[field] || '';
+                }
+            });
+            quotationRows.push(row);
+        }
+    }
+    if (options.exportEnrollments) {
+        const enrollments = await modules.enrollments.findEnrollments({
+            userId,
+        });
+        for (const enrollment of enrollments) {
+            const row = {};
+            USER_CSV_SCHEMA.enrollmentFields.forEach((field) => {
+                if ((field === 'created' || field === 'deleted' || field === 'expires') && enrollment[field]) {
+                    row[field] = new Date(enrollment[field]).getTime();
+                }
+                else if (field === 'billingAddress' && enrollment[field]) {
+                    row[field] = JSON.stringify(enrollment[field]);
+                }
+                else if (field === 'contact.emailAddress' && enrollment.contact) {
+                    row[field] = enrollment.contact.emailAddress || '';
+                }
+                else if (field === 'contact.telNumber' && enrollment.contact) {
+                    row[field] = enrollment.contact.telNumber || '';
+                }
+                else if (field === 'delivery.providerId' && enrollment.delivery) {
+                    row[field] = enrollment.delivery.deliveryProviderId || '';
+                }
+                else if (field === 'payment.providerId' && enrollment.payment) {
+                    row[field] = enrollment.payment.paymentProviderId || '';
+                }
+                else if (field === 'delivery.meta' && enrollment.delivery) {
+                    row[field] = enrollment.delivery.meta
+                        ? JSON.stringify(enrollment.delivery.meta)
+                        : '';
+                }
+                else if (field === 'payment.meta' && enrollment.payment) {
+                    row[field] = enrollment.payment.meta
+                        ? JSON.stringify(enrollment.payment.meta)
+                        : '';
+                }
+                else if (field === 'configuration' || (field === 'meta' && enrollment[field])) {
+                    row[field] = JSON.stringify(enrollment.configuration);
+                }
+                else {
+                    row[field] = enrollment[field] || '';
+                }
+            });
+            enrollmentRows.push(row);
+        }
+    }
+    const userCSV = await generateCSVFileAndURL({
+        headers: USER_CSV_SCHEMA.userFields,
+        rows: userRows,
+        directoryName: EXPORTS_DIRECTORY,
+        fileName: 'user_export.csv',
+        unchainedAPI,
+    });
+    const reviewCSV = options.exportReviews
+        ? await generateCSVFileAndURL({
+            headers: USER_CSV_SCHEMA.reviewFields,
+            rows: reviewRows,
+            directoryName: EXPORTS_DIRECTORY,
+            fileName: 'user_reviews_export.csv',
+            unchainedAPI,
+        })
+        : null;
+    const quotationCSV = options.exportQuotations
+        ? await generateCSVFileAndURL({
+            headers: USER_CSV_SCHEMA.quotationFields,
+            rows: quotationRows,
+            directoryName: EXPORTS_DIRECTORY,
+            fileName: 'user_quotations_export.csv',
+            unchainedAPI,
+        })
+        : null;
+    const bookmarksCSV = options.exportBookmarks
+        ? await generateCSVFileAndURL({
+            headers: USER_CSV_SCHEMA.bookmarkFields,
+            rows: bookmarkRows,
+            directoryName: EXPORTS_DIRECTORY,
+            fileName: 'user_bookmarks_export.csv',
+            unchainedAPI,
+        })
+        : null;
+    const ordersCSV = options.exportOrders
+        ? await generateCSVFileAndURL({
+            headers: USER_CSV_SCHEMA.orderFields,
+            rows: orderRows,
+            directoryName: EXPORTS_DIRECTORY,
+            fileName: 'user_orders_export.csv',
+            unchainedAPI,
+        })
+        : null;
+    const enrollmentCSV = options.exportEnrollments
+        ? await generateCSVFileAndURL({
+            headers: USER_CSV_SCHEMA.enrollmentFields,
+            rows: enrollmentRows,
+            directoryName: EXPORTS_DIRECTORY,
+            fileName: 'user_enrollments_export.csv',
+            unchainedAPI,
+        })
+        : null;
+    return {
+        user: userCSV,
+        bookmarks: bookmarksCSV,
+        orders: ordersCSV,
+        reviews: reviewCSV,
+        quotations: quotationCSV,
+        enrollments: enrollmentCSV,
+    };
+};
+export default exportUsersHandler;
+exportUsersHandler.payloadSchema = UserExportPayloadSchema;

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

@@ -0,0 +1,13 @@
+import type { UnchainedCore } from '../../core-index.ts';
+export interface CSVFileResult {
+    url: string;
+    expires: number;
+}
+declare const generateCSVFileAndURL: ({ rows, headers, directoryName, fileName, unchainedAPI, }: {
+    rows: Record<string, unknown>[];
+    headers: string[];
+    directoryName: string;
+    fileName: string;
+    unchainedAPI: UnchainedCore;
+}, expires?: number) => Promise<CSVFileResult>;
+export default generateCSVFileAndURL;

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

@@ -0,0 +1,21 @@
+import toCSV from "./toCSV.js";
+const generateCSVFileAndURL = async ({ rows, headers, directoryName, fileName, unchainedAPI, }, expires = 3600000) => {
+    if (!rows.length)
+        return { url: '', expires: 0 };
+    const csvString = toCSV(headers, rows);
+    const uploaded = await unchainedAPI.services.files.uploadFileFromStream({
+        directoryName,
+        rawFile: { filename: fileName, buffer: Buffer.from(csvString).toString('base64') },
+        meta: { isPrivate: true },
+    });
+    const expiresAt = Date.now() + expires;
+    const url = await unchainedAPI.services.files.createFileDownloadURL({
+        file: uploaded,
+        expires: expiresAt,
+    });
+    if (!url) {
+        throw new Error(`Failed to generate download URL for ${fileName}`);
+    }
+    return { url, expires: expiresAt };
+};
+export default generateCSVFileAndURL;

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

@@ -0,0 +1,2 @@
+declare const toCSV: (headers: string[], rows: Record<string, any>[]) => string;
+export default toCSV;

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

@@ -0,0 +1,5 @@
+const toCSV = (headers, rows) => {
+    const escape = (v) => `"${String(v ?? '').replace(/"/g, '""')}"`;
+    return [headers.join(','), ...rows.map((r) => headers.map((h) => escape(r[h])).join(','))].join('\n');
+};
+export default toCSV;

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

@@ -0,0 +1,3 @@
+import { default as createBulkExporterFactory } from './createBulkExporter.ts';
+export * from './createBulkExporter.ts';
+export default createBulkExporterFactory;

package/lib/bulk-exporter/index.js

@@ -0,0 +1,3 @@
+import { default as createBulkExporterFactory } from "./createBulkExporter.js";
+export * from "./createBulkExporter.js";
+export default createBulkExporterFactory;

package/lib/core-index.d.ts

@@ -3,10 +3,12 @@ import { type CustomServices, type Services } from './services/index.ts';
 import { type Modules, type ModuleOptions } from './modules.ts';
 import { type BulkImporter, type BulkImportHandler } from './bulk-importer/index.ts';
 import type { IBaseAdapter } from '@unchainedshop/utils';
+import { type BulkExporter, type BulkExportHandler } from './bulk-exporter/index.ts';
 export * from './bulk-importer/index.ts';
 export * from './services/index.ts';
 export * from './directors/index.ts';
 export * from './factory/index.ts';
+export * from './bulk-exporter/index.ts';
 export { default as schedule, type ScheduleData } from './utils/schedule.ts';
 export interface UnchainedCoreOptions {
     db: mongodb.Db;
@@ -14,6 +16,9 @@ export interface UnchainedCoreOptions {
     bulkImporter?: {
         handlers?: Record<string, BulkImportHandler<UnchainedCore>>;
     };
+    bulkExporter?: {
+        handlers?: Record<string, BulkExportHandler<UnchainedCore>>;
+    };
     modules?: Record<string, {
         configure: (params: ModuleInput<any>) => any;
     }>;
@@ -25,6 +30,7 @@ export interface UnchainedCore {
     services: Services;
     bulkImporter: BulkImporter;
     options: ModuleOptions;
+    bulkExporter: BulkExporter;
 }
-export declare const initCore: ({ db, migrationRepository, bulkImporter: bulkImporterOptions, modules: customModules, services: customServices, options, }: UnchainedCoreOptions) => Promise<UnchainedCore>;
+export declare const initCore: ({ db, migrationRepository, bulkImporter: bulkImporterOptions, modules: customModules, services: customServices, options, bulkExporter: bulkExporterOptions, }: UnchainedCoreOptions) => Promise<UnchainedCore>;
 export declare const getAllAdapters: () => IBaseAdapter[];

package/lib/core-index.js

@@ -3,13 +3,16 @@ import initServices, {} from "./services/index.js";
 import initModules, {} from "./modules.js";
 import createBulkImporterFactory, {} from "./bulk-importer/index.js";
 import { WorkerDirector, DeliveryDirector, DeliveryPricingDirector, EnrollmentDirector, FilterDirector, OrderDiscountDirector, OrderPricingDirector, PaymentDirector, PaymentPricingDirector, ProductDiscountDirector, ProductPricingDirector, QuotationDirector, WarehousingDirector, } from "./directors/index.js";
+import createBulkExporterFactory, {} from "./bulk-exporter/index.js";
 export * from "./bulk-importer/index.js";
 export * from "./services/index.js";
 export * from "./directors/index.js";
 export * from "./factory/index.js";
+export * from "./bulk-exporter/index.js";
 export { default as schedule } from "./utils/schedule.js";
-export const initCore = async ({ db, migrationRepository, bulkImporter: bulkImporterOptions = {}, modules: customModules = {}, services: customServices = {}, options = {}, }) => {
+export const initCore = async ({ db, migrationRepository, bulkImporter: bulkImporterOptions = {}, modules: customModules = {}, services: customServices = {}, options = {}, bulkExporter: bulkExporterOptions = {}, }) => {
     const bulkImporter = createBulkImporterFactory(db, bulkImporterOptions);
+    const bulkExporter = createBulkExporterFactory(bulkExporterOptions);
     const modules = await initModules({ db, migrationRepository, options }, customModules);
     const services = initServices(modules, customServices);
     return {
@@ -17,6 +20,7 @@ export const initCore = async ({ db, migrationRepository, bulkImporter: bulkImpo
         services,
         bulkImporter,
         options,
+        bulkExporter,
     };
 };
 export const getAllAdapters = () => {

package/lib/directors/WorkerAdapter.d.ts

@@ -3,6 +3,7 @@ import type { WorkResult } from '@unchainedshop/core-worker';
 import type { ModuleOptions, Modules } from '../modules.ts';
 import type { Services } from '../services/index.ts';
 import type { BulkImporter } from '../bulk-importer/index.ts';
+import type { BulkExporter } from '../bulk-exporter/index.ts';
 export type IWorkerAdapter<Input, Output> = IBaseAdapter & {
     type: string;
     external: boolean;
@@ -12,6 +13,7 @@ export type IWorkerAdapter<Input, Output> = IBaseAdapter & {
         services: Services;
         bulkImporter: BulkImporter;
         options: ModuleOptions;
+        bulkExporter: BulkExporter;
     }, workId: string) => Promise<WorkResult<Output>>;
 };
 export declare const WorkerAdapter: Omit<IWorkerAdapter<any, void>, 'key' | 'label' | 'type' | 'version'>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@unchainedshop/core",
   "description": "Core orchestration package for the Unchained Engine with business services and directors",
-  "version": "4.6.0",
+  "version": "4.6.1",
   "main": "lib/core-index.js",
   "types": "lib/core-index.d.ts",
   "type": "module",