hs-playlib 0.1.0

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

@@ -0,0 +1,34 @@
+/**
+ * UniFFI client for Node.js — calls the same shared library as Python/Kotlin.
+ *
+ * Uses koffi to call the UniFFI C ABI directly, replacing NAPI entirely.
+ * Handles RustBuffer serialization/deserialization for the UniFFI protocol.
+ *
+ * Flow dispatch is generic: callReq(flow, ...) and callRes(flow, ...) load
+ * the corresponding C symbol dynamically from the flow list in _generated_flows.js.
+ * No flow names are hardcoded here — add new flows to flows.yaml and run `make generate`.
+ */
+export interface RustBuffer {
+    capacity: bigint;
+    len: bigint;
+    data: Buffer | null;
+}
+export interface RustCallStatus {
+    code: number;
+    error_buf: RustBuffer;
+}
+export declare class UniffiClient {
+    private _ffi;
+    constructor(libPath?: string);
+    /**
+     * Build the connector HTTP request for any flow.
+     * Returns protobuf-encoded FfiConnectorHttpRequest bytes.
+     */
+    callReq(flow: string, requestBytes: Buffer | Uint8Array, metadata: Record<string, string>, optionsBytes: Buffer | Uint8Array): Buffer;
+    /**
+     * Parse the connector HTTP response for any flow.
+     * responseBytes: protobuf-encoded FfiConnectorHttpResponse.
+     * Returns protobuf-encoded response bytes for the flow's response type.
+     */
+    callRes(flow: string, responseBytes: Buffer | Uint8Array, requestBytes: Buffer | Uint8Array, metadata: Record<string, string>, optionsBytes: Buffer | Uint8Array): Buffer;
+}

package/dist/src/payments/uniffi_client.js

