@ug.software/opposer 3.0.10

package/lib/cjs/interfaces/controller.d.ts

@@ -0,0 +1,109 @@
+import { ClassType } from './system.js';
+export interface ControllerApiProps {
+    controller?: string;
+    method: 'get' | 'insert' | 'update' | 'delete' | string;
+    model: string;
+    payload?: any;
+    data?: any;
+}
+export interface QueryBuilder {
+    [key: string]: string | number | boolean | Date | {
+        $or?: {
+            [key: string]: any;
+        }[];
+        $l?: string;
+        $il?: string;
+        $in?: (string | number | Date)[];
+        $nin?: (string | number | Date)[];
+        $btw?: [number, number];
+        $mt?: number | Date;
+        $mte?: number | Date;
+        $lt?: number | Date;
+        $lte?: number | Date;
+        $eq?: any;
+    };
+}
+export interface RelationBuilder {
+    model: string;
+    select: (string | RelationBuilder)[];
+}
+export type AggregateOperator = 'sum' | 'avg' | 'min' | 'max' | 'count';
+export interface HandleGetProps {
+    model: string;
+    pagination?: {
+        page: number;
+        take: number;
+    };
+    query: {
+        type?: 'filter' | 'find' | 'count' | 'exists' | 'aggregate' | 'distinct' | 'group';
+        select?: string[];
+        find?: QueryBuilder;
+        filter?: QueryBuilder;
+        count?: QueryBuilder;
+        exists?: QueryBuilder;
+        aggregate?: {
+            where?: QueryBuilder;
+            aggregate: {
+                [key: string]: AggregateOperator;
+            };
+        };
+        distinct?: {
+            where?: QueryBuilder;
+            field: string;
+        };
+        group?: {
+            where?: QueryBuilder;
+            by: string[];
+            aggregate?: {
+                [key: string]: AggregateOperator;
+            };
+            select?: string[];
+        };
+        relation?: (string | RelationBuilder)[];
+    };
+}
+export interface HandleDeleteProps {
+    model: string;
+    filter: QueryBuilder;
+}
+export interface HandleInsertProps {
+    model: string;
+    data: {
+        [key: string]: unknown;
+    };
+}
+export interface HandleUpdateProps {
+    model: string;
+    filter: QueryBuilder;
+    data: {
+        [key: string]: unknown;
+    };
+}
+export interface ResultGetAllControllers {
+    [key: string]: {
+        metadata: {
+            name: string;
+        };
+        methods: {
+            name: string;
+        }[];
+        controller: ClassType<any>;
+    };
+}
+export interface PayloadRequest<D> {
+    data: D;
+    headers: {
+        autorization: string;
+        contentType: string;
+        accept: string;
+        origin: string;
+        referer: string;
+        userAgent: string;
+        ip: string;
+        cookies: {
+            data: Record<string, string>;
+            set: (name: string, value: string, options: any) => void;
+            remove: (name: string, options?: any) => void;
+        };
+    };
+}

package/lib/cjs/interfaces/controller.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/interfaces/field.d.ts

@@ -0,0 +1,23 @@
+export type ValidationFunction = (value: unknown, context: object) => string | null;
+export interface SettingsField {
+    required?: boolean;
+    default?: any;
+    length?: number;
+    match?: RegExp;
+    min?: number;
+    max?: number;
+    relation?: {
+        target: () => any;
+        type: "many-to-one" | "one-to-many" | "many-to-many" | "one-to-one" | null;
+        inverseSide: string;
+        joinColumn?: boolean;
+        joinTable?: boolean;
+        cascade?: boolean;
+    };
+}
+export interface Field {
+    type: "string" | "boolean" | "number" | "date" | "relation" | "array" | "jsonb" | null;
+    _cases: ValidationFunction[];
+    _settings: SettingsField;
+    validate: (value: any, context: object) => string[];
+}

package/lib/cjs/interfaces/field.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/interfaces/handler.d.ts

