@futdevpro/fsm-dynamo 1.20.92 → 1.20.93

package/build-esm/_models/control-models/range-value.control-model.js

@@ -0,0 +1,247 @@
+/**
+ * A class that represents a range value.
+ *
+ * @example
+ * ```ts
+ * const range: DyFM_RangeValue_ControlModel<number> = new DyFM_RangeValue_ControlModel(1, 10);
+ * ```
+ */
+export class DyFM_RangeValue_ControlModel {
+    isRange = true;
+    from;
+    to;
+    constructor(from, to) {
+        if (from?.isRange) {
+            this.from = from.from;
+            this.to = from.to;
+            return;
+        }
+        else {
+            this.from = from;
+            this.to = to ?? from;
+        }
+    }
+    constructed() {
+        return true;
+    }
+    newValues(value) {
+        this.from = value.from;
+        this.to = value.to;
+    }
+    addRange(range) {
+        this.from += range.from;
+        this.to += range.to;
+    }
+    subtractRange(range) {
+        this.from -= range.from;
+        this.to -= range.to;
+    }
+    multiplyRange(range) {
+        this.from *= range.from;
+        this.to *= range.to;
+    }
+    divideRange(range) {
+        this.from /= range.from;
+        this.to /= range.to;
+    }
+    add(value) {
+        this.from += value;
+        this.to += value;
+    }
+    subtract(value) {
+        this.from -= value;
+        this.to -= value;
+    }
+    multiply(value) {
+        this.from *= value;
+        this.to *= value;
+    }
+    divide(value) {
+        this.from /= value;
+        this.to /= value;
+    }
+    clone() {
+        return new DyFM_RangeValue_ControlModel(this.from, this.to);
+    }
+    applyTransform(transform) {
+        return new DyFM_RangeValue_ControlModel(transform(this.from), transform(this.to));
+    }
+    toString = this.stringify;
+    stringify(spaces = true, auto = true) {
+        if (auto && this.from === this.to) {
+            return `${this.from}`;
+        }
+        else if (spaces) {
+            return `${this.from} - ${this.to}`;
+        }
+        else {
+            return `${this.from}-${this.to}`;
+        }
+    }
+    /**
+     * Re-types the range value
+     * @param value - The range value to re-type
+     * @returns The re-typed range value
+     *
+     * @example
+     * ```ts
+     * const range: DyFM_RangeValue_ControlModel<number> = new DyFM_RangeValue_ControlModel<number>(5, 100);
+     * const retyped: DyFM_RangeValue_ControlModel<number> = DyFM_RangeValue_ControlModel.reType(range);
+     * ```
+     */
+    static reType(value) {
+        return new DyFM_RangeValue_ControlModel(value.from, value.to);
+    }
+    /**
+     * Adds two range values
+     * @param a - The first range value
+     * @param b - The second range value
+     * @returns The sum of the two range values
+     *
+     * @example
+     * ```ts
+     * const a = new DyFM_RangeValue_ControlModel<number>(5, 10);
+     * const b = new DyFM_RangeValue_ControlModel<number>(2, 3);
+     * const result = DyFM_RangeValue_ControlModel.addRange(a, b);
+     * console.log(result); // 7 - 13
+     * ```
+     */
+    static addRange(a, b) {
+        return new DyFM_RangeValue_ControlModel(a.from + b.from, a.to + b.to);
+    }
+    /**
+     * Subtracts two range values
+     * @param a - The first range value
+     * @param b - The second range value
+     * @returns The difference of the two range values
+     *
+     * @example
+     * ```ts
+     * const a = new DyFM_RangeValue_ControlModel<number>(5, 10);
+     * const b = new DyFM_RangeValue_ControlModel<number>(2, 3);
+     * const result = DyFM_RangeValue_ControlModel.subtractRange(a, b);
+     * console.log(result); // 3 - 7
+     * ```
+     */
+    static subtractRange(from, value) {
+        return new DyFM_RangeValue_ControlModel(from.from - value.from, from.to - value.to);
+    }
+    /**
+     * Multiplies two range values
+     * @param a - The first range value
+     * @param b - The second range value
+     * @returns The product of the two range values
+     *
+     * @example
+     * ```ts
+     * const a = new DyFM_RangeValue_ControlModel<number>(5, 10);
+     * const b = new DyFM_RangeValue_ControlModel<number>(2, 3);
+     * const result = DyFM_RangeValue_ControlModel.multiplyRange(a, b);
+     * console.log(result); // 10 - 30
+     * ```
+     */
+    static multiplyRange(from, value) {
+        return new DyFM_RangeValue_ControlModel(from.from * value.from, from.to * value.to);
+    }
+    /**
+     * Divides two range values
+     * @param a - The first range value
+     * @param b - The second range value
+     * @returns The quotient of the two range values
+     *
+     * @example
+     * ```ts
+     * const a = new DyFM_RangeValue_ControlModel<number>(10, 20);
+     * const b = new DyFM_RangeValue_ControlModel<number>(2, 4);
+     * const result = DyFM_RangeValue_ControlModel.divideRange(a, b);
+     * console.log(result); // 5 - 5
+     * ```
+     */
+    static divideRange(from, value) {
+        return new DyFM_RangeValue_ControlModel(from.from / value.from, from.to / value.to);
+    }
+    /**
+     * Adds a number to a range value
+     * @param a - The range value
+     * @param b - The number to add
+     * @returns The sum of the range value and the number
+     *
+     * @example
+     * ```ts
+     * const a = new DyFM_RangeValue_ControlModel<number>(5, 10);
+     * const result = DyFM_RangeValue_ControlModel.add(a, 5);
+     * console.log(result); // 10 - 15
+     * ```
+     */
+    static add(a, b) {
+        return new DyFM_RangeValue_ControlModel(a.from + b, a.to + b);
+    }
+    /**
+     * Subtracts a number from a range value
+     * @param a - The range value
+     * @param b - The number to subtract
+     * @returns The difference of the range value and the number
+     *
+     * @example
+     * ```ts
+     * const a = new DyFM_RangeValue_ControlModel<number>(5, 10);
+     * const result = DyFM_RangeValue_ControlModel.subtract(a, 5);
+     * console.log(result); // 0 - 5
+     * ```
+     */
+    static subtract(a, b) {
+        return new DyFM_RangeValue_ControlModel(a.from - b, a.to - b);
+    }
+    /**
+     * Multiplies a range value by a number
+     * @param a - The range value
+     * @param b - The number to multiply
+     * @returns The product of the range value and the number
+     *
+     * @example
+     * ```ts
+     * const a = new DyFM_RangeValue_ControlModel<number>(5, 10);
+     * const result = DyFM_RangeValue_ControlModel.multiply(a, 5);
+     * console.log(result); // 25 - 50
+     * ```
+     */
+    static multiply(a, b) {
+        return new DyFM_RangeValue_ControlModel(a.from * b, a.to * b);
+    }
+    /**
+     * Divides a range value by a number
+     * @param a - The range value
+     * @param b - The number to divide
+     * @returns The quotient of the range value and the number
+     *
+     * @example
+     * ```ts
+     * const a = new DyFM_RangeValue_ControlModel<number>(10, 20);
+     * const result = DyFM_RangeValue_ControlModel.divide(a, 5);
+     * console.log(result); // 2 - 4
+     * ```
+     */
+    static divide(a, b) {
+        return new DyFM_RangeValue_ControlModel(a.from / b, a.to / b);
+    }
+    /**
+     * Checks if a value is in a range value
+     * @param value - The value to check
+     * @param range - The range value to check
+     * @returns True if the value is in the range, false otherwise
+     *
+     * @example
+     * ```ts
+     * const value = 5;
+     * const range = new DyFM_RangeValue_ControlModel<number>(0, 10);
+     * const result = DyFM_RangeValue_ControlModel.isInRange(value, range);
+     * console.log(result); // true
+     * ```
+     */
+    static isInRange(value, range) {
+        return range.from <= value && value <= range.to;
+    }
+}
+Object.defineProperty(DyFM_RangeValue_ControlModel, 'name', { value: 'DyFM_RangeValue' });
+/** @deprecated Use DyFM_RangeValue_ControlModel. Same constructor; no API removal. */
+export { DyFM_RangeValue_ControlModel as DyFM_RangeValue };

