@directus/storage-driver-gcs 12.0.8 → 12.0.9

package/dist/index.d.ts

@@ -1,39 +1,40 @@
-import { TusDriver } from '@directus/storage';
-import { ReadOptions, ChunkedUploadContext } from '@directus/types';
-import { Readable } from 'node:stream';
+import { Readable } from "node:stream";
+import { TusDriver } from "@directus/storage";
+import { ChunkedUploadContext, ReadOptions } from "@directus/types";
 
+//#region src/index.d.ts
 type DriverGCSConfig = {
-    root?: string;
-    bucket: string;
-    apiEndpoint?: string;
-    tus?: {
-        enabled: boolean;
-        chunkSize?: number;
-    };
+  root?: string;
+  bucket: string;
+  apiEndpoint?: string;
+  tus?: {
+    enabled: boolean;
+    chunkSize?: number;
+  };
 };
 declare class DriverGCS implements TusDriver {
-    private root;
-    private bucket;
-    private readonly preferredChunkSize;
-    constructor(config: DriverGCSConfig);
-    private fullPath;
-    private file;
-    read(filepath: string, options?: ReadOptions): Promise<Readable>;
-    write(filepath: string, content: Readable): Promise<void>;
-    delete(filepath: string): Promise<void>;
-    stat(filepath: string): Promise<{
-        size: number;
-        modified: Date;
-    }>;
-    exists(filepath: string): Promise<boolean>;
-    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>;
+  private root;
+  private bucket;
+  private readonly preferredChunkSize;
+  constructor(config: DriverGCSConfig);
+  private fullPath;
+  private file;
+  read(filepath: string, options?: ReadOptions): Promise<Readable>;
+  write(filepath: string, content: Readable): Promise<void>;
+  delete(filepath: string): Promise<void>;
+  stat(filepath: string): Promise<{
+    size: number;
+    modified: Date;
+  }>;
+  exists(filepath: string): Promise<boolean>;
+  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 };
+//#endregion
+export { DriverGCS, DriverGCS as default, DriverGCSConfig };

package/dist/index.js

@@ -1,113 +1,107 @@
-// src/index.ts
 import { DEFAULT_CHUNK_SIZE } from "@directus/constants";
 import { normalizePath } from "@directus/utils";
 import { Storage } from "@google-cloud/storage";
