@vendure/core 1.4.5 → 1.5.0

package/cli/config/vendure-config.d.ts

@@ -0,0 +1,192 @@
+import { DynamicModule, Type } from '@nestjs/common';
+import { CorsOptions } from '@nestjs/common/interfaces/external/cors-options.interface';
+import { LanguageCode } from '@vendure/common/lib/generated-types';
+import { PluginDefinition } from 'apollo-server-core';
+import { ValidationContext } from 'graphql';
+import { ConnectionOptions } from 'typeorm';
+import { Middleware } from '../common';
+import { PermissionDefinition } from '../common/permission-definition';
+import { JobBufferStorageStrategy } from '../job-queue/job-buffer/job-buffer-storage-strategy';
+import { AssetNamingStrategy } from './asset-naming-strategy/asset-naming-strategy';
+import { AssetPreviewStrategy } from './asset-preview-strategy/asset-preview-strategy';
+import { AssetStorageStrategy } from './asset-storage-strategy/asset-storage-strategy';
+import { AuthenticationStrategy } from './auth/authentication-strategy';
+import { PasswordHashingStrategy } from './auth/password-hashing-strategy';
+import { PasswordValidationStrategy } from './auth/password-validation-strategy';
+import { CollectionFilter } from './catalog/collection-filter';
+import { ProductVariantPriceCalculationStrategy } from './catalog/product-variant-price-calculation-strategy';
+import { StockDisplayStrategy } from './catalog/stock-display-strategy';
+import { CustomFields } from './custom-field/custom-field-types';
+import { EntityIdStrategy } from './entity-id-strategy/entity-id-strategy';
+import { CustomFulfillmentProcess } from './fulfillment/custom-fulfillment-process';
+import { FulfillmentHandler } from './fulfillment/fulfillment-handler';
+import { JobQueueStrategy } from './job-queue/job-queue-strategy';
+import { VendureLogger } from './logger/vendure-logger';
+import { ChangedPriceHandlingStrategy } from './order/changed-price-handling-strategy';
+import { CustomOrderProcess } from './order/custom-order-process';
+import { OrderByCodeAccessStrategy } from './order/order-by-code-access-strategy';
+import { OrderCodeStrategy } from './order/order-code-strategy';
+import { OrderItemPriceCalculationStrategy } from './order/order-item-price-calculation-strategy';
+import { OrderMergeStrategy } from './order/order-merge-strategy';
+import { OrderPlacedStrategy } from './order/order-placed-strategy';
+import { StockAllocationStrategy } from './order/stock-allocation-strategy';
+import { CustomPaymentProcess } from './payment/custom-payment-process';
+import { PaymentMethodEligibilityChecker } from './payment/payment-method-eligibility-checker';
+import { PaymentMethodHandler } from './payment/payment-method-handler';
+import { PromotionAction } from './promotion/promotion-action';
+import { PromotionCondition } from './promotion/promotion-condition';
+import { SessionCacheStrategy } from './session-cache/session-cache-strategy';
+import { ShippingCalculator } from './shipping-method/shipping-calculator';
+import { ShippingEligibilityChecker } from './shipping-method/shipping-eligibility-checker';
+import { TaxLineCalculationStrategy } from './tax/tax-line-calculation-strategy';
+import { TaxZoneStrategy } from './tax/tax-zone-strategy';
+export interface ApiOptions {
+    hostname?: string;
+    port: number;
+    adminApiPath?: string;
+    shopApiPath?: string;
+    adminApiPlayground?: boolean | any;
+    shopApiPlayground?: boolean | any;
+    adminApiDebug?: boolean;
+    shopApiDebug?: boolean;
+    shopListQueryLimit?: number;
+    adminListQueryLimit?: number;
+    adminApiValidationRules?: Array<(context: ValidationContext) => any>;
+    shopApiValidationRules?: Array<(context: ValidationContext) => any>;
+    channelTokenKey?: string;
+    cors?: boolean | CorsOptions;
+    middleware?: Middleware[];
+    apolloServerPlugins?: PluginDefinition[];
+}
+export interface CookieOptions {
+    name?: string;
+    secret?: string;
+    path?: string;
+    domain?: string;
+    sameSite?: 'strict' | 'lax' | 'none' | boolean;
+    secure?: boolean;
+    secureProxy?: boolean;
+    httpOnly?: boolean;
+    signed?: boolean;
+    overwrite?: boolean;
+}
+export interface AuthOptions {
+    disableAuth?: boolean;
+    tokenMethod?: 'cookie' | 'bearer' | ReadonlyArray<'cookie' | 'bearer'>;
+    cookieOptions?: CookieOptions;
+    authTokenHeaderKey?: string;
+    sessionDuration?: string | number;
+    sessionCacheStrategy?: SessionCacheStrategy;
+    sessionCacheTTL?: number;
+    requireVerification?: boolean;
+    verificationTokenDuration?: string | number;
+    superadminCredentials?: SuperadminCredentials;
+    shopAuthenticationStrategy?: AuthenticationStrategy[];
+    adminAuthenticationStrategy?: AuthenticationStrategy[];
+    customPermissions?: PermissionDefinition[];
+    passwordHashingStrategy?: PasswordHashingStrategy;
+    passwordValidationStrategy?: PasswordValidationStrategy;
+}
+export interface OrderOptions {
+    orderItemsLimit?: number;
+    orderLineItemsLimit?: number;
+    orderItemPriceCalculationStrategy?: OrderItemPriceCalculationStrategy;
+    process?: Array<CustomOrderProcess<any>>;
+    stockAllocationStrategy?: StockAllocationStrategy;
+    mergeStrategy?: OrderMergeStrategy;
+    checkoutMergeStrategy?: OrderMergeStrategy;
+    orderCodeStrategy?: OrderCodeStrategy;
+    orderByCodeAccessStrategy?: OrderByCodeAccessStrategy;
+    changedPriceHandlingStrategy?: ChangedPriceHandlingStrategy;
+    orderPlacedStrategy?: OrderPlacedStrategy;
+}
+export interface AssetOptions {
+    assetNamingStrategy?: AssetNamingStrategy;
+    assetStorageStrategy?: AssetStorageStrategy;
+    assetPreviewStrategy?: AssetPreviewStrategy;
+    permittedFileTypes?: string[];
+    uploadMaxFileSize?: number;
+}
+export interface CatalogOptions {
+    collectionFilters?: Array<CollectionFilter<any>>;
+    productVariantPriceCalculationStrategy?: ProductVariantPriceCalculationStrategy;
+    stockDisplayStrategy?: StockDisplayStrategy;
+}
+export interface PromotionOptions {
+    promotionConditions?: Array<PromotionCondition<any>>;
+    promotionActions?: Array<PromotionAction<any>>;
+}
+export interface ShippingOptions {
+    shippingEligibilityCheckers?: Array<ShippingEligibilityChecker<any>>;
+    shippingCalculators?: Array<ShippingCalculator<any>>;
+    customFulfillmentProcess?: Array<CustomFulfillmentProcess<any>>;
+    fulfillmentHandlers?: Array<FulfillmentHandler<any>>;
+}
+export interface SuperadminCredentials {
+    identifier: string;
+    password: string;
+}
+export interface PaymentOptions {
+    paymentMethodHandlers: PaymentMethodHandler[];
+    paymentMethodEligibilityCheckers?: PaymentMethodEligibilityChecker[];
+    customPaymentProcess?: Array<CustomPaymentProcess<any>>;
+}
+export interface TaxOptions {
+    taxZoneStrategy?: TaxZoneStrategy;
+    taxLineCalculationStrategy?: TaxLineCalculationStrategy;
+}
+export interface ImportExportOptions {
+    importAssetsDir?: string;
+}
+export interface JobQueueOptions {
+    jobQueueStrategy?: JobQueueStrategy;
+    jobBufferStorageStrategy?: JobBufferStorageStrategy;
+    activeQueues?: string[];
+    enableWorkerHealthCheck?: boolean;
+    prefix?: string;
+}
+export interface EntityOptions {
+    entityIdStrategy?: EntityIdStrategy<any>;
+    channelCacheTtl?: number;
+    zoneCacheTtl?: number;
+}
+export interface VendureConfig {
+    apiOptions: ApiOptions;
+    assetOptions?: AssetOptions;
+    authOptions: AuthOptions;
+    catalogOptions?: CatalogOptions;
+    customFields?: CustomFields;
+    dbConnectionOptions: ConnectionOptions;
+    defaultChannelToken?: string | null;
+    defaultLanguageCode?: LanguageCode;
+    entityIdStrategy?: EntityIdStrategy<any>;
+    entityOptions?: EntityOptions;
+    importExportOptions?: ImportExportOptions;
+    orderOptions?: OrderOptions;
+    paymentOptions: PaymentOptions;
+    plugins?: Array<DynamicModule | Type<any>>;
+    promotionOptions?: PromotionOptions;
+    shippingOptions?: ShippingOptions;
+    logger?: VendureLogger;
+    taxOptions?: TaxOptions;
+    jobQueueOptions?: JobQueueOptions;
+}
+export interface RuntimeVendureConfig extends Required<VendureConfig> {
+    apiOptions: Required<ApiOptions>;
+    assetOptions: Required<AssetOptions>;
+    authOptions: Required<AuthOptions>;
+    catalogOptions: Required<CatalogOptions>;
+    customFields: Required<CustomFields>;
+    entityOptions: Required<Omit<EntityOptions, 'entityIdStrategy'>> & EntityOptions;
+    importExportOptions: Required<ImportExportOptions>;
+    jobQueueOptions: Required<JobQueueOptions>;
+    orderOptions: Required<OrderOptions>;
+    promotionOptions: Required<PromotionOptions>;
+    shippingOptions: Required<ShippingOptions>;
+    taxOptions: Required<TaxOptions>;
+}
+declare type DeepPartialSimple<T> = {
+    [P in keyof T]?: null | (T[P] extends Array<infer U> ? Array<DeepPartialSimple<U>> : T[P] extends ReadonlyArray<infer X> ? ReadonlyArray<DeepPartialSimple<X>> : T[P] extends Type<any> ? T[P] : DeepPartialSimple<T[P]>);
+};
+export declare type PartialVendureConfig = DeepPartialSimple<VendureConfig>;
+export {};

