@unchainedshop/core 5.0.0-alpha.1 → 5.0.0-alpha.11

package/lib/bulk-importer/handlers/product/update.js

@@ -1,56 +1,13 @@
 import { z } from 'zod/v4-mini';
 import upsertVariations, { ProductVariationSchema } from "./upsertVariations.js";
 import upsertMedia, { MediaSchema } from "./upsertMedia.js";
-import createProduct, { ProductCreatePayloadSchema } from "./create.js";
+import createProduct, { ProductContentSchema, ProductCreatePayloadSchema, ProductSpecificationFields, } from "./create.js";
 import convertTagsToLowerCase from "../utils/convertTagsToLowerCase.js";
+import { ProductStatus } from '@unchainedshop/core-products';
 export const ProductUpdateSpecificationSchema = z.object({
+    ...ProductSpecificationFields,
     type: z.optional(z.string()),
-    sequence: z.optional(z.number()),
-    status: z.nullable(z.optional(z.string())),
-    published: z.nullish(z.iso.datetime()),
-    tags: z.optional(z.array(z.string())),
-    commerce: z.optional(z.object({
-        pricing: z.array(z.object({
-            amount: z.number(),
-            maxQuantity: z.optional(z.number()),
-            isTaxable: z.optional(z.boolean()),
-            isNetPrice: z.optional(z.boolean()),
-            currencyCode: z.string().check(z.minLength(1, 'currencyCode is required')),
-            countryCode: z.string().check(z.minLength(1, 'countryCode is required')),
-        })),
-    })),
-    warehousing: z.optional(z.object({
-        sku: z.optional(z.string()),
-        baseUnit: z.optional(z.string()),
-    })),
-    supply: z.optional(z.object({
-        weightInGram: z.optional(z.number()),
-        heightInMillimeters: z.optional(z.number()),
-        lengthInMillimeters: z.optional(z.number()),
-        widthInMillimeters: z.optional(z.number()),
-    })),
-    bundleItems: z.optional(z.array(z.object({
-        productId: z.string(),
-        quantity: z.number(),
-        configuration: z.array(z.object({
-            key: z.string(),
-            value: z.string(),
-        })),
-    }))),
-    meta: z.optional(z.record(z.any(), z.any())),
-    content: z.optional(z.record(z.string(), z.object({
-        title: z.optional(z.string()),
-        subtitle: z.optional(z.string()),
-        slug: z.optional(z.string()),
-        description: z.optional(z.string()),
-        brand: z.optional(z.string()),
-        vendor: z.optional(z.string()),
-        labels: z.optional(z.array(z.string())),
-    }))),
-    variationResolvers: z.optional(z.array(z.object({
-        vector: z.record(z.string(), z.any()),
-        productId: z.string(),
-    }))),
+    content: z.optional(ProductContentSchema),
 });
 export const ProductUpdatePayloadSchema = z.object({
     _id: z.string(),
@@ -58,13 +15,16 @@ export const ProductUpdatePayloadSchema = z.object({
     media: z.optional(z.array(MediaSchema)),
     variations: z.optional(z.array(ProductVariationSchema)),
 });
+const normalizeStatus = (status) => (status === ProductStatus.DRAFT ? null : status);
 const transformSpecification = (specification) => {
-    const { variationResolvers: assignments, content, supply, warehousing, ...productData } = specification;
+    const { variationResolvers: assignments, content, supply, warehousing, tokenization, ...productData } = specification;
     const tags = productData?.tags ? convertTagsToLowerCase(productData.tags) : [];
     const proxy = assignments ? { assignments } : undefined;
     return {
         ...productData,
         published: productData.published ? new Date(productData.published) : undefined,
+        ...(productData.status !== undefined && { status: normalizeStatus(productData.status) }),
+        ...(tokenization !== undefined && { tokenization: tokenization }),
         tags,
         warehousing,
         supply,

package/lib/core-index.d.ts

@@ -2,7 +2,6 @@ import { type mongodb, type MigrationRepository, type ModuleInput } from '@uncha
 import { type CustomServices, type Services } from './services/index.ts';
 import { type Modules, type ModuleOptions } from './modules.ts';
 import { type BulkImporter, type BulkImportHandler } from './bulk-importer/index.ts';
-import type { IBaseAdapter } from '@unchainedshop/utils';
 import { type BulkExporter, type BulkExportHandler } from './bulk-exporter/index.ts';
 export * from './bulk-importer/index.ts';
 export * from './services/index.ts';
@@ -36,4 +35,4 @@ export interface UnchainedCore {
     bulkExporter: BulkExporter;
 }
 export declare const initCore: ({ db, migrationRepository, bulkImporter: bulkImporterOptions, modules: customModules, services: customServices, options, bulkExporter: bulkExporterOptions, }: UnchainedCoreOptions) => Promise<UnchainedCore>;
-export declare const getAllAdapters: () => IBaseAdapter[];
+export declare const getAllAdapters: () => import("@unchainedshop/utils").IBaseAdapter[];

package/lib/core-index.js

@@ -2,7 +2,7 @@ import {} from '@unchainedshop/mongodb';
 import initServices, {} from "./services/index.js";
 import initModules, {} from "./modules.js";
 import createBulkImporterFactory, {} from "./bulk-importer/index.js";
-import { WorkerDirector, DeliveryDirector, DeliveryPricingDirector, EnrollmentDirector, FileDirector, FilterDirector, OrderDiscountDirector, OrderPricingDirector, PaymentDirector, PaymentPricingDirector, ProductDiscountDirector, ProductPricingDirector, QuotationDirector, WarehousingDirector, } from "./directors/index.js";
+import { pluginRegistry } from "./plugins/PluginRegistry.js";
 import createBulkExporterFactory, {} from "./bulk-exporter/index.js";
 export * from "./bulk-importer/index.js";
 export * from "./services/index.js";
@@ -26,20 +26,4 @@ export const initCore = async ({ db, migrationRepository, bulkImporter: bulkImpo
         bulkExporter,
     };
 };
-export const getAllAdapters = () => {
-    const worker = WorkerDirector.getAdapters();
-    const delivery = DeliveryDirector.getAdapters();
-    const deliveryPricing = DeliveryPricingDirector.getAdapters();
-    const enrollment = EnrollmentDirector.getAdapters();
-    const file = FileDirector.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 [].concat(worker, delivery, deliveryPricing, enrollment, file, filter, orderDiscount, orderPricing, payment, paymentPricing, productDiscount, productPricing, quotation, warehousing);
-};
+export const getAllAdapters = () => pluginRegistry.getAllAdapters();

package/lib/directors/BaseDiscountAdapter.d.ts

@@ -31,5 +31,8 @@ export interface DiscountAdapterActions<DiscountConfiguration> {
         code?: string;
     }) => Promise<any>;
     release: () => Promise<void>;
+    reserveForCheckout?: () => Promise<{
+        release: () => Promise<void>;
+    }>;
 }
 export declare const BaseDiscountAdapter: Omit<IDiscountAdapter<unknown>, 'key' | 'label' | 'version'>;

package/lib/directors/BaseDiscountDirector.d.ts

@@ -1,4 +1,4 @@
-import { type IBaseDirector } from '@unchainedshop/utils';
+import type { IBaseDirector } from '@unchainedshop/utils';
 import type { DiscountContext, IDiscountAdapter } from './BaseDiscountAdapter.ts';
 import type { Modules } from '../modules.ts';
 export type IDiscountDirector<DiscountConfiguration> = IBaseDirector<IDiscountAdapter<DiscountConfiguration>> & {
@@ -11,4 +11,4 @@ export type IDiscountDirector<DiscountConfiguration> = IBaseDirector<IDiscountAd
         findSystemDiscounts: () => Promise<string[]>;
     }>;
 };
-export declare const BaseDiscountDirector: <DiscountConfigurationType>(directorName: string) => IDiscountDirector<DiscountConfigurationType>;
+export declare const BaseDiscountDirector: <DiscountConfigurationType>(adapterType: symbol) => IDiscountDirector<DiscountConfigurationType>;

package/lib/directors/BaseDiscountDirector.js

@@ -1,19 +1,17 @@
-import { BaseDirector } from '@unchainedshop/utils';
-export const BaseDiscountDirector = (directorName) => {
-    const baseDirector = BaseDirector(directorName, {
-        adapterSortKey: 'orderIndex',
-    });
+import { registryDirector } from "./registryDirector.js";
+export const BaseDiscountDirector = (adapterType) => {
     const director = {
-        ...baseDirector,
+        ...registryDirector(adapterType),
         actions: async function (discountContext, unchainedAPI) {
             const context = { ...discountContext, ...unchainedAPI };
             return {
                 resolveDiscountAdapterFromStaticCode: async (options) => {
                     if (!context.order)
                         return null;
-                    const discounts = await Promise.all(this.getAdapters()
-                        .filter((Adapter) => Adapter.isManualAdditionAllowed(options?.code))
-                        .map(async (Adapter) => {
+                    const discounts = await Promise.all(this.getAdapters().map(async (Adapter) => {
+                        if (!(await Adapter.isManualAdditionAllowed(options?.code))) {
+                            return { Adapter, isValid: false };
+                        }
                         const adapter = await Adapter.actions({ context });
                         return {
                             Adapter,

package/lib/directors/BasePricingDirector.d.ts

@@ -1,4 +1,4 @@
-import { type IBaseDirector, type PricingCalculation } from '@unchainedshop/utils';
+import type { IBaseDirector, PricingCalculation } from '@unchainedshop/utils';
 import type { BasePricingAdapterContext, BasePricingContext, IPricingAdapter } from './BasePricingAdapter.ts';
 import type { IPricingSheet } from './BasePricingSheet.ts';
 import type { Modules } from '../modules.ts';
@@ -13,4 +13,4 @@ export type IPricingDirector<PricingContext extends BasePricingContext, Calculat
     rebuildCalculation: (pricingContext: PricingContext, unchainedAPI: Context) => Promise<Calculation[]>;
     calculationSheet: (pricingContext: PricingContext, calculation: Calculation[]) => PricingAdapterSheet;
 };
-export declare const BasePricingDirector: <DirectorContext extends BasePricingContext, AdapterContext extends BasePricingAdapterContext, Calculation extends PricingCalculation, PricingAdapter extends IPricingAdapter<AdapterContext, Calculation, IPricingSheet<Calculation>>>(directorName: string) => IPricingDirector<DirectorContext, Calculation, AdapterContext, IPricingSheet<Calculation>, PricingAdapter>;
+export declare const BasePricingDirector: <DirectorContext extends BasePricingContext, AdapterContext extends BasePricingAdapterContext, Calculation extends PricingCalculation, PricingAdapter extends IPricingAdapter<AdapterContext, Calculation, IPricingSheet<Calculation>>>(adapterType: symbol) => IPricingDirector<DirectorContext, Calculation, AdapterContext, IPricingSheet<Calculation>, PricingAdapter>;

package/lib/directors/BasePricingDirector.js

@@ -1,13 +1,10 @@
-import { BaseDirector } from '@unchainedshop/utils';
 import { OrderDiscountDirector } from "./OrderDiscountDirector.js";
+import { registryDirector } from "./registryDirector.js";
 import { createLogger } from '@unchainedshop/logger';
 const logger = createLogger('unchained:core');
-export const BasePricingDirector = (directorName) => {
-    const baseDirector = BaseDirector(directorName, {
-        adapterSortKey: 'orderIndex',
-    });
+export const BasePricingDirector = (adapterType) => {
     const director = {
-        ...baseDirector,
+        ...registryDirector(adapterType),
         buildPricingContext: async () => {
             throw new Error('Method not implemented');
         },

package/lib/directors/BasePricingSheet.d.ts

@@ -3,6 +3,8 @@ export interface PricingDiscount {
     discountId: string;
     amount: number;
     currencyCode: string;
+    isTaxable: boolean;
+    isNetPrice: boolean;
 }
 export interface IPricingSheet<Calculation extends PricingCalculation> extends IBasePricingSheet<Calculation> {
     discountPrices: (discountId?: string) => PricingDiscount[];

package/lib/directors/BaseWorker.js

@@ -48,9 +48,10 @@ export const BaseWorker = {
                         retries: workConfig.retries || 0,
                     };
                     if (workConfig.input) {
-                        workData.input = (await workConfig.input(workData)) || {};
-                        if (!workData.input)
+                        const input = await workConfig.input(workData);
+                        if (!input)
                             return null;
+                        workData.input = input;
                     }
                     return unchainedAPI.modules.worker.ensureOneWork(workData);
                 }));

package/lib/directors/DeliveryDirector.d.ts

@@ -1,4 +1,4 @@
-import { type IBaseDirector } from '@unchainedshop/utils';
+import type { IBaseDirector } from '@unchainedshop/utils';
 import { type DeliveryAdapterActions, type DeliveryContext, type IDeliveryAdapter } from './DeliveryAdapter.ts';
 import type { DeliveryProvider } from '@unchainedshop/core-delivery';
 import { type Order } from '@unchainedshop/core-orders';

package/lib/directors/DeliveryDirector.js

@@ -1,20 +1,10 @@
-import { BaseDirector } from '@unchainedshop/utils';
 import { DeliveryError, DeliveryAdapter, } from "./DeliveryAdapter.js";
 import { OrderDeliveryStatus } from '@unchainedshop/core-orders';
 import { createLogger } from '@unchainedshop/logger';
-import { pluginRegistry } from "../plugins/PluginRegistry.js";
+import { registryDirector } from "./registryDirector.js";
 const logger = createLogger('unchained:core');
-const baseDirector = BaseDirector('DeliveryDirector');
 export const DeliveryDirector = {
-    ...baseDirector,
-    getAdapter: (key) => {
-        const adapters = pluginRegistry.getAdapters(DeliveryAdapter.adapterType);
-        return adapters.find((adapter) => adapter.key === key) || null;
-    },
-    getAdapters: ({ adapterFilter } = {}) => {
-        const adapters = pluginRegistry.getAdapters(DeliveryAdapter.adapterType);
-        return adapters.filter(adapterFilter || (() => true));
-    },
+    ...registryDirector(DeliveryAdapter.adapterType),
     actions: async (deliveryProvider, deliveryContext, unchainedAPI) => {
         const Adapter = DeliveryDirector.getAdapter(deliveryProvider.adapterKey);
         if (!Adapter) {

package/lib/directors/DeliveryPricingDirector.js

@@ -1,18 +1,9 @@
 import { DeliveryPricingSheet } from "./DeliveryPricingSheet.js";
 import { BasePricingDirector } from "./BasePricingDirector.js";
 import { DeliveryPricingAdapter, } from "./DeliveryPricingAdapter.js";
-import { pluginRegistry } from "../plugins/PluginRegistry.js";
-const baseDirector = BasePricingDirector('DeliveryPricingDirector');
+const baseDirector = BasePricingDirector(DeliveryPricingAdapter.adapterType);
 export const DeliveryPricingDirector = {
     ...baseDirector,
-    getAdapter: (key) => {
-        const adapters = pluginRegistry.getAdapters(DeliveryPricingAdapter.adapterType);
-        return adapters.find((adapter) => adapter.key === key) || null;
-    },
-    getAdapters: ({ adapterFilter } = {}) => {
-        const adapters = pluginRegistry.getAdapters(DeliveryPricingAdapter.adapterType);
-        return adapters.filter(adapterFilter || (() => true));
-    },
     async buildPricingContext(context, unchainedAPI) {
         const { modules } = unchainedAPI;
         if ('item' in context) {

package/lib/directors/DeliveryPricingSheet.js

@@ -28,10 +28,12 @@ export const DeliveryPricingSheet = (params) => {
                 meta,
             });
         },
-        addTax({ amount, rate, meta }) {
+        addTax({ amount, rate, baseCategory, discountId, meta }) {
             basePricingSheet.calculation.push({
                 amount,
                 category: DeliveryPricingRowCategory.Tax,
+                baseCategory,
+                discountId,
                 isNetPrice: false,
                 isTaxable: false,
                 meta,
@@ -54,17 +56,20 @@ export const DeliveryPricingSheet = (params) => {
                 .filter(Boolean);
             return [...new Set(discountIds)]
                 .map((discountId) => {
-                const { currencyCode, amount } = basePricingSheet.total({
-                    category: DeliveryPricingRowCategory.Discount,
+                const taxAmount = pricingSheet.taxSum({
+                    baseCategory: DeliveryPricingRowCategory.Discount,
                     discountId,
                 });
+                const amount = pricingSheet.sum({ category: DeliveryPricingRowCategory.Discount, discountId }) + taxAmount;
                 if (!amount) {
                     return null;
                 }
                 return {
                     discountId,
                     amount: Math.round(amount),
-                    currencyCode,
+                    currencyCode: pricingSheet.currencyCode,
+                    isTaxable: taxAmount !== 0,
+                    isNetPrice: false,
                 };
             })
                 .filter(Boolean);

package/lib/directors/EnrollmentAdapter.d.ts

@@ -2,6 +2,7 @@ import { type IBaseAdapter } from '@unchainedshop/utils';
 import { type Enrollment, type EnrollmentOrderPositionTemplate, type EnrollmentPeriod, type EnrollmentPlan } from '@unchainedshop/core-enrollments';
 import type { Product, ProductPlan } from '@unchainedshop/core-products';
 import type { OrderPosition } from '@unchainedshop/core-orders';
+import type { Modules } from '../modules.ts';
 export interface EnrollmentContext {
     enrollment: Enrollment;
     product: Product;
@@ -16,11 +17,20 @@ export interface EnrollmentAdapterActions {
     isOverdue: () => Promise<boolean>;
     isValidForActivation: () => Promise<boolean>;
     nextPeriod: () => Promise<EnrollmentPeriod | null>;
+    terminationDate: (params: {
+        referenceDate: Date;
+    }) => Promise<Date | null>;
+    transformPlanToNewPlan: (params: {
+        plan: EnrollmentPlan;
+    }) => Promise<EnrollmentPlan | null>;
 }
 export type IEnrollmentAdapter = IBaseAdapter & {
+    orderIndex?: number;
     isActivatedFor: (productPlan?: ProductPlan) => boolean;
     transformOrderItemToEnrollmentPlan: (orderPosition: OrderPosition, unchainedAPI: any) => Promise<EnrollmentPlan>;
-    actions: (params: EnrollmentContext) => EnrollmentAdapterActions;
+    actions: (params: EnrollmentContext & {
+        modules: Modules;
+    }) => EnrollmentAdapterActions;
 };
 export declare const periodForReferenceDate: (referenceDate: Date, intervalCount?: number, interval?: string) => {
     start: Date;

package/lib/directors/EnrollmentAdapter.js

@@ -24,7 +24,6 @@ export const EnrollmentAdapter = {
     },
     transformOrderItemToEnrollmentPlan: async (item) => {
         return {
-            configuration: item.configuration,
             productId: item.productId,
             quantity: item.quantity,
         };
@@ -57,11 +56,17 @@ export const EnrollmentAdapter = {
                     }
                     return acc;
                 }, referenceDate);
-                return {
+                const period = {
                     ...periodForReferenceDate(lastEnd, plan.billingIntervalCount, plan.billingInterval),
                     isTrial: false,
                 };
+                if (enrollment?.expires && period.start.getTime() >= new Date(enrollment.expires).getTime()) {
+                    return null;
+                }
+                return period;
             },
+            terminationDate: async ({ referenceDate }) => referenceDate,
+            transformPlanToNewPlan: async () => null,
         };
     },
 };

package/lib/directors/EnrollmentDirector.d.ts

@@ -1,7 +1,7 @@
-import { type IBaseDirector } from '@unchainedshop/utils';
+import type { IBaseDirector } from '@unchainedshop/utils';
 import type { EnrollmentAdapterActions, EnrollmentContext, IEnrollmentAdapter } from './EnrollmentAdapter.ts';
 import type { OrderPosition } from '@unchainedshop/core-orders';
-import type { Product } from '@unchainedshop/core-products';
+import type { Product, ProductPlan } from '@unchainedshop/core-products';
 import type { Enrollment } from '@unchainedshop/core-enrollments';
 import type { Modules } from '../modules.ts';
 export type IEnrollmentDirector = IBaseDirector<IEnrollmentAdapter> & {
@@ -9,6 +9,7 @@ export type IEnrollmentDirector = IBaseDirector<IEnrollmentAdapter> & {
         orderPosition: OrderPosition;
         product: Product;
     }, doc: Omit<Enrollment, 'configuration' | 'productId' | 'quantity' | 'status' | 'periods' | 'log' | '_id' | 'created'>, unchainedAPI: any) => Promise<Omit<Enrollment, 'status' | 'periods' | 'log' | '_id' | 'created'> & Pick<Partial<Enrollment>, '_id' | 'created'>>;
+    findSupportedAdapter: (productPlan?: ProductPlan) => IEnrollmentAdapter | null;
     actions: (enrollmentContext: EnrollmentContext, unchainedAPI: {
         modules: Modules;
     }) => Promise<EnrollmentAdapterActions>;

package/lib/directors/EnrollmentDirector.js

@@ -1,11 +1,8 @@
-import { BaseDirector } from '@unchainedshop/utils';
 import { EnrollmentAdapter } from "./EnrollmentAdapter.js";
 import { createLogger } from '@unchainedshop/logger';
-import { pluginRegistry } from "../plugins/PluginRegistry.js";
+import { registryDirector } from "./registryDirector.js";
+import { createServiceError } from "../errors.js";
 const logger = createLogger('unchained:core');
-const baseDirector = BaseDirector('EnrollmentDirector', {
-    adapterSortKey: 'orderIndex',
-});
 const findAppropriateAdapters = (productPlan) => EnrollmentDirector.getAdapters({
     adapterFilter: (Adapter) => {
         const activated = Adapter.isActivatedFor(productPlan);
@@ -16,32 +13,25 @@ const findAppropriateAdapters = (productPlan) => EnrollmentDirector.getAdapters(
     },
 });
 export const EnrollmentDirector = {
-    ...baseDirector,
-    getAdapter: (key) => {
-        const adapters = pluginRegistry.getAdapters(EnrollmentAdapter.adapterType);
-        return adapters.find((adapter) => adapter.key === key) || null;
-    },
-    getAdapters: ({ adapterFilter } = {}) => {
-        const adapters = pluginRegistry.getAdapters(EnrollmentAdapter.adapterType);
-        return adapters.filter(adapterFilter || (() => true));
-    },
+    ...registryDirector(EnrollmentAdapter.adapterType),
+    findSupportedAdapter: (productPlan) => findAppropriateAdapters(productPlan)?.[0] || null,
     transformOrderItemToEnrollment: async ({ orderPosition, product }, doc, unchainedAPI) => {
-        const Adapter = findAppropriateAdapters(product.plan)?.[0];
+        const Adapter = EnrollmentDirector.findSupportedAdapter(product.plan);
         if (!Adapter) {
-            throw new Error('No suitable enrollment plugin available for this item');
+            throw createServiceError('EnrollmentPlanNotSupportedError', 'No suitable enrollment plugin available for this item');
         }
         const enrollmentPlan = await Adapter.transformOrderItemToEnrollmentPlan(orderPosition, unchainedAPI);
         return {
             ...doc,
             ...enrollmentPlan,
-            configuration: [],
+            configuration: enrollmentPlan.configuration ?? [],
         };
     },
     actions: async (enrollmentContext, unchainedAPI) => {
         const context = { ...enrollmentContext, ...unchainedAPI };
-        const Adapter = findAppropriateAdapters(enrollmentContext.product.plan)?.[0];
+        const Adapter = EnrollmentDirector.findSupportedAdapter(enrollmentContext.product.plan);
         if (!Adapter) {
-            throw new Error('No suitable enrollment plugin available for this plan configuration');
+            throw createServiceError('EnrollmentPlanNotSupportedError', 'No suitable enrollment plugin available for this plan configuration');
         }
         const adapter = Adapter.actions(context);
         return adapter;

package/lib/directors/FileDirector.d.ts

@@ -1,10 +1,10 @@
 import type { IFileAdapter, UploadedFile } from '@unchainedshop/core-files';
 export type UploadFileCallback<UnchainedAPI = unknown> = (file: UploadedFile, unchainedAPI: UnchainedAPI) => Promise<void>;
 export declare const FileDirector: {
-    getAdapter: (key: string) => IFileAdapter<unknown> | null;
-    getAdapters: (options?: {
-        adapterFilter?: (adapter: IFileAdapter) => boolean;
-    }) => IFileAdapter<unknown>[];
     registerFileUploadCallback<UnchainedAPI>(directoryName: string, fn: UploadFileCallback<UnchainedAPI>): void;
     getFileUploadCallback(directoryName: string): UploadFileCallback<unknown> | null;
+    getAdapters: (options?: {
+        adapterFilter?: ((adapter: IFileAdapter<unknown>) => boolean) | undefined;
+    } | undefined) => IFileAdapter<unknown>[];
+    getAdapter: (key: string) => IFileAdapter<unknown> | null;
 };

package/lib/directors/FileDirector.js

@@ -1,19 +1,8 @@
-import { BaseDirector } from '@unchainedshop/utils';
 import { FileAdapter } from '@unchainedshop/core-files';
-import { pluginRegistry } from "../plugins/PluginRegistry.js";
+import { registryDirector } from "./registryDirector.js";
 const FileUploadRegistry = new Map();
-const baseDirector = BaseDirector('FileDirector');
 export const FileDirector = {
-    ...baseDirector,
-    getAdapter: (key) => {
-        const adapters = pluginRegistry.getAdapters(FileAdapter.adapterType);
-        return adapters.find((adapter) => adapter.key === key) || null;
-    },
-    getAdapters: (options) => {
-        const { adapterFilter } = options || {};
-        const adapters = pluginRegistry.getAdapters(FileAdapter.adapterType);
-        return adapters.filter(adapterFilter || (() => true));
-    },
+    ...registryDirector(FileAdapter.adapterType),
     registerFileUploadCallback(directoryName, fn) {
         if (!FileUploadRegistry.has(directoryName)) {
             FileUploadRegistry.set(directoryName, fn);

package/lib/directors/FilterDirector.d.ts

@@ -1,4 +1,4 @@
-import { type IBaseDirector } from '@unchainedshop/utils';
+import type { IBaseDirector } from '@unchainedshop/utils';
 import type { FilterAdapterActions, FilterContext, IFilterAdapter } from './FilterAdapter.ts';
 import { type Filter, type SearchConfiguration, type SearchFilterQuery, type SearchQuery } from '@unchainedshop/core-filters';
 import type { Modules } from '../modules.ts';

package/lib/directors/FilterDirector.js

@@ -1,25 +1,13 @@
 import { mongodb } from '@unchainedshop/mongodb';
-import { BaseDirector } from '@unchainedshop/utils';
-import { filtersSettings, FilterType, } from '@unchainedshop/core-filters';
-import { pluginRegistry } from "../plugins/PluginRegistry.js";
+import { filterCacheGeneration, filtersSettings, FilterType, } from '@unchainedshop/core-filters';
+import { registryDirector } from "./registryDirector.js";
 import { FilterAdapter } from "./FilterAdapter.js";
 export const parseQueryArray = (query) => (query || []).reduce((accumulator, { key, value }) => ({
     ...accumulator,
     [key]: accumulator[key] ? accumulator[key].concat(value) : [value],
 }), {});
-const baseDirector = BaseDirector('FilterDirector', {
-    adapterSortKey: 'orderIndex',
-});
 export const FilterDirector = {
-    ...baseDirector,
-    getAdapter: (key) => {
-        const adapters = pluginRegistry.getAdapters(FilterAdapter.adapterType);
-        return adapters.find((adapter) => adapter.key === key) || null;
-    },
-    getAdapters: ({ adapterFilter } = {}) => {
-        const adapters = pluginRegistry.getAdapters(FilterAdapter.adapterType);
-        return adapters.filter(adapterFilter || (() => true));
-    },
+    ...registryDirector(FilterAdapter.adapterType),
     actions: async (filterContext, unchainedAPI) => {
         const context = { ...filterContext, ...unchainedAPI };
         const adapters = FilterDirector.getAdapters().map((Adapter) => Adapter.actions(context));
@@ -80,18 +68,19 @@ export const FilterDirector = {
     },
     async buildProductIdMap(filter, unchainedAPI) {
         const allProductIds = await this.findProductIds(filter, {}, unchainedAPI);
-        const productIdsMap = filter.type === FilterType.SWITCH
-            ? {
-                true: await this.findProductIds(filter, { value: true }, unchainedAPI),
-                false: await this.findProductIds(filter, { value: { $in: [null, false] } }, unchainedAPI),
-            }
-            : await (filter.options || []).reduce(async (accumulatorPromise, option) => {
-                const accumulator = await accumulatorPromise;
-                return {
-                    ...accumulator,
-                    [option]: await this.findProductIds(filter, { value: option }, unchainedAPI),
-                };
-            }, Promise.resolve({}));
+        if (filter.type === FilterType.SWITCH) {
+            return [
+                allProductIds,
+                {
+                    true: await this.findProductIds(filter, { value: true }, unchainedAPI),
+                    false: await this.findProductIds(filter, { value: { $in: [null, false] } }, unchainedAPI),
+                },
+            ];
+        }
+        const productIdsMap = Object.create(null);
+        for (const option of filter.options || []) {
+            productIdsMap[option] = await this.findProductIds(filter, { value: option }, unchainedAPI);
+        }
         return [allProductIds, productIdsMap];
     },
     async filterProductIds(filter, { values, forceLiveCollection }, unchainedAPI) {
@@ -102,11 +91,13 @@ export const FilterDirector = {
             return new Set(allProductIds);
         const result = new Set();
         for (const key of filteredKeys) {
+            if (!Object.hasOwn(keyToProductIdMap, key))
+                continue;
             const additionalValues = keyToProductIdMap[key];
-            if (additionalValues) {
-                for (const val of additionalValues)
-                    result.add(val);
-            }
+            if (!additionalValues)
+                continue;
+            for (const val of additionalValues)
+                result.add(val);
         }
         return result;
     },
@@ -175,6 +166,8 @@ export const FilterDirector = {
         if (!filter)
             return;
         const [productIds, productIdMap] = await this.buildProductIdMap(filter, unchainedAPI);
-        await filtersSettings.setCachedProductIds(filter._id, productIds, productIdMap);
+        if (!(await unchainedAPI.modules.filters.filterExists({ filterId: filter._id })))
+            return;
+        await filtersSettings.setCachedProductIds(filter._id, productIds, productIdMap, filterCacheGeneration(filter));
     },
 };

package/lib/directors/OrderDiscountDirector.d.ts

@@ -1,16 +1,2 @@
-import type { IDiscountAdapter } from './BaseDiscountAdapter.ts';
 import type { OrderDiscountConfiguration } from './OrderDiscountConfiguration.ts';
-export declare const OrderDiscountDirector: {
-    getAdapter: (key: string) => IDiscountAdapter<OrderDiscountConfiguration> | null;
-    getAdapters: (options?: {
-        adapterFilter?: (adapter: any) => boolean;
-    }) => IDiscountAdapter<OrderDiscountConfiguration>[];
-    actions: (discountContext: import("./BaseDiscountAdapter.ts").DiscountContext, unchainedAPI: {
-        modules: import("../modules.ts").Modules;
-    }) => Promise<{
-        resolveDiscountAdapterFromStaticCode: (params: {
-            code: string;
-        }) => Promise<IDiscountAdapter<OrderDiscountConfiguration> | null>;
-        findSystemDiscounts: () => Promise<string[]>;
-    }>;
-};
+export declare const OrderDiscountDirector: import("./BaseDiscountDirector.ts").IDiscountDirector<OrderDiscountConfiguration>;

package/lib/directors/OrderDiscountDirector.js

@@ -1,15 +1,3 @@
 import { BaseDiscountDirector } from "./BaseDiscountDirector.js";
 import { OrderDiscountAdapter } from "./OrderDiscountAdapter.js";
-import { pluginRegistry } from "../plugins/PluginRegistry.js";
-const baseDirector = BaseDiscountDirector('OrderDiscountDirector');
-export const OrderDiscountDirector = {
-    ...baseDirector,
-    getAdapter: (key) => {
-        const adapters = pluginRegistry.getAdapters(OrderDiscountAdapter.adapterType);
-        return adapters.find((adapter) => adapter.key === key) || null;
-    },
-    getAdapters: (options) => {
-        const adapters = pluginRegistry.getAdapters(OrderDiscountAdapter.adapterType);
-        return adapters.filter(options?.adapterFilter || (() => true));
-    },
-};
+export const OrderDiscountDirector = BaseDiscountDirector(OrderDiscountAdapter.adapterType);