@air/api-rest 0.1.1

package/dist/index.cjs

@@ -0,0 +1,613 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  APIError: () => import_api_core2.APIError,
+  AirApi: () => AirApi,
+  AirBase: () => import_api_core2.AirBase,
+  Assets: () => Assets,
+  AuthenticationError: () => import_api_core2.AuthenticationError,
+  BadRequestError: () => import_api_core2.BadRequestError,
+  Boards: () => Boards,
+  ConnectionError: () => import_api_core2.ConnectionError,
+  CursorPage: () => import_api_core2.CursorPage,
+  CustomFields: () => CustomFields,
+  Imports: () => Imports,
+  InternalServerError: () => import_api_core2.InternalServerError,
+  NotFoundError: () => import_api_core2.NotFoundError,
+  PagePromise: () => import_api_core2.PagePromise,
+  PermissionError: () => import_api_core2.PermissionError,
+  RateLimitError: () => import_api_core2.RateLimitError,
+  Roles: () => Roles,
+  Tags: () => Tags,
+  TimeoutError: () => import_api_core2.TimeoutError,
+  Uploads: () => Uploads,
+  VERSION: () => import_api_core2.VERSION
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/api.ts
+var import_api_core = require("@air/api-core");
+
+// src/resources/assets.ts
+var Assets = class {
+  constructor(client) {
+    this.client = client;
+  }
+  list(params = {}) {
+    const query = {
+      limit: params.limit,
+      cursor: params.cursor,
+      parentBoardId: params.parentBoardId,
+      search: params.search
+    };
+    if (params.includeNestedAssets !== void 0) {
+      query.includeNestedAssets = params.includeNestedAssets;
+    }
+    if (params.tag) {
+      query.tag = params.tag;
+    }
+    if (params.customField) {
+      query.customField = params.customField;
+    }
+    if (params["createdAt[gte]"]) {
+      query["createdAt[gte]"] = params["createdAt[gte]"];
+    }
+    if (params["createdAt[lte]"]) {
+      query["createdAt[lte]"] = params["createdAt[lte]"];
+    }
+    return this.client.requestCursorPage({ method: "GET", path: "/assets", query }, query);
+  }
+  async get(assetId) {
+    return this.client.request({
+      method: "GET",
+      path: `/assets/${assetId}`
+    });
+  }
+  async delete(assetId) {
+    return this.client.request({
+      method: "DELETE",
+      path: `/assets/${assetId}`
+    });
+  }
+  async setCustomField(assetId, customFieldId, params) {
+    return this.client.request({
+      method: "PUT",
+      path: `/assets/${assetId}/customfields/${customFieldId}`,
+      body: params
+    });
+  }
+  async listVersions(assetId) {
+    return this.client.request({
+      method: "GET",
+      path: `/assets/${assetId}/versions`
+    });
+  }
+  async getVersion(assetId, versionId) {
+    return this.client.request({
+      method: "GET",
+      path: `/assets/${assetId}/versions/${versionId}`
+    });
+  }
+  async updateVersion(assetId, versionId, params) {
+    return this.client.request({
+      method: "PATCH",
+      path: `/assets/${assetId}/versions/${versionId}`,
+      body: params
+    });
+  }
+  async getVersionDownloadUrl(assetId, versionId) {
+    return this.client.request({
+      method: "GET",
+      path: `/assets/${assetId}/versions/${versionId}/download`
+    });
+  }
+  async addVersionTag(assetId, versionId, params) {
+    return this.client.request({
+      method: "POST",
+      path: `/assets/${assetId}/versions/${versionId}/tags`,
+      body: params
+    });
+  }
+  async removeVersionTag(assetId, versionId, tagId) {
+    return this.client.request({
+      method: "DELETE",
+      path: `/assets/${assetId}/versions/${versionId}/tags/${tagId}`
+    });
+  }
+  listBoards(assetId, params = {}) {
+    const query = {
+      limit: params.limit,
+      cursor: params.cursor
+    };
+    if (params.includeCustomFields !== void 0) {
+      query.includeCustomFields = params.includeCustomFields;
+    }
+    return this.client.requestCursorPage(
+      { method: "GET", path: `/assets/${assetId}/boards`, query },
+      query
+    );
+  }
+};
+
+// src/resources/boards.ts
+var Boards = class {
+  constructor(client) {
+    this.client = client;
+  }
+  list(params = {}) {
+    const query = {
+      limit: params.limit,
+      cursor: params.cursor,
+      name: params.name,
+      parentBoardId: params.parentBoardId
+    };
+    if (params.customField) {
+      query.customField = params.customField;
+    }
+    return this.client.requestCursorPage({ method: "GET", path: "/boards", query }, query);
+  }
+  async get(boardId) {
+    return this.client.request({
+      method: "GET",
+      path: `/boards/${boardId}`
+    });
+  }
+  async create(params) {
+    return this.client.request({
+      method: "POST",
+      path: "/boards",
+      body: params
+    });
+  }
+  async update(boardId, params) {
+    return this.client.request({
+      method: "PATCH",
+      path: `/boards/${boardId}`,
+      body: params
+    });
+  }
+  async delete(boardId) {
+    return this.client.request({
+      method: "DELETE",
+      path: `/boards/${boardId}`
+    });
+  }
+  async addAssets(boardId, params) {
+    return this.client.request({
+      method: "POST",
+      path: `/boards/${boardId}/assets`,
+      body: params
+    });
+  }
+  async removeAsset(boardId, assetId) {
+    return this.client.request({
+      method: "DELETE",
+      path: `/boards/${boardId}/assets/${assetId}`
+    });
+  }
+  async setCustomField(boardId, customFieldId, params) {
+    return this.client.request({
+      method: "PUT",
+      path: `/boards/${boardId}/customFields/${customFieldId}`,
+      body: params
+    });
+  }
+  async addGuest(boardId, params) {
+    return this.client.request({
+      method: "POST",
+      path: `/boards/${boardId}/guests`,
+      body: params
+    });
+  }
+  async listGuests(boardId, params = {}) {
+    const response = await this.client.request({
+      method: "GET",
+      path: `/boards/${boardId}/guests`,
+      query: params.email ? { email: params.email } : void 0
+    });
+    return response.data;
+  }
+  async updateGuest(boardId, guestId, params) {
+    return this.client.request({
+      method: "PATCH",
+      path: `/boards/${boardId}/guests/${guestId}`,
+      body: params
+    });
+  }
+  async removeGuest(boardId, guestId) {
+    return this.client.request({
+      method: "DELETE",
+      path: `/boards/${boardId}/guests/${guestId}`
+    });
+  }
+};
+
+// src/resources/custom-fields.ts
+var CustomFields = class {
+  constructor(client) {
+    this.client = client;
+  }
+  list(params = {}) {
+    return this.client.requestCursorPage(
+      {
+        method: "GET",
+        path: "/customfields",
+        query: params
+      },
+      params
+    );
+  }
+  async get(customFieldId) {
+    return this.client.request({
+      method: "GET",
+      path: `/customfields/${customFieldId}`
+    });
+  }
+  async create(params) {
+    return this.client.request({
+      method: "POST",
+      path: "/customfields",
+      body: params
+    });
+  }
+  async update(customFieldId, params) {
+    return this.client.request({
+      method: "PATCH",
+      path: `/customfields/${customFieldId}`,
+      body: params
+    });
+  }
+  async delete(customFieldId) {
+    return this.client.request({
+      method: "DELETE",
+      path: `/customfields/${customFieldId}`
+    });
+  }
+  async createValue(customFieldId, params) {
+    return this.client.request({
+      method: "POST",
+      path: `/customfields/${customFieldId}/values`,
+      body: params
+    });
+  }
+  async updateValue(customFieldId, valueId, params) {
+    return this.client.request({
+      method: "PATCH",
+      path: `/customfields/${customFieldId}/values/${valueId}`,
+      body: params
+    });
+  }
+  async deleteValue(customFieldId, valueId) {
+    return this.client.request({
+      method: "DELETE",
+      path: `/customfields/${customFieldId}/values/${valueId}`
+    });
+  }
+};
+
+// src/resources/imports.ts
+var Imports = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async create(params) {
+    return this.client.request({
+      method: "POST",
+      path: "/imports",
+      body: params
+    });
+  }
+  async getStatus(importId) {
+    return this.client.request({
+      method: "GET",
+      path: `/imports/${importId}/status`
+    });
+  }
+};
+
+// src/resources/roles.ts
+var Roles = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(params = { type: "guest" }) {
+    const response = await this.client.request({
+      method: "GET",
+      path: "/roles",
+      query: { type: params.type }
+    });
+    return response.data;
+  }
+};
+
+// src/resources/tags.ts
+var Tags = class {
+  constructor(client) {
+    this.client = client;
+  }
+  list(params = {}) {
+    return this.client.requestCursorPage(
+      {
+        method: "GET",
+        path: "/tags",
+        query: params
+      },
+      params
+    );
+  }
+  async get(tagId) {
+    return this.client.request({
+      method: "GET",
+      path: `/tags/${tagId}`
+    });
+  }
+  async create(params) {
+    return this.client.request({
+      method: "POST",
+      path: "/tags",
+      body: params
+    });
+  }
+  async update(tagId, params) {
+    return this.client.request({
+      method: "PATCH",
+      path: `/tags/${tagId}`,
+      body: params
+    });
+  }
+  async delete(tagId) {
+    return this.client.request({
+      method: "DELETE",
+      path: `/tags/${tagId}`
+    });
+  }
+};
+
+// src/resources/uploads.ts
+var DEFAULT_PART_SIZE = 100 * 1024 * 1024;
+var Uploads = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async create(params) {
+    return this.client.request({
+      method: "POST",
+      path: "/uploads",
+      body: params
+    });
+  }
+  async getPartUploadUrl(params) {
+    return this.client.request({
+      method: "POST",
+      path: "/uploads/uploadPart",
+      body: params
+    });
+  }
+  async completeMultipart(params) {
+    return this.client.request({
+      method: "POST",
+      path: "/uploads/completeMultipart",
+      body: params
+    });
+  }
+  async uploadFile(params, options = {}) {
+    const { fileData, fileName, ext, mime, size } = await resolveFileData(params);
+    const uploadResponse = await this.create({
+      fileName,
+      ext,
+      size,
+      mime,
+      parentBoardId: options.parentBoardId,
+      assetId: options.assetId,
+      customFields: options.customFields,
+      tags: options.tags
+    });
+    if (isSmallUpload(uploadResponse)) {
+      await this._uploadSmallFile(uploadResponse.uploadUrl, fileData, options.onProgress, size);
+      return { assetId: uploadResponse.assetId, versionId: uploadResponse.versionId };
+    }
+    await this._uploadLargeFile(uploadResponse, fileData, size, options.onProgress);
+    return { assetId: uploadResponse.assetId, versionId: uploadResponse.versionId };
+  }
+  async _uploadSmallFile(url, data, onProgress, totalSize) {
+    const fetchFn = this.client.fetchFn;
+    const response = await fetchFn(url, {
+      method: "PUT",
+      body: data
+    });
+    if (!response.ok) {
+      throw new Error(`Upload failed with status ${response.status}`);
+    }
+    if (onProgress && totalSize) {
+      onProgress({ percentage: 100, uploadedBytes: totalSize, totalBytes: totalSize });
+    }
+  }
+  async _uploadLargeFile(uploadInfo, data, totalSize, onProgress) {
+    const { multiPartUploadId, key } = uploadInfo;
+    const buffer = data instanceof Buffer ? data : Buffer.from(data);
+    const partCount = Math.ceil(totalSize / DEFAULT_PART_SIZE);
+    const parts = [];
+    let uploadedBytes = 0;
+    const fetchFn = this.client.fetchFn;
+    for (let i = 0; i < partCount; i++) {
+      const partNumber = i + 1;
+      const start = i * DEFAULT_PART_SIZE;
+      const end = Math.min(start + DEFAULT_PART_SIZE, totalSize);
+      const chunk = buffer.subarray(start, end);
+      const { url } = await this.getPartUploadUrl({
+        multiPartUploadId,
+        key,
+        partNumber
+      });
+      const response = await fetchFn(url, {
+        method: "PUT",
+        body: chunk
+      });
+      if (!response.ok) {
+        throw new Error(`Part ${partNumber} upload failed with status ${response.status}`);
+      }
+      const etag = response.headers.get("etag");
+      if (!etag) {
+        throw new Error(`Part ${partNumber} upload did not return an ETag`);
+      }
+      parts.push({ etag, partNumber });
+      uploadedBytes += chunk.byteLength;
+      if (onProgress) {
+        onProgress({
+          percentage: Math.round(uploadedBytes / totalSize * 100),
+          uploadedBytes,
+          totalBytes: totalSize
+        });
+      }
+    }
+    await this.completeMultipart({ multiPartUploadId, key, parts });
+  }
+};
+function isSmallUpload(response) {
+  return "uploadUrl" in response;
+}
+async function resolveFileData(params) {
+  if (params.filePath) {
+    const fs = await import("fs");
+    const path = await import("path");
+    const fileData = fs.readFileSync(params.filePath);
+    const parsed = path.parse(params.filePath);
+    const fileName = params.fileName ?? parsed.name;
+    const ext = params.ext ?? parsed.ext.replace(/^\./, "");
+    const mime = params.mime ?? guessMime(ext);
+    return { fileData, fileName, ext, mime, size: fileData.byteLength };
+  }
+  if (params.buffer) {
+    const data = params.buffer instanceof Buffer ? params.buffer : Buffer.from(params.buffer);
+    if (!params.fileName || !params.ext) {
+      throw new Error("fileName and ext are required when uploading from a buffer");
+    }
+    const mime = params.mime ?? guessMime(params.ext);
+    return {
+      fileData: data,
+      fileName: params.fileName,
+      ext: params.ext,
+      mime,
+      size: data.byteLength
+    };
+  }
+  if (params.file) {
+    const arrayBuffer = await params.file.arrayBuffer();
+    const data = new Uint8Array(arrayBuffer);
+    const name = params.file.name;
+    const dotIndex = name.lastIndexOf(".");
+    const fileName = params.fileName ?? (dotIndex > 0 ? name.substring(0, dotIndex) : name);
+    const ext = params.ext ?? (dotIndex > 0 ? name.substring(dotIndex + 1) : "");
+    const mime = params.mime ?? (params.file.type || guessMime(ext));
+    return { fileData: data, fileName, ext, mime, size: data.byteLength };
+  }
+  throw new Error("One of filePath, buffer, or file must be provided");
+}
+function guessMime(ext) {
+  const mimeMap = {
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    png: "image/png",
+    gif: "image/gif",
+    webp: "image/webp",
+    svg: "image/svg+xml",
+    mp4: "video/mp4",
+    mov: "video/quicktime",
+    avi: "video/x-msvideo",
+    webm: "video/webm",
+    mp3: "audio/mpeg",
+    wav: "audio/wav",
+    pdf: "application/pdf",
+    doc: "application/msword",
+    docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    xls: "application/vnd.ms-excel",
+    xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ppt: "application/vnd.ms-powerpoint",
+    pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    zip: "application/zip",
+    psd: "image/vnd.adobe.photoshop",
+    ai: "application/postscript",
+    eps: "application/postscript",
+    tif: "image/tiff",
+    tiff: "image/tiff",
+    bmp: "image/bmp"
+  };
+  return mimeMap[ext.toLowerCase()] ?? "application/octet-stream";
+}
+
+// src/api.ts
+var AirApi = class extends import_api_core.AirBase {
+  assets;
+  boards;
+  tags;
+  customFields;
+  roles;
+  imports;
+  uploads;
+  constructor(options = {}) {
+    super(options);
+    this.assets = new Assets(this);
+    this.boards = new Boards(this);
+    this.tags = new Tags(this);
+    this.customFields = new CustomFields(this);
+    this.roles = new Roles(this);
+    this.imports = new Imports(this);
+    this.uploads = new Uploads(this);
+  }
+};
+
+// src/index.ts
+var import_api_core2 = require("@air/api-core");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APIError,
+  AirApi,
+  AirBase,
+  Assets,
+  AuthenticationError,
+  BadRequestError,
+  Boards,
+  ConnectionError,
+  CursorPage,
+  CustomFields,
+  Imports,
+  InternalServerError,
+  NotFoundError,
+  PagePromise,
+  PermissionError,
+  RateLimitError,
+  Roles,
+  Tags,
+  TimeoutError,
+  Uploads,
+  VERSION
+});