package/cli/config/vendure-config.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=vendure-config.js.map

package/cli/config/vendure-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vendure-config.js","sourceRoot":"","sources":["../../src/config/vendure-config.ts"],"names":[],"mappings":""}

package/cli/connection/connection.module.d.ts

@@ -0,0 +1,7 @@
+import { DynamicModule } from '@nestjs/common';
+import { ConnectionOptions } from 'typeorm';
+export declare class ConnectionModule {
+    static forRoot(): DynamicModule;
+    static forPlugin(): DynamicModule;
+    static getTypeOrmLogger(dbConnectionOptions: ConnectionOptions): import("typeorm").Logger | "debug" | "advanced-console" | "simple-console" | "file";
+}

package/cli/connection/connection.module.js

@@ -0,0 +1,61 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var ConnectionModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionModule = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const config_module_1 = require("../config/config.module");
+const config_service_1 = require("../config/config.service");
+const typeorm_logger_1 = require("../config/logger/typeorm-logger");
+const transaction_subscriber_1 = require("./transaction-subscriber");
+const transaction_wrapper_1 = require("./transaction-wrapper");
+const transactional_connection_1 = require("./transactional-connection");
+let defaultTypeOrmModule;
+let ConnectionModule = ConnectionModule_1 = class ConnectionModule {
+    static forRoot() {
+        if (!defaultTypeOrmModule) {
+            defaultTypeOrmModule = typeorm_1.TypeOrmModule.forRootAsync({
+                imports: [config_module_1.ConfigModule],
+                useFactory: (configService) => {
+                    const { dbConnectionOptions } = configService;
+                    const logger = ConnectionModule_1.getTypeOrmLogger(dbConnectionOptions);
+                    return Object.assign(Object.assign({}, dbConnectionOptions), { logger });
+                },
+                inject: [config_service_1.ConfigService],
+            });
+        }
+        return {
+            module: ConnectionModule_1,
+            imports: [defaultTypeOrmModule],
+        };
+    }
+    static forPlugin() {
+        return {
+            module: ConnectionModule_1,
+            imports: [typeorm_1.TypeOrmModule.forFeature()],
+        };
+    }
+    static getTypeOrmLogger(dbConnectionOptions) {
+        if (!dbConnectionOptions.logger) {
+            return new typeorm_logger_1.TypeOrmLogger(dbConnectionOptions.logging);
+        }
+        else {
+            return dbConnectionOptions.logger;
+        }
+    }
+};
+ConnectionModule = ConnectionModule_1 = __decorate([
+    common_1.Module({
+        imports: [config_module_1.ConfigModule],
+        providers: [transactional_connection_1.TransactionalConnection, transaction_subscriber_1.TransactionSubscriber, transaction_wrapper_1.TransactionWrapper],
+        exports: [transactional_connection_1.TransactionalConnection, transaction_subscriber_1.TransactionSubscriber, transaction_wrapper_1.TransactionWrapper],
+    })
+], ConnectionModule);
+exports.ConnectionModule = ConnectionModule;
+//# sourceMappingURL=connection.module.js.map

