@vendure/core 2.2.0-next.2 → 2.2.0-next.4

package/dist/config/entity/entity-duplicator.d.ts

@@ -0,0 +1,166 @@
+import { ConfigArg, Permission } from '@vendure/common/lib/generated-types';
+import { ID } from '@vendure/common/lib/shared-types';
+import { RequestContext } from '../../api/index';
+import { ConfigArgs, ConfigArgValues, ConfigurableOperationDef, ConfigurableOperationDefOptions } from '../../common/configurable-operation';
+import { VendureEntity } from '../../entity/index';
+/**
+ * @description
+ * A function which performs the duplication of an entity.
+ *
+ * @docsPage EntityDuplicator
+ * @docsCategory configuration
+ * @since 2.2.0
+ */
+export type DuplicateEntityFn<T extends ConfigArgs> = (input: {
+    ctx: RequestContext;
+    entityName: string;
+    id: ID;
+    args: ConfigArgValues<T>;
+}) => Promise<VendureEntity>;
+/**
+ * @description
+ * Configuration for creating a new EntityDuplicator.
+ *
+ * @docsPage EntityDuplicator
+ * @docsCategory configuration
+ * @since 2.2.0
+ */
+export interface EntityDuplicatorConfig<T extends ConfigArgs> extends ConfigurableOperationDefOptions<T> {
+    /**
+     * @description
+     * The permissions required in order to execute this duplicator. If an array is passed,
+     * then the administrator must have at least one of the permissions in the array.
+     */
+    requiresPermission: Array<Permission | string> | Permission | string;
+    /**
+     * @description
+     * The entities for which this duplicator is able to duplicate.
+     */
+    forEntities: string[];
+    /**
+     * @description
+     * The function which performs the duplication.
+     *
+     * @example
+     * ```ts
+     * duplicate: async input => {
+     *   const { ctx, id, args } = input;
+     *
+     *   // perform the duplication logic here
+     *
+     *   return newEntity;
+     * }
+     * ```
+     */
+    duplicate: DuplicateEntityFn<T>;
+}
+/**
+ * @description
+ * An EntityDuplicator is used to define the logic for duplicating entities when the `duplicateEntity` mutation is called.
+ * This allows you to add support for duplication of both core and custom entities.
+ *
+ * @example
+ * ```ts title=src/config/custom-collection-duplicator.ts
+ * import { Collection, LanguageCode, Permission
+ *   EntityDuplicator, TransactionalConnection, CollectionService } from '\@vendure/core';
+ *
+ * let collectionService: CollectionService;
+ * let connection: TransactionalConnection;
+ *
+ * // This is just an example - we already ship with a built-in duplicator for Collections.
+ * const customCollectionDuplicator = new EntityDuplicator({
+ *     code: 'custom-collection-duplicator',
+ *     description: [{ languageCode: LanguageCode.en, value: 'Custom collection duplicator' }],
+ *     args: {
+ *         throwError: {
+ *             type: 'boolean',
+ *             defaultValue: false,
+ *         },
+ *     },
+ *     forEntities: ['Collection'],
+ *     requiresPermission: [Permission.UpdateCollection],
+ *     init(injector) {
+ *         collectionService = injector.get(CollectionService);
+ *         connection = injector.get(TransactionalConnection);
+ *     },
+ *     duplicate: async input => {
+ *         const { ctx, id, args } = input;
+ *
+ *         const original = await connection.getEntityOrThrow(ctx, Collection, id, {
+ *             relations: {
+ *                 assets: true,
+ *                 featuredAsset: true,
+ *             },
+ *         });
+ *         const newCollection = await collectionService.create(ctx, {
+ *             isPrivate: original.isPrivate,
+ *             customFields: original.customFields,
+ *             assetIds: original.assets.map(a => a.id),
+ *             featuredAssetId: original.featuredAsset?.id,
+ *             parentId: original.parentId,
+ *             filters: original.filters.map(f => ({
+ *                 code: f.code,
+ *                 arguments: f.args,
+ *             })),
+ *             inheritFilters: original.inheritFilters,
+ *             translations: original.translations.map(t => ({
+ *                 languageCode: t.languageCode,
+ *                 name: `${t.name} (copy)`,
+ *                 slug: `${t.slug}-copy`,
+ *                 description: t.description,
+ *                 customFields: t.customFields,
+ *             })),
+ *         });
+ *
+ *         if (args.throwError) {
+ *             // If an error is thrown at any point during the duplication process, the entire
+ *             // transaction will get automatically rolled back, and the mutation will return
+ *             // an ErrorResponse containing the error message.
+ *             throw new Error('Dummy error');
+ *         }
+ *
+ *         return newCollection;
+ *     },
+ * });
+ * ```
+ *
+ * The duplicator then gets passed to your VendureConfig object:
+ *
+ * ```ts title=src/vendure-config.ts
+ * import { VendureConfig, defaultEntityDuplicators } from '\@vendure/core';
+ * import { customCollectionDuplicator } from './config/custom-collection-duplicator';
+ *
+ * export const config: VendureConfig = {
+ *    // ...
+ *    entityOptions: {
+ *      entityDuplicators: [
+ *          ...defaultEntityDuplicators,
+ *          customCollectionDuplicator,
+ *      ],
+ *    },
+ * };
+ * ```
+ *
+ * @docsPage EntityDuplicator
+ * @docsWeight 0
+ * @docsCategory configuration
+ * @since 2.2.0
+ */
+export declare class EntityDuplicator<T extends ConfigArgs = ConfigArgs> extends ConfigurableOperationDef<T> {
+    private _forEntities;
+    private _requiresPermission;
+    private duplicateFn;
+    /** @internal */
+    canDuplicate(entityName: string): boolean;
+    /** @internal */
+    get forEntities(): string[];
+    /** @internal */
+    get requiresPermission(): Permission[];
+    constructor(config: EntityDuplicatorConfig<T>);
+    duplicate(input: {
+        ctx: RequestContext;
+        entityName: string;
+        id: ID;
+        args: ConfigArg[];
+    }): Promise<VendureEntity>;
+}

