ilana-orm 1.0.3 → 1.0.7

package/README.md

@@ -150,10 +150,13 @@ touch ilana.config.js
 
 ### 2. Configure Database
 
-Create `ilana.config.js` in your project root:
+**For CommonJS projects**, create `ilana.config.js` in your project root:
+
+**For ES Module projects** (with `"type": "module"` in package.json), create `ilana.config.mjs`:
 
 ```javascript
-module.exports = {
+// ilana.config.mjs
+export default {
   default: "sqlite",
 
   connections: {
@@ -212,11 +215,18 @@ This creates:
 
 ### 4. Define the Model
 
-**JavaScript:**
+**JavaScript (CommonJS):**
 
 ```javascript
 // models/User.js
 const Model = require("ilana-orm/orm/Model");
+```
+
+**JavaScript (ES Modules):**
+
+```javascript
+// models/User.js
+import Model from "ilana-orm/orm/Model";
 
 class User extends Model {
   static table = "users";
@@ -246,7 +256,8 @@ class User extends Model {
   }
 }
 
-module.exports = User;
+export default User; // For ES modules
+// module.exports = User; // For CommonJS
 ```
 
 **TypeScript (auto-generated when `tsconfig.json` detected):**
@@ -294,8 +305,14 @@ npx ilana migrate
 
 ### 6. Start Using the Model
 
+**CommonJS:**
 ```javascript
 const User = require("./models/User");