package/cli/connection/connection.module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.module.js","sourceRoot":"","sources":["../../src/connection/connection.module.ts"],"names":[],"mappings":";;;;;;;;;;AAAA,2CAAuD;AACvD,6CAAgD;AAGhD,2DAAuD;AACvD,6DAAyD;AACzD,oEAAgE;AAEhE,qEAAiE;AACjE,+DAA2D;AAC3D,yEAAqE;AAErE,IAAI,oBAAmC,CAAC;AAOxC,IAAa,gBAAgB,wBAA7B,MAAa,gBAAgB;IACzB,MAAM,CAAC,OAAO;QACV,IAAI,CAAC,oBAAoB,EAAE;YACvB,oBAAoB,GAAG,uBAAa,CAAC,YAAY,CAAC;gBAC9C,OAAO,EAAE,CAAC,4BAAY,CAAC;gBACvB,UAAU,EAAE,CAAC,aAA4B,EAAE,EAAE;oBACzC,MAAM,EAAE,mBAAmB,EAAE,GAAG,aAAa,CAAC;oBAC9C,MAAM,MAAM,GAAG,kBAAgB,CAAC,gBAAgB,CAAC,mBAAmB,CAAC,CAAC;oBACtE,uCACO,mBAAmB,KACtB,MAAM,IACR;gBACN,CAAC;gBACD,MAAM,EAAE,CAAC,8BAAa,CAAC;aAC1B,CAAC,CAAC;SACN;QACD,OAAO;YACH,MAAM,EAAE,kBAAgB;YACxB,OAAO,EAAE,CAAC,oBAAoB,CAAC;SAClC,CAAC;IACN,CAAC;IAED,MAAM,CAAC,SAAS;QACZ,OAAO;YACH,MAAM,EAAE,kBAAgB;YACxB,OAAO,EAAE,CAAC,uBAAa,CAAC,UAAU,EAAE,CAAC;SACxC,CAAC;IACN,CAAC;IAED,MAAM,CAAC,gBAAgB,CAAC,mBAAsC;QAC1D,IAAI,CAAC,mBAAmB,CAAC,MAAM,EAAE;YAC7B,OAAO,IAAI,8BAAa,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC;SACzD;aAAM;YACH,OAAO,mBAAmB,CAAC,MAAM,CAAC;SACrC;IACL,CAAC;CACJ,CAAA;AApCY,gBAAgB;IAL5B,eAAM,CAAC;QACJ,OAAO,EAAE,CAAC,4BAAY,CAAC;QACvB,SAAS,EAAE,CAAC,kDAAuB,EAAE,8CAAqB,EAAE,wCAAkB,CAAC;QAC/E,OAAO,EAAE,CAAC,kDAAuB,EAAE,8CAAqB,EAAE,wCAAkB,CAAC;KAChF,CAAC;GACW,gBAAgB,CAoC5B;AApCY,4CAAgB"}

