@unchainedshop/plugins 4.8.24 → 4.8.26

package/lib/files/gridfs/api.js

@@ -1,163 +0,0 @@
-import { Readable, PassThrough } from 'node:stream';
-import { finished, pipeline } from 'node:stream/promises';
-import { buildHashedFilename } from '@unchainedshop/core-files';
-import sign from "./sign.js";
-import { getFileAdapter } from '@unchainedshop/core';
-import { createLogger } from '@unchainedshop/logger';
-import { timingSafeStringEqual } from '@unchainedshop/utils';
-const { GRIDFS_PUT_SERVER_PATH = '/gridfs' } = process.env;
-const logger = createLogger('unchained:gridfs');
-export const gridfsRouteHandler = async (request, context) => {
-    try {
-        const { services, modules, params } = context;
-        const directoryName = decodeURIComponent(params.directoryName);
-        const fileName = decodeURIComponent(params.fileName);
-        const corsHeaders = {
-            'Access-Control-Allow-Methods': 'GET, PUT, OPTIONS',
-            'Access-Control-Allow-Headers': 'Content-Type',
-            'Access-Control-Allow-Origin': '*',
-        };
-        if (request.method === 'OPTIONS') {
-            return new Response(null, {
-                status: 200,
-                headers: corsHeaders,
-            });
-        }
-        if (request.method === 'PUT') {
-            const url = new URL(request.url);
-            const signature = url.searchParams.get('s');
-            const expiryTimestamp = url.searchParams.get('e');
-            if (!signature || !expiryTimestamp) {
-                return new Response(JSON.stringify({ error: 'Missing signature or expiry' }), {
-                    status: 400,
-                    headers: { 'Content-Type': 'application/json', ...corsHeaders },
-                });
-            }
-            const expiryDate = new Date(parseInt(expiryTimestamp, 10));
-            const fileId = await buildHashedFilename(directoryName, fileName, expiryDate);
-            const expectedSignature = await sign(directoryName, fileId, expiryDate.getTime());
-            if (!(await timingSafeStringEqual(expectedSignature, signature))) {
-                logger.error('Invalid signature', { fileId, expiryDate });
-                return new Response(JSON.stringify({ error: 'Invalid signature' }), {
-                    status: 403,
-                    headers: { 'Content-Type': 'application/json', ...corsHeaders },
-                });
-            }
-            const file = await modules.files.findFile({ fileId });
-            if (!file) {
-                logger.error('File not found', { fileId });
-                return new Response(JSON.stringify({ error: 'File not found' }), {
-                    status: 404,
-                    headers: { 'Content-Type': 'application/json', ...corsHeaders },
-                });
-            }
-            if (file.expires === null) {
-                logger.error('File already linked', { fileId });
-                return new Response(JSON.stringify({ error: 'File already linked' }), {
-                    status: 400,
-                    headers: { 'Content-Type': 'application/json', ...corsHeaders },
-                });
-            }
-            const contentType = request.headers.get('Content-Type');
-            const type = contentType === 'application/octet-stream' ? file.type || contentType : contentType || file.type;
-            const writeStream = await modules.gridfsFileUploads.createWriteStream(directoryName, fileId, fileName, {
-                chunkSizeBytes: 1024 * 1024,
-                metadata: { 'content-type': type },
-            });
-            const bodyStream = request.body;
-            if (!bodyStream) {
-                throw new Error('No request body');
-            }
-            await pipeline(bodyStream, new PassThrough({ highWaterMark: 1024 * 1024 * 4 }), writeStream);
-            await finished(writeStream, { readable: false });
-            const { length } = writeStream;
-            await services.files.linkFile({ fileId, size: length, type });
-            return new Response(JSON.stringify({
-                success: true,
-                fileId,
-                size: length,
-                type,
-            }), {
-                status: 200,
-                headers: { 'Content-Type': 'application/json', ...corsHeaders },
-            });
-        }
-        if (request.method === 'GET') {
-            const url = new URL(request.url);
-            const signature = url.searchParams.get('s');
-            const expiryTimestamp = url.searchParams.get('e');
-            const fileDocument = await modules.files.findFile({
-                url: `${GRIDFS_PUT_SERVER_PATH}/${directoryName}/${encodeURIComponent(fileName)}`,
-            });
-            if (!fileDocument) {
-                logger.error('File not found', { fileName });
-                return new Response(null, {
-                    status: 404,
-                    headers: corsHeaders,
-                });
-            }
-            if (fileDocument?.meta?.isPrivate) {
-                if (!expiryTimestamp || !signature) {
-                    return new Response(JSON.stringify({ error: 'Missing signature or expiry' }), {
-                        status: 403,
-                        headers: { 'Content-Type': 'application/json', ...corsHeaders },
-                    });
-                }
-                const expiry = parseInt(expiryTimestamp, 10);
-                if (expiry <= Date.now()) {
-                    logger.error('URL Expired', { fileName, expiry });
-                    return new Response(JSON.stringify({ error: 'Access restricted: Expired.' }), {
-                        status: 403,
-                        headers: { 'Content-Type': 'application/json', ...corsHeaders },
-                    });
-                }
-                const fileUploadAdapter = getFileAdapter();
-                const signedUrl = await fileUploadAdapter.createDownloadURL(fileDocument, expiry);
-                const expectedSignature = signedUrl ? new URL(signedUrl, 'file://').searchParams.get('s') : null;
-                if (!signedUrl ||
-                    !expectedSignature ||
-                    !(await timingSafeStringEqual(expectedSignature, signature))) {
-                    logger.error('Invalid signature', { fileName, expiry });
-                    return new Response(JSON.stringify({ error: 'Access restricted: Invalid signature.' }), {
-                        status: 403,
-                        headers: { 'Content-Type': 'application/json', ...corsHeaders },
-                    });
-                }
-            }
-            const file = await modules.gridfsFileUploads.getFileInfo(directoryName, fileDocument._id);
-            const readStream = await modules.gridfsFileUploads.createReadStream(directoryName, fileDocument._id);
-            const webStream = Readable.toWeb(readStream);
-            const headers = {
-                ...corsHeaders,
-            };
-            if (file?.metadata?.['content-type']) {
-                headers['Content-Type'] = file.metadata['content-type'];
-            }
-            if (file?.length) {
-                headers['Content-Length'] = file.length.toString();
-            }
-            return new Response(webStream, {
-                status: 200,
-                headers,
-            });
-        }
-        return new Response(null, {
-            status: 404,
-            headers: corsHeaders,
-        });
-    }
-    catch (e) {
-        logger.error(e);
-        if (e.code === 'ENOENT') {
-            return new Response(null, { status: 404 });
-        }
-        return new Response(JSON.stringify({
-            error: e.message || 'Internal Server Error',
-            name: e.name,
-            code: e.code,
-        }), {
-            status: 500,
-            headers: { 'Content-Type': 'application/json' },
-        });
-    }
-};

