@ug.software/opposer 3.0.10

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

@@ -0,0 +1,105 @@
+"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.PostgresDriver = void 0;
+class PostgresDriver {
+    constructor(options) {
+        this.options = options;
+    }
+    async connect() {
+        const pg = (await Promise.resolve().then(() => __importStar(require("pg")))).default;
+        this.pool = new pg.Pool({
+            host: this.options.host,
+            port: this.options.port,
+            user: this.options.username,
+            password: this.options.password,
+            database: this.options.database,
+        });
+        await this.pool.connect();
+    }
+    async disconnect() {
+        await this.pool.end();
+    }
+    async query(sql, params) {
+        if (this.options.logging) {
+            console.log(`[SQL] ${sql}${params && params.length ? ` -- params: ${JSON.stringify(params)}` : ""}`);
+        }
+        const result = await this.pool.query(sql, params);
+        return result.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 === "uuid")
+                constraints += " DEFAULT gen_random_uuid()";
+            else if (field.generated && field.type === "number")
+                sqlType = "SERIAL";
+            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 "TIMESTAMP";
+            case "jsonb": return "JSONB";
+            case "uuid": return "UUID";
+            default: return "TEXT";
+        }
+    }
+    formatDefault(value) {
+        if (typeof value === "string")
+            return `'${value.replace(/'/g, "''")}'`;
+        if (value instanceof Date)
+            return `'${value.toISOString()}'`;
+        return String(value);
+    }
+}
+exports.PostgresDriver = PostgresDriver;

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

