@mindstudio-ai/agent 0.1.10 → 0.1.12

package/dist/index.js

@@ -302,7 +302,15 @@ function buildDelete(table, where, whereParams) {
   if (where) sql += ` WHERE ${where}`;
   return { sql, params: whereParams?.length ? whereParams : void 0 };
 }
-var SYSTEM_COLUMNS = /* @__PURE__ */ new Set(["id", "createdAt", "updatedAt", "lastUpdatedBy"]);
+var SYSTEM_COLUMNS = /* @__PURE__ */ new Set([
+  "id",
+  "created_at",
+  "createdAt",
+  "updated_at",
+  "updatedAt",
+  "last_updated_by",
+  "lastUpdatedBy"
+]);
 function stripSystemColumns(data) {
   const result = {};
   for (const [key, value] of Object.entries(data)) {
@@ -716,8 +724,7 @@ var Parser = class {
     return PARSE_FAILED;
   }
   /**
-   * Attempt to resolve a closure variable by invoking the original function
-   * with a recording Proxy and inspecting what values it compares against.
+   * Attempt to resolve a closure variable's value.
    *
    * This handles the common pattern:
    * ```ts
@@ -725,40 +732,28 @@ var Parser = class {
    * orders.filter(o => o.requestedBy === userId)
    * ```
    *
-   * The Proxy captures property accesses on the parameter and we can then
-   * extract the comparison value from the function's behavior. However,
-   * this approach has limitations — if the function throws, has side effects,
-   * or uses the variable in a non-comparison context, we fall back to JS.
+   * Closure variable resolution is fundamentally limited in JavaScript —
+   * we can't access another function's closure scope from outside without
+   * `eval`. The `===` operator can't be overridden via Proxy or
+   * Symbol.toPrimitive, so we can't intercept comparisons.
+   *
+   * For now, this falls back to JS execution. The predicate still works
+   * correctly — it just scans all rows instead of generating SQL.
+   * This is the most common reason for JS fallback in practice, since
+   * almost every real-world filter references a variable like `userId`.
+   *
+   * A future improvement could accept an explicit `vars` argument:
+   * ```ts
+   * orders.filter(o => o.requestedBy === $userId, { $userId: auth.userId })
+   * ```
    */
   resolveClosureVariable() {
-    const identToken = this.advance();
-    let closureExpr = identToken.value;
+    this.advance();
     while (this.match("dot") && this.tokens[this.pos + 1]?.type === "identifier") {
       this.advance();
-      closureExpr += "." + this.advance().value;
-    }
-    try {
-      const MARKER = /* @__PURE__ */ Symbol("field_access_marker");
-      const accessed = [];
-      const proxy = new Proxy(
-        {},
-        {
-          get(_, prop) {
-            accessed.push(prop);
-            return new Proxy(() => MARKER, {
-              get(_2, nestedProp) {
-                accessed.push(nestedProp);
-                return MARKER;
-              }
-            });
-          }
-        }
-      );
-      void proxy;
-      return PARSE_FAILED;
-    } catch {
-      return PARSE_FAILED;
+      this.advance();
     }
+    return PARSE_FAILED;
   }
   /**
    * Look ahead to check if the next tokens form `.includes(`.
@@ -935,6 +930,76 @@ var Query = class _Query {
     return map;
   }
   // -------------------------------------------------------------------------
+  // Batch compilation — used by db.batch() to extract SQL without executing
+  // -------------------------------------------------------------------------
+  /**
+   * @internal Compile this query into a SqlQuery for batch execution.
+   *
+   * Returns the compiled SQL query (if all predicates compile to SQL),
+   * or null (if JS fallback is needed). In the fallback case, a bare
+   * `SELECT *` is returned as `fallbackQuery` so the batch can fetch
+   * all rows and this query can filter them in JS post-fetch.
+   */
+  _compile() {
+    const compiled = this._compilePredicates();
+    const sortField = this._sortAccessor ? extractFieldName(this._sortAccessor) : void 0;
+    if (compiled.allSql) {
+      const query = buildSelect(this._config.tableName, {
+        where: compiled.sqlWhere || void 0,
+        orderBy: sortField ?? void 0,
+        desc: this._reversed,
+        limit: this._limit,
+        offset: this._offset
+      });
+      return { query, fallbackQuery: null, config: this._config };
+    }
+    const fallbackQuery = buildSelect(this._config.tableName);
+    return {
+      query: null,
+      fallbackQuery,
+      config: this._config,
+      predicates: this._predicates,
+      sortAccessor: this._sortAccessor,
+      reversed: this._reversed,
+      limit: this._limit,
+      offset: this._offset
+    };
+  }
+  /**
+   * @internal Process raw SQL results into typed rows. Used by db.batch()
+   * after executing the compiled query.
+   *
+   * For SQL-compiled queries: just deserialize the rows.
+   * For JS-fallback queries: filter, sort, and slice in JS.
+   */
+  static _processResults(result, compiled) {
+    const rows = result.rows.map(
+      (row) => deserializeRow(
+        row,
+        compiled.config.columns
+      )
+    );
+    if (compiled.query) return rows;
+    let filtered = compiled.predicates ? rows.filter((row) => compiled.predicates.every((pred) => pred(row))) : rows;
+    if (compiled.sortAccessor) {
+      const accessor = compiled.sortAccessor;
+      const reversed = compiled.reversed ?? false;
+      filtered.sort((a, b) => {
+        const aVal = accessor(a);
+        const bVal = accessor(b);
+        if (aVal < bVal) return reversed ? 1 : -1;
+        if (aVal > bVal) return reversed ? -1 : 1;
+        return 0;
+      });
+    }
+    if (compiled.offset != null || compiled.limit != null) {
+      const start = compiled.offset ?? 0;
+      const end = compiled.limit != null ? start + compiled.limit : void 0;
+      filtered = filtered.slice(start, end);
+    }
+    return filtered;
+  }
+  // -------------------------------------------------------------------------
   // PromiseLike
   // -------------------------------------------------------------------------
   then(onfulfilled, onrejected) {
@@ -1180,7 +1245,49 @@ function createDb(databases, executeBatch) {
     hours: (n) => n * 36e5,
     minutes: (n) => n * 6e4,
     ago: (ms) => Date.now() - ms,
-    fromNow: (ms) => Date.now() + ms
+    fromNow: (ms) => Date.now() + ms,
+    // --- Batch execution ---
+    batch: ((...queries) => {
+      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
+            );
+          }
+          return q._compile();
+        });
+        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 });
+        }
+        const allResults = new Array(compiled.length);
+        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];
+            }
+          })
+        );
+        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`
+            );
+          }
+          return Query._processResults(result, c);
+        });
+      })();
+    })
   };
 }
 function resolveTable(databases, tableName, databaseHint) {
@@ -1951,10 +2058,12 @@ var MindStudioAgent = class {
         );
       }
       if (!res.ok) {
+        const errorBody = await res.json().catch(() => ({}));
         throw new MindStudioError(
-          `Poll request failed: ${res.status} ${res.statusText}`,
-          "poll_error",
-          res.status
+          errorBody.message ?? errorBody.error ?? `Poll request failed: ${res.status} ${res.statusText}`,
+          errorBody.code ?? "poll_error",
+          res.status,
+          errorBody
         );
       }
       const poll = await res.json();
@@ -2219,12 +2328,24 @@ var MindStudioAgent = class {
     });
     if (!res.ok) {
       let message = `Database query failed: ${res.status} ${res.statusText}`;
+      let code = "db_query_error";
       try {
-        const body = await res.json();
-        if (body.error) message = body.error;
+        const text = await res.text();
+        try {
+          const body = JSON.parse(text);
+          const errMsg = body.error ?? body.message ?? body.details;
+          if (errMsg) message = errMsg;
+          if (body.code) code = body.code;
+        } catch {
+          if (text && text.length < 500) message = text;
+        }
       } catch {
       }
-      throw new MindStudioError(message, "db_query_error", res.status);
+      throw new MindStudioError(
+        `[db] ${message}`,
+        code,
+        res.status
+      );
     }
     const data = await res.json();
     return data.results;
@@ -2269,7 +2390,14 @@ var MindStudioAgent = class {
       hours: (n) => n * 36e5,
       minutes: (n) => n * 6e4,
       ago: (ms) => Date.now() - ms,
-      fromNow: (ms) => Date.now() + ms
+      fromNow: (ms) => Date.now() + ms,
+      // Batch needs context — hydrate first, then delegate to real db
+      batch: ((...queries) => {
+        return (async () => {
+          await agent.ensureContext();
+          return agent._db.batch(...queries);
+        })();
+      })
     };
   }
   // -------------------------------------------------------------------------
@@ -2401,10 +2529,12 @@ var MindStudioAgent = class {
       headers: options.type ? { "Content-Type": options.type } : {}
     });
     if (!res.ok) {
+      const errorBody = await res.json().catch(() => ({}));
       throw new MindStudioError(
-        `Upload failed: ${res.status} ${res.statusText}`,
-        "upload_error",
-        res.status
+        errorBody.message ?? errorBody.error ?? `Upload failed: ${res.status} ${res.statusText}`,
+        errorBody.code ?? "upload_error",
+        res.status,
+        errorBody
       );
     }
     return { url: data.url };