@objectstack/driver-sql 3.2.9 → 3.3.0

package/dist/index.js

@@ -41,21 +41,47 @@ var import_nanoid = require("nanoid");
 var DEFAULT_ID_LENGTH = 16;
 var SqlDriver = class {
   constructor(config) {
-    // DriverInterface metadata
+    // IDataDriver metadata
     this.name = "com.objectstack.driver.sql";
     this.version = "1.0.0";
     this.supports = {
+      // Basic CRUD Operations
+      create: true,
+      read: true,
+      update: true,
+      delete: true,
+      // Bulk Operations
+      bulkCreate: true,
+      bulkUpdate: true,
+      bulkDelete: true,
+      // Transaction & Connection Management
       transactions: true,
-      joins: true,
-      fullTextSearch: false,
-      jsonFields: true,
-      arrayFields: true,
+      savepoints: false,
+      // Query Operations
       queryFilters: true,
       queryAggregations: true,
       querySorting: true,
       queryPagination: true,
       queryWindowFunctions: true,
-      querySubqueries: true
+      querySubqueries: true,
+      queryCTE: false,
+      joins: true,
+      // Advanced Features
+      fullTextSearch: false,
+      jsonQuery: false,
+      geospatialQuery: false,
+      streaming: false,
+      jsonFields: true,
+      arrayFields: true,
+      vectorSearch: false,
+      // Schema Management
+      schemaSync: true,
+      migrations: false,
+      indexes: false,
+      // Performance & Optimization
+      connectionPooling: true,
+      preparedStatements: true,
+      queryCache: false
     };
     this.jsonFields = {};
     this.booleanFields = {};
@@ -105,24 +131,18 @@ var SqlDriver = class {
     } else {
       builder.select("*");
     }
-    const filterCondition = query.where || query.filters;
-    if (filterCondition) {
-      this.applyFilters(builder, filterCondition);
+    if (query.where) {
+      this.applyFilters(builder, query.where);
     }
-    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);
+    if (query.orderBy && Array.isArray(query.orderBy)) {
+      for (const item of query.orderBy) {
+        if (item.field) {
+          builder.orderBy(this.mapSortField(item.field), item.order || "asc");
         }
       }
     }
-    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);
+    if (query.offset !== void 0) builder.offset(query.offset);
+    if (query.limit !== void 0) builder.limit(query.limit);
     let results;
     try {
       results = await builder;
@@ -153,6 +173,17 @@ var SqlDriver = class {
     }
     return null;
   }
+  /**
+   * Stream records matching a structured query.
+   * NOTE: Current implementation fetches all results then yields them.
+   * TODO: Use Knex .stream() for true cursor-based streaming on large datasets.
+   */
+  async *findStream(object, query, options) {
+    const results = await this.find(object, query, options);
+    for (const row of results) {
+      yield row;
+    }
+  }
   async create(object, data, options) {
     const { _id, ...rest } = data;
     const toInsert = { ...rest };
@@ -181,44 +212,71 @@ var SqlDriver = class {
     const updated = await this.getBuilder(object, options).where("id", id).first();
     return this.formatOutput(object, updated) || null;
   }
+  async upsert(object, data, conflictKeys, options) {
+    const { _id, ...rest } = data;
+    const toUpsert = { ...rest };
+    if (_id !== void 0 && toUpsert.id === void 0) {
+      toUpsert.id = _id;
+    } else if (toUpsert.id === void 0) {
+      toUpsert.id = (0, import_nanoid.nanoid)(DEFAULT_ID_LENGTH);
+    }
+    const formatted = this.formatInput(object, toUpsert);
+    const mergeKeys = conflictKeys && conflictKeys.length > 0 ? conflictKeys : ["id"];
+    const builder = this.getBuilder(object, options);
+    await builder.insert(formatted).onConflict(mergeKeys).merge();
+    const result = await this.getBuilder(object, options).where("id", toUpsert.id).first();
+    return this.formatOutput(object, result) || toUpsert;
+  }
   async delete(object, id, options) {
     const builder = this.getBuilder(object, options);
-    return await builder.where("id", id).delete();
+    const count = await builder.where("id", id).delete();
+    return count > 0;
   }
   // ===================================
-  // Optional — bulk & batch
+  // Bulk & Batch Operations
   // ===================================
   async bulkCreate(object, data, options) {
     const builder = this.getBuilder(object, options);
     return await builder.insert(data).returning("*");
   }
+  /**
+   * Batch-update multiple records by ID.
+   * NOTE: Current implementation performs sequential updates for correctness.
+   * TODO: Optimize with SQL CASE statements or batched transactions for performance.
+   */
+  async bulkUpdate(object, updates, options) {
+    const results = [];
+    for (const { id, data } of updates) {
+      const updated = await this.update(object, id, data, options);
+      if (updated) results.push(updated);
+    }
+    return results;
+  }
+  async bulkDelete(object, ids, options) {
+    const builder = this.getBuilder(object, options);
+    await builder.whereIn("id", ids).delete();
+  }
   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);
+    if (query.where) this.applyFilters(builder, query.where);
     const count = await builder.update(data);
-    return { modifiedCount: count || 0 };
+    return 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);
+    if (query.where) this.applyFilters(builder, query.where);
     const count = await builder.delete();