package/lib/files/minio/adapter.d.ts

@@ -1,4 +0,0 @@
-import { type IFileAdapter } from '@unchainedshop/core-files';
-import { Client } from 'minio';
-export declare function connectToMinio(): Promise<Client | null>;
-export declare const MinioAdapter: IFileAdapter;

package/lib/files/minio/adapter.js

@@ -1,160 +0,0 @@
-import { Readable } from 'node:stream';
-import { FileAdapter, buildHashedFilename, resolveExpirationDate, expiryOffsetInMs, } from '@unchainedshop/core-files';
-import mime from 'mime/lite';
-import { Client } from 'minio';
-import { AssumeRoleProvider } from 'minio/dist/esm/AssumeRoleProvider.mjs';
-import { createLogger } from '@unchainedshop/logger';
-const logger = createLogger('unchained:minio');
-const { MINIO_ACCESS_KEY, MINIO_REGION, MINIO_STS_ENDPOINT, MINIO_SECRET_KEY, MINIO_ENDPOINT, MINIO_BUCKET_NAME, MINIO_UPLOAD_PREFIX, NODE_ENV, AMAZON_S3_SESSION_TOKEN, } = process.env;
-let client = null;
-export async function connectToMinio() {
-    if (!MINIO_ENDPOINT || !MINIO_BUCKET_NAME) {
-        logger.error('Please configure Minio/S3 by providing MINIO_ENDPOINT & MINIO_BUCKET_NAME to use upload features');
-        return null;
-    }
-    try {
-        const resolvedUrl = new URL(MINIO_ENDPOINT);
-        const minioClient = new Client({
-            endPoint: resolvedUrl.hostname,
-            useSSL: resolvedUrl.protocol === 'https:',
-            port: parseInt(resolvedUrl.port, 10) || undefined,
-            region: MINIO_REGION,
-            sessionToken: AMAZON_S3_SESSION_TOKEN,
-            accessKey: MINIO_ACCESS_KEY,
-            secretKey: MINIO_SECRET_KEY,
-        });
-        if (NODE_ENV === 'development')
-            minioClient?.traceOn(process.stdout);
-        if (MINIO_STS_ENDPOINT) {
-            const ap = new AssumeRoleProvider({
-                stsEndpoint: MINIO_STS_ENDPOINT,
-                accessKey: MINIO_ACCESS_KEY,
-                secretKey: MINIO_SECRET_KEY,
-            });
-            await minioClient.setCredentialsProvider(ap);
-        }
-        return minioClient;
-    }
-    catch (error) {
-        logger.error(`Exception while creating Minio client: ${error.message}`);
-    }
-    return null;
-}
-const generateMinioPath = (directoryName, fileName) => {
-    const prefix = MINIO_UPLOAD_PREFIX || '';
-    return [prefix, directoryName, fileName].filter(Boolean).join('/');
-};
-const generateMinioUrl = (directoryName, hashedFilename) => {
-    return `${MINIO_ENDPOINT}/${MINIO_BUCKET_NAME}/${generateMinioPath(directoryName, hashedFilename)}`;
-};
-connectToMinio().then(function setClient(c) {
-    client = c || client;
-});
-const getObjectStats = async (fileName) => {
-    if (!client)
-        throw new Error('Minio not connected, check env variables');
-    return client.statObject(MINIO_BUCKET_NAME, fileName);
-};
-const bufferToStream = (buffer) => {
-    const stream = new Readable();
-    stream.push(buffer);
-    stream.push(null);
-    return stream;
-};
-export const MinioAdapter = {
-    key: 'shop.unchained.file-upload-plugin.minio',
-    label: 'Uploads files into an S3 bucket using minio',
-    version: '1.1.0',
-    ...FileAdapter,
-    async createDownloadURL(file) {
-        if (file.meta?.isPrivate)
-            throw new Error("Minio Plugin doesn't support private files yet");
-        return generateMinioUrl(file.path, file._id);
-    },
-    async createSignedURL(directoryName, fileName) {
-        if (!client)
-            throw new Error('Minio not connected, check env variables');
-        const expiryDate = resolveExpirationDate();
-        const _id = await buildHashedFilename(directoryName, fileName, expiryDate);
-        const url = await client.presignedPutObject(MINIO_BUCKET_NAME, generateMinioPath(directoryName, _id), expiryOffsetInMs() / 1000);
-        return {
-            _id,
-            directoryName,
-            expiryDate,
-            fileName,
-            type: mime.getType(fileName),
-            putURL: url,
-            url: generateMinioUrl(directoryName, _id),
-        };
-    },
-    async removeFiles(files) {
-        if (!client)
-            throw new Error('Minio not connected, check env variables');
-        const fileIds = files.map(({ path, _id }) => {
-            return `${path}/${_id}`;
-        });
-        await client.removeObjects(MINIO_BUCKET_NAME, fileIds);
-    },
-    async uploadFileFromStream(directoryName, rawFile) {
-        if (!client)
-            throw new Error('Minio not connected, check env variables');
-        let stream;
-        let fileName;
-        if (rawFile instanceof Promise) {
-            const { filename: fname, createReadStream } = await rawFile;
-            fileName = fname;
-            stream = createReadStream();
-        }
-        else {
-            fileName = rawFile.filename;
-            stream = bufferToStream(Buffer.from(rawFile.buffer, 'base64'));
-        }
-        const _id = await buildHashedFilename(directoryName, fileName, new Date());
-        const type = mime.getType(fileName) || (await Promise.resolve(rawFile)).mimetype;
-        const metaData = {
-            'Content-Type': type,
-        };
-        await client.putObject(MINIO_BUCKET_NAME, generateMinioPath(directoryName, _id), stream, undefined, metaData);
-        const { size } = await getObjectStats(generateMinioPath(directoryName, _id));
-        return {
-            _id,
-            directoryName,
-            expiryDate: null,
-            fileName,
-            size,
-            type,
-            url: generateMinioUrl(directoryName, _id),
-        };
-    },
-    async uploadFileFromURL(directoryName, { fileLink, fileName: fname, fileId, headers }) {
-        if (!client)
-            throw new Error('Minio not connected, check env variables');
-        const { href } = new URL(fileLink);
-        const fileName = fname || href.split('/').pop();
-        const hashedFilename = await buildHashedFilename(directoryName, fileName, new Date());
-        const url = new URL(fileLink);
-        const response = await fetch(url, { headers });
-        const type = mime.getType(fileName) || response.headers['content-type'];
-        const readable = Readable.fromWeb(response.body);
-        const metaData = {
-            'Content-Type': type,
-        };
-        await client.putObject(MINIO_BUCKET_NAME, generateMinioPath(directoryName, hashedFilename), readable, undefined, metaData);
-        const { size } = await getObjectStats(generateMinioPath(directoryName, hashedFilename));
-        return {
-            _id: fileId || hashedFilename,
-            directoryName,
-            expiryDate: null,
-            fileName,
-            size,
-            type,
-            url: generateMinioUrl(directoryName, hashedFilename),
-        };
-    },
-    async createDownloadStream(file) {
-        if (!client)
-            throw new Error('Minio not connected, check env variables');
-        const stream = await client.getObject(MINIO_BUCKET_NAME, generateMinioPath(file.path, file._id));
-        return stream;
-    },
-};

