@mitway/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,819 @@
+// src/types.ts
+var MitwayBaasError = class _MitwayBaasError extends Error {
+  statusCode;
+  error;
+  nextActions;
+  constructor(message, statusCode, error, nextActions) {
+    super(message);
+    this.name = "MitwayBaasError";
+    this.statusCode = statusCode;
+    this.error = error;
+    this.nextActions = nextActions;
+  }
+  static fromApiError(apiError) {
+    return new _MitwayBaasError(
+      apiError.message,
+      apiError.statusCode,
+      apiError.error,
+      apiError.nextActions
+    );
+  }
+};
+
+// src/lib/logger.ts
+var SENSITIVE_HEADERS = ["authorization", "x-api-key", "cookie", "set-cookie"];
+var SENSITIVE_BODY_KEYS = [
+  "password",
+  "token",
+  "accesstoken",
+  "refreshtoken",
+  "authorization",
+  "secret",
+  "apikey",
+  "api_key",
+  "email",
+  "ssn",
+  "creditcard",
+  "credit_card"
+];
+function redactHeaders(headers) {
+  const redacted = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (SENSITIVE_HEADERS.includes(key.toLowerCase())) {
+      redacted[key] = "***REDACTED***";
+    } else {
+      redacted[key] = value;
+    }
+  }
+  return redacted;
+}
+function sanitizeBody(body) {
+  if (body === null || body === void 0) return body;
+  if (typeof body === "string") {
+    try {
+      const parsed = JSON.parse(body);
+      return sanitizeBody(parsed);
+    } catch {
+      return body;
+    }
+  }
+  if (Array.isArray(body)) return body.map(sanitizeBody);
+  if (typeof body === "object") {
+    const sanitized = {};
+    for (const [key, value] of Object.entries(body)) {
+      if (SENSITIVE_BODY_KEYS.includes(key.toLowerCase().replace(/[-_]/g, ""))) {
+        sanitized[key] = "***REDACTED***";
+      } else {
+        sanitized[key] = sanitizeBody(value);
+      }
+    }
+    return sanitized;
+  }
+  return body;
+}
+function formatBody(body) {
+  if (body === void 0 || body === null) return "";
+  if (typeof body === "string") {
+    try {
+      return JSON.stringify(JSON.parse(body), null, 2);
+    } catch {
+      return body;
+    }
+  }
+  if (typeof FormData !== "undefined" && body instanceof FormData) {
+    return "[FormData]";
+  }
+  try {
+    return JSON.stringify(body, null, 2);
+  } catch {
+    return "[Unserializable body]";
+  }
+}
+var Logger = class {
+  enabled;
+  customLog;
+  constructor(debug) {
+    if (typeof debug === "function") {
+      this.enabled = true;
+      this.customLog = debug;
+    } else {
+      this.enabled = !!debug;
+      this.customLog = null;
+    }
+  }
+  log(message, ...args) {
+    if (!this.enabled) return;
+    const formatted = `[MITWAY-BaaS Debug] ${message}`;
+    if (this.customLog) {
+      this.customLog(formatted, ...args);
+    } else {
+      console.log(formatted, ...args);
+    }
+  }
+  warn(message, ...args) {
+    if (!this.enabled) return;
+    const formatted = `[MITWAY-BaaS Debug] ${message}`;
+    if (this.customLog) {
+      this.customLog(formatted, ...args);
+    } else {
+      console.warn(formatted, ...args);
+    }
+  }
+  error(message, ...args) {
+    if (!this.enabled) return;
+    const formatted = `[MITWAY-BaaS Debug] ${message}`;
+    if (this.customLog) {
+      this.customLog(formatted, ...args);
+    } else {
+      console.error(formatted, ...args);
+    }
+  }
+  logRequest(method, url, headers, body) {
+    if (!this.enabled) return;
+    const parts = [`\u2192 ${method} ${url}`];
+    if (headers && Object.keys(headers).length > 0) {
+      parts.push(`  Headers: ${JSON.stringify(redactHeaders(headers))}`);
+    }
+    const formattedBody = formatBody(sanitizeBody(body));
+    if (formattedBody) {
+      const truncated = formattedBody.length > 1e3 ? formattedBody.slice(0, 1e3) + "... [truncated]" : formattedBody;
+      parts.push(`  Body: ${truncated}`);
+    }
+    this.log(parts.join("\n"));
+  }
+  logResponse(method, url, status, durationMs, body) {
+    if (!this.enabled) return;
+    const parts = [
+      `\u2190 ${method} ${url} ${status} (${durationMs}ms)`
+    ];
+    const formattedBody = formatBody(sanitizeBody(body));
+    if (formattedBody) {
+      const truncated = formattedBody.length > 1e3 ? formattedBody.slice(0, 1e3) + "... [truncated]" : formattedBody;
+      parts.push(`  Body: ${truncated}`);
+    }
+    if (status >= 400) {
+      this.error(parts.join("\n"));
+    } else {
+      this.log(parts.join("\n"));
+    }
+  }
+};
+
+// src/lib/token-manager.ts
+var CSRF_TOKEN_COOKIE = "mitway_baas_csrf_token";
+function getCsrfToken() {
+  if (typeof document === "undefined") return null;
+  const match = document.cookie.split(";").find((c) => c.trim().startsWith(`${CSRF_TOKEN_COOKIE}=`));
+  if (!match) return null;
+  return match.split("=")[1] || null;
+}
+function setCsrfToken(token) {
+  if (typeof document === "undefined") return;
+  const maxAge = 7 * 24 * 60 * 60;
+  const secure = typeof window !== "undefined" && window.location.protocol === "https:" ? "; Secure" : "";
+  document.cookie = `${CSRF_TOKEN_COOKIE}=${encodeURIComponent(token)}; path=/; max-age=${maxAge}; SameSite=Lax${secure}`;
+}
+function clearCsrfToken() {
+  if (typeof document === "undefined") return;
+  const secure = typeof window !== "undefined" && window.location.protocol === "https:" ? "; Secure" : "";
+  document.cookie = `${CSRF_TOKEN_COOKIE}=; path=/; max-age=0; SameSite=Lax${secure}`;
+}
+var TokenManager = class {
+  accessToken = null;
+  user = null;
+  /** Fired when the access token changes (used by long-lived consumers). */
+  onTokenChange = null;
+  saveSession(session) {
+    const tokenChanged = session.accessToken !== this.accessToken;
+    this.accessToken = session.accessToken;
+    this.user = session.user;
+    if (tokenChanged && this.onTokenChange) {
+      this.onTokenChange();
+    }
+  }
+  getSession() {
+    if (!this.accessToken || !this.user) return null;
+    return {
+      accessToken: this.accessToken,
+      user: this.user
+    };
+  }
+  getAccessToken() {
+    return this.accessToken;
+  }
+  setAccessToken(token) {
+    const tokenChanged = token !== this.accessToken;
+    this.accessToken = token;
+    if (tokenChanged && this.onTokenChange) {
+      this.onTokenChange();
+    }
+  }
+  getUser() {
+    return this.user;
+  }
+  setUser(user) {
+    this.user = user;
+  }
+  clearSession() {
+    const hadToken = this.accessToken !== null;
+    this.accessToken = null;
+    this.user = null;
+    if (hadToken && this.onTokenChange) {
+      this.onTokenChange();
+    }
+  }
+};
+
+// src/lib/http-client.ts
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([500, 502, 503, 504]);
+var IDEMPOTENT_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "PUT", "DELETE", "OPTIONS"]);
+var HttpClient = class {
+  baseUrl;
+  fetch;
+  defaultHeaders;
+  anonKey;
+  userToken = null;
+  logger;
+  autoRefreshToken = true;
+  isRefreshing = false;
+  refreshPromise = null;
+  tokenManager;
+  refreshToken = null;
+  timeout;
+  retryCount;
+  retryDelay;
+  constructor(config, tokenManager, logger) {
+    this.baseUrl = config.baseUrl || "http://localhost:7130";
+    this.autoRefreshToken = config.autoRefreshToken ?? true;
+    this.fetch = config.fetch || (globalThis.fetch ? globalThis.fetch.bind(globalThis) : void 0);
+    this.anonKey = config.anonKey;
+    this.defaultHeaders = {
+      ...config.headers
+    };
+    this.tokenManager = tokenManager ?? new TokenManager();
+    this.logger = logger || new Logger(false);
+    this.timeout = config.timeout ?? 3e4;
+    this.retryCount = config.retryCount ?? 3;
+    this.retryDelay = config.retryDelay ?? 500;
+    if (!this.fetch) {
+      throw new Error(
+        "Fetch is not available. Provide a fetch implementation in the SDK config."
+      );
+    }
+  }
+  buildUrl(path, params) {
+    const url = new URL(path, this.baseUrl);
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        if (key === "select") {
+          let normalizedValue = value.replace(/\s+/g, " ").trim();
+          normalizedValue = normalizedValue.replace(/\s*\(\s*/g, "(").replace(/\s*\)\s*/g, ")").replace(/\(\s+/g, "(").replace(/\s+\)/g, ")").replace(/,\s+(?=[^()]*\))/g, ",");
+          url.searchParams.append(key, normalizedValue);
+        } else {
+          url.searchParams.append(key, value);
+        }
+      });
+    }
+    return url.toString();
+  }
+  isRetryableStatus(status) {
+    return RETRYABLE_STATUS_CODES.has(status);
+  }
+  computeRetryDelay(attempt) {
+    const base = this.retryDelay * Math.pow(2, attempt - 1);
+    const jitter = base * (0.85 + Math.random() * 0.3);
+    return Math.round(jitter);
+  }
+  async handleRequest(method, path, options = {}) {
+    const {
+      params,
+      headers = {},
+      body,
+      signal: callerSignal,
+      ...fetchOptions
+    } = options;
+    const url = this.buildUrl(path, params);
+    const startTime = Date.now();
+    const canRetry = IDEMPOTENT_METHODS.has(method.toUpperCase()) || options.idempotent === true;
+    const maxAttempts = canRetry ? this.retryCount : 0;
+    const requestHeaders = {
+      ...this.defaultHeaders
+    };
+    const authToken = this.userToken || this.anonKey;
+    if (authToken) {
+      requestHeaders["Authorization"] = `Bearer ${authToken}`;
+    }
+    let processedBody;
+    if (body !== void 0) {
+      if (typeof FormData !== "undefined" && body instanceof FormData) {
+        processedBody = body;
+      } else {
+        if (method !== "GET") {
+          requestHeaders["Content-Type"] = "application/json;charset=UTF-8";
+        }
+        processedBody = JSON.stringify(body);
+      }
+    }
+    if (headers instanceof Headers) {
+      headers.forEach((value, key) => {
+        requestHeaders[key] = value;
+      });
+    } else if (Array.isArray(headers)) {
+      headers.forEach(([key, value]) => {
+        requestHeaders[key] = value;
+      });
+    } else {
+      Object.assign(requestHeaders, headers);
+    }
+    this.logger.logRequest(method, url, requestHeaders, processedBody);
+    let lastError;
+    for (let attempt = 0; attempt <= maxAttempts; attempt++) {
+      if (attempt > 0) {
+        const delay = this.computeRetryDelay(attempt);
+        this.logger.warn(
+          `Retry ${attempt}/${maxAttempts} for ${method} ${url} in ${delay}ms`
+        );
+        if (callerSignal?.aborted) throw callerSignal.reason;
+        await new Promise((resolve, reject) => {
+          const onAbort = () => {
+            clearTimeout(timer2);
+            reject(callerSignal.reason);
+          };
+          const timer2 = setTimeout(() => {
+            if (callerSignal)
+              callerSignal.removeEventListener("abort", onAbort);
+            resolve();
+          }, delay);
+          if (callerSignal) {
+            callerSignal.addEventListener("abort", onAbort, { once: true });
+          }
+        });
+      }
+      let controller;
+      let timer;
+      if (this.timeout > 0 || callerSignal) {
+        controller = new AbortController();
+        if (this.timeout > 0) {
+          timer = setTimeout(() => controller.abort(), this.timeout);
+        }
+        if (callerSignal) {
+          if (callerSignal.aborted) {
+            controller.abort(callerSignal.reason);
+          } else {
+            const onCallerAbort = () => controller.abort(callerSignal.reason);
+            callerSignal.addEventListener("abort", onCallerAbort, { once: true });
+            controller.signal.addEventListener(
+              "abort",
+              () => {
+                callerSignal.removeEventListener("abort", onCallerAbort);
+              },
+              { once: true }
+            );
+          }
+        }
+      }
+      try {
+        const response = await this.fetch(url, {
+          method,
+          headers: requestHeaders,
+          body: processedBody,
+          ...fetchOptions,
+          ...controller ? { signal: controller.signal } : {}
+        });
+        if (this.isRetryableStatus(response.status) && attempt < maxAttempts) {
+          if (timer !== void 0) clearTimeout(timer);
+          await response.body?.cancel();
+          lastError = new MitwayBaasError(
+            `Server error: ${response.status} ${response.statusText}`,
+            response.status,
+            "SERVER_ERROR"
+          );
+          continue;
+        }
+        if (response.status === 204) {
+          if (timer !== void 0) clearTimeout(timer);
+          return void 0;
+        }
+        let data;
+        const contentType = response.headers.get("content-type");
+        try {
+          if (contentType?.includes("json")) {
+            data = await response.json();
+          } else {
+            data = await response.text();
+          }
+        } catch (parseErr) {
+          if (timer !== void 0) clearTimeout(timer);
+          throw new MitwayBaasError(
+            `Failed to parse response body: ${parseErr?.message || "Unknown error"}`,
+            response.status,
+            response.ok ? "PARSE_ERROR" : "REQUEST_FAILED"
+          );
+        }
+        if (timer !== void 0) clearTimeout(timer);
+        if (!response.ok) {
+          this.logger.logResponse(
+            method,
+            url,
+            response.status,
+            Date.now() - startTime,
+            data
+          );
+          if (data && typeof data === "object" && "error" in data) {
+            if (!data.statusCode && !data.status) {
+              data.statusCode = response.status;
+            }
+            const error = MitwayBaasError.fromApiError(data);
+            Object.keys(data).forEach((key) => {
+              if (key !== "error" && key !== "message" && key !== "statusCode") {
+                error[key] = data[key];
+              }
+            });
+            throw error;
+          }
+          throw new MitwayBaasError(
+            `Request failed: ${response.statusText}`,
+            response.status,
+            "REQUEST_FAILED"
+          );
+        }
+        this.logger.logResponse(
+          method,
+          url,
+          response.status,
+          Date.now() - startTime,
+          data
+        );
+        return data;
+      } catch (err) {
+        if (timer !== void 0) clearTimeout(timer);
+        if (err?.name === "AbortError") {
+          if (controller && controller.signal.aborted && this.timeout > 0 && !callerSignal?.aborted) {
+            throw new MitwayBaasError(
+              `Request timed out after ${this.timeout}ms`,
+              408,
+              "REQUEST_TIMEOUT"
+            );
+          }
+          throw err;
+        }
+        if (err instanceof MitwayBaasError) {
+          throw err;
+        }
+        if (attempt < maxAttempts) {
+          lastError = err;
+          continue;
+        }
+        throw new MitwayBaasError(
+          `Network request failed: ${err?.message || "Unknown error"}`,
+          0,
+          "NETWORK_ERROR"
+        );
+      }
+    }
+    throw lastError || new MitwayBaasError(
+      "Request failed after all retry attempts",
+      0,
+      "NETWORK_ERROR"
+    );
+  }
+  async request(method, path, options = {}) {
+    try {
+      return await this.handleRequest(method, path, { ...options });
+    } catch (error) {
+      if (error instanceof MitwayBaasError && error.statusCode === 401 && error.error === "INVALID_TOKEN" && this.autoRefreshToken) {
+        try {
+          const newTokenData = await this.handleTokenRefresh();
+          this.setAuthToken(newTokenData.accessToken);
+          this.tokenManager.saveSession(newTokenData);
+          if (newTokenData.csrfToken) {
+            setCsrfToken(newTokenData.csrfToken);
+          }
+          if (newTokenData.refreshToken) {
+            this.setRefreshToken(newTokenData.refreshToken);
+          }
+          return await this.handleRequest(method, path, { ...options });
+        } catch (refreshError) {
+          this.tokenManager.clearSession();
+          this.userToken = null;
+          this.refreshToken = null;
+          clearCsrfToken();
+          throw refreshError;
+        }
+      }
+      throw error;
+    }
+  }
+  get(path, options) {
+    return this.request("GET", path, options);
+  }
+  post(path, body, options) {
+    return this.request("POST", path, { ...options, body });
+  }
+  put(path, body, options) {
+    return this.request("PUT", path, { ...options, body });
+  }
+  patch(path, body, options) {
+    return this.request("PATCH", path, { ...options, body });
+  }
+  delete(path, options) {
+    return this.request("DELETE", path, options);
+  }
+  setAuthToken(token) {
+    this.userToken = token;
+  }
+  setRefreshToken(token) {
+    this.refreshToken = token;
+  }
+  getHeaders() {
+    const headers = { ...this.defaultHeaders };
+    const authToken = this.userToken || this.anonKey;
+    if (authToken) {
+      headers["Authorization"] = `Bearer ${authToken}`;
+    }
+    return headers;
+  }
+  /**
+   * Refresh the current session by calling the MITWAY-BaaS refresh endpoint.
+   * Note: the route is `/api/auth/refresh` (POST), not the InsForge
+   * `/api/auth/sessions/current` route. Returns the new access token + user.
+   */
+  async handleTokenRefresh() {
+    if (this.isRefreshing) {
+      return this.refreshPromise;
+    }
+    this.isRefreshing = true;
+    this.refreshPromise = (async () => {
+      try {
+        const csrfToken = getCsrfToken();
+        const body = this.refreshToken ? { refreshToken: this.refreshToken } : void 0;
+        const response = await this.handleRequest(
+          "POST",
+          "/api/auth/refresh",
+          {
+            body,
+            headers: csrfToken ? { "X-CSRF-Token": csrfToken } : {},
+            credentials: "include"
+          }
+        );
+        return response;
+      } finally {
+        this.isRefreshing = false;
+        this.refreshPromise = null;
+      }
+    })();
+    return this.refreshPromise;
+  }
+};
+
+// src/modules/auth.ts
+function wrapError(error, fallbackMessage) {
+  if (error instanceof MitwayBaasError) {
+    return { data: null, error };
+  }
+  return {
+    data: null,
+    error: new MitwayBaasError(
+      error instanceof Error ? error.message : fallbackMessage,
+      500,
+      "AUTH_ERROR"
+    )
+  };
+}
+var Auth = class {
+  constructor(http, tokenManager) {
+    this.http = http;
+    this.tokenManager = tokenManager;
+  }
+  http;
+  tokenManager;
+  /**
+   * Persist the session in memory + HttpClient defaults so subsequent
+   * requests carry the new bearer token automatically.
+   */
+  saveSessionFromResponse(response) {
+    const session = {
+      accessToken: response.accessToken,
+      user: response.user
+    };
+    if (response.csrfToken) {
+      setCsrfToken(response.csrfToken);
+    }
+    this.tokenManager.saveSession(session);
+    this.http.setAuthToken(response.accessToken);
+    this.http.setRefreshToken(response.refreshToken ?? null);
+  }
+  /**
+   * Create a new user account and start a session.
+   *
+   * @example
+   * const { data, error } = await client.auth.signUp({
+   *   email: 'a@b.com',
+   *   password: 'a-strong-password',
+   *   name: 'Alice'
+   * });
+   */
+  async signUp(request) {
+    try {
+      const response = await this.http.post(
+        "/api/auth/register",
+        request,
+        { credentials: "include" }
+      );
+      if (response?.accessToken && response.user) {
+        this.saveSessionFromResponse(response);
+      }
+      return { data: response, error: null };
+    } catch (error) {
+      return wrapError(error, "Sign up failed");
+    }
+  }
+  /**
+   * Sign in with email + password and start a session.
+   */
+  async signInWithPassword(request) {
+    try {
+      const response = await this.http.post(
+        "/api/auth/login",
+        request,
+        { credentials: "include" }
+      );
+      if (response?.accessToken && response.user) {
+        this.saveSessionFromResponse(response);
+      }
+      return { data: response, error: null };
+    } catch (error) {
+      return wrapError(error, "Sign in failed");
+    }
+  }
+  /**
+   * End the current session. Clears in-memory state even if the backend
+   * call fails (network/offline).
+   */
+  async signOut() {
+    try {
+      try {
+        await this.http.post("/api/auth/logout", void 0, {
+          credentials: "include"
+        });
+      } catch {
+      }
+      this.tokenManager.clearSession();
+      this.http.setAuthToken(null);
+      this.http.setRefreshToken(null);
+      clearCsrfToken();
+      return { error: null };
+    } catch {
+      return {
+        error: new MitwayBaasError("Failed to sign out", 500, "SIGNOUT_ERROR")
+      };
+    }
+  }
+  /**
+   * Manually refresh the current session. The HttpClient will call this
+   * automatically on 401 INVALID_TOKEN responses; consumers usually do
+   * not need to call it directly.
+   */
+  async refreshSession() {
+    try {
+      const response = await this.http.handleTokenRefresh();
+      if (response?.accessToken && response.user) {
+        this.saveSessionFromResponse(response);
+      }
+      return { data: response, error: null };
+    } catch (error) {
+      return wrapError(error, "Session refresh failed");
+    }
+  }
+  /**
+   * Get the current in-memory session, or null if the user is not signed in.
+   * Synchronous — does not hit the network.
+   */
+  getSession() {
+    return this.tokenManager.getSession();
+  }
+  /**
+   * Get the current in-memory user, or null if not signed in.
+   */
+  getUser() {
+    return this.tokenManager.getUser();
+  }
+};
+
+// src/modules/database.ts
+import { PostgrestClient } from "@supabase/postgrest-js";
+function createAuthedFetch(tokenManager, anonKey) {
+  return async (input, init) => {
+    const headers = new Headers(init?.headers);
+    if (!headers.has("Authorization")) {
+      const token = tokenManager.getAccessToken() ?? anonKey;
+      if (token) {
+        headers.set("Authorization", `Bearer ${token}`);
+      }
+    }
+    return fetch(input, { ...init, headers });
+  };
+}
+var Database = class {
+  postgrest;
+  postgrestUrl;
+  constructor(tokenManager, postgrestUrl, anonKey) {
+    this.postgrestUrl = postgrestUrl;
+    if (postgrestUrl) {
+      this.postgrest = new PostgrestClient(postgrestUrl, {
+        fetch: createAuthedFetch(tokenManager, anonKey),
+        headers: {}
+      });
+    } else {
+      this.postgrest = null;
+    }
+  }
+  requireClient() {
+    if (!this.postgrest) {
+      throw new MitwayBaasError(
+        "Database is not configured. Pass `postgrestUrl` in the SDK config to enable database operations.",
+        500,
+        "DATABASE_NOT_CONFIGURED"
+      );
+    }
+    return this.postgrest;
+  }
+  /**
+   * Build a PostgREST query against a table.
+   *
+   * @example
+   * const { data, error } = await client.database
+   *   .from('posts')
+   *   .select('*')
+   *   .eq('user_id', userId)
+   *   .order('created_at', { ascending: false })
+   *   .limit(10);
+   *
+   * @example
+   * const { data, error } = await client.database
+   *   .from('posts')
+   *   .insert({ title: 'Hello', content: 'World' })
+   *   .select()
+   *   .single();
+   */
+  from(table) {
+    return this.requireClient().from(table);
+  }
+  /**
+   * Call a PostgreSQL stored function (RPC).
+   *
+   * @example
+   * const { data, error } = await client.database
+   *   .rpc('get_user_stats', { user_id: 123 });
+   */
+  rpc(fn, args, options) {
+    return this.requireClient().rpc(fn, args, options);
+  }
+  /**
+   * The PostgREST URL the database client is talking to, or undefined if
+   * the database module is not configured.
+   */
+  getUrl() {
+    return this.postgrestUrl;
+  }
+};
+
+// src/client.ts
+var MitwayBaasClient = class {
+  http;
+  tokenManager;
+  auth;
+  database;
+  constructor(config = {}) {
+    const logger = new Logger(config.debug);
+    this.tokenManager = new TokenManager();
+    this.http = new HttpClient(config, this.tokenManager, logger);
+    this.auth = new Auth(this.http, this.tokenManager);
+    this.database = new Database(this.tokenManager, config.postgrestUrl, config.anonKey);
+  }
+  /**
+   * Escape hatch for callers that need to make custom requests against the
+   * backend without going through `auth` or `database`.
+   */
+  getHttpClient() {
+    return this.http;
+  }
+};
+
+// src/index.ts
+function createClient(config) {
+  return new MitwayBaasClient(config);
+}
+var index_default = MitwayBaasClient;
+export {
+  Auth,
+  Database,
+  HttpClient,
+  Logger,
+  MitwayBaasClient,
+  MitwayBaasError,
+  TokenManager,
+  createClient,
+  index_default as default
+};
+//# sourceMappingURL=index.js.map