@@ -0,0 +1,213 @@
+"use strict";
+/**
+ * UniFFI client for Node.js — calls the same shared library as Python/Kotlin.
+ *
+ * Uses koffi to call the UniFFI C ABI directly, replacing NAPI entirely.
+ * Handles RustBuffer serialization/deserialization for the UniFFI protocol.
+ *
+ * Flow dispatch is generic: callReq(flow, ...) and callRes(flow, ...) load
+ * the corresponding C symbol dynamically from the flow list in _generated_flows.js.
+ * No flow names are hardcoded here — add new flows to flows.yaml and run `make generate`.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniffiClient = void 0;
+const koffi_1 = __importDefault(require("koffi"));
+const path_1 = __importDefault(require("path"));
+// @ts-ignore - generated CommonJS module
+const _generated_flows_js_1 = require("./_generated_flows.js");
+const _dirname = __dirname;
+const FLOW_NAMES = Object.keys(_generated_flows_js_1.FLOWS);
+const RustBufferStruct = koffi_1.default.struct("RustBuffer", {
+    capacity: "uint64",
+    len: "uint64",
+    data: "void *",
+});
+const RustCallStatusStruct = koffi_1.default.struct("RustCallStatus", {
+    code: "int8",
+    error_buf: RustBufferStruct,
+});
+function loadLib(libPath) {
+    if (!libPath) {
+        const ext = process.platform === "darwin" ? "dylib" : "so";
+        libPath = path_1.default.join(_dirname, "generated", `libconnector_service_ffi.${ext}`);
+    }
+    const lib = koffi_1.default.load(libPath);
+    const fns = {
+        alloc: lib.func("ffi_connector_service_ffi_rustbuffer_alloc", RustBufferStruct, ["uint64", koffi_1.default.out(koffi_1.default.pointer(RustCallStatusStruct))]),
+        free: lib.func("ffi_connector_service_ffi_rustbuffer_free", "void", [RustBufferStruct, koffi_1.default.out(koffi_1.default.pointer(RustCallStatusStruct))]),
+    };
+    // Load req and res transformer symbols for every registered flow.
+    for (const flow of FLOW_NAMES) {
+        fns[`${flow}_req`] = lib.func(`uniffi_connector_service_ffi_fn_func_${flow}_req_transformer`, RustBufferStruct, [RustBufferStruct, RustBufferStruct, RustBufferStruct, koffi_1.default.out(koffi_1.default.pointer(RustCallStatusStruct))]);
+        fns[`${flow}_res`] = lib.func(`uniffi_connector_service_ffi_fn_func_${flow}_res_transformer`, RustBufferStruct, [RustBufferStruct, RustBufferStruct, RustBufferStruct, RustBufferStruct, koffi_1.default.out(koffi_1.default.pointer(RustCallStatusStruct))]);
+    }
+    return fns;
+}
+// ── Helpers ──────────────────────────────────────────────────────
+function makeCallStatus() {
+    return { code: 0, error_buf: { capacity: 0n, len: 0n, data: null } };
+}
+function checkCallStatus(ffi, status) {
+    if (status.code === 0)
+        return;
+    if (status.code === 1) {
+        const errMsg = liftError(status.error_buf);
+        freeRustBuffer(ffi, status.error_buf);
+        throw new Error(errMsg);
+    }
+    if (status.error_buf.len > 0n) {
+        const msg = liftString(status.error_buf);
+        freeRustBuffer(ffi, status.error_buf);
+        throw new Error(`Rust panic: ${msg}`);
+    }
+    throw new Error("Unknown Rust panic");
+}
+function liftError(buf) {
+    if (!buf.data || buf.len === 0n)
+        return "Unknown error";
+    const raw = Buffer.from(koffi_1.default.decode(buf.data, "uint8", Number(buf.len)));
+    let offset = 0;
+    // UniFFI Error layout: [i32 variant] + [i32 len] + [bytes]
+    const variant = raw.readInt32BE(offset);
+    offset += 4;
+    const variantNames = {
+        1: "DecodeError",
+        2: "MissingMetadata",
+        3: "MetadataParseError",
+        4: "HandlerError",
+        5: "NoConnectorRequest",
+    };
+    if (variant === 5)
+        return "NoConnectorRequest";
+    const strLen = raw.readInt32BE(offset);
+    offset += 4;
+    const msg = raw.subarray(offset, offset + strLen).toString("utf-8");
+    return `${variantNames[variant] || "UniffiError"}: ${msg}`;
+}
+/**
+ * UniFFI Strings are serialized as raw UTF8 bytes when top-level in RustBuffer.
+ */
+function liftString(buf) {
+    if (!buf.data || buf.len === 0n)
+        return "";
+    const raw = Buffer.from(koffi_1.default.decode(buf.data, "uint8", Number(buf.len)));
+    return raw.toString("utf-8");
+}
+/**
+ * UniFFI Vec<u8> (Bytes) as return values are serialized as [i32 length] + [raw bytes]
+ */
+function liftBytes(buf) {
+    if (!buf.data || buf.len === 0n)
+        return Buffer.alloc(0);
+    const raw = Buffer.from(koffi_1.default.decode(buf.data, "uint8", Number(buf.len)));
+    // UniFFI protocol for return values: first 4 bytes are the length of the actual payload
+    const len = raw.readInt32BE(0);
+    return raw.subarray(4, 4 + len);
+}
+function freeRustBuffer(ffi, buf) {
+    if (buf.data && buf.len > 0n) {
+        ffi.free(buf, makeCallStatus());
+    }
+}
+function allocRustBuffer(ffi, data) {
+    const status = makeCallStatus();
+    const buf = ffi.alloc(BigInt(data.length), status);
+    checkCallStatus(ffi, status);
+    koffi_1.default.encode(buf.data, "uint8", Array.from(data), data.length);
+    buf.len = BigInt(data.length);
+    return buf;
+}
+/**
+ * Lowers raw bytes into a UniFFI-compliant buffer for top-level arguments.
+ * Protocol: [i32 length prefix] + [raw bytes]
+ */
+function lowerBytes(ffi, data) {
+    const buf = Buffer.alloc(4 + data.length);
+    buf.writeInt32BE(data.length, 0);
+    Buffer.from(data).copy(buf, 4);
+    return allocRustBuffer(ffi, buf);
+}
+/**
+ * Lowers a Map into a UniFFI-compliant serialized buffer.
+ * Protocol: [i32 count] + [ [i32 key_len]+[key_bytes] + [i32 val_len]+[val_bytes] ] * count
+ */
+function lowerMap(ffi, map) {
+    const entries = Object.entries(map);
+    let totalSize = 4; // count
+    const encoded = entries.map(([k, v]) => {
+        const kBuf = Buffer.from(k, "utf-8");
+        const vBuf = Buffer.from(v, "utf-8");
+        totalSize += 4 + kBuf.length + 4 + vBuf.length;
+        return { kBuf, vBuf };
+    });
+    const buf = Buffer.alloc(totalSize);
+    let offset = 0;
+    buf.writeInt32BE(entries.length, offset);
+    offset += 4;
+    for (const { kBuf, vBuf } of encoded) {
+        buf.writeInt32BE(kBuf.length, offset);
+        offset += 4;
+        kBuf.copy(buf, offset);
+        offset += kBuf.length;
+        buf.writeInt32BE(vBuf.length, offset);
+        offset += 4;
+        vBuf.copy(buf, offset);
+        offset += vBuf.length;
+    }
+    return allocRustBuffer(ffi, buf);
+}
+class UniffiClient {
+    _ffi;
+    constructor(libPath) {
+        this._ffi = loadLib(libPath);
+    }
+    /**
+     * Build the connector HTTP request for any flow.
+     * Returns protobuf-encoded FfiConnectorHttpRequest bytes.
+     */
+    callReq(flow, requestBytes, metadata, optionsBytes) {
+        const fn = this._ffi[`${flow}_req`];
+        if (!fn)
+            throw new Error(`Unknown flow: '${flow}'. Supported: ${FLOW_NAMES.join(", ")}`);
+        const rbReq = lowerBytes(this._ffi, requestBytes);
+        const rbMeta = lowerMap(this._ffi, metadata);
+        const rbOpts = lowerBytes(this._ffi, optionsBytes);
+        const status = makeCallStatus();
+        const result = fn(rbReq, rbMeta, rbOpts, status);
+        try {
+            checkCallStatus(this._ffi, status);
+            return liftBytes(result);
+        }
+        finally {
+            freeRustBuffer(this._ffi, result);
+        }
+    }
+    /**
+     * Parse the connector HTTP response for any flow.
+     * responseBytes: protobuf-encoded FfiConnectorHttpResponse.
+     * Returns protobuf-encoded response bytes for the flow's response type.
+     */
+    callRes(flow, responseBytes, requestBytes, metadata, optionsBytes) {
+        const fn = this._ffi[`${flow}_res`];
+        if (!fn)
+            throw new Error(`Unknown flow: '${flow}'. Supported: ${FLOW_NAMES.join(", ")}`);
+        const rbRes = lowerBytes(this._ffi, responseBytes);
+        const rbReq = lowerBytes(this._ffi, requestBytes);
+        const rbMeta = lowerMap(this._ffi, metadata);
+        const rbOpts = lowerBytes(this._ffi, optionsBytes);
+        const status = makeCallStatus();
+        const result = fn(rbRes, rbReq, rbMeta, rbOpts, status);
+        try {
+            checkCallStatus(this._ffi, status);
+            return liftBytes(result);
+        }
+        finally {
+            freeRustBuffer(this._ffi, result);
+        }
+    }
+}
+exports.UniffiClient = UniffiClient;
+//# sourceMappingURL=uniffi_client.js.map

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "hs-playlib",
+  "version": "0.1.0",
+  "description": "Hyperswitch Payments SDK — Node.js client for connector integrations via UniFFI FFI",
+  "author": "Juspay <hyperswitch@juspay.in>",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/juspay/connector-service.git",
+    "directory": "sdk/javascript"
+  },
+  "keywords": ["payments", "hyperswitch", "juspay", "ffi"],
+  "bugs": {
+    "url": "https://github.com/juspay/connector-service/issues"
+  },
+  "homepage": "https://github.com/juspay/connector-service#readme",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "files": [
+    "dist/src/**/*.js",
+    "dist/src/**/*.d.ts",
+    "dist/src/payments/generated/*"
+  ],
+  "scripts": {
+    "build": "tsc && cp -r src/payments/generated dist/src/payments/ && cp src/payments/_generated_flows.js dist/src/payments/",
+    "start": "node dist/src/index.js",
+    "test": "node test_smoke.js"
+  },
+  "dependencies": {
+    "koffi": "^2.15.1",
+    "protobufjs": "^7.4.0",
+    "undici": "^6.23.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.3",
+    "protobufjs-cli": "^1.1.3",
+    "ts-node": "^10.9.2",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.9.3"
+  }
+}