@@ -0,0 +1,18 @@
+import { CookieOptions } from "express";
+export interface PayloadRequest<D> {
+    data: D;
+    headers: {
+        autorization: string;
+        contentType: string;
+        accept: string;
+        origin: string;
+        referer: string;
+        userAgent: string;
+        ip: string;
+        cookies: {
+            data: Record<string, string>;
+            set: (name: string, value: string, options: CookieOptions) => void;
+            remove: (name: string, options?: CookieOptions) => void;
+        };
+    };
+}

package/lib/cjs/interfaces/handler.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/interfaces/jwt.d.ts

@@ -0,0 +1,21 @@
+export interface ErrorJwt {
+    name: string;
+    message: string;
+    expiredAt: number;
+}
+export interface SignJwt {
+    id: string;
+    exp: number;
+    fn: string;
+    ln: string;
+    lg: string;
+    rl: {
+        sm: string;
+        mt: string;
+    }[];
+}
+export interface ForgetJwt {
+    lg: string;
+    ip: string;
+    ag: string;
+}

package/lib/cjs/interfaces/jwt.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/interfaces/model.d.ts

@@ -0,0 +1,9 @@
+import { Field } from "./field.js";
+export interface ModelDefinition {
+    [key: string]: Field;
+}
+export interface ModelResult {
+    validation: Record<string, any>;
+    entity: any;
+    definition: ModelDefinition;
+}

package/lib/cjs/interfaces/model.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/interfaces/request.d.ts

@@ -0,0 +1,13 @@
+export interface HandleRequestResultSuccess<R> {
+    success: true;
+    data: R;
+}
+export interface HandleRequestResultError {
+    success: false;
+    error: {
+        name: string;
+        code: number;
+        message: any;
+    };
+}
+export type HandleRequestResult<R> = HandleRequestResultSuccess<R> | HandleRequestResultError;

package/lib/cjs/interfaces/request.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/interfaces/schema.d.ts

@@ -0,0 +1,9 @@
+import { Field } from './field.js';
+export interface ModelDefinition {
+    [key: string]: Field;
+}
+export interface ModelResult {
+    validation: Record<string, any>;
+    entity: any;
+    definition: ModelDefinition;
+}

package/lib/cjs/interfaces/schema.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/interfaces/security.d.ts

@@ -0,0 +1,32 @@
+export interface PayloadAuthRegister {
+    fn: string;
+    ln: string;
+    lg: string;
+    ps: string;
+}
+export interface PayloadSocialLogin {
+    id: string;
+    fn: string;
+    ln: string;
+    lg: string;
+    rl: {
+        sm: string;
+        mt: string;
+    }[];
+}
+export interface PayloadAuthLogin {
+    lg: string;
+    ps: string;
+    ip: string;
+    ag: string;
+}
+export interface PayloadAuthForgetPassword {
+    lg: string;
+    ip: string;
+    ag: string;
+}
+export interface PayloadAuthChangePassword {
+    tk: string;
+    ps: string;
+    rw: string;
+}

package/lib/cjs/interfaces/security.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/interfaces/server.d.ts

@@ -0,0 +1,37 @@
+import http from "http";
+import { ClassType } from "./system.js";
+export interface CreateServerProps {
+    cors?: {
+        origin: string | string[];
+    };
+    models?: string | ClassType<unknown>[];
+    controllers?: string | ClassType<unknown>[];
+    schedules?: string | ClassType<unknown>[];
+}
+export interface Request extends http.IncomingMessage {
+    server: OpposerServer;
+    ip?: string;
+    cookies: Record<string, string>;
+    body: any;
+    url: string;
+    method: string;
+}
+export interface Response extends http.ServerResponse {
+    status: (code: number) => Response;
+    json: (data: any) => void;
+    send: (data: any) => void;
+    cookie: (name: string, value: string, options?: any) => void;
+    clearCookie: (name: string, options?: any) => void;
+}
+export type NextFunction = () => void | Promise<void>;
+export interface OpposerServer {
+    use: (middleware: any) => OpposerServer;
+    listen: (port: number, callback?: () => void) => http.Server;
+}
+export interface ServerInstance {
+    opposer: OpposerServer;
+    initialize: () => void;
+}
+export type Server = http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+export type HandleCallback = (req: http.IncomingMessage, res: http.ServerResponse) => void;
+export type ListinerCallback = () => void;