package/dist/config/entity/entity-duplicator.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityDuplicator = void 0;
+const configurable_operation_1 = require("../../common/configurable-operation");
+/**
+ * @description
+ * An EntityDuplicator is used to define the logic for duplicating entities when the `duplicateEntity` mutation is called.
+ * This allows you to add support for duplication of both core and custom entities.
+ *
+ * @example
+ * ```ts title=src/config/custom-collection-duplicator.ts
+ * import { Collection, LanguageCode, Permission
+ *   EntityDuplicator, TransactionalConnection, CollectionService } from '\@vendure/core';
+ *
+ * let collectionService: CollectionService;
+ * let connection: TransactionalConnection;
+ *
+ * // This is just an example - we already ship with a built-in duplicator for Collections.
+ * const customCollectionDuplicator = new EntityDuplicator({
+ *     code: 'custom-collection-duplicator',
+ *     description: [{ languageCode: LanguageCode.en, value: 'Custom collection duplicator' }],
+ *     args: {
+ *         throwError: {
+ *             type: 'boolean',
+ *             defaultValue: false,
+ *         },
+ *     },
+ *     forEntities: ['Collection'],
+ *     requiresPermission: [Permission.UpdateCollection],
+ *     init(injector) {
+ *         collectionService = injector.get(CollectionService);
+ *         connection = injector.get(TransactionalConnection);
+ *     },
+ *     duplicate: async input => {
+ *         const { ctx, id, args } = input;
+ *
+ *         const original = await connection.getEntityOrThrow(ctx, Collection, id, {
+ *             relations: {
+ *                 assets: true,
+ *                 featuredAsset: true,
+ *             },
+ *         });
+ *         const newCollection = await collectionService.create(ctx, {
+ *             isPrivate: original.isPrivate,
+ *             customFields: original.customFields,
+ *             assetIds: original.assets.map(a => a.id),
+ *             featuredAssetId: original.featuredAsset?.id,
+ *             parentId: original.parentId,
+ *             filters: original.filters.map(f => ({
+ *                 code: f.code,
+ *                 arguments: f.args,
+ *             })),
+ *             inheritFilters: original.inheritFilters,
+ *             translations: original.translations.map(t => ({
+ *                 languageCode: t.languageCode,
+ *                 name: `${t.name} (copy)`,
+ *                 slug: `${t.slug}-copy`,
+ *                 description: t.description,
+ *                 customFields: t.customFields,
+ *             })),
+ *         });
+ *
+ *         if (args.throwError) {
+ *             // If an error is thrown at any point during the duplication process, the entire
+ *             // transaction will get automatically rolled back, and the mutation will return
+ *             // an ErrorResponse containing the error message.
+ *             throw new Error('Dummy error');
+ *         }
+ *
+ *         return newCollection;
+ *     },
+ * });
+ * ```
+ *
+ * The duplicator then gets passed to your VendureConfig object:
+ *
+ * ```ts title=src/vendure-config.ts
+ * import { VendureConfig, defaultEntityDuplicators } from '\@vendure/core';
+ * import { customCollectionDuplicator } from './config/custom-collection-duplicator';
+ *
+ * export const config: VendureConfig = {
+ *    // ...
+ *    entityOptions: {
+ *      entityDuplicators: [
+ *          ...defaultEntityDuplicators,
+ *          customCollectionDuplicator,
+ *      ],
+ *    },
+ * };
+ * ```
+ *
+ * @docsPage EntityDuplicator
+ * @docsWeight 0
+ * @docsCategory configuration
+ * @since 2.2.0
+ */
+class EntityDuplicator extends configurable_operation_1.ConfigurableOperationDef {
+    /** @internal */
+    canDuplicate(entityName) {
+        return this._forEntities.includes(entityName);
+    }
+    /** @internal */
+    get forEntities() {
+        return this._forEntities;
+    }
+    /** @internal */
+    get requiresPermission() {
+        return (Array.isArray(this._requiresPermission)
+            ? this._requiresPermission
+            : [this._requiresPermission]);
+    }
+    constructor(config) {
+        super(config);
+        this._forEntities = config.forEntities;
+        this._requiresPermission = config.requiresPermission;
+        this.duplicateFn = config.duplicate;
+    }
+    duplicate(input) {
+        return this.duplicateFn(Object.assign(Object.assign({}, input), { args: this.argsArrayToHash(input.args) }));
+    }
+}
+exports.EntityDuplicator = EntityDuplicator;
+//# sourceMappingURL=entity-duplicator.js.map

