@unchainedshop/plugins 4.6.1 → 4.6.2

package/lib/warehousing/erc-metadata/api.js

@@ -0,0 +1,43 @@
+import { createLogger } from '@unchainedshop/logger';
+import { ProductContractStandard } from '@unchainedshop/core-products';
+import { systemLocale } from '@unchainedshop/utils';
+const logger = createLogger('unchained:erc-metadata');
+export async function ercMetadataHandler(request, context) {
+    try {
+        const { ROOT_URL = 'http://localhost:4010' } = process.env;
+        const { services, modules, locale, loaders, params } = context;
+        const url = new URL(request.url, ROOT_URL);
+        if (!url.pathname.toLowerCase().endsWith('.json')) {
+            throw new Error('Invalid ERC Metadata URI');
+        }
+        const { productId, localeOrTokenFilename, tokenFileName } = params;
+        const product = loaders
+            ? await loaders.productLoader.load({ productId })
+            : await modules.products.findProduct({ productId });
+        const tokenSelector = {
+            contractAddress: product?.tokenization?.contractAddress,
+        };
+        if (product?.tokenization?.contractStandard !== ProductContractStandard.ERC721) {
+            tokenSelector.tokenSerialNumber = (tokenFileName || localeOrTokenFilename)
+                .toLowerCase()
+                .replace('.json', '');
+        }
+        const [token] = await modules.warehousing.findTokens(tokenSelector);
+        const resolvedLocale = tokenFileName
+            ? new Intl.Locale(localeOrTokenFilename)
+            : locale || systemLocale;
+        const ercMetadata = await services.warehousing.ercMetadata({
+            product,
+            token,
+            locale: resolvedLocale,
+        });
+        if (!ercMetadata) {
+            return new Response(null, { status: 404 });
+        }
+        return Response.json(ercMetadata, { status: 200 });
+    }
+    catch (e) {
+        logger.error(e);
+        return Response.json({ name: e.name, code: e.code, message: e.message }, { status: 503 });
+    }
+}

package/lib/warehousing/erc-metadata/index.d.ts

@@ -0,0 +1,3 @@
+import type { IPlugin } from '@unchainedshop/core';
+export declare const ERCMetadataPlugin: IPlugin;
+export default ERCMetadataPlugin;

package/lib/warehousing/erc-metadata/index.js

@@ -0,0 +1,15 @@
+import { ercMetadataHandler } from "./api.js";
+const { ERC_METADATA_API_PATH = '/erc-metadata' } = process.env;
+export const ERCMetadataPlugin = {
+    key: 'shop.unchained.warehousing.erc-metadata',
+    label: 'ERC Metadata Plugin',
+    version: '1.0.0',
+    routes: [
+        {
+            path: `${ERC_METADATA_API_PATH}/:productId/:localeOrTokenFilename{/:tokenFileName}`,
+            method: 'GET',
+            handler: ercMetadataHandler,
+        },
+    ],
+};
+export default ERCMetadataPlugin;

package/lib/warehousing/eth-minter/adapter.d.ts

@@ -0,0 +1,2 @@
+import { type IWarehousingAdapter } from '@unchainedshop/core';
+export declare const ETHMinter: IWarehousingAdapter;

package/lib/warehousing/eth-minter/adapter.js

