@ug.software/opposer 3.0.10

package/lib/esm/orm/validation.d.ts

@@ -0,0 +1,44 @@
+export type ValidationFunction = (value: unknown, context: object) => string | null;
+export declare class FieldValidator {
+    protected _type: string | null;
+    protected _cases: ValidationFunction[];
+    protected _default: any;
+    get type(): string | null;
+    get defaultValue(): any;
+    default(value: any): this;
+    when(test: ValidationFunction): this;
+    validate(value: unknown, context: object): string[];
+}
+declare class NumberValidator extends FieldValidator {
+    constructor(message: string);
+    required(message: string): this;
+    min(min: number, message: string): this;
+    max(max: number, message: string): this;
+}
+declare class StringValidator extends FieldValidator {
+    constructor(message: string);
+    required(message: string): this;
+    match(regex: RegExp, message: string): this;
+}
+declare class BooleanValidator extends FieldValidator {
+    constructor(message: string);
+    required(message: string): this;
+}
+declare class DateValidator extends FieldValidator {
+    constructor(message: string);
+    required(message: string): this;
+}
+declare class JsonValidator extends FieldValidator {
+    private children?;
+    constructor(children?: Record<string, FieldValidator> | undefined);
+    validate(value: any, context: object): string[];
+}
+export declare class ValidationBuilder {
+    string(message: string): StringValidator;
+    number(message: string): NumberValidator;
+    boolean(message: string): BooleanValidator;
+    date(message: string): DateValidator;
+    json(model: Record<string, FieldValidator>): JsonValidator;
+}
+export declare const f: () => ValidationBuilder;
+export {};

package/lib/esm/orm/validation.js

@@ -0,0 +1,122 @@
+export class FieldValidator {
+    constructor() {
+        this._type = null;
+        this._cases = [];
+        this._default = undefined;
+    }
+    get type() {
+        return this._type;
+    }
+    get defaultValue() {
+        return this._default;
+    }
+    default(value) {
+        this._default = value;
+        return this;
+    }
+    when(test) {
+        this._cases.push(test);
+        return this;
+    }
+    validate(value, context) {
+        return this._cases.map((fn) => fn(value, context)).filter((res) => res !== null);
+    }
+}
+class NumberValidator extends FieldValidator {
+    constructor(message) {
+        super();
+        this._type = 'number';
+        this._cases.push((value) => (value === null || value === undefined ? null : typeof value !== 'number' ? message : null));
+    }
+    required(message) {
+        this._cases.push((value) => (value === undefined || value === null || String(value).trim() === '' ? message : null));
+        return this;
+    }
+    min(min, message) {
+        this._cases.push((value) => (typeof value === 'number' && value < min ? message : null));
+        return this;
+    }
+    max(max, message) {
+        this._cases.push((value) => (typeof value === 'number' && value > max ? message : null));
+        return this;
+    }
+}
+class StringValidator extends FieldValidator {
+    constructor(message) {
+        super();
+        this._type = 'string';
+        this._cases.push((value) => (value === null || value === undefined ? null : typeof value !== 'string' ? message : null));
+    }
+    required(message) {
+        this._cases.push((value) => (!value || String(value).trim() === '' ? message : null));
+        return this;
+    }
+    match(regex, message) {
+        this._cases.push((value) => (value === null || value === undefined ? null : !regex.test(String(value)) ? message : null));
+        return this;
+    }
+}
+class BooleanValidator extends FieldValidator {
+    constructor(message) {
+        super();
+        this._type = 'boolean';
+        this._cases.push((value) => (value === null || value === undefined ? null : typeof value !== 'boolean' ? message : null));
+    }
+    required(message) {
+        this._cases.push((value) => (typeof value !== 'boolean' ? message : null));
+        return this;
+    }
+}
+class DateValidator extends FieldValidator {
+    constructor(message) {
+        super();
+        this._type = 'date';
+        this._cases.push((value) => {
+            if (value === null || value === undefined)
+                return null;
+            const d = new Date(value);
+            return isNaN(d.getTime()) ? message : null;
+        });
+    }
+    required(message) {
+        return this.when((value) => (!value ? message : null));
+    }
+}
+class JsonValidator extends FieldValidator {
+    constructor(children) {
+        super();
+        this.children = children;
+        this._type = 'jsonb';
+    }
+    validate(value, context) {
+        if (typeof value !== 'object' || value === null) {
+            return ['Must be a valid JSON object.'];
+        }
+        if (!this.children)
+            return [];
+        const errors = [];
+        for (const [key, validator] of Object.entries(this.children)) {
+            const childErrors = validator.validate(value[key], context);
+            errors.push(...childErrors.map((e) => `${key}: ${e}`));
+        }
+        return errors;
+    }
+}
+export class ValidationBuilder {
+    string(message) {
+        return new StringValidator(message);
+    }
+    number(message) {
+        return new NumberValidator(message);
+    }
+    boolean(message) {
+        return new BooleanValidator(message);
+    }
+    date(message) {
+        return new DateValidator(message);
+    }
+    json(model) {
+        return new JsonValidator(model);
+    }
+}
+export const f = () => new ValidationBuilder();

