@rebasepro/server-core 0.0.1-canary.4d4fb3e → 0.0.1-canary.ca2cb6e

package/src/services/driver-registry.ts

@@ -117,7 +117,7 @@ export class DefaultDriverRegistry implements DriverRegistry {
         const delegate = this.delegates.get(DEFAULT_DRIVER_ID);
         if (!delegate) {
             throw new Error(
-                `[DriverRegistry] No default driver registered. ` +
+                "[DriverRegistry] No default driver registered. " +
                 `Register one with id "${DEFAULT_DRIVER_ID}" or pass a single DataDriver.`
             );
         }

package/src/singleton.test.ts

@@ -0,0 +1,28 @@
+import { rebase, _initRebase } from "./singleton";
+import type { RebaseClient } from "@rebasepro/types";
+
+describe("rebase singleton", () => {
+    beforeEach(() => {
+        // Reset the singleton before each test
+        // By calling _initRebase with null (cast to bypass type checking for the reset)
+        _initRebase(null as unknown as RebaseClient);
+    });
+
+    it("should throw an error if accessed before initialization", () => {
+        expect(() => rebase.data).toThrow(
+            "rebase.data: server not initialized yet. The singleton is available after Rebase starts — don't call it at import time."
+        );
+    });
+
+    it("should return the correctly initialized instance properties", () => {
+        const mockClient = {
+            data: { test: "mockData" },
+            auth: { test: "mockAuth" }
+        } as unknown as RebaseClient;
+
+        _initRebase(mockClient);
+
+        expect(rebase.data).toEqual({ test: "mockData" });
+        expect(rebase.auth).toEqual({ test: "mockAuth" });
+    });
+});

package/src/singleton.ts

@@ -0,0 +1,70 @@
+import type { RebaseClient } from "@rebasepro/types";
+
+let _instance: RebaseClient | null = null;
+
+/**
+ * @internal Called once during server initialization to set the backing instance.
+ * This is invoked by `initializeRebaseBackend()` — never call it manually.
+ */
+export function _initRebase(client: RebaseClient): void {
+    _instance = client;
+}
+
+/**
+ * @internal Allows overriding the underlying instance for unit testing.
+ * Throws an error if used in a non-test environment to prevent production abuse.
+ */
+export function _setRebaseMock(mockInstance: Partial<RebaseClient>): void {
+    if (process.env.NODE_ENV !== "test") {
+        throw new Error("_setRebaseMock can only be called in a test environment (NODE_ENV=test).");
+    }
+    _instance = { ...(_instance || {} as RebaseClient),
+...mockInstance } as RebaseClient;
+}
+
+/**
+ * @internal Resets the singleton instance, useful for afterEach() in test suites.
+ */
+export function _resetRebaseMock(): void {
+    if (process.env.NODE_ENV !== "test") {
+        throw new Error("_resetRebaseMock can only be called in a test environment.");
+    }
+    _instance = null;
+}
+
+/**
+ * The server-side Rebase singleton.
+ *
+ * Initialized automatically during server startup. Provides access to all
+ * app-scoped services: **data**, **auth**, **storage**, and **email**.
+ *
+ * `rebase.data` runs with **admin privileges** (no RLS). For user-scoped
+ * queries inside request handlers, continue using the handler's context
+ * or the RLS-scoped driver.
+ *
+ * @example
+ * ```typescript
+ * import { rebase } from "@rebasepro/server-core";
+ *
+ * // In a Hono handler, cron job, hook, or service file:
+ * await rebase.email?.send({ to: "admin@co.com", subject: "Alert", html: "<p>Hi</p>" });
+ * const jobs = await rebase.data.jobs.find({ limit: 10 });
+ * ```
+ */
+export const rebase: RebaseClient = new Proxy({} as RebaseClient, {
+    get(_, prop) {
+        if (!_instance) {
+            throw new Error(
+                `rebase.${String(prop)}: server not initialized yet. ` +
+                "The singleton is available after Rebase starts — don't call it at import time."
+            );
+        }
+        return _instance[prop as keyof RebaseClient];
+    },
+    set(_, prop) {
+        throw new Error(
+            `Cannot set rebase.${String(prop)} directly. ` +
+            "The singleton is read-only. Use _initRebase() during server startup."
+        );
+    }
+});

package/src/storage/LocalStorageController.ts

@@ -2,14 +2,14 @@
  * Local filesystem storage controller
  */
 
-import * as fs from 'fs';
-import * as path from 'path';
-import { promisify } from 'util';
+import * as fs from "fs";
+import * as path from "path";
+import { promisify } from "util";
 import {
     StorageController,
     LocalStorageConfig,
     DEFAULT_MAX_FILE_SIZE
-} from './types';
+} from "./types";
 import {
     UploadFileProps,
     UploadFileResult,
@@ -17,7 +17,7 @@ import {
     DownloadMetadata,
     StorageListResult,
     StorageReference
-} from '@rebasepro/types';
+} from "@rebasepro/types";
 
 const mkdir = promisify(fs.mkdir);
 const writeFile = promisify(fs.writeFile);
