@air/api-rest 0.1.1

package/dist/index.js

@@ -0,0 +1,570 @@
+// src/api.ts
+import { AirBase } from "@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 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
+import {
+  AirBase as AirBase2,
+  APIError,
+  AuthenticationError,
+  BadRequestError,
+  ConnectionError,
+  InternalServerError,
+  NotFoundError,
+  PermissionError,
+  RateLimitError,
+  TimeoutError,
+  CursorPage,
+  PagePromise,
+  VERSION
+} from "@air/api-core";
+export {
+  APIError,
+  AirApi,
+  AirBase2 as AirBase,
+  Assets,
+  AuthenticationError,
+  BadRequestError,
+  Boards,
+  ConnectionError,
+  CursorPage,
+  CustomFields,
+  Imports,
+  InternalServerError,
+  NotFoundError,
+  PagePromise,
+  PermissionError,
+  RateLimitError,
+  Roles,
+  Tags,
+  TimeoutError,
+  Uploads,
+  VERSION
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@air/api-rest",
+  "version": "0.1.1",
+  "type": "module",
+  "description": "Typed REST client for Air API",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prepublishOnly": "npm run build",
+    "build": "tsup",
+    "test": "vitest run",
+    "typecheck": "tsc -b",
+    "clean": "rm -rf dist tsconfig.tsbuildinfo"
+  },
+  "dependencies": {
+    "@air/api-core": "0.1.1"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AirLabsTeam/air-api-sdk.git",
+    "directory": "packages/rest"
+  },
+  "license": "UNLICENSED"
+}