@alphawebai/hs-prism 0.1.0-rc.27

package/dist/src/alphaweb/types.d.ts

@@ -0,0 +1,255 @@
+export type PrismEnvironment = 'test' | 'live';
+export type PrismOperationKind = 'checkout' | 'post_purchase' | 'subscription_renewal' | 'refund' | 'cancel';
+export interface PrismMoney {
+    amountMinor: string;
+    currency: string;
+}
+export type PrismReusableCapability = 'off_session' | 'post_purchase' | 'manual_capture' | 'subscription';
+export interface PrismReusablePaymentReference {
+    version: 1;
+    connector: 'stripe';
+    credentialBindingId: string;
+    providerAccountId: string;
+    livemode: boolean;
+    connectorCustomerId: string;
+    connectorPaymentMethodId: string;
+    connectorMandateId?: string;
+    sourcePaymentIntentId?: string;
+    capabilities: PrismReusableCapability[];
+}
+export interface PrismMerchantOperation {
+    operationId: string;
+    idempotencyKey: string;
+    credentialBindingId: string;
+    kind: PrismOperationKind;
+    money: PrismMoney;
+    customerReference?: string;
+    reusableReference?: PrismReusablePaymentReference;
+    methodSelection: {
+        kind: 'interactive_dynamic';
+        paymentMethodConfigurationId?: string;
+    } | {
+        kind: 'reusable_reference';
+    };
+    metadata: Record<string, string>;
+}
+export interface PrismRetryPaymentInput extends PrismMerchantOperation {
+    connectorPaymentId: string;
+}
+export type PrismNormalizedPaymentStatus = 'requires_payment_method' | 'requires_customer_action' | 'pending_authorization' | 'authorized' | 'captured' | 'canceled' | 'failed' | 'unknown';
+export interface PrismPaymentFailure {
+    category: 'declined' | 'customer_action' | 'invalid_payment_method' | 'unknown';
+    providerCode?: string;
+    declineCode?: string;
+    adviceCode?: string;
+    retryable: boolean;
+}
+export interface PrismPaymentResult {
+    connectorPaymentId: string | null;
+    status: PrismNormalizedPaymentStatus;
+    money: PrismMoney;
+    clientSecret?: string;
+    publishableKey?: string;
+    reusableReference?: PrismReusablePaymentReference;
+    providerRequestId?: string;
+    failure?: PrismPaymentFailure;
+}
+export interface PrismRefundResult {
+    connectorRefundId: string | null;
+    connectorPaymentId?: string;
+    status: 'pending' | 'succeeded' | 'failed' | 'unknown';
+    money: PrismMoney;
+    providerRequestId?: string;
+}
+export interface PrismRetrieveRefundInput {
+    connectorRefundId: string;
+    connectorPaymentId: string;
+    operationId?: string;
+    money?: PrismMoney;
+}
+export interface PrismFindRefundInput {
+    operationId: string;
+    connectorPaymentId: string;
+    money: PrismMoney;
+}
+export interface PrismDisputeResult {
+    connectorDisputeId: string;
+    connectorChargeId: string;
+    connectorPaymentId: string;
+    status: 'warning_needs_response' | 'needs_response' | 'under_review' | 'won' | 'lost' | 'closed' | 'unknown';
+    money: PrismMoney;
+    reason?: string;
+    evidenceDueAt?: string;
+    providerCreatedAt: string;
+    safeData: Record<string, string | number | boolean | null>;
+}
+export interface PrismRetrieveDisputeInput {
+    connectorDisputeId: string;
+}
+export interface PrismRetrievePaymentInput {
+    connectorPaymentId: string;
+    money: PrismMoney;
+    operationId: string;
+    expectedOwnerId?: string;
+    expectedConnectorCustomerId?: string;
+}
+export interface PrismEstablishReusableReferenceInput extends PrismRetrievePaymentInput {
+    expectedOwnerId: string;
+    purposes: Array<'post_purchase' | 'subscription'>;
+}
+export type PrismReusableReferenceDerivation = {
+    status: 'established';
+    reference: PrismReusablePaymentReference;
+    safeDisplay?: {
+        brand?: string;
+        last4?: string;
+        expMonth?: number;
+        expYear?: number;
+    };
+} | {
+    status: 'not_supported';
+    reason: 'payment_method_not_reusable' | 'requested_capability_not_supported';
+};
+export interface PrismFindPaymentInput {
+    operationId: string;
+    createdAfter?: string;
+    money?: PrismMoney;
+    expectedOwnerId?: string;
+    expectedConnectorCustomerId?: string;
+}
+export interface PrismCaptureInput extends PrismRetrievePaymentInput {
+    idempotencyKey: string;
+}
+export interface PrismCancelInput {
+    connectorPaymentId: string;
+    operationId: string;
+    idempotencyKey: string;
+}
+export interface PrismRefundInput extends PrismRetrievePaymentInput {
+    idempotencyKey: string;
+    refundId: string;
+}
+export interface PrismWebhookSigningSecretBinding {
+    credentialBindingId: string;
+    providerAccountId: string;
+    livemode: boolean;
+    endpointId: string;
+    secret: string;
+}
+export interface PrismWebhookParseInput {
+    rawBody: Uint8Array;
+    signatureHeader: string;
+    signingSecretBindings: PrismWebhookSigningSecretBinding[];
+    expectedApiVersion: string;
+}
+export interface PrismVerifiedWebhookEnvelope {
+    provider: 'stripe';
+    providerEventId: string;
+    credentialBindingId: string;
+    providerAccountId: string;
+    livemode: boolean;
+    apiVersion: string | null;
+    type: string;
+    createdAt: string;
+    objectKind: 'payment_intent' | 'setup_intent' | 'refund' | 'dispute' | 'mandate' | 'payment_method' | 'unknown';
+    objectId: string | null;
+    paymentIntentId: string | null;
+    bodyDigest: string;
+}
+export interface PrismNormalizedWebhookEvent extends PrismVerifiedWebhookEnvelope {
+    customerId: string | null;
+    paymentMethodId: string | null;
+    mandateId: string | null;
+    merchantOperationId: string | null;
+    medusaPaymentSessionId: string | null;
+    status: PrismNormalizedPaymentStatus | null;
+    money: PrismMoney | null;
+    refunds: Array<{
+        refundId: string;
+        chargeId: string | null;
+        paymentIntentId: string | null;
+        status: 'pending' | 'succeeded' | 'failed' | 'canceled' | 'unknown';
+        money: PrismMoney;
+    }>;
+    safeData: Record<string, string | number | boolean | null>;
+}
+export type PrismWebhookParseResult = {
+    status: 'normalized';
+    event: PrismNormalizedWebhookEvent;
+} | {
+    status: 'normalization_failed';
+    envelope: PrismVerifiedWebhookEnvelope;
+    error: {
+        code: 'WEBHOOK_SCHEMA_VERSION_MISMATCH' | 'WEBHOOK_EVENT_UNSUPPORTED' | 'WEBHOOK_OBJECT_INVALID';
+        safeMessage: string;
+    };
+};
+export interface PrismWebhookEndpoint {
+    endpointId: string;
+    url: string;
+    enabled: boolean;
+    apiVersion: string;
+    events: string[];
+    metadata: Record<string, string>;
+}
+export interface PrismWebhookEndpointCreated extends PrismWebhookEndpoint {
+    signingSecret: string;
+}
+export interface PrismCreateWebhookEndpointInput {
+    callbackUrl: string;
+    idempotencyKey: string;
+    metadata: Record<string, string>;
+}
+export interface PrismUpdateWebhookEndpointInput {
+    endpointId: string;
+    idempotencyKey: string;
+    callbackUrl?: string;
+    enabled?: boolean;
+}
+export interface PrismDeleteWebhookEndpointInput {
+    endpointId: string;
+    idempotencyKey: string;
+}
+export interface PrismRetrieveWebhookEndpointInput {
+    endpointId: string;
+}
+export interface PrismStripeRuntimeVerificationInput {
+    environment: PrismEnvironment;
+    secretKey: string;
+    publishableKey?: string;
+    expectedProviderAccountId?: string;
+    nativeLibraryPath?: string;
+    requestTimeoutMs?: number;
+}
+export interface PrismStripeRuntimeVerification {
+    providerAccountId: string;
+    livemode: boolean;
+}
+export interface PrismStripeConnectorV1 {
+    createPayment(input: PrismMerchantOperation): Promise<PrismPaymentResult>;
+    repeatPayment(input: PrismMerchantOperation): Promise<PrismPaymentResult>;
+    retryPayment(input: PrismRetryPaymentInput): Promise<PrismPaymentResult>;
+    retrievePayment(input: PrismRetrievePaymentInput): Promise<PrismPaymentResult>;
+    establishReusableReference(input: PrismEstablishReusableReferenceInput): Promise<PrismReusableReferenceDerivation>;
+    findPaymentsByMerchantOperation(input: PrismFindPaymentInput): Promise<PrismPaymentResult[]>;
+    capturePayment(input: PrismCaptureInput): Promise<PrismPaymentResult>;
+    cancelPayment(input: PrismCancelInput): Promise<PrismPaymentResult>;
+    refundPayment(input: PrismRefundInput): Promise<PrismRefundResult>;
+    retrieveRefund(input: PrismRetrieveRefundInput): Promise<PrismRefundResult>;
+    findRefundsByMerchantOperation(input: PrismFindRefundInput): Promise<PrismRefundResult[]>;
+    retrieveDispute(input: PrismRetrieveDisputeInput): Promise<PrismDisputeResult>;
+    parseWebhookEvent(input: PrismWebhookParseInput): Promise<PrismWebhookParseResult>;
+    createWebhookEndpoint(input: PrismCreateWebhookEndpointInput): Promise<PrismWebhookEndpointCreated>;
+    updateWebhookEndpoint(input: PrismUpdateWebhookEndpointInput): Promise<PrismWebhookEndpoint>;
+    deleteWebhookEndpoint(input: PrismDeleteWebhookEndpointInput): Promise<void>;
+    retrieveWebhookEndpoint(input: PrismRetrieveWebhookEndpointInput): Promise<PrismWebhookEndpoint>;
+}
+export interface PrismStripeConnectorOptions {
+    environment: PrismEnvironment;
+    credentialBindingId: string;
+    providerAccountId: string;
+    secretKey: string;
+    publishableKey?: string;
+    nativeLibraryPath?: string;
+    requestTimeoutMs?: number;
+}