@@ -33,10 +33,10 @@ const access = promisify(fs.access);
  */
 function normalizeStoragePath(s: string): string {
     let result = s;
-    while (result.startsWith('/')) {
+    while (result.startsWith("/")) {
         result = result.slice(1);
     }
-    while (result.endsWith('/')) {
+    while (result.endsWith("/")) {
         result = result.slice(0, -1);
     }
     return result;
@@ -55,8 +55,8 @@ export class LocalStorageController implements StorageController {
         this.basePath = path.resolve(config.basePath);
     }
 
-    getType(): 'local' {
-        return 'local';
+    getType(): "local" {
+        return "local";
     }
 
     /**
@@ -66,7 +66,7 @@ export class LocalStorageController implements StorageController {
         try {
             await mkdir(dirPath, { recursive: true });
         } catch (error: unknown) {
-            if (error instanceof Error && (error as NodeJS.ErrnoException).code !== 'EEXIST') {
+            if (error instanceof Error && (error as NodeJS.ErrnoException).code !== "EEXIST") {
                 throw error;
             }
         }
@@ -96,26 +96,22 @@ export class LocalStorageController implements StorageController {
 
         if (this.config.allowedMimeTypes && this.config.allowedMimeTypes.length > 0) {
             if (!this.config.allowedMimeTypes.includes(file.type)) {
-                throw new Error(`File type ${file.type} is not allowed. Allowed types: ${this.config.allowedMimeTypes.join(', ')}`);
+                throw new Error(`File type ${file.type} is not allowed. Allowed types: ${this.config.allowedMimeTypes.join(", ")}`);
             }
         }
     }
 
-    async uploadFile({
+    async putObject({
         file,
-        fileName,
-        path: storagePath,
+        key,
         metadata,
         bucket
     }: UploadFileProps): Promise<UploadFileResult> {
         this.validateFile(file);
 
         // Always use a bucket (default to 'default')
-        const usedBucket = bucket ?? 'default';
-        const usedFileName = fileName ?? file.name;
-        // Normalize storage path to remove leading/trailing slashes
-        const normalizedPath = storagePath ? normalizeStoragePath(storagePath) : '';
-        const fullStoragePath = normalizedPath ? `${normalizedPath}/${usedFileName}` : usedFileName;
+        const usedBucket = bucket ?? "default";
+        const fullStoragePath = key;
         const fullPath = this.getFullPath(fullStoragePath, usedBucket);
 
         // Ensure parent directory exists
@@ -136,20 +132,20 @@ export class LocalStorageController implements StorageController {
         }, null, 2));
 
         return {
-            path: fullStoragePath,
+            key: fullStoragePath,
             bucket: usedBucket,
             storageUrl: `local://${usedBucket}/${fullStoragePath}`
         };
     }
 
-    async getDownloadURL(storagePath: string, bucket?: string): Promise<DownloadConfig> {
+    async getSignedUrl(key: string, bucket?: string): Promise<DownloadConfig> {
         // Handle local:// URLs
-        let resolvedPath = storagePath;
+        let resolvedPath = key;
         let resolvedBucket = bucket;
 
-        if (storagePath.startsWith('local://')) {
-            const withoutProtocol = storagePath.substring('local://'.length);
-            const firstSlash = withoutProtocol.indexOf('/');
+        if (key.startsWith("local://")) {
+            const withoutProtocol = key.substring("local://".length);
+            const firstSlash = withoutProtocol.indexOf("/");
             if (firstSlash > 0) {
                 resolvedBucket = withoutProtocol.substring(0, firstSlash);
                 resolvedPath = withoutProtocol.substring(firstSlash + 1);
@@ -173,16 +169,16 @@ export class LocalStorageController implements StorageController {
         let metadata: DownloadMetadata | undefined;
         const metadataPath = `${fullPath}.metadata.json`;
         try {
-            const metadataContent = await readFile(metadataPath, 'utf-8');
+            const metadataContent = await readFile(metadataPath, "utf-8");
             const savedMetadata = JSON.parse(metadataContent);
             const fileStat = await stat(fullPath);
 
             metadata = {
-                bucket: resolvedBucket ?? 'default',
+                bucket: resolvedBucket ?? "default",
                 fullPath: resolvedPath,
                 name: path.basename(resolvedPath),
                 size: fileStat.size,
-                contentType: savedMetadata.contentType || 'application/octet-stream',
+                contentType: savedMetadata.contentType || "application/octet-stream",
                 customMetadata: savedMetadata
             };
         } catch {
@@ -190,11 +186,11 @@ export class LocalStorageController implements StorageController {
             try {
                 const fileStat = await stat(fullPath);
                 metadata = {
-                    bucket: resolvedBucket ?? 'default',
+                    bucket: resolvedBucket ?? "default",
                     fullPath: resolvedPath,
                     name: path.basename(resolvedPath),
                     size: fileStat.size,
-                    contentType: 'application/octet-stream',
+                    contentType: "application/octet-stream",
                     customMetadata: {}
                 };
             } catch {
@@ -203,7 +199,7 @@ export class LocalStorageController implements StorageController {
         }
 
         // Return a relative URL that will be served by the storage routes
-        const bucketPath = resolvedBucket ? `${resolvedBucket}/` : '';
+        const bucketPath = resolvedBucket ? `${resolvedBucket}/` : "";
         const url = `/api/storage/file/${bucketPath}${resolvedPath}`;
 
         return {
@@ -212,14 +208,14 @@ export class LocalStorageController implements StorageController {
         };
     }
 
-    async getFile(storagePath: string, bucket?: string): Promise<File | null> {
+    async getObject(key: string, bucket?: string): Promise<File | null> {
         // Handle local:// URLs
-        let resolvedPath = storagePath;
+        let resolvedPath = key;
         let resolvedBucket = bucket;
 
-        if (storagePath.startsWith('local://')) {
-            const withoutProtocol = storagePath.substring('local://'.length);
-            const firstSlash = withoutProtocol.indexOf('/');
+        if (key.startsWith("local://")) {
+            const withoutProtocol = key.substring("local://".length);
+            const firstSlash = withoutProtocol.indexOf("/");
             if (firstSlash > 0) {
                 resolvedBucket = withoutProtocol.substring(0, firstSlash);
                 resolvedPath = withoutProtocol.substring(firstSlash + 1);
@@ -235,10 +231,10 @@ export class LocalStorageController implements StorageController {
             const buffer = await readFile(fullPath);
 
             // Try to get content type from metadata
-            let contentType = 'application/octet-stream';
+            let contentType = "application/octet-stream";
             try {
                 const metadataPath = `${fullPath}.metadata.json`;
-                const metadataContent = await readFile(metadataPath, 'utf-8');
+                const metadataContent = await readFile(metadataPath, "utf-8");
                 const metadata = JSON.parse(metadataContent);
                 contentType = metadata.contentType || contentType;
             } catch {
@@ -252,14 +248,14 @@ export class LocalStorageController implements StorageController {
         }
     }
 
-    async deleteFile(storagePath: string, bucket?: string): Promise<void> {
+    async deleteObject(key: string, bucket?: string): Promise<void> {
         // Handle local:// URLs
-        let resolvedPath = storagePath;
+        let resolvedPath = key;
         let resolvedBucket = bucket;
 
-        if (storagePath.startsWith('local://')) {
-            const withoutProtocol = storagePath.substring('local://'.length);
-            const firstSlash = withoutProtocol.indexOf('/');
+        if (key.startsWith("local://")) {
+            const withoutProtocol = key.substring("local://".length);
+            const firstSlash = withoutProtocol.indexOf("/");
             if (firstSlash > 0) {
                 resolvedBucket = withoutProtocol.substring(0, firstSlash);
                 resolvedPath = withoutProtocol.substring(firstSlash + 1);
@@ -279,20 +275,20 @@ export class LocalStorageController implements StorageController {
                 // Metadata file might not exist
             }
         } catch (error: unknown) {
-            if (error instanceof Error && (error as NodeJS.ErrnoException).code !== 'ENOENT') {
+            if (error instanceof Error && (error as NodeJS.ErrnoException).code !== "ENOENT") {
                 throw error;
             }
             // File doesn't exist, nothing to delete
         }
     }
 
-    async list(storagePath: string, options?: {
+    async listObjects(prefix: string, options?: {
         bucket?: string;
         maxResults?: number;
         pageToken?: string;
     }): Promise<StorageListResult> {
         // Normalize path to handle leading/trailing slashes
-        const normalizedPath = normalizeStoragePath(storagePath);
+        const normalizedPath = normalizeStoragePath(prefix);
         const fullPath = this.getFullPath(normalizedPath, options?.bucket);
         const items: StorageReference[] = [];
         const prefixes: StorageReference[] = [];
@@ -309,12 +305,12 @@ export class LocalStorageController implements StorageController {
                 const entry = entries[i];
 
                 // Skip metadata files
-                if (entry.name.endsWith('.metadata.json')) {
+                if (entry.name.endsWith(".metadata.json")) {
                     continue;
                 }
 
-                const entryPath = storagePath ? `${storagePath}/${entry.name}` : entry.name;
-                const bucket = options?.bucket ?? 'default';
+                const entryPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+                const bucket = options?.bucket ?? "default";
 
                 const ref: StorageReference = {
                     bucket,
@@ -344,8 +340,9 @@ export class LocalStorageController implements StorageController {
             };
         } catch (error: unknown) {
             const code = (error as NodeJS.ErrnoException)?.code;
-            if (code === 'ENOENT' || code === 'ENOTDIR') {
-                return { items: [], prefixes: [] };
+            if (code === "ENOENT" || code === "ENOTDIR") {
+                return { items: [],
+prefixes: [] };
             }
             throw error;
         }
@@ -355,8 +352,8 @@ export class LocalStorageController implements StorageController {
      * Get the absolute filesystem path for serving files
      * Used by the storage routes to serve files directly
      */
-    getAbsolutePath(storagePath: string, bucket?: string): string {
-        return this.getFullPath(storagePath, bucket);
+    getAbsolutePath(key: string, bucket?: string): string {
+        return this.getFullPath(key, bucket);
     }
 
     /**

package/src/storage/S3StorageController.ts

@@ -11,13 +11,13 @@ import {
     HeadObjectCommand,
     _Object,
     CommonPrefix
-} from '@aws-sdk/client-s3';
-import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+} from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
 import {
     StorageController,
     S3StorageConfig,
     DEFAULT_MAX_FILE_SIZE
-} from './types';
+} from "./types";
 import {
     UploadFileProps,
     UploadFileResult,
@@ -25,7 +25,7 @@ import {
     DownloadMetadata,
     StorageListResult,
     StorageReference
-} from '@rebasepro/types';
+} from "@rebasepro/types";
 
 /**
  * S3-compatible storage implementation
@@ -38,7 +38,7 @@ export class S3StorageController implements StorageController {
     constructor(config: S3StorageConfig) {
         this.config = config;
         this.client = new S3Client({
-            region: config.region || 'us-east-1',
+            region: config.region || "us-east-1",
             endpoint: config.endpoint,
             forcePathStyle: config.forcePathStyle ?? !!config.endpoint, // Auto-enable for custom endpoints (MinIO)
             credentials: {
@@ -48,8 +48,8 @@ export class S3StorageController implements StorageController {
         });
     }
 
-    getType(): 's3' {
-        return 's3';
+    getType(): "s3" {
+        return "s3";
     }
 
     /**
@@ -63,7 +63,7 @@ export class S3StorageController implements StorageController {
 
         if (this.config.allowedMimeTypes && this.config.allowedMimeTypes.length > 0) {
             if (!this.config.allowedMimeTypes.includes(file.type)) {
-                throw new Error(`File type ${file.type} is not allowed. Allowed types: ${this.config.allowedMimeTypes.join(', ')}`);
+                throw new Error(`File type ${file.type} is not allowed. Allowed types: ${this.config.allowedMimeTypes.join(", ")}`);
             }
         }
     }
@@ -75,17 +75,14 @@ export class S3StorageController implements StorageController {
         return bucket ?? this.config.bucket;
     }
 
-    async uploadFile({
+    async putObject({
         file,
-        fileName,
-        path: storagePath,
+        key,
         metadata,
         bucket
     }: UploadFileProps): Promise<UploadFileResult> {
         this.validateFile(file);
 
-        const usedFileName = fileName ?? file.name;
-        const key = storagePath ? `${storagePath}/${usedFileName}` : usedFileName;
         const usedBucket = this.getBucket(bucket);
 
         // Convert File to Buffer
@@ -103,7 +100,7 @@ export class S3StorageController implements StorageController {
         await this.client.send(command);
 
         return {
-            path: key,
+            key,
             bucket: usedBucket,
             storageUrl: `s3://${usedBucket}/${key}`
         };
@@ -115,7 +112,7 @@ export class S3StorageController implements StorageController {
     private flattenMetadata(metadata: Record<string, unknown>): Record<string, string> {
         const flattened: Record<string, string> = {};
         for (const [key, value] of Object.entries(metadata)) {
-            if (typeof value === 'string') {
+            if (typeof value === "string") {
                 flattened[key] = value;
             } else if (value !== undefined && value !== null) {
                 flattened[key] = JSON.stringify(value);
@@ -124,14 +121,16 @@ export class S3StorageController implements StorageController {
         return flattened;
     }
 
-    async getDownloadURL(storagePath: string, bucket?: string): Promise<DownloadConfig> {
-        // Handle s3:// URLs
-        let resolvedPath = storagePath;
+    async getSignedUrl(key: string, bucket?: string): Promise<DownloadConfig> {
+        // Handle s3:// and gs:// URLs for backward compatibility
+        let resolvedPath = key;
         let resolvedBucket = this.getBucket(bucket);
 
-        if (storagePath.startsWith('s3://')) {
-            const withoutProtocol = storagePath.substring('s3://'.length);
-            const firstSlash = withoutProtocol.indexOf('/');
+        const match = key.match(/^(s3|gs):\/\//);
+        if (match) {
+            const protocolLength = match[0].length;
+            const withoutProtocol = key.substring(protocolLength);
+            const firstSlash = withoutProtocol.indexOf("/");
             if (firstSlash > 0) {
                 resolvedBucket = withoutProtocol.substring(0, firstSlash);
                 resolvedPath = withoutProtocol.substring(firstSlash + 1);
@@ -159,9 +158,9 @@ export class S3StorageController implements StorageController {
             const metadata: DownloadMetadata = {
                 bucket: resolvedBucket,
                 fullPath: resolvedPath,
-                name: resolvedPath.split('/').pop() || resolvedPath,
+                name: resolvedPath.split("/").pop() || resolvedPath,
                 size: headResult.ContentLength || 0,
-                contentType: headResult.ContentType || 'application/octet-stream',
+                contentType: headResult.ContentType || "application/octet-stream",
                 customMetadata: headResult.Metadata || {}
             };
 
@@ -171,7 +170,7 @@ export class S3StorageController implements StorageController {
             };
         } catch (error: unknown) {
             const s3Error = error as { name?: string; $metadata?: { httpStatusCode?: number } };
-            if (s3Error.name === 'NotFound' || s3Error.$metadata?.httpStatusCode === 404) {
+            if (s3Error.name === "NotFound" || s3Error.$metadata?.httpStatusCode === 404) {
                 return {
                     url: null,
                     fileNotFound: true
@@ -181,14 +180,16 @@ export class S3StorageController implements StorageController {
         }
     }
 
-    async getFile(storagePath: string, bucket?: string): Promise<File | null> {
-        // Handle s3:// URLs
-        let resolvedPath = storagePath;
+    async getObject(key: string, bucket?: string): Promise<File | null> {
+        // Handle s3:// and gs:// URLs
+        let resolvedPath = key;
         let resolvedBucket = this.getBucket(bucket);
 
-        if (storagePath.startsWith('s3://')) {
-            const withoutProtocol = storagePath.substring('s3://'.length);
-            const firstSlash = withoutProtocol.indexOf('/');
+        const match = key.match(/^(s3|gs):\/\//);
+        if (match) {
+            const protocolLength = match[0].length;
+            const withoutProtocol = key.substring(protocolLength);
+            const firstSlash = withoutProtocol.indexOf("/");
             if (firstSlash > 0) {
                 resolvedBucket = withoutProtocol.substring(0, firstSlash);
                 resolvedPath = withoutProtocol.substring(firstSlash + 1);
@@ -215,28 +216,30 @@ export class S3StorageController implements StorageController {
             }
             const buffer = Buffer.concat(chunks);
 
-            const contentType = response.ContentType || 'application/octet-stream';
-            const fileName = resolvedPath.split('/').pop() || resolvedPath;
+            const contentType = response.ContentType || "application/octet-stream";
+            const fileName = resolvedPath.split("/").pop() || resolvedPath;
 
             const blob = new Blob([buffer], { type: contentType });
             return new File([blob], fileName, { type: contentType });
         } catch (error: unknown) {
             const s3Error = error as { name?: string; $metadata?: { httpStatusCode?: number } };
-            if (s3Error.name === 'NoSuchKey' || s3Error.$metadata?.httpStatusCode === 404) {
+            if (s3Error.name === "NoSuchKey" || s3Error.$metadata?.httpStatusCode === 404) {
                 return null;
             }
             throw error;
         }
     }
 
-    async deleteFile(storagePath: string, bucket?: string): Promise<void> {
-        // Handle s3:// URLs
-        let resolvedPath = storagePath;
+    async deleteObject(key: string, bucket?: string): Promise<void> {
+        // Handle s3:// and gs:// URLs
+        let resolvedPath = key;
         let resolvedBucket = this.getBucket(bucket);
 
-        if (storagePath.startsWith('s3://')) {
-            const withoutProtocol = storagePath.substring('s3://'.length);
-            const firstSlash = withoutProtocol.indexOf('/');
+        const match = key.match(/^(s3|gs):\/\//);
+        if (match) {
+            const protocolLength = match[0].length;
+            const withoutProtocol = key.substring(protocolLength);
+            const firstSlash = withoutProtocol.indexOf("/");
             if (firstSlash > 0) {
                 resolvedBucket = withoutProtocol.substring(0, firstSlash);
                 resolvedPath = withoutProtocol.substring(firstSlash + 1);
@@ -251,7 +254,7 @@ export class S3StorageController implements StorageController {
         await this.client.send(command);
     }
 
-    async list(storagePath: string, options?: {
+    async listObjects(prefix: string, options?: {
         bucket?: string;
         maxResults?: number;
         pageToken?: string;
@@ -260,18 +263,18 @@ export class S3StorageController implements StorageController {
 
         const command = new ListObjectsV2Command({
             Bucket: resolvedBucket,
-            Prefix: storagePath || undefined,
+            Prefix: prefix || undefined,
             MaxKeys: options?.maxResults ?? 1000,
             ContinuationToken: options?.pageToken,
-            Delimiter: '/' // This gives us folder-like behavior
+            Delimiter: "/" // This gives us folder-like behavior
         });
 
         const response = await this.client.send(command);
 
         const items: StorageReference[] = (response.Contents || []).map(obj => ({
             bucket: resolvedBucket,
-            fullPath: obj.Key || '',
-            name: (obj.Key || '').split('/').pop() || '',
+            fullPath: obj.Key || "",
+            name: (obj.Key || "").split("/").pop() || "",
             parent: null as never,
             root: null as never,
             toString: () => `s3://${resolvedBucket}/${obj.Key}`
@@ -279,8 +282,8 @@ export class S3StorageController implements StorageController {
 
         const prefixes: StorageReference[] = (response.CommonPrefixes || []).map(prefix => ({
             bucket: resolvedBucket,
-            fullPath: prefix.Prefix || '',
-            name: (prefix.Prefix || '').replace(/\/$/, '').split('/').pop() || '',
+            fullPath: prefix.Prefix || "",
+            name: (prefix.Prefix || "").replace(/\/$/, "").split("/").pop() || "",
             parent: null as never,
             root: null as never,
             toString: () => `s3://${resolvedBucket}/${prefix.Prefix}`