@freshpointcz/fresh-core 0.0.13 → 0.0.15

package/dist/index.js

@@ -452,6 +452,14 @@ __export(index_exports, {
   TransactionType: () => TransactionType,
   createDeferred: () => createDeferred,
   freshEslintConfig: () => eslint_config_default,
+  hasOwn: () => hasOwn,
+  isEnumValue: () => isEnumValue,
+  isFlag01: () => isFlag01,
+  isMaybe: () => isMaybe,
+  isNumber: () => isNumber,
+  isNumberInRange: () => isNumberInRange,
+  isObject: () => isObject,
+  isString: () => isString,
   isValidCron: () => isValidCron,
   logger: () => logger
 });
@@ -746,14 +754,38 @@ __name(isValidCron, "isValidCron");
 
 // src/common/patterns/singleton.ts
 var _Singleton = class _Singleton {
-  constructor() {
+  /**
+   * Creates or returns the singleton instance for the subclass.
+   *
+   * If an instance already exists for the subclass, that instance is
+   * returned instead of creating a new one.
+   *
+   * @param callOnInit - Whether to call {@link onInit} for a newly
+   * created instance. Ignored if the instance already exists.
+   */
+  constructor(callOnInit = true) {
     const ctor = this.constructor;
     const existing = _Singleton.instances.get(ctor);
     if (existing) {
       return existing;
     }
     _Singleton.instances.set(ctor, this);
+    if (callOnInit) {
+      void this.onInit();
+    }
   }
+  /**
+   * Retrieves the singleton instance for the calling subclass.
+   *
+   * If no instance exists, a new one is created using the provided
+   * constructor arguments.
+   *
+   * Intended to be used by subclasses as a protected factory method.
+   *
+   * @typeParam T - The concrete subclass type.
+   * @param args - Arguments forwarded to the subclass constructor.
+   * @returns The singleton instance of the subclass.
+   */
   static getInstance(...args) {
     let instance = _Singleton.instances.get(this);
     if (!instance) {
@@ -764,6 +796,10 @@ var _Singleton = class _Singleton {
   }
 };
 __name(_Singleton, "Singleton");
+/**
+ * Internal registry of singleton instances.
+ * One instance per subclass constructor.
+ */
 __publicField(_Singleton, "instances", /* @__PURE__ */ new Map());
 var Singleton = _Singleton;
 
@@ -1112,6 +1148,7 @@ var PaymentMethod = /* @__PURE__ */ (function(PaymentMethod2) {
   PaymentMethod2[PaymentMethod2["CODE"] = 0] = "CODE";
   PaymentMethod2[PaymentMethod2["CARD"] = 1] = "CARD";
   PaymentMethod2[PaymentMethod2["NONE"] = 2] = "NONE";
+  PaymentMethod2[PaymentMethod2["CREDIT"] = 3] = "CREDIT";
   return PaymentMethod2;
 })({});
 
@@ -1170,6 +1207,9 @@ _ts_decorate3([
 
 // src/database/dao/fresh-dao.ts
 var _FreshDao = class _FreshDao {
+  getRepo(manager, entity = this.entity) {
+    return manager ? manager.getRepository(entity) : this.repo;
+  }
 };
 __name(_FreshDao, "FreshDao");
 var FreshDao = _FreshDao;
@@ -1258,6 +1298,56 @@ Subcategory = _ts_decorate8([
   (0, import_typeorm9.Entity)()
 ], Subcategory);
 
+// src/common/typeguards/enums.ts
+function isEnumValue(enumObj, v) {
+  if (!enumObj) {
+    return typeof v === "string" || typeof v === "number";
+  }
+  const values = new Set(Object.values(enumObj));
+  return (typeof v === "string" || typeof v === "number") && values.has(v);
+}
+__name(isEnumValue, "isEnumValue");
+
+// src/common/typeguards/objects.ts
+function isObject(v) {
+  return typeof v === "object" && v !== null;
+}
+__name(isObject, "isObject");
+function hasOwn(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+__name(hasOwn, "hasOwn");
+
+// src/common/typeguards/primitives.ts
+function isNumber(v) {
+  return typeof v === "number" && Number.isFinite(v);
+}
+__name(isNumber, "isNumber");
+function isString(v) {
+  return typeof v === "string";
+}
+__name(isString, "isString");
+function isFlag01(v) {
+  return v === 0 || v === 1;
+}
+__name(isFlag01, "isFlag01");
+function isNumberInRange(v, min, max, options) {
+  var _a, _b;
+  if (!isNumber(v)) {
+    return false;
+  }
+  const includeMin = (_a = options == null ? void 0 : options.includeMin) != null ? _a : true;
+  const includeMax = (_b = options == null ? void 0 : options.includeMax) != null ? _b : true;
+  if (includeMin ? v < min : v <= min) {
+    return false;
+  }
+  if (includeMax ? v > max : v >= max) {
+    return false;
+  }
+  return true;
+}
+__name(isNumberInRange, "isNumberInRange");
+
 // src/core/data-helper.ts
 var _DataHelper = class _DataHelper {
   constructor(startDataRetrieve = true, deviceIds) {
@@ -1299,13 +1389,34 @@ var DataHelper = _DataHelper;
 var import_node_schedule = require("node-schedule");
 var _FreshJob = class _FreshJob extends Singleton {
   /**
-   * @param cronExpression must be cron of just numbers ex.: `0 5 * * 4`
-   * By default timezone is added " Europe/Prague"
+   * Creates and optionally schedules a singleton cron job.
+   *
+   * @param jobName - Logical name of the job (used in logs and errors).
+   * @param cronExpression - Cron expression consisting of numeric fields only.
+   * Example: `0 5 * * 4`
+   * The timezone `"Europe/Prague"` is applied automatically.
+   *
+   * @param jobEnabled - Whether the job should be scheduled immediately.
+   * If `false`, the instance exists but no cron trigger is registered.
+   *
+   * @throws Error If the cron expression is invalid.
+   * @throws Error If the job cannot be scheduled.
    */
   constructor(jobName, cronExpression, jobEnabled) {
-    super();
+    super(false);
+    /** Human-readable job identifier (used for logs and errors). */
     __publicField(this, "_jobName");
+    /**
+     * Cron expression defining when the job runs.
+     *
+     * Must contain numeric cron fields only.
+     * Example: `0 5 * * 4`
+     *
+     * Timezone is always forced to `"Europe/Prague"`.
+     * If you need another timezone, this class is not your friend.
+     */
     __publicField(this, "_cronExpression");
+    /** Scheduled job instance, or `null` if the job is disabled. */
     __publicField(this, "_job", null);
     this._jobName = jobName;
     if (!isValidCron(cronExpression)) {
@@ -1325,28 +1436,68 @@ var _FreshJob = class _FreshJob extends Singleton {
     }
     this.onInit();
   }
-  /** Just logging */
+  /**
+   * Initialization hook.
+   *
+   * Called once during construction and used primarily for logging.
+   * Can also be reused by subclasses if manual rescheduling is implemented.
+   *
+   * @param rescheduled - Indicates whether the job was reconfigured
+   * after initial creation.
+   */
   onInit(rescheduled) {
     console.log(`Job ${this.jobName} ${rescheduled ? "rescheduled" : "initialized"} with cron rule: "${this.cronExpression}"`);
   }
+  /** @returns The logical name of the job. */
   get jobName() {
     return this._jobName;
   }
+  /** Allows subclasses to rename the job if absolutely necessary. */
   set jobName(value) {
     this._jobName = value;
   }
+  /** @returns The cron expression used to schedule the job. */
   get cronExpression() {
     return this._cronExpression;
   }
+  /**
+   * Allows subclasses to update the cron expression internally.
+   * Does reschedule of job if exists
+   */
   set cronExpression(value) {
+    if (!isValidCron(value)) {
+      throw new Error(`Job ${this._jobName} cannot be re-scheduled with invalid cron: "${value}"`);
+    }
     this._cronExpression = value;
   }
+  /** @returns The underlying scheduled job instance, or `null` if disabled. */
   get job() {
     return this._job;
   }
+  /** Allows subclasses to manage the scheduled job instance. */
   set job(value) {
     this._job = value;
   }
+  reschedule(newCronExpression) {
+    let result = false;
+    if (!isValidCron(newCronExpression)) {
+      throw new Error(`Job ${this._jobName} cannot be re-scheduled with invalid cron: "${newCronExpression}"`);
+    }
+    this._cronExpression = newCronExpression;
+    if (this._job) {
+      const rescheduleSuccess = this._job.reschedule({
+        rule: this._cronExpression,
+        tz: "Europe/Prague"
+      });
+      if (!rescheduleSuccess) {
+        throw new Error(`Job ${this._jobName} could not be re-scheduled`);
+      } else {
+        this.onInit(true);
+      }
+      result = rescheduleSuccess;
+    }
+    return result;
+  }
 };
 __name(_FreshJob, "FreshJob");
 var FreshJob = _FreshJob;
@@ -1370,6 +1521,12 @@ var _ApiError = class _ApiError extends Error {
 __name(_ApiError, "ApiError");
 var ApiError = _ApiError;
 
+// src/types/maybe-type.ts
+function isMaybe(v, inner) {
+  return v === null || inner(v);
+}
+__name(isMaybe, "isMaybe");
+
 // src/config/eslint-config.ts
 var import_typescript_eslint = __toESM(require("typescript-eslint"));
 var import_eslint_plugin_prettier = __toESM(require("eslint-plugin-prettier"));
@@ -1581,6 +1738,14 @@ var datasource_default = PG_DATA_SOURCE_OPTIONS;
   TransactionType,
   createDeferred,
   freshEslintConfig,
+  hasOwn,
+  isEnumValue,
+  isFlag01,
+  isMaybe,
+  isNumber,
+  isNumberInRange,
+  isObject,
+  isString,
   isValidCron,
   logger
 });