@mitralab.io/platform-sdk 1.0.8 → 1.1.0-beta.0

package/dist/index.mjs

@@ -1,706 +0,0 @@
-// src/client.ts
-import { encodePathSegment, expectObject } from "@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;
-  onUnauthorized;
-  onError;
-  defaultHeaders;
-  constructor(config) {
-    this.baseUrl = config.baseUrl.replace(/\/$/, "");
-    this.tokenGetter = config.getToken ?? (() => null);
-    this.onUnauthorized = config.onUnauthorized;
-    this.onError = config.onError;
-    this.defaultHeaders = config.defaultHeaders ?? {};
-  }
-  /**
-   * Returns the current authentication token.
-   * @returns The JWT token if authenticated, null otherwise
-   */
-  getToken() {
-    return this.tokenGetter();
-  }
-  /**
-   * Makes an HTTP request with automatic JSON handling and authentication.
-   *
-   * @param path - API endpoint path (e.g., '/users')
-   * @param options - Request options including method, body, headers, and params
-   * @returns Promise resolving to the parsed JSON response
-   * @throws {MitraApiError} When the API returns an error response
-   *
-   * @example
-   * ```typescript
-   * const result = await client.request<User>('/users/123', {
-   *   method: 'PUT',
-   *   body: { name: 'Updated Name' },
-   * });
-   * ```
-   */
-  async request(path, options = {}) {
-    const { method = "GET", body, headers = {}, params, isRetry } = options;
-    let url = `${this.baseUrl}${path}`;
-    if (params) {
-      const searchParams = new URLSearchParams();
-      Object.entries(params).forEach(([key, value]) => {
-        if (value !== void 0) {
-          searchParams.append(key, String(value));
-        }
-      });
-      const queryString = searchParams.toString();
-      if (queryString) {
-        url += `?${queryString}`;
-      }
-    }
-    const requestHeaders = {
-      "Content-Type": "application/json",
-      ...this.defaultHeaders,
-      ...headers
-    };
-    const token = this.tokenGetter();
-    if (token) {
-      requestHeaders["Authorization"] = `Bearer ${token}`;
-    }
-    const response = await fetch(url, {
-      method,
-      headers: requestHeaders,
-      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();
-        if (refreshed) {
-          return this.request(path, { ...options, isRetry: true });
-        }
-      }
-      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(
-        redactText(rawMessage || `Request failed with status ${response.status}`, token),
-        response.status,
-        rawCode === void 0 ? void 0 : redactText(rawCode, token),
-        redactDetails(errorBody, token)
-      );
-      this.onError?.(error);
-      throw error;
-    }
-    if (response.status === 204) {
-      return void 0;
-    }
-    return response.json();
-  }
-  /**
-   * Makes a GET request.
-   *
-   * @param path - API endpoint path
-   * @param params - Optional query parameters
-   * @returns Promise resolving to the parsed JSON response
-   *
-   * @example
-   * ```typescript
-   * const users = await client.get<User[]>('/users', { limit: 10 });
-   * ```
-   */
-  get(path, params) {
-    return this.request(path, { method: "GET", params });
-  }
-  /**
-   * Makes a POST request.
-   *
-   * @param path - API endpoint path
-   * @param body - Request body (will be JSON stringified)
-   * @returns Promise resolving to the parsed JSON response
-   *
-   * @example
-   * ```typescript
-   * const user = await client.post<User>('/users', { name: 'John', email: 'john@example.com' });
-   * ```
-   */
-  post(path, body) {
-    return this.request(path, { method: "POST", body });
-  }
-  /**
-   * Makes a PUT request.
-   *
-   * @param path - API endpoint path
-   * @param body - Request body (will be JSON stringified)
-   * @returns Promise resolving to the parsed JSON response
-   *
-   * @example
-   * ```typescript
-   * const user = await client.put<User>('/users/123', { name: 'Updated Name' });
-   * ```
-   */
-  put(path, body) {
-    return this.request(path, { method: "PUT", body });
-  }
-  /**
-   * Makes a DELETE request.
-   *
-   * @param path - API endpoint path
-   * @param params - Optional query parameters
-   * @returns Promise resolving to the parsed JSON response (or undefined for 204 responses)
-   *
-   * @example
-   * ```typescript
-   * await client.delete('/users/123');
-   * ```
-   */
-  delete(path, params) {
-    return this.request(path, { method: "DELETE", params });
-  }
-};
-var MitraApiError = class extends Error {
-  constructor(message, status, code, details) {
-    super(message);
-    this.status = status;
-    this.code = code;
-    this.details = details;
-    this.name = "MitraApiError";
-  }
-};
-
-// 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
-import { createAuthModule } from "@mitralab.io/sdk-core";
-var AuthModule = class {
-  appId;
-  _currentUser = 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.currentUserApi = createAuthModule(this.authedClient, coreErrors);
-    this.loadFromStorage();
-  }
-  /** The currently authenticated user, or null. */
-  get currentUser() {
-    return this._currentUser;
-  }
-  /** The current JWT access token, or null. */
-  get accessToken() {
-    return this.#accessToken;
-  }
-  /** Whether a user is currently authenticated (local check, not server-validated). */
-  get isAuthenticated() {
-    return this._currentUser !== null && this.#accessToken !== null;
-  }
-  /**
-   * Signs in a user with email and password.
-   *
-   * On success, stores access token, refresh token, and user data.
-   * Subsequent API requests use the token automatically.
-   *
-   * @param credentials - Email and password.
-   * @returns The authenticated user.
-   * @throws {MitraApiError} On invalid credentials (401).
-   *
-   * @example
-   * ```typescript
-   * const user = await mitra.auth.signIn({
-   *   email: 'user@example.com',
-   *   password: 'password123',
-   * });
-   * ```
-   */
-  async signIn(credentials) {
-    const tokenResponse = await this.publicClient.post(
-      "/api/v1/auth/login",
-      { ...credentials, appId: this.appId }
-    );
-    this.#accessToken = tokenResponse.accessToken;
-    this.#refreshToken = tokenResponse.refreshToken;
-    const user = await this.getCurrentUser();
-    this.setAuthState(user, tokenResponse.accessToken, tokenResponse.refreshToken);
-    return user;
-  }
-  /**
-   * Registers a new user and signs them in automatically.
-   *
-   * @param data - Email, password, and optional name.
-   * @returns The newly created and authenticated user.
-   * @throws {MitraApiError} On duplicate email (409) or validation error (400).
-   *
-   * @example
-   * ```typescript
-   * const user = await mitra.auth.signUp({
-   *   email: 'new@example.com',
-   *   password: 'securepassword',
-   *   name: 'Jane Doe',
-   * });
-   * ```
-   */
-  async signUp(data) {
-    await this.publicClient.post("/api/v1/auth/register", {
-      ...data,
-      appId: this.appId
-    });
-    return this.signIn({ email: data.email, password: data.password });
-  }
-  /**
-   * Signs out the current user, clearing all auth state and localStorage.
-   *
-   * @param redirectUrl - Optional URL to navigate to after sign-out.
-   *
-   * @example
-   * ```typescript
-   * mitra.auth.signOut();
-   * mitra.auth.signOut('/login');
-   * ```
-   */
-  signOut(redirectUrl) {
-    this.clearAuthState();
-    if (globalThis.window !== void 0 && redirectUrl) {
-      globalThis.window.location.href = redirectUrl;
-    }
-  }
-  /**
-   * Refreshes the session using the stored refresh token.
-   *
-   * Called automatically by the SDK on 401 responses. Can also be called
-   * manually. Multiple concurrent calls are deduplicated (only one refresh
-   * request is made).
-   *
-   * @returns `true` if refresh succeeded, `false` otherwise.
-   *
-   * @example
-   * ```typescript
-   * const ok = await mitra.auth.refreshSession();
-   * if (!ok) mitra.auth.redirectToLogin();
-   * ```
-   */
-  async refreshSession() {
-    if (!this.#refreshToken) return false;
-    if (this.refreshPromise) return this.refreshPromise;
-    this.refreshPromise = this.doRefresh();
-    try {
-      return await this.refreshPromise;
-    } finally {
-      this.refreshPromise = null;
-    }
-  }
-  /**
-   * Fetches the current user from the server and updates local state.
-   *
-   * Only clears auth state on 401 (expired/invalid token).
-   * Transient errors (500, network) return null without clearing the session.
-   *
-   * @returns The user if authenticated, `null` otherwise.
-   *
-   * @example
-   * ```typescript
-   * const user = await mitra.auth.me();
-   * if (!user) console.log('Not authenticated');
-   * ```
-   */
-  async me() {
-    if (!this.#accessToken) return null;
-    try {
-      const user = await this.getCurrentUser();
-      this._currentUser = user;
-      this.saveToStorage();
-      this.notifyListeners();
-      return user;
-    } catch (error) {
-      if (error instanceof MitraApiError && error.status === 401) {
-        this.clearAuthState();
-      }
-      return null;
-    }
-  }
-  /**
-   * Validates the current session with the server.
-   *
-   * @returns `true` if the session is valid, `false` otherwise.
-   *
-   * @example
-   * ```typescript
-   * const valid = await mitra.auth.checkAuth();
-   * if (!valid) mitra.auth.redirectToLogin();
-   * ```
-   */
-  async checkAuth() {
-    return await this.me() !== null;
-  }
-  /**
-   * Sets the access token manually (e.g., from SSO/OAuth callback).
-   *
-   * Call `me()` afterwards to fetch the associated user data.
-   *
-   * @param token - JWT access token.
-   * @param saveToStorage - Whether to persist to localStorage (default: true).
-   *
-   * @example
-   * ```typescript
-   * mitra.auth.setToken(tokenFromCallback);
-   * await mitra.auth.me();
-   * ```
-   */
-  setToken(token, saveToStorage = true) {
-    this.#accessToken = token;
-    if (saveToStorage) {
-      this.saveToStorage();
-    }
-  }
-  /**
-   * Redirects to `/login?returnUrl=...` for unauthenticated users.
-   *
-   * @param returnUrl - URL to return to after login (default: '/').
-   *
-   * @example
-   * ```typescript
-   * if (!mitra.auth.isAuthenticated) {
-   *   mitra.auth.redirectToLogin(window.location.pathname);
-   * }
-   * ```
-   */
-  redirectToLogin(returnUrl = "/") {
-    if (globalThis.window === void 0) return;
-    globalThis.window.location.href = `/login?returnUrl=${encodeURIComponent(returnUrl)}`;
-  }
-  /**
-   * Registers a callback for auth state changes.
-   *
-   * Called immediately with the current state, then on every sign-in/sign-out.
-   *
-   * @param callback - Receives the User on login, null on logout.
-   * @returns Unsubscribe function.
-   *
-   * @example
-   * ```typescript
-   * useEffect(() => {
-   *   const unsub = mitra.auth.onAuthStateChange((user) => {
-   *     setUser(user);
-   *     setLoading(false);
-   *   });
-   *   return unsub;
-   * }, []);
-   * ```
-   */
-  onAuthStateChange(callback) {
-    this.listeners.add(callback);
-    callback(this._currentUser);
-    return () => {
-      this.listeners.delete(callback);
-    };
-  }
-  async doRefresh() {
-    try {
-      const tokenResponse = await this.publicClient.post(
-        "/api/v1/auth/refresh-token",
-        { refreshToken: this.#refreshToken }
-      );
-      this.#accessToken = tokenResponse.accessToken;
-      this.#refreshToken = tokenResponse.refreshToken;
-      const user = await this.getCurrentUser();
-      this.setAuthState(user, tokenResponse.accessToken, tokenResponse.refreshToken);
-      return true;
-    } catch {
-      this.clearAuthState();
-      return false;
-    }
-  }
-  setAuthState(user, token, refreshToken) {
-    this._currentUser = user;
-    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.removeFromStorage();
-    this.notifyListeners();
-  }
-  notifyListeners() {
-    this.listeners.forEach((callback) => {
-      try {
-        callback(this._currentUser);
-      } catch (error) {
-        console.error("Auth state change listener error:", error);
-      }
-    });
-  }
-  saveToStorage() {
-    if (typeof localStorage === "undefined") return;
-    try {
-      localStorage.setItem(
-        this.storageKey,
-        JSON.stringify({
-          user: this._currentUser,
-          token: this.#accessToken,
-          refreshToken: this.#refreshToken
-        })
-      );
-    } catch {
-    }
-  }
-  loadFromStorage() {
-    if (typeof localStorage === "undefined") return;
-    try {
-      const stored = localStorage.getItem(this.storageKey);
-      if (stored) {
-        const { user, token, refreshToken } = JSON.parse(stored);
-        this._currentUser = user;
-        this.#accessToken = token;
-        this.#refreshToken = refreshToken ?? null;
-      }
-    } catch {
-      this.removeFromStorage();
-    }
-  }
-  removeFromStorage() {
-    if (typeof localStorage === "undefined") return;
-    try {
-      localStorage.removeItem(this.storageKey);
-    } catch {
-    }
-  }
-};
-
-// src/modules/entities.ts
-import {
-  createEntitiesModule
-} from "@mitralab.io/sdk-core";
-var EntitiesModule = class _EntitiesModule {
-  constructor(httpClient, dataSourceId) {
-    this.httpClient = httpClient;
-    void dataSourceId;
-    this.core = createEntitiesModule(httpClient, coreErrors);
-  }
-  core;
-  static createProxy(httpClient, dataSourceId) {
-    const instance = new _EntitiesModule(httpClient, dataSourceId);
-    return new Proxy(instance, {
-      get(target, property, receiver) {
-        if (typeof property !== "string" || property in target) {
-          return Reflect.get(target, property, receiver);
-        }
-        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) {
-    void dataSourceId;
-    this.core = createEntitiesModule(this.httpClient, coreErrors);
-  }
-  getTable(tableName) {
-    return this.core.getTable(tableName);
-  }
-};
-
-// src/modules/functions.ts
-import {
-  createFunctionsModule
-} from "@mitralab.io/sdk-core";
-var FunctionsModule = class {
-  core;
-  constructor(httpClient) {
-    this.core = createFunctionsModule(httpClient, { emptyInput: "omit-body" }, coreErrors);
-  }
-  /**
-   * 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) {
-    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
-import {
-  createIntegrationModule
-} from "@mitralab.io/sdk-core";
-var IntegrationModule = class {
-  core;
-  constructor(httpClient) {
-    this.core = createIntegrationModule(httpClient, coreErrors);
-  }
-  executeResource(resourceId, params) {
-    return this.core.executeResource(resourceId, params);
-  }
-  execute(configId, request) {
-    return this.core.execute(configId, request);
-  }
-};
-
-// src/modules/queries.ts
-import {
-  createQueriesModule
-} from "@mitralab.io/sdk-core";
-var QueriesModule = class {
-  dataSourceId = "";
-  core;
-  constructor(httpClient) {
-    this.core = createQueriesModule(httpClient, () => this.dataSourceId, coreErrors);
-  }
-  /** Called by `client.init()` to set the app's resolved data source. */
-  setDataSourceId(dataSourceId) {
-    this.dataSourceId = dataSourceId;
-  }
-  async execute(id, parameters) {
-    const result = await this.core.execute(id, parameters);
-    return { ...result, affectedRows: result.affectedRows ?? null };
-  }
-};
-
-// src/client.ts
-function expectAppInfoResponse(value) {
-  const response = 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`;
-  const dataManagerUrl = `${apiUrl}/data-manager`;
-  const functionsUrl = `${apiUrl}/functions`;
-  const integrationUrl = `${apiUrl}/integration`;
-  const codeStudioUrl = `${apiUrl}/code-studio`;
-  const authModule = new AuthModule(appId, iamUrl);
-  const onUnauthorized = () => authModule.refreshSession();
-  const defaultHeaders = { "X-App-Id": appId };
-  const httpClient = new HttpClient({
-    baseUrl: dataManagerUrl,
-    getToken: () => authModule.accessToken,
-    onUnauthorized,
-    onError,
-    defaultHeaders
-  });
-  const entitiesModule = EntitiesModule.createProxy(httpClient, "");
-  const functionsHttpClient = new HttpClient({
-    baseUrl: functionsUrl,
-    getToken: () => authModule.accessToken,
-    onUnauthorized,
-    onError,
-    defaultHeaders
-  });
-  const functionsModule = new FunctionsModule(functionsHttpClient);
-  const integrationHttpClient = new HttpClient({
-    baseUrl: integrationUrl,
-    getToken: () => authModule.accessToken,
-    onUnauthorized,
-    onError,
-    defaultHeaders
-  });
-  const integrationModule = new IntegrationModule(integrationHttpClient);
-  const queriesModule = new QueriesModule(httpClient);
-  let initialized = false;
-  let allowSignup = true;
-  async function init() {
-    if (initialized) return;
-    const publicClient = new HttpClient({
-      baseUrl: codeStudioUrl,
-      getToken: () => null
-    });
-    const appInfo = expectAppInfoResponse(
-      await publicClient.get(
-        `/api/v1/apps/${encodePathSegment(appId, "appId", coreErrors)}/info`
-      )
-    );
-    entitiesModule.setDataSourceId(appInfo.dataSourceId);
-    queriesModule.setDataSourceId(appInfo.dataSourceId);
-    allowSignup = appInfo.allowSignup;
-    initialized = true;
-  }
-  return {
-    init,
-    auth: authModule,
-    entities: entitiesModule,
-    functions: functionsModule,
-    integration: integrationModule,
-    queries: queriesModule,
-    get allowSignup() {
-      return allowSignup;
-    },
-    config
-  };
-}
-export {
-  MitraApiError,
-  createClient
-};