ilana-orm 1.0.0

package/database/DB.js

@@ -0,0 +1,85 @@
+const Database = require('./connection');
+
+/**
+ * Laravel-style DB facade for IlanaORM
+ */
+class DB {
+  /**
+   * Execute a database transaction with automatic retry for deadlocks
+   * @param {Function} callback - Transaction callback function
+   * @param {number} attempts - Number of retry attempts (default: 1)
+   * @param {string} connection - Connection name (optional)
+   * @returns {Promise<any>}
+   */
+  static async transaction(callback, attempts = 1, connection = null) {
+    return Database.transaction(callback, attempts, connection);
+  }
+
+  /**
+   * Begin a database transaction manually
+   * @param {string} connection - Connection name (optional)
+   * @returns {Promise<Transaction>}
+   */
+  static async beginTransaction(connection = null) {
+    return Database.beginTransaction(connection);
+  }
+
+  /**
+   * Commit a transaction
+   * @param {Transaction} trx - Transaction object
+   * @returns {Promise<void>}
+   */
+  static async commit(trx) {
+    return Database.commit(trx);
+  }
+
+  /**
+   * Rollback a transaction
+   * @param {Transaction} trx - Transaction object
+   * @returns {Promise<void>}
+   */
+  static async rollback(trx) {
+    return Database.rollback(trx);
+  }
+
+  /**
+   * Get a query builder for a table
+   * @param {string} table - Table name
+   * @param {string} connection - Connection name (optional)
+   * @returns {QueryBuilder}
+   */
+  static table(table, connection = null) {
+    return Database.table(table, connection);
+  }
+
+  /**
+   * Execute a raw SQL query
+   * @param {string} sql - SQL query
+   * @param {Array} bindings - Query bindings
+   * @param {string} connection - Connection name (optional)
+   * @returns {Promise<any>}
+   */
+  static raw(sql, bindings = [], connection = null) {
+    const db = connection ? Database.connection(connection) : Database.getInstance();
+    return db.raw(sql, bindings);
+  }
+
+  /**
+   * Get a database connection
+   * @param {string} name - Connection name (optional)
+   * @returns {Connection}
+   */
+  static connection(name = null) {
+    return Database.connection(name);
+  }
+
+  /**
+   * Get the default connection name
+   * @returns {string}
+   */
+  static getDefaultConnection() {
+    return Database.getDefaultConnection();
+  }
+}
+
+module.exports = DB;

package/database/connection.js

@@ -0,0 +1,114 @@
+const knex = require('knex');
+
+class Database {
+  static connections = new Map();
+  static _currentTransaction = null;
+
+  static configure(config) {
+    this.config = config;
+    this.defaultConnection = config.default;
+    
+    // Initialize all configured connections
+    for (const [name, connConfig] of Object.entries(config.connections)) {
+      const connection = knex({
+        ...connConfig,
+        migrations: config.migrations || {
+          directory: './migrations',
+          tableName: 'migrations'
+        },
+        seeds: config.seeds || {
+          directory: './seeds'
+        }
+      });
+      this.connections.set(name, connection);
+    }
+    
+    // Set default instance after all connections are created
+    if (this.connections.has(this.defaultConnection)) {
+      this.instance = this.connections.get(this.defaultConnection);
+    }
+    
+    if (!this.instance) {
+      throw new Error(`Default connection '${this.defaultConnection}' not found in connections config.`);
+    }
+  }
+
+  static connection(name) {
+    if (!name) return this.getInstance();
+    const conn = this.connections.get(name);
+    if (!conn) {
+      throw new Error(`Database connection '${name}' not configured.`);
+    }
+    return conn;
+  }
+
+  static getDefaultConnection() {
+    return this.defaultConnection;
+  }
+
+  static hasConnection(name) {
+    return this.connections.has(name);
+  }
+
+  static getInstance() {
+    if (!this.instance) {
+      throw new Error('Database not configured. Call Database.configure() first.');
+    }
+    return this.instance;
+  }
+
+  static async transaction(callback, attempts = 1, connection) {
+    const db = this.connection(connection);
+    
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+      try {
+        return await db.transaction(async (trx) => {
+          // Set current transaction for models to use
+          this._currentTransaction = trx;
+          try {
+            const result = await callback(trx);
+            return result;
+          } finally {
+            this._currentTransaction = null;
+          }
+        });
+      } catch (error) {
+        if (attempt === attempts) throw error;
+        // Wait before retry for deadlock scenarios
+        await new Promise(resolve => setTimeout(resolve, 100 * attempt));
+      }
+    }
+  }
+
+  static async beginTransaction(connection) {
+    const db = this.connection(connection);
+    const trx = await db.transaction();
+    return {
+      ...trx,
+      commit: () => trx.commit(),
+      rollback: () => trx.rollback()
+    };
+  }
+
+  static commit(trx) {
+    return trx.commit();
+  }
+
+  static rollback(trx) {
+    return trx.rollback();
+  }
+
+  static getCurrentTransaction() {
+    return this._currentTransaction;
+  }
+
+  static table(tableName, connectionName) {
+    return this.connection(connectionName)(tableName);
+  }
+
+  static raw(sql, bindings) {
+    return this.getInstance().raw(sql, bindings);
+  }
+}
+
+module.exports = Database;

