@adbjs/sdk 0.1.1

package/dist/index.cjs

@@ -0,0 +1,687 @@
+'use strict';
+
+var wretch = require('wretch');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var wretch__default = /*#__PURE__*/_interopDefault(wretch);
+
+// src/client.ts
+
+// src/errors.ts
+var AllDebridError = class _AllDebridError extends Error {
+  code;
+  isAllDebridError = true;
+  constructor(code, message) {
+    super(message);
+    this.name = "AllDebridError";
+    this.code = code;
+    if ("captureStackTrace" in Error && typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(this, _AllDebridError);
+    }
+  }
+  /**
+   * Create an AllDebridError from an API error response
+   */
+  static fromApiError(error) {
+    return new _AllDebridError(error.code, error.message);
+  }
+};
+var AuthenticationError = class extends AllDebridError {
+  constructor(code, message) {
+    super(code, message);
+    this.name = "AuthenticationError";
+  }
+};
+var LinkError = class extends AllDebridError {
+  constructor(code, message) {
+    super(code, message);
+    this.name = "LinkError";
+  }
+};
+var MagnetError = class extends AllDebridError {
+  constructor(code, message) {
+    super(code, message);
+    this.name = "MagnetError";
+  }
+};
+var NetworkError = class extends AllDebridError {
+  constructor(message, statusCode) {
+    super("NETWORK_ERROR", message);
+    this.statusCode = statusCode;
+    this.name = "NetworkError";
+  }
+};
+function createTypedError(code, message) {
+  if (code.startsWith("AUTH_")) {
+    return new AuthenticationError(code, message);
+  }
+  if (code.startsWith("LINK_") || code.startsWith("REDIRECTOR_") || code.startsWith("STREAM_") || code.startsWith("DELAYED_")) {
+    return new LinkError(code, message);
+  }
+  if (code.startsWith("MAGNET_")) {
+    return new MagnetError(code, message);
+  }
+  return new AllDebridError(code, message);
+}
+
+// src/base-resource.ts
+var BaseResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Make a GET request
+   * @param T - The generated response type (e.g., GetLinkUnlockResponse)
+   * @returns The extracted data from the response (without the { status, data } wrapper)
+   */
+  async get(path, params) {
+    const clientAny = this.client;
+    return clientAny.get(path, params);
+  }
+  /**
+   * Make a POST request
+   * @param T - The generated response type
+   * @returns The extracted data from the response (without the { status, data } wrapper)
+   */
+  async post(path, body, params) {
+    const clientAny = this.client;
+    return clientAny.post(path, body, params);
+  }
+  /**
+   * Make a POST request with FormData (multipart/form-data)
+   * @param T - The generated response type
+   * @returns The extracted data from the response (without the { status, data } wrapper)
+   */
+  async postFormData(path, formData, params) {
+    const clientAny = this.client;
+    return clientAny.postFormData(path, formData, params);
+  }
+};
+
+// src/resources/host.ts
+var HostResource = class extends BaseResource {
+  /**
+   * Get list of all supported hosts with their information
+   *
+   * @param hostOnly - If true, only return hosts (exclude streams and redirectors)
+   *
+   * @example
+   * ```ts
+   * const hosts = await client.host.list()
+   * console.log(hosts.hosts) // All supported file hosts
+   * console.log(hosts.streams) // Streaming hosts
+   * console.log(hosts.redirectors) // Link redirectors
+   * ```
+   */
+  async list(hostOnly) {
+    const params = hostOnly ? { hostOnly: "1" } : void 0;
+    return this.get("/hosts", params);
+  }
+  /**
+   * Get array of all supported domain names
+   *
+   * @example
+   * ```ts
+   * const domains = await client.host.domains()
+   * console.log(domains) // ['rapidgator.net', 'uploaded.net', ...]
+   * ```
+   */
+  async domains() {
+    return this.get("/hosts/domains");
+  }
+  /**
+   * Get hosts ordered by restriction level (priority list)
+   *
+   * @example
+   * ```ts
+   * const priority = await client.host.priority()
+   * console.log(priority.hosts) // Ordered list with restriction levels
+   * ```
+   */
+  async priority() {
+    return this.get("/hosts/priority");
+  }
+};
+
+// src/resources/link.ts
+var LinkResource = class extends BaseResource {
+  /**
+   * Get information about one or more links
+   *
+   * @param links - Single link or array of links to get info for
+   *
+   * @example
+   * ```ts
+   * const info = await client.link.infos('https://example.com/file.zip')
+   * console.log(info)
+   * ```
+   */
+  async infos(links) {
+    const linksArray = Array.isArray(links) ? links : [links];
+    const data = await this.get("/link/infos", {
+      link: linksArray
+    });
+    return data?.infos;
+  }
+  /**
+   * Extract links from redirectors/link protectors
+   *
+   * @param link - The redirector link to extract from
+   *
+   * @example
+   * ```ts
+   * const links = await client.link.redirector('https://linkprotector.com/abc123')
+   * ```
+   */
+  async redirector(link) {
+    const data = await this.get("/link/redirector", {
+      link
+    });
+    return data?.links;
+  }
+  /**
+   * Unlock a download link
+   *
+   * @param link - The link to unlock
+   *
+   * @example
+   * ```ts
+   * const result = await client.link.unlock('https://example.com/file.zip')
+   * if (result.link) {
+   *   console.log('Direct link:', result.link)
+   * } else if (result.delayed) {
+   *   // Handle delayed generation
+   *   const delayedResult = await client.link.delayed(result.delayed)
+   * }
+   * ```
+   */
+  async unlock(link) {
+    return this.get("/link/unlock", {
+      link
+    });
+  }
+  /**
+   * Unlock a link and automatically poll if delayed
+   * Note: The API response format doesn't include a delayed field in the current OpenAPI spec.
+   * This method will be updated once the delayed mechanism is documented.
+   *
+   * @param link - The link to unlock
+   * @param _options - Polling options (currently unused)
+   *
+   * @example
+   * ```ts
+   * const result = await client.link.unlockWithPolling('https://example.com/file.zip')
+   * console.log('Direct link:', result.link)
+   * ```
+   */
+  async unlockWithPolling(link, _options = {}) {
+    return this.unlock(link);
+  }
+  /**
+   * Get streaming options for a generated link
+   *
+   * @param id - The generated link ID or streaming ID
+   *
+   * @example
+   * ```ts
+   * const streams = await client.link.streaming('abc123')
+   * ```
+   */
+  async streaming(id) {
+    return this.get("/link/streaming", {
+      id
+    });
+  }
+  /**
+   * Get the status/result of a delayed link generation
+   *
+   * @param id - The delayed generation ID
+   *
+   * @example
+   * ```ts
+   * const result = await client.link.delayed('delayed_id_123')
+   * ```
+   */
+  async delayed(id) {
+    return this.get("/link/delayed", {
+      id
+    });
+  }
+};
+
+// src/resources/magnet.ts
+var MagnetResource = class extends BaseResource {
+  /**
+   * Upload magnets by URI or hash
+   *
+   * @param magnets - Single magnet URI/hash or array of magnets
+   *
+   * @example
+   * ```ts
+   * const result = await client.magnet.upload('magnet:?xt=urn:btih:...')
+   * console.log('Magnet ID:', result.magnets[0].id)
+   * ```
+   */
+  async upload(magnets) {
+    const magnetsArray = Array.isArray(magnets) ? magnets : [magnets];
+    return this.get("/magnet/upload", {
+      magnets: magnetsArray
+    });
+  }
+  /**
+   * Upload a torrent file
+   *
+   * @param file - The torrent file (Blob or File)
+   * @param filename - Optional filename (defaults to 'torrent.torrent' for Blob, or file.name for File)
+   *
+   * @example
+   * ```ts
+   * const file = new File([buffer], 'torrent.torrent')
+   * const result = await client.magnet.uploadFile(file)
+   *
+   * // Or with a Blob and custom filename
+   * const blob = new Blob([buffer])
+   * const result = await client.magnet.uploadFile(blob, 'my-torrent.torrent')
+   * ```
+   */
+  async uploadFile(file, filename) {
+    const formData = new FormData();
+    const actualFilename = filename || (file instanceof File ? file.name : "torrent.torrent");
+    formData.append("files[]", file, actualFilename);
+    return this.postFormData("/magnet/upload/file", formData);
+  }
+  /**
+   * Get the status of one or more magnets
+   *
+   * @param id - Optional magnet ID to get status for a specific magnet
+   *
+   * @example
+   * ```ts
+   * // Get all magnets status
+   * const allStatus = await client.magnet.status()
+   *
+   * // Get specific magnet status
+   * const status = await client.magnet.status('123')
+   * console.log(status.magnets[0]?.status) // 'Downloading', 'Ready', etc.
+   * ```
+   */
+  async status(id) {
+    const params = id ? { id } : void 0;
+    const data = await this.get("/magnet/status", params);
+    if (data?.magnets && !Array.isArray(data.magnets)) {
+      return {
+        ...data,
+        magnets: [data.magnets]
+      };
+    }
+    return data;
+  }
+  /**
+   * Delete a magnet
+   *
+   * @param id - The magnet ID to delete (string)
+   *
+   * @example
+   * ```ts
+   * await client.magnet.delete('123')
+   * ```
+   */
+  async delete(id) {
+    return this.get("/magnet/delete", {
+      id
+    });
+  }
+  /**
+   * Restart one or more failed magnets
+   *
+   * @param ids - Single magnet ID or array of magnet IDs to restart (strings)
+   *
+   * @example
+   * ```ts
+   * // Restart single magnet
+   * await client.magnet.restart('123')
+   *
+   * // Restart multiple magnets
+   * await client.magnet.restart(['123', '456'])
+   * ```
+   */
+  async restart(ids) {
+    const idsArray = Array.isArray(ids) ? ids : [ids];
+    return this.get("/magnet/restart", {
+      ids: idsArray
+    });
+  }
+  /**
+   * Check instant availability of magnets
+   *
+   * @param magnets - Single magnet hash or array of hashes
+   *
+   * @example
+   * ```ts
+   * const available = await client.magnet.instant(['hash1', 'hash2'])
+   * console.log(available.magnets)
+   * ```
+   */
+  async instant(magnets) {
+    const magnetsArray = Array.isArray(magnets) ? magnets : [magnets];
+    return this.get("/magnet/instant", {
+      magnets: magnetsArray
+    });
+  }
+  /**
+   * Watch a magnet's status with automatic polling
+   *
+   * @param id - The magnet ID to watch (string)
+   * @param options - Watch options
+   *
+   * @example
+   * ```ts
+   * await client.magnet.watch('123', {
+   *   onUpdate: (status) => console.log('Status:', status.magnets[0]?.status),
+   *   stopOnStatus: 'Ready'
+   * })
+   * ```
+   */
+  async watch(id, options = {}) {
+    const { interval = 3e3, maxAttempts = 0, onUpdate, stopOnStatus = "Ready" } = options;
+    let attempt = 0;
+    while (maxAttempts === 0 || attempt < maxAttempts) {
+      attempt++;
+      const status = await this.status(id);
+      onUpdate?.(status);
+      const magnet = status?.magnets?.[0];
+      if (magnet?.status === stopOnStatus) {
+        return status;
+      }
+      await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+    throw new Error(
+      `Watch timeout: magnet did not reach '${stopOnStatus}' status after ${maxAttempts} attempts`
+    );
+  }
+};
+
+// src/resources/user.ts
+var UserResource = class extends BaseResource {
+  /**
+   * Get user profile information including premium status and quotas
+   *
+   * @example
+   * ```ts
+   * const user = await client.user.getInfo()
+   * console.log(user.username, user.isPremium)
+   * ```
+   */
+  async getInfo() {
+    const data = await this.get("/user");
+    return data?.user;
+  }
+  /**
+   * Get available hosts for the current user based on their subscription
+   *
+   * @param hostOnly - If true, only return hosts data (exclude streams and redirectors)
+   *
+   * @example
+   * ```ts
+   * const hosts = await client.user.getHosts()
+   * console.log(Object.keys(hosts.hosts))
+   * ```
+   */
+  async getHosts(hostOnly) {
+    const params = hostOnly ? { hostOnly: "1" } : void 0;
+    return this.get("/user/hosts", params);
+  }
+  /**
+   * Clear a specific notification by code
+   *
+   * @param code - The notification code to clear
+   *
+   * @example
+   * ```ts
+   * await client.user.clearNotification('SOME_NOTIF_CODE')
+   * ```
+   */
+  async clearNotification(code) {
+    await this.get("/user/notification/clear", { code });
+  }
+  // ============================================
+  // Saved Links Management
+  // ============================================
+  /**
+   * Get all saved links
+   *
+   * @example
+   * ```ts
+   * const savedLinks = await client.user.getLinks()
+   * console.log(savedLinks.links)
+   * ```
+   */
+  async getLinks() {
+    return this.get("/user/links");
+  }
+  /**
+   * Save a link for later use
+   *
+   * @param link - The link to save
+   *
+   * @example
+   * ```ts
+   * await client.user.saveLink('https://example.com/file.zip')
+   * ```
+   */
+  async saveLink(link) {
+    return this.get("/user/links/save", { link });
+  }
+  /**
+   * Delete a saved link
+   *
+   * @param link - The link to delete (can be the saved link ID or URL)
+   *
+   * @example
+   * ```ts
+   * await client.user.deleteLink('saved-link-id')
+   * ```
+   */
+  async deleteLink(link) {
+    return this.get("/user/links/delete", { link });
+  }
+  // ============================================
+  // History Management
+  // ============================================
+  /**
+   * Get user history (if enabled in account settings)
+   *
+   * @example
+   * ```ts
+   * const history = await client.user.getHistory()
+   * console.log(history.links)
+   * ```
+   */
+  async getHistory() {
+    return this.get("/user/history");
+  }
+  /**
+   * Clear user history
+   *
+   * @example
+   * ```ts
+   * await client.user.clearHistory()
+   * ```
+   */
+  async clearHistory() {
+    return this.get("/user/history/delete");
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.alldebrid.com/v4";
+var DEFAULT_AGENT = "@alldebrid/sdk";
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_MAX_RETRIES = 3;
+var AllDebridClient = class {
+  config;
+  /**
+   * User resource for managing user account
+   */
+  user;
+  /**
+   * Link resource for unlocking and managing download links
+   */
+  link;
+  /**
+   * Magnet resource for managing torrents
+   */
+  magnet;
+  /**
+   * Host resource for getting information about supported hosts
+   */
+  host;
+  constructor(config) {
+    this.config = {
+      apiKey: config.apiKey,
+      agent: config.agent ?? DEFAULT_AGENT,
+      baseUrl: config.baseUrl ?? DEFAULT_BASE_URL,
+      timeout: config.timeout ?? DEFAULT_TIMEOUT,
+      retry: config.retry ?? true,
+      maxRetries: config.maxRetries ?? DEFAULT_MAX_RETRIES
+    };
+    this.user = new UserResource(this);
+    this.link = new LinkResource(this);
+    this.magnet = new MagnetResource(this);
+    this.host = new HostResource(this);
+  }
+  /**
+   * Build query string from params
+   */
+  buildUrl(path, params) {
+    const allParams = {
+      agent: this.config.agent,
+      ...params
+    };
+    const query = new URLSearchParams();
+    for (const [key, value] of Object.entries(allParams)) {
+      if (value !== void 0 && value !== null) {
+        if (Array.isArray(value)) {
+          value.forEach((v) => query.append(`${key}[]`, String(v)));
+        } else {
+          query.append(key, String(value));
+        }
+      }
+    }
+    const queryString = query.toString();
+    return queryString ? `${path}?${queryString}` : path;
+  }
+  /**
+   * Make a GET request
+   * @param T - The generated response type (e.g., GetLinkUnlockResponse)
+   * @returns The extracted data from the response (without the { status, data } wrapper)
+   */
+  async get(path, params) {
+    try {
+      const url = this.buildUrl(path, params);
+      const json = await wretch__default.default(this.config.baseUrl).auth(`Bearer ${this.config.apiKey}`).url(url).get().json();
+      if (json.status === "error" && json.error) {
+        throw createTypedError(json.error.code, json.error.message);
+      }
+      return json.data;
+    } catch (error) {
+      if (error.status === 401) {
+        throw createTypedError("AUTH_BAD_APIKEY", "Invalid API key or unauthorized access");
+      }
+      if (error.status === 403) {
+        throw createTypedError("AUTH_BLOCKED", "Access forbidden");
+      }
+      if (error.status === 429) {
+        throw createTypedError("RATE_LIMITED", "Too many requests");
+      }
+      if (error.isAllDebridError) {
+        throw error;
+      }
+      throw new NetworkError(error.message || "Network error occurred", error.status);
+    }
+  }
+  /**
+   * Make a POST request
+   * @param T - The generated response type
+   * @returns The extracted data from the response (without the { status, data } wrapper)
+   */
+  async post(path, body, params) {
+    try {
+      const url = this.buildUrl(path, params);
+      const json = await wretch__default.default(this.config.baseUrl).auth(`Bearer ${this.config.apiKey}`).url(url).post(body).json();
+      if (json.status === "error" && json.error) {
+        throw createTypedError(json.error.code, json.error.message);
+      }
+      return json.data;
+    } catch (error) {
+      if (error.status === 401) {
+        throw createTypedError("AUTH_BAD_APIKEY", "Invalid API key or unauthorized access");
+      }
+      if (error.status === 403) {
+        throw createTypedError("AUTH_BLOCKED", "Access forbidden");
+      }
+      if (error.status === 429) {
+        throw createTypedError("RATE_LIMITED", "Too many requests");
+      }
+      if (error.isAllDebridError) {
+        throw error;
+      }
+      throw new NetworkError(error.message || "Network error occurred", error.status);
+    }
+  }
+  /**
+   * Make a POST request with FormData (multipart/form-data)
+   * @param T - The generated response type
+   * @returns The extracted data from the response (without the { status, data } wrapper)
+   */
+  async postFormData(path, formData, params) {
+    try {
+      const url = this.buildUrl(path, params);
+      const json = await wretch__default.default(this.config.baseUrl).auth(`Bearer ${this.config.apiKey}`).url(url).body(formData).post().json();
+      if (json.status === "error" && json.error) {
+        throw createTypedError(json.error.code, json.error.message);
+      }
+      return json.data;
+    } catch (error) {
+      if (error.status === 401) {
+        throw createTypedError("AUTH_BAD_APIKEY", "Invalid API key or unauthorized access");
+      }
+      if (error.status === 403) {
+        throw createTypedError("AUTH_BLOCKED", "Access forbidden");
+      }
+      if (error.status === 429) {
+        throw createTypedError("RATE_LIMITED", "Too many requests");
+      }
+      if (error.isAllDebridError) {
+        throw error;
+      }
+      throw new NetworkError(error.message || "Network error occurred", error.status);
+    }
+  }
+  /**
+   * Test the API connection
+   */
+  async ping() {
+    try {
+      await this.get("/user");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+exports.AllDebridClient = AllDebridClient;
+exports.AllDebridError = AllDebridError;
+exports.AuthenticationError = AuthenticationError;
+exports.HostResource = HostResource;
+exports.LinkError = LinkError;
+exports.LinkResource = LinkResource;
+exports.MagnetError = MagnetError;
+exports.MagnetResource = MagnetResource;
+exports.NetworkError = NetworkError;
+exports.UserResource = UserResource;
+exports.createTypedError = createTypedError;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map