hs-playlib 0.1.0

package/dist/src/payments/_generated_uniffi_client_flows.js

@@ -0,0 +1,58 @@
+"use strict";
+// AUTO-GENERATED — do not edit by hand.
+// Source: services.proto ∩ bindings/uniffi.rs  |  Regenerate: make generate
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniffiClient = void 0;
+const uniffi_client_1 = require("./uniffi_client");
+class UniffiClient extends uniffi_client_1.UniffiClient {
+    /** Build connector HTTP request for authorize flow. */
+    authorizeReq(requestBytes, metadata, optionsBytes) {
+        return this.callReq('authorize', requestBytes, metadata, optionsBytes);
+    }
+    /** Parse connector HTTP response for authorize flow. */
+    authorizeRes(responseBytes, requestBytes, metadata, optionsBytes) {
+        return this.callRes('authorize', responseBytes, requestBytes, metadata, optionsBytes);
+    }
+    /** Build connector HTTP request for capture flow. */
+    captureReq(requestBytes, metadata, optionsBytes) {
+        return this.callReq('capture', requestBytes, metadata, optionsBytes);
+    }
+    /** Parse connector HTTP response for capture flow. */
+    captureRes(responseBytes, requestBytes, metadata, optionsBytes) {
+        return this.callRes('capture', responseBytes, requestBytes, metadata, optionsBytes);
+    }
+    /** Build connector HTTP request for create_access_token flow. */
+    createAccessTokenReq(requestBytes, metadata, optionsBytes) {
+        return this.callReq('create_access_token', requestBytes, metadata, optionsBytes);
+    }
+    /** Parse connector HTTP response for create_access_token flow. */
+    createAccessTokenRes(responseBytes, requestBytes, metadata, optionsBytes) {
+        return this.callRes('create_access_token', responseBytes, requestBytes, metadata, optionsBytes);
+    }
+    /** Build connector HTTP request for get flow. */
+    getReq(requestBytes, metadata, optionsBytes) {
+        return this.callReq('get', requestBytes, metadata, optionsBytes);
+    }
+    /** Parse connector HTTP response for get flow. */
+    getRes(responseBytes, requestBytes, metadata, optionsBytes) {
+        return this.callRes('get', responseBytes, requestBytes, metadata, optionsBytes);
+    }
+    /** Build connector HTTP request for refund flow. */
+    refundReq(requestBytes, metadata, optionsBytes) {
+        return this.callReq('refund', requestBytes, metadata, optionsBytes);
+    }
+    /** Parse connector HTTP response for refund flow. */
+    refundRes(responseBytes, requestBytes, metadata, optionsBytes) {
+        return this.callRes('refund', responseBytes, requestBytes, metadata, optionsBytes);
+    }
+    /** Build connector HTTP request for void flow. */
+    voidReq(requestBytes, metadata, optionsBytes) {
+        return this.callReq('void', requestBytes, metadata, optionsBytes);
+    }
+    /** Parse connector HTTP response for void flow. */
+    voidRes(responseBytes, requestBytes, metadata, optionsBytes) {
+        return this.callRes('void', responseBytes, requestBytes, metadata, optionsBytes);
+    }
+}
+exports.UniffiClient = UniffiClient;
+//# sourceMappingURL=_generated_uniffi_client_flows.js.map

package/dist/src/payments/connector_client.d.ts

@@ -0,0 +1,41 @@
+/**
+ * ConnectorClient — high-level wrapper using UniFFI bindings via koffi.
+ *
+ * Handles the full round-trip for any payment flow:
+ *   1. Serialize protobuf request to bytes
+ *   2. Build connector HTTP request via UniffiClient.callReq (generic FFI dispatch)
+ *   3. Execute the HTTP request via our standardized HttpClient
+ *   4. Parse the connector response via UniffiClient.callRes (generic FFI dispatch)
+ *   5. Deserialize protobuf response from bytes
+ *
+ * Flow methods (authorize, capture, void, refund, …) are in _generated_connector_client_flows.ts.
+ * To add a new flow: implement it in the FFI crate and run `make generate`.
+ */
+import { ucs } from "./generated/proto";
+export declare class ConnectorClient {
+    private uniffi;
+    private options;
+    private dispatcher;
+    /**
+     * @param libPath - optional path to the UniFFI shared library
+     * @param options - unified SDK configuration from Protobuf (Options message)
+     */
+    constructor(libPath?: string, options?: ucs.v2.IOptions);
+    /**
+     * Internal helper to map Protobuf HttpOptions to Native HttpClient options.
+     */
+    private getNativeHttpOptions;
+    /**
+     * Execute a full round-trip for any registered payment flow.
+     *
+     * Looks up the request/response protobuf type names from FLOWS, encodes the
+     * request, calls callReq → HTTP → callRes via the generic FFI dispatcher,
+     * then decodes and returns the response.
+     *
+     * @param flow - Flow name matching the FFI transformer prefix (e.g. "authorize").
+     * @param requestMsg - Protobuf request message object.
+     * @param metadata - Dict with connector routing and auth info.
+     * @param ffiOptions - Optional IFfiOptions override.
+     */
+    _executeFlow(flow: string, requestMsg: object, metadata: Record<string, string>, ffiOptions?: ucs.v2.IFfiOptions | null, reqTypeName?: string, resTypeName?: string): Promise<unknown>;
+}

