@unchainedshop/plugins 4.3.5 → 4.4.0

package/src/files/minio/index.ts

@@ -1,232 +0,0 @@
-import { Readable } from 'node:stream';
-import type { ReadableStream } from 'node:stream/web';
-import { UploadFileData } from '@unchainedshop/file-upload';
-import {
-  FileAdapter,
-  FileDirector,
-  buildHashedFilename,
-  resolveExpirationDate,
-  IFileAdapter,
-} from '@unchainedshop/file-upload';
-import mime from 'mime/lite';
-import { Client } from 'minio';
-import { AssumeRoleProvider } from 'minio/dist/esm/AssumeRoleProvider.mjs';
-import { expiryOffsetInMs } from '@unchainedshop/file-upload/lib/put-expiration.js';
-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: Client | null = 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,
-    });
-
-    // eslint-disable-next-line
-    // @ts-ignore
-    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!,
-      });
-      // eslint-disable-next-line
-      // @ts-ignore
-      await minioClient.setCredentialsProvider(ap);
-    }
-    return minioClient;
-  } catch (error) {
-    logger.error(`Exception while creating Minio client: ${error.message}`);
-  }
-  return null;
-}
-
-const generateMinioPath = (directoryName: string, fileName: string) => {
-  const prefix = MINIO_UPLOAD_PREFIX || '';
-  return [prefix, directoryName, fileName].filter(Boolean).join('/');
-};
-
-const generateMinioUrl = (directoryName: string, hashedFilename: string) => {
-  return `${MINIO_ENDPOINT}/${MINIO_BUCKET_NAME!}/${generateMinioPath(directoryName, hashedFilename)}`;
-};
-
-connectToMinio().then(function setClient(c) {
-  client = c || client;
-});
-
-const getObjectStats = async (fileName: string) => {
-  if (!client) throw new Error('Minio not connected, check env variables');
-
-  return client.statObject(MINIO_BUCKET_NAME!, fileName);
-};
-
-const bufferToStream = (buffer: any) => {
-  const stream = new Readable();
-  stream.push(buffer);
-  stream.push(null);
-
-  return stream;
-};
-
-export const MinioAdapter: IFileAdapter = {
-  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),
-    } as UploadFileData & { putURL: string };
-  },
-
-  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: string, rawFile: any) {
-    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),
-    } as UploadFileData;
-  },
-
-  async uploadFileFromURL(directoryName: string, { fileLink, fileName: fname, fileId, headers }: any) {
-    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 as ReadableStream<Uint8Array<ArrayBufferLike>>);
-    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),
-    } as UploadFileData;
-  },
-
-  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;
-  },
-};
-
-FileDirector.registerAdapter(MinioAdapter);
-
-export default MinioAdapter;

package/src/filters/local-search.ts

@@ -1,101 +0,0 @@
-import { mongodb } from '@unchainedshop/mongodb';
-import { ProductText } from '@unchainedshop/core-products';
-import { AssortmentText } from '@unchainedshop/core-assortments';
-import { FilterDirector, FilterAdapter, IFilterAdapter } from '@unchainedshop/core';
-import { createLogger } from '@unchainedshop/logger';
-import { isDocumentDBCompatModeEnabled } from '@unchainedshop/mongodb';
-
-const logger = createLogger('unchained:local-search');
-
-const LocalSearch: IFilterAdapter = {
-  ...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 }) => {
-        // Search Products
-        const { queryString } = params.searchQuery;
-
-        if (!queryString) return productIds;
-
-        const selector: mongodb.Filter<ProductText> = {
-          $text: { $search: queryString },
-        };
-
-        if (productIds) {
-          selector.productId = { $in: [...new Set(productIds)] as any };
-        }
-
-        const products = await params.modules.products.texts.findTexts(selector, {
-          projection: {
-            productId: 1,
-          },
-        });
-
-        return products.map(({ productId }) => productId);
-      },
-
-      searchAssortments: async ({ assortmentIds }) => {
-        const { queryString } = params.searchQuery;
-
-        if (!queryString) {
-          return assortmentIds;
-        }
-
-        const selector: mongodb.Filter<AssortmentText> = {
-          $text: { $search: queryString },
-        };
-
-        if (assortmentIds) {
-          selector.assortmentId = { $in: assortmentIds };
-        }
-
-        const assortments = await params.modules.assortments.texts.findTexts(selector, {
-          projection: {
-            assortmentId: 1,
-          },
-        });
-
-        return assortments.map(({ assortmentId }) => assortmentId);
-      },
-
-      async transformFilterSelector(last) {
-        const { queryString, filterIds, includeInactive } = params.searchQuery;
-
-        if (queryString && !filterIds) {
-          // Global search without assortment scope:
-          // Return all filters
-          const selector = { ...last };
-          if (selector?.key) {
-            // Do not restrict to keys
-            delete selector.key;
-          }
-          if (!includeInactive) {
-            // Include only active filters
-            selector.isActive = true;
-          }
-          return selector;
-        }
-
-        return last;
-      },
-    };
-  },
-};
-
-export default LocalSearch;
-
-if (!isDocumentDBCompatModeEnabled()) {
-  FilterDirector.registerAdapter(LocalSearch);
-} else {
-  logger.warn(
-    'Free text search queries have been disabled due to DocumentDB compatibility mode (env UNCHAINED_DOCUMENTDB_COMPAT_MODE is trueish)',
-  );
-}