package/build-esm/_models/control-models/server-route-settings-base.control-model.js

@@ -0,0 +1,19 @@
+import { DyFM_Endpoint_SettingsBase } from './service-endpoint-settings-base.control-model';
+/** Server route settings layered on the shared service-endpoint contract. */
+export class DyFM_ServerRouteSettingsBase_ControlModel extends DyFM_Endpoint_SettingsBase {
+    static {
+        Object.defineProperty(this, 'name', { value: 'DyFM_ServerRoute_SettingsBase' });
+    }
+    preProcesses;
+    /** @deprecated Use simpleTask instead. */
+    tasks;
+    /** Route task whose result is sent to the client by the consuming server layer. */
+    simpleTask;
+    /** Initializes a server-route settings model from the caller-owned settings. */
+    constructor(set) {
+        super(set);
+        Object.assign(this, set);
+    }
+}
+/** @deprecated Use DyFM_ServerRouteSettingsBase_ControlModel. Same constructor; no API removal. */
+export { DyFM_ServerRouteSettingsBase_ControlModel as DyFM_ServerRoute_SettingsBase };

package/build-esm/_models/control-models/server-status.control-model.js

@@ -0,0 +1,73 @@
+import { DyFM_DataModel_Params } from '../..';
+import { DyFM_Metadata } from '../data-models/metadata.data-model';
+/**
+ * A class that represents the status of a server.
+ *
+ * @example
+ * ```ts
+ * const serverStatus: DyFM_ServerStatus_ControlModel = new DyFM_ServerStatus_ControlModel({
+ *   status: 'ready',
+ * });
+ * ```
+ */
+export class DyFM_ServerStatus_ControlModel extends DyFM_Metadata {
+    status;
+    systemName;
+    systemShortCode;
+    /** @deprecated Use isClientVersionOk; clientVersionOk remains the serialized compatibility key. */
+    clientVersionOk;
+    latestClientVersion;
+    latestClientVersionNumeric;
+    /** A BEDROCK (nts-dynamo) verziója — a teljes flottán AZONOS, NEM az app sajátja. */
+    serverVersion;
+    serverNumericVersion;
+    /**
+     * AZ APP saját verziója (`DyNTS_global_settings.systemVersion`), 2026-07-20.
+     * Deploy-verifikációhoz ez a helyes mező: a `serverVersion` a bedrock verzióját adja,
+     * ezért verzió-alapú deploy-ellenőrzésre alkalmatlan (a flottán mindenhol ugyanaz).
+     * Additív mező — a `serverVersion` szemantikája változatlan (nulla regresszió).
+     */
+    appVersion;
+    uptime;
+    serverMessage;
+    memoryUsage;
+    cpuUsage;
+    serverConnections;
+    constructor(set) {
+        super(set);
+        if (set) {
+            Object.assign(this, set);
+        }
+    }
+}
+export const DyFM_serverStatus_dataParams = new DyFM_DataModel_Params({
+    dataName: 'server_status',
+    properties: {
+        status: { type: 'string' },
+        systemName: { type: 'string' },
+        systemShortCode: { type: 'string' },
+        clientVersionOk: { type: 'boolean' },
+        latestClientVersion: { type: 'string' },
+        latestClientVersionNumeric: { type: 'number' },
+        serverVersion: { type: 'string' },
+        serverNumericVersion: { type: 'number' },
+        uptime: { type: 'number' },
+        serverMessage: { type: 'string' },
+        memoryUsage: { type: 'object' },
+        cpuUsage: { type: 'object' },
+        serverConnections: { type: 'object' },
+    },
+});
+Object.defineProperty(DyFM_ServerStatus_ControlModel, 'name', { value: 'DyFM_ServerStatus' });
+/** @deprecated Use DyFM_ServerStatus_ControlModel. Same constructor; no API removal. */
+export { DyFM_ServerStatus_ControlModel as DyFM_ServerStatus };
+Object.defineProperty(DyFM_ServerStatus_ControlModel.prototype, 'isClientVersionOk', {
+    configurable: true,
+    enumerable: false,
+    get: function () {
+        return this.clientVersionOk;
+    },
+    set: function (isValue) {
+        this.clientVersionOk = isValue;
+    },
+});

