@freshpointcz/fresh-core 0.0.11 → 0.0.12

package/dist/index.js

@@ -0,0 +1,1328 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+
+// ../../node_modules/dotenv/package.json
+var require_package = __commonJS({
+  "../../node_modules/dotenv/package.json"(exports2, module2) {
+    module2.exports = {
+      name: "dotenv",
+      version: "16.6.1",
+      description: "Loads environment variables from .env file",
+      main: "lib/main.js",
+      types: "lib/main.d.ts",
+      exports: {
+        ".": {
+          types: "./lib/main.d.ts",
+          require: "./lib/main.js",
+          default: "./lib/main.js"
+        },
+        "./config": "./config.js",
+        "./config.js": "./config.js",
+        "./lib/env-options": "./lib/env-options.js",
+        "./lib/env-options.js": "./lib/env-options.js",
+        "./lib/cli-options": "./lib/cli-options.js",
+        "./lib/cli-options.js": "./lib/cli-options.js",
+        "./package.json": "./package.json"
+      },
+      scripts: {
+        "dts-check": "tsc --project tests/types/tsconfig.json",
+        lint: "standard",
+        pretest: "npm run lint && npm run dts-check",
+        test: "tap run --allow-empty-coverage --disable-coverage --timeout=60000",
+        "test:coverage": "tap run --show-full-coverage --timeout=60000 --coverage-report=text --coverage-report=lcov",
+        prerelease: "npm test",
+        release: "standard-version"
+      },
+      repository: {
+        type: "git",
+        url: "git://github.com/motdotla/dotenv.git"
+      },
+      homepage: "https://github.com/motdotla/dotenv#readme",
+      funding: "https://dotenvx.com",
+      keywords: [
+        "dotenv",
+        "env",
+        ".env",
+        "environment",
+        "variables",
+        "config",
+        "settings"
+      ],
+      readmeFilename: "README.md",
+      license: "BSD-2-Clause",
+      devDependencies: {
+        "@types/node": "^18.11.3",
+        decache: "^4.6.2",
+        sinon: "^14.0.1",
+        standard: "^17.0.0",
+        "standard-version": "^9.5.0",
+        tap: "^19.2.0",
+        typescript: "^4.8.4"
+      },
+      engines: {
+        node: ">=12"
+      },
+      browser: {
+        fs: false
+      }
+    };
+  }
+});
+
+// ../../node_modules/dotenv/lib/main.js
+var require_main = __commonJS({
+  "../../node_modules/dotenv/lib/main.js"(exports2, module2) {
+    "use strict";
+    var fs = require("fs");
+    var path2 = require("path");
+    var os = require("os");
+    var crypto = require("crypto");
+    var packageJson = require_package();
+    var version = packageJson.version;
+    var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+    function parse(src) {
+      const obj = {};
+      let lines = src.toString();
+      lines = lines.replace(/\r\n?/mg, "\n");
+      let match;
+      while ((match = LINE.exec(lines)) != null) {
+        const key = match[1];
+        let value = match[2] || "";
+        value = value.trim();
+        const maybeQuote = value[0];
+        value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
+        if (maybeQuote === '"') {
+          value = value.replace(/\\n/g, "\n");
+          value = value.replace(/\\r/g, "\r");
+        }
+        obj[key] = value;
+      }
+      return obj;
+    }
+    function _parseVault(options) {
+      options = options || {};
+      const vaultPath = _vaultPath(options);
+      options.path = vaultPath;
+      const result = DotenvModule.configDotenv(options);
+      if (!result.parsed) {
+        const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+        err.code = "MISSING_DATA";
+        throw err;
+      }
+      const keys = _dotenvKey(options).split(",");
+      const length = keys.length;
+      let decrypted;
+      for (let i = 0; i < length; i++) {
+        try {
+          const key = keys[i].trim();
+          const attrs = _instructions(result, key);
+          decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+          break;
+        } catch (error) {
+          if (i + 1 >= length) {
+            throw error;
+          }
+        }
+      }
+      return DotenvModule.parse(decrypted);
+    }
+    function _warn(message) {
+      console.log(`[dotenv@${version}][WARN] ${message}`);
+    }
+    function _debug(message) {
+      console.log(`[dotenv@${version}][DEBUG] ${message}`);
+    }
+    function _log(message) {
+      console.log(`[dotenv@${version}] ${message}`);
+    }
+    function _dotenvKey(options) {
+      if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+        return options.DOTENV_KEY;
+      }
+      if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+        return process.env.DOTENV_KEY;
+      }
+      return "";
+    }
+    function _instructions(result, dotenvKey) {
+      let uri;
+      try {
+        uri = new URL(dotenvKey);
+      } catch (error) {
+        if (error.code === "ERR_INVALID_URL") {
+          const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        }
+        throw error;
+      }
+      const key = uri.password;
+      if (!key) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing key part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environment = uri.searchParams.get("environment");
+      if (!environment) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+      const ciphertext = result.parsed[environmentKey];
+      if (!ciphertext) {
+        const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+        err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+        throw err;
+      }
+      return { ciphertext, key };
+    }
+    function _vaultPath(options) {
+      let possibleVaultPath = null;
+      if (options && options.path && options.path.length > 0) {
+        if (Array.isArray(options.path)) {
+          for (const filepath of options.path) {
+            if (fs.existsSync(filepath)) {
+              possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+            }
+          }
+        } else {
+          possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+        }
+      } else {
+        possibleVaultPath = path2.resolve(process.cwd(), ".env.vault");
+      }
+      if (fs.existsSync(possibleVaultPath)) {
+        return possibleVaultPath;
+      }
+      return null;
+    }
+    function _resolveHome(envPath) {
+      return envPath[0] === "~" ? path2.join(os.homedir(), envPath.slice(1)) : envPath;
+    }
+    function _configVault(options) {
+      const debug = Boolean(options && options.debug);
+      const quiet = options && "quiet" in options ? options.quiet : true;
+      if (debug || !quiet) {
+        _log("Loading env from encrypted .env.vault");
+      }
+      const parsed = DotenvModule._parseVault(options);
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      DotenvModule.populate(processEnv, parsed, options);
+      return { parsed };
+    }
+    function configDotenv(options) {
+      const dotenvPath = path2.resolve(process.cwd(), ".env");
+      let encoding = "utf8";
+      const debug = Boolean(options && options.debug);
+      const quiet = options && "quiet" in options ? options.quiet : true;
+      if (options && options.encoding) {
+        encoding = options.encoding;
+      } else {
+        if (debug) {
+          _debug("No encoding is specified. UTF-8 is used by default");
+        }
+      }
+      let optionPaths = [dotenvPath];
+      if (options && options.path) {
+        if (!Array.isArray(options.path)) {
+          optionPaths = [_resolveHome(options.path)];
+        } else {
+          optionPaths = [];
+          for (const filepath of options.path) {
+            optionPaths.push(_resolveHome(filepath));
+          }
+        }
+      }
+      let lastError;
+      const parsedAll = {};
+      for (const path3 of optionPaths) {
+        try {
+          const parsed = DotenvModule.parse(fs.readFileSync(path3, { encoding }));
+          DotenvModule.populate(parsedAll, parsed, options);
+        } catch (e) {
+          if (debug) {
+            _debug(`Failed to load ${path3} ${e.message}`);
+          }
+          lastError = e;
+        }
+      }
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      DotenvModule.populate(processEnv, parsedAll, options);
+      if (debug || !quiet) {
+        const keysCount = Object.keys(parsedAll).length;
+        const shortPaths = [];
+        for (const filePath of optionPaths) {
+          try {
+            const relative = path2.relative(process.cwd(), filePath);
+            shortPaths.push(relative);
+          } catch (e) {
+            if (debug) {
+              _debug(`Failed to load ${filePath} ${e.message}`);
+            }
+            lastError = e;
+          }
+        }
+        _log(`injecting env (${keysCount}) from ${shortPaths.join(",")}`);
+      }
+      if (lastError) {
+        return { parsed: parsedAll, error: lastError };
+      } else {
+        return { parsed: parsedAll };
+      }
+    }
+    function config2(options) {
+      if (_dotenvKey(options).length === 0) {
+        return DotenvModule.configDotenv(options);
+      }
+      const vaultPath = _vaultPath(options);
+      if (!vaultPath) {
+        _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
+        return DotenvModule.configDotenv(options);
+      }
+      return DotenvModule._configVault(options);
+    }
+    function decrypt(encrypted, keyStr) {
+      const key = Buffer.from(keyStr.slice(-64), "hex");
+      let ciphertext = Buffer.from(encrypted, "base64");
+      const nonce = ciphertext.subarray(0, 12);
+      const authTag = ciphertext.subarray(-16);
+      ciphertext = ciphertext.subarray(12, -16);
+      try {
+        const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+        aesgcm.setAuthTag(authTag);
+        return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+      } catch (error) {
+        const isRange = error instanceof RangeError;
+        const invalidKeyLength = error.message === "Invalid key length";
+        const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
+        if (isRange || invalidKeyLength) {
+          const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        } else if (decryptionFailed) {
+          const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+          err.code = "DECRYPTION_FAILED";
+          throw err;
+        } else {
+          throw error;
+        }
+      }
+    }
+    function populate(processEnv, parsed, options = {}) {
+      const debug = Boolean(options && options.debug);
+      const override = Boolean(options && options.override);
+      if (typeof parsed !== "object") {
+        const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+        err.code = "OBJECT_REQUIRED";
+        throw err;
+      }
+      for (const key of Object.keys(parsed)) {
+        if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+          if (override === true) {
+            processEnv[key] = parsed[key];
+          }
+          if (debug) {
+            if (override === true) {
+              _debug(`"${key}" is already defined and WAS overwritten`);
+            } else {
+              _debug(`"${key}" is already defined and was NOT overwritten`);
+            }
+          }
+        } else {
+          processEnv[key] = parsed[key];
+        }
+      }
+    }
+    var DotenvModule = {
+      configDotenv,
+      _configVault,
+      _parseVault,
+      config: config2,
+      decrypt,
+      parse,
+      populate
+    };
+    module2.exports.configDotenv = DotenvModule.configDotenv;
+    module2.exports._configVault = DotenvModule._configVault;
+    module2.exports._parseVault = DotenvModule._parseVault;
+    module2.exports.config = DotenvModule.config;
+    module2.exports.decrypt = DotenvModule.decrypt;
+    module2.exports.parse = DotenvModule.parse;
+    module2.exports.populate = DotenvModule.populate;
+    module2.exports = DotenvModule;
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AMOUNT_UNIT: () => AMOUNT_UNIT,
+  ActionCommandCode: () => ActionCommandCode,
+  ApiError: () => ApiError,
+  Category: () => Category,
+  DataHelper: () => DataHelper,
+  DateUtils: () => DateUtils,
+  DepotPoolStatus: () => DepotPoolStatus,
+  Device: () => Device,
+  FreshDao: () => FreshDao,
+  FreshEntity: () => FreshEntity,
+  FreshHyperEntity: () => FreshHyperEntity,
+  FreshJob: () => FreshJob,
+  FreshTranslationBase: () => FreshTranslationBase,
+  HttpStatus: () => HttpStatus,
+  LanguageCode: () => LanguageCode,
+  Manufacturer: () => Manufacturer,
+  PaymentMethod: () => PaymentMethod,
+  PgDataSourceOptions: () => datasource_default,
+  Product: () => Product,
+  SinglePromiseWaiter: () => SinglePromiseWaiter,
+  Singleton: () => Singleton,
+  StatusDto: () => StatusDto,
+  Subcategory: () => Subcategory,
+  TimestampColumn: () => TimestampColumn,
+  TransactionType: () => TransactionType,
+  createDeferred: () => createDeferred,
+  freshEslintConfig: () => eslint_config_default,
+  isValidCron: () => isValidCron,
+  logger: () => logger
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/common/date-utils.ts
+var import_dayjs = __toESM(require("dayjs"));
+var import_utc = __toESM(require("dayjs/plugin/utc"));
+var import_timezone = __toESM(require("dayjs/plugin/timezone"));
+var import_isBetween = __toESM(require("dayjs/plugin/isBetween"));
+var import_customParseFormat = __toESM(require("dayjs/plugin/customParseFormat"));
+import_dayjs.default.extend(import_utc.default);
+import_dayjs.default.extend(import_timezone.default);
+import_dayjs.default.extend(import_isBetween.default);
+import_dayjs.default.extend(import_customParseFormat.default);
+var _DateUtils = class _DateUtils {
+  //#endregion
+  //#region SQL timestamps
+  static fromISOtoSQLtimestamp(ts) {
+    return (0, import_dayjs.default)(ts).utc().format("YYYY-MM-DD HH:mm:ss");
+  }
+  static toSQLtimestamp(ts) {
+    return ts.format("YYYY-MM-DD HH:mm:ss");
+  }
+  static fromSQLtimestamp(mysqlDate) {
+    return (0, import_dayjs.default)(mysqlDate, "YYYY-MM-DD HH:mm:ss").utc(true);
+  }
+  static getSqlTimestampFromNowCzech() {
+    return _DateUtils.toSQLtimestamp(_DateUtils.getNowCzech());
+  }
+  //#endregion
+  // ---------- UTC
+  static fromISO(isoDate) {
+    return (0, import_dayjs.default)(isoDate).utc(false);
+  }
+  // ----------
+  static getDate(ts) {
+    return (0, import_dayjs.default)(ts);
+  }
+  static getNow() {
+    return (0, import_dayjs.default)();
+  }
+  static getNowCzech() {
+    return (0, import_dayjs.default)().tz("Europe/Prague").utc(true);
+  }
+  static clone(ts) {
+    return (0, import_dayjs.default)(ts);
+  }
+  static getLastSunday(weeksOffset = 0) {
+    let now = _DateUtils.getNowCzech();
+    now = now.date(now.date() - (now.day() + 1) % 7 - 7 * weeksOffset);
+    now = now.hour(0);
+    now = now.minute(0);
+    now = now.second(0);
+    now = now.millisecond(0);
+    return now;
+  }
+  static dayInWeek(ts) {
+    const input = ts != null ? ts : (0, import_dayjs.default)();
+    const day = input.day();
+    if (day === 0) {
+      return 7;
+    }
+    return day;
+  }
+  static isWorkdayDay(ts) {
+    const weekDay = ts.get("day");
+    if (weekDay === 0) {
+      return false;
+    }
+    if (weekDay === 6) {
+      return false;
+    }
+    ts = ts.set("hour", 0).set("minutes", 0).set("seconds", 0).set("milliseconds", 0);
+    return !_DateUtils.HOLIDAYS.includes(ts.valueOf());
+  }
+  static getDiffInMinutesWithNow(inputTime) {
+    const now = (0, import_dayjs.default)();
+    const diffInMinutes = now.diff(inputTime, "minute");
+    return diffInMinutes;
+  }
+  static isInLastDays(numOfDays, timestampInput) {
+    const timestamp = typeof timestampInput === "string" ? (0, import_dayjs.default)(timestampInput) : timestampInput;
+    const now = (0, import_dayjs.default)();
+    const dateLimit = now.subtract(numOfDays, "day");
+    return timestamp.isAfter(dateLimit);
+  }
+};
+//#region Holidays
+/** Holidays 2025-2030 as YYYY-MM-DD strings */
+_DateUtils.HOLIDAYS_STR = [
+  /* 2025 */
+  "2025-01-01",
+  "2025-04-18",
+  "2025-04-21",
+  "2025-05-01",
+  "2025-05-08",
+  "2025-07-05",
+  "2025-07-06",
+  "2025-09-28",
+  "2025-10-28",
+  "2025-11-17",
+  "2025-12-24",
+  "2025-12-25",
+  "2025-12-26",
+  /* 2026 */
+  "2026-01-01",
+  "2026-04-03",
+  "2026-04-06",
+  "2026-05-01",
+  "2026-05-08",
+  "2026-07-05",
+  "2026-07-06",
+  "2026-09-28",
+  "2026-10-28",
+  "2026-11-17",
+  "2026-12-24",
+  "2026-12-25",
+  "2026-12-26",
+  /* 2027 */
+  "2027-01-01",
+  "2027-03-26",
+  "2027-03-29",
+  "2027-05-01",
+  "2027-05-08",
+  "2027-07-05",
+  "2027-07-06",
+  "2027-09-28",
+  "2027-10-28",
+  "2027-11-17",
+  "2027-12-24",
+  "2027-12-25",
+  "2027-12-26",
+  /* 2028 */
+  "2028-01-01",
+  "2028-04-14",
+  "2028-04-17",
+  "2028-05-01",
+  "2028-05-08",
+  "2028-07-05",
+  "2028-07-06",
+  "2028-09-28",
+  "2028-10-28",
+  "2028-11-17",
+  "2028-12-24",
+  "2028-12-25",
+  "2028-12-26",
+  /* 2029 */
+  "2029-01-01",
+  "2029-03-30",
+  "2029-04-02",
+  "2029-05-01",
+  "2029-05-08",
+  "2029-07-05",
+  "2029-07-06",
+  "2029-09-28",
+  "2029-10-28",
+  "2029-11-17",
+  "2029-12-24",
+  "2029-12-25",
+  "2029-12-26",
+  /* 2030 */
+  "2030-01-01",
+  "2030-04-19",
+  "2030-04-22",
+  "2030-05-01",
+  "2030-05-08",
+  "2030-07-05",
+  "2030-07-06",
+  "2030-09-28",
+  "2030-10-28",
+  "2030-11-17",
+  "2030-12-24",
+  "2030-12-25",
+  "2030-12-26"
+];
+/** Holidays 2025-2030 as UTC timestamps */
+_DateUtils.HOLIDAYS = _DateUtils.HOLIDAYS_STR.map((h) => {
+  const date = new Date(h);
+  date.setUTCHours(0, 0, 0, 0);
+  return date.getTime();
+});
+var DateUtils = _DateUtils;
+
+// src/common/promise-magic/deferred.ts
+function createDeferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+
+// src/common/promise-magic/single-promise-waiter.ts
+var SinglePromiseWaiter = class _SinglePromiseWaiter {
+  constructor() {
+    this._promise = null;
+  }
+  static getInstance() {
+    if (!_SinglePromiseWaiter._instance) {
+      _SinglePromiseWaiter._instance = new _SinglePromiseWaiter();
+    }
+    return _SinglePromiseWaiter._instance;
+  }
+  get promise() {
+    return this._promise;
+  }
+  set promise(promise) {
+    if (promise !== null) {
+      this._promise = promise;
+      this._promise.finally(() => {
+        this._promise = null;
+      });
+    }
+  }
+  get hasPromise() {
+    return this._promise !== null;
+  }
+};
+
+// src/common/winston.ts
+var import_winston = __toESM(require("winston"));
+var SERVICE = process.env.SERVICE_NAME || "depot-ordering-service";
+var ENV = process.env.NODE_ENV || "localhost";
+var levelToSeverity = {
+  silly: "debug",
+  verbose: "debug",
+  debug: "debug",
+  http: "info",
+  info: "info",
+  warn: "warn",
+  error: "error"
+};
+var baseFormat = import_winston.default.format.combine(
+  import_winston.default.format.timestamp({ format: () => (/* @__PURE__ */ new Date()).toISOString() }),
+  import_winston.default.format.errors({ stack: true }),
+  import_winston.default.format.printf((info) => {
+    const payload = {
+      ts: info.timestamp,
+      level: info.level,
+      severity: levelToSeverity[info.level] || info.level,
+      message: info.message,
+      service: SERVICE,
+      env: ENV,
+      process_name: process.title || process.argv[1] || "node",
+      pid: process.pid,
+      device: process.env.DEVICE_ID || void 0,
+      traceId: info.traceId,
+      spanId: info.spanId,
+      extra: info.extra || info.meta || void 0,
+      stack: info.stack
+    };
+    return JSON.stringify(payload);
+  })
+);
+var transports = [
+  new import_winston.default.transports.Console({
+    level: process.env.LOG_LEVEL || "info"
+  })
+];
+var logger = import_winston.default.createLogger({
+  level: process.env.LOG_LEVEL || "info",
+  format: baseFormat,
+  transports,
+  exitOnError: false
+});
+logger.stream = {
+  write: (message) => logger.info(message.trim())
+};
+
+// src/common/utils/is-cron-valid.ts
+function isValidCron(expr) {
+  const parts = expr.trim().split(/\s+/);
+  if (parts.length < 5 || parts.length > 6) {
+    return false;
+  }
+  const cronPart = /^(\*|\d+|\d+\-\d+|\d+\/\d+|\*\/\d+)(,\d+)*$/;
+  return parts.every((part) => cronPart.test(part));
+}
+
+// src/common/patterns/singleton.ts
+var _Singleton = class _Singleton {
+  constructor() {
+    const ctor = this.constructor;
+    const existing = _Singleton.instances.get(ctor);
+    if (existing) {
+      return existing;
+    }
+    _Singleton.instances.set(ctor, this);
+  }
+};
+_Singleton.instances = /* @__PURE__ */ new Map();
+var Singleton = _Singleton;
+
+// src/common/dto/status-dto.ts
+var StatusDto = class {
+  constructor(status, details, timestamp) {
+    this.status = status;
+    this.details = details;
+    this.timestamp = timestamp != null ? timestamp : DateUtils.getNowCzech().toISOString();
+  }
+};
+
+// src/common/constants/amount-unit.ts
+var AMOUNT_UNIT = {
+  1: { symbol: "g", translations: { en: "gram", cs: "gram" } },
+  2: { symbol: "kg", translations: { en: "kilogram", cs: "kilogram" } },
+  3: { symbol: "ml", translations: { en: "milliliter", cs: "mililitr" } },
+  4: { symbol: "l", translations: { en: "liter", cs: "litr" } }
+};
+
+// src/common/schema/entities/category.entity.ts
+var import_typeorm5 = require("typeorm");
+
+// src/database/entities/fresh-entity.ts
+var import_typeorm = require("typeorm");
+
+// ../../node_modules/uuid/dist/esm/stringify.js
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+
+// ../../node_modules/uuid/dist/esm/rng.js
+var import_crypto = require("crypto");
+var rnds8Pool = new Uint8Array(256);
+var poolPtr = rnds8Pool.length;
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    (0, import_crypto.randomFillSync)(rnds8Pool);
+    poolPtr = 0;
+  }
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
+
+// ../../node_modules/uuid/dist/esm/native.js
+var import_crypto2 = require("crypto");
+var native_default = { randomUUID: import_crypto2.randomUUID };
+
+// ../../node_modules/uuid/dist/esm/v4.js
+function v4(options, buf, offset) {
+  var _a, _b, _c;
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  options = options || {};
+  const rnds = (_c = (_b = options.random) != null ? _b : (_a = options.rng) == null ? void 0 : _a.call(options)) != null ? _c : rng();
+  if (rnds.length < 16) {
+    throw new Error("Random bytes length must be >= 16");
+  }
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+var v4_default = v4;
+
+// src/database/entities/fresh-entity.ts
+var FreshEntity = class extends import_typeorm.BaseEntity {
+  /** After manual construction `id` is irrelevant. Refer to `uuid` only, because that will be inserted into DB */
+  constructor() {
+    super();
+    this.id = 0;
+    this.uuid = v4_default();
+    const newDate = /* @__PURE__ */ new Date();
+    this.created_at = newDate;
+    this.updated_at = newDate;
+    this.deleted_at = null;
+  }
+};
+__decorateClass([
+  (0, import_typeorm.PrimaryGeneratedColumn)("increment")
+], FreshEntity.prototype, "id", 2);
+__decorateClass([
+  (0, import_typeorm.Index)({ unique: true }),
+  (0, import_typeorm.Column)({ type: "uuid", default: () => "timescale.uuid_generate_v4()" })
+], FreshEntity.prototype, "uuid", 2);
+__decorateClass([
+  (0, import_typeorm.CreateDateColumn)({ type: "timestamptz" })
+], FreshEntity.prototype, "created_at", 2);
+__decorateClass([
+  (0, import_typeorm.UpdateDateColumn)({ type: "timestamptz" })
+], FreshEntity.prototype, "updated_at", 2);
+__decorateClass([
+  (0, import_typeorm.DeleteDateColumn)({ type: "timestamptz", nullable: true })
+], FreshEntity.prototype, "deleted_at", 2);
+
+// src/database/entities/fresh-hyper-entity.ts
+var import_typeorm3 = require("typeorm");
+
+// src/database/decorators/timestamp-column.ts
+var import_typeorm2 = require("typeorm");
+function TimestampColumn(options = {}) {
+  const defaultOptions = {
+    type: "timestamptz",
+    nullable: false,
+    default: () => "CURRENT_TIMESTAMP",
+    ...options
+  };
+  return (0, import_typeorm2.Column)(defaultOptions);
+}
+
+// src/database/entities/fresh-hyper-entity.ts
+var FreshHyperEntity = class extends import_typeorm3.BaseEntity {
+  /** After manual construction `id` is irrelevant */
+  constructor(timestamp) {
+    super();
+    this.timestamp = timestamp != null ? timestamp : /* @__PURE__ */ new Date();
+    this.created_at = /* @__PURE__ */ new Date();
+  }
+};
+__decorateClass([
+  (0, import_typeorm3.PrimaryColumn)({ type: "timestamptz" })
+], FreshHyperEntity.prototype, "timestamp", 2);
+__decorateClass([
+  TimestampColumn()
+], FreshHyperEntity.prototype, "created_at", 2);
+
+// src/database/entities/fresh-translation-entity.ts
+var import_typeorm4 = require("typeorm");
+
+// src/enums/action-command-code.ts
+var ActionCommandCode = /* @__PURE__ */ ((ActionCommandCode2) => {
+  ActionCommandCode2[ActionCommandCode2["RESTART_PC"] = 1] = "RESTART_PC";
+  ActionCommandCode2[ActionCommandCode2["RESTART_APPLICATION"] = 2] = "RESTART_APPLICATION";
+  ActionCommandCode2[ActionCommandCode2["RESTART_ROUTER"] = 3] = "RESTART_ROUTER";
+  ActionCommandCode2[ActionCommandCode2["RESTART_REMOTE_CONTROL"] = 4] = "RESTART_REMOTE_CONTROL";
+  ActionCommandCode2[ActionCommandCode2["SYNCHRONIZE"] = 5] = "SYNCHRONIZE";
+  ActionCommandCode2[ActionCommandCode2["DIAGNOSE_LOCKS"] = 6] = "DIAGNOSE_LOCKS";
+  ActionCommandCode2[ActionCommandCode2["SYNCHRONIZE_CONFIG"] = 7] = "SYNCHRONIZE_CONFIG";
+  return ActionCommandCode2;
+})(ActionCommandCode || {});
+
+// src/enums/depot-pool-status.ts
+var DepotPoolStatus = /* @__PURE__ */ ((DepotPoolStatus2) => {
+  DepotPoolStatus2[DepotPoolStatus2["NEW"] = 0] = "NEW";
+  DepotPoolStatus2[DepotPoolStatus2["PICKED"] = 1] = "PICKED";
+  DepotPoolStatus2[DepotPoolStatus2["WRITTEN_OFF"] = 2] = "WRITTEN_OFF";
+  DepotPoolStatus2[DepotPoolStatus2["ACTIVE"] = 3] = "ACTIVE";
+  DepotPoolStatus2[DepotPoolStatus2["TERMINATED"] = 4] = "TERMINATED";
+  return DepotPoolStatus2;
+})(DepotPoolStatus || {});
+
+// src/enums/http-status.ts
+var HttpStatus = /* @__PURE__ */ ((HttpStatus2) => {
+  HttpStatus2[HttpStatus2["CONTINUE"] = 100] = "CONTINUE";
+  HttpStatus2[HttpStatus2["SWITCHING_PROTOCOLS"] = 101] = "SWITCHING_PROTOCOLS";
+  HttpStatus2[HttpStatus2["PROCESSING"] = 102] = "PROCESSING";
+  HttpStatus2[HttpStatus2["EARLY_HINTS"] = 103] = "EARLY_HINTS";
+  HttpStatus2[HttpStatus2["OK"] = 200] = "OK";
+  HttpStatus2[HttpStatus2["CREATED"] = 201] = "CREATED";
+  HttpStatus2[HttpStatus2["ACCEPTED"] = 202] = "ACCEPTED";
+  HttpStatus2[HttpStatus2["NON_AUTHORITATIVE_INFORMATION"] = 203] = "NON_AUTHORITATIVE_INFORMATION";
+  HttpStatus2[HttpStatus2["NO_CONTENT"] = 204] = "NO_CONTENT";
+  HttpStatus2[HttpStatus2["RESET_CONTENT"] = 205] = "RESET_CONTENT";
+  HttpStatus2[HttpStatus2["PARTIAL_CONTENT"] = 206] = "PARTIAL_CONTENT";
+  HttpStatus2[HttpStatus2["MULTI_STATUS"] = 207] = "MULTI_STATUS";
+  HttpStatus2[HttpStatus2["ALREADY_REPORTED"] = 208] = "ALREADY_REPORTED";
+  HttpStatus2[HttpStatus2["IM_USED"] = 226] = "IM_USED";
+  HttpStatus2[HttpStatus2["MULTIPLE_CHOICES"] = 300] = "MULTIPLE_CHOICES";
+  HttpStatus2[HttpStatus2["MOVED_PERMANENTLY"] = 301] = "MOVED_PERMANENTLY";
+  HttpStatus2[HttpStatus2["FOUND"] = 302] = "FOUND";
+  HttpStatus2[HttpStatus2["SEE_OTHER"] = 303] = "SEE_OTHER";
+  HttpStatus2[HttpStatus2["NOT_MODIFIED"] = 304] = "NOT_MODIFIED";
+  HttpStatus2[HttpStatus2["USE_PROXY"] = 305] = "USE_PROXY";
+  HttpStatus2[HttpStatus2["TEMPORARY_REDIRECT"] = 307] = "TEMPORARY_REDIRECT";
+  HttpStatus2[HttpStatus2["PERMANENT_REDIRECT"] = 308] = "PERMANENT_REDIRECT";
+  HttpStatus2[HttpStatus2["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+  HttpStatus2[HttpStatus2["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+  HttpStatus2[HttpStatus2["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
+  HttpStatus2[HttpStatus2["FORBIDDEN"] = 403] = "FORBIDDEN";
+  HttpStatus2[HttpStatus2["NOT_FOUND"] = 404] = "NOT_FOUND";
+  HttpStatus2[HttpStatus2["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
+  HttpStatus2[HttpStatus2["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
+  HttpStatus2[HttpStatus2["PROXY_AUTHENTICATION_REQUIRED"] = 407] = "PROXY_AUTHENTICATION_REQUIRED";
+  HttpStatus2[HttpStatus2["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
+  HttpStatus2[HttpStatus2["CONFLICT"] = 409] = "CONFLICT";
+  HttpStatus2[HttpStatus2["GONE"] = 410] = "GONE";
+  HttpStatus2[HttpStatus2["LENGTH_REQUIRED"] = 411] = "LENGTH_REQUIRED";
+  HttpStatus2[HttpStatus2["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
+  HttpStatus2[HttpStatus2["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
+  HttpStatus2[HttpStatus2["URI_TOO_LONG"] = 414] = "URI_TOO_LONG";
+  HttpStatus2[HttpStatus2["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
+  HttpStatus2[HttpStatus2["RANGE_NOT_SATISFIABLE"] = 416] = "RANGE_NOT_SATISFIABLE";
+  HttpStatus2[HttpStatus2["EXPECTATION_FAILED"] = 417] = "EXPECTATION_FAILED";
+  HttpStatus2[HttpStatus2["IM_A_TEAPOT"] = 418] = "IM_A_TEAPOT";
+  HttpStatus2[HttpStatus2["MISDIRECTED_REQUEST"] = 421] = "MISDIRECTED_REQUEST";
+  HttpStatus2[HttpStatus2["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+  HttpStatus2[HttpStatus2["LOCKED"] = 423] = "LOCKED";
+  HttpStatus2[HttpStatus2["FAILED_DEPENDENCY"] = 424] = "FAILED_DEPENDENCY";
+  HttpStatus2[HttpStatus2["TOO_EARLY"] = 425] = "TOO_EARLY";
+  HttpStatus2[HttpStatus2["UPGRADE_REQUIRED"] = 426] = "UPGRADE_REQUIRED";
+  HttpStatus2[HttpStatus2["PRECONDITION_REQUIRED"] = 428] = "PRECONDITION_REQUIRED";
+  HttpStatus2[HttpStatus2["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+  HttpStatus2[HttpStatus2["REQUEST_HEADER_FIELDS_TOO_LARGE"] = 431] = "REQUEST_HEADER_FIELDS_TOO_LARGE";
+  HttpStatus2[HttpStatus2["UNAVAILABLE_FOR_LEGAL_REASONS"] = 451] = "UNAVAILABLE_FOR_LEGAL_REASONS";
+  HttpStatus2[HttpStatus2["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+  HttpStatus2[HttpStatus2["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
+  HttpStatus2[HttpStatus2["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
+  HttpStatus2[HttpStatus2["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+  HttpStatus2[HttpStatus2["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
+  HttpStatus2[HttpStatus2["HTTP_VERSION_NOT_SUPPORTED"] = 505] = "HTTP_VERSION_NOT_SUPPORTED";
+  HttpStatus2[HttpStatus2["VARIANT_ALSO_NEGOTIATES"] = 506] = "VARIANT_ALSO_NEGOTIATES";
+  HttpStatus2[HttpStatus2["INSUFFICIENT_STORAGE"] = 507] = "INSUFFICIENT_STORAGE";
+  HttpStatus2[HttpStatus2["LOOP_DETECTED"] = 508] = "LOOP_DETECTED";
+  HttpStatus2[HttpStatus2["NOT_EXTENDED"] = 510] = "NOT_EXTENDED";
+  HttpStatus2[HttpStatus2["NETWORK_AUTHENTICATION_REQUIRED"] = 511] = "NETWORK_AUTHENTICATION_REQUIRED";
+  return HttpStatus2;
+})(HttpStatus || {});
+
+// src/enums/language-code.ts
+var LanguageCode = /* @__PURE__ */ ((LanguageCode2) => {
+  LanguageCode2["CS"] = "cs";
+  LanguageCode2["EN"] = "en";
+  LanguageCode2["DE"] = "de";
+  LanguageCode2["PL"] = "pl";
+  LanguageCode2["SK"] = "sk";
+  return LanguageCode2;
+})(LanguageCode || {});
+
+// src/enums/payment-method.ts
+var PaymentMethod = /* @__PURE__ */ ((PaymentMethod2) => {
+  PaymentMethod2[PaymentMethod2["CODE"] = 0] = "CODE";
+  PaymentMethod2[PaymentMethod2["CARD"] = 1] = "CARD";
+  PaymentMethod2[PaymentMethod2["NONE"] = 2] = "NONE";
+  return PaymentMethod2;
+})(PaymentMethod || {});
+
+// src/enums/transaction-type.ts
+var TransactionType = /* @__PURE__ */ ((TransactionType2) => {
+  TransactionType2[TransactionType2["WRITEOFF"] = 0] = "WRITEOFF";
+  TransactionType2[TransactionType2["SALE"] = 1] = "SALE";
+  TransactionType2[TransactionType2["LOST"] = 2] = "LOST";
+  TransactionType2[TransactionType2["ADD"] = 3] = "ADD";
+  TransactionType2[TransactionType2["DELIVERY"] = 4] = "DELIVERY";
+  TransactionType2[TransactionType2["DEPOT_WRITEOFF"] = 5] = "DEPOT_WRITEOFF";
+  TransactionType2[TransactionType2["DEPOT_ADD"] = 6] = "DEPOT_ADD";
+  TransactionType2[TransactionType2["RETURN"] = 7] = "RETURN";
+  TransactionType2[TransactionType2["INVENTORY_SURPLUS"] = 8] = "INVENTORY_SURPLUS";
+  TransactionType2[TransactionType2["INVENTORY_MISSING"] = 9] = "INVENTORY_MISSING";
+  return TransactionType2;
+})(TransactionType || {});
+
+// src/database/entities/fresh-translation-entity.ts
+var languageValues = Object.values(LanguageCode).map((v) => `'${v}'`).join(",");
+var FreshTranslationBase = class extends import_typeorm4.BaseEntity {
+  constructor() {
+    super();
+    this.id = 0;
+    this.languageCode = "cs" /* CS */;
+  }
+};
+__decorateClass([
+  (0, import_typeorm4.PrimaryGeneratedColumn)()
+], FreshTranslationBase.prototype, "id", 2);
+__decorateClass([
+  (0, import_typeorm4.Column)({
+    type: "varchar",
+    length: 3,
+    nullable: false
+  }),
+  (0, import_typeorm4.Check)(`"languageCode" IN (${languageValues})`)
+], FreshTranslationBase.prototype, "languageCode", 2);
+
+// src/database/dao/fresh-dao.ts
+var FreshDao = class {
+};
+
+// src/common/schema/entities/category.entity.ts
+var Category = class extends FreshEntity {
+  // ...
+};
+Category = __decorateClass([
+  (0, import_typeorm5.Entity)()
+], Category);
+
+// src/common/schema/entities/device.entity.ts
+var import_typeorm6 = require("typeorm");
+var Device = class extends FreshEntity {
+  // ...
+};
+Device = __decorateClass([
+  (0, import_typeorm6.Entity)()
+], Device);
+
+// src/common/schema/entities/manufacturer.entity.ts
+var import_typeorm7 = require("typeorm");
+var Manufacturer = class extends FreshEntity {
+  // ...
+};
+Manufacturer = __decorateClass([
+  (0, import_typeorm7.Entity)()
+], Manufacturer);
+
+// src/common/schema/entities/product.entity.ts
+var import_typeorm8 = require("typeorm");
+var Product = class extends FreshEntity {
+  // ...
+};
+Product = __decorateClass([
+  (0, import_typeorm8.Entity)()
+], Product);
+
+// src/common/schema/entities/subcategory.entity.ts
+var import_typeorm9 = require("typeorm");
+var Subcategory = class extends FreshEntity {
+  // ...
+};
+Subcategory = __decorateClass([
+  (0, import_typeorm9.Entity)()
+], Subcategory);
+
+// src/core/data-helper.ts
+var DataHelper = class {
+  constructor(startDataRetrieve = true, deviceIds) {
+    this._dataPromise = null;
+    this.deviceIds = deviceIds;
+    if (startDataRetrieve) {
+      this._dataPromise = this.startDataRetrieval();
+    }
+  }
+  get data() {
+    return this._data;
+  }
+  set data(value) {
+    this._data = value;
+  }
+  get dataPromise() {
+    return this._dataPromise;
+  }
+  set dataPromise(value) {
+    this._dataPromise = value;
+  }
+  async getData() {
+    if (this._dataPromise) {
+      return await this._dataPromise;
+    }
+    if (this._data === void 0) {
+      this._dataPromise = this.startDataRetrieval();
+      return this._dataPromise;
+    }
+    return this._data;
+  }
+};
+
+// src/core/class/fresh-job.ts
+var import_node_schedule = require("node-schedule");
+var FreshJob = class extends Singleton {
+  /**
+   * @param cronExpression must be cron of just numbers ex.: `0 5 * * 4`
+   * By default timezone is added " Europe/Prague"
+   */
+  constructor(jobName, cronExpression, jobEnabled) {
+    super();
+    this._job = null;
+    this._jobName = jobName;
+    if (!isValidCron(cronExpression)) {
+      throw new Error(
+        `Job ${this.jobName} cannot be constructed with invalid cron: "${cronExpression}"`
+      );
+    }
+    this._cronExpression = cronExpression;
+    if (jobEnabled) {
+      this._job = (0, import_node_schedule.scheduleJob)(
+        { rule: this._cronExpression, tz: "Europe/Prague" },
+        async () => {
+          await this.invoke();
+        }
+      );
+      if (!this._job) {
+        throw new Error(`Job ${this._jobName} could not be scheduled`);
+      }
+    }
+    this.onInit();
+  }
+  /** Just logging */
+  onInit(rescheduled) {
+    console.log(
+      `Job ${this.jobName} ${rescheduled ? "rescheduled" : "initialized"} with cron rule: "${this.cronExpression}"`
+    );
+  }
+  get jobName() {
+    return this._jobName;
+  }
+  set jobName(value) {
+    this._jobName = value;
+  }
+  get cronExpression() {
+    return this._cronExpression;
+  }
+  set cronExpression(value) {
+    this._cronExpression = value;
+  }
+  get job() {
+    return this._job;
+  }
+  set job(value) {
+    this._job = value;
+  }
+};
+
+// src/core/errors/api-error.ts
+var ApiError = class extends Error {
+  get statusCode() {
+    return this._statusCode;
+  }
+  get statusDto() {
+    return this._statusDto;
+  }
+  constructor(statusCode, status, detail) {
+    super();
+    this._statusCode = statusCode;
+    this._statusDto = new StatusDto(status, detail);
+  }
+};
+
+// src/config/eslint-config.ts
+var import_typescript_eslint = __toESM(require("typescript-eslint"));
+var import_eslint_plugin_prettier = __toESM(require("eslint-plugin-prettier"));
+var import_eslint_config_prettier = __toESM(require("eslint-config-prettier"));
+var FRESH_ESLINT_CONFIG = [
+  {
+    // Prettier integration
+    ...import_eslint_config_prettier.default,
+    // Affected files
+    files: ["**/*.ts", "**/*.tsx"],
+    ignores: [
+      "dist/**",
+      "node_modules/**",
+      "build/**",
+      "**/*.js",
+      "**/*.mjs",
+      "**/*-migration.ts",
+      "**/*-migration.js"
+    ],
+    languageOptions: {
+      parser: import_typescript_eslint.default.parser,
+      ecmaVersion: "latest",
+      sourceType: "module"
+    },
+    // Extra plugins declared
+    plugins: {
+      "@typescript-eslint": import_typescript_eslint.default.plugin,
+      prettier: import_eslint_plugin_prettier.default
+    },
+    rules: {
+      // Eslint rules
+      // no lets or vars
+      "prefer-const": "error",
+      // blocks ("red" === color) these ifs
+      yoda: ["error", "never"],
+      "no-multiple-empty-lines": ["error", { max: 1 }],
+      // semi-colons
+      semi: ["error", "always"],
+      // forces block for all control statements (forbid one-line returns)
+      curly: ["error", "all"],
+      // makes spaces between brackets
+      "object-curly-spacing": ["error", "always"],
+      // checks same if/else conditions
+      "no-dupe-else-if": "error",
+      // keeps imports from one package in same declaration
+      "no-duplicate-imports": "error",
+      // blocks simple '=' in condition blocks
+      "no-cond-assign": ["error", "always"],
+      // forbids promise inside promise
+      "no-async-promise-executor": "error",
+      // watches possible falltrough in switch cases
+      "no-fallthrough": "error",
+      // use === instead of ==
+      eqeqeq: ["error", "always"],
+      // Prettier formatting rules
+      "prettier/prettier": [
+        "error",
+        {
+          // max 100 chars per line
+          printWidth: 100,
+          // keep 4 spaces and no tabs
+          tabWidth: 4,
+          useTabs: false,
+          // enforce semicolons
+          semi: true,
+          // prefers ""
+          singleQuote: false,
+          // last comma in array or object
+          trailingComma: "es5",
+          // enable spacing next to brackets
+          bracketSpacing: true,
+          // enables CRLF eol which is enforced by git
+          endOfLine: "auto"
+        }
+      ],
+      // Namin conventions
+      "@typescript-eslint/naming-convention": [
+        "error",
+        {
+          selector: ["variable", "function"],
+          format: ["camelCase"],
+          leadingUnderscore: "allow"
+        },
+        {
+          selector: "class",
+          format: ["PascalCase"]
+        },
+        {
+          selector: "variable",
+          modifiers: ["const", "exported"],
+          format: ["UPPER_CASE"]
+        },
+        {
+          selector: "property",
+          modifiers: ["readonly"],
+          format: ["UPPER_CASE"]
+        }
+      ]
+    }
+  }
+];
+var eslint_config_default = FRESH_ESLINT_CONFIG;
+
+// src/config/datasource.ts
+var import_path = __toESM(require("path"));
+var import_typeorm_naming_strategies = require("typeorm-naming-strategies");
+var import_dotenv = __toESM(require_main());
+(0, import_dotenv.config)();
+var basePath = process.cwd();
+var isTs = process.env.LOCAL === "true";
+var PG_DATA_SOURCE_OPTIONS = {
+  applicationName: "<service-name>",
+  name: "<service-name>-connection",
+  type: "postgres",
+  host: process.env.POSTGRE_SQL_HOST || "<host>",
+  port: Number(process.env.POSTGRE_SQL_PORT || "3300"),
+  username: process.env.POSTGRE_SQL_USER || "<user>",
+  password: process.env.POSTGRE_SQL_PASSWORD || "<password>",
+  database: process.env.POSTGRE_SQL_DATABASE || "<database>",
+  schema: process.env.POSTGRE_SQL_SCHEMA || "<scheme>",
+  entities: [import_path.default.join(basePath, isTs ? "src/entity/*.{ts,js}" : "build/entity/*.js")],
+  migrations: [import_path.default.join(basePath, isTs ? "src/migration/*.{ts,js}" : "build/migration/*.js")],
+  migrationsRun: process.env.RUN_MIGRATIONS === "true",
+  migrationsTableName: "migrations",
+  migrationsTransactionMode: "each",
+  synchronize: false,
+  logging: false,
+  extra: {
+    connectionLimit: 20
+  },
+  useUTC: true,
+  cache: true,
+  namingStrategy: new import_typeorm_naming_strategies.SnakeNamingStrategy()
+  // replication: undefined,
+};
+var datasource_default = PG_DATA_SOURCE_OPTIONS;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AMOUNT_UNIT,
+  ActionCommandCode,
+  ApiError,
+  Category,
+  DataHelper,
+  DateUtils,
+  DepotPoolStatus,
+  Device,
+  FreshDao,
+  FreshEntity,
+  FreshHyperEntity,
+  FreshJob,
+  FreshTranslationBase,
+  HttpStatus,
+  LanguageCode,
+  Manufacturer,
+  PaymentMethod,
+  PgDataSourceOptions,
+  Product,
+  SinglePromiseWaiter,
+  Singleton,
+  StatusDto,
+  Subcategory,
+  TimestampColumn,
+  TransactionType,
+  createDeferred,
+  freshEslintConfig,
+  isValidCron,
+  logger
+});
+//# sourceMappingURL=index.js.map