@mindstudio-ai/agent 0.1.17 → 0.1.19

package/dist/index.js

@@ -951,10 +951,11 @@ var Query = class _Query {
         limit: this._limit,
         offset: this._offset
       });
-      return { query, fallbackQuery: null, config: this._config };
+      return { type: "query", query, fallbackQuery: null, config: this._config };
     }
     const fallbackQuery = buildSelect(this._config.tableName);
     return {
+      type: "query",
       query: null,
       fallbackQuery,
       config: this._config,
@@ -1084,6 +1085,83 @@ function extractFieldName(accessor) {
   return match?.[2] ?? null;
 }
 
+// src/db/mutation.ts
+var Mutation = class _Mutation {
+  /** @internal */
+  _config;
+  /** @internal */
+  _queries;
+  /** @internal */
+  _processResult;
+  /** @internal Non-batchable executor for complex mutations (e.g. removeAll JS fallback). */
+  _executor;
+  constructor(config, queries, processResult) {
+    this._config = config;
+    this._queries = queries;
+    this._processResult = processResult;
+    this._executor = void 0;
+  }
+  /**
+   * Create a non-batchable mutation that wraps an async executor.
+   * Used for operations that require multi-step execution (e.g. removeAll
+   * with a JS-fallback predicate: fetch all rows → filter → delete).
+   *
+   * Works fine when awaited standalone. Throws if passed to db.batch().
+   *
+   * @internal
+   */
+  static fromExecutor(config, executor) {
+    const m = new _Mutation(config, [], () => void 0);
+    Object.defineProperty(m, "_executor", { value: executor });
+    return m;
+  }
+  // -------------------------------------------------------------------------
+  // PromiseLike — executes on await
+  // -------------------------------------------------------------------------
+  then(onfulfilled, onrejected) {
+    return this._execute().then(onfulfilled, onrejected);
+  }
+  // -------------------------------------------------------------------------
+  // Batch compilation — used by db.batch()
+  // -------------------------------------------------------------------------
+  /**
+   * @internal Compile this mutation into SQL for batch execution.
+   * Returns the queries and a result processor.
+   *
+   * Throws if this is a non-batchable mutation (created via fromExecutor).
+   */
+  _compile() {
+    if (this._executor) {
+      throw new Error(
+        "This operation cannot be batched (e.g. removeAll with a predicate that cannot compile to SQL). Await it separately."
+      );
+    }
+    return {
+      type: "mutation",
+      queries: this._queries,
+      config: this._config,
+      processResult: this._processResult
+    };
+  }
+  /**
+   * @internal Process raw SQL results into the typed result.
+   * Used by db.batch() after executing the compiled queries.
+   */
+  static _processResults(results, compiled) {
+    return compiled.processResult(results);
+  }
+  // -------------------------------------------------------------------------
+  // Execution
+  // -------------------------------------------------------------------------
+  async _execute() {
+    if (this._executor) {
+      return this._executor();
+    }
+    const results = await this._config.executeBatch(this._queries);
+    return this._processResult(results);
+  }
+};
+
 // src/db/table.ts
 var Table = class {
   /** @internal */
@@ -1147,7 +1225,7 @@ var Table = class {
   sortBy(accessor) {
     return new Query(this._config).sortBy(accessor);
   }
-  async push(data) {
+  push(data) {
     const isArray = Array.isArray(data);
     const items = isArray ? data : [data];
     const queries = items.map(
@@ -1157,71 +1235,76 @@ var Table = class {
         this._config.columns
       )
     );
-    const results = await this._config.executeBatch(queries);
-    const rows = results.map((r) => {
-      if (r.rows.length > 0) {
-        return deserializeRow(
-          r.rows[0],
-          this._config.columns
-        );
-      }
-      return void 0;
+    return new Mutation(this._config, queries, (results) => {
+      const rows = results.map((r) => {
+        if (r.rows.length > 0) {
+          return deserializeRow(
+            r.rows[0],
+            this._config.columns
+          );
+        }
+        return void 0;
+      });
+      return isArray ? rows : rows[0];
     });
-    return isArray ? rows : rows[0];
   }
   /**
    * Update a row by ID. Only the provided fields are changed.
    * Returns the updated row via `UPDATE ... RETURNING *`.
    */
-  async update(id, data) {
+  update(id, data) {
     const query = buildUpdate(
       this._config.tableName,
       id,
       data,
       this._config.columns
     );
-    const results = await this._config.executeBatch([query]);
-    return deserializeRow(
-      results[0].rows[0],
-      this._config.columns
+    return new Mutation(
+      this._config,
+      [query],
+      (results) => deserializeRow(
+        results[0].rows[0],
+        this._config.columns
+      )
     );
   }
-  async remove(id) {
+  remove(id) {
     const query = buildDelete(this._config.tableName, `id = ?`, [id]);
-    await this._config.executeBatch([query]);
+    return new Mutation(this._config, [query], () => void 0);
   }
   /**
    * Remove all rows matching a predicate. Returns the count removed.
    */
-  async removeAll(predicate) {
+  removeAll(predicate) {
     const compiled = compilePredicate(predicate);
     if (compiled.type === "sql") {
       const query = buildDelete(this._config.tableName, compiled.where);
-      const results = await this._config.executeBatch([query]);
-      return results[0].changes;
+      return new Mutation(this._config, [query], (results) => results[0].changes);
     }
-    console.warn(
-      `[mindstudio] removeAll predicate on ${this._config.tableName} could not be compiled to SQL \u2014 fetching all rows first`
-    );
-    const allQuery = buildSelect(this._config.tableName);
-    const allResults = await this._config.executeBatch([allQuery]);
-    const allRows = allResults[0].rows.map(
-      (r) => deserializeRow(
-        r,
-        this._config.columns
-      )
-    );
-    const matching = allRows.filter((row) => predicate(row));
-    if (matching.length === 0) return 0;
-    const deleteQueries = matching.filter((row) => row.id).map((row) => buildDelete(this._config.tableName, `id = ?`, [row.id]));
-    if (deleteQueries.length > 0) {
-      await this._config.executeBatch(deleteQueries);
-    }
-    return matching.length;
+    return Mutation.fromExecutor(this._config, async () => {
+      console.warn(
+        `[mindstudio] removeAll predicate on ${this._config.tableName} could not be compiled to SQL \u2014 fetching all rows first`
+      );
+      const allQuery = buildSelect(this._config.tableName);
+      const allResults = await this._config.executeBatch([allQuery]);
+      const allRows = allResults[0].rows.map(
+        (r) => deserializeRow(
+          r,
+          this._config.columns
+        )
+      );
+      const matching = allRows.filter((row) => predicate(row));
+      if (matching.length === 0) return 0;
+      const deleteQueries = matching.filter((row) => row.id).map((row) => buildDelete(this._config.tableName, `id = ?`, [row.id]));
+      if (deleteQueries.length > 0) {
+        await this._config.executeBatch(deleteQueries);
+      }
+      return matching.length;
+    });
   }
-  async clear() {
+  clear() {
     const query = buildDelete(this._config.tableName);
-    await this._config.executeBatch([query]);
+    return new Mutation(this._config, [query], () => void 0);
   }
 };
 
@@ -1247,44 +1330,64 @@ function createDb(databases, executeBatch) {
     ago: (ms) => Date.now() - ms,
     fromNow: (ms) => Date.now() + ms,
     // --- Batch execution ---
-    batch: ((...queries) => {
+    batch: ((...operations) => {
       return (async () => {
-        const compiled = queries.map((q) => {
-          if (!(q instanceof Query)) {
-            throw new MindStudioError(
-              "db.batch() only accepts Query objects (from .filter(), .sortBy(), etc.)",
-              "invalid_batch_query",
-              400
-            );
+        const compiled = operations.map((op) => {
+          if (op instanceof Query) {
+            return op._compile();
+          }
+          if (op instanceof Mutation) {
+            return op._compile();
           }
-          return q._compile();
+          throw new MindStudioError(
+            "db.batch() only accepts Query and Mutation objects (from .filter(), .update(), .push(), etc.)",
+            "invalid_batch_operation",
+            400
+          );
         });
         const groups = /* @__PURE__ */ new Map();
         for (let i = 0; i < compiled.length; i++) {
           const c = compiled[i];
           const dbId = c.config.databaseId;
-          const sqlQuery = c.query ?? c.fallbackQuery;
           if (!groups.has(dbId)) groups.set(dbId, []);
-          groups.get(dbId).push({ index: i, sqlQuery });
+          if (c.type === "query") {
+            const sqlQuery = c.query ?? c.fallbackQuery;
+            groups.get(dbId).push({ opIndex: i, sqlQueries: [sqlQuery] });
+          } else {
+            groups.get(dbId).push({ opIndex: i, sqlQueries: c.queries });
+          }
         }
-        const allResults = new Array(compiled.length);
+        const opResults = /* @__PURE__ */ new Map();
         await Promise.all(
           Array.from(groups.entries()).map(async ([dbId, entries]) => {
-            const sqlQueries = entries.map((e) => e.sqlQuery);
-            const results = await executeBatch(dbId, sqlQueries);
-            for (let i = 0; i < entries.length; i++) {
-              allResults[entries[i].index] = results[i];
+            const flatQueries = [];
+            const slices = [];
+            for (const entry of entries) {
+              slices.push({
+                opIndex: entry.opIndex,
+                start: flatQueries.length,
+                count: entry.sqlQueries.length
+              });
+              flatQueries.push(...entry.sqlQueries);
+            }
+            const results = await executeBatch(dbId, flatQueries);
+            for (const { opIndex, start, count } of slices) {
+              opResults.set(opIndex, results.slice(start, start + count));
             }
           })
         );
         return compiled.map((c, i) => {
-          const result = allResults[i];
-          if (!c.query && c.predicates?.length) {
-            console.warn(
-              `[mindstudio] db.batch(): filter on ${c.config.tableName} could not be compiled to SQL \u2014 processing in JS`
-            );
+          const results = opResults.get(i);
+          if (c.type === "query") {
+            if (!c.query && c.predicates?.length) {
+              console.warn(
+                `[mindstudio] db.batch(): filter on ${c.config.tableName} could not be compiled to SQL \u2014 processing in JS`
+              );
+            }
+            return Query._processResults(results[0], c);
+          } else {
+            return Mutation._processResults(results, c);
           }
-          return Query._processResults(result, c);
         });
       })();
     })