package/src/filters/strict-equal.ts

@@ -1,30 +0,0 @@
-import { IFilterAdapter, FilterDirector, FilterAdapter } from '@unchainedshop/core';
-
-const StrictQualFilter: IFilterAdapter = {
-  ...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;
-      },
-    };
-  },
-};
-
-FilterDirector.registerAdapter(StrictQualFilter);

package/src/payment/apple-iap/adapter.ts

@@ -1,153 +0,0 @@
-import { IPaymentAdapter, PaymentAdapter, PaymentDirector, PaymentError } from '@unchainedshop/core';
-import { createLogger } from '@unchainedshop/logger';
-import { AppleTransactionsModule } from './module.js';
-import { verifyReceipt } from './verify-receipt.js';
-
-const logger = createLogger('unchained:apple-iap');
-
-const { APPLE_IAP_SHARED_SECRET } = process.env;
-
-const AppleIAP: IPaymentAdapter = {
-  ...PaymentAdapter,
-
-  key: 'shop.unchained.apple-iap',
-  label: 'Apple In-App-Purchase',
-  version: '1.0.0',
-  initialConfiguration: [],
-
-  typeSupported: (type) => {
-    return type === 'GENERIC';
-  },
-
-  actions: (params, context) => {
-    const { order, modules } = context as typeof context & { modules: AppleTransactionsModule };
-
-    const adapterActions = {
-      ...PaymentAdapter.actions(params, context),
-
-      configurationError() {
-        if (!APPLE_IAP_SHARED_SECRET) {
-          return PaymentError.INCOMPLETE_CONFIGURATION;
-        }
-        return null;
-      },
-
-      isActive() {
-        if (adapterActions.configurationError() === null) return true;
-        return false;
-      },
-
-      isPayLaterAllowed() {
-        return false;
-      },
-
-      async sign() {
-        throw new Error('Payment signing not supported');
-      },
-
-      async validate() {
-        // once registered receipt transactions are valid by default!
-        return true;
-      },
-
-      async register(transactionContext) {
-        const { receiptData } = transactionContext;
-
-        const response = await verifyReceipt({
-          receiptData,
-          password: APPLE_IAP_SHARED_SECRET,
-        });
-        const { status, latest_receipt_info: latestReceiptInfo } = response;
-
-        if (status === 0) {
-          logger.debug('Receipt validated and updated for the user');
-          const latestTransaction = latestReceiptInfo[latestReceiptInfo.length - 1];
-          return {
-            token: latestTransaction.web_order_line_item_id,
-            latestReceiptInfo,
-          };
-        }
-
-        logger.warn('Receipt invalid', {
-          status: response.status,
-        });
-        return null;
-      },
-
-      async charge(transactionContext) {
-        const { meta, paymentCredentials, receiptData } = transactionContext || {};
-        const { transactionIdentifier } = meta || {};
-
-        if (!transactionIdentifier) {
-          throw new Error('You have to set the transaction id on the order payment');
-        }
-
-        if (!order) throw new Error('Order not found');
-
-        const receiptResponse =
-          receiptData &&
-          (await verifyReceipt({
-            receiptData,
-            password: APPLE_IAP_SHARED_SECRET,
-          }));
-
-        if (receiptResponse && receiptResponse.status !== 0) {
-          throw new Error('Receipt invalid');
-        }
-
-        const transactions =
-          receiptResponse?.latest_receipt_info || paymentCredentials?.meta?.latestReceiptInfo;
-        const matchedTransaction = transactions?.find(
-          (transaction) => transaction?.transaction_id === transactionIdentifier,
-        );
-        if (!matchedTransaction) {
-          throw new Error(`Cannot match transaction with identifier ${transactionIdentifier}`);
-        }
-
-        const orderPositions = await modules.orders.positions.findOrderPositions({
-          orderId: order._id,
-        });
-        const items = Object.entries(
-          orderPositions.reduce((acc, item) => {
-            return {
-              ...acc,
-              [item.productId]: (acc[item.productId] || 0) + item.quantity,
-            };
-          }, {}),
-        );
-
-        if (items.length !== 1) {
-          throw new Error('You can only checkout 1 unique product at once');
-        }
-
-        const [[productId, quantity]] = items;
-
-        const isMatchesTransaction =
-          parseInt(matchedTransaction.quantity, 10) === quantity &&
-          matchedTransaction.product_id === productId;
-
-        if (!isMatchesTransaction) throw new Error('Product in order does not match transaction');
-
-        const alreadyProcessedTransaction =
-          await modules.appleTransactions.findTransactionById(transactionIdentifier);
-
-        if (alreadyProcessedTransaction) throw new Error('Transaction already processed');
-
-        // All good
-        await modules.appleTransactions.createTransaction({
-          _id: transactionIdentifier,
-          matchedTransaction,
-          orderId: order._id,
-        });
-
-        return {
-          transactionIdentifier,
-        };
-      },
-    };
-
-    return adapterActions;
-  },
-};
-
-PaymentDirector.registerAdapter(AppleIAP);