package/cli/connection/transaction-subscriber.d.ts

@@ -0,0 +1,19 @@
+import { Connection, EntitySubscriberInterface } from 'typeorm';
+import { EntityManager } from 'typeorm/entity-manager/EntityManager';
+import { QueryRunner } from 'typeorm/query-runner/QueryRunner';
+import { TransactionCommitEvent } from 'typeorm/subscriber/event/TransactionCommitEvent';
+import { TransactionRollbackEvent } from 'typeorm/subscriber/event/TransactionRollbackEvent';
+export interface TransactionSubscriberEvent {
+    connection: Connection;
+    queryRunner: QueryRunner;
+    manager: EntityManager;
+}
+export declare class TransactionSubscriber implements EntitySubscriberInterface {
+    private connection;
+    private commit$;
+    private rollback$;
+    constructor(connection: Connection);
+    afterTransactionCommit(event: TransactionCommitEvent): void;
+    afterTransactionRollback(event: TransactionRollbackEvent): void;
+    awaitRelease(queryRunner: QueryRunner): Promise<QueryRunner>;
+}

package/cli/connection/transaction-subscriber.js

@@ -0,0 +1,54 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var TransactionSubscriber_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionSubscriber = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const typeorm_2 = require("typeorm");
+let TransactionSubscriber = TransactionSubscriber_1 = class TransactionSubscriber {
+    constructor(connection) {
+        this.connection = connection;
+        this.commit$ = new rxjs_1.Subject();
+        this.rollback$ = new rxjs_1.Subject();
+        if (!connection.subscribers.find(subscriber => subscriber.constructor === TransactionSubscriber_1)) {
+            connection.subscribers.push(this);
+        }
+    }
+    afterTransactionCommit(event) {
+        this.commit$.next(event);
+    }
+    afterTransactionRollback(event) {
+        this.rollback$.next(event);
+    }
+    awaitRelease(queryRunner) {
+        if (queryRunner.isTransactionActive) {
+            return rxjs_1.merge(this.commit$, this.rollback$)
+                .pipe(operators_1.filter(event => event.queryRunner === queryRunner), operators_1.take(1), operators_1.map(event => event.queryRunner), operators_1.delay(0))
+                .toPromise();
+        }
+        else {
+            return Promise.resolve(queryRunner);
+        }
+    }
+};
+TransactionSubscriber = TransactionSubscriber_1 = __decorate([
+    common_1.Injectable(),
+    __param(0, typeorm_1.InjectConnection()),
+    __metadata("design:paramtypes", [typeorm_2.Connection])
+], TransactionSubscriber);
+exports.TransactionSubscriber = TransactionSubscriber;
+//# sourceMappingURL=transaction-subscriber.js.map

