@unchainedshop/plugins 4.6.0 → 4.6.2

package/lib/delivery/post/adapter.d.ts

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

package/lib/delivery/post/adapter.js

@@ -0,0 +1,22 @@
+import { DeliveryAdapter } from '@unchainedshop/core';
+import { DeliveryProviderType } from '@unchainedshop/core-delivery';
+export const Post = {
+    ...DeliveryAdapter,
+    key: 'shop.unchained.post',
+    label: 'Manual',
+    version: '1.0.0',
+    typeSupported: (type) => {
+        return type === DeliveryProviderType.SHIPPING;
+    },
+    actions: (config, context) => {
+        return {
+            ...DeliveryAdapter.actions(config, context),
+            isActive: () => {
+                return true;
+            },
+            configurationError: () => {
+                return null;
+            },
+        };
+    },
+};

package/lib/delivery/post/index.d.ts

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

package/lib/delivery/post/index.js

@@ -0,0 +1,10 @@
+import {} from '@unchainedshop/core';
+import { Post } from "./adapter.js";
+export const PostPlugin = {
+    key: 'shop.unchained.post',
+    label: 'Post Delivery Plugin',
+    version: '1.0.0',
+    adapters: [Post],
+};
+export default PostPlugin;
+export { Post } from "./adapter.js";

package/lib/delivery/send-message/adapter.d.ts

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

package/lib/delivery/send-message/adapter.js

@@ -0,0 +1,39 @@
+import { DeliveryAdapter } from '@unchainedshop/core';
+import { DeliveryProviderType } from '@unchainedshop/core-delivery';
+export const SendMessage = {
+    ...DeliveryAdapter,
+    key: 'shop.unchained.delivery.send-message',
+    label: 'Forward via Messaging',
+    version: '1.0.0',
+    initialConfiguration: [
+        { key: 'from', value: '' },
+        { key: 'to', value: '' },
+        { key: 'cc', value: '' },
+    ],
+    typeSupported: (type) => {
+        return type === DeliveryProviderType.SHIPPING;
+    },
+    actions: (config, context) => {
+        return {
+            ...DeliveryAdapter.actions(config, context),
+            isActive: () => {
+                return true;
+            },
+            configurationError: () => {
+                return null;
+            },
+            send: async () => {
+                const { modules, order } = context;
+                return modules.worker.addWork({
+                    type: 'MESSAGE',
+                    retries: 0,
+                    input: {
+                        template: 'DELIVERY',
+                        orderId: order._id,
+                        config,
+                    },
+                });
+            },
+        };
+    },
+};

package/lib/delivery/send-message/index.d.ts

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

package/lib/delivery/send-message/index.js

@@ -0,0 +1,10 @@
+import {} from '@unchainedshop/core';
+import { SendMessage } from "./adapter.js";
+export const SendMessagePlugin = {
+    key: 'shop.unchained.delivery.send-message',
+    label: 'Send Message Delivery Plugin',
+    version: '1.0.0',
+    adapters: [SendMessage],
+};
+export default SendMessagePlugin;
+export { SendMessage } from "./adapter.js";

package/lib/delivery/stores/adapter.d.ts

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

package/lib/delivery/stores/adapter.js

@@ -0,0 +1,42 @@
+import { DeliveryAdapter } from '@unchainedshop/core';
+import { DeliveryProviderType } from '@unchainedshop/core-delivery';
+export const PickMup = {
+    ...DeliveryAdapter,
+    key: 'shop.unchained.stores',
+    label: 'Pre-configured Stores',
+    version: '1.0.0',
+    typeSupported: (type) => {
+        return type === DeliveryProviderType.PICKUP;
+    },
+    actions: (config, context) => {
+        const getStores = () => {
+            const storesItem = config.find((item) => item.key === 'stores');
+            if (!storesItem)
+                return [];
+            try {
+                return typeof storesItem.value === 'string' ? JSON.parse(storesItem.value) : storesItem.value;
+            }
+            catch {
+                return storesItem?.value ?? [];
+            }
+        };
+        return {
+            ...DeliveryAdapter.actions(config, context),
+            isActive() {
+                return true;
+            },
+            isAutoReleaseAllowed() {
+                return false;
+            },
+            configurationError() {
+                return null;
+            },
+            pickUpLocationById: async (id) => {
+                return getStores().find((store) => store._id === id);
+            },
+            pickUpLocations: async () => {
+                return getStores();
+            },
+        };
+    },
+};

