ilana-orm 1.0.18 → 1.0.19

package/README.md

@@ -24,6 +24,7 @@ A fully-featured, Eloquent-style ORM for Node.js with automatic TypeScript suppo
 - [Schema Builder](#schema-builder)
 - [Transactions](#transactions)
 - [Advanced Features](#advanced-features)
+- [Supabase](#supabase)
 - [Complete API Reference](#complete-api-reference)
 - [TypeScript Support](#typescript-support)
 - [Performance & Best Practices](#performance--best-practices)
@@ -793,47 +794,33 @@ export default class User extends Model {
 
 ### UUID Primary Keys
 
-**JavaScript:**
 ```javascript
 class User extends Model {
   static table = 'users';
-  static keyType = 'string';
+  static keyType = 'uuid';
   static incrementing = false;
 }
 
-module.exports = User;
-
-// Usage
-const user = await User.create({
-  name: 'John Doe',
-  email: 'john@example.com',
-});
-// user.id will be a generated UUID
-````
+const user = await User.create({ name: 'John Doe', email: 'john@example.com' });
+// user.id → "550e8400-e29b-41d4-a716-446655440000"
+```
 
-**TypeScript:**
+### ULID Primary Keys
 
-```typescript
-export default class User extends Model {
-  protected static table = "users";
-  protected static keyType = "string" as const;
-  protected static incrementing = false;
+ULIDs are 26-character sortable identifiers — URL-safe, lexicographically ordered by creation time:
 
-  // Attributes
-  id!: string; // UUID primary key
-  name!: string;
-  email!: string;
+```javascript
+class Order extends Model {
+  static table = 'orders';
+  static keyType = 'ulid';
+  static incrementing = false;
 }
 
-// Usage
-const user = await User.create({
-  name: "John Doe",
-  email: "john@example.com",
-});
-// user.id will be a generated UUID
+const order = await Order.create({ total: 49.99 });
+// order.id → "01J3X7KQZB8YTPNMCHW4RSVFGE"
 ```
 
-````
+Use `char(26)` for the column type in migrations.
 
 ### Attribute Casting
 
@@ -4179,6 +4166,68 @@ const users = await User.query().select('id', 'name', 'email').values();
 // [{ id: 1, name: 'John', email: 'john@example.com' }, ...]
 ```
 
+### Vector / Semantic Search (pgvector)
+
+Semantic search matches by **meaning**, not exact keywords. It works by converting text into a list of numbers called an **embedding** using an AI embedding model, storing those numbers in the database, and finding records whose embeddings are mathematically closest to a search query.
+
+**Requires:** PostgreSQL + pgvector extension. An external embedding model (OpenAI, Cohere, Ollama, etc.) is also required — IlanaORM does not include one. Does **not** work with MySQL or SQLite.
+
+```javascript
+// 1. Enable the extension in a migration
+await schema.enableVectorExtension();
+
+// 2. Add a vector column
+await schema.table('posts', table => {
+  table.specificType('embedding', 'vector(1536)'); // dimensions must match your model
+});
+
+// 3. Configure the model
+class Post extends Model {
+  static embeddingColumn = 'embedding';
+  static embeddingProvider = async (text) => {
+    // Must return Promise<number[]> — plug in any embedding API
+    const res = await openai.embeddings.create({ model: 'text-embedding-ada-002', input: text });
+    return res.data[0].embedding;
+  };
+}
+
+// 4. Store embeddings when creating records
+await Post.create({
+  title: 'JavaScript tips',
+  body: '...',
+  embedding: JSON.stringify(await Post.embeddingProvider('JavaScript tips ...')),
+});
+
+// 5. Search — converts text to vector, queries by similarity
+const posts = await Post.search('javascript performance tips', { limit: 5 });
+
+// Or search by a raw vector you already have
+const posts = await Post.nearestTo(myVector, { distance: 'cosine', limit: 10 });
+
+// Each result has a .distance attribute (lower = more similar)
+posts.forEach(p => console.log(p.title, p.distance));
+```
+
+Distance options: `'cosine'` (default, `<=>`), `'l2'` (`<->`), `'inner'` (`<#>`).
+
+### Edge Runtime
+
+Import from `ilana-orm/edge` to skip the Node.js `fs`/`path` auto-loader. Required for Cloudflare Workers, Deno, Bun, and Next.js edge routes:
+
+```javascript
+import { Model, Database } from 'ilana-orm/edge';
+
+// Must configure explicitly — no auto-loading of ilana.config.js
+Database.configure({
+  default: 'pg',
+  connections: {
+    pg: { client: 'pg', connection: { connectionString: process.env.DATABASE_URL } },
+  },
+});
+
+const users = await User.all();
+```
+
 ## TypeScript Support
 
 ### Type-Safe Models
@@ -4231,6 +4280,32 @@ const user = await User.factory().create({
 });
 ```
 
+## Supabase
+
+Supabase is a hosted PostgreSQL platform. IlanaORM works with it out of the box using the `pg` driver — no special setup required.
+
+```javascript
+// ilana.config.js
+const { Database } = require('ilana-orm');
+
+Database.configure({
+  default: 'pg',
+  connections: {
+    pg: {
+      client: 'pg',
+      connection: {
+        connectionString: process.env.DATABASE_URL, // from Supabase dashboard
+        ssl: { rejectUnauthorized: false },         // required for Supabase
+      },
+    },
+  },
+});
+```
+
+All features work including migrations, relations, soft deletes, and vector search (Supabase has pgvector built in).
+
+For serverless or edge deployments with Supabase, use the [connection pooler URL](https://supabase.com/docs/guides/database/connecting-to-postgres) (port `6543`) and the `ilana-orm/edge` entry point for Cloudflare Workers or Next.js edge routes.
+
 ## Performance & Best Practices
 
 ### Query Optimization
@@ -4410,10 +4485,14 @@ User.upsert(data, unique, update); // Upsert records
 User.destroy(ids); // Delete by IDs (soft-delete aware)
 User.truncate(); // Delete all rows in the table
 User.seed(n); // Create n records using the registered factory
+User.prune(); // Delete all records matching static prunable()
 User.withTrashed(); // Include soft deleted
 User.onlyTrashed(); // Only soft deleted
 User.withoutTrashed(); // Exclude soft deleted
 
+// Events
+User.withoutEvents(async () => { ... }); // Run without firing events
+
 // Configuration
 User.getTableName(); // Get table name
 User.getPrimaryKey(); // Get primary key
@@ -4421,6 +4500,7 @@ User.getKeyType(); // Get key type
 User.getIncrementing(); // Get incrementing flag
 User.getConnectionName(); // Get connection name
 User.generateUuid(); // Generate UUID
+User.generateUlid(); // Generate ULID
 
 // Events
 User.creating(callback); // Before creating
@@ -4458,6 +4538,8 @@ user.forceDelete(); // Force delete (ignores softDeletes)
 user.restore(); // Restore soft deleted
 user.fresh(); // Re-fetch from DB and return new instance
 user.is(other); // Check if two instances are the same record
+user.isNot(other); // Inverse of is()
+user.replicate(except?); // Clone as unsaved record (excludes PK + timestamps)
 
 // Attributes
 user.fill(attributes); // Mass assign (respects fillable/guarded)
@@ -4642,9 +4724,10 @@ query.upsert(data, uniqueBy, update);
 query.with(...relations);
 query.withConstraints(relation, callback);
 query.withCount(...relations);    // adds relation_count subquery column per model
-query.whereHas(relation, callback); // WHERE EXISTS subquery
-query.doesntHave(relation);                    // WHERE NOT EXISTS subquery
-query.whereDoesntHave(relation, callback);     // WHERE NOT EXISTS with constraint
+query.has(relation, operator?, count?); // WHERE EXISTS, or count-based (e.g. has('posts', '>', 5))
+query.whereHas(relation, callback);    // WHERE EXISTS with constraint subquery
+query.doesntHave(relation);            // WHERE NOT EXISTS subquery
+query.whereDoesntHave(relation, callback); // WHERE NOT EXISTS with constraint
 ```
 
 #### Locking

package/cli/ilana.js

@@ -283,90 +283,20 @@ function getModelTemplate(className, tableName) {
 
   if (isTypeScriptProject()) {
     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}';
-  protected static timestamps = true;
-  protected static softDeletes = false;
-  
-  // For UUID primary keys, uncomment:
-  // protected static keyType = 'string' as const;
-  // protected static incrementing = false;
-
-  protected fillable: string[] = [];
-  protected hidden: string[] = [];
-  protected appends: string[] = [];
-  protected casts = {
-    // Basic casts
-    // is_active: 'boolean' as const,
-    // metadata: 'json' as const,
-    // tags: 'array' as const,
-    
-    // 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: any) {
-  //   query.where('is_active', true);
-  // }
-  
-  // Register for polymorphic relationships
-  // static {
-  //   this.register();
-  // }
+  protected static fillable: string[] = [];
 }
 `;
   }
 
   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();
-  // }
+  static fillable = [];
 }
 
 export default ${className};
@@ -374,45 +304,10 @@ export default ${className};
   }
 
   return `const Model = require('ilana-orm/orm/Model');
-// const { MoneyCast, EncryptedCast } = require('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();
-  // }
+  static fillable = [];
 }
 
 module.exports = ${className};
@@ -427,11 +322,7 @@ function getPivotModelTemplate(className, tableName) {
 
 export default class ${className} extends Model {
   protected static table = '${tableName}';
-  protected static timestamps = true;
-  
-  protected fillable: string[] = [];
-
-  // Define pivot relationships here
+  protected static fillable: string[] = [];
 }
 `;
   }
@@ -441,11 +332,7 @@ export default class ${className} extends Model {
 
 class ${className} extends Model {
   static table = '${tableName}';
-  static timestamps = true;
-  
-  fillable = [];
-
-  // Define pivot relationships here
+  static fillable = [];
 }
 
 export default ${className};
@@ -456,11 +343,7 @@ export default ${className};
 
 class ${className} extends Model {
   static table = '${tableName}';
-  static timestamps = true;
-  
-  fillable = [];
-
-  // Define pivot relationships here
+  static fillable = [];
 }
 
 module.exports = ${className};
@@ -477,29 +360,27 @@ function generateFactory(className) {
   }
 
   const modelPath = structure.hasSrc ? `../models/${className}.js` : `../../models/${className}.js`;
+  const isESModule = isESModuleProject();
   const template = isTypeScriptProject() ?
     `import { defineFactory } from 'ilana-orm/orm/Factory.js';
 import ${className} from '${modelPath}';
 
 export default defineFactory(${className}, (faker) => ({
-  // Define your factory attributes here
   // name: faker.person.fullName(),
-  // email: faker.internet.email(),
-}))
-.state('example', (faker) => ({
-  // Define state modifications here
+}));
+` : isESModule ?
+    `import { defineFactory } from 'ilana-orm/orm/Factory';
+import ${className} from '${modelPath}';
+
+export default defineFactory(${className}, (faker) => ({
+  // name: faker.person.fullName(),
 }));
 ` :
     `const { defineFactory } = require('ilana-orm/orm/Factory');
 const ${className} = require('${modelPath.replace('.js', '')}');
 
 module.exports = defineFactory(${className}, (faker) => ({
-  // Define your factory attributes here
   // name: faker.person.fullName(),
-  // email: faker.internet.email(),
-}))
-.state('example', (faker) => ({
-  // Define state modifications here
 }));
 `;
 
@@ -517,34 +398,38 @@ function generateSeeder(className) {
   }
 
   const modelPath = structure.hasSrc ? `../models/${className}.js` : `../../models/${className}.js`;
+  const isESModule = isESModuleProject();
   const template = isTypeScriptProject() ?
     `import Seeder from 'ilana-orm/orm/Seeder.js';
+import { factory } from 'ilana-orm/orm/Factory.js';
 import ${className} from '${modelPath}';
 import '../factories/${className}Factory.js';
 
 export default class ${className}Seeder extends Seeder {
   async run(): Promise<void> {
-    console.log('Seeding ${className.toLowerCase()}s...');
-
-    // Create sample data
-    await ${className}.factory().times(10).create();
+    await factory(${className}).times(10).create();
+  }
+}
+` : isESModule ?
+    `import Seeder from 'ilana-orm/orm/Seeder';
+import { factory } from 'ilana-orm/orm/Factory';
+import ${className} from '${modelPath}';
+import '../factories/${className}Factory.js';
 
-    console.log('${className}s seeded successfully');
+export default class ${className}Seeder extends Seeder {
+  async run() {
+    await factory(${className}).times(10).create();
   }
 }
 ` :
     `const Seeder = require('ilana-orm/orm/Seeder');
+const { factory } = require('ilana-orm/orm/Factory');
 const ${className} = require('${modelPath.replace('.js', '')}');
 require('../factories/${className}Factory');
 
 class ${className}Seeder extends Seeder {
   async run() {
-    console.log('Seeding ${className.toLowerCase()}s...');
-
-    // Create sample data
-    await ${className}.factory().times(10).create();
-
-    console.log('${className}s seeded successfully');
+    await factory(${className}).times(10).create();
   }
 }
 
@@ -1590,4 +1475,5 @@ if (require.main === module) {
   main();
 }
 
-module.exports = commands;
+module.exports = commands;
+module.exports._templates = { getModelTemplate, getPivotModelTemplate };

package/database/schema-builder.js

@@ -207,6 +207,10 @@ class SchemaBuilder {
     return Promise.resolve();
   }
 
+  enableVectorExtension() {
+    return this.knex.raw('CREATE EXTENSION IF NOT EXISTS vector');
+  }
+
   createEnum(name, values) {
     if (this.knex.client.config.client === 'pg') {
       return this.knex.raw(`CREATE TYPE ${name} AS ENUM (${values.map(v => `'${v}'`).join(', ')})`);

package/index.edge.js

@@ -0,0 +1,10 @@
+// Edge runtime entry point — no auto-loading of ilana.config.js.
+// Use this when running in Cloudflare Workers, Deno, Bun, or Next.js edge routes.
+// You must call Database.configure(config) explicitly before using any models.
+//
+// import { Model, Database } from 'ilana-orm/edge';
+// Database.configure({ default: 'pg', connections: { pg: { ... } } });
+
+'use strict';
+global.__ILANA_EDGE__ = true;
+module.exports = require('./index.js');

package/index.edge.mjs

@@ -0,0 +1,37 @@
+// Edge runtime entry point — ESM wrapper.
+// Sets __ILANA_EDGE__ before any model is loaded so the auto-loader is skipped.
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+
+globalThis.__ILANA_EDGE__ = true;
+const exports = require('./index.js');
+
+export const {
+  Model,
+  QueryBuilder,
+  Collection,
+  Database,
+  DB,
+  SchemaBuilder,
+  MigrationRunner,
+  Seeder,
+  Factory,
+  defineFactory,
+  ModelNotFoundException,
+  F,
+  HasOne,
+  HasMany,
+  BelongsTo,
+  BelongsToMany,
+  HasManyThrough,
+  MorphTo,
+  MorphOne,
+  MorphMany,
+  MoneyCast,
+  EncryptedCast,
+  JsonCast,
+  ArrayCast,
+  DateCast,
+} = exports;
+
+export default exports.Model;

package/orm/MigrationRunner.js

@@ -417,28 +417,20 @@ class MigrationRunner {
 
     if (isCreate || name.includes('create_')) {
       return isTS ?
-        `import type { SchemaBuilder } from 'ilana-orm';
-
-export default class ${className} {
-  // connection = 'mysql'; // Uncomment to use specific connection
-  
-  async up(schema: SchemaBuilder): Promise<void> {
+        `export default class ${className} {
+  async up(schema) {
     await schema.createTable('${table}', (table) => {
       table.increments('id');
       table.timestamps();
     });
   }
 
-  async down(schema: SchemaBuilder): Promise<void> {
+  async down(schema) {
     await schema.dropTable('${table}');
   }
 }
 ` :
-        `const { SchemaBuilder } = require('ilana-orm');
-
-class ${className} {
-  // connection = 'mysql'; // Uncomment to use specific connection
-  
+        `class ${className} {
   async up(schema) {
     await schema.createTable('${table}', (table) => {
       table.increments('id');
@@ -455,42 +447,30 @@ module.exports = ${className};
 `;
     } else if (tableName) {
       return isTS ?
-        `import type { SchemaBuilder } from 'ilana-orm';
-
-export default class ${className} {
-  // connection = 'mysql'; // Uncomment to use specific connection
-  
-  async up(schema: SchemaBuilder): Promise<void> {
+        `export default class ${className} {
+  async up(schema) {
     await schema.table('${table}', (table) => {
-      // Add your column modifications here
-      // table.string('new_column').nullable();
+      // table.string('column_name').nullable();
     });
   }
 
-  async down(schema: SchemaBuilder): Promise<void> {
+  async down(schema) {
     await schema.table('${table}', (table) => {
-      // Reverse your modifications here
-      // table.dropColumn('new_column');
+      // table.dropColumn('column_name');
     });
   }
 }
 ` :
-        `const { SchemaBuilder } = require('ilana-orm');
-
-class ${className} {
-  // connection = 'mysql'; // Uncomment to use specific connection
-  
+        `class ${className} {
   async up(schema) {
     await schema.table('${table}', (table) => {
-      // Add your column modifications here
-      // table.string('new_column').nullable();
+      // table.string('column_name').nullable();
     });
   }
 
   async down(schema) {
     await schema.table('${table}', (table) => {
-      // Reverse your modifications here
-      // table.dropColumn('new_column');
+      // table.dropColumn('column_name');
     });
   }
 }
@@ -500,31 +480,19 @@ module.exports = ${className};
     }
 
     return isTS ?
-      `import type { SchemaBuilder } from 'ilana-orm';
-
-export default class ${className} {
-  // connection = 'mysql'; // Uncomment to use specific connection
-  
-  async up(schema: SchemaBuilder): Promise<void> {
-    // Add your migration logic here
+      `export default class ${className} {
+  async up(schema) {
   }
 
-  async down(schema: SchemaBuilder): Promise<void> {
-    // Add your rollback logic here
+  async down(schema) {
   }
 }
 ` :
-      `const { SchemaBuilder } = require('ilana-orm');
-
-class ${className} {
-  // connection = 'mysql'; // Uncomment to use specific connection
-  
+      `class ${className} {
   async up(schema) {
-    // Add your migration logic here
   }
 
   async down(schema) {
-    // Add your rollback logic here
   }
 }
 

package/orm/Model.d.ts

@@ -36,7 +36,7 @@ export default class Model<TAttributes extends ModelAttributes = ModelAttributes
   protected static table: string;
   protected static connection?: string;
   protected static primaryKey: string;
-  protected static keyType: 'number' | 'string';
+  protected static keyType: 'number' | 'string' | 'uuid' | 'ulid';
   protected static incrementing: boolean;
   protected static timestamps: boolean;
   protected static createdAt: string;
@@ -53,6 +53,9 @@ export default class Model<TAttributes extends ModelAttributes = ModelAttributes
   static strictLoading: boolean;
   static touches: string[];
   static enums: { [column: string]: string[] };
+  static embeddingColumn: string;
+  static embeddingDimensions: number;
+  static embeddingProvider?: (text: string) => Promise<number[]>;
 
   // Instance properties
   attributes: ModelAttributes;
@@ -86,15 +89,25 @@ export default class Model<TAttributes extends ModelAttributes = ModelAttributes
   static oldest(column?: string): QueryBuilder;
   static withTrashed(): QueryBuilder;
   static onlyTrashed(): QueryBuilder;
+  static withoutTrashed(): QueryBuilder;
+  static findOrFail(id: number | string): Promise<Model>;
+  static insertGetId(data: { [key: string]: any }): Promise<number | string>;
   static upsert(data: any[], uniqueBy: string[], update?: string[]): Promise<any>;
   static withoutGlobalScopes(): QueryBuilder;
   static make(attributes?: ModelAttributes): Model;
   static create(attributes?: ModelAttributes): Promise<Model>;
   static generateUuid(): string;
+  static generateUlid(): string;
+  static _generateKey(): string;
+  static withoutEvents<T>(callback: () => Promise<T>): Promise<T>;
+  static prunable(): QueryBuilder;
+  static prune(): Promise<number>;
   static insert(data: ModelAttributes | ModelAttributes[]): Promise<any>;
   static destroy(ids: any | any[]): Promise<number>;
   static truncate(): Promise<void>;
   static seed(count?: number): Promise<any[]>;
+  static nearestTo(vector: number[], options?: { limit?: number; column?: string; distance?: 'cosine' | 'l2' | 'inner' }): Promise<Collection<any>>;
+  static search(text: string, options?: { limit?: number; column?: string; distance?: 'cosine' | 'l2' | 'inner'; provider?: (text: string) => Promise<number[]> }): Promise<Collection<any>>;
   static firstOrCreate(attributes: ModelAttributes, values?: ModelAttributes): Promise<Model>;
   static firstOrNew(attributes: ModelAttributes, values?: ModelAttributes): Promise<Model>;
   static updateOrCreate(attributes: ModelAttributes, values?: ModelAttributes): Promise<Model>;
@@ -156,6 +169,8 @@ export default class Model<TAttributes extends ModelAttributes = ModelAttributes
   forceDelete(): Promise<boolean>;
   fresh(): Promise<this | null>;
   is(other: Model): boolean;
+  isNot(other: Model | null | undefined): boolean;
+  replicate(except?: string[]): this;
   toJSON(): any;
 
   // Relationships

package/orm/Model.js

@@ -4,20 +4,22 @@ const { HasOne, HasMany, BelongsTo, BelongsToMany, HasManyThrough, MorphTo, Morp
 const ModelRegistry = require('./ModelRegistry');
 const Database = require('../database/connection');
 
-// Auto-load configuration on first import
-(function autoLoadConfig() {
-  const fs = require('fs');
-  const path = require('path');
-  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
-  }
-})();
+// Auto-load configuration on first import (skipped in edge runtime)
+if (typeof process !== 'undefined' && process.versions && process.versions.node && !global.__ILANA_EDGE__) {
+  (function autoLoadConfig() {
+    const fs = require('fs');
+    const path = require('path');
+    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, handled in _getConfig
+    }
+  })();
+}
 
 class Model {
   // --- Static defaults ---
@@ -38,6 +40,8 @@ class Model {
   static strictLoading = false;
   static touches = [];
   static enums = {};
+  static embeddingColumn = 'embedding';
+  static embeddingDimensions = 1536;
 
   // --- Instance props ---
   attributes = {};
@@ -225,6 +229,9 @@ class Model {
   static oldest(col) { return this.query().oldest(col || this.createdAt || 'created_at'); }
   static withTrashed() { return this.query().withTrashed(); }
   static onlyTrashed() { return this.query().onlyTrashed(); }
+  static withoutTrashed() { return this.query().withoutTrashed(); }
+  static async findOrFail(id) { return this.query().findOrFail(id); }
+  static async insertGetId(data) { return this.query().insertGetId(data); }
   static async upsert(data, uniqueBy, update) { return this.query().upsert(data, uniqueBy, update); }
   static withoutGlobalScopes() {
     return new QueryBuilder(this.getTableName(), this, this.getConnectionName());
@@ -233,8 +240,8 @@ class Model {
   static make(attrs = {}) {
     const inst = new this(attrs);
     inst._initialize();
-    if (!this.incrementing && this.keyType === 'string' && !inst.getKey()) {
-      inst.setAttribute(this.primaryKey, this.generateUuid());
+    if (!this.incrementing && (this.keyType === 'string' || this.keyType === 'uuid' || this.keyType === 'ulid') && !inst.getKey()) {
+      inst.setAttribute(this.primaryKey, this._generateKey());
     }
     return inst;
   }
@@ -252,8 +259,63 @@ class Model {
     });
   }
 
+  static generateUlid() {
+    const CHARS = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+    const now = Date.now();
+    let t = now;
+    let ts = '';
+    for (let i = 9; i >= 0; i--) {
+      ts = CHARS[t % 32] + ts;
+      t = Math.floor(t / 32);
+    }
+    let rand = '';
+    for (let i = 0; i < 16; i++) rand += CHARS[Math.floor(Math.random() * 32)];
+    return ts + rand;
+  }
+
+  static _generateKey() {
+    if (this.keyType === 'ulid') return this.generateUlid();
+    return this.generateUuid();
+  }
+
   static async insert(data) { return this.query().insert(data); }
   static async truncate() { return this.query().toKnex().truncate(); }
+
+  static _assertPgVector() {
+    const conn = Database.connection(this.connection);
+    const client = conn?.client?.config?.client || '';
+    if (!client.includes('pg')) {
+      throw new Error(
+        `${this.name}.search() and ${this.name}.nearestTo() require PostgreSQL with the pgvector extension. ` +
+        `Current database client is '${client || 'unknown'}'. ` +
+        `Vector search is not supported on MySQL or SQLite.`
+      );
+    }
+  }
+
+  static async nearestTo(vector, { limit = 10, column, distance = 'cosine' } = {}) {
+    this._assertPgVector();
+    const col = column || this.embeddingColumn;
+    const ops = { cosine: '<=>', l2: '<->', inner: '<#>' };
+    const op = ops[distance] || '<=>';
+    const vectorStr = `[${Array.from(vector).join(',')}]`;
+    return this.query()
+      .selectRaw(`*, (${col} ${op} ?) as distance`, [vectorStr])
+      .orderByRaw(`${col} ${op} ?`, [vectorStr])
+      .limit(limit)
+      .get();
+  }
+
+  static async search(text, { limit = 10, column, distance = 'cosine', provider } = {}) {
+    this._assertPgVector();
+    const embed = provider || this.embeddingProvider;
+    if (!embed) throw new Error(
+      `${this.name}.search() requires an embedding provider. ` +
+      `Pass { provider: async (text) => number[] } or set ${this.name}.embeddingProvider.`
+    );
+    const vector = await embed(text);
+    return this.nearestTo(vector, { limit, column, distance });
+  }
   static async seed(count = 1) {
     const { factory } = require('./Factory');
     return factory(this).times(count).create();
@@ -341,6 +403,7 @@ class Model {
   }
   // static async fireEvent(evt, mdl) { for (const h of this.events[evt] || []) if (await h(mdl) === false) return false; }
   static async fireEvent(evt, mdl) {
+    if (this._mutingEvents) return true;
     const ownEvents = Object.hasOwn(this, 'events') ? this.events : {};
     const handlers = ownEvents[evt] || [];
     for (const handler of handlers) {
@@ -349,6 +412,31 @@ class Model {
     return true;
   }
 
+  static async withoutEvents(callback) {
+    this._mutingEvents = true;
+    try {
+      return await callback();
+    } finally {
+      this._mutingEvents = false;
+    }
+  }
+
+  static prunable() {
+    throw new Error(`${this.name} must implement a static prunable() method that returns a QueryBuilder.`);
+  }
+
+  static async prune() {
+    const query = this.prunable();
+    let pruned = 0;
+    await query.chunk(1000, async (models) => {
+      for (const model of models) {
+        await model.delete();
+        pruned++;
+      }
+    });
+    return pruned;
+  }
+
   // --- Instance methods ---
   static getTableName() { return this.table || this.name.toLowerCase() + 's'; }
   static getPrimaryKey() { return this.primaryKey; }
@@ -531,9 +619,10 @@ class Model {
         this.setAttribute(createdAtCol, now).setAttribute(updatedAtCol, now);
       }
 
-      // Generate UUID if needed
-      if (!this.constructor.incrementing && this.constructor.keyType === 'string' && !this.getKey()) {
-        this.setAttribute(this.constructor.primaryKey, this.constructor.generateUuid());
+      // Generate UUID/ULID if needed
+      const kt = this.constructor.keyType;
+      if (!this.constructor.incrementing && (kt === 'string' || kt === 'uuid' || kt === 'ulid') && !this.getKey()) {
+        this.setAttribute(this.constructor.primaryKey, this.constructor._generateKey());
       }
 
       const qb = this.constructor.query();
@@ -704,6 +793,27 @@ class Model {
     return this.getKey() === other.getKey();
   }
 
+  isNot(other) {
+    return !this.is(other);
+  }
+
+  replicate(except = []) {
+    const exclude = new Set([
+      this.constructor.primaryKey,
+      ...(this.constructor.timestamps ? ['created_at', 'updated_at'] : []),
+      ...except,
+    ]);
+    const attrs = {};
+    for (const [k, v] of Object.entries(this.attributes)) {
+      if (!exclude.has(k)) attrs[k] = v;
+    }
+    const copy = new this.constructor(attrs);
+    copy._initialize();
+    copy.exists = false;
+    copy.wasRecentlyCreated = false;
+    return copy;
+  }
+
   // JSON serialization
   toJSON() {
     this._initialize();

package/orm/QueryBuilder.d.ts

@@ -104,12 +104,21 @@ export default class QueryBuilder {
   // Selection
   select(...columns: any[]): this;
   addSelect(...columns: any[]): this;
+  addSelect(subqueries: { [alias: string]: (query: QueryBuilder) => void }): this;
   distinct(): this;
 
   // Raw queries
   whereRaw(sql: string, bindings?: any[]): this;
   selectRaw(sql: string, bindings?: any[]): this;
 
+  // Advanced subqueries
+  orderBySubquery(callback: (query: QueryBuilder) => void, direction?: 'asc' | 'desc'): this;
+
+  // Pending attributes (scope defaults)
+  withPendingAttributes(attributes: { [key: string]: any }): this;
+  new(attributes?: { [key: string]: any }): Promise<import('./Model').default>;
+  create(attributes?: { [key: string]: any }): Promise<import('./Model').default>;
+
   // Aggregates
   count(column?: string): Promise<number>;
   sum(column: string): Promise<number>;
@@ -125,6 +134,7 @@ export default class QueryBuilder {
   whereHas(relation: string, callback?: (query: QueryBuilder) => void): this;
   doesntHave(relation: string): this;
   whereDoesntHave(relation: string, callback?: (query: QueryBuilder) => void): this;
+  has(relation: string, operator?: '=' | '!=' | '<' | '<=' | '>' | '>=', count?: number): this;
 
   // Execution methods
   get(): Promise<Collection<Model>>;

package/orm/QueryBuilder.js

@@ -227,7 +227,32 @@ class QueryBuilder {
   }
 
   addSelect(...columns) {
-    this.query.column(...columns);
+    for (const col of columns) {
+      if (col && typeof col === 'object' && !Array.isArray(col)) {
+        // Subquery form: addSelect({ alias: (qb) => qb.from('table').select('col').where(...) })
+        for (const [alias, subFn] of Object.entries(col)) {
+          const knex = Database.connection(this.connectionName);
+          const subQuery = knex.queryBuilder();
+          const subQb = new QueryBuilder('', null, this.connectionName);
+          subQb.query = subQuery;
+          subFn(subQb);
+          this.query.column(knex.raw(`(${subQuery.toSQL().sql}) as "${alias}"`, subQuery.toSQL().bindings));
+        }
+      } else {
+        this.query.column(col);
+      }
+    }
+    return this;
+  }
+
+  orderBySubquery(callback, direction = 'asc') {
+    const knex = Database.connection(this.connectionName);
+    const subQuery = knex.queryBuilder();
+    const subQb = new QueryBuilder('', null, this.connectionName);
+    subQb.query = subQuery;
+    callback(subQb);
+    const { sql, bindings } = subQuery.toSQL();
+    this.query.orderByRaw(`(${sql}) ${direction === 'desc' ? 'desc' : 'asc'}`, bindings);
     return this;
   }
 
@@ -250,6 +275,23 @@ class QueryBuilder {
     return this;
   }
 
+  withPendingAttributes(attrs) {
+    this._pendingAttributes = { ...(this._pendingAttributes || {}), ...attrs };
+    return this;
+  }
+
+  async new(attrs = {}) {
+    const merged = { ...(this._pendingAttributes || {}), ...attrs };
+    const inst = new this.modelClass(merged);
+    inst._initialize();
+    return inst;
+  }
+
+  async create(attrs = {}) {
+    const merged = { ...(this._pendingAttributes || {}), ...attrs };
+    return this.modelClass.create(merged);
+  }
+
   when(condition, callback, otherwise) {
     if (condition) {
       callback(this, condition);
@@ -549,6 +591,37 @@ class QueryBuilder {
     return this.whereDoesntHave(relation);
   }
 
+  has(relation, operator = '>=', count = 1) {
+    if (!this.modelClass) return this;
+    try {
+      const dummy = this._makeDummy();
+      const relFn = this.modelClass.prototype[relation];
+      if (typeof relFn !== 'function') return this;
+      const rel = relFn.call(dummy);
+      const relatedClass = rel.getRelatedClass();
+      const relatedTable = relatedClass.getTableName();
+      const parentTable = this.modelClass.getTableName();
+      const isBelongsTo = rel.constructor.name === 'BelongsTo';
+      const joinCol = isBelongsTo
+        ? `${relatedTable}.${rel.localKey || relatedClass.getPrimaryKey()} = ${parentTable}.${rel.foreignKey}`
+        : `${relatedTable}.${rel.foreignKey} = ${parentTable}.${rel.localKey || this.modelClass.getPrimaryKey()}`;
+      const ops = ['=', '!=', '<', '<=', '>', '>='];
+      const safeOp = ops.includes(operator) ? operator : '>=';
+      const safeCount = parseInt(count, 10) || 1;
+      if (safeOp === '>=' && safeCount === 1) {
+        this.query.whereExists((builder) => {
+          builder.from(relatedTable).whereRaw(joinCol);
+        });
+      } else {
+        this.query.whereRaw(
+          `(select count(*) from ?? where ${joinCol}) ${safeOp} ?`,
+          [relatedTable, safeCount]
+        );
+      }
+    } catch (_) {}
+    return this;
+  }
+
   _makeDummy() {
     const dummy = Object.create(this.modelClass.prototype);
     dummy.attributes = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ilana-orm",
-  "version": "1.0.18",
+  "version": "1.0.19",
   "description": "A fully-featured, Eloquent-style ORM for Node.js with TypeScript support",
   "main": "index.js",
   "types": "index.d.ts",
@@ -10,6 +10,11 @@
       "require": "./index.js",
       "types": "./index.d.ts"
     },
+    "./edge": {
+      "import": "./index.edge.mjs",
+      "require": "./index.edge.js",
+      "types": "./index.d.ts"
+    },
     "./orm/Model": {
       "import": "./orm/Model.mjs",
       "require": "./orm/Model.js",