package/src/payment/apple-iap/db/AppleTransactionsCollection.ts

@@ -1,14 +0,0 @@
-import { mongodb } from '@unchainedshop/mongodb';
-import { TimestampFields } from '@unchainedshop/mongodb';
-
-export type AppleTransaction = {
-  _id: string;
-  matchedTransaction: any;
-  orderId: string;
-} & TimestampFields;
-
-export const AppleTransactionsCollection = async (db: mongodb.Db) => {
-  const AppleTransactions = db.collection<AppleTransaction>('payment_apple_iap_processed_transactions');
-
-  return AppleTransactions;
-};

package/src/payment/apple-iap/fix-periods.ts

@@ -1,31 +0,0 @@
-import { UnchainedCore } from '@unchainedshop/core';
-
-export const fixPeriods = async (
-  { transactionId, enrollmentId, orderId, transactions },
-  unchainedAPI: UnchainedCore,
-) => {
-  const relevantTransactions = transactions.filter(({ original_transaction_id }) => {
-    return original_transaction_id === transactionId;
-  });
-
-  const adjustedEnrollmentPeriods = relevantTransactions
-    .map((transaction) => {
-      return {
-        isTrial: transaction.is_trial_period === 'true',
-        start: new Date(parseInt(transaction.purchase_date_ms, 10)),
-        end: new Date(parseInt(transaction.expires_date_ms, 10)),
-        orderId: transaction.transaction_id === transactionId ? orderId : null,
-      };
-    })
-    .toSorted((left, right) => {
-      return left.end.getTime() - right.end.getTime();
-    });
-
-  await unchainedAPI.modules.enrollments.removeEnrollmentPeriodByOrderId(enrollmentId, orderId);
-
-  return Promise.all(
-    adjustedEnrollmentPeriods.map((period) =>
-      unchainedAPI.modules.enrollments.addEnrollmentPeriod(enrollmentId, period),
-    ),
-  );
-};

package/src/payment/apple-iap/handler-express.ts