package/cli/connection/transaction-subscriber.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction-subscriber.js","sourceRoot":"","sources":["../../src/connection/transaction-subscriber.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,2CAA4C;AAC5C,6CAAmD;AACnD,+BAAsC;AACtC,8CAA0D;AAC1D,qCAAgE;AA+BhE,IAAa,qBAAqB,6BAAlC,MAAa,qBAAqB;IAI9B,YAAwC,UAAsB;QAAtB,eAAU,GAAV,UAAU,CAAY;QAHtD,YAAO,GAAG,IAAI,cAAO,EAA8B,CAAC;QACpD,cAAS,GAAG,IAAI,cAAO,EAA8B,CAAC;QAG1D,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,UAAU,CAAC,WAAW,KAAK,uBAAqB,CAAC,EAAE;YAC9F,UAAU,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;SACrC;IACL,CAAC;IAED,sBAAsB,CAAC,KAA6B;QAChD,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC7B,CAAC;IAED,wBAAwB,CAAC,KAA+B;QACpD,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC;IAED,YAAY,CAAC,WAAwB;QACjC,IAAI,WAAW,CAAC,mBAAmB,EAAE;YACjC,OAAO,YAAK,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC;iBACrC,IAAI,CACD,kBAAM,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,WAAW,KAAK,WAAW,CAAC,EAClD,gBAAI,CAAC,CAAC,CAAC,EACP,eAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,WAAW,CAAC,EAO/B,iBAAK,CAAC,CAAC,CAAC,CACX;iBACA,SAAS,EAAE,CAAC;SACpB;aAAM;YACH,OAAO,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;SACvC;IACL,CAAC;CACJ,CAAA;AAtCY,qBAAqB;IADjC,mBAAU,EAAE;IAKI,WAAA,0BAAgB,EAAE,CAAA;qCAAqB,oBAAU;GAJrD,qBAAqB,CAsCjC;AAtCY,sDAAqB"}

package/cli/connection/transaction-wrapper.d.ts

@@ -0,0 +1,9 @@
+import { Observable } from 'rxjs';
+import { Connection } from 'typeorm';
+import { RequestContext } from '../api/common/request-context';
+import { TransactionMode } from '../api/decorators/transaction.decorator';
+export declare class TransactionWrapper {
+    executeInTransaction<T>(ctx: RequestContext, work: () => Observable<T> | Promise<T>, mode: TransactionMode, connection: Connection): Promise<T>;
+    private startTransaction;
+    private isRetriableError;
+}

package/cli/connection/transaction-wrapper.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionWrapper = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const TransactionAlreadyStartedError_1 = require("typeorm/error/TransactionAlreadyStartedError");
+const constants_1 = require("../common/constants");
+class TransactionWrapper {
+    async executeInTransaction(ctx, work, mode, connection) {
+        const queryRunnerExists = !!ctx[constants_1.TRANSACTION_MANAGER_KEY];
+        if (queryRunnerExists) {
+            return rxjs_1.from(work()).toPromise();
+        }
+        const queryRunner = connection.createQueryRunner();
+        if (mode === 'auto') {
+            await this.startTransaction(queryRunner);
+        }
+        ctx[constants_1.TRANSACTION_MANAGER_KEY] = queryRunner.manager;
+        try {
+            const maxRetries = 5;
+            const result = await rxjs_1.from(work())
+                .pipe(operators_1.retryWhen(errors => errors.pipe(operators_1.tap(err => {
+                if (!this.isRetriableError(err)) {
+                    throw err;
+                }
+            }), operators_1.take(maxRetries))))
+                .toPromise();
+            if (queryRunner.isTransactionActive) {
+                await queryRunner.commitTransaction();
+            }
+            return result;
+        }
+        catch (error) {
+            if (queryRunner.isTransactionActive) {
+                await queryRunner.rollbackTransaction();
+            }
+            throw error;
+        }
+        finally {
+            if ((queryRunner === null || queryRunner === void 0 ? void 0 : queryRunner.isReleased) === false) {
+                await queryRunner.release();
+            }
+        }
+    }
+    async startTransaction(queryRunner) {
+        const maxRetries = 25;
+        let attempts = 0;
+        let lastError;
+        async function attemptStartTransaction() {
+            try {
+                await queryRunner.startTransaction();
+                return true;
+            }
+            catch (err) {
+                lastError = err;
+                if (err instanceof TransactionAlreadyStartedError_1.TransactionAlreadyStartedError) {
+                    return false;
+                }
+                throw err;
+            }
+        }
+        while (attempts < maxRetries) {
+            const result = await attemptStartTransaction();
+            if (result) {
+                return;
+            }
+            attempts++;
+            await new Promise(resolve => setTimeout(resolve, attempts * 20));
+        }
+        throw lastError;
+    }
+    isRetriableError(err) {
+        const mysqlDeadlock = err.code === 'ER_LOCK_DEADLOCK';
+        const postgresDeadlock = err.code === 'deadlock_detected';
+        return mysqlDeadlock || postgresDeadlock;
+    }
+}
+exports.TransactionWrapper = TransactionWrapper;
+//# sourceMappingURL=transaction-wrapper.js.map

