@unchainedshop/core 4.1.0 → 4.1.1

package/src/factory/registerProductSearchFilter.ts

@@ -0,0 +1,36 @@
+import { SearchQuery } from '@unchainedshop/core-filters';
+import { FilterAdapter, FilterDirector } from '../core-index.js';
+
+export default function registerProductSearchFilter({
+  orderIndex = 0,
+  search,
+}: {
+  orderIndex?: number;
+  search: (params: SearchQuery & { queryString: string; locale: Intl.Locale }) => Promise<string[]>;
+}) {
+  FilterDirector.registerAdapter({
+    ...FilterAdapter,
+
+    key: `shop.unchained.filters.product-search-${crypto.randomUUID()}`,
+    label: 'Product Search Filter (auto-generated)',
+    version: '1.0.0',
+    orderIndex,
+
+    actions: (params) => {
+      return {
+        ...FilterAdapter.actions(params),
+
+        async searchProducts({ productIds }, { locale }) {
+          const { queryString, ...rest } = params.searchQuery;
+          if (!queryString) return productIds;
+
+          const restrictedProductIds = new Set(productIds || []);
+          const foundProductIds = await search({ ...rest, queryString, locale });
+          return foundProductIds.filter(
+            restrictedProductIds.size === 0 ? Boolean : (id) => restrictedProductIds.has(id),
+          );
+        },
+      };
+    },
+  });
+}

package/src/factory/registerShippingDelivery.ts

@@ -0,0 +1,65 @@
+import { DeliveryConfiguration, DeliveryProviderType } from '@unchainedshop/core-delivery';
+import { DeliveryAdapter, DeliveryContext, DeliveryDirector } from '../core-index.js';
+import { Work } from '@unchainedshop/core-worker';
+
+export default function registerShippingDelivery({
+  adapterId,
+  active,
+  autoReleaseAllowed,
+  estimatedDeliveryThroughput,
+  send,
+}: {
+  adapterId: string;
+  active?: boolean;
+  autoReleaseAllowed?: boolean;
+  estimatedDeliveryThroughput?: (
+    warehousingThroughputTime: number,
+    context: DeliveryContext,
+  ) => Promise<number | null>;
+  send:
+    | boolean
+    | ((configuration: DeliveryConfiguration, context: DeliveryContext) => Promise<boolean | Work>);
+}) {
+  DeliveryDirector.registerAdapter({
+    ...DeliveryAdapter,
+
+    key: `shop.unchained.delivery.shipping-${adapterId}`,
+    label: 'Shipping Delivery: ' + adapterId,
+    version: '1.0.0',
+
+    initialConfiguration: [],
+
+    typeSupported: (type) => {
+      return type === DeliveryProviderType.SHIPPING;
+    },
+
+    actions: (config, context) => {
+      return {
+        ...DeliveryAdapter.actions(config, context),
+
+        isActive: () => {
+          return active ?? true;
+        },
+
+        isAutoReleaseAllowed: () => {
+          return autoReleaseAllowed ?? true;
+        },
+
+        configurationError: () => {
+          return null;
+        },
+
+        estimatedDeliveryThroughput: async (warehousingThroughputTime) => {
+          if (estimatedDeliveryThroughput) {
+            return estimatedDeliveryThroughput(warehousingThroughputTime, context);
+          }
+          return 0;
+        },
+
+        send: async () => {
+          return typeof send === 'function' ? await send(config, context) : send;
+        },
+      };
+    },
+  });
+}

package/src/factory/registerVirtualWarehousing.ts

