@archildata/client 0.8.1 → 0.8.2

package/dist/api/index.js

@@ -0,0 +1,312 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/api/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Archil: () => Archil,
+  ArchilApiError: () => ArchilApiError,
+  Disk: () => Disk,
+  Disks: () => Disks,
+  Tokens: () => Tokens
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/api/client.ts
+var import_openapi_fetch = __toESM(require("openapi-fetch"));
+
+// src/api/errors.ts
+var ArchilApiError = class extends Error {
+  status;
+  code;
+  constructor(message, status, code) {
+    super(message);
+    this.name = "ArchilApiError";
+    this.status = status;
+    this.code = code;
+  }
+};
+
+// src/api/regions.ts
+var REGION_URLS = {
+  "aws-us-east-1": "https://control.green.us-east-1.aws.prod.archil.com",
+  "aws-eu-west-1": "https://control.green.eu-west-1.aws.prod.archil.com",
+  "aws-us-west-2": "https://control.green.us-west-2.aws.prod.archil.com",
+  "gcp-us-central1": "https://control.blue.us-central1.gcp.prod.archil.com"
+};
+function resolveBaseUrl(region) {
+  const url = REGION_URLS[region];
+  if (!url) {
+    throw new Error(
+      `Unknown region "${region}". Valid regions: ${Object.keys(REGION_URLS).join(", ")}`
+    );
+  }
+  return url;
+}
+
+// src/api/client.ts
+function createApiClient(opts) {
+  const baseUrl = opts.baseUrl ?? resolveBaseUrl(opts.region);
+  return (0, import_openapi_fetch.default)({
+    baseUrl,
+    headers: {
+      Authorization: `key-${opts.apiKey}`
+    }
+  });
+}
+async function unwrap(promise) {
+  const { data: body, error, response } = await promise;
+  if (error || !body) {
+    const errBody = error;
+    throw new ArchilApiError(
+      errBody?.error ?? `API request failed with status ${response.status}`,
+      response.status
+    );
+  }
+  if (!body.success) {
+    throw new ArchilApiError(
+      body.error ?? "Unknown API error",
+      response.status
+    );
+  }
+  return body.data;
+}
+async function unwrapEmpty(promise) {
+  const { data: body, error, response } = await promise;
+  if (error || !body) {
+    const errBody = error;
+    throw new ArchilApiError(
+      errBody?.error ?? `API request failed with status ${response.status}`,
+      response.status
+    );
+  }
+  if (!body.success) {
+    throw new ArchilApiError(
+      body.error ?? "Unknown API error",
+      response.status
+    );
+  }
+}
+
+// src/api/disk.ts
+var import_node_module = require("module");
+var import_node_url = require("url");
+var import_meta = {};
+var Disk = class {
+  id;
+  name;
+  organization;
+  status;
+  provider;
+  region;
+  createdAt;
+  fsHandlerStatus;
+  lastAccessed;
+  dataSize;
+  monthlyUsage;
+  mounts;
+  metrics;
+  connectedClients;
+  authorizedUsers;
+  /** @internal */
+  _client;
+  /** @internal */
+  _archilRegion;
+  /** @internal */
+  constructor(data, client, archilRegion) {
+    this.id = data.id;
+    this.name = data.name;
+    this.organization = data.organization;
+    this.status = data.status;
+    this.provider = data.provider;
+    this.region = data.region;
+    this.createdAt = data.createdAt;
+    this.fsHandlerStatus = data.fsHandlerStatus;
+    this.lastAccessed = data.lastAccessed;
+    this.dataSize = data.dataSize;
+    this.monthlyUsage = data.monthlyUsage;
+    this.mounts = data.mounts;
+    this.metrics = data.metrics;
+    this.connectedClients = data.connectedClients;
+    this.authorizedUsers = data.authorizedUsers;
+    this._client = client;
+    this._archilRegion = archilRegion;
+  }
+  async addUser(user) {
+    return unwrap(
+      this._client.POST("/api/disks/{id}/users", {
+        params: { path: { id: this.id } },
+        body: user
+      })
+    );
+  }
+  async removeUser(userType, principal) {
+    await unwrapEmpty(
+      this._client.DELETE("/api/disks/{id}/users/{userType}", {
+        params: {
+          path: { id: this.id, userType },
+          query: { principal }
+        }
+      })
+    );
+  }
+  async delete() {
+    await unwrapEmpty(
+      this._client.DELETE("/api/disks/{id}", {
+        params: { path: { id: this.id } }
+      })
+    );
+  }
+  /**
+   * Connect to this disk's data plane via the native ArchilClient.
+   *
+   * Requires the native module to be available (platform-specific .node binary).
+   */
+  async mount(opts) {
+    let ArchilClient;
+    try {
+      const base = typeof import_meta !== "undefined" && import_meta.url ? import_meta.url : (0, import_node_url.pathToFileURL)(__filename).href;
+      const nativeRequire = (0, import_node_module.createRequire)(base);
+      const native = nativeRequire("@archildata/client/native");
+      ArchilClient = native.ArchilClient;
+    } catch {
+      throw new Error(
+        "Native module not available. Install the platform-specific binary for @archildata/client or use ArchilClient.connect() directly."
+      );
+    }
+    return ArchilClient.connect({
+      region: this._archilRegion,
+      diskName: `${this.organization}/${this.name}`,
+      authToken: opts?.authToken,
+      logLevel: opts?.logLevel,
+      serverAddress: opts?.serverAddress,
+      insecure: opts?.insecure
+    });
+  }
+};
+
+// src/api/disks.ts
+var Disks = class {
+  /** @internal */
+  _client;
+  /** @internal */
+  _region;
+  /** @internal */
+  constructor(client, region) {
+    this._client = client;
+    this._region = region;
+  }
+  async list(opts) {
+    const data = await unwrap(
+      this._client.GET("/api/disks", {
+        params: { query: { limit: opts?.limit, cursor: opts?.cursor } }
+      })
+    );
+    return data.map(
+      (d) => new Disk(d, this._client, this._region)
+    );
+  }
+  async get(id) {
+    const data = await unwrap(
+      this._client.GET("/api/disks/{id}", {
+        params: { path: { id } }
+      })
+    );
+    return new Disk(data, this._client, this._region);
+  }
+  /**
+   * Create a new disk and return a Disk object with full details.
+   *
+   * Internally calls POST /api/disks (returns diskId) then GET /api/disks/{id}.
+   */
+  async create(req) {
+    const created = await unwrap(
+      this._client.POST("/api/disks", { body: req })
+    );
+    const diskId = created.diskId;
+    if (!diskId) {
+      throw new Error("API returned success but no diskId");
+    }
+    return this.get(diskId);
+  }
+};
+
+// src/api/tokens.ts
+var Tokens = class {
+  /** @internal */
+  _client;
+  /** @internal */
+  constructor(client) {
+    this._client = client;
+  }
+  async list(opts) {
+    const data = await unwrap(
+      this._client.GET("/api/tokens", {
+        params: { query: { limit: opts?.limit, cursor: opts?.cursor } }
+      })
+    );
+    return data.tokens ?? [];
+  }
+  async create(req) {
+    const data = await unwrap(
+      this._client.POST("/api/tokens", { body: req })
+    );
+    return data;
+  }
+  async delete(id) {
+    await unwrapEmpty(
+      this._client.DELETE("/api/tokens/{id}", {
+        params: { path: { id } }
+      })
+    );
+  }
+};
+
+// src/api/archil.ts
+var Archil = class {
+  disks;
+  tokens;
+  constructor(opts) {
+    const client = createApiClient({
+      apiKey: opts.apiKey,
+      region: opts.region,
+      baseUrl: opts.baseUrl
+    });
+    this.disks = new Disks(client, opts.region);
+    this.tokens = new Tokens(client);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Archil,
+  ArchilApiError,
+  Disk,
+  Disks,
+  Tokens
+});

