@mosano-product-framework/sdk 0.2.0

package/dist/chunk-LRM6JJ63.js

@@ -0,0 +1,616 @@
+import { MPFAPIError, MPFAuthError, MPFNetworkError, MPFError, tryDecodeAccessToken } from './chunk-AJWM5MDZ.js';
+
+// src/client/core/middleware.ts
+async function executeRequestMiddlewares(middlewares, ctx) {
+  let currentCtx = ctx;
+  for (const middleware of middlewares) {
+    if (middleware.onRequest) {
+      currentCtx = await middleware.onRequest(currentCtx);
+    }
+  }
+  return currentCtx;
+}
+async function executeResponseMiddlewares(middlewares, ctx) {
+  let currentCtx = ctx;
+  for (let i = middlewares.length - 1; i >= 0; i--) {
+    const middleware = middlewares[i];
+    if (middleware.onResponse) {
+      currentCtx = await middleware.onResponse(currentCtx);
+    }
+  }
+  return currentCtx;
+}
+async function executeErrorMiddlewares(middlewares, error, ctx) {
+  let currentError = error;
+  for (const middleware of middlewares) {
+    if (!middleware.onError) {
+      continue;
+    }
+    try {
+      await middleware.onError(currentError, ctx);
+    } catch (thrown) {
+      if (thrown instanceof Error) {
+        currentError = thrown;
+      }
+    }
+  }
+  throw currentError;
+}
+
+// src/client/middlewares/retry.ts
+var RETRY_ATTEMPT_KEY = "__retryAttempt";
+var SHOULD_RETRY_KEY = "__shouldRetry";
+var NO_RETRY_KEY = "__noRetry";
+var DEFAULT_RETRY_STATUS_CODES = [408, 429, 500, 502, 503, 504];
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function calculateDelay(attempt, baseDelay, backoffFactor, maxDelay, useJitter) {
+  const exponentialDelay = baseDelay * Math.pow(backoffFactor, attempt);
+  const cappedDelay = Math.min(exponentialDelay, maxDelay);
+  if (useJitter) {
+    const jitterFactor = 1 + Math.random() * 0.25;
+    return Math.floor(cappedDelay * jitterFactor);
+  }
+  return Math.floor(cappedDelay);
+}
+function createRetryMiddleware(options) {
+  const {
+    maxRetries = 3,
+    retryDelay = 1e3,
+    retryOn = DEFAULT_RETRY_STATUS_CODES,
+    backoffFactor = 2,
+    maxDelay = 3e4,
+    jitter = true,
+    onRetry,
+    shouldRetry: customShouldRetry
+  } = options ?? {};
+  function shouldRetry(error, attempt) {
+    if (attempt >= maxRetries) {
+      return false;
+    }
+    if (customShouldRetry) {
+      return customShouldRetry(error, attempt);
+    }
+    if (error instanceof MPFError && error.status !== void 0) {
+      return retryOn.includes(error.status);
+    }
+    if (error.name === "TypeError" && error.message.includes("fetch")) {
+      return true;
+    }
+    return false;
+  }
+  function getRetryAfterDelay(error) {
+    if (error instanceof MPFAPIError && error.details) {
+      const details = error.details;
+      const retryAfter = details["retryAfter"] || details["retry-after"] || details["Retry-After"];
+      if (typeof retryAfter === "number") {
+        return retryAfter * 1e3;
+      }
+      if (typeof retryAfter === "string") {
+        const seconds = parseInt(retryAfter, 10);
+        if (!isNaN(seconds)) {
+          return seconds * 1e3;
+        }
+        const date = new Date(retryAfter);
+        if (!isNaN(date.getTime())) {
+          const delay = date.getTime() - Date.now();
+          return delay > 0 ? delay : null;
+        }
+      }
+    }
+    return null;
+  }
+  return {
+    name: "retry",
+    onRequest(ctx) {
+      if (ctx.metadata[RETRY_ATTEMPT_KEY] === void 0) {
+        ctx.metadata[RETRY_ATTEMPT_KEY] = 0;
+      }
+      return ctx;
+    },
+    async onError(error, ctx) {
+      const currentAttempt = ctx.metadata[RETRY_ATTEMPT_KEY] ?? 0;
+      if (!shouldRetry(error, currentAttempt)) {
+        throw error;
+      }
+      let delay = getRetryAfterDelay(error);
+      if (delay === null) {
+        delay = calculateDelay(currentAttempt, retryDelay, backoffFactor, maxDelay, jitter);
+      }
+      delay = Math.min(delay, maxDelay);
+      if (onRetry) {
+        try {
+          await onRetry(currentAttempt + 1, error, delay);
+        } catch (callbackError) {
+          console.error("[MPF SDK] Error in onRetry callback:", callbackError);
+        }
+      }
+      await sleep(delay);
+      ctx.metadata[RETRY_ATTEMPT_KEY] = currentAttempt + 1;
+      requestRetry(ctx);
+      throw error;
+    }
+  };
+}
+function shouldRetryRequest(ctx) {
+  return ctx.metadata[SHOULD_RETRY_KEY] === true && !isRetryDisabled(ctx);
+}
+function requestRetry(ctx) {
+  ctx.metadata[SHOULD_RETRY_KEY] = true;
+}
+function disableRetry(ctx) {
+  ctx.metadata[NO_RETRY_KEY] = true;
+}
+function isRetryDisabled(ctx) {
+  return ctx.metadata[NO_RETRY_KEY] === true;
+}
+function isReplayableBody(body) {
+  if (body === null || body === void 0) {
+    return true;
+  }
+  if (typeof ReadableStream !== "undefined" && body instanceof ReadableStream) {
+    return false;
+  }
+  return true;
+}
+function getRetryAttempt(ctx) {
+  return ctx.metadata[RETRY_ATTEMPT_KEY] ?? 0;
+}
+function clearRetryFlag(ctx) {
+  delete ctx.metadata[SHOULD_RETRY_KEY];
+}
+
+// src/client/core/client.ts
+var MAX_REQUEST_ATTEMPTS = 4;
+var MPFClient = class {
+  baseUrl;
+  defaultHeaders;
+  middlewares;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+    this.defaultHeaders = {
+      "Content-Type": "application/json",
+      "Accept": "application/json",
+      ...config.headers
+    };
+    this.middlewares = [...config.middlewares ?? []];
+  }
+  /**
+   * Add a middleware to the client
+   * Middlewares are executed in the order they are added for requests,
+   * and in reverse order for responses.
+   *
+   * @param middleware - The middleware to add
+   * @returns The client instance for chaining
+   */
+  use(middleware) {
+    this.middlewares.push(middleware);
+    return this;
+  }
+  /**
+   * Build a full URL with query parameters
+   *
+   * @param path - The API path (e.g., "/users" or "users")
+   * @param params - Optional query parameters
+   * @returns The full URL with query string
+   */
+  buildUrl(path, params) {
+    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+    const base = /^https?:\/\//.test(this.baseUrl) ? this.baseUrl : typeof window !== "undefined" ? window.location.origin : "http://localhost";
+    const url = new URL(`${this.baseUrl}${normalizedPath}`, base);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0 && value !== null) {
+          url.searchParams.append(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+  /**
+   * Merge headers from different sources
+   *
+   * @param requestHeaders - Headers specific to this request
+   * @returns Merged headers object
+   */
+  mergeHeaders(requestHeaders) {
+    return {
+      ...this.defaultHeaders,
+      ...requestHeaders
+    };
+  }
+  /**
+   * Build the headers for a single attempt.
+   *
+   * Rebuilt per attempt so request middlewares (auth, turnstile, ...) always
+   * inject a fresh token instead of replaying a stale one.
+   *
+   * For a `FormData` body the default JSON `Content-Type` is dropped so that
+   * fetch sets `multipart/form-data` with the correct boundary.
+   */
+  buildAttemptHeaders(init) {
+    const headers = this.mergeHeaders(init.headers);
+    if (typeof FormData !== "undefined" && init.body instanceof FormData) {
+      delete headers["Content-Type"];
+    }
+    return headers;
+  }
+  /**
+   * Parse the response body based on content type
+   *
+   * @param response - The fetch Response object
+   * @returns Parsed response data
+   */
+  async parseResponse(response) {
+    const contentType = response.headers.get("content-type") ?? "";
+    if (response.status === 204 || response.headers.get("content-length") === "0") {
+      return void 0;
+    }
+    if (contentType.includes("application/json")) {
+      const text2 = await response.text();
+      if (!text2) {
+        return void 0;
+      }
+      try {
+        return JSON.parse(text2);
+      } catch {
+        throw new MPFAPIError(
+          "Failed to parse JSON response",
+          "PARSE_ERROR",
+          response.status,
+          { text: text2 }
+        );
+      }
+    }
+    const text = await response.text();
+    return text;
+  }
+  /**
+   * Handle error responses from the API
+   *
+   * @param response - The fetch Response object
+   * @throws MPFAuthError for 401/403, MPFAPIError for other errors
+   */
+  async handleErrorResponse(response) {
+    let body;
+    let errorResponse;
+    try {
+      const text = await response.text();
+      if (text) {
+        body = JSON.parse(text);
+        errorResponse = body;
+      }
+    } catch {
+    }
+    const message = errorResponse?.message ?? errorResponse?.error ?? response.statusText ?? "Request failed";
+    const code = errorResponse?.code ?? `HTTP_${response.status}`;
+    const details = errorResponse?.details;
+    if (response.status === 401) {
+      const authType = code.toLowerCase().includes("expired") ? "token_expired" : "unauthorized";
+      throw new MPFAuthError(message, authType, 401, details, errorResponse?.code);
+    }
+    if (response.status === 403) {
+      throw new MPFAuthError(message, "forbidden", 403, details, errorResponse?.code);
+    }
+    throw new MPFAPIError(message, code, response.status, details, body);
+  }
+  /**
+   * Execute an HTTP request with the full middleware chain, retrying when a
+   * middleware asks for it.
+   *
+   * Retry contract:
+   * - `metadata` is created once and shared by every attempt. Middlewares keep
+   *   their per-request state there (retry counter, auth-renew flag); rebuilding
+   *   it per attempt would reset those counters and loop forever.
+   * - `init.headers` are rebuilt per attempt so request middlewares re-inject a
+   *   fresh token rather than replaying the first attempt's headers.
+   * - `MAX_REQUEST_ATTEMPTS` bounds the loop regardless of middleware config.
+   * - Bodies that cannot be re-sent (`ReadableStream`) disable retrying.
+   *
+   * @param path - The API path
+   * @param init - Fetch RequestInit options
+   * @returns The parsed response data
+   * @throws MPFNetworkError for network failures
+   * @throws MPFAuthError for 401/403 responses
+   * @throws MPFAPIError for other error responses
+   */
+  async request(path, init = {}, params, options) {
+    const url = this.buildUrl(path, params);
+    const metadata = {};
+    for (let attempt = 0; attempt < MAX_REQUEST_ATTEMPTS; attempt++) {
+      const requestCtx = {
+        url,
+        init: {
+          ...init,
+          headers: this.buildAttemptHeaders(init)
+        },
+        metadata,
+        options
+      };
+      if (!isReplayableBody(init.body)) {
+        disableRetry(requestCtx);
+      }
+      try {
+        return await this.attempt(requestCtx);
+      } catch (error) {
+        const isLastAttempt = attempt === MAX_REQUEST_ATTEMPTS - 1;
+        if (isLastAttempt || !shouldRetryRequest(requestCtx)) {
+          throw error;
+        }
+        clearRetryFlag(requestCtx);
+      }
+    }
+    throw new MPFNetworkError("Request retry loop exhausted");
+  }
+  /**
+   * Execute a single request attempt through the middleware chain.
+   *
+   * On failure the error middleware chain runs before the error propagates, so
+   * the caller can inspect `ctx.metadata` for a retry request.
+   */
+  async attempt(ctx) {
+    let requestCtx = ctx;
+    try {
+      requestCtx = await executeRequestMiddlewares(this.middlewares, requestCtx);
+      let response;
+      try {
+        response = await fetch(requestCtx.url, requestCtx.init);
+      } catch (error) {
+        throw new MPFNetworkError(
+          error instanceof Error ? error.message : "Network request failed",
+          error instanceof Error ? error : void 0
+        );
+      }
+      if (!response.ok) {
+        await this.handleErrorResponse(response);
+      }
+      const data = await this.parseResponse(response);
+      let responseCtx = {
+        response,
+        data,
+        metadata: requestCtx.metadata
+      };
+      responseCtx = await executeResponseMiddlewares(this.middlewares, responseCtx);
+      return responseCtx.data;
+    } catch (error) {
+      try {
+        if (error instanceof Error && this.middlewares.some((m) => m.onError)) {
+          await executeErrorMiddlewares(this.middlewares, error, requestCtx);
+        }
+        throw error;
+      } finally {
+        if (requestCtx.metadata !== ctx.metadata) {
+          Object.assign(ctx.metadata, requestCtx.metadata);
+        }
+      }
+    }
+  }
+  /**
+   * Make a GET request
+   *
+   * @param path - The API path
+   * @param options - Request options
+   * @returns The parsed response data
+   */
+  async get(path, options = {}) {
+    return this.request(path, {
+      method: "GET",
+      headers: options.headers,
+      signal: options.signal
+    }, options.params, options);
+  }
+  /**
+   * Make a POST request
+   *
+   * @param path - The API path
+   * @param body - Request body (will be JSON stringified)
+   * @param options - Request options
+   * @returns The parsed response data
+   */
+  async post(path, body, options = {}) {
+    return this.request(path, {
+      method: "POST",
+      headers: options.headers,
+      signal: options.signal,
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    }, options.params, options);
+  }
+  /**
+   * Make a PUT request
+   *
+   * @param path - The API path
+   * @param body - Request body (will be JSON stringified)
+   * @param options - Request options
+   * @returns The parsed response data
+   */
+  async put(path, body, options = {}) {
+    return this.request(path, {
+      method: "PUT",
+      headers: options.headers,
+      signal: options.signal,
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    }, options.params, options);
+  }
+  /**
+   * Make a PATCH request
+   *
+   * @param path - The API path
+   * @param body - Request body (will be JSON stringified)
+   * @param options - Request options
+   * @returns The parsed response data
+   */
+  async patch(path, body, options = {}) {
+    return this.request(path, {
+      method: "PATCH",
+      headers: options.headers,
+      signal: options.signal,
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    }, options.params, options);
+  }
+  /**
+   * Make a DELETE request
+   *
+   * @param path - The API path
+   * @param body - Optional request body (will be JSON stringified)
+   * @param options - Request options
+   * @returns The parsed response data
+   */
+  async delete(path, body, options = {}) {
+    return this.request(path, {
+      method: "DELETE",
+      headers: options.headers,
+      signal: options.signal,
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    }, options.params, options);
+  }
+};
+
+// src/client/middlewares/auth.ts
+var TOKEN_ATTACHED_KEY = "__authTokenAttached";
+var RENEW_ATTEMPTED_KEY = "__authRenewAttempted";
+function createAuthMiddleware(options) {
+  const {
+    getAccessToken,
+    onTokenExpired,
+    onUnauthorized,
+    tokenType = "Bearer",
+    headerName = "Authorization"
+  } = options;
+  return {
+    name: "auth",
+    async onRequest(ctx) {
+      if (ctx.options?.skipAuth) {
+        return ctx;
+      }
+      const token = await getAccessToken();
+      if (token) {
+        const headers = new Headers(ctx.init.headers);
+        headers.set(headerName, `${tokenType} ${token}`);
+        ctx.init.headers = headers;
+        ctx.metadata[TOKEN_ATTACHED_KEY] = true;
+      }
+      return ctx;
+    },
+    async onError(error, ctx) {
+      const status = error instanceof MPFError ? error.status : void 0;
+      if (status !== 401) {
+        throw error;
+      }
+      if (ctx.metadata[TOKEN_ATTACHED_KEY] !== true) {
+        throw error;
+      }
+      if (onUnauthorized && ctx.metadata[RENEW_ATTEMPTED_KEY] !== true) {
+        ctx.metadata[RENEW_ATTEMPTED_KEY] = true;
+        let renewed = false;
+        try {
+          renewed = await onUnauthorized();
+        } catch (renewError) {
+          console.error("[MPF SDK] Error in onUnauthorized callback:", renewError);
+          renewed = false;
+        }
+        if (renewed) {
+          requestRetry(ctx);
+          throw error;
+        }
+      }
+      if (onTokenExpired) {
+        try {
+          await onTokenExpired();
+        } catch (callbackError) {
+          console.error("[MPF SDK] Error in onTokenExpired callback:", callbackError);
+        }
+      }
+      throw error;
+    }
+  };
+}
+
+// src/client/middlewares/tenant.ts
+var TENANT_HEADER = "X-MPF-Tenant";
+var TENANT_ROLE_HEADER = "X-MPF-Tenant-Role";
+var UNSCOPED_WARNING = "[MPF SDK] Request sent with no tenant selected, but the access token holds tenant memberships. The server will scope this request to the default (tenantless) role, which usually means empty results or a 403 rather than tenant data. Wire a tenantProvider (createTenantSelection()) into your client and call set(tenantId), or pass `{ tenant: null }` on the request to state explicitly that it is unscoped. This warning is shown once.";
+function createTenantMiddleware(options = {}) {
+  const {
+    tenantProvider,
+    getAccessToken,
+    warnOnUnscoped = true,
+    logger = console
+  } = options;
+  let warned = false;
+  async function maybeWarnUnscoped() {
+    if (warned || !warnOnUnscoped || !getAccessToken) {
+      return;
+    }
+    let token;
+    try {
+      token = await getAccessToken();
+    } catch {
+      return;
+    }
+    const claims = tryDecodeAccessToken(token);
+    if (!claims || claims.tnts.length === 0) {
+      return;
+    }
+    warned = true;
+    logger.warn(UNSCOPED_WARNING);
+  }
+  return {
+    name: "tenant",
+    async onRequest(ctx) {
+      if (ctx.options?.skipTenant) {
+        return ctx;
+      }
+      const perRequest = ctx.options?.tenant;
+      const inherit = perRequest === void 0;
+      const selection = inherit ? tenantProvider?.get() : void 0;
+      const tenant = inherit ? selection?.tenant ?? null : perRequest;
+      const role = ctx.options?.tenantRole ?? (inherit ? selection?.role : void 0);
+      if (tenant === null || tenant === "") {
+        if (inherit) {
+          await maybeWarnUnscoped();
+        }
+        return ctx;
+      }
+      const headers = new Headers(ctx.init.headers);
+      headers.set(TENANT_HEADER, tenant);
+      if (role !== void 0 && role !== "") {
+        headers.set(TENANT_ROLE_HEADER, role);
+      }
+      ctx.init.headers = headers;
+      return ctx;
+    }
+  };
+}
+
+// src/client/core/client-factory.ts
+function attachStandardMiddlewares(client, options) {
+  const { tokenProvider, tenantProvider } = options;
+  if (tokenProvider) {
+    client.use(
+      createAuthMiddleware({
+        getAccessToken: tokenProvider.getAccessToken,
+        onTokenExpired: tokenProvider.onTokenExpired,
+        ...tokenProvider.onUnauthorized ? { onUnauthorized: tokenProvider.onUnauthorized } : {}
+      })
+    );
+  }
+  if (tenantProvider) {
+    client.use(
+      createTenantMiddleware({
+        tenantProvider,
+        ...tokenProvider ? { getAccessToken: tokenProvider.getAccessToken } : {}
+      })
+    );
+  }
+}
+function createHttpClient(options) {
+  const { tokenProvider, tenantProvider, ...clientConfig } = options;
+  const client = new MPFClient(clientConfig);
+  attachStandardMiddlewares(client, { tokenProvider, tenantProvider });
+  return client;
+}
+
+export { MAX_REQUEST_ATTEMPTS, MPFClient, TENANT_HEADER, TENANT_ROLE_HEADER, attachStandardMiddlewares, clearRetryFlag, createAuthMiddleware, createHttpClient, createRetryMiddleware, createTenantMiddleware, disableRetry, executeErrorMiddlewares, executeRequestMiddlewares, executeResponseMiddlewares, getRetryAttempt, isReplayableBody, isRetryDisabled, requestRetry, shouldRetryRequest };
+//# sourceMappingURL=chunk-LRM6JJ63.js.map
+//# sourceMappingURL=chunk-LRM6JJ63.js.map