hydrousdb 3.0.2 → 3.5.0

package/dist/index.js

@@ -1,1179 +0,0 @@
-// src/utils/errors.ts
-var HydrousError = class extends Error {
-  constructor(message, code, status, requestId, details) {
-    super(message);
-    this.name = "HydrousError";
-    this.code = code;
-    this.status = status;
-    this.requestId = requestId;
-    this.details = details;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-  toString() {
-    return `HydrousError [${this.code}]: ${this.message}`;
-  }
-};
-var AuthError = class extends HydrousError {
-  constructor(message, code, status, requestId, details) {
-    super(message, code, status, requestId, details);
-    this.name = "AuthError";
-  }
-};
-var RecordError = class extends HydrousError {
-  constructor(message, code, status, requestId, details) {
-    super(message, code, status, requestId, details);
-    this.name = "RecordError";
-  }
-};
-var StorageError = class extends HydrousError {
-  constructor(message, code, status, requestId) {
-    super(message, code, status, requestId);
-    this.name = "StorageError";
-  }
-};
-var AnalyticsError = class extends HydrousError {
-  constructor(message, code, status, requestId) {
-    super(message, code, status, requestId);
-    this.name = "AnalyticsError";
-  }
-};
-var ValidationError = class extends HydrousError {
-  constructor(message, details) {
-    super(message, "VALIDATION_ERROR", 400, void 0, details);
-    this.name = "ValidationError";
-  }
-};
-var NetworkError = class extends HydrousError {
-  constructor(message, cause) {
-    super(message, "NETWORK_ERROR");
-    this.name = "NetworkError";
-    if (cause) this.cause = cause;
-  }
-};
-
-// src/utils/http.ts
-var DEFAULT_BASE_URL = "https://db-api-82687684612.us-central1.run.app";
-var HttpClient = class {
-  constructor(baseUrl) {
-    this.baseUrl = baseUrl.replace(/\/$/, "");
-  }
-  async request(path, apiKeyOrOpts, opts = {}) {
-    let apiKey;
-    let resolvedOpts;
-    if (typeof apiKeyOrOpts === "string") {
-      apiKey = apiKeyOrOpts;
-      resolvedOpts = opts;
-    } else {
-      apiKey = void 0;
-      resolvedOpts = apiKeyOrOpts ?? opts;
-    }
-    const {
-      method = "GET",
-      body,
-      headers = {},
-      rawBody,
-      contentType = "application/json"
-    } = resolvedOpts;
-    const url = `${this.baseUrl}${path}`;
-    const reqHeaders = {
-      ...apiKey ? { "X-Api-Key": apiKey } : {},
-      ...headers
-    };
-    let reqBody = null;
-    if (rawBody !== void 0) {
-      reqBody = rawBody;
-      if (contentType) reqHeaders["Content-Type"] = contentType;
-    } else if (body !== void 0) {
-      reqBody = JSON.stringify(body);
-      reqHeaders["Content-Type"] = "application/json";
-    }
-    let response;
-    try {
-      response = await fetch(url, {
-        method,
-        headers: reqHeaders,
-        body: reqBody
-      });
-    } catch (err) {
-      throw new NetworkError(
-        `Network request failed: ${err instanceof Error ? err.message : String(err)}`,
-        err
-      );
-    }
-    const ct = response.headers.get("content-type") ?? "";
-    if (!ct.includes("application/json")) {
-      if (!response.ok) {
-        throw new HydrousError(
-          `Request failed with status ${response.status}`,
-          `HTTP_${response.status}`,
-          response.status
-        );
-      }
-      const buffer = await response.arrayBuffer();
-      return buffer;
-    }
-    let responseData;
-    try {
-      responseData = await response.json();
-    } catch {
-      throw new HydrousError(
-        "Failed to parse server response as JSON",
-        "PARSE_ERROR",
-        response.status
-      );
-    }
-    if (!response.ok) {
-      const errData = responseData;
-      throw new HydrousError(
-        errData["error"] ?? `Request failed with status ${response.status}`,
-        errData["code"] ?? `HTTP_${response.status}`,
-        response.status,
-        errData["requestId"],
-        errData["details"]
-      );
-    }
-    return responseData;
-  }
-  get(path, apiKey, headers) {
-    return this.request(path, apiKey, { method: "GET", headers });
-  }
-  post(path, apiKey, body, headers) {
-    return this.request(path, apiKey, { method: "POST", body, headers });
-  }
-  put(path, apiKey, body, headers) {
-    return this.request(path, apiKey, { method: "PUT", body, headers });
-  }
-  patch(path, apiKey, body, headers) {
-    return this.request(path, apiKey, { method: "PATCH", body, headers });
-  }
-  delete(path, apiKey, body, headers) {
-    return this.request(path, apiKey, { method: "DELETE", body, headers });
-  }
-  async putToSignedUrl(signedUrl, data, mimeType, onProgress) {
-    const XHR = typeof globalThis["XMLHttpRequest"] !== "undefined" ? globalThis["XMLHttpRequest"] : void 0;
-    if (XHR && onProgress) {
-      return new Promise((resolve, reject) => {
-        const xhr = new XHR();
-        xhr.upload.onprogress = (e) => {
-          if (e.lengthComputable) {
-            onProgress(Math.round(e.loaded / e.total * 100));
-          }
-        };
-        xhr.onload = () => {
-          if (xhr.status >= 200 && xhr.status < 300) {
-            resolve();
-          } else {
-            reject(new Error(`Upload failed: ${xhr.status}`));
-          }
-        };
-        xhr.onerror = () => reject(new Error("Upload network error"));
-        xhr.open("PUT", signedUrl);
-        xhr.setRequestHeader("Content-Type", mimeType);
-        const payload = data instanceof Blob ? data : new Blob([data], { type: mimeType });
-        xhr.send(payload);
-      });
-    }
-    const fetchBody = data instanceof Blob ? data : new Blob([data], { type: mimeType });
-    const response = await fetch(signedUrl, {
-      method: "PUT",
-      headers: { "Content-Type": mimeType },
-      body: fetchBody
-    });
-    if (!response.ok) {
-      throw new NetworkError(`Signed URL upload failed with status ${response.status}`);
-    }
-  }
-};
-
-// src/auth/client.ts
-var AuthClient = class {
-  constructor(http, authKey, bucketKey) {
-    this.http = http;
-    this.authKey = authKey;
-    this.basePath = `/auth/${bucketKey}`;
-  }
-  post(path, body) {
-    return this.http.post(path, this.authKey, body);
-  }
-  get(path) {
-    return this.http.get(path, this.authKey);
-  }
-  patch(path, body) {
-    return this.http.patch(path, this.authKey, body);
-  }
-  delete(path, body) {
-    return this.http.delete(path, this.authKey, body);
-  }
-  // ─── Registration & Login ─────────────────────────────────────────────────
-  async signup(options) {
-    const result = await this.post(`${this.basePath}/signup`, options);
-    return { user: result.user, session: result.session };
-  }
-  async login(options) {
-    const result = await this.post(`${this.basePath}/login`, options);
-    return { user: result.user, session: result.session };
-  }
-  async logout({ sessionId }) {
-    await this.post(`${this.basePath}/logout`, { sessionId });
-  }
-  async refreshSession({ refreshToken }) {
-    const result = await this.post(`${this.basePath}/session/refresh`, { refreshToken });
-    return result.session;
-  }
-  // ─── User Profile ─────────────────────────────────────────────────────────
-  async getUser({ userId }) {
-    const result = await this.get(`${this.basePath}/user/${userId}`);
-    return result.user;
-  }
-  async updateUser(options) {
-    const { sessionId, userId, data } = options;
-    const result = await this.patch(`${this.basePath}/user`, { sessionId, userId, ...data });
-    return result.user;
-  }
-  async deleteUser({ sessionId, userId }) {
-    await this.delete(`${this.basePath}/user`, { sessionId, userId });
-  }
-  // ─── Admin Operations ─────────────────────────────────────────────────────
-  async listUsers(options) {
-    const { sessionId, limit = 50, offset = 0 } = options;
-    const result = await this.post(
-      `${this.basePath}/users/list`,
-      { sessionId, limit, offset }
-    );
-    return { users: result.users, total: result.total, limit: result.limit, offset: result.offset };
-  }
-  async hardDeleteUser({ sessionId, userId }) {
-    await this.delete(`${this.basePath}/user/hard`, { sessionId, userId });
-  }
-  async bulkDeleteUsers({ sessionId, userIds }) {
-    const result = await this.post(
-      `${this.basePath}/users/bulk-delete`,
-      { sessionId, userIds }
-    );
-    return { deleted: result.deleted, failed: result.failed };
-  }
-  async lockAccount({ sessionId, userId, duration }) {
-    const result = await this.post(
-      `${this.basePath}/account/lock`,
-      { sessionId, userId, duration }
-    );
-    return result.data;
-  }
-  async unlockAccount({ sessionId, userId }) {
-    await this.post(`${this.basePath}/account/unlock`, { sessionId, userId });
-  }
-  // ─── Password Management ──────────────────────────────────────────────────
-  async changePassword(options) {
-    await this.post(`${this.basePath}/password/change`, options);
-  }
-  async requestPasswordReset({ email }) {
-    await this.post(`${this.basePath}/password/reset/request`, { email });
-  }
-  async confirmPasswordReset({ resetToken, newPassword }) {
-    await this.post(`${this.basePath}/password/reset/confirm`, { resetToken, newPassword });
-  }
-  // ─── Email Verification ───────────────────────────────────────────────────
-  async requestEmailVerification({ userId }) {
-    await this.post(`${this.basePath}/email/verify/request`, { userId });
-  }
-  async confirmEmailVerification({ verifyToken }) {
-    await this.post(`${this.basePath}/email/verify/confirm`, { verifyToken });
-  }
-};
-
-// src/utils/query.ts
-function buildQueryParams(options = {}) {
-  const params = new URLSearchParams();
-  if (options.limit !== void 0) params.set("limit", String(options.limit));
-  if (options.offset !== void 0) params.set("offset", String(options.offset));
-  if (options.orderBy !== void 0) params.set("orderBy", options.orderBy);
-  if (options.order !== void 0) params.set("order", options.order);
-  if (options.fields !== void 0) params.set("fields", options.fields);
-  if (options.startAfter !== void 0) params.set("startAfter", options.startAfter);
-  if (options.startAt !== void 0) params.set("startAt", options.startAt);
-  if (options.endAt !== void 0) params.set("endAt", options.endAt);
-  if (options.dateRange?.start !== void 0)
-    params.set("startDate", new Date(options.dateRange.start).toISOString().split("T")[0]);
-  if (options.dateRange?.end !== void 0)
-    params.set("endDate", new Date(options.dateRange.end).toISOString().split("T")[0]);
-  if (options.filters && options.filters.length > 0) {
-    params.set("filters", JSON.stringify(options.filters));
-  }
-  const str = params.toString();
-  return str ? `?${str}` : "";
-}
-function guessMimeType(filename) {
-  const ext = filename.split(".").pop()?.toLowerCase();
-  const map = {
-    jpg: "image/jpeg",
-    jpeg: "image/jpeg",
-    png: "image/png",
-    gif: "image/gif",
-    webp: "image/webp",
-    svg: "image/svg+xml",
-    pdf: "application/pdf",
-    mp4: "video/mp4",
-    webm: "video/webm",
-    mp3: "audio/mpeg",
-    wav: "audio/wav",
-    txt: "text/plain",
-    html: "text/html",
-    css: "text/css",
-    js: "application/javascript",
-    json: "application/json",
-    xml: "application/xml",
-    zip: "application/zip",
-    csv: "text/csv"
-  };
-  return map[ext ?? ""] ?? "application/octet-stream";
-}
-function assertSafeName(name, label = "name") {
-  if (!/^[a-zA-Z_][a-zA-Z0-9_.\-]{0,200}$/.test(name)) {
-    throw new Error(
-      `Invalid ${label} "${name}". Must start with a letter or underscore and contain only letters, numbers, underscores, dots, or hyphens.`
-    );
-  }
-}
-
-// src/records/client.ts
-var RecordsClient = class {
-  constructor(http, bucketSecurityKey, bucketKey) {
-    assertSafeName(bucketKey, "bucketKey");
-    this.http = http;
-    this.bucketKey = bucketKey;
-    this.bucketKey_ = bucketSecurityKey;
-    this.basePath = `/records/${bucketKey}`;
-  }
-  get key() {
-    return this.bucketKey_;
-  }
-  // ─── Single Record Operations ─────────────────────────────────────────────
-  async create(data) {
-    const result = await this.http.post(this.basePath, this.key, data);
-    return result.record ?? result.data;
-  }
-  async get(id) {
-    const result = await this.http.get(`${this.basePath}/${id}`, this.key);
-    return result.record ?? result.data;
-  }
-  async set(id, data) {
-    const result = await this.http.put(`${this.basePath}/${id}`, this.key, data);
-    return result.record ?? result.data;
-  }
-  async patch(id, data, options = {}) {
-    const { merge = true } = options;
-    const result = await this.http.patch(
-      `${this.basePath}/${id}`,
-      this.key,
-      { ...data, _merge: merge }
-    );
-    return result.record ?? result.data;
-  }
-  async delete(id) {
-    await this.http.delete(`${this.basePath}/${id}`, this.key);
-  }
-  // ─── Batch Operations ─────────────────────────────────────────────────────
-  async batchCreate(items) {
-    const result = await this.http.post(
-      `${this.basePath}/batch`,
-      this.key,
-      { records: items }
-    );
-    return result.records;
-  }
-  async batchDelete(ids) {
-    const result = await this.http.post(
-      `${this.basePath}/batch/delete`,
-      this.key,
-      { ids }
-    );
-    return { deleted: result.deleted, failed: result.failed };
-  }
-  // ─── Querying ─────────────────────────────────────────────────────────────
-  async query(options = {}) {
-    const qs = buildQueryParams(options);
-    const result = await this.http.get(`${this.basePath}${qs}`, this.key);
-    return {
-      records: result.records,
-      total: result.total,
-      hasMore: result.hasMore,
-      nextCursor: result.nextCursor
-    };
-  }
-  async getAll(options = {}) {
-    const { records } = await this.query(options);
-    return records;
-  }
-  async count(filters = []) {
-    const result = await this.http.post(
-      `${this.basePath}/count`,
-      this.key,
-      { filters }
-    );
-    return result.count;
-  }
-  // ─── Version History ──────────────────────────────────────────────────────
-  async getHistory(id) {
-    const result = await this.http.get(`${this.basePath}/${id}/history`, this.key);
-    return result.history;
-  }
-  async restoreVersion(id, version) {
-    const result = await this.http.post(
-      `${this.basePath}/${id}/restore`,
-      this.key,
-      { version }
-    );
-    return result.record ?? result.data;
-  }
-};
-
-// src/analytics/client.ts
-var AnalyticsClient = class {
-  constructor(http, bucketSecurityKey, bucketKey) {
-    assertSafeName(bucketKey, "bucketKey");
-    this.http = http;
-    this.bucketSecurityKey = bucketSecurityKey;
-    this.basePath = `/analytics/${bucketKey}`;
-  }
-  async run(query) {
-    const result = await this.http.post(
-      this.basePath,
-      this.bucketSecurityKey,
-      query
-    );
-    return result.data;
-  }
-  async count(opts = {}) {
-    return this.run({ queryType: "count", ...opts });
-  }
-  async distribution(opts) {
-    assertSafeName(opts.field, "field");
-    return this.run({ queryType: "distribution", ...opts });
-  }
-  async sum(opts) {
-    assertSafeName(opts.field, "field");
-    if (opts.groupBy) assertSafeName(opts.groupBy, "groupBy");
-    return this.run({ queryType: "sum", ...opts });
-  }
-  async timeSeries(opts = {}) {
-    return this.run({ queryType: "timeSeries", granularity: "day", ...opts });
-  }
-  async fieldTimeSeries(opts) {
-    assertSafeName(opts.field, "field");
-    return this.run({ queryType: "fieldTimeSeries", aggregation: "sum", granularity: "day", ...opts });
-  }
-  async topN(opts) {
-    assertSafeName(opts.field, "field");
-    if (opts.labelField) assertSafeName(opts.labelField, "labelField");
-    return this.run({ queryType: "topN", n: 10, order: "desc", ...opts });
-  }
-  async stats(opts) {
-    assertSafeName(opts.field, "field");
-    return this.run({ queryType: "stats", ...opts });
-  }
-  async records(opts = {}) {
-    if (opts.orderBy) assertSafeName(opts.orderBy, "orderBy");
-    if (opts.selectFields) opts.selectFields.forEach((f) => assertSafeName(f, "selectField"));
-    return this.run({ queryType: "records", limit: 100, order: "desc", ...opts });
-  }
-  async multiMetric(opts) {
-    opts.metrics.forEach((m) => {
-      assertSafeName(m.field, "metric.field");
-      assertSafeName(m.name, "metric.name");
-    });
-    return this.run({ queryType: "multiMetric", ...opts });
-  }
-  async storageStats(opts = {}) {
-    return this.run({ queryType: "storageStats", ...opts });
-  }
-  async crossBucket(opts) {
-    assertSafeName(opts.field, "field");
-    opts.bucketKeys.forEach((k) => assertSafeName(k, "bucketKey"));
-    return this.run({ queryType: "crossBucket", aggregation: "sum", ...opts });
-  }
-  async query(query) {
-    const data = await this.run(query);
-    return { queryType: query.queryType, data };
-  }
-};
-
-// src/storage/manager.ts
-var StorageManager = class {
-  constructor(http, storageKey) {
-    this.basePath = "/storage";
-    this.http = http;
-    this.storageKey = storageKey;
-  }
-  /** Headers for all storage requests — uses X-Storage-Key, not X-Api-Key. */
-  get authHeaders() {
-    return { "X-Storage-Key": this.storageKey };
-  }
-  // ─── Upload: Simple (server-buffered) ────────────────────────────────────
-  /**
-   * Upload a file to storage in one step (server-buffered, up to 500 MB).
-   * For files >10 MB or when you need upload progress, use `getUploadUrl()` instead.
-   *
-   * @param data     File data as a Blob, Buffer, Uint8Array, or ArrayBuffer.
-   * @param path     Destination path in your storage (e.g. `"avatars/alice.jpg"`).
-   * @param options  Upload options: isPublic, overwrite, mimeType.
-   *
-   * @example
-   * ```ts
-   * // Upload a public avatar
-   * const result = await storage.upload(file, 'avatars/alice.jpg', { isPublic: true });
-   * console.log(result.publicUrl); // → https://...
-   *
-   * // Upload a private document
-   * const result = await storage.upload(pdfBuffer, 'docs/contract.pdf');
-   * console.log(result.downloadUrl); // → /storage/download/docs/contract.pdf
-   * ```
-   */
-  async upload(data, path, options = {}) {
-    const { isPublic = false, overwrite = false, mimeType } = options;
-    const mime = mimeType ?? guessMimeType(path);
-    const formData = new FormData();
-    const blob = data instanceof Blob ? data : new Blob([data], { type: mime });
-    formData.append("file", blob, path.split("/").pop() ?? "file");
-    formData.append("path", path);
-    formData.append("mimeType", mime);
-    formData.append("isPublic", String(isPublic));
-    formData.append("overwrite", String(overwrite));
-    const result = await this.http.request(`${this.basePath}/upload`, {
-      method: "POST",
-      rawBody: formData,
-      headers: this.authHeaders
-    });
-    return {
-      path: result.path,
-      mimeType: result.mimeType,
-      size: result.size,
-      isPublic: result.isPublic,
-      publicUrl: result.publicUrl,
-      downloadUrl: result.downloadUrl
-    };
-  }
-  /**
-   * Upload raw JSON or plain text data as a file.
-   *
-   * @example
-   * ```ts
-   * const result = await storage.uploadRaw(
-   *   { config: { theme: 'dark' } },
-   *   'settings/user-config.json',
-   *   { isPublic: false },
-   * );
-   * ```
-   */
-  async uploadRaw(data, path, options = {}) {
-    const { isPublic = false, overwrite = false, mimeType = "application/json" } = options;
-    const body = typeof data === "string" ? data : JSON.stringify(data);
-    const result = await this.http.request(`${this.basePath}/upload-raw`, {
-      method: "POST",
-      body: { path, data: body, mimeType, isPublic, overwrite },
-      headers: this.authHeaders
-    });
-    return {
-      path: result.path,
-      mimeType: result.mimeType,
-      size: result.size,
-      isPublic: result.isPublic,
-      publicUrl: result.publicUrl,
-      downloadUrl: result.downloadUrl
-    };
-  }
-  // ─── Upload: Direct-to-GCS (recommended for large files) ─────────────────
-  /**
-   * Step 1 of the recommended upload flow.
-   * Get a signed URL to upload directly to GCS from the client (supports progress).
-   *
-   * @example
-   * ```ts
-   * const { uploadUrl, path: confirmedPath } = await storage.getUploadUrl({
-   *   path: 'videos/intro.mp4',
-   *   mimeType: 'video/mp4',
-   *   size: file.size,
-   *   isPublic: true,
-   * });
-   *
-   * // Upload using XHR for progress tracking
-   * await storage.uploadToSignedUrl(uploadUrl, file, 'video/mp4', (pct) => {
-   *   console.log(`${pct}% uploaded`);
-   * });
-   *
-   * // Step 3: confirm
-   * const result = await storage.confirmUpload({ path: confirmedPath, mimeType: 'video/mp4', isPublic: true });
-   * ```
-   */
-  async getUploadUrl(opts) {
-    const result = await this.http.request(`${this.basePath}/upload-url`, {
-      method: "POST",
-      body: { isPublic: false, overwrite: false, expiresInSeconds: 900, ...opts },
-      headers: this.authHeaders
-    });
-    return result;
-  }
-  /**
-   * Upload data directly to a signed GCS URL (no auth headers needed).
-   * Optionally tracks progress via a callback.
-   *
-   * @param signedUrl  The URL returned by `getUploadUrl()`.
-   * @param data       File data.
-   * @param mimeType   Must match what was used in `getUploadUrl()`.
-   * @param onProgress Optional callback called with 0–100 progress percentage.
-   */
-  async uploadToSignedUrl(signedUrl, data, mimeType, onProgress) {
-    await this.http.putToSignedUrl(signedUrl, data, mimeType, onProgress);
-  }
-  /**
-   * Step 3 of the recommended upload flow.
-   * Confirm a direct upload and register metadata on the server.
-   *
-   * @example
-   * ```ts
-   * const result = await storage.confirmUpload({
-   *   path: 'videos/intro.mp4',
-   *   mimeType: 'video/mp4',
-   *   isPublic: true,
-   * });
-   * console.log(result.publicUrl);
-   * ```
-   */
-  async confirmUpload(opts) {
-    const result = await this.http.request(`${this.basePath}/confirm`, {
-      method: "POST",
-      body: { isPublic: false, ...opts },
-      headers: this.authHeaders
-    });
-    return {
-      path: result.path,
-      mimeType: result.mimeType,
-      size: result.size,
-      isPublic: result.isPublic,
-      publicUrl: result.publicUrl,
-      downloadUrl: result.downloadUrl
-    };
-  }
-  // ─── Batch Upload ─────────────────────────────────────────────────────────
-  /**
-   * Get signed upload URLs for multiple files at once.
-   *
-   * @example
-   * ```ts
-   * const { files } = await storage.getBatchUploadUrls([
-   *   { path: 'images/photo1.jpg', mimeType: 'image/jpeg', size: 204800 },
-   *   { path: 'images/photo2.jpg', mimeType: 'image/jpeg', size: 153600 },
-   * ]);
-   *
-   * // Upload each file and confirm
-   * for (const f of files) {
-   *   await storage.uploadToSignedUrl(f.uploadUrl, blobs[f.index], f.mimeType);
-   *   await storage.confirmUpload({ path: f.path, mimeType: f.mimeType });
-   * }
-   * ```
-   */
-  async getBatchUploadUrls(files) {
-    const result = await this.http.request(
-      `${this.basePath}/batch-upload-urls`,
-      { method: "POST", body: { files }, headers: this.authHeaders }
-    );
-    return { files: result.files };
-  }
-  /**
-   * Confirm multiple direct uploads at once.
-   */
-  async batchConfirmUploads(items) {
-    const result = await this.http.request(
-      `${this.basePath}/batch-confirm`,
-      { method: "POST", body: { files: items }, headers: this.authHeaders }
-    );
-    return result.files.map((r) => ({
-      path: r.path,
-      mimeType: r.mimeType,
-      size: r.size,
-      isPublic: r.isPublic,
-      publicUrl: r.publicUrl,
-      downloadUrl: r.downloadUrl
-    }));
-  }
-  // ─── Download ─────────────────────────────────────────────────────────────
-  /**
-   * Download a private file as an ArrayBuffer.
-   * For public files, use the `publicUrl` directly — no SDK needed.
-   *
-   * @example
-   * ```ts
-   * const buffer = await storage.download('docs/contract.pdf');
-   * const blob = new Blob([buffer], { type: 'application/pdf' });
-   * // Open in browser:
-   * window.open(URL.createObjectURL(blob));
-   * ```
-   */
-  async download(path) {
-    const encoded = path.split("/").map(encodeURIComponent).join("/");
-    return this.http.request(`${this.basePath}/download/${encoded}`, {
-      method: "GET",
-      headers: this.authHeaders
-    });
-  }
-  /**
-   * Download multiple files at once, returned as a JSON map of `{ path: base64 }`.
-   *
-   * @example
-   * ```ts
-   * const files = await storage.batchDownload(['docs/a.pdf', 'docs/b.pdf']);
-   * ```
-   */
-  async batchDownload(paths) {
-    const result = await this.http.request(
-      `${this.basePath}/batch-download`,
-      { method: "POST", body: { paths }, headers: this.authHeaders }
-    );
-    return result.files;
-  }
-  // ─── List ─────────────────────────────────────────────────────────────────
-  /**
-   * List files and folders at a given path prefix.
-   *
-   * @example
-   * ```ts
-   * // List everything in the root
-   * const { files, folders } = await storage.list();
-   *
-   * // List a specific folder
-   * const { files, folders, hasMore, nextCursor } = await storage.list({
-   *   prefix: 'avatars/',
-   *   limit: 20,
-   * });
-   *
-   * // Next page
-   * const page2 = await storage.list({ prefix: 'avatars/', cursor: nextCursor });
-   * ```
-   */
-  async list(opts = {}) {
-    const params = new URLSearchParams();
-    if (opts.prefix) params.set("prefix", opts.prefix);
-    if (opts.limit) params.set("limit", String(opts.limit));
-    if (opts.cursor) params.set("cursor", opts.cursor);
-    if (opts.recursive) params.set("recursive", "true");
-    const qs = params.toString() ? `?${params}` : "";
-    const result = await this.http.request(`${this.basePath}/list${qs}`, {
-      method: "GET",
-      headers: this.authHeaders
-    });
-    return {
-      files: result.files,
-      folders: result.folders,
-      hasMore: result.hasMore,
-      nextCursor: result.nextCursor
-    };
-  }
-  // ─── Metadata ─────────────────────────────────────────────────────────────
-  /**
-   * Get metadata for a file (size, MIME type, visibility, URLs).
-   *
-   * @example
-   * ```ts
-   * const meta = await storage.getMetadata('avatars/alice.jpg');
-   * console.log(meta.size, meta.isPublic, meta.publicUrl);
-   * ```
-   */
-  async getMetadata(path) {
-    const encoded = path.split("/").map(encodeURIComponent).join("/");
-    const result = await this.http.request(
-      `${this.basePath}/metadata/${encoded}`,
-      { method: "GET", headers: this.authHeaders }
-    );
-    return {
-      path: result.path,
-      size: result.size,
-      mimeType: result.mimeType,
-      isPublic: result.isPublic,
-      publicUrl: result.publicUrl,
-      downloadUrl: result.downloadUrl,
-      createdAt: result.createdAt,
-      updatedAt: result.updatedAt
-    };
-  }
-  // ─── Signed URL (time-limited share) ─────────────────────────────────────
-  /**
-   * Generate a time-limited download URL for a private file.
-   * The URL can be shared externally without requiring an `X-Storage-Key`.
-   *
-   * > **Note:** Downloads via signed URLs bypass the server, so download stats
-   * > are NOT tracked. Use `downloadUrl` for tracked downloads.
-   *
-   * @param path       Path to the file.
-   * @param expiresIn  URL lifetime in seconds (default 3600 = 1 hour).
-   *
-   * @example
-   * ```ts
-   * const { signedUrl, expiresAt } = await storage.getSignedUrl('docs/invoice.pdf', 1800);
-   * // Share signedUrl with the recipient — it expires in 30 minutes.
-   * ```
-   */
-  async getSignedUrl(path, expiresIn = 3600) {
-    const result = await this.http.request(`${this.basePath}/signed-url`, {
-      method: "POST",
-      body: { path, expiresIn },
-      headers: this.authHeaders
-    });
-    return {
-      signedUrl: result.signedUrl,
-      expiresAt: result.expiresAt,
-      expiresIn: result.expiresIn,
-      path: result.path
-    };
-  }
-  // ─── Visibility ───────────────────────────────────────────────────────────
-  /**
-   * Change a file's visibility between public and private after upload.
-   *
-   * @example
-   * ```ts
-   * // Make a file public
-   * const result = await storage.setVisibility('avatars/alice.jpg', true);
-   * console.log(result.publicUrl); // CDN URL
-   *
-   * // Make a file private
-   * const result = await storage.setVisibility('avatars/alice.jpg', false);
-   * console.log(result.downloadUrl); // Auth-required URL
-   * ```
-   */
-  async setVisibility(path, isPublic) {
-    const result = await this.http.request(`${this.basePath}/visibility`, {
-      method: "PATCH",
-      body: { path, isPublic },
-      headers: this.authHeaders
-    });
-    return {
-      path: result.path,
-      isPublic: result.isPublic,
-      publicUrl: result.publicUrl,
-      downloadUrl: result.downloadUrl
-    };
-  }
-  // ─── Folder Operations ────────────────────────────────────────────────────
-  /**
-   * Create a folder (a GCS prefix placeholder).
-   *
-   * @example
-   * ```ts
-   * await storage.createFolder('uploads/2025/');
-   * ```
-   */
-  async createFolder(path) {
-    const result = await this.http.request(
-      `${this.basePath}/folder`,
-      { method: "POST", body: { path }, headers: this.authHeaders }
-    );
-    return { path: result.path };
-  }
-  // ─── File Operations ──────────────────────────────────────────────────────
-  /**
-   * Delete a single file.
-   *
-   * @example
-   * ```ts
-   * await storage.deleteFile('avatars/old-avatar.jpg');
-   * ```
-   */
-  async deleteFile(path) {
-    await this.http.request(`${this.basePath}/file`, {
-      method: "DELETE",
-      body: { path },
-      headers: this.authHeaders
-    });
-  }
-  /**
-   * Delete a folder and all its contents recursively.
-   *
-   * @example
-   * ```ts
-   * await storage.deleteFolder('temp/');
-   * ```
-   */
-  async deleteFolder(path) {
-    await this.http.request(`${this.basePath}/folder`, {
-      method: "DELETE",
-      body: { path },
-      headers: this.authHeaders
-    });
-  }
-  /**
-   * Move or rename a file.
-   *
-   * @example
-   * ```ts
-   * // Rename
-   * await storage.move('docs/draft.pdf', 'docs/final.pdf');
-   * // Move to a different folder
-   * await storage.move('inbox/report.xlsx', 'archive/2025/report.xlsx');
-   * ```
-   */
-  async move(from, to) {
-    const result = await this.http.request(
-      `${this.basePath}/move`,
-      { method: "POST", body: { from, to }, headers: this.authHeaders }
-    );
-    return { from: result.from, to: result.to };
-  }
-  /**
-   * Copy a file to a new path.
-   *
-   * @example
-   * ```ts
-   * await storage.copy('templates/base.html', 'sites/my-site/index.html');
-   * ```
-   */
-  async copy(from, to) {
-    const result = await this.http.request(
-      `${this.basePath}/copy`,
-      { method: "POST", body: { from, to }, headers: this.authHeaders }
-    );
-    return { from: result.from, to: result.to };
-  }
-  // ─── Stats ────────────────────────────────────────────────────────────────
-  /**
-   * Get storage statistics for your key: total files, bytes, operation counts.
-   *
-   * @example
-   * ```ts
-   * const stats = await storage.getStats();
-   * console.log(`${stats.totalFiles} files, ${(stats.totalBytes / 1e6).toFixed(1)} MB`);
-   * ```
-   */
-  async getStats() {
-    const result = await this.http.request(`${this.basePath}/stats`, {
-      method: "GET",
-      headers: this.authHeaders
-    });
-    return result.stats;
-  }
-  // ─── Info (no auth) ───────────────────────────────────────────────────────
-  /**
-   * Ping the storage service. No authentication required.
-   *
-   * @example
-   * ```ts
-   * const info = await storage.info();
-   * // → { ok: true, storageRoot: 'hydrous-storage' }
-   * ```
-   */
-  async info() {
-    return this.http.get(`${this.basePath}/info`);
-  }
-};
-
-// src/storage/scoped.ts
-var ScopedStorage = class _ScopedStorage {
-  constructor(manager, prefix) {
-    this.manager = manager;
-    this.prefix = prefix.replace(/\/+$/, "") + "/";
-  }
-  scopedPath(userPath) {
-    return `${this.prefix}${userPath.replace(/^\/+/, "")}`;
-  }
-  /** Upload a file within the scoped folder. */
-  upload(data, path, options) {
-    return this.manager.upload(data, this.scopedPath(path), options);
-  }
-  /** Upload raw JSON or text within the scoped folder. */
-  uploadRaw(data, path, options) {
-    return this.manager.uploadRaw(data, this.scopedPath(path), options);
-  }
-  /** Get a signed upload URL for a file within the scoped folder. */
-  getUploadUrl(opts) {
-    return this.manager.getUploadUrl({ ...opts, path: this.scopedPath(opts.path) });
-  }
-  /** Confirm a direct upload within the scoped folder. */
-  confirmUpload(opts) {
-    return this.manager.confirmUpload({ ...opts, path: this.scopedPath(opts.path) });
-  }
-  /** Download a file within the scoped folder. */
-  download(path) {
-    return this.manager.download(this.scopedPath(path));
-  }
-  /**
-   * List files within the scoped folder.
-   * `prefix` in options is relative to the scope.
-   */
-  list(opts = {}) {
-    const scopedOpts = {
-      ...opts,
-      prefix: this.scopedPath(opts.prefix ?? "")
-    };
-    return this.manager.list(scopedOpts);
-  }
-  /** Get metadata for a file within the scoped folder. */
-  getMetadata(path) {
-    return this.manager.getMetadata(this.scopedPath(path));
-  }
-  /** Get a time-limited signed URL for a file within the scoped folder. */
-  getSignedUrl(path, expiresIn) {
-    return this.manager.getSignedUrl(this.scopedPath(path), expiresIn);
-  }
-  /** Change visibility of a file within the scoped folder. */
-  setVisibility(path, isPublic) {
-    return this.manager.setVisibility(this.scopedPath(path), isPublic);
-  }
-  /** Delete a file within the scoped folder. */
-  deleteFile(path) {
-    return this.manager.deleteFile(this.scopedPath(path));
-  }
-  /** Delete a sub-folder within the scoped folder. */
-  deleteFolder(path) {
-    return this.manager.deleteFolder(this.scopedPath(path));
-  }
-  /** Move a file within the scoped folder. */
-  move(from, to) {
-    return this.manager.move(this.scopedPath(from), this.scopedPath(to));
-  }
-  /** Copy a file within the scoped folder. */
-  copy(from, to) {
-    return this.manager.copy(this.scopedPath(from), this.scopedPath(to));
-  }
-  /** Create a sub-folder within the scoped folder. */
-  createFolder(path) {
-    return this.manager.createFolder(this.scopedPath(path));
-  }
-  /**
-   * Create a further-scoped instance nested within this scope.
-   *
-   * @example
-   * ```ts
-   * const uploads = db.storage.scope('user-uploads');
-   * const images = uploads.scope('images');   // → "user-uploads/images/"
-   * ```
-   */
-  scope(subPrefix) {
-    return new _ScopedStorage(this.manager, this.scopedPath(subPrefix));
-  }
-};
-
-// src/client.ts
-var HydrousClient = class {
-  constructor(config) {
-    this._recordsCache = /* @__PURE__ */ new Map();
-    this._authCache = /* @__PURE__ */ new Map();
-    this._analyticsCache = /* @__PURE__ */ new Map();
-    this._storageCache = /* @__PURE__ */ new Map();
-    if (!config.authKey) {
-      throw new Error("[HydrousDB] authKey is required. Get yours from https://hydrousdb.com/dashboard.");
-    }
-    if (!config.bucketSecurityKey) {
-      throw new Error("[HydrousDB] bucketSecurityKey is required. Get yours from https://hydrousdb.com/dashboard.");
-    }
-    if (!config.storageKeys || Object.keys(config.storageKeys).length === 0) {
-      throw new Error("[HydrousDB] storageKeys is required. Define at least one storage key from https://hydrousdb.com/dashboard.");
-    }
-    const baseUrl = config.baseUrl ?? DEFAULT_BASE_URL;
-    this.http = new HttpClient(baseUrl);
-    this.authKey_ = config.authKey;
-    this.bucketSecurityKey_ = config.bucketSecurityKey;
-    this.storageKeys_ = config.storageKeys;
-  }
-  // ─── Records ─────────────────────────────────────────────────────────────
-  /**
-   * Get a typed records client for the named bucket.
-   * Uses your `bucketSecurityKey` automatically.
-   *
-   * @example
-   * ```ts
-   * interface Post { title: string; published: boolean }
-   * const posts = db.records<Post>('blog-posts');
-   * const post = await posts.create({ title: 'Hello', published: false });
-   * ```
-   */
-  records(bucketKey) {
-    if (!this._recordsCache.has(bucketKey)) {
-      this._recordsCache.set(
-        bucketKey,
-        new RecordsClient(this.http, this.bucketSecurityKey_, bucketKey)
-      );
-    }
-    return this._recordsCache.get(bucketKey);
-  }
-  // ─── Auth ─────────────────────────────────────────────────────────────────
-  /**
-   * Get an auth client for the named user bucket.
-   * Uses your `authKey` automatically.
-   *
-   * @example
-   * ```ts
-   * const auth = db.auth('app-users');
-   * const { user, session } = await auth.login({ email: '…', password: '…' });
-   * ```
-   */
-  auth(bucketKey) {
-    if (!this._authCache.has(bucketKey)) {
-      this._authCache.set(bucketKey, new AuthClient(this.http, this.authKey_, bucketKey));
-    }
-    return this._authCache.get(bucketKey);
-  }
-  // ─── Analytics ────────────────────────────────────────────────────────────
-  /**
-   * Get an analytics client for the named bucket.
-   * Uses your `bucketSecurityKey` automatically.
-   *
-   * @example
-   * ```ts
-   * const analytics = db.analytics('orders');
-   * const { count } = await analytics.count();
-   * ```
-   */
-  analytics(bucketKey) {
-    if (!this._analyticsCache.has(bucketKey)) {
-      this._analyticsCache.set(
-        bucketKey,
-        new AnalyticsClient(this.http, this.bucketSecurityKey_, bucketKey)
-      );
-    }
-    return this._analyticsCache.get(bucketKey);
-  }
-  // ─── Storage ──────────────────────────────────────────────────────────────
-  /**
-   * Get a storage manager for the named storage key.
-   * The name must match a key you defined in `storageKeys` when calling `createClient`.
-   * Uses the corresponding `ssk_…` key automatically via `X-Storage-Key` header.
-   *
-   * @param keyName  The name of the storage key (e.g. `"avatars"`, `"documents"`, `"main"`).
-   *
-   * @example
-   * ```ts
-   * const avatars   = db.storage('avatars');
-   * const documents = db.storage('documents');
-   *
-   * // Upload to avatars bucket
-   * await avatars.upload(file, `${userId}.jpg`, { isPublic: true });
-   *
-   * // Scope to a sub-folder
-   * const userDocs = db.storage('documents').scope(`users/${userId}`);
-   * await userDocs.upload(pdfBuffer, 'contract.pdf');
-   * ```
-   */
-  storage(keyName) {
-    const ssk = this.storageKeys_[keyName];
-    if (!ssk) {
-      const available = Object.keys(this.storageKeys_).join(", ");
-      throw new Error(
-        `[HydrousDB] Unknown storage key name "${keyName}". Available keys: ${available}. Add it to storageKeys in your createClient() config.`
-      );
-    }
-    if (!this._storageCache.has(keyName)) {
-      this._storageCache.set(keyName, new StorageManager(this.http, ssk));
-    }
-    const mgr = this._storageCache.get(keyName);
-    const extended = mgr;
-    if (!extended.scope) {
-      extended.scope = (prefix) => new ScopedStorage(mgr, prefix);
-    }
-    return extended;
-  }
-};
-function createClient(config) {
-  return new HydrousClient(config);
-}
-
-export { AnalyticsClient, AnalyticsError, AuthClient, AuthError, HydrousClient, HydrousError, NetworkError, RecordError, RecordsClient, ScopedStorage, StorageError, StorageManager, ValidationError, createClient };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map