@unchainedshop/plugins 4.7.2 → 4.8.0

package/README.md

@@ -22,6 +22,7 @@ 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 |
@@ -133,6 +134,7 @@ 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.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/delivery/post.js

@@ -0,0 +1,23 @@
+import { DeliveryAdapter, DeliveryDirector } from '@unchainedshop/core';
+import { DeliveryProviderType } from '@unchainedshop/core-delivery';
+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;
+            },
+        };
+    },
+};
+DeliveryDirector.registerAdapter(Post);

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

@@ -0,0 +1 @@
+export {};

package/lib/delivery/send-message.js

@@ -0,0 +1,40 @@
+import { DeliveryAdapter, DeliveryDirector } from '@unchainedshop/core';
+import { DeliveryProviderType } from '@unchainedshop/core-delivery';
+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,
+                    },
+                });
+            },
+        };
+    },
+};
+DeliveryDirector.registerAdapter(SendMessage);

package/lib/delivery/stores.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/delivery/stores.js

@@ -0,0 +1,43 @@
+import { DeliveryAdapter, DeliveryDirector } from '@unchainedshop/core';
+import { DeliveryProviderType } from '@unchainedshop/core-delivery';
+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();
+            },
+        };
+    },
+};
+DeliveryDirector.registerAdapter(PickMup);

package/lib/enrollments/licensed.d.ts

@@ -0,0 +1,4 @@
+export declare const rangeMatcher: (date?: Date) => ({ start, end }: {
+    start: any;
+    end: any;
+}) => boolean;

package/lib/enrollments/licensed.js

@@ -0,0 +1,52 @@
+import { EnrollmentDirector, 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;
+    };
+};
+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;
+            },
+        };
+    },
+};
+EnrollmentDirector.registerAdapter(LicensedEnrollments);

package/lib/events/node-event-emitter.d.ts

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

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

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

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

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

package/lib/files/gridfs/adapter.js

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

package/lib/files/gridfs/handler-express.d.ts

@@ -0,0 +1,9 @@
+import express from 'express';
+import { type GridFSFileUploadsModule } from './module.ts';
+import { type Context } from '@unchainedshop/api';
+declare const gridfsHandler: (req: express.Request & {
+    unchainedContext: Context & {
+        modules: GridFSFileUploadsModule;
+    };
+}, res: express.Response) => Promise<void>;
+export default gridfsHandler;

package/lib/files/gridfs/handler-express.js

@@ -0,0 +1,110 @@
+import { pipeline, finished } from 'node:stream/promises';
+import { PassThrough } from 'node:stream';
+import { buildHashedFilename } from '@unchainedshop/file-upload';
+import express from 'express';
+import sign from "./sign.js";
+import {} from "./module.js";
+import {} from '@unchainedshop/api';
+import { createLogger } from '@unchainedshop/logger';
+import { getFileAdapter } from '@unchainedshop/core-files';
+import { timingSafeStringEqual } from '@unchainedshop/utils';
+const { ROOT_URL, GRIDFS_PUT_SERVER_PATH = '/gridfs' } = process.env;
+const logger = createLogger('unchained:gridfs');
+const gridfsHandler = async (req, res) => {
+    try {
+        const { services, modules } = req.unchainedContext;
+        const url = new URL(req.url, ROOT_URL);
+        const [, directoryNameRaw, fileNameRaw] = url.pathname.split('/');
+        const directoryName = decodeURIComponent(directoryNameRaw);
+        const fileName = decodeURIComponent(fileNameRaw);
+        res.setHeader('Access-Control-Allow-Methods', 'GET, PUT');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        if (req.method === 'OPTIONS') {
+            res.status(200).end();
+            return;
+        }
+        if (req.method === 'PUT') {
+            const { s: signature, e: expiryTimestamp } = req.query;
+            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)) {
+                const file = await modules.files.findFile({ fileId });
+                if (!file) {
+                    res.status(404).send('File not found');
+                    return;
+                }
+                if (file.expires === null) {
+                    res.status(400).send('File already linked');
+                    return;
+                }
+                const type = req.header('Content-Type') === 'application/octet-stream'
+                    ? file.type || req.header('Content-Type')
+                    : req.header('Content-Type') || file.type;
+                const writeStream = await modules.gridfsFileUploads.createWriteStream(directoryName, fileId, fileName, {
+                    chunkSizeBytes: 1024 * 1024,
+                    metadata: { 'content-type': type },
+                });
+                await pipeline(req, new PassThrough({ highWaterMark: 1024 * 1024 * 4 }), writeStream);
+                await finished(writeStream, { readable: false });
+                const { length } = writeStream;
+                await services.files.linkFile({ fileId, size: length, type });
+                res.status(200).end();
+                return;
+            }
+            res.status(403).end();
+            return;
+        }
+        if (req.method === 'GET') {
+            const { s: signature, e: expiryTimestamp } = req.query;
+            const fileDocument = await modules.files.findFile({
+                url: `${GRIDFS_PUT_SERVER_PATH}/${directoryName}/${fileName}`,
+            });
+            if (fileDocument?.meta?.isPrivate) {
+                const expiry = parseInt(expiryTimestamp, 10);
+                if (expiry <= Date.now()) {
+                    res.status(403).send('Access restricted: Expired.');
+                    return;
+                }
+                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))) {
+                    res.status(403).send('Access restricted: Invalid signature.');
+                    return;
+                }
+            }
+            else if (!fileDocument) {
+                res.status(404).end();
+                return;
+            }
+            const file = await modules.gridfsFileUploads.getFileInfo(directoryName, fileDocument._id);
+            if (file?.metadata?.['content-type']) {
+                res.setHeader('Content-Type', file.metadata['content-type']);
+            }
+            if (file?.length) {
+                res.setHeader('Content-Length', file?.length.toString());
+            }
+            const readStream = await modules.gridfsFileUploads.createReadStream(directoryName, fileDocument._id);
+            readStream.pipe(res, { end: false });
+            await finished(readStream);
+            res.status(200).end();
+            return;
+        }
+        res.status(404).end();
+    }
+    catch (e) {
+        if (e.code === 'ENOENT') {
+            logger.warn(e);
+            res.status(404).send();
+        }
+        else {
+            logger.warn(e);
+            res.status(503).send({ name: e.name, code: e.code, message: e.message });
+        }
+    }
+};
+export default gridfsHandler;