package/lib/cjs/interfaces/server.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/interfaces/system.d.ts

@@ -0,0 +1,41 @@
+import { ConnectionOptions } from "../orm/index.js";
+export interface OpposerSystemConfigOptions {
+    models: string;
+    schedules: string;
+    controllers: string;
+    port: number;
+    url?: string;
+    text?: boolean;
+    urlencoded?: boolean;
+    helmet?: boolean;
+    logger?: boolean;
+    cors?: {
+        origin: string | string[];
+    };
+    rateLimit?: {
+        windowMs: number;
+        max: number;
+    };
+    auth: boolean | {
+        exposeChangePassword: boolean;
+    };
+    jwt: {
+        access: string;
+        refresh: string;
+        recover: string;
+    };
+    database: ConnectionOptions;
+    manager: {
+        firstName: string;
+        lastName: string;
+        login: string;
+        password: string;
+    };
+}
+export interface ClassType<T> {
+    new (...args: any[]): T;
+}
+export interface ModelDefinition {
+    name: string;
+    entity: ClassType<unknown>;
+}

package/lib/cjs/interfaces/system.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/orm/decorators/index.d.ts

@@ -0,0 +1,33 @@
+import { FieldType } from "../metadata.js";
+import { FieldValidator } from "../validation.js";
+export interface EntityOptions {
+    description?: string;
+}
+export declare function Entity(tableName: string, optionsOrDescription?: EntityOptions | string): (target: any, context?: any) => void;
+export interface RelationOptions {
+    type: "one-to-one" | "one-to-many" | "many-to-one" | "many-to-many";
+    target: () => Function;
+    inverseSide?: string;
+    joinColumn?: boolean;
+}
+export interface FieldOptions {
+    type?: FieldType;
+    primary?: boolean;
+    generated?: boolean;
+    nullable?: boolean;
+    default?: any;
+    length?: number;
+    createDate?: boolean;
+    updateDate?: boolean;
+    relation?: RelationOptions;
+    validation?: () => FieldValidator;
+}
+export declare function Field(optionsOrValidation?: FieldOptions | (() => FieldValidator)): (target: any, contextOrKey: any) => void;
+export declare function PrimaryColumn(options?: FieldOptions): (target: any, contextOrKey: any) => void;
+export declare function Relation(options: RelationOptions): (target: any, contextOrKey: any) => void;
+export declare function CreateDateColumn(): (target: any, contextOrKey: any) => void;
+export declare function UpdateDateColumn(): (target: any, contextOrKey: any) => void;
+export declare const BeforeInsert: () => (target: any, propertyKey: string, descriptor?: PropertyDescriptor) => void;
+export declare const AfterInsert: () => (target: any, propertyKey: string, descriptor?: PropertyDescriptor) => void;
+export declare const BeforeUpdate: () => (target: any, propertyKey: string, descriptor?: PropertyDescriptor) => void;
+export declare const AfterUpdate: () => (target: any, propertyKey: string, descriptor?: PropertyDescriptor) => void;