package/database/schema-builder.js

@@ -0,0 +1,219 @@
+const Database = require('./connection');
+
+class SchemaBuilder {
+  constructor(connection) {
+    this.knex = Database.connection(connection);
+    this.currentTable = '';
+  }
+
+  createTable(tableName, callback) {
+    return this.knex.schema.createTable(tableName, callback);
+  }
+
+  dropTable(tableName) {
+    return this.knex.schema.dropTable(tableName);
+  }
+
+  dropTableIfExists(tableName) {
+    return this.knex.schema.dropTableIfExists(tableName);
+  }
+
+  renameTable(from, to) {
+    return this.knex.schema.renameTable(from, to);
+  }
+
+  hasTable(tableName) {
+    return this.knex.schema.hasTable(tableName);
+  }
+
+  hasColumn(tableName, columnName) {
+    return this.knex.schema.hasColumn(tableName, columnName);
+  }
+
+  table(tableName, callback) {
+    return this.knex.schema.table(tableName, callback);
+  }
+
+  alterTable(tableName, callback) {
+    return this.knex.schema.alterTable(tableName, callback);
+  }
+
+  raw(statement) {
+    return this.knex.raw(statement);
+  }
+
+  // PostgreSQL specific
+  createSchema(schemaName) {
+    return this.knex.schema.createSchema(schemaName);
+  }
+
+  dropSchema(schemaName) {
+    return this.knex.schema.dropSchema(schemaName);
+  }
+
+  // Advanced column types
+  jsonb(columnName) {
+    if (this.knex.client.config.client === 'pg') {
+      return this.knex.schema.jsonb ? this.knex.schema.jsonb(columnName) : this.knex.schema.json(columnName);
+    }
+    return this.knex.schema.json(columnName);
+  }
+
+  geometry(columnName, geometryType) {
+    return this.knex.schema.specificType(columnName, geometryType || 'geometry');
+  }
+
+  point(columnName) {
+    return this.knex.schema.specificType(columnName, 'point');
+  }
+
+  lineString(columnName) {
+    return this.knex.schema.specificType(columnName, 'linestring');
+  }
+
+  polygon(columnName) {
+    return this.knex.schema.specificType(columnName, 'polygon');
+  }
+
+  inet(columnName) {
+    return this.knex.schema.specificType(columnName, 'inet');
+  }
+
+  macaddr(columnName) {
+    return this.knex.schema.specificType(columnName, 'macaddr');
+  }
+
+  specificType(columnName, type) {
+    return this.knex.schema.specificType(columnName, type);
+  }
+
+  // Enhanced column modifiers with database-specific implementations
+  after(columnName) {
+    if (this.knex.client.config.client === 'mysql2') {
+      return this.knex.schema.raw(`AFTER ${columnName}`);
+    }
+    return this;
+  }
+
+  first() {
+    if (this.knex.client.config.client === 'mysql2') {
+      return this.knex.schema.raw('FIRST');
+    }
+    return this;
+  }
+
+  checkPositive(column) {
+    const client = this.knex.client.config.client;
+    if (client === 'pg') {
+      return this.knex.raw(`ALTER TABLE ${this.currentTable} ADD CONSTRAINT ${column}_positive CHECK (${column} > 0)`);
+    } else if (client === 'mysql2') {
+      return this.knex.raw(`ALTER TABLE ${this.currentTable} ADD CONSTRAINT ${column}_positive CHECK (${column} > 0)`);
+    }
+    return Promise.resolve();
+  }
+
+  checkRegex(column, pattern) {
+    const client = this.knex.client.config.client;
+    if (client === 'pg') {
+      return this.knex.raw(`ALTER TABLE ${this.currentTable} ADD CONSTRAINT ${column}_regex CHECK (${column} ~ '${pattern}')`);
+    } else if (client === 'mysql2') {
+      return this.knex.raw(`ALTER TABLE ${this.currentTable} ADD CONSTRAINT ${column}_regex CHECK (${column} REGEXP '${pattern}')`);
+    }
+    return Promise.resolve();
+  }
+
+  generatedAs(column, expression) {
+    const client = this.knex.client.config.client;
+    if (client === 'mysql2') {
+      return this.knex.raw(`ALTER TABLE ${this.currentTable} ADD ${column} VARCHAR(255) GENERATED ALWAYS AS (${expression}) STORED`);
+    } else if (client === 'pg') {
+      return this.knex.raw(`ALTER TABLE ${this.currentTable} ADD ${column} TEXT GENERATED ALWAYS AS (${expression}) STORED`);
+    }
+    return Promise.resolve();
+  }
+
+  collate(tableName, collation) {
+    const client = this.knex.client.config.client;
+    if (client === 'mysql2') {
+      return this.knex.raw(`ALTER TABLE ${tableName} COLLATE ${collation}`);
+    } else if (client === 'pg') {
+      return this.knex.raw(`ALTER TABLE ${tableName} ALTER COLUMN name TYPE TEXT COLLATE "${collation}"`);
+    }
+    return Promise.resolve();
+  }
+
+  // Enhanced PostgreSQL types
+  array(columnName, type = 'text') {
+    if (this.knex.client.config.client === 'pg') {
+      return this.knex.schema.specificType(columnName, `${type}[]`);
+    }
+    return this.knex.schema.json(columnName);
+  }
+
+  numrange(columnName) {
+    return this.knex.schema.specificType(columnName, 'numrange');
+  }
+
+  daterange(columnName) {
+    return this.knex.schema.specificType(columnName, 'daterange');
+  }
+
+  tsvector(columnName) {
+    return this.knex.schema.specificType(columnName, 'tsvector');
+  }
+
+  // Enhanced MySQL types
+  fulltext(columns, indexName) {
+    if (this.knex.client.config.client === 'mysql2') {
+      const name = indexName || `${columns.join('_')}_fulltext`;
+      return this.knex.raw(`ALTER TABLE ${this.currentTable} ADD FULLTEXT INDEX ${name} (${columns.join(', ')})`);
+    }
+    return Promise.resolve();
+  }
+
+  spatial(column, indexName) {
+    if (this.knex.client.config.client === 'mysql2') {
+      const name = indexName || `${column}_spatial`;
+      return this.knex.raw(`ALTER TABLE ${this.currentTable} ADD SPATIAL INDEX ${name} (${column})`);
+    }
+    return Promise.resolve();
+  }
+
+  setCurrentTable(tableName) {
+    this.currentTable = tableName;
+    return this;
+  }
+
+  // Enhanced utility methods
+  get client() {
+    return this.knex.client;
+  }
+
+  get fn() {
+    return this.knex.fn;
+  }
+
+  // Database-specific utilities
+  enableExtension(name) {
+    if (this.knex.client.config.client === 'pg') {
+      return this.knex.raw(`CREATE EXTENSION IF NOT EXISTS "${name}"`);
+    }
+    return Promise.resolve();
+  }
+
+  createEnum(name, values) {
+    if (this.knex.client.config.client === 'pg') {
+      return this.knex.raw(`CREATE TYPE ${name} AS ENUM (${values.map(v => `'${v}'`).join(', ')})`);
+    }
+    return Promise.resolve();
+  }
+
+  dropEnum(name) {
+    if (this.knex.client.config.client === 'pg') {
+      return this.knex.raw(`DROP TYPE IF EXISTS ${name}`);
+    }
+    return Promise.resolve();
+  }
+}
+
+module.exports = SchemaBuilder;

