@nu-art/ts-common 0.401.8 → 0.500.0

package/core/application.d.ts

@@ -1,4 +1,4 @@
-import { ModuleManager } from "./module-manager.js";
+import { ModuleManager } from './module-manager.js';
 /**
  * Application class that extends ModuleManager with startup callback support.
  *

package/core/application.js

@@ -15,7 +15,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ModuleManager } from "./module-manager.js";
+import { ModuleManager } from './module-manager.js';
 /**
  * Application class that extends ModuleManager with startup callback support.
  *
@@ -52,9 +52,9 @@ export class Application extends ModuleManager {
         super.build();
         onStarted && onStarted()
             .then((data) => {
-            data && this.logInfo("data: ", data);
-            this.logInfo("Completed");
+            data && this.logInfo('data: ', data);
+            this.logInfo('Completed');
         })
-            .catch((err) => this.logError("Error", err));
+            .catch((err) => this.logError('Error', err));
     }
 }

package/core/logger/index.d.ts

@@ -1 +1,2 @@
 export * from '@nu-art/logger';
+export { LogClient_Browser, LogClient_BrowserGroups } from '@nu-art/logger/browser';

package/core/logger/index.js

@@ -1 +1,2 @@
 export * from '@nu-art/logger';
+export { LogClient_Browser, LogClient_BrowserGroups } from '@nu-art/logger/browser';

package/core/module.d.ts

@@ -4,7 +4,6 @@
 import { ModuleManager } from './module-manager.js';
 import { Logger, LogLevel } from './logger/index.js';
 import { ValidatorTypeResolver } from '../validator/validator-core.js';
-import { TimerHandler } from '../utils/date-time-tools.js';
 /**
  * Base abstract class for all modules in the nu-art ecosystem.
  *
@@ -45,6 +44,7 @@ export declare abstract class Module<Config = any, ModuleConfig extends Config &
 } = Config & {
     minLogLevel?: LogLevel;
 }, ConfigValidator extends ValidatorTypeResolver<ModuleConfig> = ValidatorTypeResolver<ModuleConfig>> extends Logger {
+    private readonly classStack;
     private name;
     /** Module configuration, merged from default config and ModuleManager-provided config */
     readonly config: ModuleConfig;
@@ -54,10 +54,6 @@ export declare abstract class Module<Config = any, ModuleConfig extends Config &
     protected readonly initiated = false;
     /** Optional config validator, set via setConfigValidator() */
     protected readonly configValidator?: ConfigValidator;
-    /** Internal map for managing debounce/throttle timeouts by key */
-    protected timeoutMap: {
-        [k: string]: number;
-    };
     /**
      * Creates a new Module instance.
      *
@@ -68,43 +64,9 @@ export declare abstract class Module<Config = any, ModuleConfig extends Config &
      * @throws {BadImplementationException} If the class name doesn't end with `_Class`
      */
     constructor(tag?: string);
