ilana-orm 1.0.17 → 1.0.19

package/orm/Factory.js

@@ -14,6 +14,9 @@ class Factory {
     this.count = 1;
     this.currentStates = [];
     this.relationships = new Map();
+    this._has = new Map();
+    this._for = new Map();
+    this._hasAttached = new Map();
     this._sequenceCount = 0;
     this.sequences = new Map();
   }
@@ -57,23 +60,30 @@ class Factory {
     return this;
   }
 
-  for(relation, factory) {
-    this.relationships.set(relation, factory);
+  for(relation, relFactory) {
+    this._for.set(relation, relFactory);
     return this;
   }
 
-  has(factory, relation) {
-    if (relation) {
-      this.relationships.set(relation, factory);
-    }
+  has(relFactory, relation) {
+    this._has.set(relation, relFactory);
     return this;
   }
 
-  hasAttached(factory, relation) {
-    this.relationships.set(relation, factory);
+  hasAttached(relFactory, relation) {
+    this._hasAttached.set(relation, relFactory);
     return this;
   }
 
+  _getRelation(relationName) {
+    try {
+      const dummy = new this.model({});
+      return typeof dummy[relationName] === 'function' ? dummy[relationName]() : null;
+    } catch (_) {
+      return null;
+    }
+  }
+
   sequence() {
     return ++this._sequenceCount;
   }
@@ -173,16 +183,40 @@ class Factory {
   }
 
   async createOne(attributes = {}) {
-    const model = await this.makeOne(attributes);
-    
-    // Run beforeCreating callbacks
+    // Handle 'for' (belongsTo) — create parent first, inject FK into this model
+    const parentAttrs = {};
+    for (const [relationName, relFactory] of this._for) {
+      const parent = await relFactory.createOne({});
+      const rel = this._getRelation(relationName);
+      if (rel && rel.foreignKey) parentAttrs[rel.foreignKey] = parent.getKey();
+    }
+
+    const model = await this.makeOne({ ...parentAttrs, ...attributes });
+
     for (const callback of this._beforeCreatingCallbacks) {
       await callback(model);
     }
 
     await model.save();
 
-    // Run afterCreating callbacks
+    // Handle 'has' (hasMany) — create children with FK pointing to this model
+    for (const [relationName, relFactory] of this._has) {
+      const rel = this._getRelation(relationName);
+      if (rel && rel.foreignKey) {
+        await relFactory.create({ [rel.foreignKey]: model.getKey() });
+      }
+    }
+
+    // Handle 'hasAttached' (belongsToMany) — create and attach via pivot
+    for (const [relationName, relFactory] of this._hasAttached) {
+      const related = await relFactory.create({});
+      const relatedArr = Array.isArray(related) ? related : [related];
+      const rel = this._getRelation(relationName);
+      if (rel && typeof rel.attach === 'function') {
+        for (const r of relatedArr) await rel.attach(r.getKey());
+      }
+    }
+
     for (const callback of this._afterCreatingCallbacks) {
       await callback(model);
     }
@@ -354,6 +388,9 @@ if (typeof Model !== 'undefined') {
       newFactory.states = new Map(existingFactory.states);
       newFactory._afterCreatingCallbacks = [...existingFactory._afterCreatingCallbacks];
       newFactory._beforeCreatingCallbacks = [...existingFactory._beforeCreatingCallbacks];
+      newFactory._has = new Map(existingFactory._has);
+      newFactory._for = new Map(existingFactory._for);
+      newFactory._hasAttached = new Map(existingFactory._hasAttached);
       return newFactory;
     }
     throw new Error(`No factory defined for model: ${this.name}`);

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;
@@ -50,6 +50,12 @@ export default class Model<TAttributes extends ModelAttributes = ModelAttributes
   protected static globalScopes: Map<string, (query: QueryBuilder) => void>;
   protected static appends: string[];
   protected static timezone: string;
+  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;
@@ -83,13 +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>;
@@ -143,10 +161,16 @@ export default class Model<TAttributes extends ModelAttributes = ModelAttributes
   getDirty(): ModelAttributes;
   delete(): Promise<boolean>;
   restore(): Promise<boolean>;
+  increment(column: string, amount?: number): Promise<this>;
+  decrement(column: string, amount?: number): Promise<this>;
   trashed(): boolean;
   only(keys: string[]): ModelAttributes;
   except(keys: string[]): 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 ---
@@ -35,6 +37,11 @@ class Model {
   static globalScopes = new Map();
   static appends = [];
   static timezone = 'UTC';
+  static strictLoading = false;
+  static touches = [];
+  static enums = {};
+  static embeddingColumn = 'embedding';
+  static embeddingDimensions = 1536;
 
   // --- Instance props ---
   attributes = {};
@@ -62,6 +69,25 @@ class Model {
       ? this.appends
       : this.constructor.appends;
 
+    // Wrap relations in a Proxy for strict loading enforcement
+    const modelClass = this.constructor;
+    this.relations = new Proxy({}, {
+      get(target, key) {
+        if (typeof key !== 'string') return target[key];
+        if (modelClass.strictLoading && !(key in target)) {
+          throw new Error(
+            `Strict loading violation: '${key}' was not eager loaded on ${modelClass.name}. ` +
+            `Use .with('${key}') in your query.`
+          );
+        }
+        return target[key];
+      },
+      set(target, key, value) { target[key] = value; return true; },
+      has(target, key) { return key in target; },
+      ownKeys(target) { return Object.keys(target); },
+      getOwnPropertyDescriptor(target, key) { return Object.getOwnPropertyDescriptor(target, key); },
+    });
+
     // defer attribute setting
     if (attrs && Object.keys(attrs).length) this._deferred = attrs;
 
@@ -79,6 +105,7 @@ class Model {
     this._deferred = null;
     // Recreate getters after initialization
     this._createAttributeGetters();
+    this._generateEnumHelpers();
   }
 
   _createAttributeGetters() {
@@ -106,6 +133,26 @@ class Model {
     }
   }
 
+  _generateEnumHelpers() {
+    const enums = this.constructor.enums || {};
+    for (const [column, values] of Object.entries(enums)) {
+      for (const value of values) {
+        const pascal = value.charAt(0).toUpperCase() + value.slice(1);
+        const isMethod = `is${pascal}`;
+        const makeMethod = `make${pascal}`;
+        if (!this[isMethod]) {
+          this[isMethod] = () => this.getAttribute(column) === value;
+        }
+        if (!this[makeMethod]) {
+          this[makeMethod] = async () => {
+            this.setAttribute(column, value);
+            return this.save();
+          };
+        }
+      }
+    }
+  }
+
   _toPascalCase(key) {
     return key.replace(/(^|_)([a-z])/g, (_, __, c) => c.toUpperCase());
   }
@@ -182,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());
@@ -190,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;
   }
@@ -209,7 +259,67 @@ 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();
+  }
   static async destroy(ids) {
     const idList = Array.isArray(ids) ? ids : [ids];
     if (this.softDeletes) {
@@ -293,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) {
@@ -301,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; }
@@ -483,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();
@@ -525,9 +662,27 @@ class Model {
       this.syncOriginal();
     }
 
+    await this._touchRelations();
+
     return true;
   }
 
+  async _touchRelations() {
+    const touches = this.constructor.touches || [];
+    for (const relName of touches) {
+      if (typeof this[relName] !== 'function') continue;
+      const rel = this[relName]();
+      if (!rel || rel.constructor.name !== 'BelongsTo') continue;
+      const parentClass = rel.getRelatedClass();
+      const parentId = this.getAttribute(rel.foreignKey);
+      if (!parentId) continue;
+      const col = parentClass.updatedAt || 'updated_at';
+      await parentClass.query()
+        .where(parentClass.primaryKey || 'id', parentId)
+        .update({ [col]: new Date() });
+    }
+  }
+
   async update(attributes = {}) {
     this.fill(attributes);
     return await this.save();
@@ -604,6 +759,20 @@ class Model {
     return result;
   }
 
+  async increment(column, amount = 1) {
+    await this.constructor.query().where(this.constructor.primaryKey, this.getKey()).increment(column, amount);
+    this.setAttribute(column, (this.getAttribute(column) || 0) + amount);
+    this.syncOriginal();
+    return this;
+  }
+
+  async decrement(column, amount = 1) {
+    await this.constructor.query().where(this.constructor.primaryKey, this.getKey()).decrement(column, amount);
+    this.setAttribute(column, (this.getAttribute(column) || 0) - amount);
+    this.syncOriginal();
+    return this;
+  }
+
   async forceDelete() {
     if (!this.exists) return false;
 
@@ -614,6 +783,37 @@ class Model {
     return true;
   }
 
+  async fresh() {
+    if (!this.exists) return null;
+    return this.constructor.find(this.getKey());
+  }
+
+  is(other) {
+    if (!other || !(other instanceof this.constructor)) return false;
+    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>>;
@@ -135,6 +145,8 @@ export default class QueryBuilder {
   pluck(column: string): Promise<any[]>;
   exists(): Promise<boolean>;
   doesntExist(): Promise<boolean>;
+  sole(): Promise<Model>;
+  tap(callback: (query: this) => void): this;
 
   // Pagination
   paginate(page?: number, perPage?: number): Promise<PaginationResult<Model>>;
@@ -150,6 +162,8 @@ export default class QueryBuilder {
   insert(data: any | any[]): Promise<any>;
   insertGetId(data: any): Promise<any>;
   update(data: any): Promise<number>;
+  increment(column: string, amount?: number): Promise<number>;
+  decrement(column: string, amount?: number): Promise<number>;
   delete(): Promise<number>;
   upsert(data: any[], uniqueBy: string[], update?: string[]): Promise<any>;
 
@@ -167,6 +181,10 @@ export default class QueryBuilder {
   withTrashed(): this;
   onlyTrashed(): this;
   withoutTrashed(): this;
+  restore(): Promise<number>;
+
+  // Plain object result (no model hydration)
+  values(): Promise<any[]>;
 
   // Debug
   toSql(): string;