package/lib/files/minio/api.d.ts

@@ -1,2 +0,0 @@
-import type { UnchainedCore } from '@unchainedshop/core';
-export declare function minioWebhookHandler(request: Request, context: UnchainedCore): Promise<Response>;

package/lib/files/minio/api.js

@@ -1,40 +0,0 @@
-import { createLogger } from '@unchainedshop/logger';
-import { timingSafeStringEqual } from '@unchainedshop/utils';
-const logger = createLogger('unchained:minio');
-const { MINIO_WEBHOOK_AUTH_TOKEN } = process.env;
-const isAuthorized = async (authorization = '') => {
-    if (!MINIO_WEBHOOK_AUTH_TOKEN)
-        return false;
-    const [type, token] = authorization.split(' ');
-    if (type !== 'Bearer' || !token)
-        return false;
-    return timingSafeStringEqual(token, MINIO_WEBHOOK_AUTH_TOKEN);
-};
-export async function minioWebhookHandler(request, context) {
-    try {
-        const authorization = request.headers.get('authorization') || '';
-        if (!(await isAuthorized(authorization))) {
-            return new Response(JSON.stringify({ error: 'Unauthorized' }), {
-                status: 401,
-                headers: { 'Content-Type': 'application/json' },
-            });
-        }
-        const { Records = [], EventName } = (await request.json());
-        if (EventName === 's3:ObjectCreated:Put') {
-            const [{ s3 }] = Records;
-            const { object } = s3;
-            const { size, contentType: type } = object;
-            const [fileId] = object.key.split('.');
-            await context.services.files.linkFile({ fileId, type, size });
-            return new Response(null, { status: 200 });
-        }
-        return new Response(null, { status: 404 });
-    }
-    catch (e) {
-        logger.error(e);
-        return new Response(JSON.stringify({ name: e.name, code: e.code, message: e.message }), {
-            status: 503,
-            headers: { 'Content-Type': 'application/json' },
-        });
-    }
-}