package/cli/connection/transaction-wrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction-wrapper.js","sourceRoot":"","sources":["../../src/connection/transaction-wrapper.ts"],"names":[],"mappings":";;;AAAA,+BAA4C;AAC5C,8CAAsD;AAEtD,iGAA8F;AAI9F,mDAA8D;AAO9D,MAAa,kBAAkB;IAO3B,KAAK,CAAC,oBAAoB,CACtB,GAAmB,EACnB,IAAsC,EACtC,IAAqB,EACrB,UAAsB;QAEtB,MAAM,iBAAiB,GAAG,CAAC,CAAE,GAAW,CAAC,mCAAuB,CAAC,CAAC;QAClE,IAAI,iBAAiB,EAAE;YAInB,OAAO,WAAI,CAAC,IAAI,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC;SACnC;QACD,MAAM,WAAW,GAAG,UAAU,CAAC,iBAAiB,EAAE,CAAC;QACnD,IAAI,IAAI,KAAK,MAAM,EAAE;YACjB,MAAM,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,CAAC;SAC5C;QACA,GAAW,CAAC,mCAAuB,CAAC,GAAG,WAAW,CAAC,OAAO,CAAC;QAE5D,IAAI;YACA,MAAM,UAAU,GAAG,CAAC,CAAC;YACrB,MAAM,MAAM,GAAG,MAAM,WAAI,CAAC,IAAI,EAAE,CAAC;iBAC5B,IAAI,CACD,qBAAS,CAAC,MAAM,CAAC,EAAE,CACf,MAAM,CAAC,IAAI,CACP,eAAG,CAAC,GAAG,CAAC,EAAE;gBACN,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,EAAE;oBAC7B,MAAM,GAAG,CAAC;iBACb;YACL,CAAC,CAAC,EACF,gBAAI,CAAC,UAAU,CAAC,CACnB,CACJ,CACJ;iBACA,SAAS,EAAE,CAAC;YACjB,IAAI,WAAW,CAAC,mBAAmB,EAAE;gBACjC,MAAM,WAAW,CAAC,iBAAiB,EAAE,CAAC;aACzC;YACD,OAAO,MAAM,CAAC;SACjB;QAAC,OAAO,KAAK,EAAE;YACZ,IAAI,WAAW,CAAC,mBAAmB,EAAE;gBACjC,MAAM,WAAW,CAAC,mBAAmB,EAAE,CAAC;aAC3C;YACD,MAAM,KAAK,CAAC;SACf;gBAAS;YACN,IAAI,CAAA,WAAW,aAAX,WAAW,uBAAX,WAAW,CAAE,UAAU,MAAK,KAAK,EAAE;gBACnC,MAAM,WAAW,CAAC,OAAO,EAAE,CAAC;aAC/B;SACJ;IACL,CAAC;IAMO,KAAK,CAAC,gBAAgB,CAAC,WAAwB;QACnD,MAAM,UAAU,GAAG,EAAE,CAAC;QACtB,IAAI,QAAQ,GAAG,CAAC,CAAC;QACjB,IAAI,SAAc,CAAC;QAGnB,KAAK,UAAU,uBAAuB;YAClC,IAAI;gBACA,MAAM,WAAW,CAAC,gBAAgB,EAAE,CAAC;gBACrC,OAAO,IAAI,CAAC;aACf;YAAC,OAAO,GAAG,EAAE;gBACV,SAAS,GAAG,GAAG,CAAC;gBAChB,IAAI,GAAG,YAAY,+DAA8B,EAAE;oBAC/C,OAAO,KAAK,CAAC;iBAChB;gBACD,MAAM,GAAG,CAAC;aACb;QACL,CAAC;QAED,OAAO,QAAQ,GAAG,UAAU,EAAE;YAC1B,MAAM,MAAM,GAAG,MAAM,uBAAuB,EAAE,CAAC;YAC/C,IAAI,MAAM,EAAE;gBACR,OAAO;aACV;YACD,QAAQ,EAAE,CAAC;YAEX,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,QAAQ,GAAG,EAAE,CAAC,CAAC,CAAC;SACpE;QACD,MAAM,SAAS,CAAC;IACpB,CAAC;IAOO,gBAAgB,CAAC,GAAQ;QAC7B,MAAM,aAAa,GAAG,GAAG,CAAC,IAAI,KAAK,kBAAkB,CAAC;QACtD,MAAM,gBAAgB,GAAG,GAAG,CAAC,IAAI,KAAK,mBAAmB,CAAC;QAC1D,OAAO,aAAa,IAAI,gBAAgB,CAAC;IAC7C,CAAC;CACJ;AAvGD,gDAuGC"}