@@ -0,0 +1,119 @@
+import { WarehousingError, WarehousingAdapter, } from '@unchainedshop/core';
+import { WarehousingProviderType } from '@unchainedshop/core-warehousing';
+import { ProductContractStandard, ProductType } from '@unchainedshop/core-products';
+import { systemLocale } from '@unchainedshop/utils';
+import { generateDbObjectId } from '@unchainedshop/mongodb';
+import { getFileAdapter } from '@unchainedshop/core';
+import { createLogger } from '@unchainedshop/logger';
+const logger = createLogger('unchained:eth-minter');
+export const ETHMinter = {
+    ...WarehousingAdapter,
+    key: 'shop.unchained.warehousing.infinite-minter',
+    version: '1.0',
+    label: 'Infinite Minter',
+    orderIndex: 0,
+    initialConfiguration: [{ key: 'chainId', value: '0' }],
+    typeSupported: (type) => {
+        return type === WarehousingProviderType.VIRTUAL;
+    },
+    actions: (configuration, context) => {
+        const { MINTER_TOKEN_OFFSET = '0', ROOT_URL = 'http://localhost:4010' } = process.env;
+        const { product, orderPosition, token, modules, locale } = context;
+        const { contractAddress, contractStandard, tokenId, supply, ercMetadataProperties } = product?.tokenization || {};
+        const getTokensCreated = async () => {
+            const existingTokens = await modules.warehousing.findTokens(contractStandard === ProductContractStandard.ERC721
+                ? { contractAddress: contractStandard }
+                : {
+                    contractAddress: contractStandard,
+                    tokenSerialNumber: tokenId,
+                });
+            const tokensCreated = existingTokens.reduce((acc, curToken) => {
+                return acc + curToken.quantity;
+            }, 0);
+            return tokensCreated;
+        };
+        return {
+            ...WarehousingAdapter.actions(configuration, context),
+            isActive() {
+                return product?.type === ProductType.TOKENIZED_PRODUCT;
+            },
+            configurationError() {
+                if (contractStandard === 'ERC1155' && !tokenId) {
+                    logger.error(`Token ID is required for ERC1155 contract standard (productId: ${product._id})`);
+                    return WarehousingError.INCOMPLETE_CONFIGURATION;
+                }
+                return null;
+            },
+            stock: async () => {
+                const tokensCreated = await getTokensCreated();
+                return supply ? supply - tokensCreated : 0;
+            },
+            tokenize: async () => {
+                const chainId = configuration.find(({ key }) => key === 'chainId')?.value || undefined;
+                const meta = { contractStandard };
+                const tokensCreated = await getTokensCreated();
+                if (!orderPosition) {
+                    throw new Error('Order position not found in context');
+                }
+                if (contractStandard === 'ERC721') {
+                    const items = new Array(orderPosition.quantity).fill(null).map((_, i) => ({
+                        _id: generateDbObjectId(),
+                        tokenSerialNumber: Number(parseInt(MINTER_TOKEN_OFFSET, 10) + tokensCreated + (i + 1)).toString(),
+                        contractAddress,
+                        quantity: 1,
+                        chainId,
+                        meta,
+                    }));
+                    return items;
+                }
+                return [
+                    {
+                        _id: generateDbObjectId(),
+                        tokenSerialNumber: tokenId,
+                        contractAddress,
+                        quantity: orderPosition.quantity,
+                        chainId,
+                        meta,
+                    },
+                ];
+            },
+            tokenMetadata: async (tokenSerialNumber) => {
+                if (!product) {
+                    throw new Error('Product not found in context');
+                }
+                const allLanguages = await modules.languages.findLanguages({
+                    includeInactive: false,
+                });
+                const [firstMedia] = await modules.products.media.findProductMedias({
+                    productId: product._id,
+                    limit: 1,
+                });
+                const file = firstMedia && (await modules.files.findFile({ fileId: firstMedia.mediaId }));
+                const fileAdapter = file && getFileAdapter();
+                const signedUrl = await fileAdapter?.createDownloadURL(file);
+                const url = signedUrl && (await modules.files.normalizeUrl(signedUrl, {}));
+                const text = await modules.products.texts.findLocalizedText({
+                    productId: product._id,
+                    locale: locale || systemLocale,
+                });
+                const name = `${text.title} #${tokenSerialNumber}`;
+                const isDefaultLanguageActive = locale ? locale.language === systemLocale.language : true;
+                const localization = isDefaultLanguageActive
+                    ? {
+                        uri: `${ROOT_URL}/erc-metadata/${product._id}/${locale}/${tokenId}.json`,
+                        default: systemLocale.language,
+                        locales: allLanguages.map((lang) => lang.isoCode),
+                    }
+                    : undefined;
+                return {
+                    name,
+                    description: text.description,
+                    image: url,
+                    properties: ercMetadataProperties,
+                    localization,
+                    ...(token?.meta || {}),
+                };
+            },
+        };
+    },
+};

package/lib/warehousing/eth-minter/index.d.ts

@@ -0,0 +1,4 @@
+import { type IPlugin } from '@unchainedshop/core';
+export declare const ETHMinterPlugin: IPlugin;
+export default ETHMinterPlugin;
+export { ETHMinter } from './adapter.ts';

package/lib/warehousing/eth-minter/index.js

