wolfronix-sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,505 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AuthenticationError: () => AuthenticationError,
+  FileNotFoundError: () => FileNotFoundError,
+  NetworkError: () => NetworkError,
+  PermissionDeniedError: () => PermissionDeniedError,
+  ValidationError: () => ValidationError,
+  Wolfronix: () => Wolfronix,
+  WolfronixError: () => WolfronixError,
+  createClient: () => createClient,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var WolfronixError = class extends Error {
+  constructor(message, code, statusCode, details) {
+    super(message);
+    this.name = "WolfronixError";
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+  }
+};
+var AuthenticationError = class extends WolfronixError {
+  constructor(message = "Authentication failed") {
+    super(message, "AUTH_ERROR", 401);
+    this.name = "AuthenticationError";
+  }
+};
+var FileNotFoundError = class extends WolfronixError {
+  constructor(fileId) {
+    super(`File not found: ${fileId}`, "FILE_NOT_FOUND", 404);
+    this.name = "FileNotFoundError";
+  }
+};
+var PermissionDeniedError = class extends WolfronixError {
+  constructor(message = "Permission denied") {
+    super(message, "PERMISSION_DENIED", 403);
+    this.name = "PermissionDeniedError";
+  }
+};
+var NetworkError = class extends WolfronixError {
+  constructor(message = "Network request failed") {
+    super(message, "NETWORK_ERROR");
+    this.name = "NetworkError";
+  }
+};
+var ValidationError = class extends WolfronixError {
+  constructor(message) {
+    super(message, "VALIDATION_ERROR", 400);
+    this.name = "ValidationError";
+  }
+};
+var Wolfronix = class {
+  /**
+   * Create a new Wolfronix client
+   * 
+   * @example
+   * ```typescript
+   * const wfx = new Wolfronix({
+   *   baseUrl: 'https://wolfronix-server:5002',
+   *   clientId: 'your-client-id'
+   * });
+   * ```
+   */
+  constructor(config) {
+    this.token = null;
+    this.userId = null;
+    this.tokenExpiry = null;
+    if (typeof config === "string") {
+      this.config = {
+        baseUrl: config,
+        clientId: "",
+        timeout: 3e4,
+        retries: 3,
+        insecure: false
+      };
+    } else {
+      this.config = {
+        baseUrl: config.baseUrl,
+        clientId: config.clientId || "",
+        timeout: config.timeout || 3e4,
+        retries: config.retries || 3,
+        insecure: config.insecure || false
+      };
+    }
+    this.config.baseUrl = this.config.baseUrl.replace(/\/$/, "");
+  }
+  // ==========================================================================
+  // Private Helpers
+  // ==========================================================================
+  getHeaders(includeAuth = true) {
+    const headers = {
+      "Accept": "application/json"
+    };
+    if (this.config.clientId) {
+      headers["X-Client-ID"] = this.config.clientId;
+    }
+    if (includeAuth && this.token) {
+      headers["Authorization"] = `Bearer ${this.token}`;
+    }
+    return headers;
+  }
+  async request(method, endpoint, options = {}) {
+    const { body, formData, includeAuth = true, responseType = "json" } = options;
+    const url = `${this.config.baseUrl}${endpoint}`;
+    const headers = this.getHeaders(includeAuth);
+    if (body && !formData) {
+      headers["Content-Type"] = "application/json";
+    }
+    let lastError = null;
+    for (let attempt = 1; attempt <= this.config.retries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+        const fetchOptions = {
+          method,
+          headers,
+          signal: controller.signal
+        };
+        if (formData) {
+          fetchOptions.body = formData;
+        } else if (body) {
+          fetchOptions.body = JSON.stringify(body);
+        }
+        const response = await fetch(url, fetchOptions);
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+          const errorBody = await response.json().catch(() => ({}));
+          if (response.status === 401) {
+            throw new AuthenticationError(errorBody.error || "Authentication failed");
+          }
+          if (response.status === 403) {
+            throw new PermissionDeniedError(errorBody.error || "Permission denied");
+          }
+          if (response.status === 404) {
+            throw new FileNotFoundError(endpoint);
+          }
+          throw new WolfronixError(
+            errorBody.error || `Request failed with status ${response.status}`,
+            "REQUEST_ERROR",
+            response.status,
+            errorBody
+          );
+        }
+        if (responseType === "blob") {
+          return await response.blob();
+        }
+        if (responseType === "arraybuffer") {
+          return await response.arrayBuffer();
+        }
+        return await response.json();
+      } catch (error) {
+        lastError = error;
+        if (error instanceof AuthenticationError || error instanceof PermissionDeniedError || error instanceof FileNotFoundError) {
+          throw error;
+        }
+        if (attempt < this.config.retries) {
+          await this.sleep(Math.pow(2, attempt) * 100);
+          continue;
+        }
+      }
+    }
+    throw lastError || new NetworkError("Request failed after retries");
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  ensureAuthenticated() {
+    if (!this.token) {
+      throw new AuthenticationError("Not authenticated. Call login() or register() first.");
+    }
+  }
+  // ==========================================================================
+  // Authentication Methods
+  // ==========================================================================
+  /**
+   * Register a new user
+   * 
+   * @example
+   * ```typescript
+   * const { user_id, token } = await wfx.register('user@example.com', 'password123');
+   * ```
+   */
+  async register(email, password) {
+    if (!email || !password) {
+      throw new ValidationError("Email and password are required");
+    }
+    const response = await this.request("POST", "/api/v1/register", {
+      body: { email, password },
+      includeAuth: false
+    });
+    if (response.success) {
+      this.token = response.token;
+      this.userId = response.user_id;
+      this.tokenExpiry = new Date(Date.now() + 24 * 60 * 60 * 1e3);
+    }
+    return response;
+  }
+  /**
+   * Login with existing credentials
+   * 
+   * @example
+   * ```typescript
+   * await wfx.login('user@example.com', 'password123');
+   * ```
+   */
+  async login(email, password) {
+    if (!email || !password) {
+      throw new ValidationError("Email and password are required");
+    }
+    const response = await this.request("POST", "/api/v1/login", {
+      body: { email, password },
+      includeAuth: false
+    });
+    if (response.success) {
+      this.token = response.token;
+      this.userId = response.user_id;
+      this.tokenExpiry = new Date(Date.now() + 24 * 60 * 60 * 1e3);
+    }
+    return response;
+  }
+  /**
+   * Set authentication token directly (useful for server-side apps)
+   * 
+   * @example
+   * ```typescript
+   * wfx.setToken('jwt-token-here', 'user-id-here');
+   * ```
+   */
+  setToken(token, userId) {
+    this.token = token;
+    this.userId = userId || null;
+    this.tokenExpiry = new Date(Date.now() + 24 * 60 * 60 * 1e3);
+  }
+  /**
+   * Clear authentication state (logout)
+   */
+  logout() {
+    this.token = null;
+    this.userId = null;
+    this.tokenExpiry = null;
+  }
+  /**
+   * Check if client is authenticated
+   */
+  isAuthenticated() {
+    return !!this.token && (!this.tokenExpiry || this.tokenExpiry > /* @__PURE__ */ new Date());
+  }
+  /**
+   * Get current user ID
+   */
+  getUserId() {
+    return this.userId;
+  }
+  // ==========================================================================
+  // File Operations
+  // ==========================================================================
+  /**
+   * Encrypt and store a file
+   * 
+   * @example
+   * ```typescript
+   * // Browser
+   * const fileInput = document.querySelector('input[type="file"]');
+   * const result = await wfx.encrypt(fileInput.files[0]);
+   * 
+   * // Node.js
+   * const buffer = fs.readFileSync('document.pdf');
+   * const result = await wfx.encrypt(buffer, 'document.pdf');
+   * ```
+   */
+  async encrypt(file, filename) {
+    this.ensureAuthenticated();
+    const formData = new FormData();
+    if (file instanceof File) {
+      formData.append("file", file);
+    } else if (file instanceof Blob) {
+      formData.append("file", file, filename || "file");
+    } else if (file instanceof ArrayBuffer) {
+      const blob = new Blob([new Uint8Array(file)]);
+      formData.append("file", blob, filename || "file");
+    } else if (file instanceof Uint8Array) {
+      const arrayBuffer = file.buffer.slice(file.byteOffset, file.byteOffset + file.byteLength);
+      const blob = new Blob([arrayBuffer]);
+      formData.append("file", blob, filename || "file");
+    } else {
+      throw new ValidationError("Invalid file type. Expected File, Blob, Buffer, or ArrayBuffer");
+    }
+    formData.append("user_id", this.userId || "");
+    return this.request("POST", "/api/v1/encrypt", {
+      formData
+    });
+  }
+  /**
+   * Encrypt a file using streaming (for large files)
+   * 
+   * @example
+   * ```typescript
+   * const result = await wfx.encryptStream(largeFile, (progress) => {
+   *   console.log(`Progress: ${progress}%`);
+   * });
+   * ```
+   */
+  async encryptStream(file, onProgress) {
+    this.ensureAuthenticated();
+    const tokenResponse = await this.request("POST", "/api/v1/stream/token", {
+      body: {
+        user_id: this.userId,
+        client_id: this.config.clientId
+      }
+    });
+    const formData = new FormData();
+    formData.append("file", file);
+    formData.append("user_id", this.userId || "");
+    formData.append("stream_token", tokenResponse.token);
+    if (onProgress && typeof XMLHttpRequest !== "undefined") {
+      return new Promise((resolve, reject) => {
+        const xhr = new XMLHttpRequest();
+        xhr.upload.onprogress = (event) => {
+          if (event.lengthComputable) {
+            onProgress(Math.round(event.loaded / event.total * 100));
+          }
+        };
+        xhr.onload = () => {
+          if (xhr.status >= 200 && xhr.status < 300) {
+            resolve(JSON.parse(xhr.responseText));
+          } else {
+            reject(new WolfronixError("Upload failed", "UPLOAD_ERROR", xhr.status));
+          }
+        };
+        xhr.onerror = () => reject(new NetworkError("Upload failed"));
+        xhr.open("POST", `${this.config.baseUrl}/api/v1/stream/encrypt`);
+        const headers = this.getHeaders();
+        Object.entries(headers).forEach(([key, value]) => {
+          xhr.setRequestHeader(key, value);
+        });
+        xhr.send(formData);
+      });
+    }
+    return this.request("POST", "/api/v1/stream/encrypt", {
+      formData
+    });
+  }
+  /**
+   * Decrypt and retrieve a file
+   * 
+   * @example
+   * ```typescript
+   * // Get as Blob (browser)
+   * const blob = await wfx.decrypt('file-id');
+   * const url = URL.createObjectURL(blob);
+   * 
+   * // Get as Buffer (Node.js)
+   * const buffer = await wfx.decryptToBuffer('file-id');
+   * fs.writeFileSync('decrypted.pdf', buffer);
+   * ```
+   */
+  async decrypt(fileId) {
+    this.ensureAuthenticated();
+    if (!fileId) {
+      throw new ValidationError("File ID is required");
+    }
+    return this.request("GET", `/api/v1/decrypt/${fileId}`, {
+      responseType: "blob"
+    });
+  }
+  /**
+   * Decrypt and return as ArrayBuffer
+   */
+  async decryptToBuffer(fileId) {
+    this.ensureAuthenticated();
+    if (!fileId) {
+      throw new ValidationError("File ID is required");
+    }
+    return this.request("GET", `/api/v1/decrypt/${fileId}`, {
+      responseType: "arraybuffer"
+    });
+  }
+  /**
+   * Decrypt using streaming (for large files)
+   */
+  async decryptStream(fileId, onProgress) {
+    this.ensureAuthenticated();
+    if (onProgress && typeof XMLHttpRequest !== "undefined") {
+      return new Promise((resolve, reject) => {
+        const xhr = new XMLHttpRequest();
+        xhr.responseType = "blob";
+        xhr.onprogress = (event) => {
+          if (event.lengthComputable) {
+            onProgress(Math.round(event.loaded / event.total * 100));
+          }
+        };
+        xhr.onload = () => {
+          if (xhr.status >= 200 && xhr.status < 300) {
+            resolve(xhr.response);
+          } else {
+            reject(new WolfronixError("Download failed", "DOWNLOAD_ERROR", xhr.status));
+          }
+        };
+        xhr.onerror = () => reject(new NetworkError("Download failed"));
+        xhr.open("GET", `${this.config.baseUrl}/api/v1/stream/decrypt/${fileId}`);
+        const headers = this.getHeaders();
+        Object.entries(headers).forEach(([key, value]) => {
+          xhr.setRequestHeader(key, value);
+        });
+        xhr.send();
+      });
+    }
+    return this.request("GET", `/api/v1/stream/decrypt/${fileId}`, {
+      responseType: "blob"
+    });
+  }
+  /**
+   * List all encrypted files for current user
+   * 
+   * @example
+   * ```typescript
+   * const { files } = await wfx.listFiles();
+   * files.forEach(f => console.log(f.original_name, f.file_id));
+   * ```
+   */
+  async listFiles() {
+    this.ensureAuthenticated();
+    return this.request("GET", "/api/v1/files");
+  }
+  /**
+   * Delete an encrypted file
+   * 
+   * @example
+   * ```typescript
+   * await wfx.deleteFile('file-id');
+   * ```
+   */
+  async deleteFile(fileId) {
+    this.ensureAuthenticated();
+    if (!fileId) {
+      throw new ValidationError("File ID is required");
+    }
+    return this.request("DELETE", `/api/v1/files/${fileId}`);
+  }
+  // ==========================================================================
+  // Metrics & Status
+  // ==========================================================================
+  /**
+   * Get encryption/decryption metrics
+   * 
+   * @example
+   * ```typescript
+   * const metrics = await wfx.getMetrics();
+   * console.log(`Total encryptions: ${metrics.total_encryptions}`);
+   * ```
+   */
+  async getMetrics() {
+    this.ensureAuthenticated();
+    return this.request("GET", "/api/v1/metrics");
+  }
+  /**
+   * Check if server is healthy
+   */
+  async healthCheck() {
+    try {
+      await this.request("GET", "/health", {
+        includeAuth: false
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+function createClient(config) {
+  return new Wolfronix(config);
+}
+var index_default = Wolfronix;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthenticationError,
+  FileNotFoundError,
+  NetworkError,
+  PermissionDeniedError,
+  ValidationError,
+  Wolfronix,
+  WolfronixError,
+  createClient
+});