async-xenapi 1.0.0

package/README.md

@@ -0,0 +1,48 @@
+# async-xenapi (JavaScript / TypeScript)
+
+An async TypeScript library for [XenAPI](https://xapi-project.github.io/xen-api)
+
+## Install
+
+```
+npm install async-xenapi
+```
+
+Requires **Node.js 18+** (uses the global `fetch` API).
+
+## Usage
+
+```typescript
+import { AsyncXenAPISession } from "async-xenapi";
+
+async function main() {
+  const session = new AsyncXenAPISession(process.env.HOST_URL);
+  try {
+    await session.login_with_password(process.env.USERNAME, process.env.PASSWORD);
+    const hosts = await session.xenapi.host.get_all();
+    console.log(hosts);
+  } finally {
+    await session.xenapi.session.logout();
+  }
+}
+
+main();
+```
+
+The API mirrors the synchronous Python XenAPI SDK — any dotted method path under `session.xenapi` is translated directly to the corresponding JSON-RPC call. See the [XenAPI Reference](https://xapi-project.github.io/xen-api) for all available classes and fields.
+
+## Run tests
+
+```
+git clone git@github.com:acefei/async-xenapi.git
+cd async-xenapi/javascript
+npm install
+echo "HOST_URL=https://<xen-host>" >> .env
+echo "USERNAME=root"              >> .env
+echo "PASSWORD=<password>"        >> .env
+npm test tests/getXapiVersion.test.ts
+```
+
+## License
+
+GPL-2.0-only

package/dist/XenAPI.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Async XenAPI session via JSON-RPC (built-in fetch + crypto only, Node 18+)
+ *
+ * Usage mirrors the Python AsyncXenAPISession:
+ *
+ *   const session = new AsyncXenAPISession("https://host-ip");
+ *   await session.login_with_password("root", "password");
+ *
+ *   const vms = await session.xenapi.VM.get_all();
+ *   for (const vm of vms) {
+ *     const record = await session.xenapi.VM.get_record(vm);
+ *     console.log(record.name_label);
+ *   }
+ *
+ *   await session.logout();
+ */
+/**
+ * Recursive type describing the xenapi namespace proxy.
+ * Every property access returns another XenApiProxy;
+ * invoking it dispatches an authenticated JSON-RPC call.
+ */
+export type XenApiProxy = ((...args: unknown[]) => Promise<unknown>) & {
+    readonly [key: string]: XenApiProxy;
+};
+export declare class AsyncXenAPISession {
+    private readonly _url;
+    private _sessionRef;
+    readonly xenapi: XenApiProxy;
+    constructor(url: string | undefined);
+    login_with_password(user: string, password: string): Promise<string>;
+    logout(): Promise<void>;
+    _call(method: string, params?: unknown[]): Promise<unknown>;
+}
+/** Convenience factory — equivalent to `new AsyncXenAPISession(url)` */
+export declare function xapi_client(url: string | undefined): AsyncXenAPISession;

package/dist/XenAPI.js

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * Async XenAPI session via JSON-RPC (built-in fetch + crypto only, Node 18+)
+ *
+ * Usage mirrors the Python AsyncXenAPISession:
+ *
+ *   const session = new AsyncXenAPISession("https://host-ip");
+ *   await session.login_with_password("root", "password");
+ *
+ *   const vms = await session.xenapi.VM.get_all();
+ *   for (const vm of vms) {
+ *     const record = await session.xenapi.VM.get_record(vm);
+ *     console.log(record.name_label);
+ *   }
+ *
+ *   await session.logout();
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncXenAPISession = void 0;
+exports.xapi_client = xapi_client;
+function _jsonrpcReq(method, params) {
+    return { jsonrpc: "2.0", method, params, id: crypto.randomUUID() };
+}
+function _post(url, payload) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield fetch(url, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        return response.json();
+    });
+}
+// Accumulates dotted property access (e.g. xenapi.VM.get_all) and dispatches
+// the final call as an authenticated JSON-RPC request.
+function _xenApiNamespace(session, path = []) {
+    return new Proxy(() => { }, {
+        get(_target, property) {
+            return _xenApiNamespace(session, path.concat(property));
+        },
+        apply(_target, _self, args) {
+            return session._call(path.join("."), args);
+        },
+    });
+}
+class AsyncXenAPISession {
+    constructor(url) {
+        this._url = `${url}/jsonrpc`;
+        this.xenapi = _xenApiNamespace(this);
+    }
+    login_with_password(user, password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ret = yield _post(this._url, _jsonrpcReq("session.login_with_password", [user, password, "version", "originator"]));
+            if (ret.error)
+                throw new Error(`Login failed: ${JSON.stringify(ret.error)}`);
+            this._sessionRef = ret.result;
+            return this._sessionRef;
+        });
+    }
+    logout() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._sessionRef) {
+                const ret = yield _post(this._url, _jsonrpcReq("session.logout", [this._sessionRef]));
+                if (ret.error)
+                    throw new Error(`Logout failed: ${JSON.stringify(ret.error)}`);
+                this._sessionRef = undefined;
+            }
+        });
+    }
+    _call(method_1) {
+        return __awaiter(this, arguments, void 0, function* (method, params = []) {
+            if (!this._sessionRef)
+                throw new Error("Not logged in");
+            const ret = yield _post(this._url, _jsonrpcReq(method, [this._sessionRef, ...params]));
+            if (ret.error)
+                throw new Error(`XAPI ${method} failed: ${JSON.stringify(ret.error)}`);
+            return ret.result;
+        });
+    }
+}
+exports.AsyncXenAPISession = AsyncXenAPISession;
+/** Convenience factory — equivalent to `new AsyncXenAPISession(url)` */
+function xapi_client(url) {
+    return new AsyncXenAPISession(url);
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "async-xenapi",
+  "version": "1.0.0",
+  "description": "An async TypeScript library for Xen API",
+  "main": "dist/XenAPI.js",
+  "types": "dist/XenAPI.d.ts",
+  "files": ["/dist"],
+  "scripts": {
+    "test": "node -r ts-node/register -r dotenv/config ",
+    "build": "tsc",
+    "lint": "biome check src/ tests/",
+    "fmt": "biome check --write src/ tests/",
+    "lint:ci": "biome check --diagnostic-level=error src/ tests/"
+  },
+  "keywords": ["xenserver", "xen-api", "typescript", "async"],
+  "author": "Su Fei <fei.su@cloud.com>",
+  "license": "GPL-2.0-only",
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.0",
+    "@types/node": "^20.8.9",
+    "axios": "^1.6.0",
+    "dotenv": "^16.3.1",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.2.2"
+  },
+  "dependencies": {}
+}