@unchainedshop/core 4.0.0-rc.8 → 4.0.0

package/src/bulk-importer/handlers/assortment/upsertAssortmentChildren.ts

@@ -0,0 +1,77 @@
+import { z } from 'zod';
+import convertTagsToLowerCase from '../utils/convertTagsToLowerCase.js';
+import { Modules } from '../../../modules.js';
+
+export const AssortmentLinkSchema = z.object({
+  _id: z.string().optional(),
+  assortmentId: z.string(),
+  tags: z.array(z.string()).optional(),
+  sortKey: z.number().optional(),
+  meta: z.record(z.unknown()).optional(),
+});
+
+const upsert = async (
+  assortmentLink: {
+    _id?: string;
+    parentAssortmentId: string;
+    childAssortmentId: string;
+    tags: string[];
+    sortKey?: number;
+  },
+  { modules }: { modules: Modules },
+) => {
+  if (
+    !(await modules.assortments.assortmentExists({
+      assortmentId: assortmentLink.childAssortmentId,
+    }))
+  ) {
+    throw new Error(`Can't link non-existing assortment ${assortmentLink.childAssortmentId}`);
+  }
+  try {
+    const newAssortmentLink = await modules.assortments.links.create(assortmentLink, {
+      skipInvalidation: true,
+    });
+    return newAssortmentLink!;
+  } catch {
+    return (await modules.assortments.links.update(assortmentLink._id!, assortmentLink, {
+      skipInvalidation: true,
+    }))!;
+  }
+};
+
+export default async (
+  {
+    children,
+    assortmentId: parentAssortmentId,
+  }: {
+    children: z.infer<typeof AssortmentLinkSchema>[];
+    assortmentId: string;
+  },
+  unchainedAPI: { modules: Modules },
+) => {
+  const { modules } = unchainedAPI;
+  const assortmentLinkIds = await Promise.all(
+    children.map(
+      async ({ assortmentId: childAssortmentId, sortKey, tags: tagsMixedCase }, sortKeyForced) => {
+        const tags = tagsMixedCase ? convertTagsToLowerCase(tagsMixedCase)! : [];
+        const assortmentLink = await upsert(
+          {
+            sortKey: sortKey ?? sortKeyForced,
+            tags,
+            parentAssortmentId,
+            childAssortmentId,
+          },
+          unchainedAPI,
+        );
+        return assortmentLink._id;
+      },
+    ),
+  );
+  await modules.assortments.links.deleteMany(
+    {
+      _id: { $nin: assortmentLinkIds },
+      parentAssortmentId,
+    },
+    { skipInvalidation: true },
+  );
+};

package/src/bulk-importer/handlers/assortment/upsertAssortmentFilters.ts

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+import convertTagsToLowerCase from '../utils/convertTagsToLowerCase.js';
+import { Modules } from '../../../modules.js';
+
+export const AssortmentFilterSchema = z.object({
+  _id: z.string().optional(),
+  filterId: z.string(),
+  tags: z.array(z.string()).optional(),
+  sortKey: z.number().optional(),
+  meta: z.record(z.unknown()).optional(),
+});
+
+const upsert = async (
+  assortmentFilter: {
+    _id?: string;
+    filterId: string;
+    tags: string[];
+    assortmentId: string;
+    sortKey: number;
+  },
+  { modules }: { modules: Modules },
+) => {
+  if (
+    !(await modules.filters.filterExists({
+      filterId: assortmentFilter.filterId,
+    }))
+  ) {
+    throw new Error(`Can't link non-existing filter ${assortmentFilter.filterId}`);
+  }
+  try {
+    const newAssortmentFilter = await modules.assortments.filters.create(assortmentFilter);
+    return newAssortmentFilter;
+  } catch {
+    return await modules.assortments.filters.update(assortmentFilter._id!, assortmentFilter);
+  }
+};
+
+export default async (
+  {
+    filters,
+    assortmentId,
+  }: {
+    filters: z.infer<typeof AssortmentFilterSchema>[];
+    assortmentId: string;
+  },
+  unchainedAPI: { modules: Modules },
+) => {
+  const { modules } = unchainedAPI;
+  const assortmentFilterIds = await Promise.all(
+    filters.map(async ({ tags: tagsMixedCase, sortKey, ...rest }, forcedSortKey) => {
+      const tags = tagsMixedCase ? convertTagsToLowerCase(tagsMixedCase)! : [];
+
+      const assortmentFilter = await upsert(
+        {
+          ...rest,
+          assortmentId,
+          tags,
+          sortKey: sortKey ?? forcedSortKey,
+        },
+        unchainedAPI,
+      );
+      return assortmentFilter!._id;
+    }),
+  );
+
+  await modules.assortments.filters.deleteMany({
+    _id: { $nin: assortmentFilterIds },
+    assortmentId,
+  });
+};