@@ -0,0 +1,10 @@
+import {} from '@unchainedshop/core';
+import { ETHMinter } from "./adapter.js";
+export const ETHMinterPlugin = {
+    key: 'shop.unchained.warehousing.infinite-minter',
+    label: 'ETH Infinite Minter Warehousing Plugin',
+    version: '1.0.0',
+    adapters: [ETHMinter],
+};
+export default ETHMinterPlugin;
+export { ETHMinter } from "./adapter.js";

package/lib/warehousing/store/adapter.d.ts

@@ -0,0 +1,2 @@
+import { type IWarehousingAdapter } from '@unchainedshop/core';
+export declare const Store: IWarehousingAdapter;

package/lib/warehousing/store/adapter.js

@@ -0,0 +1,33 @@
+import { WarehousingAdapter } from '@unchainedshop/core';
+import { WarehousingProviderType } from '@unchainedshop/core-warehousing';
+export const Store = {
+    ...WarehousingAdapter,
+    key: 'shop.unchained.warehousing.store',
+    label: 'Store',
+    version: '1.0.0',
+    orderIndex: 0,
+    initialConfiguration: [{ key: 'name', value: 'Flagship Store' }],
+    typeSupported: (type) => {
+        return type === WarehousingProviderType.PHYSICAL;
+    },
+    actions: (configuration, context) => {
+        return {
+            ...WarehousingAdapter.actions(configuration, context),
+            isActive() {
+                return true;
+            },
+            configurationError() {
+                return null;
+            },
+            stock: async () => {
+                return 99999;
+            },
+            productionTime: async () => {
+                return 0;
+            },
+            commissioningTime: async () => {
+                return 0;
+            },
+        };
+    },
+};

package/lib/warehousing/store/index.d.ts

@@ -0,0 +1,4 @@
+import { type IPlugin } from '@unchainedshop/core';
+export declare const StorePlugin: IPlugin;
+export default StorePlugin;
+export { Store } from './adapter.ts';

package/lib/warehousing/store/index.js

@@ -0,0 +1,10 @@
+import {} from '@unchainedshop/core';
+import { Store } from "./adapter.js";
+export const StorePlugin = {
+    key: 'shop.unchained.warehousing.store',
+    label: 'Store Warehousing Plugin',
+    version: '1.0.0',
+    adapters: [Store],
+};
+export default StorePlugin;
+export { Store } from "./adapter.js";

package/lib/worker/budgetsms/adapter.d.ts

@@ -0,0 +1,22 @@
+import { type IWorkerAdapter } from '@unchainedshop/core';
+export declare const BudgetSMSWorker: IWorkerAdapter<{
+    from?: string;
+    to: string;
+    text?: string;
+    test?: boolean;
+    customid?: string;
+    price?: boolean;
+    mccmnc?: boolean;
+    credit?: boolean;
+    [key: string]: any;
+}, any>;
+export declare function checkBudgetSmsCredentials(): Promise<{
+    success: boolean;
+    credit: number;
+    error?: undefined;
+} | {
+    error: any;
+    success?: undefined;
+    credit?: undefined;
+}>;
+export default BudgetSMSWorker;

package/lib/worker/budgetsms/adapter.js