package/lib/esm/persistent/cache/core-context.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Especialized storage for Opposer Core Context.
+ * Uses GlobalStorage internally but provides a clean Singleton interface
+ * for the server engine and public consumption.
+ */
+declare class ContextStorage {
+    private static instance;
+    private readonly namespace;
+    private constructor();
+    static getInstance(): ContextStorage;
+    set<T>(key: string, value: T): void;
+    get<T>(key: string): T;
+    has(key: string): boolean;
+    clear(): void;
+}
+declare const _default: ContextStorage;
+export default _default;

package/lib/esm/persistent/cache/core-context.js

@@ -0,0 +1,34 @@
+import GlobalStorage from "../cache/global.js";
+/**
+ * Especialized storage for Opposer Core Context.
+ * Uses GlobalStorage internally but provides a clean Singleton interface
+ * for the server engine and public consumption.
+ */
+class ContextStorage {
+    constructor() {
+        this.namespace = "opposer:core:context";
+    }
+    static getInstance() {
+        if (!ContextStorage.instance) {
+            ContextStorage.instance = new ContextStorage();
+        }
+        return ContextStorage.instance;
+    }
+    set(key, value) {
+        const data = GlobalStorage.get(this.namespace) || {};
+        data[key] = value;
+        GlobalStorage.set(this.namespace, data);
+    }
+    get(key) {
+        const data = GlobalStorage.get(this.namespace) || {};
+        return data[key];
+    }
+    has(key) {
+        const data = GlobalStorage.get(this.namespace) || {};
+        return Object.prototype.hasOwnProperty.call(data, key);
+    }
+    clear() {
+        GlobalStorage.set(this.namespace, {});
+    }
+}
+export default ContextStorage.getInstance();

package/lib/esm/persistent/cache/global.d.ts

@@ -0,0 +1,18 @@
+import type { CacheSettings } from "../interfaces/system.js";
+import Store from "./store.js";
+declare const _default: {
+    __settings: CacheSettings;
+    __data: Store;
+    set(key: string, value: any): void;
+    get(key: string): any;
+    __isMaxSizeMemory: boolean;
+    __currentSizeMemory: number;
+    snapshot(): void;
+    restore(): void;
+    size(): boolean;
+    revalidate(): void | null;
+    notifyStoresForClearMemoryPerPolicy(): void;
+    clear(): void;
+    configure(): /*elided*/ any;
+};
+export default _default;

package/lib/esm/persistent/cache/global.js

@@ -0,0 +1,17 @@
+import system from "../system/index.js";
+import Storage from "./storage.js";
+import Store from "./store.js";
+export default new (class Global extends Storage {
+    constructor() {
+        super();
+        this.__settings = system.settings.cache.global;
+        this.__data = new Store();
+        this.__data.setSettings(system.settings.cache.global);
+    }
+    set(key, value) {
+        this.__data.set(key, value);
+    }
+    get(key) {
+        return this.__data.get(key);
+    }
+})().configure();

package/lib/esm/persistent/cache/index.d.ts

@@ -0,0 +1,3 @@
+export { default as SessionStorage } from "./session";
+export { default as GlobalStorage } from "./global";
+export { default as Store } from "./store";

package/lib/esm/persistent/cache/index.js

@@ -0,0 +1,3 @@
+export { default as SessionStorage } from "./session";
+export { default as GlobalStorage } from "./global";
+export { default as Store } from "./store";

package/lib/esm/persistent/cache/session.d.ts

