@ug.software/opposer 3.0.10 → 3.0.11

package/lib/cjs/orm/metadata.js

@@ -1,47 +0,0 @@
-"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

@@ -1,30 +0,0 @@
-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

@@ -1,33 +0,0 @@
-"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

@@ -1,32 +0,0 @@
-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;
-}

package/lib/cjs/orm/query-builder.js

@@ -1,278 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryTranslator = void 0;
-const metadata_js_1 = require("./metadata.js");
-class QueryTranslator {
-    constructor(entity, fields, driver) {
-        this.entity = entity;
-        this.fields = fields;
-        this.driver = driver;
-    }
-    validateField(field) {
-        if (field.includes('.')) {
-            const [relationName, ...rest] = field.split('.');
-            const relationField = this.fields.find((f) => f.name === relationName && f.type === 'relation');
-            if (relationField && relationField.relation) {
-                const targetEntity = relationField.relation.target();
-                const targetFields = metadata_js_1.MetadataStore.getFields(targetEntity);
-                const subField = rest.join('.');
-                return this.validateTargetField(targetFields, subField);
-            }
-            return false;
-        }
-        return (this.fields.some((f) => {
-            return f.name === field;
-        }) ||
-            field === 'id' ||
-            field === '*');
-    }
-    validateTargetField(fields, field) {
-        if (field.includes('.')) {
-            const [relationName, ...rest] = field.split('.');
-            const relationField = fields.find((f) => f.name === relationName && f.type === 'relation');
-            if (relationField && relationField.relation) {
-                const targetEntity = relationField.relation.target();
-                const targetFields = metadata_js_1.MetadataStore.getFields(targetEntity);
-                return this.validateTargetField(targetFields, rest.join('.'));
-            }
-            return false;
-        }
-        return fields.some((f) => f.name === field) || field === 'id' || field === '*';
-    }
-    renderFilter(query, params, joins, prefix = '') {
-        if (!query || typeof query !== 'object') {
-            return '';
-        }
-        const parts = [];
-        for (const [key, value] of Object.entries(query)) {
-            if (key === '$or' && Array.isArray(value)) {
-                const orParts = value
-                    .map((v) => {
-                    return this.renderFilter(v, params, joins, prefix);
-                })
-                    .filter((v) => {
-                    return v !== '';
-                })
-                    .map((v) => {
-                    return `(${v})`;
-                });
-                if (orParts.length > 0) {
-                    parts.push(`(${orParts.join(' OR ')})`);
-                }
-                continue;
-            }
-            const fullPath = prefix ? `${prefix}.${key}` : key;
-            if (!this.validateField(fullPath)) {
-                continue;
-            }
-            // If it's a nested object that is NOT an operator ($l, $eq, etc) and NOT a Date,
-            // and it corresponds to a relation, we treat it as a nested filter.
-            const isOperator = typeof key === 'string' && key.startsWith('$');
-            const isNestedFilter = typeof value === 'object' &&
-                value !== null &&
-                !(value instanceof Date) &&
-                !Object.keys(value).some(k => k.startsWith('$'));
-            if (isNestedFilter) {
-                // It's a nested filter (e.g., { author: { name: "..." } })
-                joins.add(key); // Ensure the join is added for this level
-                const nestedFilter = this.renderFilter(value, params, joins, fullPath);
-                if (nestedFilter) {
-                    parts.push(nestedFilter);
-                }
-                continue;
-            }
-            if (fullPath.includes('.')) {
-                const [relationName] = fullPath.split('.');
-                joins.add(relationName);
-            }
-            if (typeof value === 'object' && value !== null && !(value instanceof Date)) {
-                for (const [op, val] of Object.entries(value)) {
-                    const operatorSql = this.renderOperator(fullPath, op, val, params);
-                    if (operatorSql) {
-                        parts.push(operatorSql);
-                    }
-                }
-            }
-            else {
-                params.push(value);
-                parts.push(`${this.quoteField(fullPath)} = $${params.length}`);
-            }
-        }
-        return parts.join(' AND ');
-    }
-    translateFilter(query) {
-        const params = [];
-        const joins = new Set();
-        const sql = this.renderFilter(query, params, joins);
-        return { sql: sql ? `WHERE ${sql}` : '', params, joins };
-    }
-    quoteField(field) {
-        if (field.includes('.')) {
-            return field
-                .split('.')
-                .map((p) => this.driver.quoteIdentifier(p))
-                .join('.');
-        }
-        return `${this.driver.quoteIdentifier(this.entity.tableName)}.${this.driver.quoteIdentifier(field)}`;
-    }
-    renderOperator(column, op, val, params) {
-        const quotedColumn = this.quoteField(column);
-        switch (op) {
-            case '$l':
-                params.push(val);
-                return `${quotedColumn} LIKE $${params.length}`;
-            case '$il':
-                params.push(val);
-                return `${quotedColumn} ILIKE $${params.length}`;
-            case '$in':
-            case '$nin': {
-                if (!Array.isArray(val) || val.length === 0) {
-                    return '';
-                }
-                const placeholders = val
-                    .map((v) => {
-                    params.push(v);
-                    return `$${params.length}`;
-                })
-                    .join(', ');
-                const operator = op === '$in' ? 'IN' : 'NOT IN';
-                return `${quotedColumn} ${operator} (${placeholders})`;
-            }
-            case '$btw':
-                if (!Array.isArray(val) || val.length < 2) {
-                    return '';
-                }
-                params.push(val[0]);
-                params.push(val[1]);
-                return `${quotedColumn} BETWEEN $${params.length - 1} AND $${params.length}`;
-            case '$mt':
-                params.push(val);
-                return `${quotedColumn} > $${params.length}`;
-            case '$mte':
-                params.push(val);
-                return `${quotedColumn} >= $${params.length}`;
-            case '$lt':
-                params.push(val);
-                return `${quotedColumn} < $${params.length}`;
-            case '$lte':
-                params.push(val);
-                return `${quotedColumn} <= $${params.length}`;
-            case '$eq':
-                params.push(val);
-                return `${quotedColumn} = $${params.length}`;
-            default:
-                return '';
-        }
-    }
-    translateSelect(select) {
-        const table = this.driver.quoteIdentifier(this.entity.tableName);
-        if (!select || select.length === 0) {
-            return `${table}.*`;
-        }
-        return select
-            .filter((s) => {
-            return this.validateField(s);
-        })
-            .map((s) => {
-            return this.quoteField(s);
-        })
-            .join(', ');
-    }
-    translateRelations(relations) {
-        const select = [];
-        const joins = [];
-        for (const rel of relations) {
-            const relationName = typeof rel === 'string' ? rel : rel.model;
-            const relationField = this.fields.find((f) => f.name === relationName && f.type === 'relation');
-            if (!relationField) {
-                throw new Error(`Relation '${relationName}' not found on model '${this.entity.name}'`);
-            }
-            if (relationField.relation) {
-                const targetEntity = relationField.relation.target();
-                const targetMetadata = metadata_js_1.MetadataStore.getEntity(targetEntity);
-                const targetFields = metadata_js_1.MetadataStore.getFields(targetEntity);
-                if (targetMetadata) {
-                    const targetTable = this.driver.quoteIdentifier(targetMetadata.tableName);
-                    const relationAlias = this.driver.quoteIdentifier(relationName);
-                    const sourceTable = this.driver.quoteIdentifier(this.entity.tableName);
-                    // Determine join columns
-                    const targetPrimary = targetFields.find(f => f.primary);
-                    const targetPrimaryKeyName = targetPrimary ? targetPrimary.name : 'id';
-                    let joinCondition = '';
-                    if (relationField.relation.type === 'many-to-one' || (relationField.relation.type === 'one-to-one' && relationField.relation.joinColumn)) {
-                        joinCondition = `${sourceTable}.${this.driver.quoteIdentifier(relationName)} = ${relationAlias}.${this.driver.quoteIdentifier(targetPrimaryKeyName)}`;
-                    }
-                    else if (relationField.relation.type === 'one-to-many' || (relationField.relation.type === 'one-to-one' && !relationField.relation.joinColumn)) {
-                        const inverseSide = relationField.relation.inverseSide;
-                        if (inverseSide) {
-                            joinCondition = `${relationAlias}.${this.driver.quoteIdentifier(inverseSide)} = ${sourceTable}.id`;
-                        }
-                    }
-                    if (joinCondition) {
-                        joins.push(`LEFT JOIN ${targetTable} AS ${relationAlias} ON ${joinCondition}`);
-                        const selectedFields = typeof rel === 'object' && rel.select ? rel.select : ['*'];
-                        const targetPrimaryFields = targetFields.filter(f => f.primary);
-                        // Always ensure primary keys are included for hydration
-                        for (const pf of targetPrimaryFields) {
-                            if (!selectedFields.includes(pf.name) && !selectedFields.includes('*')) {
-                                select.push(`${relationAlias}.${this.driver.quoteIdentifier(pf.name)} AS ${this.driver.quoteIdentifier(`${relationName}.${pf.name}`)}`);
-                            }
-                        }
-                        for (const f of selectedFields) {
-                            if (typeof f === 'string') {
-                                if (f === '*') {
-                                    for (const tf of targetFields) {
-                                        if (tf.type !== 'relation') {
-                                            select.push(`${relationAlias}.${this.driver.quoteIdentifier(tf.name)} AS ${this.driver.quoteIdentifier(`${relationName}.${tf.name}`)}`);
-                                        }
-                                    }
-                                    // Also include 'id' if not in targetFields
-                                    if (!targetFields.some(tf => tf.name === 'id')) {
-                                        select.push(`${relationAlias}.id AS ${this.driver.quoteIdentifier(`${relationName}.id`)}`);
-                                    }
-                                }
-                                else {
-                                    select.push(`${relationAlias}.${this.driver.quoteIdentifier(f)} AS ${this.driver.quoteIdentifier(`${relationName}.${f}`)}`);
-                                }
-                            }
-                            // TODO: nested relations
-                        }
-                    }
-                }
-            }
-        }
-        return { select, joins };
-    }
-    translateAggregate(aggregates) {
-        return Object.entries(aggregates)
-            .map(([field, op]) => {
-            const quotedField = field === '*' ? '*' : this.quoteField(field);
-            const alias = this.driver.quoteIdentifier(`${op}_${field.replace('*', 'all').replace('.', '_')}`);
-            return `${op.toUpperCase()}(${quotedField}) as ${alias}`;
-        })
-            .join(', ');
-    }
-    translateGroup(fields) {
-        if (!fields || fields.length === 0) {
-            return '';
-        }
-        const quotedFields = fields
-            .filter((f) => {
-            return this.validateField(f);
-        })
-            .map((f) => {
-            return this.quoteField(f);
-        })
-            .join(', ');
-        return quotedFields ? `GROUP BY ${quotedFields}` : '';
-    }
-    translatePagination(pagination) {
-        if (!pagination) {
-            return '';
-        }
-        const limit = Math.max(0, pagination.take || 10);
-        const offset = Math.max(0, pagination.page || 0) * limit;
-        return `LIMIT ${limit} OFFSET ${offset}`;
-    }
-}
-exports.QueryTranslator = QueryTranslator;

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