+```
+
+**ES Modules:**
+```javascript
+import User from "./models/User.js";
 
 // Create user
 const user = await User.create({

package/cli/ilana.js

@@ -31,26 +31,39 @@ const defaultConfig = {
 
 // Load configuration and auto-initialize
 async function loadConfig() {
-  const configPath = path.join(process.cwd(), 'ilana.config.js');
-  if (fs.existsSync(configPath)) {
-    delete require.cache[configPath];
+  const configPathJs = path.join(process.cwd(), 'ilana.config.js');
+  const configPathMjs = path.join(process.cwd(), 'ilana.config.mjs');
+  
+  // Try .mjs first (ES modules)
+  if (fs.existsSync(configPathMjs)) {
+    try {
+      const configModule = await import(configPathMjs);
+      const config = configModule.default || configModule;
+      return config;
+    } catch (error) {
+      console.error('Error loading ilana.config.mjs:', error.message);
+      process.exit(1);
+    }
+  }
+  
+  // Try .js (CommonJS)
+  if (fs.existsSync(configPathJs)) {
+    delete require.cache[configPathJs];
     try {
-      const config = require(configPath);
-      // Config file already initializes database
+      const config = require(configPathJs);
       return config;
     } catch (error) {
       if (error.code === 'ERR_REQUIRE_ESM') {
-        // Handle ES modules
-        const configModule = await import(configPath);
-        const config = configModule.default || configModule;
-        return config;
+        console.error('Found ilana.config.js but project uses ES modules. Rename to ilana.config.mjs');
+        process.exit(1);
       } else {
         throw error;
       }
     }
   }
-  // No config file found - don't initialize with hardcoded default
-  console.error('No ilana.config.js found. Run "npx ilana setup" first.');
+  
+  // No config file found
+  console.error('No ilana.config.js or ilana.config.mjs found. Run "npx ilana setup" first.');
   process.exit(1);
 }
 
@@ -130,9 +143,11 @@ function generateModel(name, options = {}) {
 }
 
 function getModelTemplate(className, tableName) {
+  const isESModule = isESModuleProject();
+  
   if (isTypeScriptProject()) {
-    return `import Model from 'ilana-orm/orm/Model.js';
-// import { MoneyCast, EncryptedCast } from 'ilana-orm/orm/CustomCasts.js';
+    return `import Model from 'ilana-orm/orm/Model';
+// import { MoneyCast, EncryptedCast } from 'ilana-orm/orm/CustomCasts';
 
 export default class ${className} extends Model {
   protected static table = '${tableName}';
@@ -175,6 +190,53 @@ export default class ${className} extends Model {
 `;
   }
   
+  if (isESModule) {
+    return `import Model from 'ilana-orm/orm/Model';
+// import { MoneyCast, EncryptedCast } from 'ilana-orm/orm/CustomCasts';
+
+class ${className} extends Model {
+  static table = '${tableName}';
+  static timestamps = true;
+  static softDeletes = false;
+  
+  // For UUID primary keys, uncomment:
+  // static keyType = 'string';
+  // static incrementing = false;
+
+  fillable = [];
+  hidden = [];
+  appends = [];
+  casts = {
+    // Basic casts
+    // is_active: 'boolean',
+    // metadata: 'json',
+    // tags: 'array',
+    
+    // Custom casts
+    // price: new MoneyCast(),
+    // secret: new EncryptedCast('your-key'),
+  };
+
+  // Define relationships here
+  // example() {
+  //   return this.hasMany(RelatedModel, 'foreign_key');
+  // }
+
+  // Define scopes here
+  // static scopeActive(query) {
+  //   query.where('is_active', true);
+  // }
+  
+  // Register for polymorphic relationships
+  // static {
+  //   this.register();
+  // }
+}
+
+export default ${className};
+`;
+  }
+  
   return `const Model = require('ilana-orm/orm/Model');
 // const { MoneyCast, EncryptedCast } = require('ilana-orm/orm/CustomCasts');
 
@@ -222,8 +284,10 @@ module.exports = ${className};
 }
 
 function getPivotModelTemplate(className, tableName) {
+  const isESModule = isESModuleProject();
+  
   if (isTypeScriptProject()) {
-    return `import Model from 'ilana-orm/orm/Model.js';
+    return `import Model from 'ilana-orm/orm/Model';
 
 export default class ${className} extends Model {
   protected static table = '${tableName}';
@@ -236,6 +300,22 @@ export default class ${className} extends Model {
 `;
   }
   
+  if (isESModule) {
+    return `import Model from 'ilana-orm/orm/Model';
+
+class ${className} extends Model {
+  static table = '${tableName}';
+  static timestamps = true;
+  
+  fillable = [];
+
+  // Define pivot relationships here
+}
+
+export default ${className};
+`;
+  }
+  
   return `const Model = require('ilana-orm/orm/Model');
 
 class ${className} extends Model {
@@ -350,10 +430,16 @@ const commands = {
     }
 
     // Create config file if it doesn't exist
-    const configPath = 'ilana.config.js';
+    const isESModule = isESModuleProject();
+    const configPath = isESModule ? 'ilana.config.mjs' : 'ilana.config.js';
+    
     if (!fs.existsSync(configPath)) {
-      const isESModule = isESModuleProject();
       const configTemplate = isESModule ? getESModuleConfigTemplate() : getCommonJSConfigTemplate();
+      fs.writeFileSync(configPath, configTemplate);
+      console.log(`Created config file: ${configPath}`);
+    }
+  },
+};
 
 function getESModuleConfigTemplate() {
   return `import 'dotenv/config';
@@ -470,9 +556,6 @@ Database.configure(config);
 module.exports = config;
 `;
 }
-      fs.writeFileSync(configPath, configTemplate);
-      console.log(`Created config file: ${configPath}`);
-    }
 
     // Create .env file if it doesn't exist
     const envPath = '.env';

package/database/connection.d.ts

@@ -0,0 +1,45 @@
+import { Knex } from 'knex';
+
+export interface DatabaseConfig {
+  default: string;
+  connections: {
+    [name: string]: Knex.Config;
+  };
+  migrations?: {
+    directory?: string;
+    tableName?: string;
+  };
+  seeds?: {
+    directory?: string;
+  };
+}
+
+export interface Transaction extends Knex.Transaction {
+  commit(): Promise<void>;
+  rollback(): Promise<void>;
+}
+
+export default class Database {
+  static connections: Map<string, Knex>;
+  static config: DatabaseConfig;
+  static defaultConnection: string;
+  static instance: Knex;
+  private static _currentTransaction: Knex.Transaction | null;
+
+  static configure(config: DatabaseConfig): void;
+  static connection(name?: string): Knex;
+  static getDefaultConnection(): string;
+  static hasConnection(name: string): boolean;
+  static getInstance(): Knex;
+  static transaction<T>(
+    callback: (trx: Knex.Transaction) => Promise<T>,
+    attempts?: number,
+    connection?: string
+  ): Promise<T>;
+  static beginTransaction(connection?: string): Promise<Transaction>;
+  static commit(trx: Knex.Transaction): Promise<void>;
+  static rollback(trx: Knex.Transaction): Promise<void>;
+  static getCurrentTransaction(): Knex.Transaction | null;
+  static table(tableName: string, connectionName?: string): Knex.QueryBuilder;
+  static raw(sql: string, bindings?: any[]): Knex.Raw;
+}

package/database/connection.mjs

@@ -0,0 +1,7 @@
+// connection.mjs - ES Module wrapper
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+
+const Database = require('./connection.js');
+
+export default Database;

package/example.config.mjs

@@ -0,0 +1,44 @@
+// ilana.config.mjs - ES Module config example
+export default {
+  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",
+      },
+    },
+  },
+
+  migrations: {
+    directory: "./migrations",
+    tableName: "migrations",
+  },
+
+  seeds: {
+    directory: "./seeds",
+  },
+};

package/index.d.ts

@@ -0,0 +1,9 @@
+export { default as Model } from './orm/Model';
+export { default as QueryBuilder } from './orm/QueryBuilder';
+export { default as Collection } from './orm/Collection';
+export { default as Database } from './database/connection';
+export * from './orm/Relation';
+export * from './orm/CustomCasts';
+
+// Default export
+export { default } from './orm/Model';

package/index.mjs

@@ -0,0 +1,33 @@
+// index.mjs - ES Module wrapper
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+
+const exports = require('./index.js');
+
+export const {
+  Model,
+  QueryBuilder,
+  Collection,
+  Database,
+  DB,
+  SchemaBuilder,
+  MigrationRunner,
+  Seeder,
+  Factory,
+  defineFactory,
+  Relation,
+  HasOne,
+  HasMany,
+  BelongsTo,
+  BelongsToMany,
+  HasManyThrough,
+  MorphTo,
+  MorphMany,
+  MoneyCast,
+  EncryptedCast,
+  JsonCast,
+  ArrayCast,
+  DateCast
+} = exports;
+
+export default exports.Model;

package/orm/Collection.d.ts

@@ -0,0 +1,53 @@
+export default class Collection<T = any> extends Array<T> {
+  constructor(items?: T[]);
+
+  // Static factory methods
+  static make<T>(items?: T[]): Collection<T>;
+  static times<T>(count: number, callback: (index: number) => T): Collection<T>;
+  static range(start: number, end: number): Collection<number>;
+
+  // Collection methods
+  filter(callback: (item: T, index: number) => boolean): Collection<T>;
+  map<U>(callback: (item: T, index: number) => U): Collection<U>;
+  first(): T | undefined;
+  last(): T | undefined;
+  pluck<K extends keyof T>(key: K): Collection<T[K]>;
+  unique(): Collection<T>;
+  unique<K extends keyof T>(key: K): Collection<T>;
+  groupBy<K extends keyof T>(key: K): { [key: string]: Collection<T> };
+  sortBy<K extends keyof T>(key: K): Collection<T>;
+  sortByDesc<K extends keyof T>(key: K): Collection<T>;
+  where<K extends keyof T>(key: K, value: T[K]): Collection<T>;
+  firstWhere<K extends keyof T>(key: K, value: T[K]): T | undefined;
+  sum(): number;
+  sum<K extends keyof T>(key: K): number;
+  avg(): number;
+  avg<K extends keyof T>(key: K): number;
+  min(): T | undefined;
+  min<K extends keyof T>(key: K): T[K] | undefined;
+  max(): T | undefined;
+  max<K extends keyof T>(key: K): T[K] | undefined;
+  chunk(size: number): Collection<Collection<T>>;
+  toJSON(): any[];
+
+  // Advanced collection methods
+  reject(callback: (item: T, index: number) => boolean): Collection<T>;
+  partition(callback: (item: T, index: number) => boolean): [Collection<T>, Collection<T>];
+  keyBy<K extends keyof T>(key: K): { [key: string]: T };
+  countBy<K extends keyof T>(key: K): { [key: string]: number };
+  flatten(): Collection<any>;
+  take(count: number): Collection<T>;
+  skip(count: number): Collection<T>;
+  random(): T | undefined;
+  random(count: number): Collection<T>;
+  shuffle(): Collection<T>;
+  tap(callback: (collection: this) => void): this;
+  pipe<U>(callback: (collection: this) => U): U;
+  whenEmpty(callback: (collection: this) => void): this;
+  whenNotEmpty(callback: (collection: this) => void): this;
+  unless(condition: boolean, callback: (collection: this) => void): this;
+  when(condition: boolean, callback: (collection: this) => void): this;
+  toArray(): T[];
+  isEmpty(): boolean;
+  isNotEmpty(): boolean;
+}

package/orm/Collection.mjs

@@ -0,0 +1,7 @@
+// Collection.mjs - ES Module wrapper
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+
+const Collection = require('./Collection.js');
+
+export default Collection;

package/orm/CustomCasts.d.ts

@@ -0,0 +1,30 @@
+export interface Cast {
+  get(value: any): any;
+  set(value: any): any;
+}
+
+export class MoneyCast implements Cast {
+  get(value: any): number | null;
+  set(value: any): number | null;
+}
+
+export class EncryptedCast implements Cast {
+  constructor(key?: string);
+  get(value: any): string | null;
+  set(value: any): string | null;
+}
+
+export class JsonCast implements Cast {
+  get(value: any): any;
+  set(value: any): string | null;
+}
+
+export class ArrayCast implements Cast {
+  get(value: any): any[] | null;
+  set(value: any): string | null;
+}
+
+export class DateCast implements Cast {
+  get(value: any): Date | null;
+  set(value: any): string | null;
+}

package/orm/Model.d.ts

@@ -0,0 +1,160 @@
+import QueryBuilder from './QueryBuilder';
+import { HasOne, HasMany, BelongsTo, BelongsToMany, HasManyThrough, MorphTo, MorphMany } from './Relation';
+
+export interface ModelAttributes {
+  [key: string]: any;
+}
+
+export interface ModelCasts {
+  [key: string]: 'string' | 'number' | 'boolean' | 'date' | 'json' | 'array' | 'object' | 'float';
+}
+
+export interface ModelEvents {
+  [event: string]: Array<(model: any) => Promise<boolean | void> | boolean | void>;
+}
+
+export interface Observer {
+  creating?(model: any): Promise<void> | void;
+  created?(model: any): Promise<void> | void;
+  updating?(model: any): Promise<void> | void;
+  updated?(model: any): Promise<void> | void;
+  saving?(model: any): Promise<void> | void;
+  saved?(model: any): Promise<void> | void;
+  deleting?(model: any): Promise<void> | void;
+  deleted?(model: any): Promise<void> | void;
+  restoring?(model: any): Promise<void> | void;
+  restored?(model: any): Promise<void> | void;
+}
+
+export default class Model {
+  // Static properties
+  protected static table: string;
+  protected static connection?: string;
+  protected static primaryKey: string;
+  protected static keyType: 'number' | 'string';
+  protected static incrementing: boolean;
+  protected static timestamps: boolean;
+  protected static softDeletes: boolean;
+  protected static fillable: string[];
+  protected static guarded: string[];
+  protected static casts: ModelCasts;
+  protected static events: ModelEvents;
+  protected static globalScopes: Map<string, (query: QueryBuilder) => void>;
+  protected static appends: string[];
+  protected static timezone: string;
+
+  // Instance properties
+  attributes: ModelAttributes;
+  original: ModelAttributes;
+  relations: { [key: string]: any };
+  exists: boolean;
+  wasRecentlyCreated: boolean;
+  protected _dirty: Set<string>;
+  protected fillable: string[];
+  protected guarded: string[];
+  protected casts: ModelCasts;
+  protected hidden?: string[];
+  protected appends?: string[];
+  protected _deferred?: ModelAttributes;
+
+  constructor(attributes?: ModelAttributes);
+
+  // Static methods
+  static register(): void;
+  static resolveRelatedModel(related: string | typeof Model): typeof Model;
+  static query(): QueryBuilder;
+  static with(...relations: string[]): QueryBuilder;
+  static on(connectionOrTrx: string | any): QueryBuilder;
+  static all(): Promise<Model[]>;
+  static find(id: any): Promise<Model | null>;
+  static findBy(column: string, value: any): Promise<Model | null>;
+  static first(): Promise<Model | null>;
+  static firstOrFail(): Promise<Model>;
+  static latest(column?: string): QueryBuilder;
+  static oldest(column?: string): QueryBuilder;
+  static make(attributes?: ModelAttributes): Model;
+  static create(attributes?: ModelAttributes): Promise<Model>;
+  static generateUuid(): string;
+  static insert(data: ModelAttributes | ModelAttributes[]): Promise<any>;
+  static destroy(ids: any | any[]): Promise<number>;
+  static firstOrCreate(attributes: ModelAttributes, values?: ModelAttributes): Promise<Model>;
+  static firstOrNew(attributes: ModelAttributes, values?: ModelAttributes): Promise<Model>;
+  static updateOrCreate(attributes: ModelAttributes, values?: ModelAttributes): Promise<Model>;
+
+  // Scopes
+  static addGlobalScope(name: string, scope: (query: QueryBuilder) => void): void;
+  static removeGlobalScope(name: string): void;
+  static withoutGlobalScope(name: string): QueryBuilder;
+  static applyGlobalScopes(query: QueryBuilder): void;
+
+  // Events
+  static creating(callback: (model: Model) => Promise<boolean | void> | boolean | void): void;
+  static created(callback: (model: Model) => Promise<boolean | void> | boolean | void): void;
+  static updating(callback: (model: Model) => Promise<boolean | void> | boolean | void): void;
+  static updated(callback: (model: Model) => Promise<boolean | void> | boolean | void): void;
+  static saving(callback: (model: Model) => Promise<boolean | void> | boolean | void): void;
+  static saved(callback: (model: Model) => Promise<boolean | void> | boolean | void): void;
+  static deleting(callback: (model: Model) => Promise<boolean | void> | boolean | void): void;
+  static deleted(callback: (model: Model) => Promise<boolean | void> | boolean | void): void;
+  static restoring(callback: (model: Model) => Promise<boolean | void> | boolean | void): void;
+  static restored(callback: (model: Model) => Promise<boolean | void> | boolean | void): void;
+  static observe(observer: Observer | (new () => Observer)): void;
+  static fireEvent(event: string, model: Model): Promise<boolean>;
+
+  // Table info
+  protected static getTableName(): string;
+  protected static getPrimaryKey(): string;
+  protected static getKeyType(): string;
+  protected static getIncrementing(): boolean;
+  protected static getConnectionName(): string | undefined;
+
+  // Instance methods
+  getKey(): any;
+  fill(attributes: ModelAttributes): this;
+  isFillable(key: string): boolean;
+  getAttribute(key: string): any;
+  setAttribute(key: string, value: any): this;
+  syncOriginal(): void;
+  save(): Promise<boolean>;
+  update(attributes?: ModelAttributes): Promise<boolean>;
+  isDirty(key?: string): boolean;
+  getDirty(): ModelAttributes;
+  delete(): Promise<boolean>;
+  restore(): Promise<boolean>;
+  trashed(): boolean;
+  only(keys: string[]): ModelAttributes;
+  except(keys: string[]): ModelAttributes;
+  forceDelete(): Promise<boolean>;
+  toJSON(): any;
+
+  // Relationships
+  hasOne(related: string | typeof Model, foreignKey?: string, localKey?: string): HasOne;
+  hasMany(related: string | typeof Model, foreignKey?: string, localKey?: string): HasMany;
+  belongsTo(related: string | typeof Model, foreignKey?: string, ownerKey?: string): BelongsTo;
+  belongsToMany(
+    related: string | typeof Model,
+    pivotTable?: string,
+    foreignPivotKey?: string,
+    relatedPivotKey?: string,
+    parentKey?: string,
+    relatedKey?: string
+  ): BelongsToMany;
+  hasManyThrough(
+    related: string | typeof Model,
+    through: string | typeof Model,
+    firstKey?: string,
+    secondKey?: string,
+    localKey?: string,
+    secondLocalKey?: string
+  ): HasManyThrough;
+  morphTo(typeColumn?: string, idColumn?: string): MorphTo;
+  morphMany(related: string | typeof Model, typeColumn?: string, idColumn?: string): MorphMany;
+
+  // Protected methods
+  protected _initialize(): void;
+  protected _createAttributeGetters(): void;
+  protected _getCurrentTimestamp(): Date;
+  protected _getTimezoneOffset(timezone: string, date: Date): number;
+  protected _getConfig(): any;
+  protected _resolveRelatedName(related: string | typeof Model): string;
+}

package/orm/Model.js

@@ -8,10 +8,14 @@ const Database = require('../database/connection');
 (function autoLoadConfig() {
   const fs = require('fs');
   const path = require('path');
-  const configPath = path.join(process.cwd(), 'ilana.config.js');
-  if (fs.existsSync(configPath)) {
-    delete require.cache[configPath];
-    require(configPath);
+  const configPathJs = path.join(process.cwd(), 'ilana.config.js');
+  const configPathMjs = path.join(process.cwd(), 'ilana.config.mjs');
+  
+  if (fs.existsSync(configPathJs)) {
+    delete require.cache[configPathJs];
+    require(configPathJs);
+  } else if (fs.existsSync(configPathMjs)) {
+    // For ES modules, we'll handle this in the _getConfig method
   }
 })();
 
@@ -371,9 +375,19 @@ class Model {
   _getConfig() {
     try {
       const path = require('path');
-      const configPath = path.join(process.cwd(), 'ilana.config.js');
-      delete require.cache[configPath];
-      return require(configPath);
+      const fs = require('fs');
+      const configPathJs = path.join(process.cwd(), 'ilana.config.js');
+      const configPathMjs = path.join(process.cwd(), 'ilana.config.mjs');
+      
+      if (fs.existsSync(configPathJs)) {
+        delete require.cache[configPathJs];
+        return require(configPathJs);
+      } else if (fs.existsSync(configPathMjs)) {
+        // For ES modules, return a promise or handle async import
+        // For now, return null and let the caller handle it
+        return null;
+      }
+      return null;
     } catch (e) {
       return null;
     }

package/orm/Model.mjs

@@ -0,0 +1,7 @@
+// Model.mjs - ES Module wrapper
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+
+const Model = require('./Model.js');
+
+export default Model;

package/orm/ModelRegistry.d.ts

@@ -0,0 +1,11 @@
+import Model from './Model';
+
+export default class ModelRegistry {
+  private static models: Map<string, typeof Model>;
+
+  static register(name: string, model: typeof Model): void;
+  static get(name: string): typeof Model | undefined;
+  static has(name: string): boolean;
+  static all(): Map<string, typeof Model>;
+  static clear(): void;
+}

package/orm/ModelRegistry.mjs

@@ -0,0 +1,7 @@
+// ModelRegistry.mjs - ES Module wrapper
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+
+const ModelRegistry = require('./ModelRegistry.js');
+
+export default ModelRegistry;

package/orm/QueryBuilder.d.ts

@@ -0,0 +1,155 @@
+import Collection from './Collection';
+import Model from './Model';
+
+export interface PaginationResult<T> {
+  data: Collection<T>;
+  total: number;
+  perPage: number;
+  currentPage: number;
+  lastPage: number;
+  from: number | null;
+  to: number | null;
+  nextPage: number | null;
+}
+
+export interface SimplePaginationResult<T> {
+  data: Collection<T>;
+  hasMore: boolean;
+}
+
+export interface CursorPaginationResult<T> {
+  data: Collection<T>;
+  nextCursor?: string;
+  prevCursor?: string;
+  hasNextPage: boolean;
+  hasPrevPage: boolean;
+  path: string;
+  perPage: number;
+}
+
+export default class QueryBuilder {
+  protected query: any;
+  protected modelClass: typeof Model;
+  protected connectionName?: string;
+  protected eagerLoad: string[];
+  protected eagerLoadConstraints: { [key: string]: (query: QueryBuilder) => void };
+  protected _transaction?: any;
+  protected _includeTrashed?: boolean;
+  protected _onlyTrashed?: boolean;
+  protected _withoutTrashed?: boolean;
+
+  constructor(tableName: string, modelClass: typeof Model, connectionName?: string);
+
+  // Where clauses
+  where(column: string, value: any): this;
+  where(column: string, operator: string, value: any): this;
+  orWhere(column: string, value: any): this;
+  orWhere(column: string, operator: string, value: any): this;
+  whereIn(column: string, values: any[]): this;
+  whereNotIn(column: string, values: any[]): this;
+  whereNull(column: string): this;
+  whereNotNull(column: string): this;
+  whereBetween(column: string, range: [any, any]): this;
+  whereJsonContains(column: string, value: any): this;
+  whereJsonLength(column: string, operator: string, value: number): this;
+  whereDate(column: string, value: string): this;
+  whereDate(column: string, operator: string, value: string): this;
+  whereMonth(column: string, month: number): this;
+  whereYear(column: string, year: number): this;
+  whereExists(callback: (query: QueryBuilder) => void): this;
+  when<T>(condition: T, callback: (query: this, condition: T) => void, otherwise?: (query: this) => void): this;
+
+  // Joins
+  join(table: string, first: string, operator: string, second: string): this;
+  leftJoin(table: string, first: string, operator: string, second: string): this;
+  rightJoin(table: string, first: string, operator: string, second: string): this;
+
+  // Ordering and limits
+  orderBy(column: string, direction?: 'asc' | 'desc'): this;
+  latest(column?: string): this;
+  oldest(column?: string): this;
+  limit(count: number): this;
+  offset(count: number): this;
+  take(count: number): this;
+  skip(count: number): this;
+
+  // Grouping
+  groupBy(...columns: string[]): this;
+  having(column: string, operator: string, value: any): this;
+  having(rawSql: string): this;
+
+  // Locking
+  lockForUpdate(): this;
+  sharedLock(): this;
+  skipLocked(): this;
+  noWait(): this;
+
+  // Selection
+  select(...columns: string[]): this;
+  distinct(): this;
+
+  // Raw queries
+  whereRaw(sql: string, bindings?: any[]): this;
+  selectRaw(sql: string, bindings?: any[]): this;
+
+  // Aggregates
+  count(column?: string): Promise<number>;
+  sum(column: string): Promise<number>;
+  avg(column: string): Promise<number>;
+  min(column: string): Promise<any>;
+  max(column: string): Promise<any>;
+
+  // Eager loading
+  with(...relations: string[]): this;
+  withConstraints(relation: string, callback: (query: QueryBuilder) => void): this;
+  withConstraints(relations: { [key: string]: (query: QueryBuilder) => void }): this;
+  withCount(...relations: string[]): this;
+  whereHas(relation: string, callback?: (query: QueryBuilder) => void): this;
+
+  // Execution methods
+  get(): Promise<Collection<Model>>;
+  first(): Promise<Model | null>;
+  find(id: any): Promise<Model | null>;
+  findOrFail(id: any): Promise<Model>;
+  pluck(column: string): Promise<any[]>;
+  exists(): Promise<boolean>;
+
+  // Pagination
+  paginate(page?: number, perPage?: number): Promise<PaginationResult<Model>>;
+  simplePaginate(page?: number, perPage?: number): Promise<SimplePaginationResult<Model>>;
+  cursorPaginate(perPage?: number, cursor?: string, column?: string, direction?: 'asc' | 'desc'): Promise<CursorPaginationResult<Model>>;
+
+  // Chunking
+  chunk(size: number, callback: (models: Collection<Model>) => Promise<void>): Promise<void>;
+  cursor(chunkSize?: number): AsyncGenerator<Model, void, unknown>;
+  lazy(chunkSize?: number): AsyncGenerator<Model, void, unknown>;
+
+  // Insert/Update/Delete
+  insert(data: any | any[]): Promise<any>;
+  insertGetId(data: any): Promise<any>;
+  update(data: any): Promise<number>;
+  delete(): Promise<number>;
+  upsert(data: any[], uniqueBy: string[], update?: string[]): Promise<any>;
+
+  // Connection switching
+  connection(name: string): QueryBuilder;
+  on(connectionOrTrx: string | any): QueryBuilder;
+
+  // Clone query
+  clone(): QueryBuilder;
+
+  // Get underlying Knex query
+  toKnex(): any;
+
+  // Soft delete methods
+  withTrashed(): this;
+  onlyTrashed(): this;
+  withoutTrashed(): this;
+
+  // Debug
+  toSql(): string;
+
+  // Protected methods
+  protected loadRelations(models: Model[]): Promise<void>;
+  protected loadRelation(models: Model[], relationName: string): Promise<void>;
+}

package/orm/QueryBuilder.mjs

@@ -0,0 +1,7 @@
+// QueryBuilder.mjs - ES Module wrapper
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+
+const QueryBuilder = require('./QueryBuilder.js');
+
+export default QueryBuilder;

package/orm/Relation.d.ts

@@ -0,0 +1,99 @@
+import QueryBuilder from './QueryBuilder';
+import Model from './Model';
+import Collection from './Collection';
+
+export class Relation {
+  protected parent: Model;
+  protected related: string | typeof Model;
+  protected foreignKey: string;
+  protected localKey: string;
+
+  constructor(parent: Model, related: string | typeof Model, foreignKey: string, localKey?: string);
+
+  getRelatedClass(): typeof Model;
+  newQuery(): QueryBuilder;
+}
+
+export class HasOne extends Relation {
+  addConstraints(): void;
+  getResults(): Promise<Model | null>;
+}
+
+export class HasMany extends Relation {
+  addConstraints(): void;
+  getResults(): Promise<Collection<Model>>;
+}
+
+export class BelongsTo extends Relation {
+  addConstraints(): void;
+  getResults(): Promise<Model | null>;
+}
+
+export class BelongsToMany extends Relation {
+  protected pivotTable: string;
+  protected parentPivotKey: string;
+  protected relatedPivotKey: string;
+  protected parentKey: string;
+  protected relatedKey: string;
+  protected pivotColumns: string[];
+  protected pivotTimestamps: boolean;
+
+  constructor(
+    parent: Model,
+    related: string | typeof Model,
+    pivotTable?: string,
+    foreignPivotKey?: string,
+    relatedPivotKey?: string,
+    parentKey?: string,
+    relatedKey?: string
+  );
+
+  withPivot(...columns: string[]): this;
+  withTimestamps(): this;
+  addConstraints(): void;
+  getResults(): Promise<Model[]>;
+  attach(id: any, attributes?: any): Promise<void>;
+  detach(id?: any): Promise<number>;
+  sync(ids: any[]): Promise<void>;
+}
+
+export class HasManyThrough extends Relation {
+  protected through: string | typeof Model;
+  protected firstKey: string;
+  protected secondKey: string;
+  protected secondLocalKey: string;
+
+  constructor(
+    parent: Model,
+    related: string | typeof Model,
+    through: string | typeof Model,
+    firstKey?: string,
+    secondKey?: string,
+    localKey?: string,
+    secondLocalKey?: string
+  );
+
+  addConstraints(): void;
+  getResults(): Promise<Collection<Model>>;
+}
+
+export class MorphTo extends Relation {
+  protected morphType: string;
+  protected morphId: string;
+
+  constructor(parent: Model, morphType: string, morphId: string);
+
+  addConstraints(): void;
+  getResults(): Promise<Model | null>;
+}
+
+export class MorphMany extends Relation {
+  protected morphType: string;
+  protected morphId: string;
+  protected morphClass: string;
+
+  constructor(parent: Model, related: string | typeof Model, morphType: string, morphId: string, morphClass: string);
+
+  addConstraints(): void;
+  getResults(): Promise<Collection<Model>>;
+}

package/orm/Relation.mjs

@@ -0,0 +1,7 @@
+// Relation.mjs - ES Module wrapper
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+
+const Relations = require('./Relation.js');
+
+export const { Relation, HasOne, HasMany, BelongsTo, BelongsToMany, HasManyThrough, MorphTo, MorphMany } = Relations;

package/package.json

@@ -1,8 +1,36 @@
 {
   "name": "ilana-orm",
-  "version": "1.0.3",
+  "version": "1.0.7",
   "description": "A fully-featured, Eloquent-style ORM for Node.js with TypeScript support",
   "main": "index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./index.mjs",
+      "require": "./index.js",
+      "types": "./index.d.ts"
+    },
+    "./orm/Model": {
+      "import": "./orm/Model.mjs",
+      "require": "./orm/Model.js",
+      "types": "./orm/Model.d.ts"
+    },
+    "./orm/QueryBuilder": {
+      "import": "./orm/QueryBuilder.mjs",
+      "require": "./orm/QueryBuilder.js",
+      "types": "./orm/QueryBuilder.d.ts"
+    },
+    "./orm/Collection": {
+      "import": "./orm/Collection.mjs",
+      "require": "./orm/Collection.js",
+      "types": "./orm/Collection.d.ts"
+    },
+    "./database/connection": {
+      "import": "./database/connection.mjs",
+      "require": "./database/connection.js",
+      "types": "./database/connection.d.ts"
+    }
+  },
   "bin": {
     "ilana": "cli/ilana.js"
   },
@@ -38,9 +66,15 @@
   },
   "files": [
     "*.js",
+    "*.mjs",
+    "*.d.ts",
     "cli/**/*.js",
     "database/**/*.js",
+    "database/**/*.mjs",
+    "database/**/*.d.ts",
     "orm/**/*.js",
+    "orm/**/*.mjs",
+    "orm/**/*.d.ts",
     "README.md",
     "LICENSE",
     "ilana.png"
@@ -65,6 +99,9 @@
     "@types/jest": "^29.0.0",
     "ts-jest": "^29.0.0"
   },
+  "peerDependencies": {
+    "@types/node": ">=16.0.0"
+  },
   "engines": {
     "node": ">=16.0.0"
   }