@unchainedshop/core 4.6.0 → 4.6.2

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/FileDirector.d.ts

@@ -0,0 +1,10 @@
+import type { IFileAdapter, UploadedFile } from '@unchainedshop/core-files';
+export type UploadFileCallback<UnchainedAPI = unknown> = (file: UploadedFile, unchainedAPI: UnchainedAPI) => Promise<void>;
+export declare const FileDirector: {
+    getAdapter: (key: string) => IFileAdapter<unknown> | null;
+    getAdapters: (options?: {
+        adapterFilter?: (adapter: IFileAdapter) => boolean;
+    }) => IFileAdapter<unknown>[];
+    registerFileUploadCallback<UnchainedAPI>(directoryName: string, fn: UploadFileCallback<UnchainedAPI>): void;
+    getFileUploadCallback(directoryName: string): UploadFileCallback<unknown> | null;
+};

package/lib/directors/FileDirector.js

@@ -0,0 +1,25 @@
+import { BaseDirector } from '@unchainedshop/utils';
+import { FileAdapter } from '@unchainedshop/core-files';
+import { pluginRegistry } from "../plugins/PluginRegistry.js";
+const FileUploadRegistry = new Map();
+const baseDirector = BaseDirector('FileDirector');
+export const FileDirector = {
+    ...baseDirector,
+    getAdapter: (key) => {
+        const adapters = pluginRegistry.getAdapters(FileAdapter.adapterType);
+        return adapters.find((adapter) => adapter.key === key) || null;
+    },
+    getAdapters: (options) => {
+        const { adapterFilter } = options || {};
+        const adapters = pluginRegistry.getAdapters(FileAdapter.adapterType);
+        return adapters.filter(adapterFilter || (() => true));
+    },
+    registerFileUploadCallback(directoryName, fn) {
+        if (!FileUploadRegistry.has(directoryName)) {
+            FileUploadRegistry.set(directoryName, fn);
+        }
+    },
+    getFileUploadCallback(directoryName) {
+        return FileUploadRegistry.get(directoryName) || null;
+    },
+};

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'>;