package/dist/config/entity/entity-duplicator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-duplicator.js","sourceRoot":"","sources":["../../../src/config/entity/entity-duplicator.ts"],"names":[],"mappings":";;;AAIA,gFAK6C;AAwD7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2FG;AACH,MAAa,gBAAoD,SAAQ,iDAA2B;IAKhG,gBAAgB;IAChB,YAAY,CAAC,UAAkB;QAC3B,OAAO,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;IAClD,CAAC;IAED,gBAAgB;IAChB,IAAI,WAAW;QACX,OAAO,IAAI,CAAC,YAAY,CAAC;IAC7B,CAAC;IAED,gBAAgB;IAChB,IAAI,kBAAkB;QAClB,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,mBAAmB,CAAC;YAC3C,CAAC,CAAC,IAAI,CAAC,mBAAmB;YAC1B,CAAC,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAwB,CAAC;IAC7D,CAAC;IAED,YAAY,MAAiC;QACzC,KAAK,CAAC,MAAM,CAAC,CAAC;QACd,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC,WAAW,CAAC;QACvC,IAAI,CAAC,mBAAmB,GAAG,MAAM,CAAC,kBAAkB,CAAC;QACrD,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC,SAAS,CAAC;IACxC,CAAC;IAED,SAAS,CAAC,KAKT;QACG,OAAO,IAAI,CAAC,WAAW,iCAChB,KAAK,KACR,IAAI,EAAE,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,IAAI,CAAC,IACxC,CAAC;IACP,CAAC;CACJ;AAxCD,4CAwCC"}