@@ -1,54 +0,0 @@
-import { OpposerDatabase } from './opposer.js';
-import { EntityMetadata, FieldMetadata } from './metadata.js';
-import { QueryBuilder as OpposerQueryBuilder, RelationBuilder } from '../interfaces/controller.js';
-export declare class Repository<T> {
-    private connection;
-    private target;
-    private metadata;
-    private fields;
-    private translator;
-    constructor(connection: OpposerDatabase, target: Function);
-    get Metadata(): EntityMetadata;
-    get Fields(): FieldMetadata[];
-    find(options: {
-        where?: OpposerQueryBuilder;
-        select?: string[];
-        pagination?: {
-            page: number;
-            take: number;
-        };
-        relation?: (string | RelationBuilder)[];
-    }): Promise<T[]>;
-    findOne(options: {
-        where?: OpposerQueryBuilder;
-        select?: string[];
-        relation?: (string | RelationBuilder)[];
-    }): Promise<T | null>;
-    private reconstruct;
-    private merge;
-    private executeHooks;
-    insert(data: Partial<T>): Promise<T>;
-    update(where: OpposerQueryBuilder, data: Partial<T>): Promise<void>;
-    delete(where: OpposerQueryBuilder): Promise<void>;
-    count(where: OpposerQueryBuilder): Promise<number>;
-    exists(where: OpposerQueryBuilder): Promise<boolean>;
-    aggregate(options: {
-        where?: OpposerQueryBuilder;
-        aggregate: {
-            [key: string]: 'sum' | 'avg' | 'min' | 'max' | 'count';
-        };
-    }): Promise<any>;
-    distinct(options: {
-        where?: OpposerQueryBuilder;
-        field: string;
-    }): Promise<any[]>;
-    group(options: {
-        where?: OpposerQueryBuilder;
-        by: string[];
-        aggregate?: {
-            [key: string]: 'sum' | 'avg' | 'min' | 'max' | 'count';
-        };
-        select?: string[];
-    }): Promise<any[]>;
-    validate(data: Partial<T>): Record<string, string[]>;
-}