package/lib/files/gridfs/handler-fastify.d.ts

@@ -0,0 +1,3 @@
+import { type RouteHandlerMethod } from 'fastify';
+declare const gridfsHandler: RouteHandlerMethod;
+export default gridfsHandler;

package/lib/files/gridfs/handler-fastify.js

@@ -0,0 +1,138 @@
+import { finished, pipeline } from 'node:stream/promises';
+import { PassThrough } from 'node:stream';
+import {} from 'fastify';
+import { buildHashedFilename } from '@unchainedshop/file-upload';
+import sign from "./sign.js";
+import {} from "./module.js";
+import {} from '@unchainedshop/api';
+import { createLogger } from '@unchainedshop/logger';
+import { getFileAdapter } from '@unchainedshop/core-files';
+import { timingSafeStringEqual } from '@unchainedshop/utils';
+const logger = createLogger('unchained:gridfs');
+const { GRIDFS_PUT_SERVER_PATH = '/gridfs' } = process.env;
+const gridfsHandler = async (req, reply) => {
+    try {
+        const { services, modules } = req.unchainedContext;
+        const { directoryName, fileName } = req.params;
+        reply.header('Access-Control-Allow-Methods', 'GET, PUT');
+        reply.header('Access-Control-Allow-Headers', 'content-type');
+        reply.header('Access-Control-Allow-Origin', '*');
+        if (req.method === 'OPTIONS') {
+            reply.status(200);
+            return reply.send();
+        }
+        if (req.method === 'PUT') {
+            const { s: signature, e: expiryTimestamp } = req.query;
+            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)) {
+                const file = await modules.files.findFile({ fileId });
+                if (!file) {
+                    reply.status(404);
+                    logger.error('File not found', { fileId });
+                    return reply.send({
+                        success: false,
+                        message: 'File not found',
+                        name: 'FILE_NOT_FOUND',
+                    });
+                }
+                if (file.expires === null) {
+                    reply.status(400);
+                    logger.error('File already linked', { fileId });
+                    return reply.send({
+                        success: false,
+                        message: 'File already linked',
+                        name: 'FILE_ALREADY_LINKED',
+                    });
+                }
+                const type = req.headers['content-type'] === 'application/octet-stream'
+                    ? file.type || req.headers['content-type']
+                    : req.headers['content-type'] || file.type;
+                const writeStream = await modules.gridfsFileUploads.createWriteStream(directoryName, fileId, fileName, {
+                    chunkSizeBytes: 1024 * 1024,
+                    metadata: { 'content-type': type },
+                });
+                await pipeline(req.raw, new PassThrough({ highWaterMark: 1024 * 1024 * 4 }), writeStream);
+                await finished(writeStream, { readable: false });
+                const { length } = writeStream;
+                await services.files.linkFile({ fileId, size: length, type });
+                reply.status(200);
+                return reply.send({
+                    success: true,
+                    fileId,
+                    size: length,
+                    type,
+                });
+            }
+            logger.error('Invalid signature', { fileId, expiryDate });
+            reply.status(403);
+            return reply.send({
+                success: false,
+                message: 'Access restricted: Invalid signature.',
+                name: 'INVALID_SIGNATURE',
+            });
+        }
+        if (req.method === 'GET') {
+            const { s: signature, e: expiryTimestamp } = req.query;
+            const fileDocument = await modules.files.findFile({
+                url: `${GRIDFS_PUT_SERVER_PATH}/${directoryName}/${fileName}`,
+            });
+            if (fileDocument?.meta?.isPrivate) {
+                const expiry = parseInt(expiryTimestamp, 10);
+                if (expiry <= Date.now()) {
+                    logger.error('URL Expired', { fileName, expiry });
+                    reply.status(403);
+                    return reply.send({
+                        success: false,
+                        message: 'Access restricted: URL expired.',
+                        name: 'URL_EXPIRED',
+                    });
+                }
+                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))) {
+                    reply.status(403);
+                    logger.error('Invalid signature', { fileName, expiry });
+                    return reply.send({
+                        success: false,
+                        message: 'Access restricted: Invalid signature.',
+                        name: 'INVALID_SIGNATURE',
+                    });
+                }
+            }
+            else if (!fileDocument) {
+                logger.error('File not found', { fileName });
+                reply.status(404);
+                return reply.send();
+            }
+            const file = await modules.gridfsFileUploads.getFileInfo(directoryName, fileDocument._id);
+            if (file?.metadata?.['content-type']) {
+                reply.header('content-type', file.metadata['content-type']);
+            }
+            if (file?.length) {
+                reply.header('content-length', file?.length.toString());
+            }
+            const readStream = await modules.gridfsFileUploads.createReadStream(directoryName, fileDocument._id);
+            reply.status(200);
+            return reply.send(readStream);
+        }
+        reply.status(404);
+        return reply.send();
+    }
+    catch (e) {
+        logger.error(e);
+        if (e.code === 'ENOENT') {
+            reply.status(404);
+            return reply.send();
+        }
+        else {
+            reply.status(504);
+            return reply.send({ success: false, name: e.name, code: e.code, message: e.message });
+        }
+    }
+};
+export default gridfsHandler;

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