@@ -0,0 +1,19 @@
+import type { Request, Response, NextFunction } from "express";
+import Store from "./store.js";
+declare const _default: {
+    createStore(sessionId: string): Store;
+    loadStore(sessionId: string): Store | null;
+    initialize(req: Request, res: Response, next: NextFunction): Response<any, Record<string, any>> | undefined;
+    __settings: import("../interfaces/system.js").CacheSettings;
+    __data: Record<string, any>;
+    __isMaxSizeMemory: boolean;
+    __currentSizeMemory: number;
+    snapshot(): void;
+    restore(): void;
+    size(): boolean;
+    revalidate(): void | null;
+    notifyStoresForClearMemoryPerPolicy(): void;
+    clear(): void;
+    configure(): /*elided*/ any;
+};
+export default _default;

package/lib/esm/persistent/cache/session.js

@@ -0,0 +1,34 @@
+import context from "../context/index.js";
+import Storage from "./storage.js";
+import Store from "./store.js";
+export default new (class Session extends Storage {
+    createStore(sessionId) {
+        const store = new Store(sessionId);
+        Object.defineProperty(this.__data, sessionId, {
+            value: store,
+            writable: true,
+            enumerable: true,
+            configurable: true,
+        });
+        return store;
+    }
+    loadStore(sessionId) {
+        const store = this.__data[sessionId];
+        if (!store) {
+            if (this.__isMaxSizeMemory) {
+                return null;
+            }
+            return this.createStore(sessionId);
+        }
+        store.revalidateTimer();
+        return store;
+    }
+    initialize(req, res, next) {
+        const sessionId = req.headers["session-opposer-id"];
+        const store = this.loadStore(sessionId);
+        if (!sessionId) {
+            return res.status(401);
+        }
+        context.run({ store, sessionId }, next);
+    }
+})().configure();

package/lib/esm/persistent/cache/storage.d.ts

@@ -0,0 +1,14 @@
+import { type CacheSettings } from "../interfaces/system.js";
+export default class Storage {
+    __settings: CacheSettings;
+    __data: Record<string, any>;
+    __isMaxSizeMemory: boolean;
+    __currentSizeMemory: number;
+    snapshot(): void;
+    restore(): void;
+    size(): boolean;
+    revalidate(): void | null;
+    notifyStoresForClearMemoryPerPolicy(): void;
+    clear(): void;
+    configure(): this;
+}

package/lib/esm/persistent/cache/storage.js

@@ -0,0 +1,82 @@
+import timer from "../utils/timer.js";
+import system from "../system/index.js";
+import Store from "./store.js";
+import memory from "../utils/memory.js";
+export default class Storage {
+    constructor() {
+        this.__data = {};
+        this.__isMaxSizeMemory = false;
+        this.__currentSizeMemory = 0;
+    }
+    snapshot() { }
+    restore() { }
+    size() {
+        this.__currentSizeMemory = memory.roughSizeOfObject(this.__data);
+        this.__isMaxSizeMemory =
+            this.__currentSizeMemory ===
+                memory.toBytes(this.__settings.maxmemory.size, this.__settings.maxmemory.unit);
+        return this.__isMaxSizeMemory;
+    }
+    revalidate() {
+        if (this.__data instanceof Store) {
+            this.__data.clearMemoryForPolicy();
+            var __isMaxSizeMemory = this.size();
+            if (__isMaxSizeMemory) {
+                return this.notifyStoresForClearMemoryPerPolicy();
+            }
+            return null;
+        }
+        var creared = Object.keys(this.__data).reduce((data, key) => {
+            var store = this.__data[key];
+            if (store.isValid()) {
+                Object.defineProperty(data, key, {
+                    value: store,
+                    configurable: true,
+                    enumerable: true,
+                    writable: true,
+                });
+            }
+            return data;
+        }, {});
+        Object.defineProperty(this, "__data", {
+            value: creared,
+            configurable: true,
+            enumerable: true,
+            writable: true,
+        });
+        var __isMaxSizeMemory = this.size();
+        if (__isMaxSizeMemory) {
+            return this.notifyStoresForClearMemoryPerPolicy();
+        }
+        return null;
+    }
+    notifyStoresForClearMemoryPerPolicy() {
+        Object.values(this.__data).forEach((store) => store.clearMemoryForPolicy());
+        var __isMaxSizeMemory = this.size();
+        if (__isMaxSizeMemory) {
+            this.notifyStoresForClearMemoryPerPolicy();
+        }
+    }
+    clear() {
+        Object.defineProperty(this, "__data", {
+            value: {},
+            configurable: true,
+            enumerable: true,
+            writable: true,
+        });
+    }
+    configure() {
+        if (system.settings.cache.type === "persistent") {
+            if (system.settings.cache.snapshot.active) {
+                setInterval(() => {
+                    this.snapshot();
+                }, system.settings.cache.snapshot.timer * timer.msPerUnit[system.settings.cache.snapshot.unit]);
+            }
+            this.restore();
+        }
+        setInterval(() => {
+            this.revalidate();
+        }, timer.getSeconds(this.__settings.revalidate.timer, this.__settings.revalidate.unit));
+        return this;
+    }
+}