package/src/bulk-importer/handlers/assortment/upsertAssortmentProducts.ts

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+import { AssortmentProduct } from '@unchainedshop/core-assortments';
+import convertTagsToLowerCase from '../utils/convertTagsToLowerCase.js';
+import { Modules } from '../../../modules.js';
+
+export const AssortmentProductSchema = z.object({
+  _id: z.string().optional(),
+  productId: z.string(),
+  tags: z.array(z.string()).optional(),
+  sortKey: z.number().optional(),
+  meta: z.record(z.any()).optional(),
+});
+
+const upsert = async (
+  assortmentProduct: {
+    _id?: string;
+    productId: string;
+    tags: string[];
+    assortmentId: string;
+    sortKey: number;
+  },
+  unchainedAPI: { modules: Modules },
+) => {
+  const { modules } = unchainedAPI;
+  if (
+    !(await modules.products.productExists({
+      productId: assortmentProduct.productId,
+    }))
+  ) {
+    throw new Error(`Can't link non-existing product ${assortmentProduct.productId}`);
+  }
+  try {
+    const newAssortmentProduct = (await modules.assortments.products.create(assortmentProduct, {
+      skipInvalidation: true,
+    })) as AssortmentProduct;
+    return newAssortmentProduct;
+  } catch {
+    return (await modules.assortments.products.update(assortmentProduct._id!, assortmentProduct, {
+      skipInvalidation: true,
+    })) as AssortmentProduct;
+  }
+};
+
+export default async (
+  {
+    products,
+    assortmentId,
+  }: { products: z.infer<typeof AssortmentProductSchema>[]; assortmentId: string },
+  unchainedAPI: { modules: Modules },
+) => {
+  const { modules } = unchainedAPI;
+  const assortmentProductIds = await Promise.all(
+    products.map(async ({ tags: tagsMixedCase, sortKey, ...rest }, forcedSortKey) => {
+      const tags = tagsMixedCase ? convertTagsToLowerCase(tagsMixedCase)! : [];
+
+      const assortmentProduct = await upsert(
+        {
+          ...rest,
+          tags,
+          sortKey: sortKey ?? forcedSortKey,
+          assortmentId,
+        },
+        unchainedAPI,
+      );
+      return assortmentProduct._id;
+    }),
+  );
+
+  await modules.assortments.products.deleteMany(
+    {
+      _id: { $nin: assortmentProductIds },
+      assortmentId,
+    },
+    { skipInvalidation: true },
+  );
+};

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

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+import { Services } from '../../../services/index.js';
+import { Modules } from '../../../modules.js';
+import upsertAsset, { AssetSchema } from '../../upsertAsset.js';
+import { AssortmentMediaType } from '@unchainedshop/core-assortments';
+
+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 upsertMediaObject = async (media, unchainedAPI: { modules: Modules; services: Services }) => {
+  const { modules } = unchainedAPI;
+  try {
+    const assortmentMedia = (await modules.assortments.media.create(media)) as AssortmentMediaType;
+    return assortmentMedia;
+  } catch {
+    const { _id, ...mediaData } = media;
+    return (await modules.assortments.media.update(_id, mediaData)) as AssortmentMediaType;
+  }
+};
+
+export default async (
+  { media, assortmentId }: { media: z.infer<typeof MediaSchema>[]; assortmentId: string },
+  unchainedAPI: { modules: Modules; services: Services },
+) => {
+  const { modules } = unchainedAPI;
+  const mediaObjects = await Promise.all(
+    media.map(async ({ asset, content, ...mediaData }) => {
+      const file = await upsertAsset(
+        'assortment-media',
+        { meta: { ...(asset.meta || {}), assortmentId }, ...asset },
+        unchainedAPI,
+      );
+      if (!file) throw new Error(`Unable to create binary ${asset._id}`);
+
+      const mediaObject = await upsertMediaObject(
+        {
+          ...mediaData,
+          assortmentId,
+          mediaId: file._id,
+        },
+        unchainedAPI,
+      );
+
+      if (!mediaObject) throw new Error(`Unable to create media object ${mediaData._id}`);
+
+      if (content) {
+        await modules.assortments.media.texts.updateMediaTexts(
+          mediaObject._id,
+          Object.entries(content).map(([locale, localizedData]: [string, any]) => ({
+            locale,
+            ...localizedData,
+          })),
+        );
+      }
+      return mediaObject;
+    }),
+  );
+
+  await modules.assortments.media.deleteMediaFiles({
+    assortmentId,
+    excludedAssortmentMediaIds: mediaObjects.map((obj) => obj._id),
+  });
+};

package/src/bulk-importer/handlers/filter/create.ts