@@ -1,5 +1,4 @@
-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';
+import './adapter.ts';
+import gridfsModules, { type GridFSFileUploadsModule } from './module.ts';
+export type { GridFSFileUploadsModule };
+export default gridfsModules;

package/lib/files/gridfs/index.js

@@ -1,30 +1,3 @@
-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";
+import "./adapter.js";
+import gridfsModules, {} from "./module.js";
+export default gridfsModules;

package/lib/files/minio/handler-express.d.ts

@@ -0,0 +1,2 @@
+declare const minioHandler: (req: any, res: any) => Promise<void>;
+export default minioHandler;

package/lib/files/minio/handler-express.js

@@ -0,0 +1,36 @@
+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);
+};
+const minioHandler = async (req, res) => {
+    try {
+        if (req.method === 'POST' && req.body) {
+            const { headers } = req;
+            const { Records = [], EventName } = req.body;
+            if (EventName === 's3:ObjectCreated:Put' && (await isAuthorized(headers))) {
+                const [{ s3 }] = Records;
+                const { object } = s3;
+                const { size, contentType: type } = object;
+                const [fileId] = object.key.split('.');
+                const { services } = req.unchainedContext;
+                await services.files.linkFile({ fileId, type, size });
+                res.status(200).end();
+                return;
+            }
+        }
+        res.status(404).end();
+    }
+    catch (e) {
+        logger.error(e);
+        res.status(503).send({ name: e.name, code: e.code, message: e.message });
+    }
+};
+export default minioHandler;

package/lib/files/minio/handler-fastify.d.ts

@@ -0,0 +1,3 @@
+import { type RouteHandlerMethod } from 'fastify';
+declare const minioHandler: RouteHandlerMethod;
+export default minioHandler;

package/lib/files/minio/handler-fastify.js

@@ -0,0 +1,40 @@
+import {} from '@unchainedshop/api';
+import { createLogger } from '@unchainedshop/logger';
+import {} from 'fastify';
+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);
+};
+const minioHandler = async (req, res) => {
+    try {
+        if (req.body) {
+            const { headers } = req;
+            const { Records = [], EventName } = req.body;
+            if (EventName === 's3:ObjectCreated:Put' && (await isAuthorized(headers))) {
+                const [{ s3 }] = Records;
+                const { object } = s3;
+                const { size, contentType: type } = object;
+                const [fileId] = object.key.split('.');
+                const { services } = req.unchainedContext;
+                await services.files.linkFile({ fileId, type, size });
+                res.status(200);
+                return res.send();
+            }
+        }
+        res.status(404);
+        return res.send();
+    }
+    catch (e) {
+        logger.error(e);
+        res.status(503);
+        return res.send({ name: e.name, code: e.code, message: e.message });
+    }
+};
+export default minioHandler;

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

@@ -1,4 +1,5 @@
-import type { IPlugin } from '@unchainedshop/core';
-export declare const MinioPlugin: IPlugin;
-export default MinioPlugin;
-export { MinioAdapter, connectToMinio } from './adapter.ts';
+import { type IFileAdapter } from '@unchainedshop/file-upload';
+import { Client } from 'minio';
+export declare function connectToMinio(): Promise<Client | null>;
+export declare const MinioAdapter: IFileAdapter;
+export default MinioAdapter;