package/lib/files/temp-upload/api.d.ts

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

package/lib/files/temp-upload/api.js

@@ -1,48 +0,0 @@
-import { createLogger } from '@unchainedshop/logger';
-import { getFileAdapter } from '@unchainedshop/core';
-const logger = createLogger('unchained:temp-upload');
-export async function tempUploadHandler(request, context) {
-    try {
-        const hasPermission = await context.roles?.userHasPermission(context, 'uploadTempFile', []);
-        if (!hasPermission) {
-            return Response.json({ error: 'Permission denied', message: 'User does not have uploadTempFile permission' }, { status: 403 });
-        }
-        const formData = await request.formData();
-        let file = formData.get('file');
-        if (!file || !(file instanceof File)) {
-            for (const [, value] of formData.entries()) {
-                if (value instanceof File) {
-                    file = value;
-                    break;
-                }
-            }
-        }
-        if (!file) {
-            return Response.json({ error: 'No file uploaded' }, { status: 400 });
-        }
-        const buffer = Buffer.from(await file.arrayBuffer());
-        const uploadedFile = await context.services.files.uploadFileFromStream({
-            directoryName: 'temp-uploads',
-            rawFile: {
-                filename: file.name,
-                buffer,
-                mimetype: file.type,
-            },
-            meta: { encoding: 'binary' },
-        });
-        const expires = new Date(Date.now() + 24 * 60 * 60 * 1000);
-        await context.modules.files.update(uploadedFile._id, {
-            expires,
-        });
-        const fileUploadAdapter = getFileAdapter();
-        const rawUrl = await fileUploadAdapter.createDownloadURL(uploadedFile);
-        if (!rawUrl)
-            throw new Error('Could not create download URL for file');
-        const url = context.modules.files.normalizeUrl(rawUrl, {});
-        return Response.json({ fileId: uploadedFile._id, url, expires: expires.toISOString() }, { status: 200 });
-    }
-    catch (e) {
-        logger.error(e);
-        return Response.json({ name: e.name, code: e.code, message: e.message }, { status: 503 });
-    }
-}

package/lib/files/temp-upload/index.d.ts

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

package/lib/files/temp-upload/index.js

