@mostajs/orm 1.0.0

package/dist/dialects/mysql.dialect.js

@@ -0,0 +1,101 @@
+// MySQL Dialect — extends AbstractSqlDialect
+// Equivalent to org.hibernate.dialect.MySQLDialect (Hibernate ORM 6.4)
+// Driver: npm install mysql2
+// Author: Dr Hamid MADANI drmdh@msn.com
+import { AbstractSqlDialect } from './abstract-sql.dialect.js';
+// ============================================================
+// Type Mapping — DAL FieldType → MySQL column type
+// ============================================================
+const MYSQL_TYPE_MAP = {
+    string: 'TEXT',
+    number: 'DOUBLE',
+    boolean: 'TINYINT(1)',
+    date: 'DATETIME',
+    json: 'JSON',
+    array: 'JSON',
+};
+// ============================================================
+// MySQLDialect
+// ============================================================
+export class MySQLDialect extends AbstractSqlDialect {
+    dialectType = 'mysql';
+    pool = null;
+    // --- Abstract implementations ---
+    quoteIdentifier(name) {
+        return `\`${name}\``;
+    }
+    getPlaceholder(_index) {
+        return '?';
+    }
+    fieldToSqlType(field) {
+        return MYSQL_TYPE_MAP[field.type] || 'TEXT';
+    }
+    getIdColumnType() {
+        return 'VARCHAR(36)';
+    }
+    getTableListQuery() {
+        return "SELECT table_name as name FROM information_schema.tables WHERE table_schema = DATABASE()";
+    }
+    // --- Hooks ---
+    supportsIfNotExists() { return true; }
+    supportsReturning() { return false; }
+    // MySQL uses TINYINT(1) for boolean: 1 = true, 0 = false
+    serializeBoolean(v) { return v ? 1 : 0; }
+    deserializeBoolean(v) {
+        return v === 1 || v === true || v === '1';
+    }
+    // --- Connection ---
+    async doConnect(config) {
+        try {
+            const mysql2 = await import(/* webpackIgnore: true */ 'mysql2/promise');
+            const createPool = mysql2.default?.createPool || mysql2.createPool;
+            this.pool = createPool({
+                uri: config.uri,
+                connectionLimit: config.poolSize ?? 10,
+                waitForConnections: true,
+            });
+        }
+        catch (e) {
+            throw new Error(`MySQL driver not found. Install it: npm install mysql2\n` +
+                `Original error: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    async doDisconnect() {
+        if (this.pool) {
+            await this.pool.end();
+            this.pool = null;
+        }
+    }
+    async doTestConnection() {
+        if (!this.pool)
+            return false;
+        const conn = await this.pool.getConnection();
+        try {
+            await conn.query('SELECT 1');
+            return true;
+        }
+        finally {
+            conn.release();
+        }
+    }
+    // --- Query execution ---
+    async executeQuery(sql, params) {
+        if (!this.pool)
+            throw new Error('MySQL not connected. Call connect() first.');
+        const [rows] = await this.pool.execute(sql, params);
+        return rows;
+    }
+    async executeRun(sql, params) {
+        if (!this.pool)
+            throw new Error('MySQL not connected. Call connect() first.');
+        const [result] = await this.pool.execute(sql, params);
+        return { changes: result.affectedRows ?? 0 };
+    }
+    getDialectLabel() { return 'MySQL'; }
+}
+// ============================================================
+// Factory export
+// ============================================================
+export function createDialect() {
+    return new MySQLDialect();
+}

package/dist/dialects/oracle.dialect.d.ts

@@ -0,0 +1,2 @@
+import type { IDialect } from '../core/types.js';
+export declare function createDialect(): IDialect;

package/dist/dialects/oracle.dialect.js

@@ -0,0 +1,206 @@
+// Oracle Database Dialect — extends AbstractSqlDialect
+// Equivalent to org.hibernate.dialect.OracleDialect (Hibernate ORM 6.4)
+// Driver: npm install oracledb
+// Author: Dr Hamid MADANI drmdh@msn.com
+import { AbstractSqlDialect } from './abstract-sql.dialect.js';
+// ============================================================
+// Type Mapping — DAL FieldType → Oracle column type
+// ============================================================
+const ORACLE_TYPE_MAP = {
+    string: 'VARCHAR2(4000)',
+    number: 'NUMBER',
+    boolean: 'NUMBER(1)',
+    date: 'TIMESTAMP',
+    json: 'CLOB',
+    array: 'CLOB',
+};
+// ============================================================
+// OracleDialect
+// ============================================================
+class OracleDialect extends AbstractSqlDialect {
+    dialectType = 'oracle';
+    pool = null;
+    oracledb = null;
+    // --- Abstract implementations ---
+    quoteIdentifier(name) {
+        return `"${name}"`;
+    }
+    // Oracle uses :1, :2, ... bind variables
+    getPlaceholder(index) {
+        return `:${index}`;
+    }
+    fieldToSqlType(field) {
+        return ORACLE_TYPE_MAP[field.type] || 'VARCHAR2(4000)';
+    }
+    getIdColumnType() {
+        return 'VARCHAR2(36)';
+    }
+    getTableListQuery() {
+        return "SELECT table_name as name FROM user_tables";
+    }
+    // --- Hooks ---
+    // Oracle prior to 23c doesn't support IF NOT EXISTS
+    supportsIfNotExists() { return false; }
+    supportsReturning() { return false; }
+    // Oracle NUMBER(1): 1 = true, 0 = false
+    serializeBoolean(v) { return v ? 1 : 0; }
+    deserializeBoolean(v) {
+        return v === 1 || v === true || v === '1';
+    }
+    /** Oracle LIKE is case-sensitive — use UPPER() for case-insensitive search */
+    buildRegexCondition(col, flags) {
+        if (flags?.includes('i')) {
+            return `UPPER(${col}) LIKE UPPER(${this.nextPlaceholder()})`;
+        }
+        return `${col} LIKE ${this.nextPlaceholder()}`;
+    }
+    // Oracle uses OFFSET n ROWS FETCH FIRST m ROWS ONLY (12c+)
+    buildLimitOffset(options) {
+        if (!options?.limit && !options?.skip)
+            return '';
+        const offset = options.skip ?? 0;
+        const limit = options.limit;
+        let sql = ` OFFSET ${offset} ROWS`;
+        if (limit)
+            sql += ` FETCH FIRST ${limit} ROWS ONLY`;
+        return sql;
+    }
+    // Oracle: use PL/SQL block to check existence before CREATE TABLE
+    getCreateTablePrefix(tableName) {
+        const q = this.quoteIdentifier(tableName);
+        return `CREATE TABLE ${q}`;
+    }
+    getCreateIndexPrefix(indexName, unique) {
+        const u = unique ? 'UNIQUE ' : '';
+        return `CREATE ${u}INDEX ${this.quoteIdentifier(indexName)}`;
+    }
+    // --- Connection ---
+    async doConnect(config) {
+        try {
+            const oracledb = await import(/* webpackIgnore: true */ 'oracledb');
+            this.oracledb = oracledb.default || oracledb;
+            this.oracledb.outFormat = this.oracledb.OUT_FORMAT_OBJECT;
+            this.oracledb.autoCommit = true;
+            this.pool = await this.oracledb.createPool({
+                connectString: config.uri,
+                poolMax: config.poolSize ?? 10,
+                poolMin: 2,
+            });
+        }
+        catch (e) {
+            throw new Error(`Oracle driver not found. Install it: npm install oracledb\n` +
+                `Original error: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    async doDisconnect() {
+        if (this.pool) {
+            await this.pool.close(0);
+            this.pool = null;
+        }
+    }
+    async doTestConnection() {
+        if (!this.pool)
+            return false;
+        const conn = await this.pool.getConnection();
+        try {
+            await conn.execute('SELECT 1 FROM DUAL');
+            return true;
+        }
+        finally {
+            await conn.close();
+        }
+    }
+    // --- Query execution ---
+    async executeQuery(sql, params) {
+        if (!this.pool)
+            throw new Error('Oracle not connected. Call connect() first.');
+        const conn = await this.pool.getConnection();
+        try {
+            const result = await conn.execute(sql, params);
+            return result.rows ?? [];
+        }
+        finally {
+            await conn.close();
+        }
+    }
+    async executeRun(sql, params) {
+        if (!this.pool)
+            throw new Error('Oracle not connected. Call connect() first.');
+        const conn = await this.pool.getConnection();
+        try {
+            const result = await conn.execute(sql, params);
+            return { changes: result.rowsAffected ?? 0 };
+        }
+        finally {
+            await conn.close();
+        }
+    }
+    // Override initSchema to handle Oracle's lack of IF NOT EXISTS
+    async initSchema(schemas) {
+        this.schemas = schemas;
+        const strategy = this.config?.schemaStrategy ?? 'none';
+        this.log('INIT_SCHEMA', `strategy=${strategy}`, { entities: schemas.map(s => s.name) });
+        if (strategy === 'none')
+            return;
+        if (strategy === 'validate') {
+            for (const schema of schemas) {
+                const exists = await this.tableExists(schema.collection);
+                if (!exists) {
+                    throw new Error(`Schema validation failed: table "${schema.collection}" does not exist ` +
+                        `(entity: ${schema.name}). Set schemaStrategy to "update" or "create".`);
+                }
+            }
+            return;
+        }
+        // For 'update' strategy: create tables only if they don't exist
+        for (const schema of schemas) {
+            const exists = await this.tableExists(schema.collection);
+            if (!exists) {
+                const createSql = this.generateCreateTable(schema);
+                this.log('DDL', schema.collection, createSql);
+                await this.executeRun(createSql, []);
+            }
+            // Indexes: check existence before creating
+            const indexStatements = this.generateIndexes(schema);
+            for (const stmt of indexStatements) {
+                try {
+                    await this.executeRun(stmt, []);
+                }
+                catch {
+                    // Index may already exist — ignore
+                }
+            }
+        }
+        // Junction tables
+        for (const schema of schemas) {
+            for (const [, rel] of Object.entries(schema.relations)) {
+                if (rel.type === 'many-to-many' && rel.through) {
+                    const exists = await this.tableExists(rel.through);
+                    if (exists)
+                        continue;
+                    const targetSchema = schemas.find(s => s.name === rel.target);
+                    if (!targetSchema)
+                        continue;
+                    const sourceKey = `${schema.name.toLowerCase()}Id`;
+                    const targetKey = `${rel.target.toLowerCase()}Id`;
+                    const q = (n) => this.quoteIdentifier(n);
+                    const idType = this.getIdColumnType();
+                    const ddl = `CREATE TABLE ${q(rel.through)} (
+  ${q(sourceKey)} ${idType} NOT NULL,
+  ${q(targetKey)} ${idType} NOT NULL,
+  PRIMARY KEY (${q(sourceKey)}, ${q(targetKey)})
+)`;
+                    this.log('DDL_JUNCTION', rel.through, ddl);
+                    await this.executeRun(ddl, []);
+                }
+            }
+        }
+    }
+    getDialectLabel() { return 'Oracle'; }
+}
+// ============================================================
+// Factory export
+// ============================================================
+export function createDialect() {
+    return new OracleDialect();
+}

package/dist/dialects/postgres.dialect.d.ts

@@ -0,0 +1,26 @@
+import type { IDialect, DialectType, ConnectionConfig, FieldDef } from '../core/types.js';
+import { AbstractSqlDialect } from './abstract-sql.dialect.js';
+export declare class PostgresDialect extends AbstractSqlDialect {
+    readonly dialectType: DialectType;
+    protected pool: unknown;
+    quoteIdentifier(name: string): string;
+    getPlaceholder(index: number): string;
+    fieldToSqlType(field: FieldDef): string;
+    getIdColumnType(): string;
+    getTableListQuery(): string;
+    protected supportsIfNotExists(): boolean;
+    protected supportsReturning(): boolean;
+    protected serializeBoolean(v: boolean): unknown;
+    protected deserializeBoolean(v: unknown): boolean;
+    /** PostgreSQL LIKE is case-sensitive — use ILIKE when flags contain 'i' */
+    protected buildRegexCondition(col: string, flags?: string): string;
+    doConnect(config: ConnectionConfig): Promise<void>;
+    doDisconnect(): Promise<void>;
+    doTestConnection(): Promise<boolean>;
+    executeQuery<T>(sql: string, params: unknown[]): Promise<T[]>;
+    executeRun(sql: string, params: unknown[]): Promise<{
+        changes: number;
+    }>;
+    protected getDialectLabel(): string;
+}
+export declare function createDialect(): IDialect;

package/dist/dialects/postgres.dialect.js

@@ -0,0 +1,105 @@
+// PostgreSQL Dialect — extends AbstractSqlDialect
+// Equivalent to org.hibernate.dialect.PostgreSQLDialect (Hibernate ORM 6.4)
+// Driver: npm install pg
+// Author: Dr Hamid MADANI drmdh@msn.com
+import { AbstractSqlDialect } from './abstract-sql.dialect.js';
+// ============================================================
+// Type Mapping — DAL FieldType → PostgreSQL column type
+// ============================================================
+const PG_TYPE_MAP = {
+    string: 'TEXT',
+    number: 'DOUBLE PRECISION',
+    boolean: 'BOOLEAN',
+    date: 'TIMESTAMPTZ',
+    json: 'JSONB',
+    array: 'JSONB',
+};
+// ============================================================
+// PostgresDialect
+// ============================================================
+export class PostgresDialect extends AbstractSqlDialect {
+    dialectType = 'postgres';
+    pool = null;
+    // --- Abstract implementations ---
+    quoteIdentifier(name) {
+        return `"${name}"`;
+    }
+    getPlaceholder(index) {
+        return `$${index}`;
+    }
+    fieldToSqlType(field) {
+        return PG_TYPE_MAP[field.type] || 'TEXT';
+    }
+    getIdColumnType() {
+        return 'TEXT';
+    }
+    getTableListQuery() {
+        return "SELECT tablename as name FROM pg_tables WHERE schemaname = 'public'";
+    }
+    // --- Hooks ---
+    supportsIfNotExists() { return true; }
+    supportsReturning() { return true; }
+    serializeBoolean(v) { return v; }
+    deserializeBoolean(v) { return v === true || v === 't' || v === 'true'; }
+    /** PostgreSQL LIKE is case-sensitive — use ILIKE when flags contain 'i' */
+    buildRegexCondition(col, flags) {
+        if (flags?.includes('i')) {
+            return `${col} ILIKE ${this.nextPlaceholder()}`;
+        }
+        return `${col} LIKE ${this.nextPlaceholder()}`;
+    }
+    // --- Connection ---
+    async doConnect(config) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const pg = await import(/* webpackIgnore: true */ 'pg');
+            const Pool = pg.default?.Pool || pg.Pool;
+            this.pool = new Pool({
+                connectionString: config.uri,
+                max: config.poolSize ?? 10,
+            });
+        }
+        catch (e) {
+            throw new Error(`PostgreSQL driver not found. Install it: npm install pg\n` +
+                `Original error: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    async doDisconnect() {
+        if (this.pool) {
+            await this.pool.end();
+            this.pool = null;
+        }
+    }
+    async doTestConnection() {
+        if (!this.pool)
+            return false;
+        const client = await this.pool.connect();
+        try {
+            await client.query('SELECT 1');
+            return true;
+        }
+        finally {
+            client.release();
+        }
+    }
+    // --- Query execution ---
+    async executeQuery(sql, params) {
+        if (!this.pool)
+            throw new Error('PostgreSQL not connected. Call connect() first.');
+        const result = await this.pool.query(sql, params);
+        return result.rows;
+    }
+    async executeRun(sql, params) {
+        if (!this.pool)
+            throw new Error('PostgreSQL not connected. Call connect() first.');
+        const result = await this.pool.query(sql, params);
+        return { changes: result.rowCount ?? 0 };
+    }
+    getDialectLabel() { return 'PostgreSQL'; }
+}
+// ============================================================
+// Factory export
+// ============================================================
+export function createDialect() {
+    return new PostgresDialect();
+}

package/dist/dialects/spanner.dialect.d.ts

@@ -0,0 +1,2 @@
+import type { IDialect } from '../core/types.js';
+export declare function createDialect(): IDialect;