package/dist/config/entity/entity-duplicators/collection-duplicator.d.ts

@@ -0,0 +1,6 @@
+import { EntityDuplicator } from '../entity-duplicator';
+/**
+ * @description
+ * Duplicates a Collection
+ */
+export declare const collectionDuplicator: EntityDuplicator<{}>;

package/dist/config/entity/entity-duplicators/collection-duplicator.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectionDuplicator = void 0;
+const generated_types_1 = require("@vendure/common/lib/generated-types");
+const index_1 = require("../../../connection/index");
+const index_2 = require("../../../entity/index");
+const index_3 = require("../../../service/index");
+const entity_duplicator_1 = require("../entity-duplicator");
+let connection;
+let collectionService;
+/**
+ * @description
+ * Duplicates a Collection
+ */
+exports.collectionDuplicator = new entity_duplicator_1.EntityDuplicator({
+    code: 'collection-duplicator',
+    description: [
+        {
+            languageCode: generated_types_1.LanguageCode.en,
+            value: 'Default duplicator for Collections',
+        },
+    ],
+    requiresPermission: [generated_types_1.Permission.CreateCollection, generated_types_1.Permission.CreateCatalog],
+    forEntities: ['Collection'],
+    args: {},
+    init(injector) {
+        connection = injector.get(index_1.TransactionalConnection);
+        collectionService = injector.get(index_3.CollectionService);
+    },
+    async duplicate({ ctx, id }) {
+        const collection = await connection.getEntityOrThrow(ctx, index_2.Collection, id, {
+            relations: {
+                featuredAsset: true,
+                assets: true,
+                channels: true,
+            },
+        });
+        const translations = collection.translations.map(translation => {
+            return {
+                name: translation.name + ' (copy)',
+                slug: translation.slug + '-copy',
+                description: translation.description,
+                languageCode: translation.languageCode,
+                customFields: translation.customFields,
+            };
+        });
+        const collectionInput = {
+            featuredAssetId: collection.featuredAsset.id,
+            isPrivate: true,
+            assetIds: collection.assets.map(value => value.assetId),
+            parentId: collection.parentId,
+            translations,
+            customFields: collection.customFields,
+            filters: collection.filters.map(filter => ({
+                code: filter.code,
+                arguments: filter.args,
+            })),
+        };
+        const duplicatedCollection = await collectionService.create(ctx, collectionInput);
+        return duplicatedCollection;
+    },
+});
+//# sourceMappingURL=collection-duplicator.js.map