@@ -1,15 +0,0 @@
-import { tempUploadHandler } from "./api.js";
-const { TEMP_UPLOAD_API_PATH = '/temp-upload' } = process.env;
-export const TempUploadPlugin = {
-    key: 'shop.unchained.files.temp-upload',
-    label: 'Temp Upload Plugin',
-    version: '1.0.0',
-    routes: [
-        {
-            path: TEMP_UPLOAD_API_PATH,
-            method: 'POST',
-            handler: tempUploadHandler,
-        },
-    ],
-};
-export default TempUploadPlugin;

package/lib/filters/local-search/adapter.d.ts

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

package/lib/filters/local-search/adapter.js

@@ -1,56 +0,0 @@
-import { FilterAdapter } from '@unchainedshop/core';
-export const LocalSearch = {
-    ...FilterAdapter,
-    key: 'shop.unchained.filters.local-search',
-    label: 'Simple Fulltext search with MongoDB',
-    version: '1.0.0',
-    orderIndex: 10,
-    actions: (params) => {
-        return {
-            ...FilterAdapter.actions(params),
-            searchProducts: async ({ productIds }) => {
-                const { queryString } = params.searchQuery;
-                if (!queryString)
-                    return productIds;
-                const products = await params.modules.products.texts.findTexts({
-                    queryString,
-                    productIds: productIds ? [...new Set(productIds)] : undefined,
-                }, {
-                    projection: {
-                        productId: 1,
-                    },
-                });
-                return products.map(({ productId }) => productId);
-            },
-            searchAssortments: async ({ assortmentIds }) => {
-                const { queryString } = params.searchQuery;
-                if (!queryString) {
-                    return assortmentIds;
-                }
-                const assortments = await params.modules.assortments.texts.findTexts({
-                    queryString,
-                    assortmentIds,
-                }, {
-                    projection: {
-                        assortmentId: 1,
-                    },
-                });
-                return assortments.map(({ assortmentId }) => assortmentId);
-            },
-            async transformFilterSelector(last) {
-                const { queryString, filterIds, includeInactive } = params.searchQuery;
-                if (queryString && !filterIds) {
-                    const selector = { ...last };
-                    if (selector?.key) {
-                        delete selector.key;
-                    }
-                    if (!includeInactive) {
-                        selector.isActive = true;
-                    }
-                    return selector;
-                }
-                return last;
-            },
-        };
-    },
-};

package/lib/filters/local-search/index.d.ts

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

package/lib/filters/local-search/index.js

@@ -1,10 +0,0 @@
-import {} from '@unchainedshop/core';
-import { LocalSearch } from "./adapter.js";
-export const LocalSearchPlugin = {
-    key: 'shop.unchained.filters.local-search',
-    label: 'Local Search Filter Plugin',
-    version: '1.0.0',
-    adapters: [LocalSearch],
-};
-export default LocalSearchPlugin;
-export { LocalSearch } from "./adapter.js";

package/lib/filters/strict-equal/adapter.d.ts

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

package/lib/filters/strict-equal/adapter.js

@@ -1,23 +0,0 @@
-import { FilterAdapter } from '@unchainedshop/core';
-export const StrictQualFilter = {
-    ...FilterAdapter,
-    key: 'shop.unchained.filters.strict-qual',
-    label: 'Simple Strict Equal DB Filter',
-    version: '1.0.0',
-    orderIndex: 0,
-    actions: (params) => {
-        return {
-            ...FilterAdapter.actions(params),
-            transformProductSelector: async (lastSelector, options) => {
-                const { key, value } = options || {};
-                if (key) {
-                    return {
-                        ...lastSelector,
-                        [key]: value !== undefined ? value : { $exists: true },
-                    };
-                }
-                return lastSelector;
-            },
-        };
-    },
-};

package/lib/filters/strict-equal/index.d.ts

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

package/lib/filters/strict-equal/index.js

@@ -1,10 +0,0 @@
-import {} from '@unchainedshop/core';
-import { StrictQualFilter } from "./adapter.js";
-export const StrictQualFilterPlugin = {
-    key: 'shop.unchained.filters.strict-qual',
-    label: 'Strict Equal Filter Plugin',
-    version: '1.0.0',
-    adapters: [StrictQualFilter],
-};
-export default StrictQualFilterPlugin;
-export { StrictQualFilter } from "./adapter.js";

package/lib/payment/apple-iap/api.d.ts

@@ -1,2 +0,0 @@
-import type { UnchainedCore } from '@unchainedshop/core';
-export declare function appleIAPWebhookHandler(request: Request, context: UnchainedCore): Promise<Response>;