package/build-esm/_models/control-models/service-endpoint-settings-base.control-model.js

@@ -0,0 +1,110 @@
+import { DyFM_getConstructionStackLocation } from '../../_collections/utils/stack.util';
+/**
+ * A class that represents the settings of a service endpoint.
+ *
+ * @example
+ * ```ts
+ * const endpointSettings: DyFM_Endpoint_SettingsBase<string, [string], undefined> = new DyFM_Endpoint_SettingsBase({
+ *   name: 'myEndpoint',
+ *   type: DyFM_HttpCallType.get,
+ *   endpoint: '/get/:id',
+ * });
+ * ```
+ */
+export class DyFM_ServiceEndpointSettingsBase_ControlModel {
+    static {
+        Object.defineProperty(this, 'name', { value: 'DyFM_Endpoint_SettingsBase' });
+    }
+    name;
+    type;
+    endpoint;
+    pathParamKeys = [];
+    constructor(set) {
+        if (!set.endpoint) {
+            throw new Error(`endpoint not setted up for this endpoint (${set.name ?? DyFM_getConstructionStackLocation()})`);
+        }
+        if (set.endpoint.includes('{')) {
+            console.warn(`using {param} brackets in endpoint definitions will be deprecated... ` +
+                `\nuse :param instead ({pathParam} --> :pathParam) (${set.name})`);
+            set.endpoint = set.endpoint.replace(/{/g, ':').replace(/}/g, '');
+        }
+        Object.assign(this, set);
+        this.pathParamKeys = this.endpoint.split('/').filter((part) => part.startsWith(':')).map((part) => part.replace(':', ''));
+    }
+}
+export var DyFM_API_Input_Type;
+(function (DyFM_API_Input_Type) {
+    DyFM_API_Input_Type["body"] = "body";
+    DyFM_API_Input_Type["queryParams"] = "queryParams";
+})(DyFM_API_Input_Type || (DyFM_API_Input_Type = {}));
+/** @deprecated Use DyFM_ServiceEndpointSettingsBase_ControlModel. Same constructor; no API removal. */
+export { DyFM_ServiceEndpointSettingsBase_ControlModel as DyFM_Endpoint_SettingsBase, };
+// BFR-FUTDEVPRO-021: the server-route models are exported by the package index DIRECTLY — re-exporting them from HERE
+// made a module cycle (server-route EXTENDS this file's class): harmless in CommonJS, but in an ES-module build the
+// hoisted re-export evaluates the subclass BEFORE its base class ("Class extends value undefined").
+/* asdasd
+export class DyNX_ApiCall_Settings<
+  T_Result,
+  T_Inputs extends Array<any>,
+  T_Body
+> extends DyFM_Endpoint_SettingsBase<T_Result, T_Inputs, T_Body> {
+  baseUrl?: string;
+
+  httpOptions?: any;
+
+  call?: (...inputs: T_Inputs) => Promise<T_Result>;
+
+  constructor(
+    set: DyNX_ApiCall_Settings<T_Result, T_Inputs, T_Body>
+  ) {
+    super(set);
+  }
+}
+export type DyNX_ApiService_Base<T extends DyFM_ServiceEndpointTypesSetting> = {
+  [K in keyof T]: DyNX_ApiCall_Settings<
+    T[K]['resultType'], T[K]['inputTypes'], T[K]['bodyType']
+  >
+} */
+/*
+
+
+export interface Flow_EPResult_Settings333 extends DyFM_ServiceEndpointTypesSetting {
+  getFlow: DyFM_EndpointTypesContainer<Flow, [string], undefined>;
+  modifyFlow: DyFM_EndpointTypesContainer<Flow, [string, Flow], Flow>;
+  getFlowsByUserId: DyFM_EndpointTypesContainer<Flow[], [string], undefined>;
+}
+
+export class Flow_EP333 implements DyFM_ServiceEndpoint_SettingsBase<Flow_EPResult_Settings333> {
+  [key: string]: DyFM_Endpoint_SettingsBase<any, any, any>;
+
+  getFlow = new DyFM_Endpoint_SettingsBase({
+    type: DyFM_HttpCallType.get,
+    endpoint: '/get/:userId/:flowId',
+  });
+  modifyFlow = new DyFM_Endpoint_SettingsBase({
+    type: DyFM_HttpCallType.post,
+    endpoint: '/modify/:userId',
+  });
+  getFlowsByUserId = new DyFM_Endpoint_SettingsBase({
+    type: DyFM_HttpCallType.get,
+    endpoint: '/get-all-my/:userId',
+  });
+}
+const flow_EP333 = new Flow_EP333();
+
+export class Flow_API333 implements DyNX_ApiService_Base<Flow_EPResult_Settings333> {
+  [key: string]: DyNX_ApiCall_Settings<any, any, any>;
+
+  getFlow = new DyNX_ApiCall_Settings<Flow, [string], undefined>({
+    ...flow_EP333.getFlow,
+    call: async (id: string) => new Flow(),
+  });
+  modifyFlow = new DyNX_ApiCall_Settings<Flow, [string, Flow], Flow>({
+    ...flow_EP333.modifyFlow,
+    call: async (userId: string, flow: Flow) => new Flow(),
+  });
+  getFlowsByUserId = new DyNX_ApiCall_Settings<Flow[], [string], undefined>({
+    ...flow_EP333.getFlowsByUserId,
+    call: async (userId: string) => [new Flow()],
+  });
+} */

