@unchainedshop/core 4.3.6 → 4.5.0

package/src/bulk-importer/handlers/product/update.ts

@@ -1,175 +0,0 @@
-import { z } from 'zod';
-import { Modules } from '../../../modules.js';
-import { Services } from '../../../services/index.js';
-import upsertVariations, { ProductVariationSchema } from './upsertVariations.js';
-import upsertMedia, { MediaSchema } from './upsertMedia.js';
-import createProduct, { ProductCreatePayloadSchema } from './create.js';
-import convertTagsToLowerCase from '../utils/convertTagsToLowerCase.js';
-
-export const ProductUpdateSpecificationSchema = z.object({
-  type: z.string().optional(),
-  sequence: z.number().optional(),
-  status: z.string().optional().nullable(), // or null!
-  published: z.string().datetime().optional().nullable(), // or null!
-  tags: z.array(z.string()).optional(),
-  commerce: z
-    .object({
-      pricing: z.array(
-        z.object({
-          amount: z.number(),
-          maxQuantity: z.number().optional(),
-          isTaxable: z.boolean().optional(),
-          isNetPrice: z.boolean().optional(),
-          currencyCode: z.string(),
-          countryCode: z.string(),
-        }),
-      ),
-    })
-    .optional(),
-  warehousing: z
-    .object({
-      sku: z.string().optional(),
-      baseUnit: z.string().optional(),
-    })
-    .optional(),
-  supply: z
-    .object({
-      weightInGram: z.number().optional(),
-      heightInMillimeters: z.number().optional(),
-      lengthInMillimeters: z.number().optional(),
-      widthInMillimeters: z.number().optional(),
-    })
-    .optional(),
-  bundleItems: z
-    .array(
-      z.object({
-        productId: z.string(),
-        quantity: z.number(),
-        configuration: z.array(
-          z.object({
-            key: z.string(),
-            value: z.string(),
-          }),
-        ),
-      }),
-    )
-    .optional(),
-  meta: z.record(z.any(), z.any()).optional(),
-  content: z
-    .record(
-      z.string(), // locale
-      z.object({
-        title: z.string().optional(),
-        subtitle: z.string().optional(),
-        slug: z.string().optional(),
-        description: z.string().optional(),
-        brand: z.string().optional(),
-        vendor: z.string().optional(),
-        labels: z.array(z.string()).optional(),
-      }),
-    )
-    .optional(),
-  variationResolvers: z
-    .array(
-      z.object({
-        vector: z.record(z.string(), z.any()),
-        productId: z.string(),
-      }),
-    )
-    .optional(),
-});
-
-export const ProductUpdatePayloadSchema = z.object({
-  _id: z.string(),
-  specification: ProductUpdateSpecificationSchema.optional(),
-  media: z.array(MediaSchema).optional(),
-  variations: z.array(ProductVariationSchema).optional(),
-});
-
-const transformSpecification = (specification: z.infer<typeof ProductUpdateSpecificationSchema>) => {
-  const {
-    variationResolvers: assignments,
-    content, // eslint-disable-line
-    supply,
-    warehousing,
-    ...productData
-  } = specification;
-
-  const tags = productData?.tags ? convertTagsToLowerCase(productData.tags!)! : [];
-  const proxy = assignments ? { assignments } : undefined;
-
-  return {
-    ...productData,
-    published: productData.published ? new Date(productData.published) : undefined,
-    tags,
-    warehousing,
-    supply,
-    proxy,
-  };
-};
-
-export default async function updateProduct(
-  payload: z.infer<typeof ProductUpdatePayloadSchema>,
-  { logger, updateShouldUpsertIfIDNotExists },
-  unchainedAPI: { modules: Modules; services: Services },
-) {
-  const { modules } = unchainedAPI;
-  const { specification, media, variations, _id } = payload;
-
-  if (!(await modules.products.productExists({ productId: _id }))) {
-    if (updateShouldUpsertIfIDNotExists && payload.specification) {
-      return createProduct(
-        payload as z.infer<typeof ProductCreatePayloadSchema>,
-        { logger, createShouldUpsertIfIDExists: false },
-        unchainedAPI,
-      );
-    }
-    throw new Error(`Can't update non-existing product ${_id}`);
-  }
-
-  if (specification) {
-    const productData = transformSpecification(specification);
-    logger.debug('update product object', productData);
-    await modules.products.update(_id, {
-      ...productData,
-    });
-
-    if (specification.content) {
-      logger.debug('replace localized content for product', specification.content);
-      await modules.products.texts.updateTexts(
-        _id,
-        Object.entries(specification.content).map(([locale, localizedData]: [string, any]) => {
-          return {
-            locale,
-            ...localizedData,
-          };
-        }),
-      );
-    }
-  }
-
-  if (variations) {
-    logger.debug('replace variations', variations);
-    await upsertVariations(
-      {
-        variations: variations || [],
-        productId: _id,
-      },
-      unchainedAPI,
-    );
-  }
-
-  if (media) {
-    logger.debug('replace product media', media);
-    await upsertMedia({ media, productId: _id }, unchainedAPI);
-  }
-
-  return {
-    entity: 'PRODUCT',
-    operation: 'update',
-    _id,
-    success: true,
-  };
-}
-
-updateProduct.payloadSchema = ProductUpdatePayloadSchema;