package/cli/connection/transactional-connection.d.ts

@@ -0,0 +1,25 @@
+import { ID, Type } from '@vendure/common/lib/shared-types';
+import { Connection, EntitySchema, FindOneOptions, ObjectType, Repository } from 'typeorm';
+import { RequestContext } from '../api/common/request-context';
+import { ChannelAware } from '../common/types/common-types';
+import { VendureEntity } from '../entity/base/base.entity';
+import { TransactionWrapper } from './transaction-wrapper';
+import { GetEntityOrThrowOptions } from './types';
+export declare class TransactionalConnection {
+    private connection;
+    private transactionWrapper;
+    constructor(connection: Connection, transactionWrapper: TransactionWrapper);
+    get rawConnection(): Connection;
+    getRepository<Entity>(target: ObjectType<Entity> | EntitySchema<Entity> | string): Repository<Entity>;
+    getRepository<Entity>(ctx: RequestContext | undefined, target: ObjectType<Entity> | EntitySchema<Entity> | string): Repository<Entity>;
+    withTransaction<T>(work: (ctx: RequestContext) => Promise<T>): Promise<T>;
+    withTransaction<T>(ctx: RequestContext, work: (ctx: RequestContext) => Promise<T>): Promise<T>;
+    startTransaction(ctx: RequestContext): Promise<void>;
+    commitOpenTransaction(ctx: RequestContext): Promise<void>;
+    rollBackTransaction(ctx: RequestContext): Promise<void>;
+    getEntityOrThrow<T extends VendureEntity>(ctx: RequestContext, entityType: Type<T>, id: ID, options?: GetEntityOrThrowOptions<T>): Promise<T>;
+    private getEntityOrThrowInternal;
+    findOneInChannel<T extends ChannelAware & VendureEntity>(ctx: RequestContext, entity: Type<T>, id: ID, channelId: ID, options?: FindOneOptions): Promise<T | undefined>;
+    findByIdsInChannel<T extends ChannelAware | VendureEntity>(ctx: RequestContext, entity: Type<T>, ids: ID[], channelId: ID, options: FindOneOptions): Promise<T[]>;
+    private getTransactionManager;
+}

package/cli/connection/transactional-connection.js