-import { join } from "path";
-import "stream";
-import { pipeline } from "stream/promises";
-var MINIMUM_CHUNK_SIZE = 262144;
+import { join } from "node:path";
+import { pipeline } from "node:stream/promises";
+
+//#region src/index.ts
+const MINIMUM_CHUNK_SIZE = 262144;
 var DriverGCS = class {
-  root;
-  bucket;
-  // TUS specific members
-  preferredChunkSize;
-  constructor(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 = tus?.chunkSize || DEFAULT_CHUNK_SIZE;
-    if (tus?.enabled && (this.preferredChunkSize < MINIMUM_CHUNK_SIZE || Math.log2(this.preferredChunkSize) % 1 !== 0)) {
-      throw new Error("Invalid chunkSize provided");
-    }
-  }
-  fullPath(filepath) {
-    return normalizePath(join(this.root, filepath));
-  }
-  file(filepath) {
-    return this.bucket.file(filepath);
-  }
-  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));
-    const stream = file.createWriteStream({ resumable: false });
-    await pipeline(content, stream);
-  }
-  async delete(filepath) {
-    await this.file(this.fullPath(filepath)).delete();
-  }
-  async stat(filepath) {
-    const [{ size, updated }] = await this.file(this.fullPath(filepath)).getMetadata();
-    return { size, modified: new Date(updated) };
-  }
-  async exists(filepath) {
-    return (await this.file(this.fullPath(filepath)).exists())[0];
-  }
-  async move(src, dest) {
-    await this.file(this.fullPath(src)).move(this.file(this.fullPath(dest)));
-  }
-  async copy(src, dest) {
-    await this.file(this.fullPath(src)).copy(this.file(this.fullPath(dest)));
-  }
-  async *list(prefix = "") {
-    let query = {
-      prefix: this.fullPath(prefix),
-      autoPaginate: false,
-      maxResults: 500
-    };
-    while (query) {
-      const [files, nextQuery] = await this.bucket.getFiles(query);
-      for (const file of files) {
-        yield file.name.substring(this.root.length);
-      }
-      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 index_default = DriverGCS;
-export {
-  DriverGCS,
-  index_default as default
+	root;
+	bucket;
+	preferredChunkSize;
+	constructor(config) {
+		const { bucket, root, tus,...storageOptions } = config;
+		this.root = root ? normalizePath(root, { removeLeading: true }) : "";
+		this.bucket = new Storage(storageOptions).bucket(bucket);
+		this.preferredChunkSize = tus?.chunkSize || DEFAULT_CHUNK_SIZE;
+		if (tus?.enabled && (this.preferredChunkSize < MINIMUM_CHUNK_SIZE || Math.log2(this.preferredChunkSize) % 1 !== 0)) throw new Error("Invalid chunkSize provided");
+	}
+	fullPath(filepath) {
+		return normalizePath(join(this.root, filepath));
+	}
+	file(filepath) {
+		return this.bucket.file(filepath);
+	}
+	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 stream = this.file(this.fullPath(filepath)).createWriteStream({ resumable: false });
+		await pipeline(content, stream);
+	}
+	async delete(filepath) {
+		await this.file(this.fullPath(filepath)).delete();
+	}
+	async stat(filepath) {
+		const [{ size, updated }] = await this.file(this.fullPath(filepath)).getMetadata();
+		return {
+			size,
+			modified: new Date(updated)
+		};
+	}
+	async exists(filepath) {
+		return (await this.file(this.fullPath(filepath)).exists())[0];
+	}
+	async move(src, dest) {
+		await this.file(this.fullPath(src)).move(this.file(this.fullPath(dest)));
+	}
+	async copy(src, dest) {
+		await this.file(this.fullPath(src)).copy(this.file(this.fullPath(dest)));
+	}
+	async *list(prefix = "") {
+		let query = {
+			prefix: this.fullPath(prefix),
+			autoPaginate: false,
+			maxResults: 500
+		};
+		while (query) {
+			const [files, nextQuery] = await this.bucket.getFiles(query);
+			for (const file of files) yield file.name.substring(this.root.length);
+			query = nextQuery;
+		}
+	}
+	get tusExtensions() {
+		return [
+			"creation",
+			"termination",
+			"expiration"
+		];
+	}
+	async createChunkedUpload(filepath, context) {
+		const [uri] = await this.file(this.fullPath(filepath)).createResumableUpload();
+		context.metadata["uri"] = uri;
+		return context;
+	}
+	async writeChunk(filepath, content, offset, context) {
+		const stream = this.file(this.fullPath(filepath)).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;
+
+//#endregion
+export { DriverGCS, src_default as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@directus/storage-driver-gcs",
-  "version": "12.0.8",
+  "version": "12.0.9",
   "description": "GCS file storage abstraction for `@directus/storage`",
   "homepage": "https://directus.io",
   "repository": {
@@ -22,22 +22,22 @@
   ],
   "dependencies": {
     "@google-cloud/storage": "7.16.0",
-    "@directus/constants": "13.0.2",
-    "@directus/storage": "12.0.1",
-    "@directus/utils": "13.0.9"
+    "@directus/constants": "13.0.3",
+    "@directus/storage": "12.0.2",
+    "@directus/utils": "13.0.10"
   },
   "devDependencies": {
     "@directus/tsconfig": "3.0.0",
     "@ngneat/falso": "8.0.2",
     "@vitest/coverage-v8": "3.2.4",
-    "tsup": "8.5.0",
+    "tsdown": "0.14.2",
     "typescript": "5.8.3",
     "vitest": "3.2.4",
-    "@directus/types": "13.2.1"
+    "@directus/types": "13.2.3"
   },
   "scripts": {
-    "build": "tsup src/index.ts --format=esm --dts",
-    "dev": "tsup src/index.ts --format=esm --dts --watch",
+    "build": "tsdown src/index.ts --dts",
+    "dev": "tsdown src/index.ts --dts --watch",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage"
   }