package/dist/src/alphaweb/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/src/http_client.d.ts

@@ -0,0 +1,58 @@
+import { Dispatcher } from "undici";
+import { types } from "./payments/generated/proto";
+/**
+ * Normalized HTTP Request structure for the Connector Service.
+ */
+export interface HttpRequest {
+    url: string;
+    method: string;
+    headers?: Record<string, string>;
+    body?: Uint8Array;
+}
+/**
+ * Normalized HTTP Response structure.
+ */
+export interface HttpResponse {
+    statusCode: number;
+    headers: Record<string, string>;
+    body: Uint8Array;
+    latencyMs: number;
+}
+/** Optional mock intercept — set by smoke test in mock mode only. */
+export declare let _intercept: ((req: HttpRequest) => Promise<HttpResponse>) | null;
+/** Network error codes from proto (single source of truth). */
+export declare const NetworkErrorCode: typeof types.NetworkErrorCode;
+/**
+ * Network error for HTTP transport failures (timeouts, connection errors, config).
+ * Uses proto-generated NetworkErrorCode for cross-SDK parity with IntegrationError/ConnectorError.
+ */
+export declare class NetworkError extends Error {
+    code: types.NetworkErrorCode;
+    statusCode?: number | undefined;
+    body?: string | undefined;
+    headers?: Record<string, string> | undefined;
+    constructor(message: string, code?: types.NetworkErrorCode, statusCode?: number | undefined, body?: string | undefined, headers?: Record<string, string> | undefined);
+    /**
+     * String error code for parity with IntegrationError/ConnectorError (e.g. "CONNECT_TIMEOUT").
+     * Use for logging, display, and simple comparisons.
+     */
+    get errorCode(): string;
+}
+/**
+ * Resolve proxy URL, honoring bypass rules.
+ */
+export declare function resolveProxyUrl(url: string, proxy?: types.IProxyOptions | null): string | null;
+/**
+ * Generate a cache key from proxy configuration for HTTP client caching.
+ * Returns empty string when no proxy is configured.
+ */
+export declare function generateProxyCacheKey(proxy?: types.IProxyOptions | null): string;
+/**
+ * Creates a high-performance dispatcher with specialized fintech timeouts.
+ * (The instance-level connection pool)
+ */
+export declare function createDispatcher(config: types.IHttpConfig): Dispatcher;
+/**
+ * Standardized network execution engine for Unified Connector Service.
+ */
+export declare function execute(request: HttpRequest, options?: types.IHttpConfig, dispatcher?: Dispatcher): Promise<HttpResponse>;