@@ -0,0 +1,169 @@
+import { WorkerAdapter } from '@unchainedshop/core';
+const { BUDGETSMS_USERNAME, BUDGETSMS_USERID, BUDGETSMS_HANDLE } = process.env;
+export const BudgetSMSWorker = {
+    ...WorkerAdapter,
+    key: 'shop.unchained.worker-plugin.budgetsms',
+    label: 'Send Messages through BudgetSMS',
+    version: '1.0.0',
+    type: 'BUDGETSMS',
+    doWork: async ({ from, to, text, test = false, customid, price = false, mccmnc = false, credit = false, ...params }) => {
+        try {
+            if (!BUDGETSMS_USERNAME || !BUDGETSMS_USERID || !BUDGETSMS_HANDLE) {
+                throw new Error('Missing BudgetSMS credentials. Please set BUDGETSMS_USERNAME, BUDGETSMS_USERID, and BUDGETSMS_HANDLE');
+            }
+            const username = BUDGETSMS_USERNAME.trim();
+            const userid = BUDGETSMS_USERID.trim();
+            const handle = BUDGETSMS_HANDLE.trim();
+            if (!/^\d+$/.test(userid)) {
+                throw new Error('BUDGETSMS_USERID must be numeric only. Found: ' + userid);
+            }
+            const url = test ? 'https://api.budgetsms.net/testsms/' : 'https://api.budgetsms.net/sendsms/';
+            const formattedTo = to.replace(/^\+|^00/, '').replace(/[\s-]/g, '');
+            const queryParams = new URLSearchParams({
+                username: username,
+                userid: userid,
+                handle: handle,
+                msg: text || '',
+                from: from || '',
+                to: formattedTo,
+                ...(customid && { customid }),
+                ...(!test && price && { price: '1' }),
+                ...(!test && mccmnc && { mccmnc: '1' }),
+                ...(!test && credit && { credit: '1' }),
+                ...params,
+            });
+            const fullUrl = `${url}?${queryParams.toString()}`;
+            const response = await fetch(fullUrl, {
+                method: 'GET',
+                headers: {
+                    Accept: 'text/plain',
+                    'User-Agent': 'Unchained/BudgetSMS-Plugin',
+                },
+            });
+            const responseText = await response.text().then((text) => text.trim());
+            if (responseText.startsWith('OK')) {
+                const parts = responseText.split(' ');
+                const result = {
+                    sms_id: parts[1] || null,
+                    status: test ? 'test_successful' : 'sent',
+                    test_mode: test,
+                };
+                if (test) {
+                    result.message = 'Test SMS validated successfully (no credit deducted)';
+                }
+                else {
+                    let index = 2;
+                    if (price && parts[index] && parts[index + 1]) {
+                        result.price = parseFloat(parts[index]);
+                        result.parts = parseInt(parts[index + 1]);
+                        index += 2;
+                    }
+                    if (mccmnc && parts[index]) {
+                        result.mccmnc = parts[index];
+                        index += 1;
+                    }
+                    if (credit && parts[index]) {
+                        result.remaining_credit = parseFloat(parts[index]);
+                    }
+                }
+                return {
+                    success: true,
+                    result,
+                    error: null,
+                };
+            }
+            if (responseText.startsWith('ERR')) {
+                const parts = responseText.split(' ');
+                const errorCode = parts[1] || 'UNKNOWN';
+                const errorMessages = {
+                    '1001': 'Authentication failed OR insufficient credit (BudgetSMS returns 1001 for both)',
+                    '1002': 'Account not active',
+                    '1003': 'Insufficient credit',
+                    '1004': 'No access to this API',
+                    '1005': 'No handle provided',
+                    '1006': 'No UserID provided',
+                    '1007': 'No Username provided',
+                    '2001': 'SMS message text is empty',
+                    '2002': 'SMS numeric senderid can be max. 16 numbers',
+                    '2003': 'SMS alphanumeric sender can be max. 11 characters',
+                    '2004': 'SMS senderid is empty or invalid',
+                    '2005': 'Destination number is too short',
+                    '2006': 'Destination is not numeric',
+                    '2007': 'Destination is empty',
+                    '2008': 'SMS text is not OK (check encoding?)',
+                    '2009': 'Parameter issue',
+                    '2010': 'Destination number is invalidly formatted',
+                    '2011': 'Destination is invalid',
+                    '2012': 'SMS message text is too long',
+                    '2013': 'SMS message is invalid',
+                    '2014': 'SMS CustomID is used before',
+                    '2015': 'Charset problem',
+                    '2016': 'Invalid UTF-8 encoding',
+                    '3001': 'No route to destination',
+                    '3002': 'No routes are setup',
+                    '3003': 'Invalid destination',
+                    '4001': 'System error, related to customid',
+                    '4002': 'System error, temporary issue',
+                };
+                let message = errorMessages[errorCode] || `Unknown error code: ${errorCode}`;
+                if (errorCode === '1001') {
+                    message += '. Note: Check your account balance - BudgetSMS may return 1001 when credit is 0.';
+                }
+                return {
+                    success: false,
+                    error: {
+                        name: 'BUDGETSMS_ERROR',
+                        code: errorCode,
+                        message,
+                    },
+                };
+            }
+            return {
+                success: false,
+                error: {
+                    name: 'BUDGETSMS_ERROR',
+                    message: 'Unexpected response format from BudgetSMS API',
+                    response: responseText,
+                },
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: {
+                    name: err.name,
+                    message: err.message,
+                    stack: err.stack,
+                },
+            };
+        }
+    },
+};
+export async function checkBudgetSmsCredentials() {
+    const url = 'https://api.budgetsms.net/checkcredit/';
+    const username = process.env.BUDGETSMS_USERNAME?.trim();
+    const userid = process.env.BUDGETSMS_USERID?.trim();
+    const handle = process.env.BUDGETSMS_HANDLE?.trim();
+    if (!username || !userid || !handle) {
+        return { error: 'Missing credentials' };
+    }
+    if (!/^\d+$/.test(userid)) {
+        return { error: 'UserID must be numeric only' };
+    }
+    const queryParams = new URLSearchParams({ username, userid, handle });
+    try {
+        const response = await fetch(`${url}?${queryParams.toString()}`, { method: 'GET' });
+        const text = await response.text();
+        if (text.startsWith('OK')) {
+            const credit = parseFloat(text.split(' ')[1]) || 0;
+            return { success: true, credit };
+        }
+        else {
+            return { error: text };
+        }
+    }
+    catch (err) {
+        return { error: err.message };
+    }
+}
+export default BudgetSMSWorker;

