@lacrous/omnicloud 0.2.32 → 0.2.34

package/dist/index.d.cts

@@ -429,6 +429,12 @@ declare class FilesApi {
      * fetch elsewhere.
      */
     upload(input: UploadInput, options?: UploadOptions): Promise<FileDTO$1>;
+    private canStreamFromDisk;
+    /**
+     * Node: streams a file from disk as a multipart body. The file is re-opened on
+     * every attempt, so a retry sends the same bytes without holding them in memory.
+     */
+    private uploadPathOnce;
     private uploadOnce;
     private uploadViaXhr;
     /** Uploads a new version of an existing file. */
@@ -858,6 +864,28 @@ interface BrowserSessionRecord {
     userAgent: string | null;
     ip: string | null;
 }
+interface ApiTokenRecord {
+    id: string;
+    userId: string;
+    name: string;
+    tokenHash: string;
+    createdAt: Date;
+    revokedAt: Date | null;
+    lastUsedAt: Date | null;
+}
+/** Personal API tokens. Holds only token hashes, never raw tokens. */
+interface ApiTokenRepository {
+    create(input: {
+        userId: string;
+        name: string;
+        tokenHash: string;
+    }): Promise<ApiTokenRecord>;
+    findByTokenHash(tokenHash: string): Promise<ApiTokenRecord | null>;
+    findByIdForUser(userId: string, id: string): Promise<ApiTokenRecord | null>;
+    listForUser(userId: string): Promise<ApiTokenRecord[]>;
+    touch(id: string, at: Date): Promise<void>;
+    revoke(id: string, at: Date): Promise<void>;
+}
 /** Server-side browser sessions. Holds only token hashes, never raw tokens. */
 interface BrowserSessionRepository {
     create(input: {
@@ -1061,6 +1089,7 @@ interface Repos {
     users: UserRepository;
     sessions: SessionRepository;
     browserSessions: BrowserSessionRepository;
+    apiTokens: ApiTokenRepository;
     uploadOperations: UploadOperationRepository;
     storages: StorageRepository;
     folders: FolderRepository;

package/dist/index.d.ts

@@ -429,6 +429,12 @@ declare class FilesApi {
      * fetch elsewhere.
      */
     upload(input: UploadInput, options?: UploadOptions): Promise<FileDTO$1>;
+    private canStreamFromDisk;
+    /**
+     * Node: streams a file from disk as a multipart body. The file is re-opened on
+     * every attempt, so a retry sends the same bytes without holding them in memory.
+     */
+    private uploadPathOnce;
     private uploadOnce;
     private uploadViaXhr;
     /** Uploads a new version of an existing file. */
@@ -858,6 +864,28 @@ interface BrowserSessionRecord {
     userAgent: string | null;
     ip: string | null;
 }
+interface ApiTokenRecord {
+    id: string;
+    userId: string;
+    name: string;
+    tokenHash: string;
+    createdAt: Date;
+    revokedAt: Date | null;
+    lastUsedAt: Date | null;
+}
+/** Personal API tokens. Holds only token hashes, never raw tokens. */
+interface ApiTokenRepository {
+    create(input: {
+        userId: string;
+        name: string;
+        tokenHash: string;
+    }): Promise<ApiTokenRecord>;
+    findByTokenHash(tokenHash: string): Promise<ApiTokenRecord | null>;
+    findByIdForUser(userId: string, id: string): Promise<ApiTokenRecord | null>;
+    listForUser(userId: string): Promise<ApiTokenRecord[]>;
+    touch(id: string, at: Date): Promise<void>;
+    revoke(id: string, at: Date): Promise<void>;
+}
 /** Server-side browser sessions. Holds only token hashes, never raw tokens. */
 interface BrowserSessionRepository {
     create(input: {
@@ -1061,6 +1089,7 @@ interface Repos {
     users: UserRepository;
     sessions: SessionRepository;
     browserSessions: BrowserSessionRepository;
+    apiTokens: ApiTokenRepository;
     uploadOperations: UploadOperationRepository;
     storages: StorageRepository;
     folders: FolderRepository;

package/dist/index.js

@@ -14,6 +14,51 @@ var OmniCloudError = class extends Error {
   details;
 };
 var DEFAULT_RETRY = { attempts: 3, baseDelayMs: 300 };
+function randomId() {
+  return globalThis.crypto.randomUUID().replace(/-/g, "");
+}
+function multipartHead(boundary, fields, fileName) {
+  const parts = fields.map(
+    ([name, value]) => `--${boundary}\r
+Content-Disposition: form-data; name="${name}"\r
+\r
+${value}\r
+`
+  );
+  const safeName = fileName.replace(/["\\\r\n]/g, "_");
+  parts.push(
+    `--${boundary}\r
+Content-Disposition: form-data; name="file"; filename="${safeName}"\r
+Content-Type: application/octet-stream\r
+\r
+`
+  );
+  return parts.join("");
+}
+function nodeMultipartStream(head, file, tail) {
+  const encoder = new TextEncoder();
+  const iterator = file[Symbol.asyncIterator]();
+  let sentHead = false;
+  return new ReadableStream({
+    async pull(controller) {
+      if (!sentHead) {
+        sentHead = true;
+        controller.enqueue(encoder.encode(head));
+        return;
+      }
+      const { done, value } = await iterator.next();
+      if (done) {
+        controller.enqueue(encoder.encode(tail));
+        controller.close();
+        return;
+      }
+      controller.enqueue(typeof value === "string" ? encoder.encode(value) : new Uint8Array(value));
+    },
+    async cancel(reason) {
+      await iterator.return?.(reason);
+    }
+  });
+}
 function sleep(ms, signal) {
   return new Promise((resolve, reject) => {
     const timer = setTimeout(resolve, ms);
@@ -305,10 +350,13 @@ var FilesApi = class {
   async upload(input, options = {}) {
     const attempts = Math.max(1, (options.retry ?? 2) + 1);
     let lastError;
-    const blob = await toBlob(input);
+    const source = input.path !== void 0 && this.canStreamFromDisk() ? { kind: "path", path: input.path } : { kind: "blob", blob: await toBlob(input) };
     for (let attempt = 1; attempt <= attempts; attempt += 1) {
       try {
-        return await this.uploadOnce(blob, input.name, options);
+        if (source.kind === "path") {
+          return await this.uploadPathOnce(source.path, input.name, options);
+        }
+        return await this.uploadOnce(source.blob, input.name, options);
       } catch (error) {
         lastError = error;
         if (options.signal?.aborted) throw error;
@@ -318,6 +366,46 @@ var FilesApi = class {
     }
     throw lastError;
   }
+  canStreamFromDisk() {
+    return typeof XMLHttpRequest !== "function" && typeof ReadableStream === "function";
+  }
+  /**
+   * Node: streams a file from disk as a multipart body. The file is re-opened on
+   * every attempt, so a retry sends the same bytes without holding them in memory.
+   */
+  async uploadPathOnce(path, name, options) {
+    const { createReadStream, statSync } = await import("fs");
+    const size = statSync(path).size;
+    const boundary = `omnicloud-${randomId()}`;
+    const fields = [];
+    if (options.folderId) fields.push(["folderId", options.folderId]);
+    const head = multipartHead(boundary, fields, name);
+    const tail = `\r
+--${boundary}--\r
+`;
+    const body = nodeMultipartStream(head, createReadStream(path), tail);
+    const response = await this.client.fetchImpl(`${this.client.baseUrl}/api/files`, {
+      method: "POST",
+      headers: {
+        ...this.client.defaultHeaders,
+        "Content-Type": `multipart/form-data; boundary=${boundary}`,
+        "Content-Length": String(Buffer.byteLength(head) + size + Buffer.byteLength(tail))
+      },
+      body,
+      credentials: "include",
+      duplex: "half"
+    });
+    const text = await response.text();
+    if (!response.ok) {
+      const error = safeJsonParse(text)?.error;
+      throw new OmniCloudError(
+        response.status,
+        error?.code ?? "UPLOAD_FAILED",
+        error?.message ?? `Upload failed (${response.status})`
+      );
+    }
+    return JSON.parse(text).file;
+  }
   async uploadOnce(blob, name, options) {
     const form = new FormData();
     form.append("file", blob, name);
@@ -1318,6 +1406,9 @@ async function resolveItemQuery(folders, userId, input) {
 // ../core/src/services/auth-session-service.ts
 import { createHash as createHash3, randomBytes } from "crypto";
 
+// ../core/src/services/api-token-service.ts
+import { randomBytes as randomBytes2 } from "crypto";
+
 // ../core/src/services/version-retention.ts
 function versionsToPrune(versions, currentVersionId, policy, now) {
   const historical = versions.filter((version) => version.id !== currentVersionId).sort((a, b) => b.versionNumber - a.versionNumber);
@@ -2693,7 +2784,7 @@ import { Transform as Transform2 } from "stream";
 import { pipeline } from "stream/promises";
 
 // ../core/src/utils/secret-box.ts
-import { createCipheriv, createDecipheriv, randomBytes as randomBytes2, scryptSync } from "crypto";
+import { createCipheriv, createDecipheriv, randomBytes as randomBytes3, scryptSync } from "crypto";
 
 // ../telegram/src/client.ts
 import { Api, TelegramClient } from "telegram";