@otim/utils 0.0.4 → 0.0.6

package/dist/server/index.mjs

@@ -1,421 +1,216 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { a as getPlatformApiUrl, i as getOffchainApiUrl, n as getAppId, o as getWalletConnectProjectId, r as getAppUrl, t as OtimEnvironment } from "../api-urls-DJcIKBCy.mjs";
+import { t as createApiClient } from "../client-factory-7xUSPC9I.mjs";
 
-// src/server/client.ts
-import axios from "axios";
-
-// src/env.ts
-var BUILD_MODE = "development";
-var APP_API_URL = "http://localhost:3000/api";
-
-// src/helpers/logger.ts
-var Logger = class {
-  constructor() {
-    __publicField(this, "isDevelopment", BUILD_MODE === "development");
-  }
-  debug(message, options) {
-    if (this.isDevelopment) {
-      this.log("debug", message, options);
-    }
-  }
-  info(message, options) {
-    this.log("info", message, options);
-  }
-  warn(message, options) {
-    this.log("warn", message, options);
-  }
-  error(message, options) {
-    this.log("error", message, options);
-  }
-  /**
-   * Log errors with context - useful for non-API errors
-   * For API errors, use the existing getErrorMessage from @otim/utils/api
-   */
-  logError(error, options = {}) {
-    const { context, operation, metadata } = options;
-    const prefix = this.buildPrefix(context, operation);
-    let message = "Unknown error";
-    if (error instanceof Error) {
-      message = error.message;
-    } else if (typeof error === "string") {
-      message = error;
-    } else if (error && typeof error === "object" && "message" in error) {
-      message = String(error.message);
-    }
-    console.error(prefix ? `${prefix} ${message}` : message);
-    if (metadata && Object.keys(metadata).length > 0) {
-      console.error("Context:", metadata);
-    }
-    if (error instanceof Error && error.stack) {
-      console.error("Stack:", error.stack);
-    } else {
-      console.error("Error details:", error);
-    }
-  }
-  buildPrefix(context, operation) {
-    const parts = [];
-    if (context) parts.push(`[${context}]`);
-    if (operation) parts.push(`[${operation}]`);
-    return parts.join(" ");
-  }
-  log(level, message, options) {
-    const prefix = options?.context ? `[${options.context}]` : "";
-    const fullMessage = `${prefix} ${message}`.trim();
-    switch (level) {
-      case "debug":
-      case "info":
-        console.log(fullMessage);
-        break;
-      case "warn":
-        console.warn(fullMessage);
-        break;
-      case "error":
-        console.error(fullMessage);
-        break;
-    }
-    if (options?.data) {
-      console.dir(options.data, { depth: null });
-    }
-  }
-};
-var logger = new Logger();
-
-// src/helpers/types.ts
-var isString = (value) => typeof value === "string";
-
-// src/server/client.ts
-var getApiUrl = () => {
-  const appApiUrl = APP_API_URL;
-  if (!isString(appApiUrl) || appApiUrl.trim() === "") {
-    const errorMessage = "APP API Client URL must be defined";
-    logger.error(errorMessage, { context: "App Server Client" });
-    throw new Error(errorMessage);
-  }
-  return appApiUrl;
-};
-var authTokenGetter = null;
-var setAuthTokenGetter = (getter) => {
-  authTokenGetter = getter;
-};
-var appApiClient = axios.create({
-  baseURL: getApiUrl(),
-  timeout: 3e4
-});
-appApiClient.interceptors.request.use(async (config) => {
-  if (authTokenGetter) {
-    const token = await authTokenGetter();
-    if (token) {
-      config.headers = config.headers ?? {};
-      config.headers.Authorization = `Bearer ${token}`;
-    }
-  }
-  return config;
-});
+//#region src/server/server-client.ts
+/**
+* Cache for server-side API client instances
+* One client per environment to ensure efficient resource usage
+*/
+const clientCache = /* @__PURE__ */ new Map();
+/**
+* Global auth token getter function
+* Can be set once at app initialization to provide auth tokens for all API requests
+*/
+let globalAuthTokenGetter;
+/**
+* Sets the global auth token getter function.
+* This should be called once at app initialization.
+*
+* @param getter - Function that returns the current auth token
+*/
+function setAuthTokenGetter(getter) {
+	globalAuthTokenGetter = getter;
+}
+/**
+* Gets the current global auth token getter function.
+*
+* @returns The global auth token getter, or undefined if not set
+*/
+function getAuthTokenGetter() {
+	return globalAuthTokenGetter;
+}
+/**
+* Gets or creates a cached API client for the specified environment.
+*
+* This function is designed for server-side use (Next.js server actions, API routes).
+* It maintains a singleton client per environment to avoid creating multiple
+* instances for the same environment.
+*
+* @param environment - The environment to get a client for
+* @param authTokenGetter - Optional auth token getter for this client
+* @returns A cached or new API client instance
+*/
+function getServerApiClient(environment, authTokenGetter) {
+	const tokenGetter = authTokenGetter ?? globalAuthTokenGetter;
+	if (!tokenGetter) {
+		const cached = clientCache.get(environment);
+		if (cached) return cached;
+		const client = createApiClient({ environment });
+		clientCache.set(environment, client);
+		return client;
+	}
+	return createApiClient({
+		environment,
+		authTokenGetter: tokenGetter
+	});
+}
+/**
+* Clears the server-side client cache.
+* Useful for testing or when you need to force recreation of clients.
+*
+* @param environment - Optional environment to clear. If not provided, clears all.
+*/
+function clearServerClientCache(environment) {
+	if (environment) clientCache.delete(environment);
+	else clientCache.clear();
+}
 