package/src/bulk-importer/handlers/product/upsertMedia.ts

@@ -1,81 +0,0 @@
-import { z } from 'zod';
-import { ProductMedia } from '@unchainedshop/core-products';
-import { Modules } from '../../../modules.js';
-import { Services } from '../../../services/index.js';
-import convertTagsToLowerCase from '../utils/convertTagsToLowerCase.js';
-import upsertAsset, { AssetSchema } from '../../upsertAsset.js';
-
-export const MediaSchema = z.object({
-  _id: z.string().optional(),
-  asset: AssetSchema,
-  content: z
-    .record(
-      z.string(), // locale
-      z.object({
-        title: z.string().optional(),
-        subtitle: z.string().optional(),
-      }),
-    )
-    .optional(),
-  tags: z.array(z.string()).optional(),
-  sortKey: z.number().optional(),
-});
-
-const upsertProductMedia = async (productMedia: ProductMedia, { modules }: { modules: Modules }) => {
-  try {
-    const productMediaObj = await modules.products.media.create(productMedia);
-    return productMediaObj;
-  } catch {
-    const { _id, ...productMediaData } = productMedia;
-    const productMediaId = _id;
-    return modules.products.media.update(productMediaId, productMediaData);
-  }
-};
-
-export default async function upsertMedia(
-  { media, productId }: { media: z.infer<typeof MediaSchema>[]; productId: string },
-  unchainedAPI: { modules: Modules; services: Services },
-) {
-  const { modules } = unchainedAPI;
-
-  const productMediaObjects = await Promise.all(
-    media.map(async ({ asset, content, ...mediaData }) => {
-      const file = await upsertAsset(
-        'product-media',
-        { meta: { ...(asset.meta || {}), productId }, ...asset },
-        unchainedAPI,
-      );
-      if (!file) throw new Error(`Unable to create binary ${asset._id}`);
-      const fileId = file._id;
-      const tags = mediaData?.tags ? convertTagsToLowerCase(mediaData?.tags)! : [];
-      const productMedia = await upsertProductMedia(
-        {
-          ...mediaData,
-          tags,
-          productId,
-          mediaId: file._id,
-        } as ProductMedia,
-        unchainedAPI,
-      );
-      if (!productMedia) throw new Error(`Unable to create product media object for file ${fileId}`);
-
-      if (content) {
-        await modules.products.media.texts.updateMediaTexts(
-          productMedia._id,
-          Object.entries(content).map(([locale, localizedData]: [string, any]) => {
-            return {
-              locale,
-              ...localizedData,
-            };
-          }),
-        );
-      }
-      return productMedia;
-    }),
-  );
-
-  await modules.products.media.deleteMediaFiles({
-    productId,
-    excludedProductMediaIds: productMediaObjects.map((obj) => obj._id),
-  });
-}

package/src/bulk-importer/handlers/product/upsertVariations.ts