package/dist/src/http_client.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkError = exports.NetworkErrorCode = exports._intercept = void 0;
+exports.resolveProxyUrl = resolveProxyUrl;
+exports.generateProxyCacheKey = generateProxyCacheKey;
+exports.createDispatcher = createDispatcher;
+exports.execute = execute;
+const undici_1 = require("undici");
+// @ts-ignore
+const proto_1 = require("./payments/generated/proto");
+const Defaults = proto_1.types.HttpDefault;
+/** Optional mock intercept — set by smoke test in mock mode only. */
+exports._intercept = null;
+/** Network error codes from proto (single source of truth). */
+exports.NetworkErrorCode = proto_1.types.NetworkErrorCode;
+/**
+ * Network error for HTTP transport failures (timeouts, connection errors, config).
+ * Uses proto-generated NetworkErrorCode for cross-SDK parity with IntegrationError/ConnectorError.
+ */
+class NetworkError extends Error {
+    code;
+    statusCode;
+    body;
+    headers;
+    constructor(message, code = proto_1.types.NetworkErrorCode.NETWORK_ERROR_CODE_UNSPECIFIED, statusCode, body, headers) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.body = body;
+        this.headers = headers;
+        this.name = "NetworkError";
+    }
+    /**
+     * String error code for parity with IntegrationError/ConnectorError (e.g. "CONNECT_TIMEOUT").
+     * Use for logging, display, and simple comparisons.
+     */
+    get errorCode() {
+        return proto_1.types.NetworkErrorCode[this.code] ?? "NETWORK_ERROR_CODE_UNSPECIFIED";
+    }
+}
+exports.NetworkError = NetworkError;
+/**
+ * Resolve proxy URL, honoring bypass rules.
+ */
+function resolveProxyUrl(url, proxy) {
+    if (!proxy)
+        return null;
+    const shouldBypass = Array.isArray(proxy.bypassUrls) && proxy.bypassUrls.includes(url);
+    if (shouldBypass)
+        return null;
+    return proxy.httpsUrl || proxy.httpUrl || null;
+}
+/**
+ * Generate a cache key from proxy configuration for HTTP client caching.
+ * Returns empty string when no proxy is configured.
+ */
+function generateProxyCacheKey(proxy) {
+    if (!proxy)
+        return "";
+    const httpUrl = proxy.httpUrl || "";
+    const httpsUrl = proxy.httpsUrl || "";
+    const bypassUrls = Array.isArray(proxy.bypassUrls)
+        ? [...proxy.bypassUrls].sort().join(",")
+        : "";
+    return `${httpUrl}|${httpsUrl}|${bypassUrls}`;
+}
+/**
+ * Creates a high-performance dispatcher with specialized fintech timeouts.
+ * (The instance-level connection pool)
+ */
+function createDispatcher(config) {
+    let ca;
+    if (config.caCert) {
+        if (config.caCert.pem) {
+            ca = config.caCert.pem;
+        }
+        else if (config.caCert.der) {
+            ca = config.caCert.der;
+        }
+    }
+    const connectOptions = {
+        timeout: config.connectTimeoutMs ?? Defaults.CONNECT_TIMEOUT_MS,
+        ca,
+    };
+    const commonOptions = {
+        headersTimeout: config.responseTimeoutMs ?? Defaults.RESPONSE_TIMEOUT_MS,
+        bodyTimeout: config.responseTimeoutMs ?? Defaults.RESPONSE_TIMEOUT_MS,
+        keepAliveTimeout: config.keepAliveTimeoutMs ?? Defaults.KEEP_ALIVE_TIMEOUT_MS,
+    };
+    const proxyUrl = config.proxy?.httpsUrl || config.proxy?.httpUrl;
+    try {
+        if (proxyUrl) {
+            // For a CONNECT proxy:
+            //   - `connect`     governs TLS to the proxy itself (HTTP proxy → no TLS needed)
+            //   - `requestTls`  governs TLS for the tunneled origin connection (the CONNECT tunnel)
+            //                   This is where the custom CA must live so Node trusts the
+            //                   mitmproxy-issued leaf certificate for api.stripe.com, etc.
+            return new undici_1.ProxyAgent({
+                uri: proxyUrl,
+                ...commonOptions,
+                connect: { timeout: config.connectTimeoutMs ?? Defaults.CONNECT_TIMEOUT_MS },
+                requestTls: { ca },
+            });
+        }
+        return new undici_1.Agent({ ...commonOptions, connect: connectOptions });
+    }
+    catch (error) {
+        const code = proxyUrl ? proto_1.types.NetworkErrorCode.INVALID_PROXY_CONFIGURATION : proto_1.types.NetworkErrorCode.CLIENT_INITIALIZATION_FAILURE;
+        throw new NetworkError(`Internal HTTP setup failed: ${error.message}`, code, 500);
+    }
+}
+/**
+ * Standardized network execution engine for Unified Connector Service.
+ */
+async function execute(request, options = {}, dispatcher // Pass the instance-owned pool here
+) {
+    // Check for mock intercept (used in smoke test mock mode)
+    if (exports._intercept) {
+        return (0, exports._intercept)(request);
+    }
+    const { url, method, headers, body } = request;
+    try {
+        new URL(url);
+    }
+    catch {
+        throw new NetworkError(`Invalid URL: ${url}`, proto_1.types.NetworkErrorCode.URL_PARSING_FAILED);
+    }
+    const totalTimeout = options.totalTimeoutMs ?? Defaults.TOTAL_TIMEOUT_MS;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), totalTimeout);
+    const startTime = Date.now();
+    try {
+        const response = await fetch(url, {
+            method: method.toUpperCase(),
+            headers: headers || {},
+            body: body ? Buffer.from(body) : undefined,
+            redirect: "manual",
+            signal: controller.signal,
+            // @ts-ignore
+            dispatcher,
+        });
+        const responseHeaders = {};
+        response.headers.forEach((v, k) => { responseHeaders[k.toLowerCase()] = v; });
+        let responseBody;
+        try {
+            responseBody = new Uint8Array(await response.arrayBuffer());
+        }
+        catch (e) {
+            throw new NetworkError(`Failed to read response body: ${e?.message || e}`, proto_1.types.NetworkErrorCode.RESPONSE_DECODING_FAILED, response.status);
+        }
+        return {
+            statusCode: response.status,
+            headers: responseHeaders,
+            body: responseBody,
+            latencyMs: Date.now() - startTime
+        };
+    }
+    catch (error) {
+        if (error instanceof NetworkError)
+            throw error;
+        if (error.name === 'AbortError') {
+            throw new NetworkError(`Total Request Timeout: ${method} ${url} exceeded ${totalTimeout}ms`, proto_1.types.NetworkErrorCode.TOTAL_TIMEOUT_EXCEEDED, 504);
+        }
+        const cause = error.cause;
+        if (cause) {
+            if (cause.code === 'UND_ERR_CONNECT_TIMEOUT') {
+                throw new NetworkError(`Connection Timeout: Failed to connect to ${url}`, proto_1.types.NetworkErrorCode.CONNECT_TIMEOUT_EXCEEDED, 504);
+            }
+            if (cause.code === 'UND_ERR_BODY_TIMEOUT' || cause.code === 'UND_ERR_HEADERS_TIMEOUT') {
+                throw new NetworkError(`Response Timeout: Gateway ${url} accepted connection but failed to respond`, proto_1.types.NetworkErrorCode.RESPONSE_TIMEOUT_EXCEEDED, 504);
+            }
+        }
+        throw new NetworkError(`Network Error: ${error.message}`, proto_1.types.NetworkErrorCode.NETWORK_FAILURE, 500);
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+//# sourceMappingURL=http_client.js.map

package/dist/src/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./payments/_generated_connector_client_flows";
+export { UniffiClient } from "./payments/_generated_uniffi_client_flows";
+export type { RustBuffer, RustCallStatus } from "./payments/uniffi_client";
+export * from "./http_client";
+export * from './payments/generated/proto';
+export { types } from './payments/generated/proto';
+export { GrpcClient } from "./payments/grpc_client";
+export type { GrpcConfig, GrpcPaymentClient, GrpcCustomerClient, GrpcPaymentMethodClient, GrpcPaymentMethodAuthenticationClient, GrpcEventClient, GrpcMerchantAuthenticationClient, GrpcRecurringPaymentClient, } from "./payments/grpc_client";
+export { IntegrationError, ConnectorError } from './payments/connector_client';
+export * from './alphaweb/index';

package/dist/src/index.js

@@ -0,0 +1,41 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectorError = exports.IntegrationError = exports.GrpcClient = exports.types = exports.UniffiClient = void 0;
+// Re-export client classes flat (high-level API)
+__exportStar(require("./payments/_generated_connector_client_flows"), exports);
+var _generated_uniffi_client_flows_1 = require("./payments/_generated_uniffi_client_flows");
+Object.defineProperty(exports, "UniffiClient", { enumerable: true, get: function () { return _generated_uniffi_client_flows_1.UniffiClient; } });
+__exportStar(require("./http_client"), exports);
+__exportStar(require("./payments/generated/proto"), exports);
+// Re-export types namespace explicitly for both runtime and type access
+var proto_1 = require("./payments/generated/proto");
+Object.defineProperty(exports, "types", { enumerable: true, get: function () { return proto_1.types; } });
+// gRPC client (Rust-backed via hyperswitch_grpc_ffi native library)
+var grpc_client_1 = require("./payments/grpc_client");
+Object.defineProperty(exports, "GrpcClient", { enumerable: true, get: function () { return grpc_client_1.GrpcClient; } });
+// Export error classes
+var connector_client_1 = require("./payments/connector_client");
+Object.defineProperty(exports, "IntegrationError", { enumerable: true, get: function () { return connector_client_1.IntegrationError; } });
+Object.defineProperty(exports, "ConnectorError", { enumerable: true, get: function () { return connector_client_1.ConnectorError; } });
+__exportStar(require("./alphaweb/index"), exports);
+// ---------------------------------------------------------------------------
+// Domain namespaces — runtime values
+// Usage: import { payments, payment_methods, configs } from '@juspay/connector-service-sdk';
+//        const config: configs.IConnectorConfig = { ... };
+//        const client = new ConnectorClient(identity);
+// ---------------------------------------------------------------------------
+//# sourceMappingURL=index.js.map