@@ -0,0 +1,104 @@
+import { z } from 'zod';
+import { Modules } from '../../../modules.js';
+
+export const LocalizedContentSchema = z.record(
+  z.string(), // locale
+  z.object({
+    title: z.string().optional(),
+    subtitle: z.string().optional(),
+  }),
+);
+
+export const FilterCreatePayloadSchema = z.object({
+  _id: z.string(),
+  specification: z.object({
+    type: z.string(),
+    key: z.string(),
+    isActive: z.boolean().optional(),
+    options: z
+      .array(
+        z.object({
+          value: z.string(),
+          content: LocalizedContentSchema.optional(),
+        }),
+      )
+      .optional(),
+    meta: z.record(z.unknown()).optional(),
+    content: LocalizedContentSchema,
+  }),
+});
+
+export default async function createFilter(
+  payload: any,
+  { logger, createShouldUpsertIfIDExists },
+  unchainedAPI: { modules: Modules },
+) {
+  const { modules } = unchainedAPI;
+  const { specification, _id } = payload;
+
+  if (!specification) throw new Error(`Specification is required when creating new filter ${_id}`);
+
+  const { content, options, ...filterData } = specification;
+
+  if (!content) throw new Error(`Localizable content is required when creating new filter${_id}`);
+
+  logger.debug('create filter object', specification);
+  try {
+    await unchainedAPI.modules.filters.create({
+      ...filterData,
+      _id,
+      options: options?.map((option) => option.value) || [],
+    });
+  } catch (e) {
+    if (!createShouldUpsertIfIDExists) throw e;
+
+    logger.debug('entity already exists, falling back to update', specification);
+    await modules.filters.update(_id, {
+      ...filterData,
+      options: options?.map((option) => option.value) || [],
+    });
+  }
+
+  if (!(await modules.filters.filterExists({ filterId: _id }))) {
+    throw new Error(`Can't upsert filter ${_id}`);
+  }
+
+  if (content) {
+    logger.debug('create localized content for filter', content);
+    await modules.filters.texts.updateTexts(
+      { filterId: _id },
+      Object.entries(content).map(([locale, localizedData]: [string, any]) => {
+        return {
+          locale,
+          ...localizedData,
+        };
+      }),
+    );
+  }
+
+  if (options) {
+    logger.debug('create localized content for filter options', content);
+    await Promise.all(
+      options.map(async ({ content: optionContent, value: optionValue }) => {
+        if (optionContent) {
+          await modules.filters.texts.updateTexts(
+            { filterId: _id, filterOptionValue: optionValue },
+            Object.entries(optionContent).map(([locale, localizedData]: [string, any]) => {
+              return {
+                locale,
+                ...localizedData,
+              };
+            }),
+          );
+        }
+      }),
+    );
+  }
+
+  return {
+    entity: 'FILTER',
+    operation: 'create',
+    _id,
+    success: true,
+  };
+}

package/src/bulk-importer/handlers/filter/index.ts

@@ -0,0 +1,3 @@
+export { default as create } from './create.js';
+export { default as update } from './update.js';
+export { default as remove } from './remove.js';