package/dist/config/entity/entity-duplicators/collection-duplicator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection-duplicator.js","sourceRoot":"","sources":["../../../../src/config/entity/entity-duplicators/collection-duplicator.ts"],"names":[],"mappings":";;;AAAA,yEAK6C;AAG7C,qDAAoE;AACpE,iDAAmD;AACnD,kDAA2D;AAC3D,4DAAwD;AAExD,IAAI,UAAmC,CAAC;AACxC,IAAI,iBAAoC,CAAC;AAEzC;;;GAGG;AACU,QAAA,oBAAoB,GAAG,IAAI,oCAAgB,CAAC;IACrD,IAAI,EAAE,uBAAuB;IAC7B,WAAW,EAAE;QACT;YACI,YAAY,EAAE,8BAAY,CAAC,EAAE;YAC7B,KAAK,EAAE,oCAAoC;SAC9C;KACJ;IACD,kBAAkB,EAAE,CAAC,4BAAU,CAAC,gBAAgB,EAAE,4BAAU,CAAC,aAAa,CAAC;IAC3E,WAAW,EAAE,CAAC,YAAY,CAAC;IAC3B,IAAI,EAAE,EAAE;IACR,IAAI,CAAC,QAAkB;QACnB,UAAU,GAAG,QAAQ,CAAC,GAAG,CAAC,+BAAuB,CAAC,CAAC;QACnD,iBAAiB,GAAG,QAAQ,CAAC,GAAG,CAAC,yBAAiB,CAAC,CAAC;IACxD,CAAC;IACD,KAAK,CAAC,SAAS,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE;QACvB,MAAM,UAAU,GAAG,MAAM,UAAU,CAAC,gBAAgB,CAAC,GAAG,EAAE,kBAAU,EAAE,EAAE,EAAE;YACtE,SAAS,EAAE;gBACP,aAAa,EAAE,IAAI;gBACnB,MAAM,EAAE,IAAI;gBACZ,QAAQ,EAAE,IAAI;aACjB;SACJ,CAAC,CAAC;QACH,MAAM,YAAY,GAAuC,UAAU,CAAC,YAAY,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE;YAC/F,OAAO;gBACH,IAAI,EAAE,WAAW,CAAC,IAAI,GAAG,SAAS;gBAClC,IAAI,EAAE,WAAW,CAAC,IAAI,GAAG,OAAO;gBAChC,WAAW,EAAE,WAAW,CAAC,WAAW;gBACpC,YAAY,EAAE,WAAW,CAAC,YAAY;gBACtC,YAAY,EAAE,WAAW,CAAC,YAAY;aACzC,CAAC;QACN,CAAC,CAAC,CAAC;QACH,MAAM,eAAe,GAA0B;YAC3C,eAAe,EAAE,UAAU,CAAC,aAAa,CAAC,EAAE;YAC5C,SAAS,EAAE,IAAI;YACf,QAAQ,EAAE,UAAU,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC;YACvD,QAAQ,EAAE,UAAU,CAAC,QAAQ;YAC7B,YAAY;YACZ,YAAY,EAAE,UAAU,CAAC,YAAY;YACrC,OAAO,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;gBACvC,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,SAAS,EAAE,MAAM,CAAC,IAAI;aACzB,CAAC,CAAC;SACN,CAAC;QAEF,MAAM,oBAAoB,GAAG,MAAM,iBAAiB,CAAC,MAAM,CAAC,GAAG,EAAE,eAAe,CAAC,CAAC;QAClF,OAAO,oBAAoB,CAAC;IAChC,CAAC;CACJ,CAAC,CAAC"}

package/dist/config/entity/entity-duplicators/facet-duplicator.d.ts

@@ -0,0 +1,16 @@
+import { LanguageCode } from '@vendure/common/lib/generated-types';
+import { EntityDuplicator } from '../entity-duplicator';
+/**
+ * @description
+ * Duplicates a Facet
+ */
+export declare const facetDuplicator: EntityDuplicator<{
+    includeFacetValues: {
+        type: "boolean";
+        defaultValue: true;
+        label: {
+            languageCode: LanguageCode.en;
+            value: string;
+        }[];
+    };
+}>;

package/dist/config/entity/entity-duplicators/facet-duplicator.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.facetDuplicator = void 0;
+const generated_types_1 = require("@vendure/common/lib/generated-types");
+const index_1 = require("../../../connection/index");
+const index_2 = require("../../../entity/index");
+const index_3 = require("../../../service/index");
+const entity_duplicator_1 = require("../entity-duplicator");
+let connection;
+let facetService;
+let facetValueService;
+/**
+ * @description
+ * Duplicates a Facet
+ */
+exports.facetDuplicator = new entity_duplicator_1.EntityDuplicator({
+    code: 'facet-duplicator',
+    description: [
+        {
+            languageCode: generated_types_1.LanguageCode.en,
+            value: 'Default duplicator for Facets',
+        },
+    ],
+    requiresPermission: [generated_types_1.Permission.CreateFacet, generated_types_1.Permission.CreateCatalog],
+    forEntities: ['Facet'],
+    args: {
+        includeFacetValues: {
+            type: 'boolean',
+            defaultValue: true,
+            label: [{ languageCode: generated_types_1.LanguageCode.en, value: 'Include facet values' }],
+        },
+    },
+    init(injector) {
+        connection = injector.get(index_1.TransactionalConnection);
+        facetService = injector.get(index_3.FacetService);
+        facetValueService = injector.get(index_3.FacetValueService);
+    },
+    async duplicate({ ctx, id, args }) {
+        const facet = await connection.getEntityOrThrow(ctx, index_2.Facet, id, {
+            relations: {
+                values: true,
+            },
+        });
+        const translations = facet.translations.map(translation => {
+            return {
+                name: translation.name + ' (copy)',
+                languageCode: translation.languageCode,
+                customFields: translation.customFields,
+            };
+        });
+        const facetInput = {
+            isPrivate: true,
+            translations,
+            customFields: facet.customFields,
+            code: facet.code + '-copy',
+        };
+        const duplicatedFacet = await facetService.create(ctx, facetInput);
+        if (args.includeFacetValues) {
+            if (facet.values.length) {
+                for (const value of facet.values) {
+                    const newValue = await facetValueService.create(ctx, duplicatedFacet, {
+                        code: value.code + '-copy',
+                        translations: value.translations.map(translation => ({
+                            name: translation.name + ' (copy)',
+                            languageCode: translation.languageCode,
+                            customFields: translation.customFields,
+                        })),
+                        facetId: duplicatedFacet.id,
+                        customFields: value.customFields,
+                    });
+                    duplicatedFacet.values.push(newValue);
+                }
+            }
+        }
+        return duplicatedFacet;
+    },
+});
+//# sourceMappingURL=facet-duplicator.js.map