-    return { deletedCount: count || 0 };
+    return 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);
+    if (query?.where) {
+      this.applyFilters(builder, query.where);
     }
     const result = await builder.count("* as count");
     if (result && result.length > 0) {
       const row = result[0];
-      return Number(row.count || row["count(*)"]);
+      return Number(row.count ?? row["count(*)"] ?? 0);
     }
     return 0;
   }
@@ -238,11 +296,21 @@ var SqlDriver = class {
   async beginTransaction() {
     return await this.knex.transaction();
   }
+  /** IDataDriver standard */
+  async commit(transaction) {
+    await transaction.commit();
+  }
+  /** IDataDriver standard */
+  async rollback(transaction) {
+    await transaction.rollback();
+  }
+  /** @deprecated Use commit() instead */
   async commitTransaction(trx) {
-    await trx.commit();
+    await this.commit(trx);
   }
+  /** @deprecated Use rollback() instead */
   async rollbackTransaction(trx) {
-    await trx.rollback();
+    await this.rollback(trx);
   }
   // ===================================
   // Aggregation
@@ -311,6 +379,10 @@ var SqlDriver = class {
   // ===================================
   // Query Plan Analysis
   // ===================================
+  /** IDataDriver standard: analyze query performance */
+  async explain(object, query, options) {
+    return this.analyzeQuery(object, query, options);
+  }
   async analyzeQuery(object, query, options) {
     const builder = this.getBuilder(object, options);
     if (query.fields) {
@@ -362,7 +434,10 @@ var SqlDriver = class {
   // ===================================
   async syncSchema(object, schema, _options) {
     const objectDef = schema;
-    await this.initObjects([objectDef]);
+    await this.initObjects([{ ...objectDef, name: object }]);
+  }
+  async dropTable(object, _options) {
+    await this.knex.schema.dropTableIfExists(object);
   }
   /**
    * Batch-initialise tables from an array of object definitions.
@@ -370,7 +445,7 @@ var SqlDriver = class {
   async initObjects(objects) {
     await this.ensureDatabaseExists();
     for (const obj of objects) {
-      const tableName = obj.name;
+      const tableName = obj.tableName || obj.name;
       const jsonCols = [];
       const booleanCols = [];
       if (obj.fields) {
@@ -395,6 +470,7 @@ var SqlDriver = class {
           exists = false;
         }
       }
+      const builtinColumns = /* @__PURE__ */ new Set(["id", "created_at", "updated_at"]);
       if (!exists) {
         await this.knex.schema.createTable(tableName, (table) => {
           table.string("id").primary();
@@ -402,6 +478,7 @@ var SqlDriver = class {
           table.timestamp("updated_at").defaultTo(this.knex.fn.now());
           if (obj.fields) {
             for (const [name, field] of Object.entries(obj.fields)) {
+              if (builtinColumns.has(name)) continue;
               this.createColumn(table, name, field);
             }
           }
@@ -495,7 +572,7 @@ var SqlDriver = class {
         return;
       }
       for (const [key, value] of Object.entries(filters)) {
-        if (["filters", "sort", "limit", "skip", "offset", "fields", "orderBy"].includes(key)) continue;
+        if (["limit", "offset", "fields", "orderBy"].includes(key)) continue;
         builder.where(key, value);
       }
       return;
@@ -736,11 +813,12 @@ var SqlDriver = class {
   }
   // ── Database helpers ────────────────────────────────────────────────────────
   async ensureDatabaseExists() {
-    if (!this.isPostgres) return;
+    if (this.isSqlite) return;
+    if (!this.isPostgres && !this.isMysql) return;
     try {
       await this.knex.raw("SELECT 1");
     } catch (e) {
-      if (e.code === "3D000") {
+      if (e.code === "3D000" || e.code === "ER_BAD_DB_ERROR" || e.errno === 1049) {
         await this.createDatabase();
       } else {
         throw e;
@@ -752,18 +830,37 @@ var SqlDriver = class {
     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();
+    if (this.isPostgres) {
+      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" };
+      }
+    } else if (this.isMysql) {
+      if (typeof connection === "string") {
+        const url = new URL(connection);
+        dbName = url.pathname.slice(1);
+        url.pathname = "/";
+        adminConfig.connection = url.toString();
+      } else {
+        dbName = connection.database;
+        const { database: _db, ...rest } = connection;
+        adminConfig.connection = rest;
+      }
     } else {
-      dbName = connection.database;
-      adminConfig.connection = { ...connection, database: "postgres" };
+      return;
     }
     const adminKnex = (0, import_knex.default)(adminConfig);
     try {
-      await adminKnex.raw(`CREATE DATABASE "${dbName}"`);
+      if (this.isPostgres) {
+        await adminKnex.raw(`CREATE DATABASE "${dbName}"`);
+      } else if (this.isMysql) {
+        await adminKnex.raw(`CREATE DATABASE IF NOT EXISTS \`${dbName}\``);
+      }
     } finally {
       await adminKnex.destroy();
     }