@punks/backend-entity-manager 0.0.365 → 0.0.367

package/dist/cjs/index.js

@@ -231,8 +231,10 @@ class EntitySerializer {
         return records.map((x, i) => this.convertSheetRecord(x, definition, i));
     }
     parseXlsx(data, definition) {
+        const dateColumns = definition.columns.filter((x) => x.sheetParser === "date");
         const records = backendCore.excelParse(data, {
             keysTransform: backendCore.ExcelKeyTransform.Lower,
+            dateColumns: dateColumns.map((x) => x.name),
         });
         return records.map((x, i) => this.convertSheetRecord(x, definition, i));
     }
@@ -4260,6 +4262,19 @@ const WpEntitySnapshotService = (entityName, props = {}) => common.applyDecorato
     ...props,
 }));
 
+const TASK_KEY = "wp_task";
+var TaskConcurrency;
+(function (TaskConcurrency) {
+    TaskConcurrency["Single"] = "single";
+    TaskConcurrency["Multiple"] = "multiple";
+})(TaskConcurrency || (TaskConcurrency = {}));
+function WpTask(name, settings) {
+    return common.applyDecorators(common.Injectable(), common.SetMetadata(TASK_KEY, {
+        name,
+        ...settings,
+    }));
+}
+
 const WpEventsTracker = (props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EventsTracker, {
     ...props,
 }));
@@ -22235,26 +22250,6 @@ exports.MediaLibraryService = __decorate([
     __metadata("design:paramtypes", [exports.EntityManagerRegistry])
 ], exports.MediaLibraryService);
 
-function toInteger(dirtyNumber) {
-  if (dirtyNumber === null || dirtyNumber === true || dirtyNumber === false) {
-    return NaN;
-  }
-
-  var number = Number(dirtyNumber);
-
-  if (isNaN(number)) {
-    return number;
-  }
-
-  return number < 0 ? Math.ceil(number) : Math.floor(number);
-}
-
-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
@@ -22271,9 +22266,11 @@ function requiredArgs(required, args) {
  *
  * **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
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ *
+ * @param argument - The value to convert
+ *
+ * @returns The parsed date in the local time zone
  *
  * @example
  * // Clone the date:
@@ -22285,28 +22282,68 @@ function requiredArgs(required, args) {
  * 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
+  const argStr = Object.prototype.toString.call(argument);
 
-  if (argument instanceof Date || typeof argument === 'object' && argStr === '[object Date]') {
+  // 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 argument.constructor(+argument);
+  } else if (
+    typeof argument === "number" ||
+    argStr === "[object Number]" ||
+    typeof argument === "string" ||
+    argStr === "[object String]"
+  ) {
+    // TODO: Can we get rid of as?
     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://git.io/fjule"); // eslint-disable-next-line no-console
-
-      console.warn(new Error().stack);
-    }
-
+    // TODO: Can we get rid of as?
     return new Date(NaN);
   }
 }
 
+/**
+ * @name constructFrom
+ * @category Generic Helpers
+ * @summary Constructs a date using the reference date and the value
+ *
+ * @description
+ * The function constructs a new date using the constructor from the reference
+ * date and the given value. It helps to build generic functions that accept
+ * date extensions.
+ *
+ * It defaults to `Date` if the passed reference date is a number or a string.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ *
+ * @param date - The reference date to take constructor from
+ * @param value - The value to create the date
+ *
+ * @returns Date initialized using the given date and value
+ *
+ * @example
+ * import { constructFrom } from 'date-fns'
+ *
+ * // A function that clones a date preserving the original type
+ * function cloneDate<DateType extends Date(date: DateType): DateType {
+ *   return constructFrom(
+ *     date, // Use contrustor from the given date
+ *     date.getTime() // Use the date value to create a new date
+ *   )
+ * }
+ */
+function constructFrom(date, value) {
+  if (date instanceof Date) {
+    return new date.constructor(value);
+  } else {
+    return new Date(value);
+  }
+}
+
 /**
  * @name addDays
  * @category Day Helpers
@@ -22315,37 +22352,60 @@ function toDate(argument) {
  * @description
  * Add the specified number of days to the given date.
  *
- * ### v2.0.0 breaking changes:
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
  *
- * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).
+ * @param date - The date to be changed
+ * @param amount - The amount of days to be added.
  *
- * @param {Date|Number} date - the date to be changed
- * @param {Number} amount - the amount of days to be added. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.
- * @returns {Date} the new date with the days added
- * @throws {TypeError} 2 arguments required
+ * @returns The new date with the days added
  *
  * @example
  * // Add 10 days to 1 September 2014:
- * var result = addDays(new Date(2014, 8, 1), 10)
+ * const result = addDays(new Date(2014, 8, 1), 10)
  * //=> Thu Sep 11 2014 00:00:00
  */