package/lib/delivery/stores/index.d.ts

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

package/lib/delivery/stores/index.js

@@ -0,0 +1,10 @@
+import {} from '@unchainedshop/core';
+import { PickMup } from "./adapter.js";
+export const PickMupPlugin = {
+    key: 'shop.unchained.stores',
+    label: 'Pick-up Stores Delivery Plugin',
+    version: '1.0.0',
+    adapters: [PickMup],
+};
+export default PickMupPlugin;
+export { PickMup } from "./adapter.js";

package/lib/enrollments/licensed/adapter.d.ts

@@ -0,0 +1,6 @@
+import { type IEnrollmentAdapter } from '@unchainedshop/core';
+export declare const rangeMatcher: (date?: Date) => ({ start, end }: {
+    start: any;
+    end: any;
+}) => boolean;
+export declare const LicensedEnrollments: IEnrollmentAdapter;

package/lib/enrollments/licensed/adapter.js

@@ -0,0 +1,51 @@
+import { EnrollmentAdapter } from '@unchainedshop/core';
+export const rangeMatcher = (date = new Date()) => {
+    const timestamp = date.getTime();
+    return ({ start, end }) => {
+        const startTimestamp = new Date(start).getTime();
+        const endTimestamp = new Date(end).getTime();
+        return startTimestamp <= timestamp && endTimestamp >= timestamp;
+    };
+};
+export const LicensedEnrollments = {
+    ...EnrollmentAdapter,
+    key: 'shop.unchained.enrollments.licensed',
+    version: '1.0.0',
+    label: 'Simple Licensed Enrollments',
+    isActivatedFor: (productPlan) => {
+        return productPlan?.usageCalculationType === 'LICENSED';
+    },
+    actions: (params) => {
+        const { enrollment } = params;
+        return {
+            ...EnrollmentAdapter.actions(params),
+            isValidForActivation: async () => {
+                const periods = enrollment?.periods || [];
+                return periods.findIndex(rangeMatcher()) !== -1;
+            },
+            isOverdue: async () => {
+                return false;
+            },
+            configurationForOrder: async (context) => {
+                const { period } = context;
+                const beginningOfPeriod = period.start.getTime() <= new Date().getTime();
+                if (!enrollment)
+                    throw new Error('Enrollment missing in context');
+                if (beginningOfPeriod) {
+                    return {
+                        period,
+                        orderContext: {},
+                        orderPositionTemplates: [
+                            {
+                                quantity: 1,
+                                productId: enrollment.productId,
+                                originalProductId: enrollment.productId,
+                            },
+                        ],
+                    };
+                }
+                return null;
+            },
+        };
+    },
+};

package/lib/enrollments/licensed/index.d.ts

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

package/lib/enrollments/licensed/index.js

@@ -0,0 +1,10 @@
+import {} from '@unchainedshop/core';
+import { LicensedEnrollments } from "./adapter.js";
+export const LicensedEnrollmentsPlugin = {
+    key: 'shop.unchained.enrollments.licensed',
+    label: 'Licensed Enrollments Plugin',
+    version: '1.0.0',
+    adapters: [LicensedEnrollments],
+};
+export default LicensedEnrollmentsPlugin;
+export { LicensedEnrollments, rangeMatcher } from "./adapter.js";

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

@@ -0,0 +1,7 @@
+import { type UnchainedCore } from '@unchainedshop/core';
+import type { GridFSFileUploadsModule } from './module.ts';
+export declare const gridfsRouteHandler: (request: Request, context: UnchainedCore & {
+    params: Record<string, string>;
+    modules: GridFSFileUploadsModule;
+    rawRequest?: any;
+}) => Promise<Response>;

package/lib/files/gridfs/api.js

@@ -0,0 +1,163 @@
+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}/${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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,160 @@
+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

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

package/lib/files/minio/api.js

@@ -0,0 +1,41 @@
+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 body = await request.json();
+        const { Records = [], EventName } = body;
+        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

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