@futdevpro/fsm-dynamo 1.20.8 → 1.20.10

package/src/_models/control-models/service-endpoint-settings-base.control-model.spec.ts

@@ -1,145 +0,0 @@
-import { DyFM_Endpoint_SettingsBase, DyFM_ServerRoute_SettingsBase, DyFM_API_Input_Type } from './service-endpoint-settings-base.control-model';
-import { DyFM_HttpCallType } from '../../_enums/http/http-call-type.enum';
-
-describe('| DyFM_Endpoint_SettingsBase', (): void => {
-  it('| should create an instance with valid endpoint', (): void => {
-    const settings = new DyFM_Endpoint_SettingsBase<string, [string], undefined>({
-      name: 'testEndpoint',
-      type: DyFM_HttpCallType.get,
-      endpoint: '/test/:id'
-    });
-
-    expect(settings.name).toBe('testEndpoint');
-    expect(settings.type).toBe(DyFM_HttpCallType.get);
-    expect(settings.endpoint).toBe('/test/:id');
-    expect(settings.pathParamKeys).toEqual(['id']);
-  });
-
-  it('| should throw error when endpoint is not provided', (): void => {
-    expect(() => {
-      new DyFM_Endpoint_SettingsBase<string, [string], undefined>({
-        name: 'testEndpoint',
-        type: DyFM_HttpCallType.get
-      } as any);
-    }).toThrow();
-  });
-
-  it('| should convert {param} to :param format', (): void => {
-    const settings = new DyFM_Endpoint_SettingsBase<string, [string], undefined>({
-      name: 'testEndpoint',
-      type: DyFM_HttpCallType.get,
-      endpoint: '/test/{id}'
-    });
-
-    expect(settings.endpoint).toBe('/test/:id');
-    expect(settings.pathParamKeys).toEqual(['id']);
-  });
-
-  it('| should extract path parameters from endpoint', (): void => {
-    const settings = new DyFM_Endpoint_SettingsBase<string, [string, string], undefined>({
-      name: 'testEndpoint',
-      type: DyFM_HttpCallType.get,
-      endpoint: '/test/:userId/:itemId'
-    });
-
-    expect(settings.pathParamKeys).toEqual(['userId', 'itemId']);
-  });
-
-  it('| should handle endpoint without path parameters', (): void => {
-    const settings = new DyFM_Endpoint_SettingsBase<string, [], undefined>({
-      name: 'testEndpoint',
-      type: DyFM_HttpCallType.get,
-      endpoint: '/test/all'
-    });
-
-    expect(settings.pathParamKeys).toEqual([]);
-  });
-
-  it('| should handle complex endpoint with multiple path parameters', (): void => {
-    const settings = new DyFM_Endpoint_SettingsBase<string, [string, string, string], undefined>({
-      name: 'testEndpoint',
-      type: DyFM_HttpCallType.post,
-      endpoint: '/api/:version/:resource/:id'
-    });
-
-    expect(settings.pathParamKeys).toEqual(['version', 'resource', 'id']);
-  });
-
-  it('| should handle endpoint with path parameters in middle', (): void => {
-    const settings = new DyFM_Endpoint_SettingsBase<string, [string], undefined>({
-      name: 'testEndpoint',
-      type: DyFM_HttpCallType.get,
-      endpoint: '/api/v1/users/:id/posts'
-    });
-
-    expect(settings.pathParamKeys).toEqual(['id']);
-  });
-});
-
-describe('| DyFM_ServerRoute_SettingsBase', (): void => {
-  it('| should create an instance with valid endpoint', (): void => {
-    const settings = new DyFM_ServerRoute_SettingsBase<string, [], undefined>({
-      name: 'testRoute',
-      type: DyFM_HttpCallType.get,
-      endpoint: '/test',
-      preProcesses: []
-    });
-
-    expect(settings.name).toBe('testRoute');
-    expect(settings.type).toBe(DyFM_HttpCallType.get);
-    expect(settings.endpoint).toBe('/test');
-    expect(settings.preProcesses).toEqual([]);
-  });
-
-  it('| should inherit from DyFM_Endpoint_SettingsBase', (): void => {
-    const settings = new DyFM_ServerRoute_SettingsBase<string, [], undefined>({
-      name: 'testRoute',
-      type: DyFM_HttpCallType.get,
-      endpoint: '/test/:id',
-      preProcesses: []
-    });
-
-    expect(settings.pathParamKeys).toEqual(['id']);
-  });
-
-  it('| should handle tasks array', (): void => {
-    const task = async (): Promise<void> => {
-      // Test task
-    };
-    const settings = new DyFM_ServerRoute_SettingsBase<string, [], undefined>({
-      name: 'testRoute',
-      type: DyFM_HttpCallType.get,
-      endpoint: '/test',
-      preProcesses: [],
-      tasks: [task]
-    });
-
-    expect(settings.tasks).toEqual([task]);
-  });
-
-  it('| should handle simpleTask', (): void => {
-    const simpleTask = async (): Promise<string> => {
-      return 'result';
-    };
-    const settings = new DyFM_ServerRoute_SettingsBase<string, [], undefined>({
-      name: 'testRoute',
-      type: DyFM_HttpCallType.get,
-      endpoint: '/test',
-      preProcesses: [],
-      simpleTask: simpleTask
-    });
-
-    expect(settings.simpleTask).toBe(simpleTask);
-  });
-});
-
-describe('| DyFM_API_Input_Type', (): void => {
-  it('| should have body value', (): void => {
-    expect(DyFM_API_Input_Type.body).toBe('body');
-  });
-
-  it('| should have queryParams value', (): void => {
-    expect(DyFM_API_Input_Type.queryParams).toBe('queryParams');
-  });
-});
-

