@borealise/api 1.0.0

package/dist/index.mjs

@@ -0,0 +1,571 @@
+// src/Api.ts
+import axios from "axios";
+
+// src/Logger.ts
+var Logger = class _Logger {
+  constructor(name, enabled = true) {
+    this.name = name;
+    this.enabled = enabled;
+  }
+  static create(name) {
+    return new _Logger(name);
+  }
+  enable() {
+    this.enabled = true;
+  }
+  disable() {
+    this.enabled = false;
+  }
+  log(level, message, ...args) {
+    if (!this.enabled) return;
+    const prefix = `[${this.name}]`;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    switch (level) {
+      case "debug":
+        console.debug(`${timestamp} ${prefix} ${message}`, ...args);
+        break;
+      case "info":
+        console.info(`${timestamp} ${prefix} ${message}`, ...args);
+        break;
+      case "success":
+        console.log(`${timestamp} ${prefix} \u2713 ${message}`, ...args);
+        break;
+      case "error":
+        console.error(`${timestamp} ${prefix} \u2717 ${message}`, ...args);
+        break;
+    }
+  }
+  debug(message, ...args) {
+    this.log("debug", message, ...args);
+  }
+  info(message, ...args) {
+    this.log("info", message, ...args);
+  }
+  success(message, ...args) {
+    this.log("success", message, ...args);
+  }
+  error(message, ...args) {
+    this.log("error", message, ...args);
+  }
+};
+
+// src/Api.ts
+var ApiError = class extends Error {
+  constructor(message, status, code, response) {
+    super(message);
+    this.name = "ApiError";
+    this.status = status;
+    this.code = code;
+    this.response = response;
+  }
+};
+var _Api = class _Api {
+  constructor(config) {
+    var _a;
+    this.config = config;
+    this.logger = Logger.create("Api");
+    if (config.logging === false) {
+      this.logger.disable();
+    }
+    this.axios = axios.create({
+      baseURL: config.baseURL,
+      timeout: (_a = config.timeout) != null ? _a : 3e4,
+      headers: {
+        "Content-Type": "application/json",
+        ...config.headers
+      }
+    });
+    this.setupInterceptors();
+    this.logger.success(`initialized (baseURL: ${config.baseURL})`);
+  }
+  static getInstance(config) {
+    if (!_Api.instance) {
+      if (!config) {
+        throw new Error('Api must be initialized with config first. Call Api.getInstance({ baseURL: "..." }) once before using resources.');
+      }
+      _Api.instance = new _Api(config);
+    }
+    return _Api.instance;
+  }
+  /** Reset the singleton (useful for testing or re-initializing with a new config) */
+  static reset() {
+    _Api.instance = null;
+  }
+  setupInterceptors() {
+    this.axios.interceptors.request.use(
+      (config) => {
+        var _a;
+        this.logger.debug(`\u2192 ${(_a = config.method) == null ? void 0 : _a.toUpperCase()} ${config.url}`);
+        return config;
+      },
+      (error) => {
+        this.logger.error("Request error", error);
+        return Promise.reject(error);
+      }
+    );
+    this.axios.interceptors.response.use(
+      (response) => {
+        this.logger.debug(`\u2190 ${response.status} ${response.config.url}`);
+        return response;
+      },
+      (error) => {
+        var _a, _b, _c;
+        const apiError = this.parseError(error);
+        const status = (_b = (_a = apiError.status) != null ? _a : apiError.code) != null ? _b : "ERR";
+        this.logger.error(`\u2190 ${status} ${(_c = error.config) == null ? void 0 : _c.url}: ${apiError.message}`);
+        return Promise.reject(apiError);
+      }
+    );
+  }
+  parseError(error) {
+    if (error.response) {
+      const responseData = error.response.data;
+      let message;
+      let backendResponse;
+      if (responseData && "error" in responseData && responseData.error) {
+        message = responseData.error;
+        backendResponse = responseData;
+      } else if (responseData && "message" in responseData && responseData.message) {
+        message = responseData.message;
+      } else {
+        message = error.message;
+      }
+      return new ApiError(message, error.response.status, error.code, backendResponse);
+    }
+    if (error.request) {
+      return new ApiError("No response received from server", void 0, "NETWORK_ERROR");
+    }
+    return new ApiError(error.message, void 0, error.code);
+  }
+  setAuthToken(token) {
+    if (token) {
+      this.axios.defaults.headers.common["Authorization"] = `Bearer ${token}`;
+      this.logger.debug("Auth token set");
+    } else {
+      delete this.axios.defaults.headers.common["Authorization"];
+      this.logger.debug("Auth token cleared");
+    }
+  }
+  setHeader(key, value) {
+    this.axios.defaults.headers.common[key] = value;
+  }
+  removeHeader(key) {
+    delete this.axios.defaults.headers.common[key];
+  }
+  async get(url, config) {
+    const response = await this.axios.get(url, config);
+    return this.wrapResponse(response);
+  }
+  async post(url, data, config) {
+    const response = await this.axios.post(url, data, config);
+    return this.wrapResponse(response);
+  }
+  async put(url, data, config) {
+    const response = await this.axios.put(url, data, config);
+    return this.wrapResponse(response);
+  }
+  async patch(url, data, config) {
+    const response = await this.axios.patch(url, data, config);
+    return this.wrapResponse(response);
+  }
+  async delete(url, config) {
+    const response = await this.axios.delete(url, config);
+    return this.wrapResponse(response);
+  }
+  wrapResponse(response) {
+    return {
+      data: response.data,
+      status: response.status,
+      headers: response.headers
+    };
+  }
+  get axiosInstance() {
+    return this.axios;
+  }
+};
+_Api.instance = null;
+var Api = _Api;
+
+// src/ApiResource.ts
+var ApiResource = class {
+  constructor() {
+    this._logger = null;
+  }
+  get api() {
+    return Api.getInstance();
+  }
+  get logger() {
+    if (!this._logger) {
+      this._logger = Logger.create(this.constructor.name);
+    }
+    return this._logger;
+  }
+  buildUrl(path) {
+    if (path !== void 0) {
+      return `${this.endpoint}/${path}`;
+    }
+    return this.endpoint;
+  }
+  buildConfig(options) {
+    return {
+      params: options == null ? void 0 : options.params,
+      headers: options == null ? void 0 : options.headers
+    };
+  }
+  async index(options) {
+    this.logger.debug("index");
+    return this.api.get(this.endpoint, this.buildConfig(options));
+  }
+  async paginate(page = 1, perPage = 15, options) {
+    this.logger.debug(`paginate (page: ${page}, perPage: ${perPage})`);
+    return this.api.get(this.endpoint, {
+      ...this.buildConfig(options),
+      params: { page, per_page: perPage, ...options == null ? void 0 : options.params }
+    });
+  }
+  async show(id, options) {
+    this.logger.debug(`show (id: ${id})`);
+    return this.api.get(this.buildUrl(id), this.buildConfig(options));
+  }
+  async store(data, options) {
+    this.logger.debug("store");
+    return this.api.post(this.endpoint, data, this.buildConfig(options));
+  }
+  async update(id, data, options) {
+    this.logger.debug(`update (id: ${id})`);
+    return this.api.put(this.buildUrl(id), data, this.buildConfig(options));
+  }
+  async patch(id, data, options) {
+    this.logger.debug(`patch (id: ${id})`);
+    return this.api.patch(this.buildUrl(id), data, this.buildConfig(options));
+  }
+  async destroy(id, options) {
+    this.logger.debug(`destroy (id: ${id})`);
+    return this.api.delete(this.buildUrl(id), this.buildConfig(options));
+  }
+  async get(path, options) {
+    return this.api.get(`${this.endpoint}/${path}`, this.buildConfig(options));
+  }
+  async post(path, data, options) {
+    return this.api.post(`${this.endpoint}/${path}`, data, this.buildConfig(options));
+  }
+  async put(path, data, options) {
+    return this.api.put(`${this.endpoint}/${path}`, data, this.buildConfig(options));
+  }
+  async delete(path, options) {
+    return this.api.delete(`${this.endpoint}/${path}`, this.buildConfig(options));
+  }
+};
+
+// src/resources/AuthResource.ts
+var AuthResource = class extends ApiResource {
+  constructor() {
+    super(...arguments);
+    this.endpoint = "/auth";
+  }
+  // POST /api/auth/login
+  async login(credentials) {
+    return this.post("login", credentials);
+  }
+  // POST /api/auth/register
+  async register(data) {
+    return this.post("register", data);
+  }
+  // POST /api/auth/refresh
+  async refresh(refreshToken) {
+    return this.post("refresh", { refreshToken });
+  }
+  // POST /api/auth/logout
+  async logout() {
+    return this.post("logout");
+  }
+  // GET /api/auth/me
+  async me() {
+    return this.get("me");
+  }
+};
+var authResource = new AuthResource();
+
+// src/resources/UserResource.ts
+var UserResource = class extends ApiResource {
+  constructor() {
+    super(...arguments);
+    this.endpoint = "/users";
+  }
+  // GET /api/users/:id
+  async getById(id) {
+    return this.show(id);
+  }
+  // GET /api/users/username/:username
+  async getByUsername(username) {
+    return this.get(`username/${username}`);
+  }
+  // PATCH /api/users/me
+  async updateProfile(data) {
+    return this.api.patch(`${this.endpoint}/me`, data);
+  }
+  // DELETE /api/users/me
+  async deleteAccount() {
+    return this.api.delete(`${this.endpoint}/me`);
+  }
+};
+var userResource = new UserResource();
+
+// src/resources/RoomResource.ts
+var RoomResource = class extends ApiResource {
+  constructor() {
+    super(...arguments);
+    this.endpoint = "/rooms";
+  }
+  // GET /api/rooms - List all rooms
+  async list() {
+    return this.get("");
+  }
+  // GET /api/rooms/featured - Get featured rooms
+  async featured() {
+    return this.get("featured");
+  }
+  // GET /api/rooms/:slug - Get room by slug
+  async getBySlug(slug) {
+    return this.get(slug);
+  }
+  // POST /api/rooms - Create a new room
+  async create(data) {
+    return this.post("", data);
+  }
+  // PATCH /api/rooms/:slug - Update room
+  async updateRoom(slug, data) {
+    return this.api.patch(`${this.endpoint}/${slug}`, data);
+  }
+  // DELETE /api/rooms/:slug - Delete room
+  async deleteRoom(slug) {
+    return this.api.delete(`${this.endpoint}/${slug}`);
+  }
+  // GET /api/rooms/:slug/staff - Get room staff
+  async getStaff(slug) {
+    return this.get(`${slug}/staff`);
+  }
+  // PUT /api/rooms/:slug/staff/:userId - Update staff role
+  async updateStaffRole(slug, userId, role) {
+    return this.api.put(`${this.endpoint}/${slug}/staff/${userId}`, { role });
+  }
+  // DELETE /api/rooms/:slug/staff/:userId - Remove staff
+  async removeStaff(slug, userId) {
+    return this.api.delete(`${this.endpoint}/${slug}/staff/${userId}`);
+  }
+  // POST /api/rooms/:slug/join - Join a room (session-based)
+  async join(slug) {
+    return this.post(`${slug}/join`);
+  }
+  // POST /api/rooms/:slug/leave - Leave a room
+  async leave(slug) {
+    return this.post(`${slug}/leave`);
+  }
+  // ============================================
+  // Waitlist methods
+  // ============================================
+  // GET /api/rooms/:slug/waitlist
+  async getWaitlist(slug) {
+    return this.get(`${slug}/waitlist`);
+  }
+  // POST /api/rooms/:slug/waitlist/join
+  async joinWaitlist(slug) {
+    return this.post(`${slug}/waitlist/join`);
+  }
+  // POST /api/rooms/:slug/waitlist/leave
+  async leaveWaitlist(slug) {
+    return this.post(`${slug}/waitlist/leave`);
+  }
+  // PATCH /api/rooms/:slug/waitlist - Move user in waitlist
+  async moveInWaitlist(slug, userId, position) {
+    return this.api.patch(`${this.endpoint}/${slug}/waitlist`, { userId, position });
+  }
+  // DELETE /api/rooms/:slug/waitlist/:userId - Remove user from waitlist
+  async removeFromWaitlist(slug, userId) {
+    return this.api.delete(`${this.endpoint}/${slug}/waitlist/${userId}`);
+  }
+  // POST /api/rooms/:slug/waitlist/lock
+  async lockWaitlist(slug) {
+    return this.post(`${slug}/waitlist/lock`);
+  }
+  // POST /api/rooms/:slug/waitlist/unlock
+  async unlockWaitlist(slug) {
+    return this.post(`${slug}/waitlist/unlock`);
+  }
+  // ============================================
+  // Booth methods
+  // ============================================
+  // GET /api/rooms/:slug/booth
+  async getBooth(slug) {
+    return this.get(`${slug}/booth`);
+  }
+  // POST /api/rooms/:slug/booth/skip
+  async skipTrack(slug, options) {
+    return this.post(`${slug}/booth/skip`, options || {});
+  }
+  // POST /api/rooms/:slug/vote
+  async vote(slug, type) {
+    return this.post(`${slug}/vote`, { type });
+  }
+  // POST /api/rooms/:slug/grab
+  async grabTrack(slug, playlistId) {
+    return this.post(`${slug}/grab`, playlistId ? { playlistId } : {});
+  }
+};
+var roomResource = new RoomResource();
+
+// src/resources/ChatResource.ts
+var ChatResource = class extends ApiResource {
+  constructor() {
+    super(...arguments);
+    this.endpoint = "/rooms";
+  }
+  // POST /api/rooms/:slug/chat - Send a chat message
+  async sendMessage(slug, data) {
+    return this.api.post(`${this.endpoint}/${slug}/chat`, data);
+  }
+  // GET /api/rooms/:slug/chat - Get chat history
+  async getMessages(slug, before, limit = 50) {
+    const params = { limit };
+    if (before) {
+      params.before = before;
+    }
+    return this.api.get(`${this.endpoint}/${slug}/chat`, { params });
+  }
+  // DELETE /api/rooms/:slug/chat/:messageId - Delete a chat message (moderation)
+  async deleteMessage(slug, messageId) {
+    return this.api.delete(`${this.endpoint}/${slug}/chat/${messageId}`);
+  }
+};
+var chatResource = new ChatResource();
+
+// src/resources/PlaylistResource.ts
+var PlaylistResource = class extends ApiResource {
+  constructor() {
+    super(...arguments);
+    this.endpoint = "/playlists";
+  }
+  // GET /api/playlists - Get all user's playlists
+  async getAll() {
+    return this.api.get(this.endpoint);
+  }
+  // GET /api/playlists/:id - Get playlist with items
+  async getById(playlistId) {
+    return this.api.get(`${this.endpoint}/${playlistId}`);
+  }
+  // POST /api/playlists - Create playlist
+  async create(name) {
+    return this.api.post(this.endpoint, { name });
+  }
+  // PATCH /api/playlists/:id - Update playlist
+  async rename(playlistId, name) {
+    return this.api.patch(`${this.endpoint}/${playlistId}`, { name });
+  }
+  // DELETE /api/playlists/:id - Delete playlist
+  async remove(playlistId) {
+    return this.api.delete(`${this.endpoint}/${playlistId}`);
+  }
+  // POST /api/playlists/:id/activate - Activate playlist
+  async activate(playlistId) {
+    return this.api.post(`${this.endpoint}/${playlistId}/activate`);
+  }
+  // POST /api/playlists/:id/shuffle - Shuffle playlist
+  async shuffle(playlistId) {
+    return this.api.post(`${this.endpoint}/${playlistId}/shuffle`);
+  }
+  // POST /api/playlists/:id/items - Add item to playlist
+  async addItem(playlistId, data) {
+    return this.api.post(`${this.endpoint}/${playlistId}/items`, data);
+  }
+  // DELETE /api/playlists/:id/items/:itemId - Remove item from playlist
+  async removeItem(playlistId, itemId) {
+    return this.api.delete(`${this.endpoint}/${playlistId}/items/${itemId}`);
+  }
+  // PATCH /api/playlists/:id/items/:itemId/move - Move item in playlist
+  async moveItem(playlistId, itemId, position) {
+    return this.api.patch(`${this.endpoint}/${playlistId}/items/${itemId}/move`, { position });
+  }
+  // POST /api/playlists/:id/import - Import from YouTube/SoundCloud playlist
+  async importPlaylist(playlistId, data) {
+    return this.api.post(`${this.endpoint}/${playlistId}/import`, data);
+  }
+};
+var playlistResource = new PlaylistResource();
+
+// src/resources/SourceResource.ts
+var SourceResource = class extends ApiResource {
+  constructor() {
+    super(...arguments);
+    this.endpoint = "/sources";
+  }
+  // ============================================
+  // YouTube
+  // ============================================
+  // GET /api/sources/youtube/search?q=...&limit=...
+  async searchYouTube(query, limit = 10) {
+    return this.api.get(`${this.endpoint}/youtube/search`, {
+      params: { q: query, limit }
+    });
+  }
+  // GET /api/sources/youtube/videos/:videoId
+  async getYouTubeVideo(videoId) {
+    return this.api.get(`${this.endpoint}/youtube/videos/${videoId}`);
+  }
+  // ============================================
+  // SoundCloud
+  // ============================================
+  // GET /api/sources/soundcloud/search?q=...&limit=...
+  async searchSoundCloud(query, limit = 10) {
+    return this.api.get(`${this.endpoint}/soundcloud/search`, {
+      params: { q: query, limit }
+    });
+  }
+  // GET /api/sources/soundcloud/tracks/:trackId
+  async getSoundCloudTrack(trackId) {
+    return this.api.get(`${this.endpoint}/soundcloud/tracks/${trackId}`);
+  }
+  // GET /api/sources/soundcloud/resolve?url=...
+  async resolveSoundCloudUrl(url) {
+    return this.api.get(`${this.endpoint}/soundcloud/resolve`, {
+      params: { url }
+    });
+  }
+  // ============================================
+  // Combined search (helper)
+  // ============================================
+  // Search both YouTube and SoundCloud
+  async searchAll(query, limit = 10) {
+    var _a, _b, _c, _d;
+    const [youtube, soundcloud] = await Promise.allSettled([
+      this.searchYouTube(query, limit),
+      this.searchSoundCloud(query, limit)
+    ]);
+    const results = [];
+    if (youtube.status === "fulfilled" && ((_b = (_a = youtube.value.data) == null ? void 0 : _a.data) == null ? void 0 : _b.results)) {
+      results.push(...youtube.value.data.data.results);
+    }
+    if (soundcloud.status === "fulfilled" && ((_d = (_c = soundcloud.value.data) == null ? void 0 : _c.data) == null ? void 0 : _d.results)) {
+      results.push(...soundcloud.value.data.data.results);
+    }
+    return results;
+  }
+};
+var sourceResource = new SourceResource();
+export {
+  Api,
+  ApiError,
+  ApiResource,
+  AuthResource,
+  ChatResource,
+  Logger,
+  PlaylistResource,
+  RoomResource,
+  SourceResource,
+  UserResource,
+  authResource,
+  chatResource,
+  playlistResource,
+  roomResource,
+  sourceResource,
+  userResource
+};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@borealise/api",
+  "version": "1.0.0",
+  "description": "Official API client for Borealise",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "lint": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "borealise",
+    "api",
+    "client",
+    "music",
+    "rooms"
+  ],
+  "author": "Borealise",
+  "license": "MIT",
+  "homepage": "https://borealise.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/borealise/api-client"
+  },
+  "bugs": {
+    "url": "https://github.com/borealise/api-client/issues"
+  },
+  "peerDependencies": {
+    "axios": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "axios": "^1.6.0"
+  }
+}