@@ -0,0 +1,14 @@
+import { DatabaseDriver, ConnectionOptions } from "../opposer.js";
+import { EntityMetadata, FieldMetadata } from "../metadata.js";
+export declare class SQLiteDriver implements DatabaseDriver {
+    private options;
+    private db;
+    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/sqlite.js

@@ -0,0 +1,143 @@
+"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.SQLiteDriver = void 0;
+class SQLiteDriver {
+    constructor(options) {
+        this.options = options;
+    }
+    async connect() {
+        const sqlite3 = (await Promise.resolve().then(() => __importStar(require("sqlite3")))).default;
+        return new Promise((resolve, reject) => {
+            this.db = new sqlite3.Database(this.options.database, (err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    async disconnect() {
+        return new Promise((resolve, reject) => {
+            this.db.close((err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    async query(sql, params) {
+        if (this.options.logging) {
+            console.log(`[SQL] ${sql}${params && params.length ? ` -- params: ${JSON.stringify(params)}` : ""}`);
+        }
+        return new Promise((resolve, reject) => {
+            const adjustedSql = sql.replace(/\$(\d+)/g, "?");
+            this.db.all(adjustedSql, params, (err, rows) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(rows);
+                }
+            });
+        });
+    }
+    quoteIdentifier(identifier) {
+        return `"${identifier.replace(/"/g, '""')}"`;
+    }
+    async createTable(entity, fields) {
+        const columnsSql = fields
+            .filter((field) => {
+            if (field.type === "relation") {
+                return (field.relation?.type !== "one-to-many" &&
+                    field.relation?.type !== "many-to-many");
+            }
+            return true;
+        })
+            .map((field) => {
+            let sqlType = this.getSqlType(field);
+            let constraints = "";
+            if (field.primary) {
+                constraints += " PRIMARY KEY";
+            }
+            if (field.generated && field.type === "number") {
+                constraints += " AUTOINCREMENT";
+            }
+            if (field.nullable === false && !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 "TEXT";
+            case "number":
+                return "INTEGER";
+            case "boolean":
+                return "INTEGER";
+            case "date":
+                return "DATETIME";
+            case "jsonb":
+                return "TEXT";
+            case "uuid":
+                return "TEXT";
+            default:
+                return "TEXT";
+        }
+    }
+    formatDefault(value) {
+        if (typeof value === "string") {
+            return `'${value.replace(/'/g, "''")}'`;
+        }
+        if (value instanceof Date) {
+            return `'${value.toISOString()}'`;
+        }
+        return String(value);
+    }
+}
+exports.SQLiteDriver = SQLiteDriver;

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

@@ -0,0 +1,8 @@
+export * from "./decorators/index.js";
+export * from "./opposer.js";
+export * from "./repository.js";
+export * from "./metadata.js";
+export * from "./validation.js";
+export { PostgresDriver } from "./driver/postgres.js";
+export { SQLiteDriver } from "./driver/sqlite.js";
+export { MySQLDriver } from "./driver/mysql.js";

package/lib/cjs/orm/index.js

@@ -0,0 +1,28 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySQLDriver = exports.SQLiteDriver = exports.PostgresDriver = void 0;
+__exportStar(require("./decorators/index.js"), exports);
+__exportStar(require("./opposer.js"), exports);
+__exportStar(require("./repository.js"), exports);
+__exportStar(require("./metadata.js"), exports);
+__exportStar(require("./validation.js"), exports);
+var postgres_js_1 = require("./driver/postgres.js");
+Object.defineProperty(exports, "PostgresDriver", { enumerable: true, get: function () { return postgres_js_1.PostgresDriver; } });
+var sqlite_js_1 = require("./driver/sqlite.js");
+Object.defineProperty(exports, "SQLiteDriver", { enumerable: true, get: function () { return sqlite_js_1.SQLiteDriver; } });
+var mysql_js_1 = require("./driver/mysql.js");
+Object.defineProperty(exports, "MySQLDriver", { enumerable: true, get: function () { return mysql_js_1.MySQLDriver; } });

package/lib/cjs/orm/metadata.d.ts

@@ -0,0 +1,47 @@
+import "reflect-metadata";
+export declare const ENTITY_METADATA_KEY: unique symbol;
+export declare const FIELD_METADATA_KEY: unique symbol;
+export declare const HOOK_METADATA_KEY: unique symbol;
+export type FieldType = "string" | "number" | "boolean" | "date" | "jsonb" | "uuid" | "relation";
+export interface EntityMetadata {
+    name: string;
+    tableName: string;
+    target: Function;
+    description?: string;
+}
+export interface FieldMetadata {
+    name: string;
+    propertyKey: string;
+    type: FieldType;
+    primary?: boolean;
+    generated?: boolean;
+    nullable?: boolean;
+    default?: any;
+    length?: number;
+    createDate?: boolean;
+    updateDate?: boolean;
+    relation?: {
+        type: "one-to-one" | "one-to-many" | "many-to-one" | "many-to-many";
+        target: () => Function;
+        inverseSide?: string;
+        joinColumn?: boolean;
+    };
+    validation?: any;
+}
+export interface HookMetadata {
+    type: "before-insert" | "after-insert" | "before-update" | "after-update";
+    propertyKey: string;
+}
+export declare class MetadataStore {
+    private static entities;
+    private static fields;
+    private static hooks;
+    static registerEntity(target: Function, metadata: EntityMetadata): void;
+    static registerField(target: Function, metadata: FieldMetadata): void;
+    static registerHook(target: Function, hook: HookMetadata): void;
+    static getEntity(target: Function): EntityMetadata | undefined;
+    static getFields(target: Function): FieldMetadata[];
+    static getPersistableFields(target: Function): FieldMetadata[];
+    static getHooks(target: Function): HookMetadata[];
+    static getAllEntities(): EntityMetadata[];
+}

package/lib/cjs/orm/metadata.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataStore = exports.HOOK_METADATA_KEY = exports.FIELD_METADATA_KEY = exports.ENTITY_METADATA_KEY = void 0;
+require("reflect-metadata");
+exports.ENTITY_METADATA_KEY = Symbol("orm:entity");
+exports.FIELD_METADATA_KEY = Symbol("orm:field");
+exports.HOOK_METADATA_KEY = Symbol("orm:hook");
+class MetadataStore {
+    static registerEntity(target, metadata) {
+        this.entities.set(target, metadata);
+    }
+    static registerField(target, metadata) {
+        const fields = this.fields.get(target) || [];
+        fields.push(metadata);
+        this.fields.set(target, fields);
+    }
+    static registerHook(target, hook) {
+        const hooks = this.hooks.get(target) || [];
+        hooks.push(hook);
+        this.hooks.set(target, hooks);
+    }
+    static getEntity(target) {
+        return this.entities.get(target);
+    }
+    static getFields(target) {
+        return this.fields.get(target) || [];
+    }
+    static getPersistableFields(target) {
+        const fields = this.getFields(target);
+        return fields.filter((field) => {
+            if (field.type === "relation") {
+                return field.relation?.type !== "one-to-many" && field.relation?.type !== "many-to-many";
+            }
+            return true;
+        });
+    }
+    static getHooks(target) {
+        return this.hooks.get(target) || [];
+    }
+    static getAllEntities() {
+        return Array.from(this.entities.values());
+    }
+}
+exports.MetadataStore = MetadataStore;
+MetadataStore.entities = new Map();
+MetadataStore.fields = new Map();
+MetadataStore.hooks = new Map();

package/lib/cjs/orm/opposer.d.ts

@@ -0,0 +1,30 @@
+import { EntityMetadata, FieldMetadata } from "./metadata.js";
+import { Repository } from "./repository.js";
+export type QueryResultRow = {
+    [key: string]: unknown;
+};
+export interface DatabaseDriver {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    query<T = QueryResultRow>(sql: string, params?: any[]): Promise<T[]>;
+    createTable(entity: EntityMetadata, fields: FieldMetadata[]): Promise<void>;
+    quoteIdentifier(identifier: string): string;
+}
+export interface ConnectionOptions {
+    type: "postgres" | "sqlite" | "mysql";
+    host?: string;
+    port?: number;
+    username?: string;
+    password?: string;
+    database: string;
+    logging?: boolean;
+}
+export declare class OpposerDatabase {
+    private driver;
+    private entities;
+    constructor(driver: DatabaseDriver, entities: Function[]);
+    connect(): Promise<void>;
+    getDriver(): DatabaseDriver;
+    getEntities(): Function[];
+    getRepository<T>(target: new (...args: any[]) => T): Repository<T>;
+}

package/lib/cjs/orm/opposer.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpposerDatabase = void 0;
+const metadata_js_1 = require("./metadata.js");
+const repository_js_1 = require("./repository.js");
+class OpposerDatabase {
+    constructor(driver, entities) {
+        this.driver = driver;
+        this.entities = entities;
+    }
+    async connect() {
+        await this.driver.connect();
+        // After connecting, ensure tables exist (simplified sync for now)
+        for (const entity of this.entities) {
+            const metadata = metadata_js_1.MetadataStore.getEntity(entity);
+            const fields = metadata_js_1.MetadataStore.getPersistableFields(entity);
+            if (metadata) {
+                console.log(`-> Creating table "${metadata.tableName}" with fields: ${fields.map(f => f.name).join(", ")}`);
+                await this.driver.createTable(metadata, fields);
+            }
+        }
+    }
+    getDriver() {
+        return this.driver;
+    }
+    getEntities() {
+        return this.entities;
+    }
+    getRepository(target) {
+        return new repository_js_1.Repository(this, target);
+    }
+}
+exports.OpposerDatabase = OpposerDatabase;

package/lib/cjs/orm/query-builder.d.ts

@@ -0,0 +1,32 @@
+import { QueryBuilder as OpposerQueryBuilder, RelationBuilder } from '../interfaces/controller.js';
+import { EntityMetadata, FieldMetadata } from './metadata.js';
+import { DatabaseDriver } from './opposer.js';
+export declare class QueryTranslator {
+    private entity;
+    private fields;
+    private driver;
+    constructor(entity: EntityMetadata, fields: FieldMetadata[], driver: DatabaseDriver);
+    private validateField;
+    private validateTargetField;
+    private renderFilter;
+    translateFilter(query: OpposerQueryBuilder): {
+        sql: string;
+        params: any[];
+        joins: Set<string>;
+    };
+    private quoteField;
+    private renderOperator;
+    translateSelect(select: string[]): string;
+    translateRelations(relations: (string | RelationBuilder)[]): {
+        select: string[];
+        joins: string[];
+    };
+    translateAggregate(aggregates: {
+        [key: string]: 'sum' | 'avg' | 'min' | 'max' | 'count';
+    }): string;
+    translateGroup(fields: string[]): string;
+    translatePagination(pagination: {
+        page: number;
+        take: number;
+    } | undefined): string;
+}