@unchainedshop/plugins 4.6.1 → 4.7.2

package/README.md

@@ -22,7 +22,6 @@ npm install @unchainedshop/plugins
 | Stripe | `payment/stripe` | Stripe payment integration |
 | Datatrans V2 | `payment/datatrans-v2` | Datatrans payment gateway |
 | Saferpay | `payment/saferpay` | Saferpay payment gateway |
-| PayPal Checkout | `payment/paypal-checkout` | PayPal Checkout integration |
 | Braintree | `payment/braintree` | Braintree payments |
 | Payrexx | `payment/payrexx` | Payrexx payment gateway |
 | Apple IAP | `payment/apple-iap` | Apple In-App Purchase |
@@ -134,7 +133,6 @@ All payment plugins implement secure tokenization patterns for PCI DSS SAQ-A eli
 | Stripe | PaymentIntent/SetupIntent tokenization |
 | Datatrans | Secure Fields with HMAC-SHA-256 signatures |
 | Saferpay | Redirect with SHA-256 transaction signatures |
-| PayPal | Order ID references |
 | Braintree | Client SDK tokenization |
 | Cryptopay | BIP-32 HD wallet address derivation |
 

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.js → post/adapter.js}

@@ -1,6 +1,6 @@
-import { DeliveryAdapter, DeliveryDirector } from '@unchainedshop/core';
+import { DeliveryAdapter } from '@unchainedshop/core';
 import { DeliveryProviderType } from '@unchainedshop/core-delivery';
-const Post = {
+export const Post = {
     ...DeliveryAdapter,
     key: 'shop.unchained.post',
     label: 'Manual',
@@ -20,4 +20,3 @@ const Post = {
         };
     },
 };
-DeliveryDirector.registerAdapter(Post);

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.js → send-message/adapter.js}

@@ -1,6 +1,6 @@
-import { DeliveryAdapter, DeliveryDirector } from '@unchainedshop/core';
+import { DeliveryAdapter } from '@unchainedshop/core';
 import { DeliveryProviderType } from '@unchainedshop/core-delivery';
-const SendMessage = {
+export const SendMessage = {
     ...DeliveryAdapter,
     key: 'shop.unchained.delivery.send-message',
     label: 'Forward via Messaging',
@@ -37,4 +37,3 @@ const SendMessage = {
         };
     },
 };
-DeliveryDirector.registerAdapter(SendMessage);

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.js → stores/adapter.js}

@@ -1,6 +1,6 @@
-import { DeliveryAdapter, DeliveryDirector } from '@unchainedshop/core';
+import { DeliveryAdapter } from '@unchainedshop/core';
 import { DeliveryProviderType } from '@unchainedshop/core-delivery';
-const PickMup = {
+export const PickMup = {
     ...DeliveryAdapter,
     key: 'shop.unchained.stores',
     label: 'Pre-configured Stores',
@@ -40,4 +40,3 @@ const PickMup = {
         };
     },
 };
-DeliveryDirector.registerAdapter(PickMup);

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.js → licensed/adapter.js}

