@mindstudio-ai/agent 0.1.34 → 0.1.35

package/dist/index.js

@@ -37,13 +37,23 @@ async function requestWithRetry(config, method, url, body, attempt) {
     return requestWithRetry(config, method, url, body, attempt + 1);
   }
   if (!res.ok) {
-    const errorBody = await res.json().catch(() => ({}));
-    throw new MindStudioError(
-      errorBody.message || `${res.status} ${res.statusText}`,
-      errorBody.code || "api_error",
-      res.status,
-      errorBody
-    );
+    let message = `${res.status} ${res.statusText}`;
+    let code = "api_error";
+    let details;
+    try {
+      const text = await res.text();
+      try {
+        const body2 = JSON.parse(text);
+        details = body2;
+        const errMsg = body2.error ?? body2.message ?? body2.details;
+        if (errMsg) message = errMsg;
+        if (body2.code) code = body2.code;
+      } catch {
+        if (text && text.length < 500) message = text;
+      }
+    } catch {
+    }
+    throw new MindStudioError(message, code, res.status, details);
   }
   const data = await res.json();
   return { data, headers: res.headers };
@@ -1248,6 +1258,9 @@ var Table = class {
     const items = (isArray ? data : [data]).map(
       (item) => this._config.defaults ? { ...this._config.defaults, ...item } : item
     );
+    for (const item of items) {
+      this._checkManagedColumns(item);
+    }
     const queries = items.map(
       (item) => buildInsert(
         this._config.tableName,
@@ -1265,7 +1278,13 @@ var Table = class {
         }
         return void 0;
       });
-      return isArray ? rows : rows[0];
+      const result = isArray ? rows : rows[0];
+      this._syncRolesIfNeeded(
+        items,
+        result,
+        isArray
+      );
+      return result;
     });
   }
   /**
@@ -1273,20 +1292,25 @@ var Table = class {
    * Returns the updated row via `UPDATE ... RETURNING *`.
    */
   update(id, data) {
+    this._checkManagedColumns(data);
     const query = buildUpdate(
       this._config.tableName,
       id,
       data,
       this._config.columns
     );
-    return new Mutation(
-      this._config,
-      [query],
-      (results) => deserializeRow(
+    return new Mutation(this._config, [query], (results) => {
+      const result = deserializeRow(
         results[0].rows[0],
         this._config.columns
-      )
-    );
+      );
+      this._syncRolesIfNeeded(
+        [data],
+        result,
+        false
+      );
+      return result;
+    });
   }
   remove(id) {
     const query = buildDelete(this._config.tableName, `id = ?`, [id]);
@@ -1341,24 +1365,65 @@ var Table = class {
     const conflictColumns = Array.isArray(conflictKey) ? conflictKey : [conflictKey];
     this._validateUniqueConstraint(conflictColumns);
     const withDefaults = this._config.defaults ? { ...this._config.defaults, ...data } : data;
+    this._checkManagedColumns(withDefaults);
     const query = buildUpsert(
       this._config.tableName,
       withDefaults,
       conflictColumns,
       this._config.columns
     );
-    return new Mutation(
-      this._config,
-      [query],
-      (results) => deserializeRow(
+    return new Mutation(this._config, [query], (results) => {
+      const result = deserializeRow(
         results[0].rows[0],
         this._config.columns
-      )
-    );
+      );
+      this._syncRolesIfNeeded([withDefaults], result, false);
+      return result;
+    });
   }
   // -------------------------------------------------------------------------
   // Internal helpers
   // -------------------------------------------------------------------------
+  /** @internal Throw if data includes a platform-managed email/phone column. */
+  _checkManagedColumns(data) {
+    const mc = this._config.managedColumns;
+    if (!mc) return;
+    const keys = Object.keys(data);
+    for (const key of keys) {
+      if (mc.email && key === mc.email || mc.phone && key === mc.phone) {
+        throw new MindStudioError(
+          `Cannot write to "${key}" \u2014 this column is managed by auth. Use the auth API to change a user's ${key === mc.email ? "email" : "phone"}.`,
+          "managed_column_write",
+          400
+        );
+      }
+    }
+  }
+  /**
+   * @internal Fire role sync for rows that wrote to the roles column.
+   * Called inside processResult (runs after SQL execution in both
+   * standalone and batch paths). Fire-and-forget.
+   */
+  _syncRolesIfNeeded(inputItems, result, isArray) {
+    const rolesCol = this._config.managedColumns?.roles;
+    const syncRoles = this._config.syncRoles;
+    if (!rolesCol || !syncRoles) return;
+    if (!inputItems.some((item) => rolesCol in item)) return;
+    if (isArray) {
+      for (const row of result) {
+        if (row?.id) {
+          syncRoles(row.id, row[rolesCol]).catch(() => {
+          });
+        }
+      }
+    } else {
+      const row = result;
+      if (row?.id) {
+        syncRoles(row.id, row[rolesCol]).catch(() => {
+        });
+      }
+    }
+  }
   /** @internal Validate that the given columns match a declared unique constraint. */
   _validateUniqueConstraint(columns) {
     if (!this._config.unique?.length) {
@@ -1383,7 +1448,7 @@ var Table = class {
 };
 
 // src/db/index.ts
-function createDb(databases, executeBatch) {
+function createDb(databases, executeBatch, authConfig, syncRoles) {
   return {
     defineTable(name, options) {
       const resolved = resolveTable(databases, name, options?.database);
@@ -1393,6 +1458,8 @@ function createDb(databases, executeBatch) {
         columns: resolved.columns,
         unique: options?.unique,
         defaults: options?.defaults,
+        managedColumns: authConfig?.table === name ? authConfig.columns : void 0,
+        syncRoles: authConfig?.table === name && authConfig.columns.roles ? syncRoles : void 0,
         executeBatch: (queries) => executeBatch(resolved.databaseId, queries)
       };
       return new Table(config);
@@ -3847,7 +3914,9 @@ var MindStudioAgent = class {
     this._auth = new AuthContext(context.auth);
     this._db = createDb(
       context.databases,
-      this._executeDbBatch.bind(this)
+      this._executeDbBatch.bind(this),
+      context.authConfig,
+      this._syncRoles.bind(this)
     );
   }
   /**
@@ -3863,7 +3932,8 @@ var MindStudioAgent = class {
     if (ai?.auth && ai?.databases) {
       this._applyContext({
         auth: ai.auth,
-        databases: ai.databases
+        databases: ai.databases,
+        authConfig: ai.authConfig
       });
     }
   }
@@ -3909,6 +3979,39 @@ var MindStudioAgent = class {
     const data = await res.json();
     return data.results;
   }
+  /**
+   * @internal Sync a user's roles to the platform after a successful
+   * auth table write. Calls POST /_internal/v2/auth/sync-user.
+   * Fire-and-forget: errors are caught and logged, never propagated.
+   */
+  async _syncRoles(userId, roles) {
+    try {
+      const url = `${this._httpConfig.baseUrl}/_internal/v2/auth/sync-user`;
+      const res = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: this._token
+        },
+        body: JSON.stringify({
+          appId: this._appId,
+          userId,
+          roles
+        })
+      });
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        console.warn(
+          `[mindstudio] Failed to sync roles for user ${userId}: ${res.status} ${text}`
+        );
+      }
+    } catch (err) {
+      console.warn(
+        `[mindstudio] Failed to sync roles for user ${userId}:`,
+        err
+      );
+    }
+  }
   /**
    * @internal Create a lazy Db proxy that auto-hydrates context.
    *
@@ -3921,7 +4024,7 @@ var MindStudioAgent = class {
     return {
       defineTable(name, options) {
         const databaseHint = options?.database;
-        return new Table({
+        const tableConfig = {
           databaseId: "",
           tableName: name,
           columns: [],
@@ -3929,6 +4032,13 @@ var MindStudioAgent = class {
           defaults: options?.defaults,
           executeBatch: async (queries) => {
             await agent.ensureContext();
+            const ac = agent._context.authConfig;
+            if (ac && ac.table === name && !tableConfig.managedColumns) {
+              tableConfig.managedColumns = ac.columns;
+              if (ac.columns.roles) {
+                tableConfig.syncRoles = agent._syncRoles.bind(agent);
+              }
+            }
             const databases = agent._context.databases;
             let targetDb;
             if (databaseHint) {
@@ -3943,7 +4053,8 @@ var MindStudioAgent = class {
             const databaseId = targetDb?.id ?? databases[0]?.id ?? "";
             return agent._executeDbBatch(databaseId, queries);
           }
-        });
+        };
+        return new Table(tableConfig);
       },
       // Time helpers work without context
       now: () => Date.now(),