-// src/server/routes/account.ts
-var createDelegation = async (request) => {
-  const response = await appApiClient.post(
-    "/account/delegation",
-    request
-  );
-  return response.data;
-};
-var getDelegationStatus = async (request) => {
-  const response = await appApiClient.get(
-    "/account/delegation/status",
-    { params: request }
-  );
-  return response.data;
+//#endregion
+//#region src/server/routes/account.ts
+const createDelegation = async (client, request) => {
+	return (await client.post("/account/delegation", request)).data;
+};
+const getDelegationStatus = async (client, request) => {
+	return (await client.get("/account/delegation/status", { params: request })).data;
 };
 
-// src/server/routes/auth.ts
-var postLogin = async (request) => {
-  const response = await appApiClient.post(
-    "/auth/login",
-    request
-  );
-  return response.data;
-};
-var turnkeyVerification = async (request) => {
-  const response = await appApiClient.post(
-    "/auth/turnkey-verification",
-    request
-  );
-  return response.data;
-};
-var turnkeyLogin = async (request) => {
-  const response = await appApiClient.post(
-    "/auth/turnkey-login",
-    request
-  );
-  return response.data;
-};
-async function getNonce() {
-  const response = await appApiClient.get("/auth/nonce");
-  return response.data.nonce;
-}
-async function verifyAuthentication(params) {
-  const response = await appApiClient.post("/auth/authenticate", params);
-  return response.data;
+//#endregion
+//#region src/server/routes/auth.ts
+const postLogin = async (client, request) => {
+	return (await client.post("/auth/login", request)).data;
+};
+const turnkeyVerification = async (client, request) => {
+	return (await client.post("/auth/turnkey-verification", request)).data;
+};
+const turnkeyLogin = async (client, request) => {
+	return (await client.post("/auth/turnkey-login", request)).data;
+};
+async function getNonce(client) {
+	return (await client.get("/auth/nonce")).data.nonce;
 }
-async function setSessionToken(sessionToken) {
-  const response = await appApiClient.post(
-    "/auth/session",
-    { sessionToken }
-  );
-  return response.data;
+async function verifyAuthentication(client, params) {
+	return (await client.post("/auth/authenticate", params)).data;
 }
-async function destroySessionToken() {
-  const response = await appApiClient.delete(
-    "/auth/session"
-  );
-  return response.data;
+async function destroySessionToken(client) {
+	return (await client.delete("/auth/session")).data;
 }
-var getChainId = async () => {
-  const response = await appApiClient.get("/auth/chain");
-  return response.data;
-};
-var postChainId = async (request) => {
-  const response = await appApiClient.post(
-    "/auth/chain",
-    request
-  );
-  return response.data;
-};
-var deleteChainId = async () => {
-  const response = await appApiClient.delete("/auth/chain");
-  return response.data;
-};
-var postSessionToken = async (request) => {
-  const response = await appApiClient.post(
-    "/auth/session",
-    request
-  );
-  return response.data;
-};
-var getSessionVerify = async () => {
-  const response = await appApiClient.get("/auth/verify");
-  return response.data;
-};
-var getCurrentUser = async () => {
-  const response = await appApiClient.get("/auth/me");
-  return response.data.data;
-};
-var postCheckEmailInWhitelist = async (request) => {
-  const response = await appApiClient.post(
-    "/auth/whitelist/email",
-    request
-  );
-  return response.data;
-};
-var postCheckAddressInWhitelist = async (request) => {
-  const response = await appApiClient.post(
-    "/auth/whitelist/wallet-address",
-    request
-  );
-  return response.data;
+const getChainId = async (client) => {
+	return (await client.get("/auth/chain")).data;
+};
+const postChainId = async (client, request) => {
+	return (await client.post("/auth/chain", request)).data;
+};
+const deleteChainId = async (client) => {
+	return (await client.delete("/auth/chain")).data;
+};
+const postSessionToken = async (client, request) => {
+	return (await client.post("/auth/session", request)).data;
+};
+const getSessionVerify = async (client) => {
+	return (await client.get("/auth/verify")).data;
+};
+const getCurrentUser = async (client) => {
+	return (await client.get("/auth/me")).data;
+};
+const postCheckEmailInWhitelist = async (client, request) => {
+	return (await client.post("/auth/whitelist/email", request)).data;
+};
+const postCheckAddressInWhitelist = async (client, request) => {
+	return (await client.post("/auth/whitelist/wallet-address", request)).data;
+};
+const updateUserPreferences = async (client, request) => {
+	return (await client.post("/auth/preferences", request)).data;
+};
+
+//#endregion
+//#region src/server/routes/bridge.ts
+const getBridgeCustomer = async (client, customerId) => {
+	return (await client.get("/bridge/customer", { params: { customerId } })).data;
+};
+const generateBridgeKycLinks = async (client, request) => {
+	return (await client.post("/bridge/kyc-links", request)).data;
+};
+const getBridgeKycLinkStatus = async (client, kycLinkId) => {
+	return (await client.get("/bridge/kyc-links/status", { params: { kycLinkId } })).data;
+};
+const createBridgePlaidLinkToken = async (client, request) => {
+	return (await client.post("/bridge/plaid/link-token", request)).data;
+};
+const bridgeExchangePlaidPublicToken = async (client, request) => {
+	return (await client.post("/bridge/plaid/exchange-token", request)).data;
+};
+const getBridgeExternalAccounts = async (client, customerId) => {
+	return (await client.get("/bridge/external-accounts", { params: { customerId } })).data;
+};
+const getBridgeLiquidationAddresses = async (client, customerId) => {
+	return (await client.get("/bridge/liquidation-addresses", { params: { customerId } })).data;
+};
+const createBridgeLiquidationAddress = async (client, request) => {
+	return (await client.post("/bridge/liquidation-addresses", request)).data;
+};
+const createBridgeTransfer = async (client, request) => {
+	return (await client.post("/bridge/transfer", request)).data;
+};
+const updateBridgeExternalAccountAddress = async (client, customerId, externalAccountId, address) => {
+	return (await client.put("/bridge/external-accounts/update-address", {
+		customerId,
+		externalAccountId,
+		address
+	})).data;
+};
+const createBridgeIbanExternalAccount = async (client, request) => {
+	return (await client.post("/bridge/external-accounts/iban", request)).data;
+};
+const ensureOnrampRoute = async (client, params) => {
+	return (await client.post("/bridge/routes/ensure-onramp", params)).data;
+};
+const ensureOfframpRoute = async (client, params) => {
+	return (await client.post("/bridge/routes/ensure-offramp", params)).data;
+};
+const getBridgeLiquidationAddressDrains = async (client, params) => {
+	const { liquidationAddressId, customerId, limit = 100 } = params;
+	return (await client.get(`/bridge/liquidation-addresses/${encodeURIComponent(liquidationAddressId)}/drains`, { params: {
+		customerId,
+		limit
+	} })).data;
 };
 
-// src/server/routes/bridge.ts
-var getBridgeCustomer = async (customerId) => {
-  const response = await appApiClient.get(
-    "/bridge/customer",
-    { params: { customerId } }
-  );
-  return response.data;
-};
-var generateBridgeKycLinks = async (request) => {
-  const response = await appApiClient.post(
-    "/bridge/kyc-links",
-    request
-  );
-  return response.data;
-};
-var getBridgeKycLinkStatus = async (kycLinkId) => {
-  const response = await appApiClient.get(
-    "/bridge/kyc-links/status",
-    { params: { kycLinkId } }
-  );
-  return response.data;
-};
-var createBridgePlaidLinkToken = async (request) => {
-  const response = await appApiClient.post(
-    "/bridge/plaid/link-token",
-    request
-  );
-  return response.data;
-};
-var bridgeExchangePlaidPublicToken = async (request) => {
-  const response = await appApiClient.post(
-    "/bridge/plaid/exchange-token",
-    request
-  );
-  return response.data;
-};
-var getBridgeExternalAccounts = async (customerId) => {
-  const response = await appApiClient.get(
-    "/bridge/external-accounts",
-    { params: { customerId } }
-  );
-  return response.data;
-};
-var getBridgeLiquidationAddresses = async (customerId) => {
-  const response = await appApiClient.get(
-    "/bridge/liquidation-addresses",
-    { params: { customerId } }
-  );
-  return response.data;
-};
-var createBridgeLiquidationAddress = async (request) => {
-  const response = await appApiClient.post(
-    "/bridge/liquidation-addresses",
-    request
-  );
-  return response.data;
-};
-var createBridgeTransfer = async (request) => {
-  const response = await appApiClient.post(
-    "/bridge/transfer",
-    request
-  );
-  return response.data;
-};
-var updateBridgeExternalAccountAddress = async (customerId, externalAccountId, address) => {
-  const response = await appApiClient.put(
-    "/bridge/external-accounts/update-address",
-    {
-      customerId,
-      externalAccountId,
-      address
-    }
-  );
-  return response.data;
-};
-var createBridgeIbanExternalAccount = async (request) => {
-  const response = await appApiClient.post(
-    "/bridge/external-accounts/iban",
-    request
-  );
-  return response.data;
-};
-var ensureOnrampRoute = async (params) => {
-  const response = await appApiClient.post(
-    "/bridge/routes/ensure-onramp",
-    params
-  );
-  return response.data;
-};
-var ensureOfframpRoute = async (params) => {
-  const response = await appApiClient.post(
-    "/bridge/routes/ensure-offramp",
-    params
-  );
-  return response.data;
+//#endregion
+//#region src/server/routes/config.ts
+const getDelegateAddress = async (client, request) => {
+	return (await client.get(`/config/delegate-address/${request.chainId}`)).data;
 };
 
-// src/server/routes/config.ts
-var getDelegateAddress = async (request) => {
-  const response = await appApiClient.get(
-    `/config/delegate-address/${request.chainId}`
-  );
-  return response.data;
+//#endregion
+//#region src/server/routes/instruction.ts
+const buildInstruction = async (client, request) => {
+	return (await client.post("/instruction/build", request)).data;
+};
+const activateInstruction = async (client, request) => {
+	return (await client.post("/instruction/activate", request)).data;
 };
 
-// src/server/routes/instruction.ts
-var buildInstruction = async (request) => {
-  const response = await appApiClient.post(
-    "/instruction/build",
-    request
-  );
-  return response.data;
-};
-var activateInstruction = async (request) => {
-  const response = await appApiClient.post(
-    "/instruction/activate",
-    request
-  );
-  return response.data;
+//#endregion
+//#region src/server/routes/integration.ts
+const getIntegration = async (client, request) => {
+	return (await client.post("/integration/get", request)).data;
+};
+const upsertIntegration = async (client, request) => {
+	return (await client.put("/integration", request)).data;
 };
 
-// src/server/routes/integration.ts
-var getIntegration = async (request) => {
-  const response = await appApiClient.post(
-    "/integration/get",
-    request
-  );
-  return response.data;
-};
-var upsertIntegration = async (request) => {
-  const response = await appApiClient.put(
-    "/integration",
-    request
-  );
-  return response.data;
+//#endregion
+//#region src/server/routes/payments.ts
+const buildPaymentRequest = async (client, request) => {
+	return (await client.post("/orchestration/build", request)).data;
+};
+const newPaymentRequest = async (client, request) => {
+	return (await client.post("/orchestration/new", request)).data;
+};
+const buildSettlementOrchestration = async (client, request) => {
+	return (await client.post("/orchestration/build/settlement", request)).data;
 };
 
-// src/server/routes/payments.ts
-var buildPaymentRequest = async (request) => {
-  const response = await appApiClient.post(
-    "/orchestration/build",
-    request
-  );
-  return response.data;
-};
-var newPaymentRequest = async (request) => {
-  const response = await appApiClient.post(
-    "/orchestration/new",
-    request
-  );
-  return response.data;
-};
-var buildSettlementOrchestration = async (request) => {
-  const response = await appApiClient.post(
-    "/orchestration/build/settlement",
-    request
-  );
-  return response.data;
-};
-export {
-  activateInstruction,
-  appApiClient,
-  bridgeExchangePlaidPublicToken,
-  buildInstruction,
-  buildPaymentRequest,
-  buildSettlementOrchestration,
-  createBridgeIbanExternalAccount,
-  createBridgeLiquidationAddress,
-  createBridgePlaidLinkToken,
-  createBridgeTransfer,
-  createDelegation,
-  deleteChainId,
-  destroySessionToken,
-  ensureOfframpRoute,
-  ensureOnrampRoute,
-  generateBridgeKycLinks,
-  getBridgeCustomer,
-  getBridgeExternalAccounts,
-  getBridgeKycLinkStatus,
-  getBridgeLiquidationAddresses,
-  getChainId,
-  getCurrentUser,
-  getDelegateAddress,
-  getDelegationStatus,
-  getIntegration,
-  getNonce,
-  getSessionVerify,
-  newPaymentRequest,
-  postChainId,
-  postCheckAddressInWhitelist,
-  postCheckEmailInWhitelist,
-  postLogin,
-  postSessionToken,
-  setAuthTokenGetter,
-  setSessionToken,
-  turnkeyLogin,
-  turnkeyVerification,
-  updateBridgeExternalAccountAddress,
-  upsertIntegration,
-  verifyAuthentication
-};
-//# sourceMappingURL=index.mjs.map
+//#endregion
+export { OtimEnvironment, activateInstruction, bridgeExchangePlaidPublicToken, buildInstruction, buildPaymentRequest, buildSettlementOrchestration, clearServerClientCache, createApiClient, createBridgeIbanExternalAccount, createBridgeLiquidationAddress, createBridgePlaidLinkToken, createBridgeTransfer, createDelegation, deleteChainId, destroySessionToken, ensureOfframpRoute, ensureOnrampRoute, generateBridgeKycLinks, getAppId, getAppUrl, getAuthTokenGetter, getBridgeCustomer, getBridgeExternalAccounts, getBridgeKycLinkStatus, getBridgeLiquidationAddressDrains, getBridgeLiquidationAddresses, getChainId, getCurrentUser, getDelegateAddress, getDelegationStatus, getIntegration, getNonce, getOffchainApiUrl, getPlatformApiUrl, getServerApiClient, getSessionVerify, getWalletConnectProjectId, newPaymentRequest, postChainId, postCheckAddressInWhitelist, postCheckEmailInWhitelist, postLogin, postSessionToken, setAuthTokenGetter, turnkeyLogin, turnkeyVerification, updateBridgeExternalAccountAddress, updateUserPreferences, upsertIntegration, verifyAuthentication };
+//# sourceMappingURL=index.mjs.map