@punks/backend-entity-manager 0.0.259 → 0.0.261

package/dist/cjs/index.js

@@ -126,6 +126,9 @@ class MissingEntityIdError extends EntityManagerException {
     }
 }
 
+class LockNotFoundError extends Error {
+}
+
 exports.ReplicationMode = void 0;
 (function (ReplicationMode) {
     ReplicationMode[ReplicationMode["Sync"] = 0] = "Sync";
@@ -3804,6 +3807,10 @@ function __decorate(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 
+function __param(paramIndex, decorator) {
+  return function (target, key) { decorator(target, key, paramIndex); }
+}
+
 function __metadata(metadataKey, metadataValue) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
 }
@@ -21544,6 +21551,15 @@ exports.CustomDiscoveryModule = __decorate([
     })
 ], exports.CustomDiscoveryModule);
 
+const LIB_DI_TOKEN_NAMESPACE = "WP";
+const buildProviderToken = (name) => `${LIB_DI_TOKEN_NAMESPACE}.PROVIDER.${name}`;
+
+const EntityManagerProviderToken = {
+    OperationsLockRepository: {},
+};
+const toSnakeUpperCase = (str) => lodash.exports.trimStart(str.replace(/([A-Z])/g, (match) => `_${match}`).toUpperCase(), "_");
+const getEntityManagerProviderToken = (name) => buildProviderToken(toSnakeUpperCase(name));
+
 exports.EntityManagerService = class EntityManagerService {
     constructor(registry) {
         this.registry = registry;
@@ -21685,6 +21701,271 @@ exports.MediaLibraryService = __decorate([
     __metadata("design:paramtypes", [exports.EntityManagerRegistry])
 ], exports.MediaLibraryService);
 
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+    return typeof obj;
+  } : function (obj) {
+    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+  }, _typeof(obj);
+}
+
+function requiredArgs(required, args) {
+  if (args.length < required) {
+    throw new TypeError(required + ' argument' + (required > 1 ? 's' : '') + ' required, but only ' + args.length + ' present');
+  }
+}
+
+/**
+ * @name toDate
+ * @category Common Helpers
+ * @summary Convert the given argument to an instance of Date.
+ *
+ * @description
+ * Convert the given argument to an instance of Date.
+ *
+ * If the argument is an instance of Date, the function returns its clone.
+ *
+ * If the argument is a number, it is treated as a timestamp.
+ *
+ * If the argument is none of the above, the function returns Invalid Date.
+ *
+ * **Note**: *all* Date arguments passed to any *date-fns* function is processed by `toDate`.
+ *
+ * @param {Date|Number} argument - the value to convert
+ * @returns {Date} the parsed date in the local time zone
+ * @throws {TypeError} 1 argument required
+ *
+ * @example
+ * // Clone the date:
+ * const result = toDate(new Date(2014, 1, 11, 11, 30, 30))
+ * //=> Tue Feb 11 2014 11:30:30
+ *
+ * @example
+ * // Convert the timestamp to date:
+ * const result = toDate(1392098430000)
+ * //=> Tue Feb 11 2014 11:30:30
+ */
+function toDate(argument) {
+  requiredArgs(1, arguments);
+  var argStr = Object.prototype.toString.call(argument);
+
+  // Clone the date
+  if (argument instanceof Date || _typeof(argument) === 'object' && argStr === '[object Date]') {
+    // Prevent the date to lose the milliseconds when passed to new Date() in IE10
+    return new Date(argument.getTime());
+  } else if (typeof argument === 'number' || argStr === '[object Number]') {
+    return new Date(argument);
+  } else {
+    if ((typeof argument === 'string' || argStr === '[object String]') && typeof console !== 'undefined') {
+      // eslint-disable-next-line no-console
+      console.warn("Starting with v2.0.0-beta.1 date-fns doesn't accept strings as date arguments. Please use `parseISO` to parse strings. See: https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#string-arguments");
+      // eslint-disable-next-line no-console
+      console.warn(new Error().stack);
+    }
+    return new Date(NaN);
+  }
+}
+
+/**
+ * Days in 1 week.
+ *
+ * @name daysInWeek
+ * @constant
+ * @type {number}
+ * @default
+ */
+
+/**
+ * Milliseconds in 1 minute
+ *
+ * @name millisecondsInMinute
+ * @constant
+ * @type {number}
+ * @default
+ */
+var millisecondsInMinute = 60000;
+
+/**
+ * @name differenceInMilliseconds
+ * @category Millisecond Helpers
+ * @summary Get the number of milliseconds between the given dates.
+ *
+ * @description
+ * Get the number of milliseconds between the given dates.
+ *
+ * @param {Date|Number} dateLeft - the later date
+ * @param {Date|Number} dateRight - the earlier date
+ * @returns {Number} the number of milliseconds
+ * @throws {TypeError} 2 arguments required
+ *
+ * @example
+ * // How many milliseconds are between
+ * // 2 July 2014 12:30:20.600 and 2 July 2014 12:30:21.700?
+ * const result = differenceInMilliseconds(
+ *   new Date(2014, 6, 2, 12, 30, 21, 700),
+ *   new Date(2014, 6, 2, 12, 30, 20, 600)
+ * )
+ * //=> 1100
+ */
+function differenceInMilliseconds(dateLeft, dateRight) {
+  requiredArgs(2, arguments);
+  return toDate(dateLeft).getTime() - toDate(dateRight).getTime();
+}
+
+var roundingMap = {
+  ceil: Math.ceil,
+  round: Math.round,
+  floor: Math.floor,
+  trunc: function trunc(value) {
+    return value < 0 ? Math.ceil(value) : Math.floor(value);
+  } // Math.trunc is not supported by IE
+};
+
+var defaultRoundingMethod = 'trunc';
+function getRoundingMethod(method) {
+  return method ? roundingMap[method] : roundingMap[defaultRoundingMethod];
+}
+
+/**
+ * @name differenceInMinutes
+ * @category Minute Helpers
+ * @summary Get the number of minutes between the given dates.
+ *
+ * @description
+ * Get the signed number of full (rounded towards 0) minutes between the given dates.
+ *
+ * @param {Date|Number} dateLeft - the later date
+ * @param {Date|Number} dateRight - the earlier date
+ * @param {Object} [options] - an object with options.
+ * @param {String} [options.roundingMethod='trunc'] - a rounding method (`ceil`, `floor`, `round` or `trunc`)
+ * @returns {Number} the number of minutes
+ * @throws {TypeError} 2 arguments required
+ *
+ * @example
+ * // How many minutes are between 2 July 2014 12:07:59 and 2 July 2014 12:20:00?
+ * const result = differenceInMinutes(
+ *   new Date(2014, 6, 2, 12, 20, 0),
+ *   new Date(2014, 6, 2, 12, 7, 59)
+ * )
+ * //=> 12
+ *
+ * @example
+ * // How many minutes are between 10:01:59 and 10:00:00
+ * const result = differenceInMinutes(
+ *   new Date(2000, 0, 1, 10, 0, 0),
+ *   new Date(2000, 0, 1, 10, 1, 59)
+ * )
+ * //=> -1
+ */
+function differenceInMinutes(dateLeft, dateRight, options) {
+  requiredArgs(2, arguments);
+  var diff = differenceInMilliseconds(dateLeft, dateRight) / millisecondsInMinute;
+  return getRoundingMethod(options === null || options === void 0 ? void 0 : options.roundingMethod)(diff);
+}
+
+exports.OperationLockService = class OperationLockService {
+    constructor(operations) {
+        this.operations = operations;
+        this.executeExclusive = async (input) => {
+            const lock = await this.operations.acquire({
+                lockUid: input.lockUid,
+                requestedBy: input.requestedBy,
+            });
+            if (!lock.available &&
+                input.lockTimeout &&
+                this.isLockExpired(lock.lockItem, new Date(), input.lockTimeout)) {
+                await this.operations.release({
+                    lockUid: input.lockUid,
+                });
+                return await this.executeExclusive(input);
+            }
+            if (!lock.available) {
+                return {
+                    skipped: true,
+                    result: undefined,
+                };
+            }
+            try {
+                return {
+                    skipped: false,
+                    result: await this.executeOperation(input),
+                };
+            }
+            finally {
+                await this.operations.release({
+                    lockUid: input.lockUid,
+                });
+            }
+        };
+        this.executeOperation = async (input) => {
+            return await input.operation();
+        };
+        this.isLockExpired = (item, refDate, timeoutMinutes) => {
+            return differenceInMinutes(refDate, item.createdOn) > timeoutMinutes;
+        };
+    }
+};
+exports.OperationLockService = __decorate([
+    common.Injectable(),
+    __param(0, common.Optional()),
+    __param(0, common.Inject(getEntityManagerProviderToken("OperationsLockRepository"))),
+    __metadata("design:paramtypes", [Object])
+], exports.OperationLockService);
+
+exports.TypeormOperationLockRepository = class TypeormOperationLockRepository {
+    constructor(repo, entityClass) {
+        this.repo = repo;
+        this.entityClass = entityClass;
+        // todo: fix typing (and remove as any)
+        this.get = async (lockUid) => (await this.repo.findOne({
+            where: {
+                uid: lockUid,
+            },
+        })) ?? undefined;
+        this.acquire = async (input) => {
+            return await this.repo.manager.transaction(async (manager) => {
+                const currentLock = await manager.findOne(this.entityClass, {
+                    where: [
+                        {
+                            uid: input.lockUid,
+                        },
+                    ],
+                });
+                if (currentLock) {
+                    return {
+                        available: false,
+                        lockItem: currentLock,
+                    };
+                }
+                const newLock = manager.create(this.entityClass, {
+                    id: backendCore.newUuid(),
+                    uid: input.lockUid,
+                    lockedBy: input.requestedBy,
+                });
+                await manager.save([newLock]);
+                return {
+                    available: true,
+                    lockItem: newLock,
+                };
+            });
+        };
+        this.release = async (input) => {
+            const result = await this.repo.delete({
+                uid: input.lockUid,
+            });
+            if (result.affected === 0) {
+                throw new LockNotFoundError(`Lock ${input.lockUid} was not found`);
+            }
+        };
+    }
+};
+exports.TypeormOperationLockRepository = __decorate([
+    common.Injectable(),
+    __metadata("design:paramtypes", [typeorm.Repository, Object])
+], exports.TypeormOperationLockRepository);
+
 exports.EmailService = class EmailService {
     constructor(registry) {
         this.registry = registry;
@@ -22648,6 +22929,7 @@ const Services$1 = [
     exports.MediaLibraryService,
     exports.SecretsService,
     exports.TrackingService,
+    exports.OperationLockService,
 ];
 
 const IoC = [exports.EntityManagerRegistry];
@@ -23222,10 +23504,32 @@ const getIoCContext = () => {
     return _context;
 };
 
+const ModuleData$7 = {
+    imports: [exports.CustomDiscoveryModule, eventEmitter.EventEmitterModule],
+    providers: [
+        ...IoC,
+        ...Providers,
+        ...Processors,
+        ...Services$1,
+        ...PipelineProviders,
+    ],
+    exports: [exports.EntityManagerRegistry, ...Services$1],
+};
 exports.EntityManagerModule = class EntityManagerModule {
     constructor(registry) {
         this.registry = registry;
     }
+    // static forRoot(input: {
+    //   imports?: ModuleMetadata["imports"]
+    //   providers?: ModuleMetadata["providers"]
+    // }): DynamicModule {
+    //   return {
+    //     module: EntityManagerModule,
+    //     imports: ModuleData.imports,
+    //     providers: [...ModuleData.providers, ...(input.providers ?? [])],
+    //     exports: ModuleData.exports,
+    //   }
+    // }
     onModuleInit() {
         initializeIoCContext({
             registry: this.registry,
@@ -23234,15 +23538,9 @@ exports.EntityManagerModule = class EntityManagerModule {
 };
 exports.EntityManagerModule = __decorate([
     common.Module({
-        imports: [exports.CustomDiscoveryModule, eventEmitter.EventEmitterModule],
-        providers: [
-            ...IoC,
-            ...Providers,
-            ...Processors,
-            ...Services$1,
-            ...PipelineProviders,
-        ],
-        exports: [exports.EntityManagerRegistry, ...Services$1],
+        imports: ModuleData$7.imports,
+        providers: ModuleData$7.providers,
+        exports: ModuleData$7.exports,
     }),
     __metadata("design:paramtypes", [exports.EntityManagerRegistry])
 ], exports.EntityManagerModule);
@@ -32698,6 +32996,7 @@ exports.AwsSesEmailTemplate = AwsSesEmailTemplate;
 exports.CurrentUser = CurrentUser;
 exports.EntityManagerConfigurationError = EntityManagerConfigurationError;
 exports.EntityManagerException = EntityManagerException;
+exports.EntityManagerProviderToken = EntityManagerProviderToken;
 exports.EntityManagerSymbols = EntityManagerSymbols;
 exports.EntityManagerUnauthorizedException = EntityManagerUnauthorizedException;
 exports.EntityNotFoundException = EntityNotFoundException;
@@ -32707,6 +33006,7 @@ exports.EntitySerializer = EntitySerializer;
 exports.EntitySnapshotService = EntitySnapshotService;
 exports.IEntityVersionsCursor = IEntityVersionsCursor;
 exports.InvalidCredentialsError = InvalidCredentialsError;
+exports.LockNotFoundError = LockNotFoundError;
 exports.MemberOf = MemberOf;
 exports.MissingEntityIdError = MissingEntityIdError;
 exports.MultipleEntitiesFoundException = MultipleEntitiesFoundException;
@@ -32769,6 +33069,7 @@ exports.WpSendgridEmailTemplate = WpSendgridEmailTemplate;
 exports.WpUserRolesService = WpUserRolesService;
 exports.WpUserService = WpUserService;
 exports.buildPermissionsGuard = buildPermissionsGuard;
+exports.buildProviderToken = buildProviderToken;
 exports.buildRolesGuard = buildRolesGuard;
 exports.createContainer = createContainer;
 exports.createExpressFileResponse = createExpressFileResponse;