package/lib/worker/budgetsms/index.d.ts

@@ -0,0 +1,4 @@
+import { type IPlugin } from '@unchainedshop/core';
+export declare const BudgetSMSPlugin: IPlugin;
+export default BudgetSMSPlugin;
+export { BudgetSMSWorker, checkBudgetSmsCredentials } from './adapter.ts';

package/lib/worker/budgetsms/index.js

@@ -0,0 +1,10 @@
+import {} from '@unchainedshop/core';
+import { BudgetSMSWorker } from "./adapter.js";
+export const BudgetSMSPlugin = {
+    key: 'shop.unchained.worker-plugin.budgetsms',
+    label: 'Budget SMS Worker Plugin',
+    version: '1.0.0',
+    adapters: [BudgetSMSWorker],
+};
+export default BudgetSMSPlugin;
+export { BudgetSMSWorker, checkBudgetSmsCredentials } from "./adapter.js";

package/lib/worker/bulk-export/adapter.d.ts

@@ -0,0 +1,3 @@
+import { type IWorkerAdapter } from '@unchainedshop/core';
+export declare const BulkExport: IWorkerAdapter<any, any>;
+export default BulkExport;

package/lib/worker/bulk-export/adapter.js

@@ -0,0 +1,64 @@
+import { WorkerAdapter } from '@unchainedshop/core';
+import { createLogger } from '@unchainedshop/logger';
+const isSupportedLocale = (locale) => {
+    try {
+        const dtf = new Intl.DateTimeFormat(locale);
+        const resolved = dtf.resolvedOptions().locale;
+        return resolved.toLowerCase() === locale.toLowerCase();
+    }
+    catch (e) {
+        console.error(e);
+        return false;
+    }
+};
+const createLanguageDialectList = (languages, countries) => {
+    const result = new Set();
+    (languages || []).forEach(({ isoCode: baseIsoCode }) => {
+        result.add(baseIsoCode);
+        (countries || []).forEach(({ isoCode: countryIsoCode }) => {
+            const dialectIsoCode = [baseIsoCode, countryIsoCode.toUpperCase()].join('-');
+            if (isSupportedLocale(dialectIsoCode))
+                result.add(dialectIsoCode);
+        });
+    });
+    return Array.from(result);
+};
+const logger = createLogger('unchained:bulk-export');
+export const BulkExport = {
+    ...WorkerAdapter,
+    key: 'shop.unchained.worker-plugin.bulk-export',
+    label: 'Bulk Export',
+    version: '2.1.0',
+    type: 'BULK_EXPORT',
+    maxParallelAllocations: 1,
+    doWork: async (payload, unchainedAPI) => {
+        try {
+            const { modules } = unchainedAPI;
+            const languages = await modules.languages.findLanguages({ includeInactive: false });
+            const countries = await modules.countries.findCountries({ includeInactive: false });
+            const bulkExporter = unchainedAPI.bulkExporter.createBulkExporter({ entity: payload.type });
+            await bulkExporter.validate(payload);
+            const locales = createLanguageDialectList(languages, countries);
+            const [result, error] = await bulkExporter.execute(payload, locales, unchainedAPI);
+            if (error) {
+                return {
+                    success: false,
+                    result: result,
+                    error,
+                };
+            }
+            return {
+                success: true,
+                result,
+            };
+        }
+        catch (err) {
+            logger.error(err);
+            return {
+                success: false,
+                error: { name: err.name, message: err.message, stack: err.stack },
+            };
+        }
+    },
+};
+export default BulkExport;