@@ -1,140 +0,0 @@
-import { Context } from '@unchainedshop/api';
-import { EnrollmentStatus } from '@unchainedshop/core-enrollments';
-import { createLogger } from '@unchainedshop/logger';
-import { fixPeriods } from './fix-periods.js';
-
-const logger = createLogger('unchained:apple-iap:handler');
-
-const { APPLE_IAP_SHARED_SECRET } = process.env;
-
-const AppleNotificationTypes = {
-  INITIAL_BUY: 'INITIAL_BUY',
-  DID_RECOVER: 'DID_RECOVER',
-  DID_CHANGE_RENEWAL_STATUS: 'DID_CHANGE_RENEWAL_STATUS',
-  DID_FAIL_TO_RENEW: 'DID_FAIL_TO_RENEW',
-  DID_CHANGE_RENEWAL_PREF: 'DID_CHANGE_RENEWAL_PREF',
-};
-
-export const appleIAPHandler = async (req, res) => {
-  if (req.method === 'POST') {
-    try {
-      const resolvedContext = req.unchainedContext as Context;
-      const { modules, services } = resolvedContext;
-      const responseBody = req.body || {};
-      if (responseBody.password !== APPLE_IAP_SHARED_SECRET) {
-        throw new Error('shared secret not valid');
-      }
-
-      const transactions = responseBody?.unified_receipt?.latest_receipt_info;
-      const latestTransaction = transactions[0];
-
-      if (responseBody.notification_type === AppleNotificationTypes.INITIAL_BUY) {
-        // Find the cart to checkout
-        const orderPayment = await modules.orders.payments.findOrderPaymentByContextData({
-          context: {
-            'meta.transactionIdentifier': latestTransaction.transaction_id,
-          },
-        });
-
-        if (!orderPayment) throw new Error('Could not find any matching order payment');
-
-        const order = await services.orders.checkoutOrder(orderPayment.orderId, {
-          paymentContext: {
-            receiptData: responseBody?.unified_receipt?.latest_receipt,
-          },
-        });
-
-        if (!order) throw new Error(`Order with id ${orderPayment.orderId} not found`);
-
-        const orderId = order._id;
-        const enrollment = await modules.enrollments.findEnrollment({
-          orderId,
-        });
-
-        if (!enrollment) throw new Error('Could not find any matching enrollment');
-
-        await fixPeriods(
-          {
-            transactionId: latestTransaction.original_transaction_id,
-            transactions,
-            enrollmentId: enrollment._id,
-            orderId,
-          },
-          resolvedContext,
-        );
-
-        logger.info(`Apple IAP Webhook: Confirmed checkout for order ${order.orderNumber}`, {
-          orderId: order._id,
-        });
-      } else {
-        // Just store payment credentials, use the enrollments paymentProvider reference and
-        // let the job do the rest
-        const originalOrderPayment = await modules.orders.payments.findOrderPaymentByContextData({
-          context: {
-            'meta.transactionIdentifier': latestTransaction.original_transaction_id,
-          },
-        });
-        if (!originalOrderPayment) throw new Error('Could not find any matching order payment');
-        const originalOrder = await modules.orders.findOrder({
-          orderId: originalOrderPayment.orderId,
-        });
-        const enrollment =
-          originalOrder &&
-          (await modules.enrollments.findEnrollment({
-            orderId: originalOrder._id,
-          }));
-        if (!enrollment?.payment) throw new Error('Could not find a valid enrollment payment method');
-
-        await services.orders.registerPaymentCredentials(enrollment.payment.paymentProviderId, {
-          transactionContext: {
-            receiptData: responseBody?.unified_receipt?.latest_receipt,
-          },
-          userId: enrollment.userId,
-        });
-
-        await fixPeriods(
-          {
-            transactionId: latestTransaction.original_transaction_id,
-            transactions,
-            enrollmentId: enrollment._id,
-            orderId: originalOrder!._id,
-          },
-          resolvedContext,
-        );
-
-        logger.info(
-          `Apple IAP Webhook: Processed notification for ${latestTransaction.original_transaction_id} and type ${responseBody.notification_type}`,
-        );
-
-        if (responseBody.notification_type === AppleNotificationTypes.DID_RECOVER) {
-          if (
-            enrollment.status !== EnrollmentStatus.TERMINATED &&
-            responseBody.auto_renew_status === 'false'
-          ) {
-            await services.enrollments.terminateEnrollment(enrollment);
-          }
-        }
-
-        if (responseBody.notification_type === AppleNotificationTypes.DID_CHANGE_RENEWAL_STATUS) {
-          if (
-            enrollment.status !== EnrollmentStatus.TERMINATED &&
-            responseBody.auto_renew_status === 'false'
-          ) {
-            await services.enrollments.terminateEnrollment(enrollment);
-          }
-        }
-        logger.info(`Apple IAP Webhook: Updated enrollment from Apple`);
-      }
-
-      res.status(200).end();
-      return;
-    } catch (e) {
-      logger.warn(`Apple IAP Webhook: ${e.message}`, e);
-      res.status(503).send({ name: e.name, code: e.code, message: e.message });
-      return;
-    }
-  }
-  res.status(404).end();
-};
-
-export default appleIAPHandler;