@@ -1,110 +0,0 @@
-import { z } from 'zod';
-import { ProductVariation } from '@unchainedshop/core-products';
-import { Modules } from '../../../modules.js';
-
-const ProductVariationOptionSchema = z.object({
-  value: z.string(),
-  content: z
-    .record(
-      z.string(), // locale
-      z.object({
-        title: z.string().optional(),
-        subtitle: z.string().optional(),
-      }),
-    )
-    .optional(),
-});
-
-export const ProductVariationSchema = z.object({
-  _id: z.string().optional(),
-  key: z.string(),
-  type: z.string(),
-  options: z.array(ProductVariationOptionSchema),
-  content: z
-    .record(
-      z.string(), // locale
-      z.object({
-        title: z.string().optional(),
-        subtitle: z.string().optional(),
-      }),
-    )
-    .optional(),
-});
-
-const upsert = async (
-  productVariation: Omit<ProductVariation, '_id' | 'created'> &
-    Pick<Partial<ProductVariation>, '_id' | 'created'>,
-  unchainedAPI: { modules: Modules },
-) => {
-  const { modules } = unchainedAPI;
-  try {
-    const newVariation = (await modules.products.variations.create(
-      productVariation,
-    )) as ProductVariation;
-    return newVariation;
-  } catch {
-    return (await modules.products.variations.update(
-      productVariation._id!,
-      productVariation,
-    )) as ProductVariation;
-  }
-};
-
-export default async function upsertVariations(
-  { variations, productId }: { variations: z.infer<typeof ProductVariationSchema>[]; productId: string },
-  unchainedAPI: { modules: Modules },
-) {
-  const { modules } = unchainedAPI;
-
-  const upsertedProductVariationIds = await Promise.all(
-    variations.map(async ({ content, options, ...variationsRest }) => {
-      const variation = await upsert(
-        {
-          ...variationsRest,
-          options: options.map((option) => option.value),
-          productId,
-        },
-        unchainedAPI,
-      );
-
-      await Promise.all(
-        options.map(async ({ content: optionContent, value: optionValue }) => {
-          if (optionContent) {
-            await modules.products.variations.texts.updateVariationTexts(
-              variation._id,
-              Object.entries(optionContent).map(([locale, localizedData]: [string, any]) => {
-                return {
-                  locale,
-                  ...localizedData,
-                };
-              }),
-              optionValue,
-            );
-          }
-        }),
-      );
-      if (content) {
-        await modules.products.variations.texts.updateVariationTexts(
-          variation._id,
-          Object.entries(content).map(([locale, localizedData]: [string, any]) => {
-            return {
-              locale,
-              ...localizedData,
-            };
-          }),
-        );
-      }
-      return variation._id;
-    }),
-  );
-  const allVariations = await modules.products.variations.findProductVariations({
-    productId,
-  });
-  await Promise.all(
-    allVariations.map(async (variation) => {
-      if (!upsertedProductVariationIds.includes(variation._id)) {
-        await modules.products.variations.delete(variation._id);
-      }
-    }),
-  );
-}

package/src/bulk-importer/handlers/utils/convertTagsToLowerCase.ts

@@ -1,4 +0,0 @@
-export default (tags: string[]): string[] | null => {
-  if (Array.isArray(tags)) return tags.map((tag) => tag.toLowerCase());
-  return null;
-};

package/src/bulk-importer/index.ts

@@ -1,3 +0,0 @@
-import { default as createBulkImporterFactory } from './createBulkImporter.js';
-export * from './createBulkImporter.js';
-export default createBulkImporterFactory;

package/src/bulk-importer/upsertAsset.ts

@@ -1,53 +0,0 @@
-import { createLogger } from '@unchainedshop/logger';
-import { Modules } from '../modules.js';
-import { Services } from '../services/index.js';
-import { z } from 'zod';
-
-const logger = createLogger('unchained:bulk-import');
-
-export const AssetSchema = z.object({
-  _id: z.string().optional(),
-  url: z.string(),
-  meta: z.record(z.any(), z.any()).optional(),
-  fileName: z.string(),
-  headers: z.record(z.string(), z.any()).optional(),
-});
-
-const upsertAsset = async (
-  directoryName: string,
-  asset: z.infer<typeof AssetSchema>,
-  unchainedAPI: { modules: Modules; services: Services },
-) => {
-  const { modules, services } = unchainedAPI;
-  const { _id: fileId, fileName, url, meta, headers, ...assetData } = asset;
-
-  try {
-    const existingFile = fileId && (await modules.files.findFile({ fileId }));
-    if (existingFile) {
-      if (JSON.stringify(meta) === JSON.stringify(existingFile.meta)) {
-        return existingFile;
-      }
-      await modules.files.update(fileId, { meta, ...assetData });
-      const updatedFile = await modules.files.findFile({ fileId });
-      return updatedFile;
-    }
-
-    const assetObject = await services.files.uploadFileFromURL({
-      directoryName,
-      fileInput: {
-        fileLink: url,
-        fileName,
-        fileId,
-        headers,
-      },
-      meta,
-    });
-
-    if (!assetObject) return null;
-  } catch (e) {
-    logger.warn(`Unable to upsert asset ${fileId || fileName}: ${e.message}`);
-    return null;
-  }
-};
-
-export default upsertAsset;