package/ilana.config.js

@@ -0,0 +1,61 @@
+const Database = require('ilana/database/connection').default;
+
+const config = {
+  default: 'sqlite',
+  
+  connections: {
+    sqlite: {
+      client: 'sqlite3',
+      connection: {
+        filename: './database.sqlite'
+      }
+    },
+    
+    // mysql: {
+    //   client: 'mysql2',
+    //   connection: {
+    //     host: 'localhost',
+    //     port: 3306,
+    //     user: 'your_username',
+    //     password: 'your_password',
+    //     database: 'your_database'
+    //   }
+    // },
+    
+    // postgres: {
+    //   client: 'pg',
+    //   connection: {
+    //     host: 'localhost',
+    //     port: 5432,
+    //     user: 'your_username',
+    //     password: 'your_password',
+    //     database: 'your_database'
+    //   }
+    // },
+    
+    // mysql_secondary: {
+    //   client: 'mysql2',
+    //   connection: {
+    //     host: 'secondary.mysql.com',
+    //     port: 3306,
+    //     user: 'secondary_user',
+    //     password: 'secondary_password',
+    //     database: 'secondary_db'
+    //   }
+    // }
+  },
+  
+  migrations: {
+    directory: './migrations',
+    tableName: 'migrations'
+  },
+  
+  seeds: {
+    directory: './seeds'
+  }
+};
+
+// Auto-initialize database connections
+Database.configure(config);
+
+module.exports = config;

package/index.js

@@ -0,0 +1,34 @@
+// Main exports
+const Model = require('./orm/Model');
+const QueryBuilder = require('./orm/QueryBuilder');
+const Collection = require('./orm/Collection');
+const Database = require('./database/connection');
+const DB = require('./database/DB');
+const SchemaBuilder = require('./database/schema-builder');
+const MigrationRunner = require('./orm/MigrationRunner');
+const Seeder = require('./orm/Seeder');
+const Factory = require('./orm/Factory');
+const Relation = require('./orm/Relation');
+const CustomCasts = require('./orm/CustomCasts');
+
+module.exports = {
+  Model,
+  QueryBuilder,
+  Collection,
+  Database,
+  DB,
+  SchemaBuilder,
+  MigrationRunner,
+  Seeder,
+  Factory: Factory.Factory,
+  defineFactory: Factory.defineFactory,
+  
+  // Relationships
+  ...Relation,
+  
+  // Custom Casts
+  ...CustomCasts
+};
+
+// Default export
+module.exports.default = module.exports.Model;