@@ -0,0 +1,170 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionalConnection = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const request_context_1 = require("../api/common/request-context");
+const constants_1 = require("../common/constants");
+const errors_1 = require("../common/error/errors");
+const transaction_wrapper_1 = require("./transaction-wrapper");
+let TransactionalConnection = class TransactionalConnection {
+    constructor(connection, transactionWrapper) {
+        this.connection = connection;
+        this.transactionWrapper = transactionWrapper;
+    }
+    get rawConnection() {
+        return this.connection;
+    }
+    getRepository(ctxOrTarget, maybeTarget) {
+        var _a;
+        if (ctxOrTarget instanceof request_context_1.RequestContext) {
+            const transactionManager = this.getTransactionManager(ctxOrTarget);
+            if (transactionManager && maybeTarget && !((_a = transactionManager.queryRunner) === null || _a === void 0 ? void 0 : _a.isReleased)) {
+                return transactionManager.getRepository(maybeTarget);
+            }
+            else {
+                return typeorm_2.getRepository(maybeTarget);
+            }
+        }
+        else {
+            return typeorm_2.getRepository(ctxOrTarget !== null && ctxOrTarget !== void 0 ? ctxOrTarget : maybeTarget);
+        }
+    }
+    async withTransaction(ctxOrWork, maybeWork) {
+        let ctx;
+        let work;
+        if (ctxOrWork instanceof request_context_1.RequestContext) {
+            ctx = ctxOrWork;
+            work = maybeWork;
+        }
+        else {
+            ctx = request_context_1.RequestContext.empty();
+            work = ctxOrWork;
+        }
+        return this.transactionWrapper.executeInTransaction(ctx, () => work(ctx), 'auto', this.rawConnection);
+    }
+    async startTransaction(ctx) {
+        var _a;
+        const transactionManager = this.getTransactionManager(ctx);
+        if (((_a = transactionManager === null || transactionManager === void 0 ? void 0 : transactionManager.queryRunner) === null || _a === void 0 ? void 0 : _a.isTransactionActive) === false) {
+            await transactionManager.queryRunner.startTransaction();
+        }
+    }
+    async commitOpenTransaction(ctx) {
+        var _a;
+        const transactionManager = this.getTransactionManager(ctx);
+        if ((_a = transactionManager === null || transactionManager === void 0 ? void 0 : transactionManager.queryRunner) === null || _a === void 0 ? void 0 : _a.isTransactionActive) {
+            await transactionManager.queryRunner.commitTransaction();
+        }
+    }
+    async rollBackTransaction(ctx) {
+        var _a;
+        const transactionManager = this.getTransactionManager(ctx);
+        if ((_a = transactionManager === null || transactionManager === void 0 ? void 0 : transactionManager.queryRunner) === null || _a === void 0 ? void 0 : _a.isTransactionActive) {
+            await transactionManager.queryRunner.rollbackTransaction();
+        }
+    }
+    async getEntityOrThrow(ctx, entityType, id, options = {}) {
+        const { retries, retryDelay } = options;
+        if (retries == null || retries <= 0) {
+            return this.getEntityOrThrowInternal(ctx, entityType, id, options);
+        }
+        else {
+            let err;
+            const retriesInt = Math.ceil(retries);
+            const delay = Math.ceil(Math.max(retryDelay || 25, 1));
+            for (let attempt = 0; attempt < retriesInt; attempt++) {
+                try {
+                    const result = await this.getEntityOrThrowInternal(ctx, entityType, id, options);
+                    return result;
+                }
+                catch (e) {
+                    err = e;
+                    if (attempt < retriesInt - 1) {
+                        await new Promise(resolve => setTimeout(resolve, delay));
+                    }
+                }
+            }
+            throw err;
+        }
+    }
+    async getEntityOrThrowInternal(ctx, entityType, id, options = {}) {
+        let entity;
+        if (options.channelId != null) {
+            const { channelId } = options, optionsWithoutChannelId = __rest(options, ["channelId"]);
+            entity = await this.findOneInChannel(ctx, entityType, id, options.channelId, optionsWithoutChannelId);
+        }
+        else {
+            entity = await this.getRepository(ctx, entityType).findOne(id, options);
+        }
+        if (!entity ||
+            (entity.hasOwnProperty('deletedAt') &&
+                entity.deletedAt !== null &&
+                options.includeSoftDeleted !== true)) {
+            throw new errors_1.EntityNotFoundError(entityType.name, id);
+        }
+        return entity;
+    }
+    findOneInChannel(ctx, entity, id, channelId, options = {}) {
+        const qb = this.getRepository(ctx, entity).createQueryBuilder('entity');
+        typeorm_2.FindOptionsUtils.applyFindManyOptionsOrConditionsToQueryBuilder(qb, options);
+        if (options.loadEagerRelations !== false) {
+            typeorm_2.FindOptionsUtils.joinEagerRelations(qb, qb.alias, qb.expressionMap.mainAlias.metadata);
+        }
+        return qb
+            .leftJoin('entity.channels', 'channel')
+            .andWhere('entity.id = :id', { id })
+            .andWhere('channel.id = :channelId', { channelId })
+            .getOne();
+    }
+    findByIdsInChannel(ctx, entity, ids, channelId, options) {
+        if (ids.length === 0) {
+            return Promise.resolve([]);
+        }
+        const qb = this.getRepository(ctx, entity).createQueryBuilder('entity');
+        typeorm_2.FindOptionsUtils.applyFindManyOptionsOrConditionsToQueryBuilder(qb, options);
+        if (options.loadEagerRelations !== false) {
+            typeorm_2.FindOptionsUtils.joinEagerRelations(qb, qb.alias, qb.expressionMap.mainAlias.metadata);
+        }
+        return qb
+            .leftJoin('entity.channels', 'channel')
+            .andWhere('entity.id IN (:...ids)', { ids })
+            .andWhere('channel.id = :channelId', { channelId })
+            .getMany();
+    }
+    getTransactionManager(ctx) {
+        return ctx[constants_1.TRANSACTION_MANAGER_KEY];
+    }
+};
+TransactionalConnection = __decorate([
+    common_1.Injectable(),
+    __param(0, typeorm_1.InjectConnection()),
+    __metadata("design:paramtypes", [typeorm_2.Connection,
+        transaction_wrapper_1.TransactionWrapper])
+], TransactionalConnection);
+exports.TransactionalConnection = TransactionalConnection;
+//# sourceMappingURL=transactional-connection.js.map