package/dist/config/entity/entity-duplicators/facet-duplicator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"facet-duplicator.js","sourceRoot":"","sources":["../../../../src/config/entity/entity-duplicators/facet-duplicator.ts"],"names":[],"mappings":";;;AAAA,yEAK6C;AAG7C,qDAAoE;AACpE,iDAA8C;AAC9C,kDAAyE;AACzE,4DAAwD;AAExD,IAAI,UAAmC,CAAC;AACxC,IAAI,YAA0B,CAAC;AAC/B,IAAI,iBAAoC,CAAC;AAEzC;;;GAGG;AACU,QAAA,eAAe,GAAG,IAAI,oCAAgB,CAAC;IAChD,IAAI,EAAE,kBAAkB;IACxB,WAAW,EAAE;QACT;YACI,YAAY,EAAE,8BAAY,CAAC,EAAE;YAC7B,KAAK,EAAE,+BAA+B;SACzC;KACJ;IACD,kBAAkB,EAAE,CAAC,4BAAU,CAAC,WAAW,EAAE,4BAAU,CAAC,aAAa,CAAC;IACtE,WAAW,EAAE,CAAC,OAAO,CAAC;IACtB,IAAI,EAAE;QACF,kBAAkB,EAAE;YAChB,IAAI,EAAE,SAAS;YACf,YAAY,EAAE,IAAI;YAClB,KAAK,EAAE,CAAC,EAAE,YAAY,EAAE,8BAAY,CAAC,EAAE,EAAE,KAAK,EAAE,sBAAsB,EAAE,CAAC;SAC5E;KACJ;IACD,IAAI,CAAC,QAAkB;QACnB,UAAU,GAAG,QAAQ,CAAC,GAAG,CAAC,+BAAuB,CAAC,CAAC;QACnD,YAAY,GAAG,QAAQ,CAAC,GAAG,CAAC,oBAAY,CAAC,CAAC;QAC1C,iBAAiB,GAAG,QAAQ,CAAC,GAAG,CAAC,yBAAiB,CAAC,CAAC;IACxD,CAAC;IACD,KAAK,CAAC,SAAS,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE;QAC7B,MAAM,KAAK,GAAG,MAAM,UAAU,CAAC,gBAAgB,CAAC,GAAG,EAAE,aAAK,EAAE,EAAE,EAAE;YAC5D,SAAS,EAAE;gBACP,MAAM,EAAE,IAAI;aACf;SACJ,CAAC,CAAC;QACH,MAAM,YAAY,GAA4B,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE;YAC/E,OAAO;gBACH,IAAI,EAAE,WAAW,CAAC,IAAI,GAAG,SAAS;gBAClC,YAAY,EAAE,WAAW,CAAC,YAAY;gBACtC,YAAY,EAAE,WAAW,CAAC,YAAY;aACzC,CAAC;QACN,CAAC,CAAC,CAAC;QACH,MAAM,UAAU,GAAqB;YACjC,SAAS,EAAE,IAAI;YACf,YAAY;YACZ,YAAY,EAAE,KAAK,CAAC,YAAY;YAChC,IAAI,EAAE,KAAK,CAAC,IAAI,GAAG,OAAO;SAC7B,CAAC;QAEF,MAAM,eAAe,GAAG,MAAM,YAAY,CAAC,MAAM,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;QACnE,IAAI,IAAI,CAAC,kBAAkB,EAAE;YACzB,IAAI,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE;gBACrB,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,MAAM,EAAE;oBAC9B,MAAM,QAAQ,GAAG,MAAM,iBAAiB,CAAC,MAAM,CAAC,GAAG,EAAE,eAAe,EAAE;wBAClE,IAAI,EAAE,KAAK,CAAC,IAAI,GAAG,OAAO;wBAC1B,YAAY,EAAE,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;4BACjD,IAAI,EAAE,WAAW,CAAC,IAAI,GAAG,SAAS;4BAClC,YAAY,EAAE,WAAW,CAAC,YAAY;4BACtC,YAAY,EAAE,WAAW,CAAC,YAAY;yBACzC,CAAC,CAAC;wBACH,OAAO,EAAE,eAAe,CAAC,EAAE;wBAC3B,YAAY,EAAE,KAAK,CAAC,YAAY;qBACnC,CAAC,CAAC;oBACH,eAAe,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;iBACzC;aACJ;SACJ;QACD,OAAO,eAAe,CAAC;IAC3B,CAAC;CACJ,CAAC,CAAC"}