package/src/core-index.ts

@@ -1,103 +0,0 @@
-import { mongodb, MigrationRepository, ModuleInput } from '@unchainedshop/mongodb';
-import initServices, { CustomServices, Services } from './services/index.js';
-import initModules, { Modules, ModuleOptions } from './modules.js';
-import createBulkImporterFactory, { BulkImporter, BulkImportHandler } from './bulk-importer/index.js';
-
-import {
-  WorkerDirector,
-  DeliveryDirector,
-  DeliveryPricingDirector,
-  EnrollmentDirector,
-  FilterDirector,
-  OrderDiscountDirector,
-  OrderPricingDirector,
-  PaymentDirector,
-  PaymentPricingDirector,
-  ProductDiscountDirector,
-  ProductPricingDirector,
-  QuotationDirector,
-  WarehousingDirector,
-} from './directors/index.js';
-import { IBaseAdapter } from '@unchainedshop/utils';
-
-export * from './bulk-importer/index.js';
-export * from './services/index.js';
-export * from './directors/index.js';
-export * from './factory/index.js';
-
-export interface UnchainedCoreOptions {
-  db: mongodb.Db;
-  migrationRepository: MigrationRepository<UnchainedCore>;
-  bulkImporter?: {
-    handlers?: Record<string, BulkImportHandler<UnchainedCore>>;
-  };
-  modules?: Record<
-    string,
-    {
-      configure: (params: ModuleInput<any>) => any;
-    }
-  >;
-  services?: CustomServices;
-  options?: ModuleOptions;
-}
-
-export interface UnchainedCore {
-  modules: Modules;
-  services: Services;
-  bulkImporter: BulkImporter;
-  options: ModuleOptions;
-}
-
-export const initCore = async ({
-  db,
-  migrationRepository,
-  bulkImporter: bulkImporterOptions = {},
-  modules: customModules = {},
-  services: customServices = {},
-  options = {},
-}: UnchainedCoreOptions): Promise<UnchainedCore> => {
-  // Configure custom modules
-
-  const bulkImporter = createBulkImporterFactory(db, bulkImporterOptions);
-  const modules = await initModules({ db, migrationRepository, options }, customModules);
-  const services = initServices(modules, customServices);
-
-  return {
-    modules,
-    services,
-    bulkImporter,
-    options,
-  };
-};
-
-export const getAllAdapters = () => {
-  const worker = WorkerDirector.getAdapters();
-  const delivery = DeliveryDirector.getAdapters();
-  const deliveryPricing = DeliveryPricingDirector.getAdapters();
-  const enrollment = EnrollmentDirector.getAdapters();
-  const filter = FilterDirector.getAdapters();
-  const orderDiscount = OrderDiscountDirector.getAdapters();
-  const orderPricing = OrderPricingDirector.getAdapters();
-  const payment = PaymentDirector.getAdapters();
-  const paymentPricing = PaymentPricingDirector.getAdapters();
-  const productDiscount = ProductDiscountDirector.getAdapters();
-  const productPricing = ProductPricingDirector.getAdapters();
-  const quotation = QuotationDirector.getAdapters();
-  const warehousing = WarehousingDirector.getAdapters();
-
-  return ([] as IBaseAdapter[]).concat(
-    worker,
-    delivery,
-    deliveryPricing,
-    enrollment,
-    filter,
-    orderDiscount,
-    orderPricing,
-    payment,
-    paymentPricing,
-    productDiscount,
-    productPricing,
-    quotation,
-    warehousing,
-  );
-};

package/src/directors/BaseDiscountAdapter.test.ts

