@otim/utils 0.0.4 → 0.0.6

package/dist/server/index.js

@@ -1,452 +1,265 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+const require_api_urls = require('../api-urls-Cd20DG4i.js');
+const require_client_factory = require('../client-factory-CTI_Nt35.js');
 
-// src/server/index.ts
-var server_exports = {};
-__export(server_exports, {
-  activateInstruction: () => activateInstruction,
-  appApiClient: () => appApiClient,
-  bridgeExchangePlaidPublicToken: () => bridgeExchangePlaidPublicToken,
-  buildInstruction: () => buildInstruction,
-  buildPaymentRequest: () => buildPaymentRequest,
-  buildSettlementOrchestration: () => buildSettlementOrchestration,
-  createBridgeIbanExternalAccount: () => createBridgeIbanExternalAccount,
-  createBridgeLiquidationAddress: () => createBridgeLiquidationAddress,
-  createBridgePlaidLinkToken: () => createBridgePlaidLinkToken,
-  createBridgeTransfer: () => createBridgeTransfer,
-  createDelegation: () => createDelegation,
-  deleteChainId: () => deleteChainId,
-  destroySessionToken: () => destroySessionToken,
-  ensureOfframpRoute: () => ensureOfframpRoute,
-  ensureOnrampRoute: () => ensureOnrampRoute,
-  generateBridgeKycLinks: () => generateBridgeKycLinks,
-  getBridgeCustomer: () => getBridgeCustomer,
-  getBridgeExternalAccounts: () => getBridgeExternalAccounts,
-  getBridgeKycLinkStatus: () => getBridgeKycLinkStatus,
-  getBridgeLiquidationAddresses: () => getBridgeLiquidationAddresses,
-  getChainId: () => getChainId,
-  getCurrentUser: () => getCurrentUser,
-  getDelegateAddress: () => getDelegateAddress,
-  getDelegationStatus: () => getDelegationStatus,
-  getIntegration: () => getIntegration,
-  getNonce: () => getNonce,
-  getSessionVerify: () => getSessionVerify,
-  newPaymentRequest: () => newPaymentRequest,
-  postChainId: () => postChainId,
-  postCheckAddressInWhitelist: () => postCheckAddressInWhitelist,
-  postCheckEmailInWhitelist: () => postCheckEmailInWhitelist,
-  postLogin: () => postLogin,
-  postSessionToken: () => postSessionToken,
-  setAuthTokenGetter: () => setAuthTokenGetter,
-  setSessionToken: () => setSessionToken,
-  turnkeyLogin: () => turnkeyLogin,
-  turnkeyVerification: () => turnkeyVerification,
-  updateBridgeExternalAccountAddress: () => updateBridgeExternalAccountAddress,
-  upsertIntegration: () => upsertIntegration,
-  verifyAuthentication: () => verifyAuthentication
-});
-module.exports = __toCommonJS(server_exports);
-
-// src/server/client.ts
-var import_axios = __toESM(require("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 = import_axios.default.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 = require_client_factory.createApiClient({ environment });
+		clientCache.set(environment, client);
+		return client;
+	}
+	return require_client_factory.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;
-};
-//# sourceMappingURL=index.js.map
+//#endregion
+exports.OtimEnvironment = require_api_urls.OtimEnvironment;
+exports.activateInstruction = activateInstruction;
+exports.bridgeExchangePlaidPublicToken = bridgeExchangePlaidPublicToken;
+exports.buildInstruction = buildInstruction;
+exports.buildPaymentRequest = buildPaymentRequest;
+exports.buildSettlementOrchestration = buildSettlementOrchestration;
+exports.clearServerClientCache = clearServerClientCache;
+exports.createApiClient = require_client_factory.createApiClient;
+exports.createBridgeIbanExternalAccount = createBridgeIbanExternalAccount;
+exports.createBridgeLiquidationAddress = createBridgeLiquidationAddress;
+exports.createBridgePlaidLinkToken = createBridgePlaidLinkToken;
+exports.createBridgeTransfer = createBridgeTransfer;
+exports.createDelegation = createDelegation;
+exports.deleteChainId = deleteChainId;
+exports.destroySessionToken = destroySessionToken;
+exports.ensureOfframpRoute = ensureOfframpRoute;
+exports.ensureOnrampRoute = ensureOnrampRoute;
+exports.generateBridgeKycLinks = generateBridgeKycLinks;
+exports.getAppId = require_api_urls.getAppId;
+exports.getAppUrl = require_api_urls.getAppUrl;
+exports.getAuthTokenGetter = getAuthTokenGetter;
+exports.getBridgeCustomer = getBridgeCustomer;
+exports.getBridgeExternalAccounts = getBridgeExternalAccounts;
+exports.getBridgeKycLinkStatus = getBridgeKycLinkStatus;
+exports.getBridgeLiquidationAddressDrains = getBridgeLiquidationAddressDrains;
+exports.getBridgeLiquidationAddresses = getBridgeLiquidationAddresses;
+exports.getChainId = getChainId;
+exports.getCurrentUser = getCurrentUser;
+exports.getDelegateAddress = getDelegateAddress;
+exports.getDelegationStatus = getDelegationStatus;
+exports.getIntegration = getIntegration;
+exports.getNonce = getNonce;
+exports.getOffchainApiUrl = require_api_urls.getOffchainApiUrl;
+exports.getPlatformApiUrl = require_api_urls.getPlatformApiUrl;
+exports.getServerApiClient = getServerApiClient;
+exports.getSessionVerify = getSessionVerify;
+exports.getWalletConnectProjectId = require_api_urls.getWalletConnectProjectId;
+exports.newPaymentRequest = newPaymentRequest;
+exports.postChainId = postChainId;
+exports.postCheckAddressInWhitelist = postCheckAddressInWhitelist;
+exports.postCheckEmailInWhitelist = postCheckEmailInWhitelist;
+exports.postLogin = postLogin;
+exports.postSessionToken = postSessionToken;
+exports.setAuthTokenGetter = setAuthTokenGetter;
+exports.turnkeyLogin = turnkeyLogin;
+exports.turnkeyVerification = turnkeyVerification;
+exports.updateBridgeExternalAccountAddress = updateBridgeExternalAccountAddress;
+exports.updateUserPreferences = updateUserPreferences;
+exports.upsertIntegration = upsertIntegration;
+exports.verifyAuthentication = verifyAuthentication;
+//# sourceMappingURL=index.js.map