@objectstack/driver-sql 3.2.9

package/dist/index.mjs

@@ -0,0 +1,1007 @@
+// src/sql-driver.ts
+import knex from "knex";
+import { nanoid } from "nanoid";
+var DEFAULT_ID_LENGTH = 16;
+var SqlDriver = class {
+  constructor(config) {
+    // DriverInterface metadata
+    this.name = "com.objectstack.driver.sql";
+    this.version = "1.0.0";
+    this.supports = {
+      transactions: true,
+      joins: true,
+      fullTextSearch: false,
+      jsonFields: true,
+      arrayFields: true,
+      queryFilters: true,
+      queryAggregations: true,
+      querySorting: true,
+      queryPagination: true,
+      queryWindowFunctions: true,
+      querySubqueries: true
+    };
+    this.jsonFields = {};
+    this.booleanFields = {};
+    this.tablesWithTimestamps = /* @__PURE__ */ new Set();
+    this.config = config;
+    this.knex = knex(config);
+  }
+  /** Whether the underlying database is a SQLite variant (sqlite3 or better-sqlite3). */
+  get isSqlite() {
+    const c = this.config.client;
+    return c === "sqlite3" || c === "better-sqlite3";
+  }
+  /** Whether the underlying database is PostgreSQL. */
+  get isPostgres() {
+    const c = this.config.client;
+    return c === "pg" || c === "postgresql";
+  }
+  /** Whether the underlying database is MySQL. */
+  get isMysql() {
+    const c = this.config.client;
+    return c === "mysql" || c === "mysql2";
+  }
+  // ===================================
+  // Lifecycle
+  // ===================================
+  async connect() {
+    return Promise.resolve();
+  }
+  async checkHealth() {
+    try {
+      await this.knex.raw("SELECT 1");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async disconnect() {
+    await this.knex.destroy();
+  }
+  // ===================================
+  // CRUD — DriverInterface core
+  // ===================================
+  async find(object, query, options) {
+    const builder = this.getBuilder(object, options);
+    if (query.fields) {
+      builder.select(query.fields.map((f) => this.mapSortField(f)));
+    } else {
+      builder.select("*");
+    }
+    const filterCondition = query.where || query.filters;
+    if (filterCondition) {
+      this.applyFilters(builder, filterCondition);
+    }
+    const sortArray = query.orderBy || query.sort;
+    if (sortArray && Array.isArray(sortArray)) {
+      for (const item of sortArray) {
+        const field = item.field || item[0];
+        const dir = item.order || item[1] || "asc";
+        if (field) {
+          builder.orderBy(this.mapSortField(field), dir);
+        }
+      }
+    }
+    const offsetValue = query.offset ?? query.skip;
+    const limitValue = query.limit ?? query.top;
+    if (offsetValue !== void 0) builder.offset(offsetValue);
+    if (limitValue !== void 0) builder.limit(limitValue);
+    let results;
+    try {
+      results = await builder;
+    } catch (error) {
+      if (error.message && (error.message.includes("no such column") || error.message.includes("column") && error.message.includes("does not exist"))) {
+        return [];
+      }
+      throw error;
+    }
+    if (!Array.isArray(results)) {
+      return [];
+    }
+    if (this.isSqlite) {
+      for (const row of results) {
+        this.formatOutput(object, row);
+      }
+    }
+    return results;
+  }
+  async findOne(object, query, options) {
+    if (typeof query === "string" || typeof query === "number") {
+      const res = await this.getBuilder(object, options).where("id", query).first();
+      return this.formatOutput(object, res) || null;
+    }
+    if (query && typeof query === "object") {
+      const results = await this.find(object, { ...query, limit: 1 }, options);
+      return results[0] || null;
+    }
+    return null;
+  }
+  async create(object, data, options) {
+    const { _id, ...rest } = data;
+    const toInsert = { ...rest };
+    if (_id !== void 0 && toInsert.id === void 0) {
+      toInsert.id = _id;
+    } else if (toInsert.id === void 0) {
+      toInsert.id = nanoid(DEFAULT_ID_LENGTH);
+    }
+    const builder = this.getBuilder(object, options);
+    const formatted = this.formatInput(object, toInsert);
+    const result = await builder.insert(formatted).returning("*");
+    return this.formatOutput(object, result[0]);
+  }
+  async update(object, id, data, options) {
+    const builder = this.getBuilder(object, options);
+    const formatted = this.formatInput(object, data);
+    if (this.tablesWithTimestamps.has(object)) {
+      if (this.isSqlite) {
+        const now = /* @__PURE__ */ new Date();
+        formatted.updated_at = now.toISOString().replace("T", " ").replace("Z", "");
+      } else {
+        formatted.updated_at = this.knex.fn.now();
+      }
+    }
+    await builder.where("id", id).update(formatted);
+    const updated = await this.getBuilder(object, options).where("id", id).first();
+    return this.formatOutput(object, updated) || null;
+  }
+  async delete(object, id, options) {
+    const builder = this.getBuilder(object, options);
+    return await builder.where("id", id).delete();
+  }
+  // ===================================
+  // Optional — bulk & batch
+  // ===================================
+  async bulkCreate(object, data, options) {
+    const builder = this.getBuilder(object, options);
+    return await builder.insert(data).returning("*");
+  }
+  async updateMany(object, query, data, options) {
+    const builder = this.getBuilder(object, options);
+    const filters = query.where || query.filters || query;
+    if (filters) this.applyFilters(builder, filters);
+    const count = await builder.update(data);
+    return { modifiedCount: count || 0 };
+  }
+  async deleteMany(object, query, options) {
+    const builder = this.getBuilder(object, options);
+    const filters = query.where || query.filters || query;
+    if (filters) this.applyFilters(builder, filters);
+    const count = await builder.delete();
+    return { deletedCount: count || 0 };
+  }
+  async count(object, query, options) {
+    const builder = this.getBuilder(object, options);
+    let actualFilters = query;
+    if (query && (query.where || query.filters)) {
+      actualFilters = query.where || query.filters;
+    }
+    if (actualFilters) {
+      this.applyFilters(builder, actualFilters);
+    }
+    const result = await builder.count("* as count");
+    if (result && result.length > 0) {
+      const row = result[0];
+      return Number(row.count || row["count(*)"]);
+    }
+    return 0;
+  }
+  // ===================================
+  // Raw Execution
+  // ===================================
+  async execute(command, params, options) {
+    if (typeof command !== "string") {
+      return command;
+    }
+    const builder = options?.transaction ? this.knex.raw(command, params || []).transacting(options.transaction) : this.knex.raw(command, params || []);
+    return await builder;
+  }
+  // ===================================
+  // Transactions
+  // ===================================
+  async beginTransaction() {
+    return await this.knex.transaction();
+  }
+  async commitTransaction(trx) {
+    await trx.commit();
+  }
+  async rollbackTransaction(trx) {
+    await trx.rollback();
+  }
+  // ===================================
+  // Aggregation
+  // ===================================
+  async aggregate(object, query, options) {
+    const builder = this.getBuilder(object, options);
+    if (query.where) {
+      this.applyFilters(builder, query.where);
+    }
+    if (query.groupBy) {
+      builder.groupBy(query.groupBy);
+      for (const field of query.groupBy) {
+        builder.select(field);
+      }
+    }
+    const aggregates = query.aggregations || query.aggregate;
+    if (aggregates) {
+      for (const agg of aggregates) {
+        const funcName = agg.function || agg.func;
+        const rawFunc = this.mapAggregateFunc(funcName);
+        if (agg.alias) {
+          builder.select(this.knex.raw(`${rawFunc}(??) as ??`, [agg.field, agg.alias]));
+        } else {
+          builder.select(this.knex.raw(`${rawFunc}(??)`, [agg.field]));
+        }
+      }
+    }
+    return await builder;
+  }
+  // ===================================
+  // Distinct
+  // ===================================
+  async distinct(object, field, filters, options) {
+    const builder = this.getBuilder(object, options);
+    if (filters) {
+      this.applyFilters(builder, filters);
+    }
+    builder.distinct(field);
+    const results = await builder;
+    return results.map((row) => row[field]);
+  }
+  // ===================================
+  // Window Functions
+  // ===================================
+  async findWithWindowFunctions(object, query, options) {
+    const builder = this.getBuilder(object, options);
+    builder.select("*");
+    if (query.where) {
+      this.applyFilters(builder, query.where);
+    }
+    if (query.windowFunctions && Array.isArray(query.windowFunctions)) {
+      for (const wf of query.windowFunctions) {
+        const windowFunc = this.buildWindowFunction(wf);
+        builder.select(this.knex.raw(`${windowFunc} as ??`, [wf.alias]));
+      }
+    }
+    if (query.orderBy && Array.isArray(query.orderBy)) {
+      for (const sort of query.orderBy) {
+        builder.orderBy(this.mapSortField(sort.field), sort.order || "asc");
+      }
+    }
+    if (query.limit) builder.limit(query.limit);
+    if (query.offset) builder.offset(query.offset);
+    return await builder;
+  }
+  // ===================================
+  // Query Plan Analysis
+  // ===================================
+  async analyzeQuery(object, query, options) {
+    const builder = this.getBuilder(object, options);
+    if (query.fields) {
+      builder.select(query.fields);
+    } else {
+      builder.select("*");
+    }
+    if (query.where) {
+      this.applyFilters(builder, query.where);
+    }
+    if (query.orderBy && Array.isArray(query.orderBy)) {
+      for (const sort of query.orderBy) {
+        builder.orderBy(this.mapSortField(sort.field), sort.order || "asc");
+      }
+    }
+    if (query.limit) builder.limit(query.limit);
+    if (query.offset) builder.offset(query.offset);
+    const sql = builder.toSQL();
+    const client = this.config.client;
+    let explainResults;
+    try {
+      if (this.isPostgres) {
+        explainResults = await this.knex.raw(`EXPLAIN (FORMAT JSON, ANALYZE) ${sql.sql}`, sql.bindings);
+      } else if (this.isMysql) {
+        explainResults = await this.knex.raw(`EXPLAIN FORMAT=JSON ${sql.sql}`, sql.bindings);
+      } else if (this.isSqlite) {
+        explainResults = await this.knex.raw(`EXPLAIN QUERY PLAN ${sql.sql}`, sql.bindings);
+      } else {
+        return {
+          sql: sql.sql,
+          bindings: sql.bindings,
+          client,
+          note: "EXPLAIN not supported for this database client"
+        };
+      }
+      return { sql: sql.sql, bindings: sql.bindings, client, plan: explainResults };
+    } catch (error) {
+      return {
+        sql: sql.sql,
+        bindings: sql.bindings,
+        client,
+        error: error.message,
+        note: "Failed to execute EXPLAIN."
+      };
+    }
+  }
+  // ===================================
+  // Schema Sync (syncSchema / init)
+  // ===================================
+  async syncSchema(object, schema, _options) {
+    const objectDef = schema;
+    await this.initObjects([objectDef]);
+  }
+  /**
+   * Batch-initialise tables from an array of object definitions.
+   */
+  async initObjects(objects) {
+    await this.ensureDatabaseExists();
+    for (const obj of objects) {
+      const tableName = obj.name;
+      const jsonCols = [];
+      const booleanCols = [];
+      if (obj.fields) {
+        for (const [name, field] of Object.entries(obj.fields)) {
+          const type = field.type || "string";
+          if (this.isJsonField(type, field)) {
+            jsonCols.push(name);
+          }
+          if (type === "boolean") {
+            booleanCols.push(name);
+          }
+        }
+      }
+      this.jsonFields[tableName] = jsonCols;
+      this.booleanFields[tableName] = booleanCols;
+      let exists = await this.knex.schema.hasTable(tableName);
+      if (exists) {
+        const columnInfo = await this.knex(tableName).columnInfo();
+        const existingColumns = Object.keys(columnInfo);
+        if (existingColumns.includes("_id") && !existingColumns.includes("id")) {
+          await this.knex.schema.dropTable(tableName);
+          exists = false;
+        }
+      }
+      if (!exists) {
+        await this.knex.schema.createTable(tableName, (table) => {
+          table.string("id").primary();
+          table.timestamp("created_at").defaultTo(this.knex.fn.now());
+          table.timestamp("updated_at").defaultTo(this.knex.fn.now());
+          if (obj.fields) {
+            for (const [name, field] of Object.entries(obj.fields)) {
+              this.createColumn(table, name, field);
+            }
+          }
+        });
+        this.tablesWithTimestamps.add(tableName);
+      } else {
+        const columnInfo = await this.knex(tableName).columnInfo();
+        const existingColumns = Object.keys(columnInfo);
+        if (existingColumns.includes("updated_at")) {
+          this.tablesWithTimestamps.add(tableName);
+        }
+        await this.knex.schema.alterTable(tableName, (table) => {
+          if (obj.fields) {
+            for (const [name, field] of Object.entries(obj.fields)) {
+              if (!existingColumns.includes(name)) {
+                this.createColumn(table, name, field);
+              }
+            }
+          }
+        });
+      }
+    }
+  }
+  // ===================================
+  // Schema Introspection
+  // ===================================
+  async introspectSchema() {
+    const tables = {};
+    let tableNames = [];
+    if (this.isPostgres) {
+      const result = await this.knex.raw(`
+        SELECT table_name
+        FROM information_schema.tables
+        WHERE table_schema = 'public'
+        AND table_type = 'BASE TABLE'
+      `);
+      tableNames = result.rows.map((row) => row.table_name);
+    } else if (this.isMysql) {
+      const result = await this.knex.raw(`
+        SELECT table_name
+        FROM information_schema.tables
+        WHERE table_schema = DATABASE()
+        AND table_type = 'BASE TABLE'
+      `);
+      tableNames = result[0].map((row) => row.TABLE_NAME);
+    } else if (this.isSqlite) {
+      const result = await this.knex.raw(`
+        SELECT name as table_name
+        FROM sqlite_master
+        WHERE type='table'
+        AND name NOT LIKE 'sqlite_%'
+      `);
+      tableNames = result.map((row) => row.table_name);
+    }
+    for (const tableName of tableNames) {
+      const columns = await this.introspectColumns(tableName);
+      const foreignKeys = await this.introspectForeignKeys(tableName);
+      const primaryKeys = await this.introspectPrimaryKeys(tableName);
+      const uniqueConstraints = await this.introspectUniqueConstraints(tableName);
+      for (const col of columns) {
+        if (primaryKeys.includes(col.name)) col.isPrimary = true;
+        if (uniqueConstraints.includes(col.name)) col.isUnique = true;
+      }
+      tables[tableName] = { name: tableName, columns, foreignKeys, primaryKeys };
+    }
+    return { tables };
+  }
+  // ===================================
+  // Internal helpers
+  // ===================================
+  /** Expose the underlying Knex instance for advanced usage. */
+  getKnex() {
+    return this.knex;
+  }
+  getBuilder(object, options) {
+    let builder = this.knex(object);
+    if (options?.transaction) {
+      builder = builder.transacting(options.transaction);
+    }
+    return builder;
+  }
+  // ── Filter helpers ──────────────────────────────────────────────────────────
+  applyFilters(builder, filters) {
+    if (!filters) return;
+    if (!Array.isArray(filters) && typeof filters === "object") {
+      const hasMongoOperators = Object.keys(filters).some(
+        (k) => k.startsWith("$") || typeof filters[k] === "object" && filters[k] !== null && Object.keys(filters[k]).some((op) => op.startsWith("$"))
+      );
+      if (hasMongoOperators) {
+        this.applyFilterCondition(builder, filters);
+        return;
+      }
+      for (const [key, value] of Object.entries(filters)) {
+        if (["filters", "sort", "limit", "skip", "offset", "fields", "orderBy"].includes(key)) continue;
+        builder.where(key, value);
+      }
+      return;
+    }
+    if (!Array.isArray(filters) || filters.length === 0) return;
+    let nextJoin = "and";
+    for (const item of filters) {
+      if (typeof item === "string") {
+        if (item.toLowerCase() === "or") nextJoin = "or";
+        else if (item.toLowerCase() === "and") nextJoin = "and";
+        continue;
+      }
+      if (Array.isArray(item)) {
+        const [fieldRaw, op, value] = item;
+        const isCriterion = typeof fieldRaw === "string" && typeof op === "string";
+        if (isCriterion) {
+          const field = this.mapSortField(fieldRaw);
+          const apply = (b) => {
+            const method = nextJoin === "or" ? "orWhere" : "where";
+            const methodIn = nextJoin === "or" ? "orWhereIn" : "whereIn";
+            const methodNotIn = nextJoin === "or" ? "orWhereNotIn" : "whereNotIn";
+            if (op === "contains") {
+              b[method](field, "like", `%${value}%`);
+              return;
+            }
+            switch (op) {
+              case "=":
+                b[method](field, value);
+                break;
+              case "!=":
+                b[method](field, "<>", value);
+                break;
+              case "in":
+                b[methodIn](field, value);
+                break;
+              case "nin":
+                b[methodNotIn](field, value);
+                break;
+              default:
+                b[method](field, op, value);
+            }
+          };
+          apply(builder);
+        } else {
+          const method = nextJoin === "or" ? "orWhere" : "where";
+          builder[method]((qb) => {
+            this.applyFilters(qb, item);
+          });
+        }
+        nextJoin = "and";
+      }
+    }
+  }
+  applyFilterCondition(builder, condition, logicalOp = "and") {
+    if (!condition || typeof condition !== "object") return;
+    for (const [key, value] of Object.entries(condition)) {
+      if (key === "$and" && Array.isArray(value)) {
+        builder.where((qb) => {
+          for (const sub of value) {
+            qb.where((subQb) => {
+              this.applyFilterCondition(subQb, sub, "and");
+            });
+          }
+        });
+      } else if (key === "$or" && Array.isArray(value)) {
+        const method = logicalOp === "or" ? "orWhere" : "where";
+        builder[method]((qb) => {
+          for (const sub of value) {
+            qb.orWhere((subQb) => {
+              this.applyFilterCondition(subQb, sub, "or");
+            });
+          }
+        });
+      } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        const field = this.mapSortField(key);
+        for (const [op, opValue] of Object.entries(value)) {
+          const method = logicalOp === "or" ? "orWhere" : "where";
+          switch (op) {
+            case "$eq":
+              builder[method](field, opValue);
+              break;
+            case "$ne":
+              builder[method](field, "<>", opValue);
+              break;
+            case "$gt":
+              builder[method](field, ">", opValue);
+              break;
+            case "$gte":
+              builder[method](field, ">=", opValue);
+              break;
+            case "$lt":
+              builder[method](field, "<", opValue);
+              break;
+            case "$lte":
+              builder[method](field, "<=", opValue);
+              break;
+            case "$in": {
+              const mIn = logicalOp === "or" ? "orWhereIn" : "whereIn";
+              builder[mIn](field, opValue);
+              break;
+            }
+            case "$nin": {
+              const mNotIn = logicalOp === "or" ? "orWhereNotIn" : "whereNotIn";
+              builder[mNotIn](field, opValue);
+              break;
+            }
+            case "$contains":
+              builder[method](field, "like", `%${opValue}%`);
+              break;
+            default:
+              builder[method](field, opValue);
+          }
+        }
+      } else {
+        const field = this.mapSortField(key);
+        const method = logicalOp === "or" ? "orWhere" : "where";
+        builder[method](field, value);
+      }
+    }
+  }
+  // ── Field mapping ───────────────────────────────────────────────────────────
+  mapSortField(field) {
+    if (field === "createdAt") return "created_at";
+    if (field === "updatedAt") return "updated_at";
+    return field;
+  }
+  mapAggregateFunc(func) {
+    switch (func) {
+      case "count":
+        return "count";
+      case "sum":
+        return "sum";
+      case "avg":
+        return "avg";
+      case "min":
+        return "min";
+      case "max":
+        return "max";
+      default:
+        throw new Error(`Unsupported aggregate function: ${func}`);
+    }
+  }
+  // ── Window function builder ─────────────────────────────────────────────────
+  buildWindowFunction(spec) {
+    const func = spec.function.toUpperCase();
+    let sql = `${func}()`;
+    const overParts = [];
+    if (spec.partitionBy && Array.isArray(spec.partitionBy) && spec.partitionBy.length > 0) {
+      const partitionFields = spec.partitionBy.map((f) => this.mapSortField(f)).join(", ");
+      overParts.push(`PARTITION BY ${partitionFields}`);
+    }
+    if (spec.orderBy && Array.isArray(spec.orderBy) && spec.orderBy.length > 0) {
+      const orderFields = spec.orderBy.map((s) => {
+        const field = this.mapSortField(s.field);
+        const order = (s.order || "asc").toUpperCase();
+        return `${field} ${order}`;
+      }).join(", ");
+      overParts.push(`ORDER BY ${orderFields}`);
+    }
+    sql += overParts.length > 0 ? ` OVER (${overParts.join(" ")})` : ` OVER ()`;
+    return sql;
+  }
+  // ── Column creation helper ──────────────────────────────────────────────────
+  createColumn(table, name, field) {
+    if (field.multiple) {
+      table.json(name);
+      return;
+    }
+    const type = field.type || "string";
+    let col;
+    switch (type) {
+      case "string":
+      case "email":
+      case "url":
+      case "phone":
+      case "password":
+        col = table.string(name);
+        break;
+      case "text":
+      case "textarea":
+      case "html":
+      case "markdown":
+        col = table.text(name);
+        break;
+      case "integer":
+      case "int":
+        col = table.integer(name);
+        break;
+      case "float":
+      case "number":
+      case "currency":
+      case "percent":
+        col = table.float(name);
+        break;
+      case "boolean":
+        col = table.boolean(name);
+        break;
+      case "date":
+        col = table.date(name);
+        break;
+      case "datetime":
+        col = table.timestamp(name);
+        break;
+      case "time":
+        col = table.time(name);
+        break;
+      case "json":
+      case "object":
+      case "array":
+      case "image":
+      case "file":
+      case "avatar":
+      case "location":
+        col = table.json(name);
+        break;
+      case "lookup":
+        col = table.string(name);
+        if (field.reference_to) {
+          table.foreign(name).references("id").inTable(field.reference_to);
+        }
+        break;
+      case "summary":
+        col = table.float(name);
+        break;
+      case "auto_number":
+        col = table.string(name);
+        break;
+      case "formula":
+        return;
+      // Virtual — no column
+      default:
+        col = table.string(name);
+    }
+    if (col) {
+      if (field.unique) col.unique();
+      if (field.required) col.notNullable();
+    }
+  }
+  // ── Database helpers ────────────────────────────────────────────────────────
+  async ensureDatabaseExists() {
+    if (!this.isPostgres) return;
+    try {
+      await this.knex.raw("SELECT 1");
+    } catch (e) {
+      if (e.code === "3D000") {
+        await this.createDatabase();
+      } else {
+        throw e;
+      }
+    }
+  }
+  async createDatabase() {
+    const config = this.config;
+    const connection = config.connection;
+    let dbName = "";
+    const adminConfig = { ...config };
+    if (typeof connection === "string") {
+      const url = new URL(connection);
+      dbName = url.pathname.slice(1);
+      url.pathname = "/postgres";
+      adminConfig.connection = url.toString();
+    } else {
+      dbName = connection.database;
+      adminConfig.connection = { ...connection, database: "postgres" };
+    }
+    const adminKnex = knex(adminConfig);
+    try {
+      await adminKnex.raw(`CREATE DATABASE "${dbName}"`);
+    } finally {
+      await adminKnex.destroy();
+    }
+  }
+  isJsonField(type, field) {
+    return ["json", "object", "array", "image", "file", "avatar", "location"].includes(type) || field.multiple;
+  }
+  // ── SQLite serialisation ────────────────────────────────────────────────────
+  formatInput(object, data) {
+    if (!this.isSqlite) return data;
+    const fields = this.jsonFields[object];
+    if (!fields || fields.length === 0) return data;
+    const copy = { ...data };
+    for (const field of fields) {
+      if (copy[field] !== void 0 && typeof copy[field] === "object" && copy[field] !== null) {
+        copy[field] = JSON.stringify(copy[field]);
+      }
+    }
+    return copy;
+  }
+  formatOutput(object, data) {
+    if (!data) return data;
+    if (this.isSqlite) {
+      const jsonFields = this.jsonFields[object];
+      if (jsonFields && jsonFields.length > 0) {
+        for (const field of jsonFields) {
+          if (data[field] !== void 0 && typeof data[field] === "string") {
+            try {
+              data[field] = JSON.parse(data[field]);
+            } catch {
+            }
+          }
+        }
+      }
+      const booleanFields = this.booleanFields[object];
+      if (booleanFields && booleanFields.length > 0) {
+        for (const field of booleanFields) {
+          if (data[field] !== void 0 && data[field] !== null) {
+            data[field] = Boolean(data[field]);
+          }
+        }
+      }
+    }
+    return data;
+  }
+  // ── Introspection internals ─────────────────────────────────────────────────
+  async introspectColumns(tableName) {
+    const columnInfo = await this.knex(tableName).columnInfo();
+    const columns = [];
+    for (const [colName, info] of Object.entries(columnInfo)) {
+      let type = "string";
+      let maxLength;
+      if (this.isSqlite) {
+        type = info.type?.toLowerCase() || "string";
+      } else {
+        type = info.type || "string";
+      }
+      if (info.maxLength) {
+        maxLength = info.maxLength;
+      }
+      columns.push({
+        name: colName,
+        type,
+        nullable: info.nullable !== false,
+        defaultValue: info.defaultValue,
+        isPrimary: false,
+        isUnique: false,
+        maxLength
+      });
+    }
+    return columns;
+  }
+  async introspectForeignKeys(tableName) {
+    const foreignKeys = [];
+    try {
+      if (this.isPostgres) {
+        const result = await this.knex.raw(
+          `
+          SELECT
+            kcu.column_name,
+            ccu.table_name AS referenced_table,
+            ccu.column_name AS referenced_column,
+            tc.constraint_name
+          FROM information_schema.table_constraints AS tc
+          JOIN information_schema.key_column_usage AS kcu
+            ON tc.constraint_name = kcu.constraint_name
+            AND tc.table_schema = kcu.table_schema
+          JOIN information_schema.constraint_column_usage AS ccu
+            ON ccu.constraint_name = tc.constraint_name
+            AND ccu.table_schema = tc.table_schema
+          WHERE tc.constraint_type = 'FOREIGN KEY'
+            AND tc.table_name = ?
+        `,
+          [tableName]
+        );
+        for (const row of result.rows) {
+          foreignKeys.push({
+            columnName: row.column_name,
+            referencedTable: row.referenced_table,
+            referencedColumn: row.referenced_column,
+            constraintName: row.constraint_name
+          });
+        }
+      } else if (this.isMysql) {
+        const result = await this.knex.raw(
+          `
+          SELECT
+            COLUMN_NAME as column_name,
+            REFERENCED_TABLE_NAME as referenced_table,
+            REFERENCED_COLUMN_NAME as referenced_column,
+            CONSTRAINT_NAME as constraint_name
+          FROM information_schema.KEY_COLUMN_USAGE
+          WHERE TABLE_SCHEMA = DATABASE()
+            AND TABLE_NAME = ?
+            AND REFERENCED_TABLE_NAME IS NOT NULL
+        `,
+          [tableName]
+        );
+        for (const row of result[0]) {
+          foreignKeys.push({
+            columnName: row.column_name,
+            referencedTable: row.referenced_table,
+            referencedColumn: row.referenced_column,
+            constraintName: row.constraint_name
+          });
+        }
+      } else if (this.isSqlite) {
+        const tableExistsResult = await this.knex.raw(
+          "SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?",
+          [tableName]
+        );
+        if (!Array.isArray(tableExistsResult) || tableExistsResult.length === 0) {
+          return foreignKeys;
+        }
+        const safeTableName = tableName.replace(/[^a-zA-Z0-9_]/g, "");
+        const result = await this.knex.raw(`PRAGMA foreign_key_list(${safeTableName})`);
+        for (const row of result) {
+          foreignKeys.push({
+            columnName: row.from,
+            referencedTable: row.table,
+            referencedColumn: row.to,
+            constraintName: `fk_${tableName}_${row.from}`
+          });
+        }
+      }
+    } catch {
+    }
+    return foreignKeys;
+  }
+  async introspectPrimaryKeys(tableName) {
+    const primaryKeys = [];
+    try {
+      if (this.isPostgres) {
+        const result = await this.knex.raw(
+          `
+          SELECT a.attname as column_name
+          FROM pg_index i
+          JOIN pg_attribute a ON a.attrelid = i.indrelid
+            AND a.attnum = ANY(i.indkey)
+          WHERE i.indrelid = ?::regclass
+            AND i.indisprimary
+        `,
+          [tableName]
+        );
+        for (const row of result.rows) {
+          primaryKeys.push(row.column_name);
+        }
+      } else if (this.isMysql) {
+        const result = await this.knex.raw(
+          `
+          SELECT COLUMN_NAME as column_name
+          FROM information_schema.KEY_COLUMN_USAGE
+          WHERE TABLE_SCHEMA = DATABASE()
+            AND TABLE_NAME = ?
+            AND CONSTRAINT_NAME = 'PRIMARY'
+        `,
+          [tableName]
+        );
+        for (const row of result[0]) {
+          primaryKeys.push(row.column_name);
+        }
+      } else if (this.isSqlite) {
+        const safeTableName = tableName.replace(/[^a-zA-Z0-9_]/g, "");
+        const tablesResult = await this.knex.raw("SELECT name FROM sqlite_master WHERE type = 'table'");
+        const tableNames = Array.isArray(tablesResult) ? tablesResult.map((row) => row.name) : [];
+        if (!tableNames.includes(safeTableName)) {
+          return primaryKeys;
+        }
+        const result = await this.knex.raw(`PRAGMA table_info(${safeTableName})`);
+        for (const row of result) {
+          if (row.pk === 1) {
+            primaryKeys.push(row.name);
+          }
+        }
+      }
+    } catch {
+    }
+    return primaryKeys;
+  }
+  async introspectUniqueConstraints(tableName) {
+    const uniqueColumns = [];
+    try {
+      if (this.isPostgres) {
+        const result = await this.knex.raw(
+          `
+          SELECT c.column_name
+          FROM information_schema.table_constraints tc
+          JOIN information_schema.constraint_column_usage AS ccu
+            ON tc.constraint_schema = ccu.constraint_schema
+            AND tc.constraint_name = ccu.constraint_name
+          WHERE tc.constraint_type = 'UNIQUE'
+            AND tc.table_name = ?
+        `,
+          [tableName]
+        );
+        for (const row of result.rows) {
+          uniqueColumns.push(row.column_name);
+        }
+      } else if (this.isMysql) {
+        const result = await this.knex.raw(
+          `
+          SELECT COLUMN_NAME
+          FROM information_schema.TABLE_CONSTRAINTS tc
+          JOIN information_schema.KEY_COLUMN_USAGE kcu
+            USING (CONSTRAINT_NAME, TABLE_SCHEMA, TABLE_NAME)
+          WHERE CONSTRAINT_TYPE = 'UNIQUE'
+            AND TABLE_SCHEMA = DATABASE()
+            AND TABLE_NAME = ?
+        `,
+          [tableName]
+        );
+        for (const row of result[0]) {
+          uniqueColumns.push(row.COLUMN_NAME);
+        }
+      } else if (this.isSqlite) {
+        const safeTableName = tableName.replace(/[^a-zA-Z0-9_]/g, "");
+        const tablesResult = await this.knex.raw("SELECT name FROM sqlite_master WHERE type = 'table'");
+        const tableNames = Array.isArray(tablesResult) ? tablesResult.map((row) => row.name) : [];
+        if (!tableNames.includes(safeTableName)) {
+          return uniqueColumns;
+        }
+        const indexes = await this.knex.raw(`PRAGMA index_list(${safeTableName})`);
+        for (const idx of indexes) {
+          if (idx.unique === 1) {
+            const info = await this.knex.raw(`PRAGMA index_info(${idx.name})`);
+            if (info.length === 1) {
+              uniqueColumns.push(info[0].name);
+            }
+          }
+        }
+      }
+    } catch {
+    }
+    return uniqueColumns;
+  }
+};
+
+// src/index.ts
+var index_default = {
+  id: "com.objectstack.driver.sql",
+  version: "1.0.0",
+  onEnable: async (context) => {
+    const { logger, config, drivers } = context;
+    logger.info("[SQL Driver] Initializing...");
+    if (drivers) {
+      const driver = new SqlDriver(config);
+      drivers.register(driver);
+      logger.info(`[SQL Driver] Registered driver: ${driver.name}`);
+    } else {
+      logger.warn("[SQL Driver] No driver registry found in context.");
+    }
+  }
+};
+export {
+  SqlDriver,
+  index_default as default
+};
+//# sourceMappingURL=index.mjs.map