package/build-esm/_models/data-models/errors.data-model.js

@@ -0,0 +1,156 @@
+import { DyFM_DataModel_Params } from '../control-models/data-model-params.control-model';
+import { DyFM_ErrorStatus } from '../../_enums/error-status.enum';
+import { DyFM_Metadata } from './metadata.data-model';
+export const DyFM_errorsFlag = 'DyFM-ERRORS-OBJECT';
+/**
+ * This obj is the saved version of the DyFM_Error object.
+ * It is used to store the error in the database and its statistics.
+ *
+ * @example
+ * ```ts
+ * const errors: DyFM_Errors_DataModel<DyFM_Error> = new DyFM_Errors_DataModel({
+ *   message: 'Error message',
+ *   error: new DyFM_Error({
+ *     message: 'Error message',
+ *   }),
+ * });
+ * ```
+ */
+export class DyFM_Errors_DataModel extends DyFM_Metadata {
+    flag = DyFM_errorsFlag;
+    source;
+    issuer;
+    username;
+    /** In which system versions this error occurred. */
+    versions = [];
+    localTime;
+    region;
+    message;
+    exception;
+    exceptionObj;
+    stackTrace = [];
+    error;
+    count = 1;
+    d_error;
+    additionalContent;
+    level;
+    priority;
+    duplications = [];
+    /**
+     * Free-form osztaly-cimke a generic-application errors mellett. Tipikus
+     * ertekek: `'application'` (default), `'system-unreachable'`, `'build-failure'`,
+     * `'auth'`, `'db'`. A UI-szuro/tab itt szur. Optional + string (NEM enum),
+     * hogy minden host-app sajat kategoriai is additive-en bovithetok legyenek
+     * a bedrock medellenelkul.
+     */
+    category;
+    // ─── Fix tracking (append-only audit + quick-access aliases) ────────────────
+    /**
+     * Lifecycle status. `active` for every new record; `fixed` after a claimed
+     * fix (`recordFixAttempt` / `resolveError`, record KEPT not deleted);
+     * `regressed` when `recordError` sees a recurrence with a version >= the last
+     * claimed-fix version (auto-reactivation); `investigating` set manually.
+     * Mirrors `regressedAfterFix` (kept for back-compat): `regressed` ⇔ `regressedAfterFix=true`.
+     */
+    status = DyFM_ErrorStatus.active;
+    /** Optional free-form notes captured on a soft-resolve (`resolveError`). */
+    resolutionNotes;
+    /**
+     * Append-only audit log of fix attempts. New entries via `recordFixAttempt`
+     * on the data-service. Never overwritten / pruned — full hypothesis history
+     * stays available even when one hypothesis turns out to be wrong and the
+     * next attempt is logged.
+     */
+    fixAttempts = [];
+    /** Convenience alias — last entry of `fixAttempts.at`. */
+    lastFixedAt;
+    /** Convenience alias — last entry of `fixAttempts.by`. */
+    lastFixedBy;
+    /** Convenience alias — last entry of `fixAttempts.version`. */
+    lastFixedInVersion;
+    /** Convenience alias — last entry of `fixAttempts.hypothesis`. */
+    lastFixHypothesis;
+    /**
+     * Set to `true` in the `recordError` dedup branch when a NEW occurrence
+     * arrives carrying a `versions[0]` >= `lastFixedInVersion`. Indicates the
+     * most recent fix attempt did not actually fix the root cause — surface as
+     * a flag on the dashboard so the next investigator knows to dig deeper than
+     * "already fixed in vN".
+     */
+    /** @deprecated Use isRegressedAfterFix; regressedAfterFix remains the serialized compatibility key. */
+    regressedAfterFix;
+    /**
+     * A LEGUTOLSO elofordulas diagnosztikai kontextusa (es annak idopontja).
+     *
+     * MIERT KELL (2026-08-07, eles eset): a `recordError` dedup-aga csak `$inc`-el, ezert az
+     * `additionalContent` AZ ELSO elofordulasnal BEFAGY. Egy hosszu eletu hibanal ez azt jelenti,
+     * hogy a diagnosztika orokre a ho-napokkal ezelotti elso esethez tartozik — a MOSTANI hivorol
+     * semmit nem tudsz meg, es a kesobb bevezetett gazdagabb kontextus (pl. origin / referer /
+     * user-agent) SOHA nem jut el a rekordba.
+     *
+     * MERT ESET: az overseer `No authentication provided` rekordja 68 587 elofordulasnal tartott,
+     * es az `additionalContent`-je csak egy regi `endpointInfo`-t tartalmazott. A hivot igy CSAK a
+     * szerver-logbol lehetett volna azonositani — az viszont ~13 percenkent forog, egy loketszeru
+     * (1/perc) esemenynel pedig ez rendszeresen elvetette. A hibarekordbol NEM lehetett megmondani,
+     * KI hivja. (Hard rule: "minden hibanak debug-szintu detail-t kell hordoznia, hogy a hiba a
+     * hiba-detailekbol ONMAGABAN debuggolhato legyen".)
+     *
+     * Ez a mezo a dedup-agon FRISSUL, igy a rekord mindig a LEGFRISSEBB kontextust is hordozza —
+     * az `additionalContent` (elso elofordulas) pedig valtozatlan marad, tehat semmi nem vesz el.
+     */
+    lastOccurrenceContent;
+    /** A `lastOccurrenceContent` rogzitesenek idopontja. */
+    lastOccurrenceAt;
+    constructor(set) {
+        super(set);
+        if (set) {
+            Object.assign(this, set);
+        }
+    }
+}
+export const DyFM_errors_dataParams = new DyFM_DataModel_Params({
+    dataName: 'errors',
+    properties: {
+        flag: { type: 'string' },
+        issuer: { type: 'string' },
+        username: { type: 'string' },
+        versions: { type: 'string[]' },
+        localTime: { type: 'string' },
+        region: { type: 'string' },
+        message: { type: 'string' },
+        exception: { type: 'string' },
+        exceptionObj: { type: 'any' },
+        stackTrace: { type: 'string[]' },
+        error: { type: 'any' },
+        count: { type: 'number' },
+        d_error: { type: 'DyFM_Error' },
+        additionalContent: { type: 'any' },
+        level: { type: 'DyFM_ErrorLevel' },
+        priority: { type: 'number' },
+        duplications: { type: 'DyNTS_Error[]' },
+        category: { type: 'string' },
+        status: { type: 'string' },
+        resolutionNotes: { type: 'string' },
+        fixAttempts: { type: 'any' },
+        lastFixedAt: { type: 'Date' },
+        lastFixedBy: { type: 'string' },
+        lastFixedInVersion: { type: 'string' },
+        lastFixHypothesis: { type: 'string' },
+        regressedAfterFix: { type: 'boolean' },
+        lastOccurrenceContent: { type: 'any' },
+        lastOccurrenceAt: { type: 'Date' },
+    },
+});
+Object.defineProperty(DyFM_Errors_DataModel, 'name', { value: 'DyFM_Errors' });
+/** @deprecated Use DyFM_Errors_DataModel. Same constructor; no API removal. */
+export { DyFM_Errors_DataModel as DyFM_Errors };
+Object.defineProperty(DyFM_Errors_DataModel.prototype, 'isRegressedAfterFix', {
+    configurable: true,
+    enumerable: false,
+    get: function () {
+        return this.regressedAfterFix;
+    },
+    set: function (isValue) {
+        this.regressedAfterFix = isValue;
+    },
+});