package/dist/src/payments/connector_client.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * ConnectorClient — high-level wrapper using UniFFI bindings via koffi.
+ *
+ * Handles the full round-trip for any payment flow:
+ *   1. Serialize protobuf request to bytes
+ *   2. Build connector HTTP request via UniffiClient.callReq (generic FFI dispatch)
+ *   3. Execute the HTTP request via our standardized HttpClient
+ *   4. Parse the connector response via UniffiClient.callRes (generic FFI dispatch)
+ *   5. Deserialize protobuf response from bytes
+ *
+ * Flow methods (authorize, capture, void, refund, …) are in _generated_connector_client_flows.ts.
+ * To add a new flow: implement it in the FFI crate and run `make generate`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectorClient = void 0;
+const uniffi_client_1 = require("./uniffi_client");
+const http_client_1 = require("../http_client");
+// @ts-ignore - protobuf generated files might not have types yet
+const proto_1 = require("./generated/proto");
+const v2 = proto_1.ucs.v2;
+class ConnectorClient {
+    uniffi;
+    options;
+    dispatcher;
+    /**
+     * @param libPath - optional path to the UniFFI shared library
+     * @param options - unified SDK configuration from Protobuf (Options message)
+     */
+    constructor(libPath, options = {}) {
+        this.uniffi = new uniffi_client_1.UniffiClient(libPath);
+        this.options = options;
+        // Instance-level cache: create the primary connection pool at startup
+        this.dispatcher = (0, http_client_1.createDispatcher)(this.getNativeHttpOptions(options.http));
+    }
+    /**
+     * Internal helper to map Protobuf HttpOptions to Native HttpClient options.
+     */
+    getNativeHttpOptions(proto) {
+        if (!proto)
+            return {};
+        return {
+            totalTimeoutMs: proto.totalTimeoutMs ?? undefined,
+            connectTimeoutMs: proto.connectTimeoutMs ?? undefined,
+            responseTimeoutMs: proto.responseTimeoutMs ?? undefined,
+            keepAliveTimeoutMs: proto.keepAliveTimeoutMs ?? undefined,
+            proxy: proto.proxy ? {
+                httpUrl: proto.proxy.httpUrl ?? undefined,
+                httpsUrl: proto.proxy.httpsUrl ?? undefined,
+                bypassUrls: proto.proxy.bypassUrls ?? undefined,
+            } : undefined,
+            caCert: proto.caCert ?? undefined,
+        };
+    }
+    /**
+     * Execute a full round-trip for any registered payment flow.
+     *
+     * Looks up the request/response protobuf type names from FLOWS, encodes the
+     * request, calls callReq → HTTP → callRes via the generic FFI dispatcher,
+     * then decodes and returns the response.
+     *
+     * @param flow - Flow name matching the FFI transformer prefix (e.g. "authorize").
+     * @param requestMsg - Protobuf request message object.
+     * @param metadata - Dict with connector routing and auth info.
+     * @param ffiOptions - Optional IFfiOptions override.
+     */
+    async _executeFlow(flow, requestMsg, metadata, ffiOptions, reqTypeName, resTypeName) {
+        const reqType = reqTypeName ? v2[reqTypeName] : undefined;
+        const resType = resTypeName ? v2[resTypeName] : undefined;
+        if (!reqType || !resType) {
+            throw new Error(`Unknown flow: '${flow}' or missing type names.`);
+        }
+        // 1. Serialize request
+        const requestBytes = Buffer.from(reqType.encode(requestMsg).finish());
+        // 2. Resolve FFI options (prefer call-specific)
+        const ffi = ffiOptions || this.options.ffi;
+        const optionsBytes = ffi ? Buffer.from(v2.FfiOptions.encode(ffi).finish()) : Buffer.alloc(0);
+        // 3. Build connector HTTP request via FFI (returns FfiConnectorHttpRequest protobuf bytes)
+        const resultBytes = this.uniffi.callReq(flow, requestBytes, metadata, optionsBytes);
+        const connectorReq = v2.FfiConnectorHttpRequest.decode(resultBytes);
+        const connectorRequest = {
+            url: connectorReq.url,
+            method: connectorReq.method,
+            headers: connectorReq.headers || {},
+            body: connectorReq.body ?? undefined
+        };
+        // 4. Execute HTTP using the instance-owned connection pool
+        const response = await (0, http_client_1.execute)(connectorRequest, this.getNativeHttpOptions(this.options.http), this.dispatcher);
+        // 5. Encode HTTP response as FfiConnectorHttpResponse protobuf bytes
+        const resProto = v2.FfiConnectorHttpResponse.create({
+            statusCode: response.statusCode,
+            headers: response.headers,
+            body: response.body
+        });
+        const resBytes = Buffer.from(v2.FfiConnectorHttpResponse.encode(resProto).finish());
+        // 6. Parse connector response via FFI and decode
+        const resultBytesRes = this.uniffi.callRes(flow, resBytes, requestBytes, metadata, optionsBytes);
+        return resType.decode(resultBytesRes);
+    }
+}
+exports.ConnectorClient = ConnectorClient;
+//# sourceMappingURL=connector_client.js.map