@contractspec/integration.providers-impls 1.57.0 → 1.59.0

package/dist/impls/powens-openbanking.js

@@ -1,219 +1,427 @@
-import { PowensClient, PowensClientError } from "./powens-client.js";
-
-//#region src/impls/powens-openbanking.ts
-var PowensOpenBankingProvider = class {
-	client;
-	logger;
-	constructor(options) {
-		this.client = new PowensClient(options);
-		this.logger = options.logger;
-	}
-	async listAccounts(params) {
-		if (!params.userId) throw new PowensClientError("Powens account listing requires the upstream userId mapped to Powens user UUID.", 400);
-		const context = this.toContext(params.tenantId, params.connectionId);
-		try {
-			const response = await this.client.listAccounts({
-				userUuid: params.userId,
-				cursor: params.cursor,
-				limit: params.pageSize,
-				includeBalances: params.includeBalances,
-				institutionUuid: params.institutionId
-			});
-			return {
-				accounts: response.accounts.map((account) => this.mapAccount(account, context)),
-				nextCursor: response.pagination?.nextCursor,
-				hasMore: response.pagination?.hasMore
-			};
-		} catch (error) {
-			this.handleError("listAccounts", error);
-		}
-	}
-	async getAccountDetails(params) {
-		const context = this.toContext(params.tenantId, params.connectionId);
-		try {
-			const account = await this.client.getAccount(params.accountId);
-			return this.mapAccountDetails(account, context);
-		} catch (error) {
-			this.handleError("getAccountDetails", error);
-		}
-	}
-	async listTransactions(params) {
-		const context = this.toContext(params.tenantId, params.connectionId);
-		try {
-			const response = await this.client.listTransactions({
-				accountUuid: params.accountId,
-				cursor: params.cursor,
-				limit: params.pageSize,
-				from: params.from,
-				to: params.to,
-				includePending: params.includePending
-			});
-			return {
-				transactions: response.transactions.map((transaction) => this.mapTransaction(transaction, context)),
-				nextCursor: response.pagination?.nextCursor,
-				hasMore: response.pagination?.hasMore
-			};
-		} catch (error) {
-			this.handleError("listTransactions", error);
-		}
-	}
-	async getBalances(params) {
-		const context = this.toContext(params.tenantId, params.connectionId);
-		try {
-			return (await this.client.getBalances(params.accountId)).filter((balance) => params.balanceTypes?.length ? params.balanceTypes.includes(String(balance.type)) : true).map((balance) => this.mapBalance(balance, context));
-		} catch (error) {
-			this.handleError("getBalances", error);
-		}
-	}
-	async getConnectionStatus(params) {
-		try {
-			const status = await this.client.getConnectionStatus(params.connectionId);
-			return {
-				connectionId: params.connectionId,
-				tenantId: params.tenantId,
-				status: this.mapConnectionStatus(status.status),
-				lastCheckedAt: status.lastAttemptAt,
-				errorCode: status.errorCode,
-				errorMessage: status.errorMessage,
-				details: status.metadata
-			};
-		} catch (error) {
-			this.handleError("getConnectionStatus", error);
-		}
-	}
-	mapAccount(account, context) {
-		return {
-			id: account.uuid,
-			externalId: account.reference ?? account.uuid,
-			tenantId: context.tenantId,
-			connectionId: context.connectionId,
-			userId: account.userUuid,
-			displayName: account.name,
-			institutionId: account.institution.id,
-			institutionName: account.institution.name,
-			institutionLogoUrl: account.institution.logoUrl,
-			accountType: account.type ?? "unknown",
-			iban: account.iban,
-			bic: account.bic,
-			currency: account.currency ?? "EUR",
-			accountNumberMasked: account.metadata?.account_number_masked,
-			ownership: this.mapOwnership(account.metadata?.ownership),
-			status: this.mapAccountStatus(account.status),
-			lastSyncedAt: account.metadata?.last_sync_at,
-			metadata: account.metadata
-		};
-	}
-	mapAccountDetails(account, context) {
-		return {
-			...this.mapAccount(account, context),
-			productCode: account.metadata?.product_code,
-			openedAt: account.metadata?.opened_at,
-			closedAt: account.metadata?.closed_at,
-			availableBalance: account.availableBalance ?? void 0,
-			currentBalance: account.balance ?? void 0,
-			creditLimit: account.metadata?.credit_limit,
-			customFields: account.metadata
-		};
-	}
-	mapTransaction(transaction, context) {
-		return {
-			id: transaction.uuid,
-			externalId: transaction.uuid,
-			tenantId: context.tenantId,
-			accountId: transaction.accountUuid,
-			connectionId: context.connectionId,
-			amount: transaction.amount,
-			currency: transaction.currency,
-			direction: transaction.direction === "credit" ? "credit" : "debit",
-			description: transaction.description ?? transaction.rawLabel,
-			bookingDate: transaction.bookingDate,
-			valueDate: transaction.valueDate,
-			postedAt: transaction.bookingDate,
-			category: transaction.category,
-			rawCategory: transaction.rawLabel,
-			merchantName: transaction.merchantName,
-			merchantCategoryCode: transaction.merchantCategoryCode,
-			counterpartyName: transaction.counterpartyName,
-			counterpartyAccount: transaction.counterpartyAccount,
-			reference: transaction.metadata?.reference,
-			status: this.mapTransactionStatus(transaction.status),
-			metadata: transaction.metadata
-		};
-	}
-	mapBalance(balance, context) {
-		return {
-			accountId: balance.accountUuid,
-			connectionId: context.connectionId,
-			tenantId: context.tenantId,
-			type: balance.type ?? "current",
-			currency: balance.currency ?? "EUR",
-			amount: balance.amount,
-			lastUpdatedAt: balance.updatedAt,
-			metadata: balance.metadata
-		};
-	}
-	toContext(tenantId, connectionId) {
-		return {
-			tenantId,
-			connectionId
-		};
-	}
-	mapOwnership(value) {
-		switch (value?.toLowerCase()) {
-			case "individual":
-			case "personal": return "individual";
-			case "joint": return "joint";
-			case "business":
-			case "corporate": return "business";
-			default: return "unknown";
-		}
-	}
-	mapAccountStatus(status) {
-		switch (status?.toLowerCase()) {
-			case "active":
-			case "enabled": return "active";
-			case "disabled":
-			case "inactive": return "inactive";
-			case "closed": return "closed";
-			case "suspended": return "suspended";
-			default: return "active";
-		}
-	}
-	mapTransactionStatus(status) {
-		switch (status?.toLowerCase()) {
-			case "pending":
-			case "authorised": return "pending";
-			case "booked":
-			case "posted": return "booked";
-			case "cancelled":
-			case "rejected": return "cancelled";
-			default: return "booked";
-		}
-	}
-	mapConnectionStatus(status) {
-		switch (status) {
-			case "healthy": return "healthy";
-			case "pending": return "degraded";
-			case "error": return "error";
-			case "revoked": return "disconnected";
-			default: return "degraded";
-		}
-	}
-	handleError(operation, error) {
-		if (error instanceof PowensClientError) {
-			this.logger?.error?.(`[PowensOpenBankingProvider] ${operation} failed`, {
-				status: error.status,
-				code: error.code,
-				requestId: error.requestId,
-				message: error.message
-			});
-			throw error;
-		}
-		this.logger?.error?.(`[PowensOpenBankingProvider] ${operation} failed with unexpected error`, error);
-		throw error instanceof Error ? error : /* @__PURE__ */ new Error(`Powens operation "${operation}" failed`);
-	}
+// @bun
+// src/impls/powens-client.ts
+import { URL } from "url";
+var POWENS_BASE_URL = {
+  sandbox: "https://api-sandbox.powens.com/v2",
+  production: "https://api.powens.com/v2"
 };
 
-//#endregion
-export { PowensOpenBankingProvider };
-//# sourceMappingURL=powens-openbanking.js.map
+class PowensClientError extends Error {
+  status;
+  code;
+  requestId;
+  response;
+  constructor(message, status, code, requestId, response) {
+    super(message);
+    this.name = "PowensClientError";
+    this.status = status;
+    this.code = code;
+    this.requestId = requestId;
+    this.response = response;
+  }
+}
+
+class PowensClient {
+  clientId;
+  clientSecret;
+  apiKey;
+  fetchImpl;
+  logger;
+  defaultTimeoutMs;
+  token;
+  baseUrl;
+  constructor(options) {
+    this.clientId = options.clientId;
+    this.clientSecret = options.clientSecret;
+    this.apiKey = options.apiKey;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+    this.logger = options.logger;
+    this.defaultTimeoutMs = options.defaultTimeoutMs ?? 15000;
+    this.baseUrl = options.baseUrl ?? POWENS_BASE_URL[options.environment] ?? POWENS_BASE_URL.production;
+  }
+  async listAccounts(params) {
+    const searchParams = {
+      cursor: params.cursor,
+      limit: params.limit,
+      include_balances: params.includeBalances,
+      institution_uuid: params.institutionUuid
+    };
+    const response = await this.request({
+      method: "GET",
+      path: `/users/${encodeURIComponent(params.userUuid)}/accounts`,
+      searchParams
+    });
+    return response;
+  }
+  async getAccount(accountUuid) {
+    return this.request({
+      method: "GET",
+      path: `/accounts/${encodeURIComponent(accountUuid)}`
+    });
+  }
+  async listTransactions(params) {
+    const searchParams = {
+      cursor: params.cursor,
+      limit: params.limit,
+      from: params.from,
+      to: params.to,
+      include_pending: params.includePending
+    };
+    return this.request({
+      method: "GET",
+      path: `/accounts/${encodeURIComponent(params.accountUuid)}/transactions`,
+      searchParams
+    });
+  }
+  async getBalances(accountUuid) {
+    return this.request({
+      method: "GET",
+      path: `/accounts/${encodeURIComponent(accountUuid)}/balances`
+    });
+  }
+  async getConnectionStatus(connectionUuid) {
+    return this.request({
+      method: "GET",
+      path: `/connections/${encodeURIComponent(connectionUuid)}`
+    });
+  }
+  async request(options) {
+    const url = new URL(options.path, this.baseUrl);
+    if (options.searchParams) {
+      for (const [key, value] of Object.entries(options.searchParams)) {
+        if (value === undefined || value === null)
+          continue;
+        url.searchParams.set(key, String(value));
+      }
+    }
+    const headers = {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+    if (this.apiKey) {
+      headers["x-api-key"] = this.apiKey;
+    }
+    if (!options.skipAuth) {
+      const token = await this.ensureAccessToken();
+      headers.Authorization = `Bearer ${token}`;
+    }
+    const controller = new AbortController;
+    const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? this.defaultTimeoutMs);
+    try {
+      const response = await this.fetchImpl(url, {
+        method: options.method,
+        headers,
+        body: options.body ? JSON.stringify(options.body) : undefined,
+        signal: controller.signal
+      });
+      const requestId = response.headers.get("x-request-id") ?? undefined;
+      if (!response.ok) {
+        let errorBody;
+        try {
+          errorBody = await response.json();
+        } catch {}
+        const errorObject = typeof errorBody === "object" && errorBody !== null ? errorBody : undefined;
+        const message = typeof errorObject?.message === "string" ? errorObject.message : `Powens API request failed with status ${response.status}`;
+        const code = typeof errorObject?.code === "string" ? errorObject.code : undefined;
+        throw new PowensClientError(message, response.status, code, requestId, errorBody);
+      }
+      if (response.status === 204) {
+        return;
+      }
+      try {
+        return await response.json();
+      } catch (error) {
+        this.logger?.error?.("[PowensClient] Failed to parse JSON response", error);
+        throw new PowensClientError("Failed to parse Powens response payload as JSON", response.status, undefined, requestId);
+      }
+    } catch (error) {
+      if (error instanceof PowensClientError) {
+        throw error;
+      }
+      if (error.name === "AbortError") {
+        throw new PowensClientError(`Powens API request timed out after ${options.timeoutMs ?? this.defaultTimeoutMs}ms`, 408);
+      }
+      this.logger?.error?.("[PowensClient] Request failed", error);
+      throw new PowensClientError(error.message ?? "Powens API request failed", 500);
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  async ensureAccessToken() {
+    if (this.token && Date.now() < this.token.expiresAt - 5000) {
+      return this.token.accessToken;
+    }
+    this.token = await this.fetchAccessToken();
+    return this.token.accessToken;
+  }
+  async fetchAccessToken() {
+    const url = new URL("/oauth/token", this.baseUrl);
+    const basicAuth = Buffer.from(`${this.clientId}:${this.clientSecret}`, "utf-8").toString("base64");
+    const response = await this.fetchImpl(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Basic ${basicAuth}`,
+        "Content-Type": "application/x-www-form-urlencoded",
+        Accept: "application/json"
+      },
+      body: new URLSearchParams({
+        grant_type: "client_credentials"
+      }).toString()
+    });
+    if (!response.ok) {
+      let errorBody;
+      try {
+        errorBody = await response.json();
+      } catch {}
+      const errorObject = typeof errorBody === "object" && errorBody !== null ? errorBody : undefined;
+      const message = typeof errorObject?.error_description === "string" ? errorObject.error_description : "Failed to obtain Powens access token";
+      throw new PowensClientError(message, response.status, undefined, undefined, errorBody);
+    }
+    const payload = await response.json();
+    const expiresAt = Date.now() + payload.expires_in * 1000;
+    this.logger?.debug?.("[PowensClient] Received access token", {
+      expiresIn: payload.expires_in
+    });
+    return {
+      accessToken: payload.access_token,
+      expiresAt,
+      scope: payload.scope
+    };
+  }
+}
+
+// src/impls/powens-openbanking.ts
+class PowensOpenBankingProvider {
+  client;
+  logger;
+  constructor(options) {
+    this.client = new PowensClient(options);
+    this.logger = options.logger;
+  }
+  async listAccounts(params) {
+    if (!params.userId) {
+      throw new PowensClientError("Powens account listing requires the upstream userId mapped to Powens user UUID.", 400);
+    }
+    const context = this.toContext(params.tenantId, params.connectionId);
+    try {
+      const response = await this.client.listAccounts({
+        userUuid: params.userId,
+        cursor: params.cursor,
+        limit: params.pageSize,
+        includeBalances: params.includeBalances,
+        institutionUuid: params.institutionId
+      });
+      return {
+        accounts: response.accounts.map((account) => this.mapAccount(account, context)),
+        nextCursor: response.pagination?.nextCursor,
+        hasMore: response.pagination?.hasMore
+      };
+    } catch (error) {
+      this.handleError("listAccounts", error);
+    }
+  }
+  async getAccountDetails(params) {
+    const context = this.toContext(params.tenantId, params.connectionId);
+    try {
+      const account = await this.client.getAccount(params.accountId);
+      return this.mapAccountDetails(account, context);
+    } catch (error) {
+      this.handleError("getAccountDetails", error);
+    }
+  }
+  async listTransactions(params) {
+    const context = this.toContext(params.tenantId, params.connectionId);
+    try {
+      const response = await this.client.listTransactions({
+        accountUuid: params.accountId,
+        cursor: params.cursor,
+        limit: params.pageSize,
+        from: params.from,
+        to: params.to,
+        includePending: params.includePending
+      });
+      return {
+        transactions: response.transactions.map((transaction) => this.mapTransaction(transaction, context)),
+        nextCursor: response.pagination?.nextCursor,
+        hasMore: response.pagination?.hasMore
+      };
+    } catch (error) {
+      this.handleError("listTransactions", error);
+    }
+  }
+  async getBalances(params) {
+    const context = this.toContext(params.tenantId, params.connectionId);
+    try {
+      const balances = await this.client.getBalances(params.accountId);
+      return balances.filter((balance) => params.balanceTypes?.length ? params.balanceTypes.includes(String(balance.type)) : true).map((balance) => this.mapBalance(balance, context));
+    } catch (error) {
+      this.handleError("getBalances", error);
+    }
+  }
+  async getConnectionStatus(params) {
+    try {
+      const status = await this.client.getConnectionStatus(params.connectionId);
+      return {
+        connectionId: params.connectionId,
+        tenantId: params.tenantId,
+        status: this.mapConnectionStatus(status.status),
+        lastCheckedAt: status.lastAttemptAt,
+        errorCode: status.errorCode,
+        errorMessage: status.errorMessage,
+        details: status.metadata
+      };
+    } catch (error) {
+      this.handleError("getConnectionStatus", error);
+    }
+  }
+  mapAccount(account, context) {
+    return {
+      id: account.uuid,
+      externalId: account.reference ?? account.uuid,
+      tenantId: context.tenantId,
+      connectionId: context.connectionId,
+      userId: account.userUuid,
+      displayName: account.name,
+      institutionId: account.institution.id,
+      institutionName: account.institution.name,
+      institutionLogoUrl: account.institution.logoUrl,
+      accountType: account.type ?? "unknown",
+      iban: account.iban,
+      bic: account.bic,
+      currency: account.currency ?? "EUR",
+      accountNumberMasked: account.metadata?.account_number_masked,
+      ownership: this.mapOwnership(account.metadata?.ownership),
+      status: this.mapAccountStatus(account.status),
+      lastSyncedAt: account.metadata?.last_sync_at,
+      metadata: account.metadata
+    };
+  }
+  mapAccountDetails(account, context) {
+    return {
+      ...this.mapAccount(account, context),
+      productCode: account.metadata?.product_code,
+      openedAt: account.metadata?.opened_at,
+      closedAt: account.metadata?.closed_at,
+      availableBalance: account.availableBalance ?? undefined,
+      currentBalance: account.balance ?? undefined,
+      creditLimit: account.metadata?.credit_limit,
+      customFields: account.metadata
+    };
+  }
+  mapTransaction(transaction, context) {
+    return {
+      id: transaction.uuid,
+      externalId: transaction.uuid,
+      tenantId: context.tenantId,
+      accountId: transaction.accountUuid,
+      connectionId: context.connectionId,
+      amount: transaction.amount,
+      currency: transaction.currency,
+      direction: transaction.direction === "credit" ? "credit" : "debit",
+      description: transaction.description ?? transaction.rawLabel,
+      bookingDate: transaction.bookingDate,
+      valueDate: transaction.valueDate,
+      postedAt: transaction.bookingDate,
+      category: transaction.category,
+      rawCategory: transaction.rawLabel,
+      merchantName: transaction.merchantName,
+      merchantCategoryCode: transaction.merchantCategoryCode,
+      counterpartyName: transaction.counterpartyName,
+      counterpartyAccount: transaction.counterpartyAccount,
+      reference: transaction.metadata?.reference,
+      status: this.mapTransactionStatus(transaction.status),
+      metadata: transaction.metadata
+    };
+  }
+  mapBalance(balance, context) {
+    return {
+      accountId: balance.accountUuid,
+      connectionId: context.connectionId,
+      tenantId: context.tenantId,
+      type: balance.type ?? "current",
+      currency: balance.currency ?? "EUR",
+      amount: balance.amount,
+      lastUpdatedAt: balance.updatedAt,
+      metadata: balance.metadata
+    };
+  }
+  toContext(tenantId, connectionId) {
+    return { tenantId, connectionId };
+  }
+  mapOwnership(value) {
+    switch (value?.toLowerCase()) {
+      case "individual":
+      case "personal":
+        return "individual";
+      case "joint":
+        return "joint";
+      case "business":
+      case "corporate":
+        return "business";
+      default:
+        return "unknown";
+    }
+  }
+  mapAccountStatus(status) {
+    switch (status?.toLowerCase()) {
+      case "active":
+      case "enabled":
+        return "active";
+      case "disabled":
+      case "inactive":
+        return "inactive";
+      case "closed":
+        return "closed";
+      case "suspended":
+        return "suspended";
+      default:
+        return "active";
+    }
+  }
+  mapTransactionStatus(status) {
+    switch (status?.toLowerCase()) {
+      case "pending":
+      case "authorised":
+        return "pending";
+      case "booked":
+      case "posted":
+        return "booked";
+      case "cancelled":
+      case "rejected":
+        return "cancelled";
+      default:
+        return "booked";
+    }
+  }
+  mapConnectionStatus(status) {
+    switch (status) {
+      case "healthy":
+        return "healthy";
+      case "pending":
+        return "degraded";
+      case "error":
+        return "error";
+      case "revoked":
+        return "disconnected";
+      default:
+        return "degraded";
+    }
+  }
+  handleError(operation, error) {
+    if (error instanceof PowensClientError) {
+      this.logger?.error?.(`[PowensOpenBankingProvider] ${operation} failed`, {
+        status: error.status,
+        code: error.code,
+        requestId: error.requestId,
+        message: error.message
+      });
+      throw error;
+    }
+    this.logger?.error?.(`[PowensOpenBankingProvider] ${operation} failed with unexpected error`, error);
+    throw error instanceof Error ? error : new Error(`Powens operation "${operation}" failed`);
+  }
+}
+export {
+  PowensOpenBankingProvider
+};