package/lib/worker/bulk-export/index.d.ts

@@ -0,0 +1,4 @@
+import { type IPlugin } from '@unchainedshop/core';
+export declare const BulkExportPlugin: IPlugin;
+export default BulkExportPlugin;
+export { BulkExport } from './adapter.ts';

package/lib/worker/bulk-export/index.js

@@ -0,0 +1,10 @@
+import {} from '@unchainedshop/core';
+import { BulkExport } from "./adapter.js";
+export const BulkExportPlugin = {
+    key: 'shop.unchained.worker-plugin.bulk-export',
+    label: 'Bulk Export Worker Plugin',
+    version: '1.0.0',
+    adapters: [BulkExport],
+};
+export default BulkExportPlugin;
+export { BulkExport } from "./adapter.js";

package/lib/worker/bulk-import/adapter.d.ts

@@ -0,0 +1,3 @@
+import { type IWorkerAdapter } from '@unchainedshop/core';
+export declare const BulkImportWorker: IWorkerAdapter<any, Record<string, any>>;
+export default BulkImportWorker;

package/lib/worker/bulk-import/adapter.js

@@ -0,0 +1,65 @@
+import { WorkerAdapter } from '@unchainedshop/core';
+import { createLogger } from '@unchainedshop/logger';
+const logger = createLogger('unchained:bulk-import');
+export const BulkImportWorker = {
+    ...WorkerAdapter,
+    key: 'shop.unchained.worker-plugin.bulk-import',
+    label: 'Bulk Import',
+    version: '1.0.0',
+    type: 'BULK_IMPORT',
+    maxParallelAllocations: 1,
+    doWork: async (rawPayload, unchainedAPI) => {
+        try {
+            const { createShouldUpsertIfIDExists = false, skipCacheInvalidation = false, updateShouldUpsertIfIDNotExists = false, } = rawPayload;
+            const bulkImporter = unchainedAPI.bulkImporter.createBulkImporter({
+                createShouldUpsertIfIDExists,
+                updateShouldUpsertIfIDNotExists,
+                skipCacheInvalidation,
+            });
+            if (rawPayload.payloadId) {
+                const readStream = await unchainedAPI.services.files.createDownloadStream({
+                    fileId: rawPayload.payloadId,
+                });
+                if (!readStream) {
+                    throw new Error('Could not create download stream from uploaded file');
+                }
+                await unchainedAPI.bulkImporter.pipeEventStream(readStream, bulkImporter, unchainedAPI);
+            }
+            else {
+                const { events } = rawPayload;
+                if (!events?.length)
+                    throw new Error('No events submitted');
+                await events.reduce(async (currentEventPromise, nextEvent) => {
+                    await currentEventPromise;
+                    await bulkImporter.validate(nextEvent);
+                    return bulkImporter.prepare(nextEvent, unchainedAPI);
+                }, Promise.resolve());
+            }
+            const [result, error] = await bulkImporter.execute();
+            await bulkImporter.invalidateCaches(unchainedAPI);
+            if (error) {
+                return {
+                    success: false,
+                    result: result,
+                    error,
+                };
+            }
+            return {
+                success: true,
+                result: result,
+            };
+        }
+        catch (err) {
+            logger.error(err);
+            return {
+                success: false,
+                error: {
+                    name: err.name,
+                    message: err.message,
+                    stack: err.stack,
+                },
+            };
+        }
+    },
+};
+export default BulkImportWorker;

package/lib/worker/bulk-import/api.d.ts

@@ -0,0 +1,7 @@
+import type { UnchainedCore } from '@unchainedshop/core';
+export declare function bulkImportHandler(request: Request, context: UnchainedCore & {
+    params: Record<string, string>;
+    rawRequest?: any;
+    userId?: string;
+    user?: any;
+}): Promise<Response>;