package/lib/cjs/orm/decorators/index.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AfterUpdate = exports.BeforeUpdate = exports.AfterInsert = exports.BeforeInsert = void 0;
+exports.Entity = Entity;
+exports.Field = Field;
+exports.PrimaryColumn = PrimaryColumn;
+exports.Relation = Relation;
+exports.CreateDateColumn = CreateDateColumn;
+exports.UpdateDateColumn = UpdateDateColumn;
+const metadata_js_1 = require("../metadata.js");
+function Entity(tableName, optionsOrDescription) {
+    return (target, context) => {
+        const description = typeof optionsOrDescription === 'string'
+            ? optionsOrDescription
+            : optionsOrDescription?.description;
+        // Standard Class Decorator
+        if (context && typeof context === 'object' && context.kind === "class") {
+            metadata_js_1.MetadataStore.registerEntity(target, {
+                name: target.name,
+                tableName,
+                target,
+                description,
+            });
+            return;
+        }
+        // Legacy Class Decorator
+        metadata_js_1.MetadataStore.registerEntity(target, {
+            name: target.name,
+            tableName,
+            target,
+            description,
+        });
+        Reflect.defineMetadata(metadata_js_1.ENTITY_METADATA_KEY, tableName, target);
+    };
+}
+function Field(optionsOrValidation) {
+    return (target, contextOrKey) => {
+        let options = {};
+        if (typeof optionsOrValidation === "function") {
+            options = { validation: optionsOrValidation };
+        }
+        else if (optionsOrValidation) {
+            options = optionsOrValidation;
+        }
+        // Legacy Property Decorator
+        if (typeof contextOrKey === "string") {
+            const propertyKey = contextOrKey;
+            const constructor = target.constructor;
+            let type = options.type;
+            let defaultValue = options.default;
+            if (options.validation) {
+                const validator = options.validation();
+                if (!type)
+                    type = validator.type;
+                if (defaultValue === undefined)
+                    defaultValue = validator.defaultValue;
+            }
+            if (!type) {
+                const reflectedType = Reflect.getMetadata("design:type", target, propertyKey);
+                if (reflectedType === String)
+                    type = "string";
+                else if (reflectedType === Number)
+                    type = "number";
+                else if (reflectedType === Boolean)
+                    type = "boolean";
+                else if (reflectedType === Date)
+                    type = "date";
+                else
+                    type = "string";
+            }
+            metadata_js_1.MetadataStore.registerField(constructor, {
+                name: propertyKey,
+                propertyKey,
+                type,
+                ...options,
+                default: defaultValue
+            });
+            return;
+        }
+        // Standard Property Decorator (Stage 3)
+        if (contextOrKey && typeof contextOrKey === 'object' && contextOrKey.kind === "field") {
+            const propertyKey = contextOrKey.name;
+            contextOrKey.addInitializer(function () {
+                const constructor = this.constructor;
+                let type = options.type;
+                let defaultValue = options.default;
+                if (options.validation) {
+                    const validator = options.validation();
+                    if (!type)
+                        type = validator.type;
+                    if (defaultValue === undefined)
+                        defaultValue = validator.defaultValue;
+                }
+                metadata_js_1.MetadataStore.registerField(constructor, {
+                    name: propertyKey,
+                    propertyKey,
+                    type: type || "string",
+                    ...options,
+                    default: defaultValue
+                });
+            });
+        }
+    };
+}
+function PrimaryColumn(options = {}) {
+    return Field({ ...options, primary: true, generated: options.generated ?? true });
+}
+function Relation(options) {
+    return Field({ type: "relation", relation: options });
+}
+function CreateDateColumn() {
+    return Field({ type: "date", createDate: true });
+}
+function UpdateDateColumn() {
+    return Field({ type: "date", updateDate: true });
+}
+// Lifecycle Hooks
+function Hook(type) {
+    return (target, propertyKey, descriptor) => {
+        const constructor = typeof target === 'function' ? target : target.constructor;
+        metadata_js_1.MetadataStore.registerHook(constructor, { type, propertyKey });
+    };
+}
+const BeforeInsert = () => Hook("before-insert");
+exports.BeforeInsert = BeforeInsert;
+const AfterInsert = () => Hook("after-insert");
+exports.AfterInsert = AfterInsert;
+const BeforeUpdate = () => Hook("before-update");
+exports.BeforeUpdate = BeforeUpdate;
+const AfterUpdate = () => Hook("after-update");
+exports.AfterUpdate = AfterUpdate;