package/lib/esm/persistent/cache/store.d.ts

@@ -0,0 +1,16 @@
+import type { CacheSettings } from "../interfaces/system.js";
+export default class Store {
+    private __sessionId;
+    private __settings;
+    private __expires_in;
+    private __data;
+    private __meta;
+    constructor(session?: string);
+    private trackAccess;
+    get(key: string): any;
+    set(key: string, value: any, ttlMs?: number): void;
+    revalidateTimer(): void;
+    isValid(): boolean;
+    clearMemoryForPolicy(): void;
+    setSettings(settings: CacheSettings): void;
+}

package/lib/esm/persistent/cache/store.js

@@ -0,0 +1,106 @@
+import timer from "../utils/timer.js";
+export default class Store {
+    constructor(session) {
+        this.__expires_in = timer.getNextSessionExpireDate();
+        this.__data = new Map();
+        this.__meta = new Map();
+        this.__sessionId = session;
+    }
+    // Marca o acesso e frequência (para LFU/LRU)
+    trackAccess(key) {
+        if (!this.__meta.has(key)) {
+            this.__meta.set(key, {
+                lastAccess: Date.now(),
+                frequency: 1,
+                ttl: undefined,
+            });
+        }
+        else {
+            var __meta = this.__meta.get(key);
+            if (!__meta) {
+                return;
+            }
+            __meta.lastAccess = Date.now();
+            __meta.frequency++;
+        }
+    }
+    get(key) {
+        const value = this.__data.get(key);
+        if (value !== undefined) {
+            this.trackAccess(key);
+        }
+        return value;
+    }
+    set(key, value, ttlMs) {
+        this.__data.set(key, value);
+        this.__meta.set(key, {
+            lastAccess: Date.now(),
+            frequency: 1,
+            ttl: ttlMs ? Date.now() + ttlMs : undefined,
+        });
+    }
+    revalidateTimer() {
+        this.__expires_in = timer.getNextSessionExpireDate();
+    }
+    isValid() {
+        return this.__expires_in > new Date().getTime();
+    }
+    // Políticas de limpeza
+    clearMemoryForPolicy() {
+        const policy = this.__settings.evictionPolicy;
+        switch (policy) {
+            // Nenhuma exclusão automática
+            case "noeviction":
+                return;
+            // Remove o menos recentemente usado
+            case "volatile-lru": {
+                let oldestKey = null;
+                let oldestAccess = Infinity;
+                for (const [key, meta] of Object.entries(this.__meta)) {
+                    if (meta.lastAccess < oldestAccess) {
+                        oldestAccess = meta.lastAccess;
+                        oldestKey = key;
+                    }
+                }
+                if (oldestKey) {
+                    this.__data.delete(oldestKey);
+                    this.__meta.delete(oldestKey);
+                }
+                break;
+            }
+            // Remove o menos frequentemente usado
+            case "volatile-lfu": {
+                let leastUsedKey = null;
+                let leastFrequency = Infinity;
+                for (const [key, meta] of Object.entries(this.__meta)) {
+                    if (meta.frequency < leastFrequency) {
+                        leastUsedKey = key;
+                        leastFrequency = meta.frequency;
+                    }
+                }
+                if (leastUsedKey) {
+                    this.__data.delete(leastUsedKey);
+                    this.__meta.delete(leastUsedKey);
+                }
+                break;
+            }
+            // Remove chaves que passaram do TTL
+            case "volatile-ttl": {
+                const now = Date.now();
+                for (const [key, meta] of Object.entries(this.__meta)) {
+                    if (meta.ttl && meta.ttl < now) {
+                        this.__data.delete(key);
+                        this.__meta.delete(key);
+                    }
+                }
+                break;
+            }
+            default:
+                console.warn(`[Store] Unknown eviction policy: ${policy}`);
+                break;
+        }
+    }
+    setSettings(settings) {
+        this.__settings = settings;
+    }
+}

