@objectstack/objectql 3.3.0 → 4.0.0

package/dist/index.mjs

@@ -547,7 +547,7 @@ var ObjectStackProtocolImplementation = class {
     const registeredServices = this.getServicesRegistry ? this.getServicesRegistry() : /* @__PURE__ */ new Map();
     const services = {
       // --- Kernel-provided (objectql is an example kernel implementation) ---
-      metadata: { enabled: true, status: "degraded", route: "/api/v1/meta", provider: "objectql", message: "In-memory registry only; DB persistence not yet implemented" },
+      metadata: { enabled: true, status: "available", route: "/api/v1/meta", provider: "objectql" },
       data: { enabled: true, status: "available", route: "/api/v1/data", provider: "objectql" },
       analytics: { enabled: true, status: "available", route: "/api/v1/analytics", provider: "objectql" }
     };
@@ -609,7 +609,7 @@ var ObjectStackProtocolImplementation = class {
       metadata: "/api/v1/meta",
       ...optionalRoutes
     };
-    const capabilities = {
+    const wellKnown = {
       feed: registeredServices.has("feed"),
       comments: registeredServices.has("feed"),
       automation: registeredServices.has("automation"),
@@ -618,6 +618,10 @@ var ObjectStackProtocolImplementation = class {
       export: registeredServices.has("automation") || registeredServices.has("queue"),
       chunkedUpload: registeredServices.has("file-storage")
     };
+    const capabilities = {};
+    for (const [key, enabled] of Object.entries(wellKnown)) {
+      capabilities[key] = { enabled };
+    }
     return {
       version: "1.0",
       apiName: "ObjectStack API",
@@ -637,6 +641,33 @@ var ObjectStackProtocolImplementation = class {
       const alt = request.type.endsWith("s") ? request.type.slice(0, -1) : request.type + "s";
       items = SchemaRegistry.listItems(alt);
     }
+    if (items.length === 0) {
+      try {
+        const allRecords = await this.engine.find("sys_metadata", {
+          where: { type: request.type, state: "active" }
+        });
+        if (allRecords && allRecords.length > 0) {
+          items = allRecords.map((record) => {
+            const data = typeof record.metadata === "string" ? JSON.parse(record.metadata) : record.metadata;
+            SchemaRegistry.registerItem(request.type, data, "name");
+            return data;
+          });
+        } else {
+          const alt = request.type.endsWith("s") ? request.type.slice(0, -1) : request.type + "s";
+          const altRecords = await this.engine.find("sys_metadata", {
+            where: { type: alt, state: "active" }
+          });
+          if (altRecords && altRecords.length > 0) {
+            items = altRecords.map((record) => {
+              const data = typeof record.metadata === "string" ? JSON.parse(record.metadata) : record.metadata;
+              SchemaRegistry.registerItem(request.type, data, "name");
+              return data;
+            });
+          }
+        }
+      } catch {
+      }
+    }
     return {
       type: request.type,
       items
@@ -648,6 +679,27 @@ var ObjectStackProtocolImplementation = class {
       const alt = request.type.endsWith("s") ? request.type.slice(0, -1) : request.type + "s";
       item = SchemaRegistry.getItem(alt, request.name);
     }
+    if (item === void 0) {
+      try {
+        const record = await this.engine.findOne("sys_metadata", {
+          where: { type: request.type, name: request.name, state: "active" }
+        });
+        if (record) {
+          item = typeof record.metadata === "string" ? JSON.parse(record.metadata) : record.metadata;
+          SchemaRegistry.registerItem(request.type, item, "name");
+        } else {
+          const alt = request.type.endsWith("s") ? request.type.slice(0, -1) : request.type + "s";
+          const altRecord = await this.engine.findOne("sys_metadata", {
+            where: { type: alt, name: request.name, state: "active" }
+          });
+          if (altRecord) {
+            item = typeof altRecord.metadata === "string" ? JSON.parse(altRecord.metadata) : altRecord.metadata;
+            SchemaRegistry.registerItem(request.type, item, "name");
+          }
+        }
+      } catch {
+      }
+    }
     return {
       type: request.type,
       name: request.name,
@@ -711,12 +763,22 @@ var ObjectStackProtocolImplementation = class {
   }
   async findData(request) {
     const options = { ...request.query };
-    if (options.top != null) options.top = Number(options.top);
-    if (options.skip != null) options.skip = Number(options.skip);
+    if (options.top != null) {
+      options.limit = Number(options.top);
+      delete options.top;
+    }
+    if (options.skip != null) {
+      options.offset = Number(options.skip);
+      delete options.skip;
+    }
     if (options.limit != null) options.limit = Number(options.limit);
+    if (options.offset != null) options.offset = Number(options.offset);
     if (typeof options.select === "string") {
-      options.select = options.select.split(",").map((s) => s.trim()).filter(Boolean);
+      options.fields = options.select.split(",").map((s) => s.trim()).filter(Boolean);
+    } else if (Array.isArray(options.select)) {
+      options.fields = options.select;
     }
+    if (options.select !== void 0) delete options.select;
     const sortValue = options.orderBy ?? options.sort;
     if (typeof sortValue === "string") {
       const parsed = sortValue.split(",").map((part) => {
@@ -727,62 +789,75 @@ var ObjectStackProtocolImplementation = class {
         const [field, order] = trimmed.split(/\s+/);
         return { field, order: order?.toLowerCase() === "desc" ? "desc" : "asc" };
       }).filter((s) => s.field);
-      options.sort = parsed;
-      delete options.orderBy;
-    }
-    if (options.filters !== void 0 && options.filter === void 0) {
-      options.filter = options.filters;
+      options.orderBy = parsed;
+    } else if (Array.isArray(sortValue)) {
+      options.orderBy = sortValue;
     }
+    delete options.sort;
+    const filterValue = options.filter ?? options.filters ?? options.$filter ?? options.where;
+    delete options.filter;
     delete options.filters;
-    if (typeof options.filter === "string") {
-      try {
-        options.filter = JSON.parse(options.filter);
-      } catch {
+    delete options.$filter;
+    if (filterValue !== void 0) {
+      let parsedFilter = filterValue;
+      if (typeof parsedFilter === "string") {
+        try {
+          parsedFilter = JSON.parse(parsedFilter);
+        } catch {
+        }
       }
+      if (isFilterAST(parsedFilter)) {
+        parsedFilter = parseFilterAST(parsedFilter);
+      }
+      options.where = parsedFilter;
     }
-    if (isFilterAST(options.filter)) {
-      options.filter = parseFilterAST(options.filter);
-    }
-    if (typeof options.populate === "string") {
-      options.populate = options.populate.split(",").map((s) => s.trim()).filter(Boolean);
-    }
+    const populateValue = options.populate;
     const expandValue = options.$expand ?? options.expand;
-    if (expandValue && !options.populate) {
+    const expandNames = [];
+    if (typeof populateValue === "string") {
+      expandNames.push(...populateValue.split(",").map((s) => s.trim()).filter(Boolean));
+    } else if (Array.isArray(populateValue)) {
+      expandNames.push(...populateValue);
+    }
+    if (!expandNames.length && expandValue) {
       if (typeof expandValue === "string") {
-        options.populate = expandValue.split(",").map((s) => s.trim()).filter(Boolean);
+        expandNames.push(...expandValue.split(",").map((s) => s.trim()).filter(Boolean));
       } else if (Array.isArray(expandValue)) {
-        options.populate = expandValue;
+        expandNames.push(...expandValue);
       }
     }
+    delete options.populate;
     delete options.$expand;
-    delete options.expand;
+    if (typeof options.expand !== "object" || options.expand === null) {
+      delete options.expand;
+    }
+    if (expandNames.length > 0 && !options.expand) {
+      options.expand = {};
+      for (const rel of expandNames) {
+        options.expand[rel] = { object: rel };
+      }
+    }
     for (const key of ["distinct", "count"]) {
       if (options[key] === "true") options[key] = true;
       else if (options[key] === "false") options[key] = false;
     }
     const knownParams = /* @__PURE__ */ new Set([
       "top",
-      "skip",
       "limit",
       "offset",
-      "sort",
       "orderBy",
-      "select",
       "fields",
-      "filter",
-      "filters",
-      "$filter",
-      "populate",
+      "where",
       "expand",
-      "$expand",
       "distinct",
       "count",
       "aggregations",
       "groupBy",
       "search",
-      "context"
+      "context",
+      "cursor"
     ]);
-    if (!options.filter) {
+    if (!options.where) {
       const implicitFilters = {};
       for (const key of Object.keys(options)) {
         if (!knownParams.has(key)) {
@@ -791,14 +866,14 @@ var ObjectStackProtocolImplementation = class {
         }
       }
       if (Object.keys(implicitFilters).length > 0) {
-        options.filter = implicitFilters;
+        options.where = implicitFilters;
       }
     }
     const records = await this.engine.find(request.object, options);
     return {
       object: request.object,
       value: records,
-      // OData compaibility
+      // OData compatibility
       records,
       // Legacy
       total: records.length,
@@ -807,13 +882,17 @@ var ObjectStackProtocolImplementation = class {
   }
   async getData(request) {
     const queryOptions = {
-      filter: { id: request.id }
+      where: { id: request.id }
     };
     if (request.select) {
-      queryOptions.select = typeof request.select === "string" ? request.select.split(",").map((s) => s.trim()).filter(Boolean) : request.select;
+      queryOptions.fields = typeof request.select === "string" ? request.select.split(",").map((s) => s.trim()).filter(Boolean) : request.select;
     }
     if (request.expand) {
-      queryOptions.populate = typeof request.expand === "string" ? request.expand.split(",").map((s) => s.trim()).filter(Boolean) : request.expand;
+      const expandNames = typeof request.expand === "string" ? request.expand.split(",").map((s) => s.trim()).filter(Boolean) : request.expand;
+      queryOptions.expand = {};
+      for (const rel of expandNames) {
+        queryOptions.expand[rel] = { object: rel };
+      }
     }
     const result = await this.engine.findOne(request.object, queryOptions);
     if (result) {
@@ -834,7 +913,7 @@ var ObjectStackProtocolImplementation = class {
     };
   }
   async updateData(request) {
-    const result = await this.engine.update(request.object, request.data, { filter: { id: request.id } });
+    const result = await this.engine.update(request.object, request.data, { where: { id: request.id } });
     return {
       object: request.object,
       id: request.id,
@@ -842,7 +921,7 @@ var ObjectStackProtocolImplementation = class {
     };
   }
   async deleteData(request) {
-    await this.engine.delete(request.object, { filter: { id: request.id } });
+    await this.engine.delete(request.object, { where: { id: request.id } });
     return {
       object: request.object,
       id: request.id,
@@ -905,7 +984,7 @@ var ObjectStackProtocolImplementation = class {
           }
           case "update": {
             if (!record.id) throw new Error("Record id is required for update");
-            const updated = await this.engine.update(object, record.data || {}, { filter: { id: record.id } });
+            const updated = await this.engine.update(object, record.data || {}, { where: { id: record.id } });
             results.push({ id: record.id, success: true, record: updated });
             succeeded++;
             break;
@@ -913,9 +992,9 @@ var ObjectStackProtocolImplementation = class {
           case "upsert": {
             if (record.id) {
               try {
-                const existing = await this.engine.findOne(object, { filter: { id: record.id } });
+                const existing = await this.engine.findOne(object, { where: { id: record.id } });
                 if (existing) {
-                  const updated = await this.engine.update(object, record.data || {}, { filter: { id: record.id } });
+                  const updated = await this.engine.update(object, record.data || {}, { where: { id: record.id } });
                   results.push({ id: record.id, success: true, record: updated });
                 } else {
                   const created = await this.engine.insert(object, { id: record.id, ...record.data || {} });
@@ -934,7 +1013,7 @@ var ObjectStackProtocolImplementation = class {
           }
           case "delete": {
             if (!record.id) throw new Error("Record id is required for delete");
-            await this.engine.delete(object, { filter: { id: record.id } });
+            await this.engine.delete(object, { where: { id: record.id } });
             results.push({ id: record.id, success: true });
             succeeded++;
             break;
@@ -978,7 +1057,7 @@ var ObjectStackProtocolImplementation = class {
     let failed = 0;
     for (const record of records) {
       try {
-        const updated = await this.engine.update(object, record.data, { filter: { id: record.id } });
+        const updated = await this.engine.update(object, record.data, { where: { id: record.id } });
         results.push({ id: record.id, success: true, record: updated });
         succeeded++;
       } catch (err) {
@@ -1029,9 +1108,9 @@ var ObjectStackProtocolImplementation = class {
       filter = conditions.length === 1 ? conditions[0] : { $and: conditions };
     }
     const rows = await this.engine.aggregate(object, {
-      filter,
+      where: filter,
       groupBy: groupBy.length > 0 ? groupBy : void 0,
-      aggregations: aggregations.length > 0 ? aggregations.map((a) => ({ field: a.field, method: a.method, alias: a.alias })) : [{ field: "*", method: "count", alias: "count" }]
+      aggregations: aggregations.length > 0 ? aggregations.map((a) => ({ function: a.method, field: a.field, alias: a.alias })) : [{ function: "count", alias: "count" }]
     });
     const fields = [
       ...groupBy.map((d) => ({ name: d, type: "string" })),
@@ -1142,7 +1221,7 @@ var ObjectStackProtocolImplementation = class {
   }
   async deleteManyData(request) {
     return this.engine.delete(request.object, {
-      filter: { id: { $in: request.ids } },
+      where: { id: { $in: request.ids } },
       ...request.options
     });
   }
@@ -1151,10 +1230,76 @@ var ObjectStackProtocolImplementation = class {
       throw new Error("Item data is required");
     }
     SchemaRegistry.registerItem(request.type, request.item, "name");
-    return {
-      success: true,
-      message: "Saved to memory registry"
-    };
+    try {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const existing = await this.engine.findOne("sys_metadata", {
+        where: { type: request.type, name: request.name }
+      });
+      if (existing) {
+        await this.engine.update("sys_metadata", {
+          metadata: JSON.stringify(request.item),
+          updated_at: now,
+          version: (existing.version || 0) + 1
+        }, {
+          where: { id: existing.id }
+        });
+      } else {
+        const id = typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID() : `meta_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+        await this.engine.insert("sys_metadata", {
+          id,
+          name: request.name,
+          type: request.type,
+          scope: "platform",
+          metadata: JSON.stringify(request.item),
+          state: "active",
+          version: 1,
+          created_at: now,
+          updated_at: now
+        });
+      }
+      return {
+        success: true,
+        message: "Saved to database and registry"
+      };
+    } catch (dbError) {
+      console.warn(`[Protocol] DB persistence failed for ${request.type}/${request.name}: ${dbError.message}`);
+      return {
+        success: true,
+        message: "Saved to memory registry (DB persistence unavailable)",
+        warning: dbError.message
+      };
+    }
+  }
+  /**
+   * Hydrate SchemaRegistry from the database on startup.
+   * Loads all active metadata records and registers them in the in-memory registry.
+   * Safe to call repeatedly — idempotent (latest DB record wins).
+   */
+  async loadMetaFromDb() {
+    let loaded = 0;
+    let errors = 0;
+    try {
+      const records = await this.engine.find("sys_metadata", {
+        where: { state: "active" }
+      });
+      for (const record of records) {
+        try {
+          const data = typeof record.metadata === "string" ? JSON.parse(record.metadata) : record.metadata;
+          if (record.type === "object") {
+            SchemaRegistry.registerObject(data, record.packageId || "sys_metadata");
+          } else {
+            SchemaRegistry.registerItem(record.type, data, "name");
+          }
+          loaded++;
+        } catch (e) {
+          errors++;
+          console.warn(`[Protocol] Failed to hydrate ${record.type}/${record.name}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+      }
+    } catch (e) {
+      console.warn(`[Protocol] DB hydration skipped: ${e.message}`);
+    }
+    return { loaded, errors };
   }
   // ==========================================
   // Feed Operations
@@ -1872,46 +2017,18 @@ var _ObjectQL = class _ObjectQL {
     return records;
   }
   // ============================================
-  // Helper: Query Conversion
-  // ============================================
-  toQueryAST(object, options) {
-    const ast = { object };
-    if (!options) return ast;
-    if (options.filter) {
-      ast.where = options.filter;
-    }
-    if (options.select) {
-      ast.fields = options.select;
-    }
-    if (options.sort) {
-      if (Array.isArray(options.sort)) {
-        ast.orderBy = options.sort;
-      } else {
-        ast.orderBy = Object.entries(options.sort).map(([field, order]) => ({
-          field,
-          order: order === -1 || order === "desc" ? "desc" : "asc"
-        }));
-      }
-    }
-    if (options.top !== void 0) ast.limit = options.top;
-    else if (options.limit !== void 0) ast.limit = options.limit;
-    if (options.skip !== void 0) ast.offset = options.skip;
-    if (options.populate && options.populate.length > 0) {
-      ast.expand = {};
-      for (const rel of options.populate) {
-        ast.expand[rel] = { object: rel };
-      }
-    }
-    return ast;
-  }
-  // ============================================
   // Data Access Methods (IDataEngine Interface)
   // ============================================
   async find(object, query) {
     object = this.resolveObjectName(object);
     this.logger.debug("Find operation starting", { object, query });
     const driver = this.getDriver(object);
-    const ast = this.toQueryAST(object, query);
+    const ast = { object, ...query };
+    delete ast.context;
+    if (ast.top != null && ast.limit == null) {
+      ast.limit = ast.top;
+    }
+    delete ast.top;
     const opCtx = {
       object,
       operation: "find",
@@ -1949,8 +2066,9 @@ var _ObjectQL = class _ObjectQL {
     objectName = this.resolveObjectName(objectName);
     this.logger.debug("FindOne operation", { objectName });
     const driver = this.getDriver(objectName);
-    const ast = this.toQueryAST(objectName, query);
-    ast.limit = 1;
+    const ast = { object: objectName, ...query, limit: 1 };
+    delete ast.context;
+    delete ast.top;
     const opCtx = {
       object: objectName,
       operation: "findOne",
@@ -2016,9 +2134,8 @@ var _ObjectQL = class _ObjectQL {
     this.logger.debug("Update operation starting", { object });
     const driver = this.getDriver(object);
     let id = data.id;
-    if (!id && options?.filter) {
-      if (typeof options.filter === "string") id = options.filter;
-      else if (options.filter.id) id = options.filter.id;
+    if (!id && options?.where && typeof options.where === "object" && "id" in options.where) {
+      id = options.where.id;
     }
     const opCtx = {
       object,
@@ -2042,7 +2159,7 @@ var _ObjectQL = class _ObjectQL {
         if (hookContext.input.id) {
           result = await driver.update(object, hookContext.input.id, hookContext.input.data, hookContext.input.options);
         } else if (options?.multi && driver.updateMany) {
-          const ast = this.toQueryAST(object, { filter: options.filter });
+          const ast = { object, where: options.where };
           result = await driver.updateMany(object, ast, hookContext.input.data, hookContext.input.options);
         } else {
           throw new Error("Update requires an ID or options.multi=true");
@@ -2063,9 +2180,8 @@ var _ObjectQL = class _ObjectQL {
     this.logger.debug("Delete operation starting", { object });
     const driver = this.getDriver(object);
     let id = void 0;
-    if (options?.filter) {
-      if (typeof options.filter === "string") id = options.filter;
-      else if (options.filter.id) id = options.filter.id;
+    if (options?.where && typeof options.where === "object" && "id" in options.where) {
+      id = options.where.id;
     }
     const opCtx = {
       object,
@@ -2088,7 +2204,7 @@ var _ObjectQL = class _ObjectQL {
         if (hookContext.input.id) {
           result = await driver.delete(object, hookContext.input.id, hookContext.input.options);
         } else if (options?.multi && driver.deleteMany) {
-          const ast = this.toQueryAST(object, { filter: options.filter });
+          const ast = { object, where: options.where };
           result = await driver.deleteMany(object, ast, hookContext.input.options);
         } else {
           throw new Error("Delete requires an ID or options.multi=true");
@@ -2115,10 +2231,10 @@ var _ObjectQL = class _ObjectQL {
     };
     await this.executeWithMiddleware(opCtx, async () => {
       if (driver.count) {
-        const ast = this.toQueryAST(object, { filter: query?.filter });
+        const ast = { object, where: query?.where };
         return driver.count(object, ast);
       }
-      const res = await this.find(object, { filter: query?.filter, select: ["id"] });
+      const res = await this.find(object, { where: query?.where, fields: ["id"] });
       return res.length;
     });
     return opCtx.result;
@@ -2136,13 +2252,9 @@ var _ObjectQL = class _ObjectQL {
     await this.executeWithMiddleware(opCtx, async () => {
       const ast = {
         object,
-        where: query.filter,
+        where: query.where,
         groupBy: query.groupBy,
-        aggregations: query.aggregations?.map((agg) => ({
-          function: agg.method,
-          field: agg.field,
-          alias: agg.alias || `${agg.method}_${agg.field || "all"}`
-        }))
+        aggregations: query.aggregations
       };
       return driver.find(object, ast);
     });
@@ -2370,7 +2482,7 @@ var ObjectRepository = class {
   /** Update a single record by ID */
   async updateById(id, data) {
     return this.engine.update(this.objectName, { ...data, id }, {
-      filter: { id },
+      where: { id },
       context: this.context
     });
   }
@@ -2383,7 +2495,7 @@ var ObjectRepository = class {
   /** Delete a single record by ID */
   async deleteById(id) {
     return this.engine.delete(this.objectName, {
-      filter: { id },
+      where: { id },
       context: this.context
     });
   }
@@ -2679,7 +2791,7 @@ var ObjectQLPlugin = class {
       if (hookCtx.input?.id && !hookCtx.previous) {
         try {
           const existing = await this.ql.findOne(hookCtx.object, {
-            filter: { id: hookCtx.input.id }
+            where: { id: hookCtx.input.id }
           });
           if (existing) {
             hookCtx.previous = existing;
@@ -2692,7 +2804,7 @@ var ObjectQLPlugin = class {
       if (hookCtx.input?.id && !hookCtx.previous) {
         try {
           const existing = await this.ql.findOne(hookCtx.object, {
-            filter: { id: hookCtx.input.id }
+            where: { id: hookCtx.input.id }
           });
           if (existing) {
             hookCtx.previous = existing;
@@ -2730,9 +2842,13 @@ var ObjectQLPlugin = class {
   /**
    * Synchronize all registered object schemas to the database.
    *
-   * Iterates every object in the SchemaRegistry and calls the
-   * responsible driver's `syncSchema()` for each one.  This is
-   * idempotent — drivers must tolerate repeated calls without
+   * Groups objects by their responsible driver, then:
+   * - If the driver advertises `supports.batchSchemaSync` and implements
+   *   `syncSchemasBatch()`, submits all schemas in a single call (reducing
+   *   network round-trips for remote drivers like Turso).
+   * - Otherwise falls back to sequential `syncSchema()` per object.
+   *
+   * This is idempotent — drivers must tolerate repeated calls without
    * duplicating tables or erroring out.
    *
    * Drivers that do not implement `syncSchema` are silently skipped.
@@ -2743,6 +2859,7 @@ var ObjectQLPlugin = class {
     if (allObjects.length === 0) return;
     let synced = 0;
     let skipped = 0;
+    const driverGroups = /* @__PURE__ */ new Map();
     for (const obj of allObjects) {
       const driver = this.ql.getDriverForObject(obj.name);
       if (!driver) {
@@ -2761,16 +2878,59 @@ var ObjectQLPlugin = class {
         continue;
       }
       const tableName = obj.tableName || obj.name;
-      try {
-        await driver.syncSchema(tableName, obj);
-        synced++;
-      } catch (e) {
-        ctx.logger.warn("Failed to sync schema for object", {
-          object: obj.name,
-          tableName,
-          driver: driver.name,
-          error: e instanceof Error ? e.message : String(e)
-        });
+      let group = driverGroups.get(driver);
+      if (!group) {
+        group = [];
+        driverGroups.set(driver, group);
+      }
+      group.push({ obj, tableName });
+    }
+    for (const [driver, entries] of driverGroups) {
+      if (driver.supports?.batchSchemaSync && typeof driver.syncSchemasBatch === "function") {
+        const batchPayload = entries.map((e) => ({
+          object: e.tableName,
+          schema: e.obj
+        }));
+        try {
+          await driver.syncSchemasBatch(batchPayload);
+          synced += entries.length;
+          ctx.logger.debug("Batch schema sync succeeded", {
+            driver: driver.name,
+            count: entries.length
+          });
+        } catch (e) {
+          ctx.logger.warn("Batch schema sync failed, falling back to sequential", {
+            driver: driver.name,
+            error: e instanceof Error ? e.message : String(e)
+          });
+          for (const { obj, tableName } of entries) {
+            try {
+              await driver.syncSchema(tableName, obj);
+              synced++;
+            } catch (seqErr) {
+              ctx.logger.warn("Failed to sync schema for object", {
+                object: obj.name,
+                tableName,
+                driver: driver.name,
+                error: seqErr instanceof Error ? seqErr.message : String(seqErr)
+              });
+            }
+          }
+        }
+      } else {
+        for (const { obj, tableName } of entries) {
+          try {
+            await driver.syncSchema(tableName, obj);
+            synced++;
+          } catch (e) {
+            ctx.logger.warn("Failed to sync schema for object", {
+              object: obj.name,
+              tableName,
+              driver: driver.name,
+              error: e instanceof Error ? e.message : String(e)
+            });
+          }
+        }
       }
     }
     if (synced > 0 || skipped > 0) {