@darseen/vaze 2.3.0 → 2.4.0

package/dist/index.js

@@ -1,4 +1,7 @@
 // src/utils/index.ts
+function env(name) {
+  return typeof process === "undefined" ? void 0 : process.env?.[name];
+}
 function constructFileUrls({
   vazeUrl,
   files
@@ -25,21 +28,26 @@ function parseContentDispositionFilename(header) {
 // src/base.ts
 var Base = class {
   apiKey;
+  headers;
+  // wrapped so the global fetch is never called with this class as `this`
+  fetch;
   vazeUrl;
   constructor(options = {}) {
-    const vazeUrl = options.vazeUrl || process.env.VAZE_URL;
-    const apiKey = options.apiKey || process.env.VAZE_API_KEY;
+    const vazeUrl = options.vazeUrl || env("VAZE_URL");
+    const apiKey = options.apiKey || env("VAZE_API_KEY");
     if (!vazeUrl) {
       throw new Error(
         "You must provide a Vaze URL or set the VAZE_URL environment variable."
       );
     }
-    if (!apiKey) {
+    if (!apiKey && !options.headers) {
       throw new Error(
-        "You must provide an API key or set the VAZE_API_KEY environment variable."
+        "You must provide an API key or headers, or set the VAZE_API_KEY environment variable."
       );
     }
     this.apiKey = apiKey;
+    this.headers = options.headers;
+    this.fetch = options.fetch ?? ((input, init) => fetch(input, init));
     this.vazeUrl = vazeUrl.endsWith("/") ? vazeUrl : `${vazeUrl}/`;
   }
   apiUrl(path, params) {
@@ -51,35 +59,45 @@ var Base = class {
     }
     return url.toString();
   }
+  /** The headers every request carries, for clients fetching an SDK URL themselves. */
+  async authHeaders() {
+    const headers = typeof this.headers === "function" ? await this.headers() : this.headers;
+    return this.apiKey ? { ...headers, "API-Key": this.apiKey } : { ...headers };
+  }
   async request(method, url, body, headers) {
     try {
       const fetchHeaders = {
-        "API-Key": this.apiKey,
+        ...await this.authHeaders(),
         ...headers
       };
       const isFormData = body instanceof FormData;
       if (body !== void 0 && !isFormData && !fetchHeaders["Content-Type"]) {
         fetchHeaders["Content-Type"] = "application/json";
       }
-      const response = await fetch(url, {
+      const response = await this.fetch(url, {
         method,
         headers: fetchHeaders,
         body: isFormData ? body : body !== void 0 ? JSON.stringify(body) : null
       });
+      const { status } = response;
       const contentType = response.headers.get("content-type") ?? "";
       if (!contentType.includes("application/json")) {
         return {
           data: null,
           error: {
-            message: `Unexpected non-JSON response from server (status ${response.status}).`
+            message: `Unexpected non-JSON response from server (status ${status}).`,
+            status
           }
         };
       }
       const result = await response.json();
-      if (!response.ok && !result.error) {
+      if (!response.ok) {
         return {
           data: null,
-          error: { message: `Request failed with status ${response.status}.` }
+          error: {
+            message: result.error?.message ?? `Request failed with status ${status}.`,
+            status
+          }
         };
       }
       return result;
@@ -94,22 +112,25 @@ var Base = class {
   }
   async requestBlob(url, method = "GET", body) {
     try {
-      const headers = { "API-Key": this.apiKey };
+      const headers = await this.authHeaders();
       if (body !== void 0) headers["Content-Type"] = "application/json";
-      const response = await fetch(url, {
+      const response = await this.fetch(url, {
         method,
         headers,
         body: body !== void 0 ? JSON.stringify(body) : null
       });
+      const { status } = response;
       const contentType = response.headers.get("content-type") ?? "";
       if (!response.ok) {
         if (contentType.includes("application/json")) {
           const result = await response.json();
-          if (result.error) return { data: null, error: result.error };
+          if (result.error) {
+            return { data: null, error: { ...result.error, status } };
+          }
         }
         return {
           data: null,
-          error: { message: `Request failed with status ${response.status}.` }
+          error: { message: `Request failed with status ${status}.`, status }
         };
       }
       return {
@@ -133,6 +154,70 @@ var Base = class {
   }
 };
 
+// src/account.ts
+var Account = class extends Base {
+  /** Changes the display name, the sign-in email, or both. */
+  async update(changes) {
+    return await this.request("PUT", this.apiUrl("/api/me"), changes);
+  }
+  async changePassword({
+    currentPassword,
+    newPassword,
+    revokeOtherSessions = false
+  }) {
+    return await this.request("PUT", this.apiUrl("/api/me/password"), {
+      currentPassword,
+      newPassword,
+      revokeOtherSessions
+    });
+  }
+  /** Every device signed in to the account, the current one first. */
+  async getSessions() {
+    return await this.request(
+      "GET",
+      this.apiUrl("/api/me/sessions")
+    );
+  }
+  /** Signs out another device. The current session ends with a sign-out instead. */
+  async revokeSession(id) {
+    return await this.request("DELETE", this.apiUrl("/api/me/sessions"), {
+      id
+    });
+  }
+  /** Signs out every device but the current one. */
+  async revokeOtherSessions() {
+    return await this.request("DELETE", this.apiUrl("/api/me/sessions"), {
+      others: true
+    });
+  }
+};
+
+// src/activity.ts
+var Activity = class extends Base {
+  /** The most recent entries, newest first. */
+  async getAll() {
+    return await this.request(
+      "GET",
+      this.apiUrl("/api/activity")
+    );
+  }
+  async delete(ids) {
+    return await this.request(
+      "DELETE",
+      this.apiUrl("/api/activity"),
+      { ids }
+    );
+  }
+  /** Deletes every entry. Files, keys and accounts are not affected. */
+  async clear() {
+    return await this.request(
+      "DELETE",
+      this.apiUrl("/api/activity"),
+      { all: true }
+    );
+  }
+};
+
 // src/files.ts
 var Files = class extends Base {
   async getAll(options) {
@@ -220,8 +305,15 @@ var Files = class extends Base {
     };
   }
   async download(id) {
-    const url = this.apiUrl(`/api/files/download/${encodeURIComponent(id)}`);
-    return await this.requestBlob(url);
+    return await this.requestBlob(this.downloadUrl(id));
+  }
+  /** Where `download` reads from; fetch it yourself with `authHeaders()`. */
+  downloadUrl(id) {
+    return this.apiUrl(`/api/files/download/${encodeURIComponent(id)}`);
+  }
+  /** A WebP thumbnail of an image file; fetch it with `authHeaders()`. */
+  thumbnailUrl(id) {
+    return this.apiUrl(`/api/files/thumbnail/${encodeURIComponent(id)}`);
   }
   /** Download several files as one zip, with paths below their shared folder. */
   async downloadMany(ids) {
@@ -344,14 +436,140 @@ var Folders = class extends Base {
   }
 };
 
+// src/keys.ts
+var Keys = class extends Base {
+  /** Every key the caller owns, newest first. */
+  async getAll() {
+    return await this.request(
+      "GET",
+      this.apiUrl("/api/keys")
+    );
+  }
+  /** The response holds the key's secret, which can't be read again later. */
+  async create({ name, scopes, expiresAt }) {
+    return await this.request(
+      "POST",
+      this.apiUrl("/api/keys"),
+      {
+        name,
+        scopes,
+        expiresAt: expiresAt instanceof Date ? expiresAt.toISOString() : expiresAt
+      }
+    );
+  }
+  async rename(data) {
+    return await this.request("PUT", this.apiUrl("/api/keys"), data);
+  }
+  /** Revokes the key at once for anything using it. */
+  async delete(id) {
+    return await this.request("DELETE", this.apiUrl("/api/keys"), {
+      id
+    });
+  }
+};
+
+// src/settings.ts
+var Settings = class extends Base {
+  async get() {
+    return await this.request(
+      "GET",
+      this.apiUrl("/api/settings")
+    );
+  }
+  /** Limits left out keep their current values. */
+  async update(changes) {
+    return await this.request(
+      "PUT",
+      this.apiUrl("/api/settings"),
+      changes
+    );
+  }
+  /** Gives every existing file this visibility. */
+  async applyVisibility(visibility) {
+    return await this.request(
+      "POST",
+      this.apiUrl("/api/settings/apply-visibility"),
+      { visibility }
+    );
+  }
+};
+
+// src/users.ts
+var Users = class extends Base {
+  /** Every account, oldest first. */
+  async getAll() {
+    return await this.request(
+      "GET",
+      this.apiUrl("/api/users")
+    );
+  }
+  async create(options) {
+    return await this.request(
+      "POST",
+      this.apiUrl("/api/users"),
+      options
+    );
+  }
+  /** Applies right away, to the user's sessions and API keys alike. */
+  async setAccess({
+    id,
+    role,
+    scopes = []
+  }) {
+    return await this.request(
+      "PUT",
+      this.apiUrl("/api/users"),
+      { id, role, scopes }
+    );
+  }
+  /** Also signs the user out of every device. */
+  async resetPassword({
+    id,
+    password
+  }) {
+    return await this.request(
+      "PUT",
+      this.apiUrl("/api/users"),
+      { id, password }
+    );
+  }
+  /** A disabled user is signed out and their API keys stop until re-enabled. */
+  async setDisabled({
+    id,
+    disabled
+  }) {
+    return await this.request(
+      "PUT",
+      this.apiUrl("/api/users"),
+      { id, disabled }
+    );
+  }
+  /** Removes the account, its API keys and its history. Files stay. */
+  async delete(id) {
+    return await this.request("DELETE", this.apiUrl("/api/users"), {
+      id
+    });
+  }
+};
+
 // src/index.ts
 var Vaze = class extends Base {
   files;
   folders;
+  keys;
+  account;
+  activity;
+  users;
+  settings;
   constructor(options = {}) {
     super(options);
     this.files = new Files(options);
     this.folders = new Folders(options);
+    this.keys = new Keys(options);
+    this.account = new Account(options);
+    this.activity = new Activity(options);
+    this.users = new Users(options);
+    this.settings = new Settings(options);
   }
   async health() {
     return await this.request(
@@ -359,6 +577,35 @@ var Vaze = class extends Base {
       this.apiUrl("/api/health")
     );
   }
+  /** The caller's account and the scopes it may use. */
+  async me() {
+    return await this.request("GET", this.apiUrl("/api/me"));
+  }
+  /** Dashboard numbers, with each section limited to the caller's scopes. */
+  async stats() {
+    const { data, error } = await this.request(
+      "GET",
+      this.apiUrl("/api/stats")
+    );
+    const files = data?.files;
+    return {
+      error,
+      data: data ? {
+        ...data,
+        files: files ? {
+          ...files,
+          largest: constructFileUrls({
+            vazeUrl: this.vazeUrl,
+            files: files.largest
+          }),
+          recent: constructFileUrls({
+            vazeUrl: this.vazeUrl,
+            files: files.recent
+          })
+        } : null
+      } : null
+    };
+  }
 };
 export {
   Vaze as default

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darseen/vaze",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "Vaze Self-Hosted file storage and hosting service SDK.",
   "keywords": [
     "api",