package/lib/esm/persistent/context/index.d.ts

@@ -0,0 +1,3 @@
+import { AsyncLocalStorage } from "async_hooks";
+declare const context: AsyncLocalStorage<unknown>;
+export default context;

package/lib/esm/persistent/context/index.js

@@ -0,0 +1,3 @@
+import { AsyncLocalStorage } from "async_hooks";
+const context = new AsyncLocalStorage();
+export default context;

package/lib/esm/persistent/decorators/global.d.ts

@@ -0,0 +1 @@
+export default function Global(): (target: any, property: string) => void;

package/lib/esm/persistent/decorators/global.js

@@ -0,0 +1,19 @@
+import global from "../cache/global.js";
+export default function Global() {
+    return function (target, property) {
+        const __property = Symbol(property);
+        const __class = target.constructor.name;
+        const __key = __class + ":" + property;
+        Object.defineProperty(target, property, {
+            get() {
+                return global.get(__key);
+            },
+            set(value) {
+                global.set(__key, value);
+                this[__property] = value;
+            },
+            enumerable: true,
+            configurable: true,
+        });
+    };
+}

package/lib/esm/persistent/decorators/session.d.ts

@@ -0,0 +1 @@
+export default function Session(): (target: any, property: string) => void;

package/lib/esm/persistent/decorators/session.js

@@ -0,0 +1,21 @@
+import context from "../context/index.js";
+export default function Session() {
+    return function (target, property) {
+        const __property = Symbol(property);
+        const __class = target.constructor.name;
+        const __key = __class + ":" + property;
+        Object.defineProperty(target, property, {
+            get() {
+                var __context = context.getStore();
+                return __context.store.get(__key);
+            },
+            set(value) {
+                var __context = context.getStore();
+                __context.store.set(__key, value);
+                this[__property] = value;
+            },
+            enumerable: true,
+            configurable: true,
+        });
+    };
+}

package/lib/esm/persistent/index.d.ts

@@ -0,0 +1,6 @@
+export { default as SessionStorage } from "./cache/session.js";
+export { default as GlobalStorage } from "./cache/global.js";
+export { default as Store } from "./cache/store.js";
+export { default as Session } from "./decorators/session.js";
+export { default as Global } from "./decorators/global.js";
+export { default as Context } from "./context/index.js";

package/lib/esm/persistent/index.js

@@ -0,0 +1,6 @@
+export { default as SessionStorage } from "./cache/session.js";
+export { default as GlobalStorage } from "./cache/global.js";
+export { default as Store } from "./cache/store.js";
+export { default as Session } from "./decorators/session.js";
+export { default as Global } from "./decorators/global.js";
+export { default as Context } from "./context/index.js";

package/lib/esm/persistent/interfaces/context.d.ts

@@ -0,0 +1,5 @@
+import type { Store } from "../cache/index.js";
+export interface ContextSession {
+    sessionId: string;
+    store: Store;
+}

package/lib/esm/persistent/interfaces/context.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/persistent/interfaces/system.d.ts

@@ -0,0 +1,47 @@
+export declare enum MemoryUnit {
+    MB = "mb",
+    GB = "gb"
+}
+export declare enum TimerUnit {
+    seconds = "seconds",
+    minutes = "minutes",
+    hours = "hours",
+    days = "days"
+}
+export declare enum EvictionPolicy {
+    noeviction = "noeviction",
+    volatileLru = "volatile-lru",
+    allkeysLru = "allkeys-lru",
+    volatileLfu = "volatile-lfu",
+    allkeysLfu = "allkeys-lfu",
+    volatileTtl = "volatile-ttl"
+}
+export declare enum CacheType {
+    inMemory = "in-memory",
+    persistent = "persistent"
+}
+export interface CacheSettings {
+    expire: number;
+    unit: TimerUnit;
+    evictionPolicy: EvictionPolicy;
+    maxmemory: {
+        size: number;
+        unit: MemoryUnit;
+    };
+    revalidate: {
+        timer: number;
+        unit: TimerUnit;
+    };
+}
+export interface OpposerSystemConfigOptions {
+    cache: {
+        type: CacheType;
+        snapshot: {
+            active: boolean;
+            timer: number;
+            unit: TimerUnit;
+        };
+        session: CacheSettings;
+        global: CacheSettings;
+    };
+}