@mitralab.io/platform-sdk 1.0.6 → 1.0.8

package/dist/index.js

@@ -25,7 +25,35 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/client.ts
+var import_sdk_core6 = require("@mitralab.io/sdk-core");
+
 // src/utils/http-client.ts
+var bearerCredentialPattern = /(Bearer\s+)\S+/gi;
+function redactText(value, currentToken) {
+  const withoutBearerCredentials = value.replace(bearerCredentialPattern, "$1[REDACTED]");
+  return currentToken ? withoutBearerCredentials.split(currentToken).join("[REDACTED]") : withoutBearerCredentials;
+}
+function redactDetails(value, currentToken) {
+  if (typeof value === "string") return redactText(value, currentToken);
+  if (Array.isArray(value)) return value.map((item) => redactDetails(item, currentToken));
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [
+        redactText(key, currentToken),
+        redactDetails(entry, currentToken)
+      ])
+    );
+  }
+  return value;
+}
+function asErrorPayload(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  return value;
+}
+function optionalString(value) {
+  return typeof value === "string" ? value : void 0;
+}
 var HttpClient = class {
   baseUrl;
   tokenGetter;
@@ -89,8 +117,18 @@ var HttpClient = class {
     const response = await fetch(url, {
       method,
       headers: requestHeaders,
-      body: body ? JSON.stringify(body) : void 0
+      body: body ? JSON.stringify(body) : void 0,
+      redirect: "manual"
     });
+    if (response.redirected || response.type === "opaqueredirect") {
+      const error = new MitraApiError(
+        "Redirected responses are not allowed",
+        response.status,
+        "REDIRECT_NOT_ALLOWED"
+      );
+      this.onError?.(error);
+      throw error;
+    }
     if (!response.ok) {
       if (response.status === 401 && !isRetry && this.onUnauthorized) {
         const refreshed = await this.onUnauthorized();
@@ -99,11 +137,14 @@ var HttpClient = class {
         }
       }
       const errorBody = await response.json().catch(() => ({}));
+      const errorPayload = asErrorPayload(errorBody);
+      const rawMessage = optionalString(errorPayload.message);
+      const rawCode = optionalString(errorPayload.error_code);
       const error = new MitraApiError(
-        errorBody.message || `Request failed with status ${response.status}`,
+        redactText(rawMessage || `Request failed with status ${response.status}`, token),
         response.status,
-        errorBody.error_code,
-        errorBody
+        rawCode === void 0 ? void 0 : redactText(rawCode, token),
+        redactDetails(errorBody, token)
       );
       this.onError?.(error);
       throw error;
@@ -184,22 +225,31 @@ var MitraApiError = class extends Error {
   }
 };
 
+// src/core-errors.ts
+var coreErrors = {
+  configuration: (message) => new MitraApiError(message, 0, "INVALID_CONFIGURATION"),
+  invalidResponse: (message) => new MitraApiError(message, 200, "INVALID_RESPONSE")
+};
+
 // src/modules/auth.ts
+var import_sdk_core = require("@mitralab.io/sdk-core");
 var AuthModule = class {
   appId;
   _currentUser = null;
-  _accessToken = null;
-  _refreshToken = null;
+  #accessToken = null;
+  #refreshToken = null;
   refreshPromise = null;
   listeners = /* @__PURE__ */ new Set();
   storageKey;
   publicClient;
   authedClient;
+  currentUserApi;
   constructor(appId, iamBaseUrl) {
     this.appId = appId;
     this.storageKey = `mitra_auth_${appId}`;
     this.publicClient = new HttpClient({ baseUrl: iamBaseUrl, getToken: () => null });
-    this.authedClient = new HttpClient({ baseUrl: iamBaseUrl, getToken: () => this._accessToken });
+    this.authedClient = new HttpClient({ baseUrl: iamBaseUrl, getToken: () => this.#accessToken });
+    this.currentUserApi = (0, import_sdk_core.createAuthModule)(this.authedClient, coreErrors);
     this.loadFromStorage();
   }
   /** The currently authenticated user, or null. */
@@ -208,11 +258,11 @@ var AuthModule = class {
   }
   /** The current JWT access token, or null. */
   get accessToken() {
-    return this._accessToken;
+    return this.#accessToken;
   }
   /** Whether a user is currently authenticated (local check, not server-validated). */
   get isAuthenticated() {
-    return this._currentUser !== null && this._accessToken !== null;
+    return this._currentUser !== null && this.#accessToken !== null;
   }
   /**
    * Signs in a user with email and password.
@@ -237,9 +287,9 @@ var AuthModule = class {
       "/api/v1/auth/login",
       { ...credentials, appId: this.appId }
     );
-    this._accessToken = tokenResponse.accessToken;
-    this._refreshToken = tokenResponse.refreshToken;
-    const user = await this.authedClient.get("/api/v1/auth/me");
+    this.#accessToken = tokenResponse.accessToken;
+    this.#refreshToken = tokenResponse.refreshToken;
+    const user = await this.getCurrentUser();
     this.setAuthState(user, tokenResponse.accessToken, tokenResponse.refreshToken);
     return user;
   }
@@ -299,7 +349,7 @@ var AuthModule = class {
    * ```
    */
   async refreshSession() {
-    if (!this._refreshToken) return false;
+    if (!this.#refreshToken) return false;
     if (this.refreshPromise) return this.refreshPromise;
     this.refreshPromise = this.doRefresh();
     try {
@@ -323,9 +373,9 @@ var AuthModule = class {
    * ```
    */
   async me() {
-    if (!this._accessToken) return null;
+    if (!this.#accessToken) return null;
     try {
-      const user = await this.authedClient.get("/api/v1/auth/me");
+      const user = await this.getCurrentUser();
       this._currentUser = user;
       this.saveToStorage();
       this.notifyListeners();
@@ -366,7 +416,7 @@ var AuthModule = class {
    * ```
    */
   setToken(token, saveToStorage = true) {
-    this._accessToken = token;
+    this.#accessToken = token;
     if (saveToStorage) {
       this.saveToStorage();
     }
@@ -417,11 +467,11 @@ var AuthModule = class {
     try {
       const tokenResponse = await this.publicClient.post(
         "/api/v1/auth/refresh-token",
-        { refreshToken: this._refreshToken }
+        { refreshToken: this.#refreshToken }
       );
-      this._accessToken = tokenResponse.accessToken;
-      this._refreshToken = tokenResponse.refreshToken;
-      const user = await this.authedClient.get("/api/v1/auth/me");
+      this.#accessToken = tokenResponse.accessToken;
+      this.#refreshToken = tokenResponse.refreshToken;
+      const user = await this.getCurrentUser();
       this.setAuthState(user, tokenResponse.accessToken, tokenResponse.refreshToken);
       return true;
     } catch {
@@ -431,15 +481,19 @@ var AuthModule = class {
   }
   setAuthState(user, token, refreshToken) {
     this._currentUser = user;
-    this._accessToken = token;
-    this._refreshToken = refreshToken;
+    this.#accessToken = token;
+    this.#refreshToken = refreshToken;
     this.saveToStorage();
     this.notifyListeners();
   }
+  async getCurrentUser() {
+    const user = await this.currentUserApi.me();
+    return { ...user, tenantId: user.tenant.id };
+  }
   clearAuthState() {
     this._currentUser = null;
-    this._accessToken = null;
-    this._refreshToken = null;
+    this.#accessToken = null;
+    this.#refreshToken = null;
     this.removeFromStorage();
     this.notifyListeners();
   }
@@ -459,8 +513,8 @@ var AuthModule = class {
         this.storageKey,
         JSON.stringify({
           user: this._currentUser,
-          token: this._accessToken,
-          refreshToken: this._refreshToken
+          token: this.#accessToken,
+          refreshToken: this.#refreshToken
         })
       );
     } catch {
@@ -473,8 +527,8 @@ var AuthModule = class {
       if (stored) {
         const { user, token, refreshToken } = JSON.parse(stored);
         this._currentUser = user;
-        this._accessToken = token;
-        this._refreshToken = refreshToken ?? null;
+        this.#accessToken = token;
+        this.#refreshToken = refreshToken ?? null;
       }
     } catch {
       this.removeFromStorage();
@@ -490,208 +544,115 @@ var AuthModule = class {
 };
 
 // src/modules/entities.ts
+var import_sdk_core2 = require("@mitralab.io/sdk-core");
 var EntitiesModule = class _EntitiesModule {
-  httpClient;
-  dataSourceId;
-  tableProxies = /* @__PURE__ */ new Map();
   constructor(httpClient, dataSourceId) {
     this.httpClient = httpClient;
-    this.dataSourceId = dataSourceId;
+    void dataSourceId;
+    this.core = (0, import_sdk_core2.createEntitiesModule)(httpClient, coreErrors);
   }
+  core;
   static createProxy(httpClient, dataSourceId) {
     const instance = new _EntitiesModule(httpClient, dataSourceId);
     return new Proxy(instance, {
-      get: (target, prop) => {
-        if (prop in target) {
-          return target[prop];
+      get(target, property, receiver) {
+        if (typeof property !== "string" || property in target) {
+          return Reflect.get(target, property, receiver);
         }
-        return target.getTable(prop);
+        return target.getTable(property);
       }
     });
   }
+  /**
+   * Preserved for Platform SDK 1.x compatibility.
+   * Records now resolve the app from authenticated context instead of a data source path.
+   */
   setDataSourceId(dataSourceId) {
-    this.dataSourceId = dataSourceId;
-    this.tableProxies.clear();
+    void dataSourceId;
+    this.core = (0, import_sdk_core2.createEntitiesModule)(this.httpClient, coreErrors);
   }
   getTable(tableName) {
-    if (!this.tableProxies.has(tableName)) {
-      this.tableProxies.set(tableName, this.createTableAccessor(tableName));
-    }
-    return this.tableProxies.get(tableName);
-  }
-  createTableAccessor(tableName) {
-    const basePath = `/api/v1/data-sources/${this.dataSourceId}/tables/${tableName}/records`;
-    return {
-      list: async (sortOrOptions, limit, skip, fields) => {
-        let params;
-        if (typeof sortOrOptions === "string" || sortOrOptions === void 0) {
-          params = {
-            sort: sortOrOptions,
-            limit,
-            skip,
-            fields: fields?.join(",")
-          };
-        } else {
-          params = {
-            sort: sortOrOptions.sort,
-            limit: sortOrOptions.limit,
-            skip: sortOrOptions.skip,
-            fields: sortOrOptions.fields?.join(",")
-          };
-        }
-        const response = await this.httpClient.get(basePath, params);
-        return response.data;
-      },
-      filter: async (query, sort, limit, skip, fields) => {
-        const params = {
-          q: JSON.stringify(query),
-          sort,
-          limit,
-          skip,
-          fields: fields?.join(",")
-        };
-        const response = await this.httpClient.get(basePath, params);
-        return response.data;
-      },
-      get: async (id) => {
-        return this.httpClient.get(`${basePath}/${id}`);
-      },
-      create: async (data) => {
-        return this.httpClient.post(basePath, data);
-      },
-      update: async (id, data) => {
-        return this.httpClient.put(`${basePath}/${id}`, data);
-      },
-      delete: async (id) => {
-        return this.httpClient.delete(`${basePath}/${id}`);
-      },
-      deleteMany: async (query) => {
-        return this.httpClient.delete(basePath, {
-          q: JSON.stringify(query)
-        });
-      },
-      bulkCreate: async (data) => {
-        return this.httpClient.post(`${basePath}/bulk`, data);
-      }
-    };
+    return this.core.getTable(tableName);
   }
 };
 
 // src/modules/functions.ts
+var import_sdk_core3 = require("@mitralab.io/sdk-core");
 var FunctionsModule = class {
-  httpClient;
+  core;
   constructor(httpClient) {
-    this.httpClient = httpClient;
+    this.core = (0, import_sdk_core3.createFunctionsModule)(httpClient, { emptyInput: "omit-body" }, coreErrors);
   }
   /**
-   * Executes a serverless function by ID.
-   *
-   * Triggers the function's current published version with the provided input.
-   *
-   * @param functionId - UUID of the function to execute.
-   * @param input - Input data to pass to the function.
-   * @returns The execution result with status, output, and metadata.
-   * @throws {MitraApiError} On function not found (404) or unauthorized (401).
-   *
-   * @example
-   * ```typescript
-   * const execution = await mitra.functions.execute('fn-id', { key: 'value' });
-   * console.log(execution.status, execution.output);
-   * ```
+   * Executes a Function using the Platform SDK 1.x server-default invocation semantics.
+   * The runtime SDK uses an explicit invocation header instead.
    */
   async execute(functionId, input) {
-    return this.httpClient.post(
-      `/api/v1/functions/${functionId}/execute`,
-      input ? { input } : void 0
-    );
+    const execution = await this.core.execute(functionId, input);
+    if (execution.input === null) {
+      throw coreErrors.invalidResponse(
+        "Function execution response has an invalid input field"
+      );
+    }
+    return { ...execution, input: execution.input };
   }
 };
 
 // src/modules/integration.ts
+var import_sdk_core4 = require("@mitralab.io/sdk-core");
 var IntegrationModule = class {
-  httpClient;
+  core;
   constructor(httpClient) {
-    this.httpClient = httpClient;
+    this.core = (0, import_sdk_core4.createIntegrationModule)(httpClient, coreErrors);
   }
-  /**
-   * Executes a pre-defined integration resource by ID.
-   *
-   * The resource's endpoint, method, and body are resolved server-side
-   * using the provided parameters. Only declared parameters can be passed.
-   *
-   * @param resourceId - UUID of the integration resource.
-   * @param params - Named parameters declared in the resource's params schema.
-   * @returns Proxy result with status, headers, body, and execution metadata.
-   * @throws {MitraApiError} On resource not found (404) or external API failure.
-   *
-   * @example
-   * ```typescript
-   * const result = await mitra.integration.executeResource('resource-id', {
-   *   descricao: 'Notebook',
-   *   limit: 10,
-   * });
-   * console.log(result.body);
-   * ```
-   */
-  async executeResource(resourceId, params) {
-    return this.httpClient.post(
-      `/api/v1/proxy/resources/${resourceId}/execute`,
-      { params }
-    );
+  executeResource(resourceId, params) {
+    return this.core.executeResource(resourceId, params);
   }
-  /**
-   * Executes a proxied HTTP request through an integration config.
-   *
-   * The Mitra server handles authentication and injects credentials automatically.
-   * Note: integrations configured with RESOURCE_ONLY mode will block direct proxy access.
-   *
-   * @param configId - UUID of the integration config.
-   * @param request - The HTTP request to proxy (method, endpoint, body, etc.).
-   * @returns Proxy result with status, headers, body, and execution metadata.
-   * @throws {MitraApiError} On config not found (404) or external API failure.
-   */
-  async execute(configId, request) {
-    return this.httpClient.post(
-      `/api/v1/proxy/template-configs/${configId}/execute`,
-      { ...request, source: "SDK" }
-    );
+  execute(configId, request) {
+    return this.core.execute(configId, request);
   }
 };
 
 // src/modules/queries.ts
+var import_sdk_core5 = require("@mitralab.io/sdk-core");
 var QueriesModule = class {
-  httpClient;
   dataSourceId = "";
+  core;
   constructor(httpClient) {
-    this.httpClient = httpClient;
+    this.core = (0, import_sdk_core5.createQueriesModule)(httpClient, () => this.dataSourceId, coreErrors);
   }
-  /** @internal Called by client.init() to set the resolved data source. */
+  /** Called by `client.init()` to set the app's resolved data source. */
   setDataSourceId(dataSourceId) {
     this.dataSourceId = dataSourceId;
   }
-  /**
-   * Executes a named query.
-   *
-   * @param id - UUID of the custom query.
-   * @param parameters - Named parameters for the prepared statement.
-   * @returns Query result with rows and affected row count.
-   * @throws {MitraApiError} On query not found (404).
-   *
-   * @example
-   * ```typescript
-   * const result = await mitra.queries.execute('query-id', { status: 'active' });
-   * console.log(`Found ${result.rows.length} rows`);
-   * ```
-   */
   async execute(id, parameters) {
-    return this.httpClient.post(
-      `/api/v1/custom-queries/${id}/execute`,
-      { datasourceId: this.dataSourceId, parameters }
-    );
+    const result = await this.core.execute(id, parameters);
+    return { ...result, affectedRows: result.affectedRows ?? null };
   }
 };
 
 // src/client.ts
+function expectAppInfoResponse(value) {
+  const response = (0, import_sdk_core6.expectObject)(
+    value,
+    "App info response",
+    coreErrors
+  );
+  if (typeof response.dataSourceId !== "string" || !response.dataSourceId.trim()) {
+    throw coreErrors.invalidResponse(
+      "App info response has an invalid dataSourceId field"
+    );
+  }
+  if (typeof response.allowSignup !== "boolean") {
+    throw coreErrors.invalidResponse(
+      "App info response has an invalid allowSignup field"
+    );
+  }
+  return {
+    dataSourceId: response.dataSourceId,
+    allowSignup: response.allowSignup
+  };
+}
 function createClient(config) {
   const { appId, apiUrl, onError } = config;
   const iamUrl = `${apiUrl}/iam`;
@@ -735,8 +696,10 @@ function createClient(config) {
       baseUrl: codeStudioUrl,
       getToken: () => null
     });
-    const appInfo = await publicClient.get(
-      `/api/v1/apps/${appId}/info`
+    const appInfo = expectAppInfoResponse(
+      await publicClient.get(
+        `/api/v1/apps/${(0, import_sdk_core6.encodePathSegment)(appId, "appId", coreErrors)}/info`
+      )
     );
     entitiesModule.setDataSourceId(appInfo.dataSourceId);
     queriesModule.setDataSourceId(appInfo.dataSourceId);