@@ -1,52 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert/strict';
-import { BaseDiscountAdapter } from './BaseDiscountAdapter.js';
-
-describe('BaseDiscountAdapter instantiation', () => {
-  const adapter = BaseDiscountAdapter;
-  const context = null as any;
-  it('should initialize with default values', async () => {
-    assert.equal(adapter.orderIndex, 0);
-    assert.equal(typeof adapter.log, 'function');
-    assert.equal(await adapter.isManualAdditionAllowed(''), false);
-    assert.equal(await adapter.isManualRemovalAllowed(), false);
-    assert.deepStrictEqual(Object.keys(await adapter.actions(context)), [
-      'isValidForSystemTriggering',
-      'reserve',
-      'release',
-      'isValidForCodeTriggering',
-      'discountForPricingAdapterKey',
-    ]);
-  });
-
-  describe('actions', () => {
-    it('isValidForSystemTriggering', async () => {
-      const result = await adapter.actions(context);
-      assert.equal(await result.isValidForSystemTriggering(), false);
-    });
-
-    it('reserve', async () => {
-      const result = await adapter.actions(context);
-      assert.deepEqual(await result.reserve({ code: '' }), {});
-    });
-
-    it('release', async () => {
-      const result = await adapter.actions(context);
-      assert.equal(await result.release(), undefined);
-    });
-
-    it('isValidForCodeTriggering', async () => {
-      const result = await adapter.actions(context);
-      assert.equal(await result.isValidForCodeTriggering({ code: '' }), false);
-    });
-
-    it('discountForPricingAdapterKey', async () => {
-      const result = await adapter.actions(context);
-      const calculationSheet = {};
-      assert.equal(
-        await result.discountForPricingAdapterKey({ calculationSheet, pricingAdapterKey: 'key' } as any),
-        null,
-      );
-    });
-  });
-});

package/src/directors/BaseDiscountAdapter.ts

@@ -1,86 +0,0 @@
-import { BaseAdapter, IBaseAdapter } from '@unchainedshop/utils';
-import { IPricingSheet } from './BasePricingSheet.js';
-import { PricingCalculation } from '@unchainedshop/utils';
-import { Order, OrderDiscount } from '@unchainedshop/core-orders';
-import { Modules } from '../modules.js';
-export interface DiscountContext {
-  code?: string;
-  orderDiscount?: OrderDiscount;
-  order: Order;
-}
-
-export type IDiscountAdapter<DiscountConfiguration> = IBaseAdapter & {
-  orderIndex: number;
-
-  isManualAdditionAllowed: (code?: string) => Promise<boolean>;
-  isManualRemovalAllowed: () => Promise<boolean>;
-
-  actions: (params: {
-    context: DiscountContext & { modules: Modules };
-  }) => Promise<DiscountAdapterActions<DiscountConfiguration>>;
-};
-
-export interface DiscountAdapterActions<DiscountConfiguration> {
-  isValidForSystemTriggering: () => Promise<boolean>;
-  isValidForCodeTriggering: (params: { code: string }) => Promise<boolean>;
-
-  discountForPricingAdapterKey: (params: {
-    pricingAdapterKey: string;
-    calculationSheet: IPricingSheet<PricingCalculation>;
-  }) => DiscountConfiguration | null;
-
-  reserve: (params: { code?: string }) => Promise<any>;
-  release: () => Promise<void>;
-}
-
-export const BaseDiscountAdapter: Omit<IDiscountAdapter<unknown>, 'key' | 'label' | 'version'> = {
-  ...BaseAdapter,
-  orderIndex: 0,
-
-  isManualAdditionAllowed: async () => {
-    return false;
-  },
-
-  // return true if a discount is allowed to get removed manually by a user
-  isManualRemovalAllowed: async () => {
-    return false;
-  },
-
-  actions: async () => ({
-    // return true if a discount is valid to be part of the order
-    // without input of a user. that could be a time based global discount
-    // like a 10% discount day
-    // if you return false, this discount will
-    // get removed from the order before any price calculation
-    // takes place.
-
-    isValidForSystemTriggering: async () => {
-      return false;
-    },
-
-    // return an arbitrary JSON serializable object with reservation data
-    // this method is called when a discount is added through a manual code and let's
-    // you manually deduct expendable discounts (coupon balances for ex.) before checkout
-    reserve: async () => {
-      return {};
-    },
-
-    // return void, allows you to free up any reservations in backend systems
-    release: async () => {
-      return;
-    },
-
-    // return true if a discount is valid to be part of the order.
-    // if you return false, this discount will
-    // get removed from the order before any price calculation
-    // takes place.
-    isValidForCodeTriggering: async () => {
-      return false;
-    },
-
-    // returns the appropriate discount context for a calculation adapter
-    discountForPricingAdapterKey() {
-      return null;
-    },
-  }),
-};