@@ -1,4 +1,4 @@
-import { EnrollmentDirector, EnrollmentAdapter } from '@unchainedshop/core';
+import { EnrollmentAdapter } from '@unchainedshop/core';
 export const rangeMatcher = (date = new Date()) => {
     const timestamp = date.getTime();
     return ({ start, end }) => {
@@ -7,7 +7,7 @@ export const rangeMatcher = (date = new Date()) => {
         return startTimestamp <= timestamp && endTimestamp >= timestamp;
     };
 };
-const LicensedEnrollments = {
+export const LicensedEnrollments = {
     ...EnrollmentAdapter,
     key: 'shop.unchained.enrollments.licensed',
     version: '1.0.0',
@@ -49,4 +49,3 @@ const LicensedEnrollments = {
         };
     },
 };
-EnrollmentDirector.registerAdapter(LicensedEnrollments);

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/events/node-event-emitter.d.ts

@@ -1 +1,3 @@
-export {};
+import { type EmitAdapter } from '@unchainedshop/events';
+export declare const NodeEventEmitter: () => EmitAdapter;
+export default NodeEventEmitter;

package/lib/events/node-event-emitter.js

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'node:events';
-import { setEmitAdapter } from '@unchainedshop/events';
-const NodeEventEmitter = () => {
+import {} from '@unchainedshop/events';
+export const NodeEventEmitter = () => {
     const eventEmitter = new EventEmitter();
     return {
         publish: (eventName, payload) => {
@@ -11,4 +11,4 @@ const NodeEventEmitter = () => {
         },
     };
 };
-setEmitAdapter(NodeEventEmitter());
+export default NodeEventEmitter;

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

@@ -1,6 +1,6 @@
-import { type IFileAdapter } from '@unchainedshop/file-upload';
+import { type IFileAdapter } from '@unchainedshop/core-files';
 import { type UnchainedCore } from '@unchainedshop/core';
-import { type GridFSFileUploadsModule } from './index.ts';
+import { type GridFSFileUploadsModule } from './module.ts';
 export declare const GridFSAdapter: IFileAdapter<UnchainedCore & {
     modules: GridFSFileUploadsModule;
 }>;

package/lib/files/gridfs/adapter.js

@@ -1,12 +1,10 @@
 import { Readable, PassThrough } from 'node:stream';
 import { finished, pipeline } from 'node:stream/promises';
 import mime from 'mime/lite';
-import { FileAdapter, FileDirector, buildHashedFilename, resolveExpirationDate, } from '@unchainedshop/file-upload';
-import {} from '@unchainedshop/file-upload';
+import { FileAdapter, buildHashedFilename, resolveExpirationDate, filesSettings, } from '@unchainedshop/core-files';
 import sign from "./sign.js";
-import { filesSettings } from '@unchainedshop/core-files';
 import {} from '@unchainedshop/core';
-import {} from "./index.js";
+import {} from "./module.js";
 const { GRIDFS_PUT_SERVER_PATH = '/gridfs' } = process.env;
 const bufferToStream = (buffer) => {
     const stream = new Readable();
@@ -113,4 +111,3 @@ export const GridFSAdapter = {
         await Promise.all(files.map(async ({ _id, path }) => modules.gridfsFileUploads.removeFileFromBucket(path, _id)));
     },
 };
-FileDirector.registerAdapter(GridFSAdapter);

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

@@ -1,4 +1,5 @@
-import './adapter.ts';
-import gridfsModules, { type GridFSFileUploadsModule } from './module.ts';
-export type { GridFSFileUploadsModule };
-export default gridfsModules;
+import type { IPlugin } from '@unchainedshop/core';
+export declare const GridFSPlugin: IPlugin;
+export default GridFSPlugin;
+export { GridFSAdapter } from './adapter.ts';
+export { type GridFSFileUploadsModule } from './module.ts';

package/lib/files/gridfs/index.js

@@ -1,3 +1,30 @@
-import "./adapter.js";
-import gridfsModules, {} from "./module.js";
-export default gridfsModules;
+import { createLogger } from '@unchainedshop/logger';
+import { GridFSAdapter } from "./adapter.js";
+import { configureGridFSFileUploadModule } from "./module.js";
+import { gridfsRouteHandler } from "./api.js";
+const { GRIDFS_PUT_SERVER_PATH = '/gridfs', UNCHAINED_GRIDFS_PUT_UPLOAD_SECRET } = process.env;
+const logger = createLogger('unchained:gridfs');
+export const GridFSPlugin = {
+    key: 'shop.unchained.file-upload-plugin.gridfs',
+    label: 'GridFS File Upload Plugin',
+    version: '1.0.0',
+    adapters: [GridFSAdapter],
+    module: ({ db }) => ({
+        gridfsFileUploads: configureGridFSFileUploadModule({ db }),
+    }),
+    routes: [
+        {
+            path: `${GRIDFS_PUT_SERVER_PATH}/:directoryName/:fileName`,
+            method: 'ALL',
+            handler: gridfsRouteHandler,
+        },
+    ],
+    onRegister: () => {
+        if (!UNCHAINED_GRIDFS_PUT_UPLOAD_SECRET) {
+            logger.warn('UNCHAINED_GRIDFS_PUT_UPLOAD_SECRET not set - PUT uploads and signed downloads will fail');
+        }
+    },
+};
+export default GridFSPlugin;
+export { GridFSAdapter } from "./adapter.js";
+export {} from "./module.js";

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' },
+        });
+    }
+}