@directus/storage-driver-gcs 11.0.1 → 11.1.0

package/dist/index.d.ts

@@ -1,18 +1,23 @@
-import { Driver, Range } from '@directus/storage';
+import { TusDriver, ReadOptions, ChunkedUploadContext } from '@directus/storage';
 import { Readable } from 'node:stream';
 
 type DriverGCSConfig = {
     root?: string;
     bucket: string;
     apiEndpoint?: string;
+    tus?: {
+        chunkSize?: number;
+    };
 };
-declare class DriverGCS implements Driver {
+declare class DriverGCS implements TusDriver {
     private root;
     private bucket;
+    private readonly preferredChunkSize;
     constructor(config: DriverGCSConfig);
+    private getPreferredChunkSize;
     private fullPath;
     private file;
-    read(filepath: string, range?: Range): Promise<Readable>;
+    read(filepath: string, options?: ReadOptions): Promise<Readable>;
     write(filepath: string, content: Readable): Promise<void>;
     delete(filepath: string): Promise<void>;
     stat(filepath: string): Promise<{
@@ -23,6 +28,11 @@ declare class DriverGCS implements Driver {
     move(src: string, dest: string): Promise<void>;
     copy(src: string, dest: string): Promise<void>;
     list(prefix?: string): AsyncGenerator<string, void, unknown>;
+    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 { DriverGCS, type DriverGCSConfig, DriverGCS as default };

package/dist/index.js

@@ -3,14 +3,28 @@ import { normalizePath } from "@directus/utils";
 import { Storage } from "@google-cloud/storage";
 import { join } from "node:path";
 import { pipeline } from "node:stream/promises";
+var DEFAULT_CHUNK_SIZE = 8388608;
+var MINIMUM_CHUNK_SIZE = 262144;
 var DriverGCS = class {
   root;
   bucket;
+  // TUS specific members
+  preferredChunkSize;
   constructor(config) {
-    const { bucket, root, ...storageOptions } = config;
+    const { bucket, root, tus, ...storageOptions } = config;
     this.root = root ? normalizePath(root, { removeLeading: true }) : "";
     const storage = new Storage(storageOptions);
     this.bucket = storage.bucket(bucket);
+    this.preferredChunkSize = this.getPreferredChunkSize(tus);
+  }
+  getPreferredChunkSize(tus) {
+    if (!tus?.chunkSize) {
+      return DEFAULT_CHUNK_SIZE;
+    }
+    if (tus.chunkSize < MINIMUM_CHUNK_SIZE || Math.log2(tus.chunkSize) % 1 !== 0) {
+      throw new Error("Invalid chunkSize provided");
+    }
+    return tus.chunkSize;
   }
   fullPath(filepath) {
     return normalizePath(join(this.root, filepath));
@@ -18,11 +32,12 @@ var DriverGCS = class {
   file(filepath) {
     return this.bucket.file(filepath);
   }
-  async read(filepath, range) {
-    const options = {};
-    if (range?.start) options.start = range.start;
-    if (range?.end) options.end = range.end;
-    return this.file(this.fullPath(filepath)).createReadStream(options);
+  async read(filepath, options) {
+    const { range } = options || {};
+    const stream_options = {};
+    if (range?.start) stream_options.start = range.start;
+    if (range?.end) stream_options.end = range.end;
+    return this.file(this.fullPath(filepath)).createReadStream(stream_options);
   }
   async write(filepath, content) {
     const file = this.file(this.fullPath(filepath));
@@ -59,6 +74,42 @@ var DriverGCS = class {
       query = nextQuery;
     }
   }
+  get tusExtensions() {
+    return ["creation", "termination", "expiration"];
+  }
+  async createChunkedUpload(filepath, context) {
+    const file = this.file(this.fullPath(filepath));
+    const [uri] = await file.createResumableUpload();
+    context.metadata["uri"] = uri;
+    return context;
+  }
+  async writeChunk(filepath, content, offset, context) {
+    const file = this.file(this.fullPath(filepath));
+    const stream = file.createWriteStream({
+      chunkSize: this.preferredChunkSize,
+      uri: context.metadata["uri"],
+      offset,
+      isPartialUpload: true,
+      resumeCRC32C: context.metadata["hash"],
+      metadata: {
+        contentLength: context.size || 0
+      }
+    });
+    stream.on("crc32c", (hash) => {
+      context.metadata["hash"] = hash;
+    });
+    let bytesUploaded = offset || 0;
+    content.on("data", (chunk) => {
+      bytesUploaded += chunk.length;
+    });
+    await pipeline(content, stream);
+    return bytesUploaded;
+  }
+  async finishChunkedUpload(_filepath, _context) {
+  }
+  async deleteChunkedUpload(filepath, _context) {
+    await this.delete(filepath);
+  }
 };
 var src_default = DriverGCS;
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@directus/storage-driver-gcs",
-  "version": "11.0.1",
+  "version": "11.1.0",
   "description": "GCS file storage abstraction for `@directus/storage`",
   "homepage": "https://directus.io",
   "repository": {
@@ -21,15 +21,15 @@
     "dist"
   ],
   "dependencies": {
-    "@google-cloud/storage": "7.12.0",
-    "@directus/storage": "11.0.0",
-    "@directus/utils": "12.0.1"
+    "@google-cloud/storage": "7.13.0",
+    "@directus/storage": "11.0.1",
+    "@directus/utils": "12.0.3"
   },
   "devDependencies": {
     "@ngneat/falso": "7.2.0",
     "@vitest/coverage-v8": "2.1.2",
-    "tsup": "8.2.4",
-    "typescript": "5.6.2",
+    "tsup": "8.3.0",
+    "typescript": "5.6.3",
     "vitest": "2.1.2",
     "@directus/tsconfig": "2.0.0"
   },