-    /**
-     * Debounces a function call, canceling any pending execution with the same key
-     * and scheduling a new execution after the specified delay.
-     *
-     * Each call with the same key cancels the previous pending execution and resets
-     * the timer. Useful for rate-limiting user input or API calls.
-     *
-     * @param handler - Function to execute after the delay
-     * @param key - Unique key to identify this debounced operation. Multiple calls
-     *              with the same key will cancel previous pending executions.
-     * @param ms - Delay in milliseconds before executing the handler (default: 0)
-     *
-     * @example
-     * ```typescript
-     * // Debounce search input
-     * this.debounce(() => this.performSearch(query), 'search', 300);
-     * ```
-     */
-    debounce(handler: TimerHandler, key: string, ms?: number): void;
-    /**
-     * Throttles a function call, ensuring it executes at most once per time period.
-     *
-     * Unlike debounce, throttle executes immediately if no execution is pending,
-     * then prevents further executions until the time period expires. Useful for
-     * limiting the frequency of expensive operations.
-     *
-     * @param handler - Function to execute
-     * @param key - Unique key to identify this throttled operation
-     * @param ms - Minimum time in milliseconds between executions (default: 0)
-     *
-     * @example
-     * ```typescript
-     * // Throttle scroll handler
-     * this.throttle(() => this.updateScrollPosition(), 'scroll', 100);
-     * ```
-     */
-    throttle(handler: TimerHandler, key: string, ms?: number): void;
+    protected addToClassStack: (cls: Function) => void;
+    isInstanceOf: <T extends Function>(cls: T) => this is T;
+    isInstanceType: <T extends Function>(cls: T) => this is T;
     /**
      * Sets a config validator for runtime validation of module configuration.
      *

package/core/module.js

@@ -18,7 +18,7 @@
 import { BadImplementationException } from './exceptions/exceptions.js';
 import { merge } from '../utils/merge-tools.js';
 import { Logger } from './logger/index.js';
-import { _clearTimeout, _setTimeout } from '../utils/date-time-tools.js';
+import { lastElement } from '../utils/array-tools.js';
 /**
  * Base abstract class for all modules in the nu-art ecosystem.
  *
@@ -55,6 +55,7 @@ import { _clearTimeout, _setTimeout } from '../utils/date-time-tools.js';
  * ```
  */
 export class Module extends Logger {
+    classStack = [];
     name;
     /** Module configuration, merged from default config and ModuleManager-provided config */
     config = {};
@@ -64,8 +65,6 @@ export class Module extends Logger {
     initiated = false;
     /** Optional config validator, set via setConfigValidator() */
     configValidator;
-    /** Internal map for managing debounce/throttle timeouts by key */
-    timeoutMap = {};
     /**
      * Creates a new Module instance.
      *
@@ -83,68 +82,15 @@ export class Module extends Logger {
             throw new BadImplementationException(`Found module named: ${this.name}, Module class MUST end with '_Class' e.g. MyModule_Class`);
         this.name = this.name.replace('_Class', '');
     }
-    /**
-     * Debounces a function call, canceling any pending execution with the same key
-     * and scheduling a new execution after the specified delay.
-     *
-     * Each call with the same key cancels the previous pending execution and resets
-     * the timer. Useful for rate-limiting user input or API calls.
-     *
-     * @param handler - Function to execute after the delay
-     * @param key - Unique key to identify this debounced operation. Multiple calls
-     *              with the same key will cancel previous pending executions.
-     * @param ms - Delay in milliseconds before executing the handler (default: 0)
-     *
-     * @example
-     * ```typescript
-     * // Debounce search input
-     * this.debounce(() => this.performSearch(query), 'search', 300);
-     * ```
-     */
-    debounce(handler, key, ms = 0) {
-        _clearTimeout(this.timeoutMap[key]);
-        this.timeoutMap[key] = _setTimeout(handler, ms);
-    }
-    // // possibly to add
-    // public async debounceSync(handler: TimerHandler, key: string, ms = 0) {
-    // 	_clearTimeout(this.timeoutMap[key]);
-    //
-    // 	await new Promise((resolve, reject) => {
-    // 		this.timeoutMap[key] = setTimeout(async (..._args) => {
-    // 			try {
-    // 				await handler(..._args);
-    // 				resolve();
-    // 			} catch (e:any) {
-    // 				reject(e);
-    // 			}
-    // 		}, ms) as unknown as number;
-    // 	});
-    // }
-    /**
-     * Throttles a function call, ensuring it executes at most once per time period.
-     *
-     * Unlike debounce, throttle executes immediately if no execution is pending,
-     * then prevents further executions until the time period expires. Useful for
-     * limiting the frequency of expensive operations.
-     *
-     * @param handler - Function to execute
-     * @param key - Unique key to identify this throttled operation
-     * @param ms - Minimum time in milliseconds between executions (default: 0)
-     *
-     * @example
-     * ```typescript
-     * // Throttle scroll handler
-     * this.throttle(() => this.updateScrollPosition(), 'scroll', 100);
-     * ```
-     */
-    throttle(handler, key, ms = 0) {
-        if (this.timeoutMap[key])
-            return;
-        this.timeoutMap[key] = _setTimeout(() => {
-            handler();
-            delete this.timeoutMap[key];
-        }, ms);
-    }
+    addToClassStack = (cls) => {
+        this.classStack.push(cls.name);
+    };
+    isInstanceOf = (cls) => {
+        return this.classStack.includes(cls.name);
+    };
+    isInstanceType = (cls) => {
+        return lastElement(this.classStack) === cls.name;
+    };
     /**
      * Sets a config validator for runtime validation of module configuration.
      *

package/index.d.ts

@@ -35,4 +35,5 @@ export * from './validator/validator-core.js';
 export * from './validator/validators.js';
 export * from './validator/type-validators.js';
 export * from './consts/consts.js';
+export * from './mem-cache/index.js';
 export * from './modules/csv-serializer.js';

package/index.js

@@ -52,4 +52,5 @@ export * from './validator/validator-core.js';
 export * from './validator/validators.js';
 export * from './validator/type-validators.js';
 export * from './consts/consts.js';
+export * from './mem-cache/index.js';
 export * from './modules/csv-serializer.js';

package/mem-cache/MemCache.d.ts

@@ -0,0 +1,57 @@
+import { TypedMap } from '../utils/types.js';
+/** Key reference for lookup: string id or partial object to resolve via keyToId */
+export type MemCacheKeyRef = string | Record<string, unknown>;
+/**
+ * Options for constructing a MemCache. Id extraction is pluggable; no DB or domain types.
+ */
+export type MemCacheOptions<T extends object> = {
+    /** Extracts a stable string id from an item. Used for map storage and delta updates. */
+    getId: (item: T) => string;
+    /** Resolves a lookup key (string or partial object) to id. Omit if lookups are always by string id. */
+    keyToId?: (key: MemCacheKeyRef) => string;
+};
+/**
+ * In-memory cache with pluggable id extraction.
+ *
+ * Provides fast, synchronous access with filtering, mapping, unique lookups, and delta updates.
+ * Items are stored frozen. No dependency on DB or Proto; app provides getId/keyToId.
+ *
+ * @template T - Item type
+ */
+export declare class MemCache<T extends object> {
+    private readonly getId;
+    private readonly keyToId;
+    loaded: boolean;
+    private _map;
+    private _array;
+    protected cacheFilter?: (item: Readonly<T>) => boolean;
+    constructor(options: MemCacheOptions<T>);
+    setCacheFilter: (filter: (item: Readonly<T>) => boolean) => void;
+    getCacheFilter: () => ((item: Readonly<T>) => boolean) | undefined;
+    forEach: (processor: (item: Readonly<T>) => void) => void;
+    clear: () => void;
+    /**
+     * Load items into cache. Items are frozen.
+     */
+    load(items: T[]): void;
+    private resolveKey;
+    uniqueAssert: (key?: MemCacheKeyRef) => Readonly<T>;
+    unique: (key?: MemCacheKeyRef) => Readonly<T> | undefined;
+    all: () => Readonly<Readonly<T>[]>;
+    allMutable: () => Readonly<T>[];
+    filter: (filter: (item: Readonly<T>, index: number, array: Readonly<T[]>) => boolean) => Readonly<T>[];
+    byIds: (ids: MemCacheKeyRef[]) => (Readonly<T> | undefined)[];
+    find: (filter: (item: Readonly<T>, index: number, array: Readonly<T[]>) => boolean) => Readonly<T> | undefined;
+    map: <U>(mapper: (item: Readonly<T>, index: number, array: Readonly<T[]>) => U) => U[];
+    sort: (map?: keyof T | (keyof T)[] | ((item: Readonly<T>) => unknown), invert?: boolean) => Readonly<T>[];
+    arrayToMap: (getKey: (item: Readonly<T>, index: number, map: TypedMap<Readonly<T>>) => string | number | (string | number)[], map?: TypedMap<Readonly<T>>) => TypedMap<Readonly<T>>;
+    /**
+     * Update cache after entries are deleted. Uses getId for identity.
+     */
+    onEntriesDeleted(itemsDeleted: T[]): void;
+    /**
+     * Update cache after entries are updated/created. Uses getId for identity.
+     */
+    onEntriesUpdated(itemsUpdated: T[]): void;
+    protected setCache(cacheArray: Readonly<T>[]): void;
+}

package/mem-cache/MemCache.js

@@ -0,0 +1,95 @@
+/*
+ * ts-common - Core TypeScript infrastructure
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ * Licensed under the Apache License, Version 2.0
+ */
+import { arrayToMap, sortArray } from '../utils/array-tools.js';
+import { BadImplementationException } from '../core/exceptions/exceptions.js';
+/**
+ * In-memory cache with pluggable id extraction.
+ *
+ * Provides fast, synchronous access with filtering, mapping, unique lookups, and delta updates.
+ * Items are stored frozen. No dependency on DB or Proto; app provides getId/keyToId.
+ *
+ * @template T - Item type
+ */
+export class MemCache {
+    getId;
+    keyToId;
+    loaded = false;
+    _map;
+    _array;
+    cacheFilter;
+    constructor(options) {
+        this.getId = options.getId;
+        this.keyToId = options.keyToId;
+        this.clear();
+    }
+    setCacheFilter = (filter) => {
+        this.cacheFilter = filter;
+    };
+    getCacheFilter = () => this.cacheFilter;
+    forEach = (processor) => {
+        this._array.forEach(processor);
+    };
+    clear = () => {
+        this.setCache([]);
+        this.loaded = false;
+    };
+    /**
+     * Load items into cache. Items are frozen.
+     */
+    load(items) {
+        const frozen = items.map(item => Object.freeze(item));
+        this.setCache(frozen);
+        this.loaded = true;
+    }
+    resolveKey(key) {
+        if (typeof key === 'string')
+            return key;
+        if (this.keyToId)
+            return this.keyToId(key);
+        return undefined;
+    }
+    uniqueAssert = (key) => {
+        const item = this.unique(key);
+        if (!item)
+            throw new BadImplementationException(`Missing expected item for keys: ${JSON.stringify(key)}`);
+        return item;
+    };
+    unique = (key) => {
+        if (key === undefined)
+            return undefined;
+        const id = this.resolveKey(key);
+        return id !== undefined ? this._map[id] : undefined;
+    };
+    all = () => this._array;
+    allMutable = () => [...this._array];
+    filter = (filter) => this.all().filter(filter);
+    byIds = (ids) => ids.map(id => this.unique(id));
+    find = (filter) => this.all().find(filter);
+    map = (mapper) => this.all().map(mapper);
+    sort = (map = (i) => i, invert = false) => sortArray(this.allMutable(), map, invert);
+    arrayToMap = (getKey, map = {}) => arrayToMap(this.allMutable(), getKey, map);
+    /**
+     * Update cache after entries are deleted. Uses getId for identity.
+     */
+    onEntriesDeleted(itemsDeleted) {
+        const ids = new Set(itemsDeleted.map(this.getId));
+        this.setCache(this.filter(i => !ids.has(this.getId(i))));
+    }
+    /**
+     * Update cache after entries are updated/created. Uses getId for identity.
+     */
+    onEntriesUpdated(itemsUpdated) {
+        const frozen = itemsUpdated.map(item => Object.freeze(item));
+        const ids = new Set(itemsUpdated.map(this.getId));
+        const toCache = this.filter(i => !ids.has(this.getId(i)));
+        toCache.push(...frozen);
+        this.setCache(toCache);
+    }
+    setCache(cacheArray) {
+        this._map = Object.freeze({ ...arrayToMap(cacheArray, (item) => this.getId(item)) });
+        this._array = Object.freeze(cacheArray);
+    }
+}

package/mem-cache/index.d.ts

@@ -0,0 +1 @@
+export * from './MemCache.js';

package/mem-cache/index.js

@@ -0,0 +1,6 @@
+/*
+ * ts-common - Core TypeScript infrastructure
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ * Licensed under the Apache License, Version 2.0
+ */
+export * from './MemCache.js';

package/mem-storage/MemStorage.d.ts

@@ -86,6 +86,12 @@ export declare class MemStorage {
  * Provides a type-safe interface for accessing MemStorage values.
  * Supports unique keys (prevent overwriting), lazy resolution, and assertions.
  *
+ * **Design – never set nothing**: MemKeys must never be set to undefined or null.
+ * There is no point in setting something that is nothing; it would be like deleting
+ * or overwriting relevant state that should persist. Callers must use a meaningful
+ * empty value for their type (e.g. `''` for string, `{}` for object) when the logical
+ * value is "absent". `set()` throws if given undefined or null.
+ *
  * **Usage**:
  * ```typescript
  * const userKey = new MemKey<User>('user', true); // unique key

package/mem-storage/MemStorage.js

@@ -128,6 +128,12 @@ export class MemStorage {
  * Provides a type-safe interface for accessing MemStorage values.
  * Supports unique keys (prevent overwriting), lazy resolution, and assertions.
  *
+ * **Design – never set nothing**: MemKeys must never be set to undefined or null.
+ * There is no point in setting something that is nothing; it would be like deleting
+ * or overwriting relevant state that should persist. Callers must use a meaningful
+ * empty value for their type (e.g. `''` for string, `{}` for object) when the logical
+ * value is "absent". `set()` throws if given undefined or null.
+ *
  * **Usage**:
  * ```typescript
  * const userKey = new MemKey<User>('user', true); // unique key

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nu-art/ts-common",
-  "version": "0.401.8",
+  "version": "0.500.0",
   "description": "Core TypeScript infrastructure library for building modular applications with lifecycle management, logging, validation, and utilities",
   "type": "module",
   "keywords": [
@@ -37,8 +37,8 @@
     "run-tests": "ts-mocha --timeout 50000 -p src/test/tsconfig.json src/test/run-all-tests.ts"
   },
   "dependencies": {
-    "@nu-art/testalot": "0.401.8",
-    "@nu-art/logger": "0.401.8",
+    "@nu-art/testalot": "0.500.0",
+    "@nu-art/logger": "0.500.0",
     "fast-csv": "^5.0.2",
     "export-to-csv": "0.2.1",
     "moment": "^2.29.4",

package/utils/db-object-tools.js

@@ -9,7 +9,11 @@ export const DB_OBJECT_PROP__CREATED = '__created';
 /** Database object property name for update timestamp */
 export const DB_OBJECT_PROP__UPDATED = '__updated';
 /** Array of all database object metadata keys */
-export const KeysOfDB_Object = [DB_OBJECT_PROP__ID, DB_OBJECT_PROP__VERSION, DB_OBJECT_PROP__CREATED, DB_OBJECT_PROP__UPDATED, '__metadata1'];
+export const KeysOfDB_Object = [DB_OBJECT_PROP__ID,
+    DB_OBJECT_PROP__VERSION,
+    DB_OBJECT_PROP__CREATED,
+    DB_OBJECT_PROP__UPDATED,
+    '__metadata1'];
 /**
  * Extracts the ID from a database object.
  *

package/utils/hash-tools.js

@@ -15,7 +15,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import md from "node-forge";
+import md from 'node-forge';
 /**
  * Computes MD5 hash of input data.
  *
@@ -84,7 +84,7 @@ export function sha512(toBeConverted) {
  * @param encoding - Target encoding (default: "base64")
  * @returns Encoded string
  */
-export function encode(data, encoding = "base64") {
+export function encode(data, encoding = 'base64') {
     let buffer;
     if (Buffer.isBuffer(data))
         buffer = data;
@@ -102,6 +102,6 @@ export function encode(data, encoding = "base64") {
  * @param to - Target encoding (default: "utf8")
  * @returns Decoded string
  */
-export function decode(encoded, from = "base64", to = "utf8") {
+export function decode(encoded, from = 'base64', to = 'utf8') {
     return Buffer.from(encoded, from).toString(to);
 }

package/utils/index.d.ts

@@ -1,27 +1,27 @@
-export * from "./array-tools.js";
-export * from "./conflict-tools.js";
-export * from "./crypto-tools.js";
-export * from "./date-time-tools.js";
-export * from "./db-object-tools.js";
-export * from "./exception-tools.js";
-export * from "./filter-tools.js";
-export * from "./hash-tools.js";
-export * from "./index.js";
-export * from "./json-tools.js";
-export * from "./merge-tools.js";
-export * from "./mimetype-tools.js";
-export * from "./number-tools.js";
-export * from "./object-tools.js";
-export * from "./promise-tools.js";
-export * from "./query-params.js";
-export * from "./queue.js";
-export * from "./queue-v2.js";
-export * from "./random-tools.js";
-export * from "./storage-capacity-tools.js";
-export * from "./string-tools.js";
-export * from "./time-proxy.js";
-export * from "./tools.js";
-export * from "./types.js";
-export * from "./ui-tools.js";
-export * from "./url-tools.js";
-export * from "./version-tools.js";
+export * from './array-tools.js';
+export * from './conflict-tools.js';
+export * from './crypto-tools.js';
+export * from './date-time-tools.js';
+export * from './db-object-tools.js';
+export * from './exception-tools.js';
+export * from './filter-tools.js';
+export * from './hash-tools.js';
+export * from './index.js';
+export * from './json-tools.js';
+export * from './merge-tools.js';
+export * from './mimetype-tools.js';
+export * from './number-tools.js';
+export * from './object-tools.js';
+export * from './promise-tools.js';
+export * from './query-params.js';
+export * from './queue.js';
+export * from './queue-v2.js';
+export * from './random-tools.js';
+export * from './storage-capacity-tools.js';
+export * from './string-tools.js';
+export * from './time-proxy.js';
+export * from './tools.js';
+export * from './types.js';
+export * from './ui-tools.js';
+export * from './url-tools.js';
+export * from './version-tools.js';

package/utils/index.js

@@ -1,27 +1,27 @@
-export * from "./array-tools.js";
-export * from "./conflict-tools.js";
-export * from "./crypto-tools.js";
-export * from "./date-time-tools.js";
-export * from "./db-object-tools.js";
-export * from "./exception-tools.js";
-export * from "./filter-tools.js";
-export * from "./hash-tools.js";
-export * from "./index.js";
-export * from "./json-tools.js";
-export * from "./merge-tools.js";
-export * from "./mimetype-tools.js";
-export * from "./number-tools.js";
-export * from "./object-tools.js";
-export * from "./promise-tools.js";
-export * from "./query-params.js";
-export * from "./queue.js";
-export * from "./queue-v2.js";
-export * from "./random-tools.js";
-export * from "./storage-capacity-tools.js";
-export * from "./string-tools.js";
-export * from "./time-proxy.js";
-export * from "./tools.js";
-export * from "./types.js";
-export * from "./ui-tools.js";
-export * from "./url-tools.js";
-export * from "./version-tools.js";
+export * from './array-tools.js';
+export * from './conflict-tools.js';
+export * from './crypto-tools.js';
+export * from './date-time-tools.js';
+export * from './db-object-tools.js';
+export * from './exception-tools.js';
+export * from './filter-tools.js';
+export * from './hash-tools.js';
+export * from './index.js';
+export * from './json-tools.js';
+export * from './merge-tools.js';
+export * from './mimetype-tools.js';
+export * from './number-tools.js';
+export * from './object-tools.js';
+export * from './promise-tools.js';
+export * from './query-params.js';
+export * from './queue.js';
+export * from './queue-v2.js';
+export * from './random-tools.js';
+export * from './storage-capacity-tools.js';
+export * from './string-tools.js';
+export * from './time-proxy.js';
+export * from './tools.js';
+export * from './types.js';
+export * from './ui-tools.js';
+export * from './url-tools.js';
+export * from './version-tools.js';

package/utils/tools.d.ts

@@ -124,3 +124,9 @@ export type KeyBinder<K extends string, Type> = {
  * @returns Locked function that prevents concurrent execution
  */
 export declare function createLockedAsyncFunction(fn: () => Promise<void>): () => void;
+/**
+ * Converts a base64 data URL to a Blob.
+ * @param imageAsBase64 - Data URL (e.g. "data:image/png;base64,...") or base64 string
+ * @returns Promise resolving to the Blob
+ */
+export declare function base64ToBlob(imageAsBase64: string): Promise<Blob>;

package/utils/tools.js

@@ -173,3 +173,11 @@ export function createLockedAsyncFunction(fn) {
         });
     };
 }
+/**
+ * Converts a base64 data URL to a Blob.
+ * @param imageAsBase64 - Data URL (e.g. "data:image/png;base64,...") or base64 string
+ * @returns Promise resolving to the Blob
+ */
+export async function base64ToBlob(imageAsBase64) {
+    return (await fetch(imageAsBase64)).blob();
+}

package/utils/types.d.ts

@@ -292,15 +292,6 @@ export type AuditBy = {
     /** Timestamp of the change */
     auditAt: Timestamp;
 };
-/**
- * Simplified audit information (v2).
- *
- * Only stores the auditor ID, not full audit details.
- */
-export type AuditableV2 = {
-    /** ID of the user/system that made the change */
-    _auditorId: string;
-};
 /**
  * Timestamp with formatted string representation.
  */

package/validator/type-validators.d.ts

@@ -16,7 +16,7 @@ import { ArrayType, AuditBy, RangeTimestamp, TypedMap } from '../utils/types.js'
  * @param mandatory - Whether the object itself is required (default: true)
  * @returns Validator that validates both keys and values
  */
-export declare const tsValidateDynamicObject: <T extends object>(valuesValidator: ValidatorTypeResolver<T[keyof T]>, keysValidator: ValidatorTypeResolver<string>, mandatory?: boolean) => (import("./validator-core.js").ValidatorImpl<any> | ((input?: T) => InvalidResultObject<T> | undefined))[];
+export declare const tsValidateDynamicObject: <T extends object>(valuesValidator: ValidatorTypeResolver<T[keyof T]>, keysValidator: ValidatorTypeResolver<keyof T>, mandatory?: boolean) => (import("./validator-core.js").ValidatorImpl<any> | ((input?: T) => InvalidResultObject<T> | undefined))[];
 /**
  * Validates input against multiple validators (union type).
  *

package/validator/validator-core.d.ts

@@ -10,7 +10,7 @@ import { CustomException } from '../core/exceptions/exceptions.js';
  *
  * This enables type-safe validation where the validator structure matches the data structure.
  */
-export type ValidatorTypeResolver<K> = K extends [any] ? Validator<K> : K extends [any, any] ? Validator<K> : K extends [any, any, any] ? Validator<K> : K extends [any, any, any, any] ? Validator<K> : K extends any[] ? Validator<K> : K extends TS_Object ? TypeValidator<K> | Validator<K> : Validator<K>;
+export type ValidatorTypeResolver<K> = K extends (any[] | readonly any[]) ? Validator<K> : K extends TS_Object ? TypeValidator<K> | Validator<K> : Validator<K>;
 /**
  * Core validator function type.
  *

package/validator/validators.d.ts

@@ -1,5 +1,5 @@
 import { Validator, ValidatorTypeResolver } from './validator-core.js';
-import { AuditableV2, DBPointer } from '../utils/types.js';
+import { DBPointer } from '../utils/types.js';
 import { DBDef_V3 } from '../db/types.js';
 /**
  * Validates an optional array (non-mandatory).
@@ -111,7 +111,6 @@ export declare const tsValidator_LowerUpperStringWithSpaces: Validator<string>;
 export declare const tsValidator_LowerUpperStringWithDashesAndUnderscore: Validator<string>;
 export declare const tsValidator_InternationalPhoneNumber: Validator<string>;
 export declare const tsValidator_DB_RefId: Validator<string>;
-export declare const tsValidator_AuditableV2: ValidatorTypeResolver<AuditableV2>;
 export declare const DB_Object_validator: {
     __metadata1: import("./validator-core.js").ValidatorImpl<any>;
     _id: Validator<string>;

package/validator/validators.js

@@ -118,7 +118,6 @@ export const tsValidator_LowerUpperStringWithSpaces = tsValidateRegexp(/^[A-Za-z
 export const tsValidator_LowerUpperStringWithDashesAndUnderscore = tsValidateRegexp(/^[A-Za-z-_]+$/);
 export const tsValidator_InternationalPhoneNumber = tsValidateRegexp(/^\+(?:[0-9] ?){6,14}[0-9]$/);
 export const tsValidator_DB_RefId = tsValidateId(dbRefIdLength);
-export const tsValidator_AuditableV2 = { _auditorId: tsValidateString() };
 export const DB_Object_validator = {
     // this will be the way to handle app level context via proto.. need to rename this to __metadata once done
     __metadata1: tsValidateOptional,