package/src/_models/control-models/service-endpoint-settings-base.control-model.ts

@@ -1,187 +0,0 @@
-import { DyFM_getConstructionStackLocation } from '../../_collections/utils/stack.util';
-import { DyFM_HttpCallType } from '../../_enums/http/http-call-type.enum';
-
-/* class Flow {
-  id: string;
-  userId: string;
-  name: string;
-}
-
-class SomethingElse {
-  idddd: string;
-  userIdddd: string;
-  nameeee: string;
-}
- */
-
-
-export interface DyFM_EndpointTypesContainer<
-  T_Result,
-  //T_Inputs extends DyFM_API_Input<any>[] = [],
-  T_Inputs extends any[] = [],
-  T_Body = undefined
-> {
-  resultType: T_Result;
-  inputTypes: T_Inputs;
-  bodyType: T_Body;
-}
-export type DyFM_ServiceEndpointTypesSettings = {
-  [key: string]: DyFM_EndpointTypesContainer<unknown, any, unknown>;
-}
-
-/**
- * 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_Endpoint_SettingsBase<T_Result, I_Inputs, T_Body> {
-  name?: string;
-  type?: DyFM_HttpCallType;
-  endpoint?: string;
-
-  pathParamKeys?: string[] = [];
-
-  constructor(
-    set: DyFM_Endpoint_SettingsBase<T_Result, I_Inputs, T_Body>
-  ) {
-    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: string): boolean => part.startsWith(':')
-    ).map(
-      (part: string): string => part.replace(':', '')
-    );
-  }
-}
-export type DyFM_ServiceEndpoint_SettingsBase<T extends DyFM_ServiceEndpointTypesSettings> = {
-  [K in keyof T]: DyFM_Endpoint_SettingsBase<T[K]['resultType'], T[K]['inputTypes'], T[K]['bodyType']>;
-}
-
-
-
-export class DyFM_ServerRoute_SettingsBase<
-  T_Result,
-  T_Inputs extends DyFM_API_Input<any>[] = [],
-  T_Body = undefined
-> extends DyFM_Endpoint_SettingsBase<T_Result, T_Inputs, T_Body> {
-
-  preProcesses: ((req: Request, res: Response) => Promise<void>)[];
-  /** this is the old way of setting up tasks, it will be deprecated in future (we want)
-   * @deprecated use simpleTask instead */
-  tasks?: ((req: Request, res: Response, issuer?: string, ...inputs: T_Inputs) => Promise<void>)[];
-  /**
-   * a simple task that is executed after the preProcesses
-   * this will automatically handle the API setup and this will be the TASK that will be executed 
-   * (result will be sent to the client, error will be caught and sent to the client)
-   */
-  simpleTask?: (...inputs: T_Inputs) => Promise<T_Result>;
-
-  constructor(
-    set: DyFM_ServerRoute_SettingsBase<T_Result, T_Inputs, T_Body>
-  ) {
-    super(set);
-
-    Object.assign(this, set);
-  }
-}
-
-export interface DyFM_API_Input<T_Input> {
-  type: DyFM_API_Input_Type;
-  value: T_Input;
-}
-
-export enum DyFM_API_Input_Type {
-  body = 'body',
-  queryParams = 'queryParams',
-}
-
-/* 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/src/_models/data-models/errors.data-model.spec.ts

@@ -1,71 +0,0 @@
-import { DyFM_Errors } from './errors.data-model';
-import { DyFM_Error } from '../control-models/error.control-model';
-import { DyFM_ErrorLevel } from '../../_enums/error-level.enum';
-
-describe('| DyFM_Errors', (): void => {
-  it('| should create an instance without initial data', (): void => {
-    const errors = new DyFM_Errors<DyFM_Error>();
-
-    expect(errors).toBeTruthy();
-    expect(errors.flag).toBe('DyFM-ERRORS-OBJECT');
-    expect(errors.count).toBe(1);
-    expect(errors.duplications).toEqual([]);
-    expect(errors.__created).toBeInstanceOf(Date);
-    expect(errors.__lastModified).toBeInstanceOf(Date);
-  });
-
-  it('| should create an instance with initial data', (): void => {
-    const error = new DyFM_Error({
-      message: 'Test error',
-      errorCode: 'TEST-ERROR',
-    });
-
-    const initialData: DyFM_Errors<DyFM_Error> = {
-      source: 'test-source',
-      issuer: 'test-issuer',
-      username: 'test-user',
-      versions: ['1.0.0'],
-      localTime: '2023-01-01T00:00:00Z',
-      region: 'US',
-      message: 'Test error message',
-      exception: 'Test exception',
-      exceptionObj: { test: 'data' },
-      stackTrace: ['line1', 'line2'],
-      error: { test: 'error' },
-      count: 5,
-      d_error: error,
-      additionalContent: { extra: 'data' },
-      level: DyFM_ErrorLevel.error,
-      priority: 10,
-      duplications: [],
-    };
-
-    const errors = new DyFM_Errors<DyFM_Error>(initialData);
-
-    expect(errors.source).toBe('test-source');
-    expect(errors.issuer).toBe('test-issuer');
-    expect(errors.username).toBe('test-user');
-    expect(errors.versions).toEqual(['1.0.0']);
-    expect(errors.localTime).toBe('2023-01-01T00:00:00Z');
-    expect(errors.region).toBe('US');
-    expect(errors.message).toBe('Test error message');
-    expect(errors.exception).toBe('Test exception');
-    expect(errors.exceptionObj).toEqual({ test: 'data' });
-    expect(errors.stackTrace).toEqual(['line1', 'line2']);
-    expect(errors.error).toEqual({ test: 'error' });
-    expect(errors.count).toBe(5);
-    expect(errors.d_error).toEqual(error);
-    expect(errors.additionalContent).toEqual({ extra: 'data' });
-    expect(errors.level).toBe(DyFM_ErrorLevel.error);
-    expect(errors.priority).toBe(10);
-    expect(errors.duplications).toEqual([]);
-  });
-
-  it('| should have dataParams defined', (): void => {
-    const { DyFM_errors_dataParams } = require('./errors.data-model');
-
-    expect(DyFM_errors_dataParams).toBeTruthy();
-    expect(DyFM_errors_dataParams.dataName).toBe('errors');
-  });
-});
-

package/src/_models/data-models/errors.data-model.ts

@@ -1,201 +0,0 @@
-import { DyFM_DataModel_Params } from '../control-models/data-model-params.control-model';
-import { DyFM_ErrorLevel } from '../../_enums/error-level.enum';
-import { DyFM_ErrorStatus } from '../../_enums/error-status.enum';
-import { DyFM_Error } from '../control-models/error.control-model';
-import { DyFM_Metadata } from './metadata.data-model';
-
-
-export const DyFM_errorsFlag = 'DyFM-ERRORS-OBJECT';
-
-
-/**
- * Single fix-attempt entry on an error record. Append-only — every call to the
- * `recordFixAttempt` data-service method adds a new entry to `fixAttempts[]`.
- *
- * Intended use: after diagnosing the root cause of an error and shipping a fix,
- * mark the error with the hypothesis + target version. If a NEW occurrence of
- * the same error then arrives carrying a version >= this attempt's version,
- * the dedup branch of `recordError` flips `regressedAfterFix: true` — the
- * dashboard can highlight it as a failed hypothesis worth re-investigating.
- */
-export interface DyFM_Errors_FixAttempt {
-  /** When the fix was claimed. */
-  at: Date | string;
-  /** Issuer / username who claimed the fix. */
-  by: string;
-  /** The app version that contains the claimed fix (e.g. `01.15.117`). */
-  version: string;
-  /** Plain-text root-cause hypothesis that justified the fix. */
-  hypothesis: string;
-  /** Optional free-form notes attached to this fix attempt (links, context, follow-ups). */
-  notes?: string;
-}
-
-/**
- * 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<DyFM_Error> = new DyFM_Errors({
- *   message: 'Error message',
- *   error: new DyFM_Error({
- *     message: 'Error message',
- *   }),
- * });
- * ```
- */
-export class DyFM_Errors<T_Error extends DyFM_Error> extends DyFM_Metadata {
-  readonly flag?: string = DyFM_errorsFlag;
-
-  source?: string;
-  issuer?: string;
-  username?: string;
-  /** In which system versions this error occurred. */
-  versions?: string[] = [];
-  localTime?: string;
-  region?: string;
-
-  message?: string;
-  exception?: string;
-  exceptionObj?: any;
-
-  stackTrace?: string[] = [];
-  error?: any;
-
-  count?: number = 1;
-  
-  d_error?: T_Error;
-
-  additionalContent?: any;
-
-  level?: DyFM_ErrorLevel;
-  priority?: number;
-  duplications?: DyFM_Errors<T_Error>[] = [];
-
-  /**
-   * 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?: string;
-
-  // ─── 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 = DyFM_ErrorStatus.active;
-
-  /** Optional free-form notes captured on a soft-resolve (`resolveError`). */
-  resolutionNotes?: string;
-
-  /**
-   * 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?: DyFM_Errors_FixAttempt[] = [];
-
-  /** Convenience alias — last entry of `fixAttempts.at`. */
-  lastFixedAt?: Date | string;
-  /** Convenience alias — last entry of `fixAttempts.by`. */
-  lastFixedBy?: string;
-  /** Convenience alias — last entry of `fixAttempts.version`. */
-  lastFixedInVersion?: string;
-  /** Convenience alias — last entry of `fixAttempts.hypothesis`. */
-  lastFixHypothesis?: string;
-
-  /**
-   * 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".
-   */
-  regressedAfterFix?: boolean;
-
-  /**
-   * 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?: any;
-  /** A `lastOccurrenceContent` rogzitesenek idopontja. */
-  lastOccurrenceAt?: Date | string;
-
-  constructor(
-    set?: DyFM_Errors<T_Error>
-  ) {
-    super(set);
-    
-    if (set) {
-      Object.assign(this, set);
-    }
-  }
-}
-
-export const DyFM_errors_dataParams: DyFM_DataModel_Params<DyFM_Errors<DyFM_Error>> = 
-  new DyFM_DataModel_Params<DyFM_Errors<DyFM_Error>>({
-    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' },
-    },
-  });