package/src/bulk-importer/handlers/filter/remove.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { Modules } from '../../../modules.js';
+
+export const FilterRemovePayloadSchema = z.object({
+  _id: z.string(),
+});
+
+export default async function removeFilter(
+  payload: z.infer<typeof FilterRemovePayloadSchema>,
+  { logger },
+  unchainedAPI: { modules: Modules },
+) {
+  const { modules } = unchainedAPI;
+  const { _id } = payload;
+  logger.debug('remove filter');
+  await modules.assortments.filters.deleteMany({ filterId: _id });
+  await modules.filters.delete(_id);
+
+  return {
+    entity: 'FILTER',
+    operation: 'remove',
+    _id,
+    success: true,
+  };
+}

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

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+import createFilter from './create.js';
+import { Modules } from '../../../modules.js';
+
+export const LocalizedContentSchema = z.record(
+  z.string(), // locale
+  z.object({
+    title: z.string().optional(),
+    subtitle: z.string().optional(),
+  }),
+);
+export const FilterUpdatePayloadSchema = z.object({
+  _id: z.string(),
+  specification: z.object({
+    type: z.string(),
+    key: z.string(),
+    isActive: z.boolean().optional(),
+    options: z
+      .array(
+        z.object({
+          value: z.string(),
+          content: LocalizedContentSchema.optional(),
+        }),
+      )
+      .optional(),
+    meta: z.record(z.unknown()).optional(),
+    content: LocalizedContentSchema,
+  }),
+});
+
+export default async function updateFilter(
+  payload: any,
+  { logger, updateShouldUpsertIfIDNotExists }: { logger: any; updateShouldUpsertIfIDNotExists: boolean },
+  unchainedAPI: { modules: Modules },
+) {
+  const { modules } = unchainedAPI;
+  const { specification, _id } = payload;
+
+  if (!(await modules.filters.filterExists({ filterId: _id }))) {
+    if (updateShouldUpsertIfIDNotExists) {
+      return createFilter(payload, { logger, createShouldUpsertIfIDExists: false }, unchainedAPI);
+    }
+    throw new Error(`Can't update non-existing filter ${_id}`);
+  }
+
+  const { content, options, ...filterData } = specification;
+
+  if (specification) {
+    logger.debug('update filter object', specification);
+    await modules.filters.update(_id, {
+      ...filterData,
+      options: options?.map((option) => option.value) || [],
+    });
+  }
+
+  if (content) {
+    logger.debug('replace localized content for filter', content);
+    await modules.filters.texts.updateTexts(
+      { filterId: _id },
+      Object.entries(content).map(([locale, localizedData]: [string, any]) => {
+        return {
+          locale,
+          ...localizedData,
+        };
+      }),
+    );
+  }
+
+  if (options) {
+    logger.debug('replace localized content for filter options', content);
+    await Promise.all(
+      options.map(async ({ content: optionContent, value: optionValue }) => {
+        if (optionContent) {
+          await modules.filters.texts.updateTexts(
+            { filterId: _id, filterOptionValue: optionValue },
+            Object.entries(optionContent).map(([locale, localizedData]: [string, any]) => {
+              return {
+                locale,
+                ...localizedData,
+              };
+            }),
+          );
+        }
+      }),
+    );
+  }
+
+  return {
+    entity: 'FILTER',
+    operation: 'update',
+    _id,
+    success: true,
+  };
+}

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

@@ -0,0 +1,170 @@
+import { z } from 'zod';
+import { Modules } from '../../../modules.js';
+import { Services } from '../../../services/index.js';
+import upsertVariations, { ProductVariationSchema } from './upsertVariations.js';
+import upsertMedia from './upsertMedia.js';
+import { MediaSchema } from '../assortment/upsertMedia.js';
+import convertTagsToLowerCase from '../utils/convertTagsToLowerCase.js';
+
+export const ProductCreateSpecificationSchema = z.object({
+  type: z.string(),
+  sequence: z.number(),
+  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.unknown()).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(),
+    }),
+  ),
+  variationResolvers: z
+    .array(
+      z.object({
+        vector: z.record(z.string()),
+        productId: z.string(),
+      }),
+    )
+    .optional(),
+});
+
+export const ProductCreatePayloadSchema = z.object({
+  _id: z.string(),
+  specification: ProductCreateSpecificationSchema,
+  media: z.array(MediaSchema).optional(),
+  variations: z.array(ProductVariationSchema).optional(),
+});
+
+const transformSpecification = (specification: z.infer<typeof ProductCreateSpecificationSchema>) => {
+  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 createProduct(
+  payload: z.infer<typeof ProductCreatePayloadSchema>,
+  { logger, createShouldUpsertIfIDExists },
+  unchainedAPI: { modules: Modules; services: Services },
+) {
+  const { modules } = unchainedAPI;
+  const { specification, media, variations, _id } = payload;
+
+  const productData = transformSpecification(specification);
+  logger.debug('create product object', productData);
+  try {
+    await modules.products.create({
+      ...productData,
+      _id,
+    });
+  } catch (e) {
+    if (!createShouldUpsertIfIDExists) throw e;
+
+    logger.debug('entity already exists, falling back to update', specification);
+    await modules.products.update(_id, {
+      ...productData,
+    });
+  }
+
+  if (!(await modules.products.productExists({ productId: _id }))) {
+    throw new Error(`Can't create product ${_id}`);
+  }
+
+  if (specification.content) {
+    logger.debug('create localized content for product', specification.content);
+    await modules.products.texts.updateTexts(
+      _id,
+      Object.entries(specification.content).map(([locale, localizedData]: [string, any]) => {
+        return {
+          locale,
+          ...localizedData,
+        };
+      }),
+    );
+  }
+
+  logger.debug('create product variations', variations);
+  await upsertVariations(
+    {
+      variations: variations || [],
+      productId: _id,
+    },
+    unchainedAPI,
+  );
+
+  logger.debug('create product media', media);
+  await upsertMedia({ media: media || [], productId: _id }, unchainedAPI);
+
+  return {
+    entity: 'PRODUCT',
+    operation: 'create',
+    _id,
+    success: true,
+  };
+}
+
+createProduct.payloadSchema = ProductCreatePayloadSchema;

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

@@ -0,0 +1,3 @@
+export { default as create } from './create.js';
+export { default as update } from './update.js';
+export { default as remove } from './remove.js';