@@ -0,0 +1,100 @@
+import {
+  TokenSurrogate,
+  WarehousingConfiguration,
+  WarehousingProviderType,
+} from '@unchainedshop/core-warehousing';
+import { WarehousingAdapter, WarehousingContext, WarehousingDirector } from '../core-index.js';
+
+export default function registerVirtualWarehousing<Metadata = Record<string, any>>({
+  adapterId,
+  orderIndex = 0,
+  stock,
+  tokenize,
+  tokenMetadata,
+  isInvalidateable,
+}: {
+  adapterId: string;
+  orderIndex?: number;
+  stock?:
+    | number
+    | ((
+        referenceDate: Date,
+        configuration: WarehousingConfiguration,
+        context: WarehousingContext,
+      ) => Promise<number>);
+
+  tokenize: (
+    configuration: WarehousingConfiguration,
+    context: WarehousingContext,
+  ) => Promise<Omit<TokenSurrogate, 'userId' | 'productId' | 'orderPositionId'>[]>;
+
+  tokenMetadata?: (
+    serialNumber: string,
+    referenceDate: Date,
+    configuration: WarehousingConfiguration,
+    context: WarehousingContext,
+  ) => Promise<Metadata>;
+
+  isInvalidateable?: (
+    serialNumber: string,
+    referenceDate: Date,
+    configuration: WarehousingConfiguration,
+    context: WarehousingContext,
+  ) => Promise<boolean>;
+}) {
+  WarehousingDirector.registerAdapter({
+    ...WarehousingAdapter,
+
+    key: 'shop.unchained.warehousing.virtual.' + adapterId,
+    label: 'Virtual Wareshousing: ' + adapterId,
+    version: '1.0.0',
+    orderIndex,
+
+    initialConfiguration: [{ key: 'shipping-hub', value: 'Shipping Hub' }],
+
+    typeSupported: (type) => {
+      return type === WarehousingProviderType.VIRTUAL;
+    },
+
+    actions: (configuration, context) => {
+      return {
+        ...WarehousingAdapter.actions(configuration, context),
+
+        isActive() {
+          return true;
+        },
+
+        configurationError() {
+          return null;
+        },
+
+        stock: async (referenceDate) => {
+          if (typeof stock === 'number') {
+            return stock;
+          } else if (typeof stock === 'function') {
+            return stock(referenceDate, configuration, context);
+          }
+          return 99999;
+        },
+
+        async tokenize() {
+          return tokenize(configuration, context);
+        },
+
+        async tokenMetadata(serialNumber, referenceDate) {
+          if (tokenMetadata) {
+            return tokenMetadata(serialNumber, referenceDate, configuration, context);
+          }
+          return null;
+        },
+
+        async isInvalidateable(serialNumber, referenceDate) {
+          if (isInvalidateable) {
+            return isInvalidateable(serialNumber, referenceDate, configuration, context);
+          }
+          return false;
+        },
+      };
+    },
+  });
+}

package/src/factory/registerWorker.ts

@@ -0,0 +1,46 @@
+import { WorkerAdapter, WorkerDirector } from '../core-index.js';
+
+export default function registerWorker<Input = any, Result = any>({
+  type,
+  external,
+  maxParallelAllocations,
+  process,
+}: {
+  type: string;
+  external?: boolean;
+  maxParallelAllocations?: number;
+  process?: (input: Input, workId: string) => Promise<Result>;
+}) {
+  WorkerDirector.registerAdapter({
+    ...WorkerAdapter,
+
+    key: 'shop.unchained.worker.' + type.toLowerCase(),
+    label: 'Worker: ' + type,
+    version: '1.0',
+    external: external ?? false,
+    maxParallelAllocations,
+    type,
+
+    async doWork(input, _, workId) {
+      if (!process) {
+        return { success: false };
+      }
+      try {
+        const result = await process(input, workId);
+        return {
+          success: true,
+          result,
+        };
+      } catch (err) {
+        return {
+          success: false,
+          error: {
+            name: err.name,
+            message: err.message,
+            cause: err.cause,
+          },
+        };
+      }
+    },
+  });
+}

package/src/services/removeProduct.ts

@@ -28,6 +28,9 @@ export async function removeProductService(
         await this.products.delete(productId);
       }
       break;
+    case ProductStatus.DELETED:
+      // Already deleted
+      return false;
     default:
       throw new Error(`Invalid status: ${product?.status}`);
   }