-
-function addDays(dirtyDate, dirtyAmount) {
-  requiredArgs(2, arguments);
-  var date = toDate(dirtyDate);
-  var amount = toInteger(dirtyAmount);
-
-  if (isNaN(amount)) {
-    return new Date(NaN);
-  }
-
+function addDays(date, amount) {
+  const _date = toDate(date);
+  if (isNaN(amount)) return constructFrom(date, NaN);
   if (!amount) {
     // If 0 days, no-op to avoid changing times in the hour before end of DST
-    return date;
+    return _date;
   }
+  _date.setDate(_date.getDate() + amount);
+  return _date;
+}
 
-  date.setDate(date.getDate() + amount);
-  return date;
+/**
+ * @module constants
+ * @summary Useful constants
+ * @description
+ * Collection of useful date constants.
+ *
+ * The constants could be imported from `date-fns/constants`:
+ *
+ * ```ts
+ * import { maxTime, minTime } from "./constants/date-fns/constants";
+ *
+ * function isAllowedTime(time) {
+ *   return time <= maxTime && time >= minTime;
+ * }
+ * ```
+ */
+
+/**
+ * @constant
+ * @name millisecondsInMinute
+ * @summary Milliseconds in 1 minute
+ */
+const millisecondsInMinute = 60000;
+
+function getRoundingMethod(method) {
+  return (number) => {
+    const round = method ? Math[method] : Math.trunc;
+    const result = round(number);
+    // Prevent negative zero
+    return result === 0 ? 0 : result;
+  };
 }
 
 /**
@@ -22356,33 +22416,30 @@ function addDays(dirtyDate, dirtyAmount) {
  * @description
  * Get the number of milliseconds between the given dates.
  *
- * ### v2.0.0 breaking changes:
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
  *
- * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).
+ * @param dateLeft - The later date
+ * @param dateRight - The earlier date
  *
- * @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
+ * @returns The number of milliseconds
  *
  * @example
  * // How many milliseconds are between
  * // 2 July 2014 12:30:20.600 and 2 July 2014 12:30:21.700?
- * var result = differenceInMilliseconds(
+ * const result = differenceInMilliseconds(
  *   new Date(2014, 6, 2, 12, 30, 21, 700),
  *   new Date(2014, 6, 2, 12, 30, 20, 600)
  * )
  * //=> 1100
  */
-
-function differenceInMilliseconds(dirtyDateLeft, dirtyDateRight) {
-  requiredArgs(2, arguments);
-  var dateLeft = toDate(dirtyDateLeft);
-  var dateRight = toDate(dirtyDateRight);
-  return dateLeft.getTime() - dateRight.getTime();
+function differenceInMilliseconds(dateLeft, dateRight) {
+  return +toDate(dateLeft) - +toDate(dateRight);
 }
 
-var MILLISECONDS_IN_MINUTE = 60000;
+/**
+ * The {@link differenceInMinutes} function options.
+ */
+
 /**
  * @name differenceInMinutes
  * @category Minute Helpers
@@ -22391,36 +22448,34 @@ var MILLISECONDS_IN_MINUTE = 60000;
  * @description
  * Get the signed number of full (rounded towards 0) minutes between the given dates.
  *
- * ### v2.0.0 breaking changes:
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
  *
- * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).
+ * @param dateLeft - The later date
+ * @param dateRight - The earlier date
+ * @param options - An object with options.
  *
- * @param {Date|Number} dateLeft - the later date
- * @param {Date|Number} dateRight - the earlier date
- * @returns {Number} the number of minutes
- * @throws {TypeError} 2 arguments required
+ * @returns The number of minutes
  *
  * @example
  * // How many minutes are between 2 July 2014 12:07:59 and 2 July 2014 12:20:00?
- * var result = differenceInMinutes(
+ * 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 from 10:01:59 to 10:00:00
- * var result = differenceInMinutes(
+ * // 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(dirtyDateLeft, dirtyDateRight) {
-  requiredArgs(2, arguments);
-  var diff = differenceInMilliseconds(dirtyDateLeft, dirtyDateRight) / MILLISECONDS_IN_MINUTE;
-  return diff > 0 ? Math.floor(diff) : Math.ceil(diff);
+function differenceInMinutes(dateLeft, dateRight, options) {
+  const diff =
+    differenceInMilliseconds(dateLeft, dateRight) / millisecondsInMinute;
+  return getRoundingMethod(options?.roundingMethod)(diff);
 }
 
 /**
@@ -22431,25 +22486,20 @@ function differenceInMinutes(dirtyDateLeft, dirtyDateRight) {
  * @description
  * Subtract the specified number of days from the given date.
  *
- * ### v2.0.0 breaking changes:
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
  *
- * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).
+ * @param date - The date to be changed
+ * @param amount - The amount of days to be subtracted.
  *
- * @param {Date|Number} date - the date to be changed
- * @param {Number} amount - the amount of days to be subtracted. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.
- * @returns {Date} the new date with the days subtracted
- * @throws {TypeError} 2 arguments required
+ * @returns The new date with the days subtracted
  *
  * @example
  * // Subtract 10 days from 1 September 2014:
- * var result = subDays(new Date(2014, 8, 1), 10)
+ * const result = subDays(new Date(2014, 8, 1), 10)
  * //=> Fri Aug 22 2014 00:00:00
  */
-
-function subDays(dirtyDate, dirtyAmount) {
-  requiredArgs(2, arguments);
-  var amount = toInteger(dirtyAmount);
-  return addDays(dirtyDate, -amount);
+function subDays(date, amount) {
+  return addDays(date, -amount);
 }
 
 const WpOperationLockService = (props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.OperationLockService, {
@@ -34744,6 +34794,164 @@ exports.JobsModule = JobsModule_1 = __decorate([
         JobsProviderFactory])
 ], exports.JobsModule);
 
+var TaskRunType;
+(function (TaskRunType) {
+    TaskRunType["Scheduled"] = "Scheduled";
+    TaskRunType["OnDemand"] = "OnDemand";
+})(TaskRunType || (TaskRunType = {}));
+
+const getCronCurrentSchedule = (cronExpression, ref) => {
+    const interval = parser$1.parseExpression(cronExpression, {
+        currentDate: ref,
+    });
+    return interval.prev().toDate();
+};
+
+function floorDateToSecond(date) {
+    const flooredDate = new Date(date);
+    flooredDate.setMilliseconds(0);
+    return flooredDate;
+}
+
+var TaskShell_1;
+let TaskShell = TaskShell_1 = class TaskShell {
+    constructor(registry, operations) {
+        this.registry = registry;
+        this.operations = operations;
+        this.logger = backendCore.Log.getLogger(TaskShell_1.name);
+    }
+    async executeTask(instance, settings) {
+        switch (settings.concurrency) {
+            case TaskConcurrency.Single:
+                return await this.executeTaskSequential(instance, settings);
+            case TaskConcurrency.Multiple:
+                return await this.executeTaskParallel(instance, settings);
+            default:
+                throw new Error(`Unknown task concurrency: ${settings.concurrency}`);
+        }
+    }
+    async executeTaskParallel(instance, settings) {
+        await this.invokeTask(instance, settings);
+    }
+    async executeTaskSequential(instance, settings) {
+        const currentSchedule = getCronCurrentSchedule(settings.cronExpression, new Date());
+        const lockKey = this.getTaskLockKey(settings, currentSchedule);
+        const lock = await this.operations.acquireLock({
+            lockUid: lockKey,
+        });
+        if (lock.available) {
+            await this.invokeTask(instance, settings);
+        }
+    }
+    getTaskLockKey(settings, cronSchedule) {
+        return `task:${settings.name}:${floorDateToSecond(cronSchedule).toISOString()}`;
+    }
+    async invokeTask(instance, settings) {
+        try {
+            this.logger.info(`Task ${settings.name} -> starting`);
+            await instance.execute({
+                name: settings.name,
+                startedAt: new Date(),
+                runId: backendCore.newUuid(),
+                runType: TaskRunType.Scheduled,
+            });
+            this.logger.info(`Task ${settings.name} -> completed`);
+        }
+        catch (error) {
+            this.logger.exception(`Task ${settings.name} -> failed`, error);
+        }
+    }
+    get operationsLockService() {
+        return this.registry
+            .getContainer()
+            .getEntitiesServicesLocator()
+            .resolveOperationLockService();
+    }
+};
+TaskShell = TaskShell_1 = __decorate([
+    common.Injectable(),
+    __param(1, common.Inject(getEntityManagerProviderToken("OperationsLockRepository"))),
+    __metadata("design:paramtypes", [exports.EntityManagerRegistry, Object])
+], TaskShell);
+
+var TaskScheduler_1;
+let TaskScheduler = TaskScheduler_1 = class TaskScheduler {
+    constructor(schedulerRegistry, jobShell) {
+        this.schedulerRegistry = schedulerRegistry;
+        this.jobShell = jobShell;
+        this.logger = new common.Logger(TaskScheduler_1.name);
+        this.jobs = [];
+    }
+    async registerTask(job, instance) {
+        const cronJob = new dist.CronJob(job.cronExpression, async (context) => {
+            await this.jobShell.executeTask(instance, job);
+        });
+        this.schedulerRegistry.addCronJob(job.name, cronJob);
+        cronJob.start();
+        this.jobs.push(cronJob);
+        this.logger.log(`Jobs ${job.name} registered`);
+    }
+    stopAllTasks() {
+        this.jobs.forEach((job) => {
+            job.stop();
+        });
+    }
+};
+TaskScheduler = TaskScheduler_1 = __decorate([
+    common.Injectable(),
+    __metadata("design:paramtypes", [schedule.SchedulerRegistry,
+        TaskShell])
+], TaskScheduler);
+
+var TasksInitializer_1;
+let TasksInitializer = TasksInitializer_1 = class TasksInitializer {
+    constructor(discover, scheduler) {
+        this.discover = discover;
+        this.scheduler = scheduler;
+        this.logger = new common.Logger(TasksInitializer_1.name);
+    }
+    async initialize(app) {
+        await this.registerCronJobs();
+        this.logger.log("Tasks initialized 🎰");
+    }
+    async registerCronJobs() {
+        const tasks = await this.discoverTasks();
+        const duplicatedJobs = tasks.filter((job, index, self) => index !== self.findIndex((t) => t.meta.name === job.meta.name));
+        if (duplicatedJobs.length) {
+            throw new Error(`Duplicated jobs found: ${duplicatedJobs
+                .map((j) => j.meta.name)
+                .join(", ")}`);
+        }
+        for (const task of tasks) {
+            await this.scheduler.registerTask(task.meta, task.discoveredClass.instance);
+        }
+    }
+    async discoverTasks() {
+        return await this.discover.providersWithMetaAtKey(TASK_KEY);
+    }
+};
+TasksInitializer = TasksInitializer_1 = __decorate([
+    WpAppInitializer(),
+    __metadata("design:paramtypes", [exports.CustomDiscoveryService,
+        TaskScheduler])
+], TasksInitializer);
+
+exports.TasksModule = class TasksModule {
+    constructor(scheduler) {
+        this.scheduler = scheduler;
+    }
+    onModuleDestroy() {
+        this.scheduler.stopAllTasks();
+    }
+};
+exports.TasksModule = __decorate([
+    common.Module({
+        imports: [exports.EntityManagerModule],
+        providers: [TasksInitializer, TaskScheduler, TaskShell],
+    }),
+    __metadata("design:paramtypes", [TaskScheduler])
+], exports.TasksModule);
+
 const createExpressFileResponse = (res, file) => {
     res.set({
         "Content-Type": file.contentType,
@@ -44519,6 +44727,7 @@ exports.WpPermissionsService = WpPermissionsService;
 exports.WpPipeline = WpPipeline;
 exports.WpRolesService = WpRolesService;
 exports.WpSendgridEmailTemplate = WpSendgridEmailTemplate;
+exports.WpTask = WpTask;
 exports.WpUserRolesService = WpUserRolesService;
 exports.WpUserService = WpUserService;
 exports.awsBatchSettings = awsBatchSettings;