package/dist/api/index.mjs

@@ -0,0 +1,270 @@
+// src/api/client.ts
+import createClient from "openapi-fetch";
+
+// src/api/errors.ts
+var ArchilApiError = class extends Error {
+  status;
+  code;
+  constructor(message, status, code) {
+    super(message);
+    this.name = "ArchilApiError";
+    this.status = status;
+    this.code = code;
+  }
+};
+
+// src/api/regions.ts
+var REGION_URLS = {
+  "aws-us-east-1": "https://control.green.us-east-1.aws.prod.archil.com",
+  "aws-eu-west-1": "https://control.green.eu-west-1.aws.prod.archil.com",
+  "aws-us-west-2": "https://control.green.us-west-2.aws.prod.archil.com",
+  "gcp-us-central1": "https://control.blue.us-central1.gcp.prod.archil.com"
+};
+function resolveBaseUrl(region) {
+  const url = REGION_URLS[region];
+  if (!url) {
+    throw new Error(
+      `Unknown region "${region}". Valid regions: ${Object.keys(REGION_URLS).join(", ")}`
+    );
+  }
+  return url;
+}
+
+// src/api/client.ts
+function createApiClient(opts) {
+  const baseUrl = opts.baseUrl ?? resolveBaseUrl(opts.region);
+  return createClient({
+    baseUrl,
+    headers: {
+      Authorization: `key-${opts.apiKey}`
+    }
+  });
+}
+async function unwrap(promise) {
+  const { data: body, error, response } = await promise;
+  if (error || !body) {
+    const errBody = error;
+    throw new ArchilApiError(
+      errBody?.error ?? `API request failed with status ${response.status}`,
+      response.status
+    );
+  }
+  if (!body.success) {
+    throw new ArchilApiError(
+      body.error ?? "Unknown API error",
+      response.status
+    );
+  }
+  return body.data;
+}
+async function unwrapEmpty(promise) {
+  const { data: body, error, response } = await promise;
+  if (error || !body) {
+    const errBody = error;
+    throw new ArchilApiError(
+      errBody?.error ?? `API request failed with status ${response.status}`,
+      response.status
+    );
+  }
+  if (!body.success) {
+    throw new ArchilApiError(
+      body.error ?? "Unknown API error",
+      response.status
+    );
+  }
+}
+
+// src/api/disk.ts
+import { createRequire } from "module";
+import { pathToFileURL } from "url";
+var Disk = class {
+  id;
+  name;
+  organization;
+  status;
+  provider;
+  region;
+  createdAt;
+  fsHandlerStatus;
+  lastAccessed;
+  dataSize;
+  monthlyUsage;
+  mounts;
+  metrics;
+  connectedClients;
+  authorizedUsers;
+  /** @internal */
+  _client;
+  /** @internal */
+  _archilRegion;
+  /** @internal */
+  constructor(data, client, archilRegion) {
+    this.id = data.id;
+    this.name = data.name;
+    this.organization = data.organization;
+    this.status = data.status;
+    this.provider = data.provider;
+    this.region = data.region;
+    this.createdAt = data.createdAt;
+    this.fsHandlerStatus = data.fsHandlerStatus;
+    this.lastAccessed = data.lastAccessed;
+    this.dataSize = data.dataSize;
+    this.monthlyUsage = data.monthlyUsage;
+    this.mounts = data.mounts;
+    this.metrics = data.metrics;
+    this.connectedClients = data.connectedClients;
+    this.authorizedUsers = data.authorizedUsers;
+    this._client = client;
+    this._archilRegion = archilRegion;
+  }
+  async addUser(user) {
+    return unwrap(
+      this._client.POST("/api/disks/{id}/users", {
+        params: { path: { id: this.id } },
+        body: user
+      })
+    );
+  }
+  async removeUser(userType, principal) {
+    await unwrapEmpty(
+      this._client.DELETE("/api/disks/{id}/users/{userType}", {
+        params: {
+          path: { id: this.id, userType },
+          query: { principal }
+        }
+      })
+    );
+  }
+  async delete() {
+    await unwrapEmpty(
+      this._client.DELETE("/api/disks/{id}", {
+        params: { path: { id: this.id } }
+      })
+    );
+  }
+  /**
+   * Connect to this disk's data plane via the native ArchilClient.
+   *
+   * Requires the native module to be available (platform-specific .node binary).
+   */
+  async mount(opts) {
+    let ArchilClient;
+    try {
+      const base = typeof import.meta !== "undefined" && import.meta.url ? import.meta.url : pathToFileURL(__filename).href;
+      const nativeRequire = createRequire(base);
+      const native = nativeRequire("@archildata/client/native");
+      ArchilClient = native.ArchilClient;
+    } catch {
+      throw new Error(
+        "Native module not available. Install the platform-specific binary for @archildata/client or use ArchilClient.connect() directly."
+      );
+    }
+    return ArchilClient.connect({
+      region: this._archilRegion,
+      diskName: `${this.organization}/${this.name}`,
+      authToken: opts?.authToken,
+      logLevel: opts?.logLevel,
+      serverAddress: opts?.serverAddress,
+      insecure: opts?.insecure
+    });
+  }
+};
+
+// src/api/disks.ts
+var Disks = class {
+  /** @internal */
+  _client;
+  /** @internal */
+  _region;
+  /** @internal */
+  constructor(client, region) {
+    this._client = client;
+    this._region = region;
+  }
+  async list(opts) {
+    const data = await unwrap(
+      this._client.GET("/api/disks", {
+        params: { query: { limit: opts?.limit, cursor: opts?.cursor } }
+      })
+    );
+    return data.map(
+      (d) => new Disk(d, this._client, this._region)
+    );
+  }
+  async get(id) {
+    const data = await unwrap(
+      this._client.GET("/api/disks/{id}", {
+        params: { path: { id } }
+      })
+    );
+    return new Disk(data, this._client, this._region);
+  }
+  /**
+   * Create a new disk and return a Disk object with full details.
+   *
+   * Internally calls POST /api/disks (returns diskId) then GET /api/disks/{id}.
+   */
+  async create(req) {
+    const created = await unwrap(
+      this._client.POST("/api/disks", { body: req })
+    );
+    const diskId = created.diskId;
+    if (!diskId) {
+      throw new Error("API returned success but no diskId");
+    }
+    return this.get(diskId);
+  }
+};
+
+// src/api/tokens.ts
+var Tokens = class {
+  /** @internal */
+  _client;
+  /** @internal */
+  constructor(client) {
+    this._client = client;
+  }
+  async list(opts) {
+    const data = await unwrap(
+      this._client.GET("/api/tokens", {
+        params: { query: { limit: opts?.limit, cursor: opts?.cursor } }
+      })
+    );
+    return data.tokens ?? [];
+  }
+  async create(req) {
+    const data = await unwrap(
+      this._client.POST("/api/tokens", { body: req })
+    );
+    return data;
+  }
+  async delete(id) {
+    await unwrapEmpty(
+      this._client.DELETE("/api/tokens/{id}", {
+        params: { path: { id } }
+      })
+    );
+  }
+};
+
+// src/api/archil.ts
+var Archil = class {
+  disks;
+  tokens;
+  constructor(opts) {
+    const client = createApiClient({
+      apiKey: opts.apiKey,
+      region: opts.region,
+      baseUrl: opts.baseUrl
+    });
+    this.disks = new Disks(client, opts.region);
+    this.tokens = new Tokens(client);
+  }
+};
+export {
+  Archil,
+  ArchilApiError,
+  Disk,
+  Disks,
+  Tokens
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archildata/client",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "description": "High-performance Node.js client for Archil distributed filesystem",
   "main": "main.js",
   "types": "main.d.ts",