package/lib/cjs/orm/driver/mysql.d.ts

@@ -0,0 +1,14 @@
+import { DatabaseDriver, ConnectionOptions } from "../opposer.js";
+import { EntityMetadata, FieldMetadata } from "../metadata.js";
+export declare class MySQLDriver implements DatabaseDriver {
+    private options;
+    private connection;
+    constructor(options: ConnectionOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    query<T = any>(sql: string, params?: any[]): Promise<T[]>;
+    quoteIdentifier(identifier: string): string;
+    createTable(entity: EntityMetadata, fields: FieldMetadata[]): Promise<void>;
+    private getSqlType;
+    private formatDefault;
+}

package/lib/cjs/orm/driver/mysql.js

@@ -0,0 +1,103 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySQLDriver = void 0;
+class MySQLDriver {
+    constructor(options) {
+        this.options = options;
+    }
+    async connect() {
+        const mysql = (await Promise.resolve(`${"mysql2/promise"}`).then(s => __importStar(require(s)))).default;
+        this.connection = await mysql.createConnection({
+            host: this.options.host,
+            port: this.options.port,
+            user: this.options.username,
+            password: this.options.password,
+            database: this.options.database,
+        });
+    }
+    async disconnect() {
+        await this.connection.end();
+    }
+    async query(sql, params) {
+        if (this.options.logging) {
+            console.log(`[SQL] ${sql}${params && params.length ? ` -- params: ${JSON.stringify(params)}` : ""}`);
+        }
+        const adjustedSql = sql.replace(/\$(\d+)/g, "?");
+        const [rows] = await this.connection.execute(adjustedSql, params);
+        return rows;
+    }
+    quoteIdentifier(identifier) {
+        return `\`${identifier.replace(/`/g, "``")}\``;
+    }
+    async createTable(entity, fields) {
+        const columnsSql = fields
+            .map((field) => {
+            let sqlType = this.getSqlType(field);
+            let constraints = "";
+            if (field.primary)
+                constraints += " PRIMARY KEY";
+            if (field.generated && field.type === "number")
+                sqlType += " AUTO_INCREMENT";
+            if (!field.nullable && !field.primary)
+                constraints += " NOT NULL";
+            if (field.default !== undefined)
+                constraints += ` DEFAULT ${this.formatDefault(field.default)}`;
+            return `${this.quoteIdentifier(field.name)} ${sqlType}${constraints}`;
+        })
+            .join(", ");
+        const sql = `CREATE TABLE IF NOT EXISTS ${this.quoteIdentifier(entity.tableName)} (${columnsSql});`;
+        await this.query(sql);
+    }
+    getSqlType(field) {
+        switch (field.type) {
+            case "string": return field.length ? `VARCHAR(${field.length})` : "TEXT";
+            case "number": return "INT";
+            case "boolean": return "BOOLEAN";
+            case "date": return "DATETIME";
+            case "jsonb": return "JSON";
+            case "uuid": return "VARCHAR(36)";
+            default: return "TEXT";
+        }
+    }
+    formatDefault(value) {
+        if (typeof value === "string")
+            return `'${value.replace(/'/g, "''")}'`;
+        if (value instanceof Date)
+            return `'${value.toISOString()}'`;
+        return String(value);
+    }
+}
+exports.MySQLDriver = MySQLDriver;

package/lib/cjs/orm/driver/postgres.d.ts

@@ -0,0 +1,14 @@
+import { DatabaseDriver, ConnectionOptions } from "../opposer.js";
+import { EntityMetadata, FieldMetadata } from "../metadata.js";
+export declare class PostgresDriver implements DatabaseDriver {
+    private options;
+    private pool;
+    constructor(options: ConnectionOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    query<T = any>(sql: string, params?: any[]): Promise<T[]>;
+    quoteIdentifier(identifier: string): string;
+    createTable(entity: EntityMetadata, fields: FieldMetadata[]): Promise<void>;
+    private getSqlType;
+    private formatDefault;
+}