@directus/storage-driver-supabase 2.0.2 → 2.1.1

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Driver, ReadOptions } from '@directus/storage';
+import { TusDriver, ReadOptions, ChunkedUploadContext } from '@directus/storage';
 import { Readable } from 'node:stream';
 
 type DriverSupabaseConfig = {
@@ -8,17 +8,22 @@ type DriverSupabaseConfig = {
     /** Allows a custom Supabase endpoint for self-hosting */
     endpoint?: string;
     root?: string;
+    tus?: {
+        chunkSize?: number;
+    };
 };
-declare class DriverSupabase implements Driver {
+declare class DriverSupabase implements TusDriver {
     private config;
     private client;
     private bucket;
+    private readonly preferredChunkSize;
     constructor(config: DriverSupabaseConfig);
     private get endpoint();
     private getClient;
     private getBucket;
     private fullPath;
     private getAuthenticatedUrl;
+    private getResumableUrl;
     read(filepath: string, options?: ReadOptions): Promise<Readable>;
     stat(filepath: string): Promise<{
         size: any;
@@ -31,6 +36,11 @@ declare class DriverSupabase implements Driver {
     delete(filepath: string): Promise<void>;
     list(prefix?: string): AsyncIterable<string>;
     listGenerator(prefix: string): AsyncIterable<string>;
+    get tusExtensions(): string[];
+    createChunkedUpload(_filepath: string, context: ChunkedUploadContext): Promise<ChunkedUploadContext>;
+    writeChunk(filepath: string, content: Readable, offset: number, context: ChunkedUploadContext): Promise<number>;
+    finishChunkedUpload(_filepath: string, _context: ChunkedUploadContext): Promise<void>;
+    deleteChunkedUpload(filepath: string, _context: ChunkedUploadContext): Promise<void>;
 }
 
 export { DriverSupabase, type DriverSupabaseConfig, DriverSupabase as default };

package/dist/index.js

@@ -1,18 +1,23 @@
 // src/index.ts
+import { DEFAULT_CHUNK_SIZE } from "@directus/constants";
 import { normalizePath } from "@directus/utils";
 import { StorageClient } from "@supabase/storage-js";
 import { join } from "node:path";
 import { Readable } from "node:stream";
+import * as tus from "tus-js-client";
 import { fetch } from "undici";
 var DriverSupabase = class {
   config;
   client;
   bucket;
+  // TUS specific members
+  preferredChunkSize;
   constructor(config) {
     this.config = {
       ...config,
       root: normalizePath(config.root ?? "", { removeLeading: true })
     };
+    this.preferredChunkSize = this.config.tus?.chunkSize ?? DEFAULT_CHUNK_SIZE;
     this.client = this.getClient();
     this.bucket = this.getBucket();
   }
@@ -45,6 +50,9 @@ var DriverSupabase = class {
   getAuthenticatedUrl(filepath) {
     return `${this.endpoint}/${join("object/authenticated", this.config.bucket, this.fullPath(filepath))}`;
   }
+  getResumableUrl() {
+    return `${this.endpoint}/upload/resumable`;
+  }
   async read(filepath, options) {
     const { range } = options || {};
     const requestInit = { method: "GET" };
@@ -130,11 +138,85 @@ var DriverSupabase = class {
       }
     } while (itemCount === limit);
   }
+  get tusExtensions() {
+    return ["creation", "termination", "expiration"];
+  }
+  async createChunkedUpload(_filepath, context) {
+    return context;
+  }
+  async writeChunk(filepath, content, offset, context) {
+    let bytesUploaded = offset || 0;
+    const metadata = {
+      bucketName: this.config.bucket,
+      objectName: this.fullPath(filepath),
+      contentType: context.metadata["type"] ?? "image/png",
+      cacheControl: "3600"
+    };
+    await new Promise((resolve, reject) => {
+      const upload = new tus.Upload(content, {
+        endpoint: this.getResumableUrl(),
+        // @ts-expect-error
+        fileReader: new FileReader(),
+        headers: {
+          Authorization: `Bearer ${this.config.serviceRole}`,
+          "x-upsert": "true"
+        },
+        metadata,
+        chunkSize: this.preferredChunkSize,
+        uploadSize: context.size,
+        retryDelays: null,
+        onError(error) {
+          reject(error);
+        },
+        onChunkComplete: function(chunkSize) {
+          bytesUploaded += chunkSize;
+          resolve(null);
+        },
+        onSuccess() {
+          resolve(null);
+        },
+        onUploadUrlAvailable() {
+          if (!context.metadata["upload-url"]) {
+            context.metadata["upload-url"] = upload.url;
+          }
+        }
+      });
+      if (context.metadata["upload-url"]) {
+        upload.resumeFromPreviousUpload({
+          size: context.size,
+          creationTime: context.metadata["creation_date"],
+          metadata,
+          uploadUrl: context.metadata["upload-url"]
+        });
+      }
+      upload.start();
+    });
+    return bytesUploaded;
+  }
+  async finishChunkedUpload(_filepath, _context) {
+  }
+  async deleteChunkedUpload(filepath, _context) {
+    await this.delete(filepath);
+  }
 };
 var src_default = DriverSupabase;
 function dirname(path) {
   return path.split("/").slice(0, -1).join("/");
 }
+var StreamSource2 = class extends tus.StreamSource {
+  _streamEnded = false;
+  // @ts-expect-error
+  async slice(start, end) {
+    if (this._streamEnded) return null;
+    this._streamEnded = true;
+    return super.slice(0, end - start);
+  }
+};
+var FileReader = class {
+  async openFile(input, _) {
+    return new StreamSource2(input);
+  }
+};
 export {
   DriverSupabase,
   src_default as default

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@directus/storage-driver-supabase",
-  "version": "2.0.2",
+  "version": "2.1.1",
   "description": "Supabase file storage abstraction for `@directus/storage`",
   "homepage": "https://directus.io",
   "repository": {
@@ -22,9 +22,11 @@
   ],
   "dependencies": {
     "@supabase/storage-js": "2.7.1",
+    "tus-js-client": "4.2.3",
     "undici": "6.20.0",
-    "@directus/utils": "12.0.2",
-    "@directus/storage": "11.0.1"
+    "@directus/constants": "12.0.1",
+    "@directus/storage": "11.0.1",
+    "@directus/utils": "12.0.4"
   },
   "devDependencies": {
     "@ngneat/falso": "7.2.0",