package/dist/config/entity/entity-duplicators/index.d.ts

@@ -0,0 +1,19 @@
+export declare const defaultEntityDuplicators: (import("../entity-duplicator").EntityDuplicator<{}> | import("../entity-duplicator").EntityDuplicator<{
+    includeFacetValues: {
+        type: "boolean";
+        defaultValue: true;
+        label: {
+            languageCode: import("@vendure/common/lib/generated-types").LanguageCode.en;
+            value: string;
+        }[];
+    };
+}> | import("../entity-duplicator").EntityDuplicator<{
+    includeVariants: {
+        type: "boolean";
+        defaultValue: true;
+        label: {
+            languageCode: import("@vendure/common/lib/generated-types").LanguageCode.en;
+            value: string;
+        }[];
+    };
+}>)[];

package/dist/config/entity/entity-duplicators/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultEntityDuplicators = void 0;
+const collection_duplicator_1 = require("./collection-duplicator");
+const facet_duplicator_1 = require("./facet-duplicator");
+const product_duplicator_1 = require("./product-duplicator");
+const promotion_duplicator_1 = require("./promotion-duplicator");
+exports.defaultEntityDuplicators = [
+    product_duplicator_1.productDuplicator,
+    collection_duplicator_1.collectionDuplicator,
+    facet_duplicator_1.facetDuplicator,
+    promotion_duplicator_1.promotionDuplicator,
+];
+//# sourceMappingURL=index.js.map

package/dist/config/entity/entity-duplicators/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/config/entity/entity-duplicators/index.ts"],"names":[],"mappings":";;;AAAA,mEAA+D;AAC/D,yDAAqD;AACrD,6DAAyD;AACzD,iEAA6D;AAEhD,QAAA,wBAAwB,GAAG;IACpC,sCAAiB;IACjB,4CAAoB;IACpB,kCAAe;IACf,0CAAmB;CACtB,CAAC"}

package/dist/config/entity/entity-duplicators/product-duplicator.d.ts

@@ -0,0 +1,16 @@
+import { LanguageCode } from '@vendure/common/lib/generated-types';
+import { EntityDuplicator } from '../entity-duplicator';
+/**
+ * @description
+ * Duplicates a Product and its associated ProductVariants.
+ */
+export declare const productDuplicator: EntityDuplicator<{
+    includeVariants: {
+        type: "boolean";
+        defaultValue: true;
+        label: {
+            languageCode: LanguageCode.en;
+            value: string;
+        }[];
+    };
+}>;