@digibuffer/file-manager-core 1.0.0

package/dist/router-De_vaLLo.js

@@ -0,0 +1,1031 @@
+import { createAwsSignature, createSignedUrl } from "@digibuffer/upload-lib-server/helpers";
+import { z } from "zod";
+
+//#region src/types.ts
+/**
+* Custom error class for file manager operations
+*/
+var FileManagerError = class extends Error {
+	constructor(message, code, statusCode = 500, details) {
+		super(message);
+		this.code = code;
+		this.statusCode = statusCode;
+		this.details = details;
+		this.name = "FileManagerError";
+	}
+};
+
+//#endregion
+//#region src/storage/s3-provider.ts
+/**
+* S3/R2 Storage Provider Implementation
+*/
+var S3StorageProvider = class {
+	constructor(config) {
+		this.config = config;
+	}
+	/**
+	* List files from S3/R2 storage
+	*/
+	async list(options = {}) {
+		const { prefix = "", delimiter = "", maxKeys = 1e3, cursor, sortBy = "lastModified", sortOrder = "desc" } = options;
+		const url = new URL(this.config.endpoint);
+		url.pathname = `/${this.config.bucket}`;
+		url.searchParams.set("list-type", "2");
+		url.searchParams.set("max-keys", maxKeys.toString());
+		if (prefix) url.searchParams.set("prefix", prefix);
+		if (delimiter) url.searchParams.set("delimiter", delimiter);
+		if (cursor?.continuationToken) url.searchParams.set("continuation-token", cursor.continuationToken);
+		const signature = await createAwsSignature({
+			method: "GET",
+			url: url.toString(),
+			region: this.config.region || "auto",
+			service: "s3",
+			accessKeyId: this.config.accessKeyId,
+			secretAccessKey: this.config.secretAccessKey
+		});
+		const response = await fetch(url.toString(), {
+			method: "GET",
+			headers: signature.headers
+		});
+		if (!response.ok) throw new FileManagerError(`Failed to list files: ${response.statusText}`, "LIST_ERROR", response.status);
+		const xmlText = await response.text();
+		const files = this.parseListResponse(xmlText);
+		const sortedFiles = this.sortFiles(files, sortBy, sortOrder);
+		const nextToken = this.extractContinuationToken(xmlText);
+		return {
+			data: sortedFiles,
+			nextCursor: nextToken ? { continuationToken: nextToken } : void 0,
+			hasMore: !!nextToken
+		};
+	}
+	/**
+	* Delete a single file
+	*/
+	async delete(key) {
+		try {
+			const url = `${this.config.endpoint}/${this.config.bucket}/${encodeURIComponent(key)}`;
+			const signature = await createAwsSignature({
+				method: "DELETE",
+				url,
+				region: this.config.region || "auto",
+				service: "s3",
+				accessKeyId: this.config.accessKeyId,
+				secretAccessKey: this.config.secretAccessKey
+			});
+			const response = await fetch(url, {
+				method: "DELETE",
+				headers: signature.headers
+			});
+			if (!response.ok && response.status !== 404) throw new Error(`Failed to delete: ${response.statusText}`);
+			return {
+				success: true,
+				key
+			};
+		} catch (error) {
+			return {
+				success: false,
+				key,
+				error: error instanceof Error ? error.message : "Unknown error"
+			};
+		}
+	}
+	/**
+	* Delete multiple files in batch
+	*/
+	async deleteBatch(keys) {
+		const results = await Promise.allSettled(keys.map((key) => this.delete(key)));
+		const succeeded = [];
+		const failed = [];
+		results.forEach((result, index) => {
+			if (result.status === "fulfilled" && result.value.success) succeeded.push(keys[index]);
+			else failed.push({
+				key: keys[index],
+				error: result.status === "rejected" ? result.reason : result.value.error || "Unknown error"
+			});
+		});
+		return {
+			succeeded,
+			failed,
+			totalProcessed: keys.length
+		};
+	}
+	/**
+	* Check if file exists
+	*/
+	async exists(key) {
+		try {
+			return await this.getMetadata(key) !== null;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Get file metadata
+	*/
+	async getMetadata(key) {
+		try {
+			const url = `${this.config.endpoint}/${this.config.bucket}/${encodeURIComponent(key)}`;
+			const signature = await createAwsSignature({
+				method: "HEAD",
+				url,
+				region: this.config.region || "auto",
+				service: "s3",
+				accessKeyId: this.config.accessKeyId,
+				secretAccessKey: this.config.secretAccessKey
+			});
+			const response = await fetch(url, {
+				method: "HEAD",
+				headers: signature.headers
+			});
+			if (!response.ok) {
+				if (response.status === 404) return null;
+				throw new Error(`Failed to get metadata: ${response.statusText}`);
+			}
+			return {
+				key,
+				bucket: this.config.bucket,
+				size: parseInt(response.headers.get("content-length") || "0", 10),
+				lastModified: new Date(response.headers.get("last-modified") || Date.now()),
+				contentType: response.headers.get("content-type") || void 0,
+				etag: response.headers.get("etag")?.replace(/"/g, "") || void 0
+			};
+		} catch (error) {
+			console.error(`Error getting metadata for ${key}:`, error);
+			return null;
+		}
+	}
+	/**
+	* Generate presigned download URL
+	*/
+	async getDownloadUrl(key, options = {}) {
+		const { expiresIn = 3600, disposition = "inline", filename } = options;
+		const url = new URL(`${this.config.endpoint}/${this.config.bucket}/${encodeURIComponent(key)}`);
+		if (disposition === "attachment") {
+			const downloadFilename = filename || key.split("/").pop() || "download";
+			url.searchParams.set("response-content-disposition", `attachment; filename="${downloadFilename}"`);
+		}
+		return await createSignedUrl({
+			url: url.toString(),
+			method: "GET",
+			expiresIn,
+			region: this.config.region || "auto",
+			service: "s3",
+			accessKeyId: this.config.accessKeyId,
+			secretAccessKey: this.config.secretAccessKey
+		});
+	}
+	/**
+	* Move a file (copy + delete source)
+	*/
+	async move(options) {
+		const { sourceKey, destinationKey } = options;
+		try {
+			const copyResult = await this.copy({
+				sourceKey,
+				destinationKey
+			});
+			if (!copyResult.success) return copyResult;
+			const deleteResult = await this.delete(sourceKey);
+			if (!deleteResult.success) {
+				await this.delete(destinationKey);
+				return {
+					success: false,
+					key: sourceKey,
+					error: `Failed to delete source after copy: ${deleteResult.error}`
+				};
+			}
+			return {
+				success: true,
+				key: destinationKey
+			};
+		} catch (error) {
+			return {
+				success: false,
+				key: sourceKey,
+				error: error instanceof Error ? error.message : "Unknown error"
+			};
+		}
+	}
+	/**
+	* Copy a file to a new location
+	*/
+	async copy(options) {
+		const { sourceKey, destinationKey, metadata } = options;
+		try {
+			const url = `${this.config.endpoint}/${this.config.bucket}/${encodeURIComponent(destinationKey)}`;
+			const headers = { "x-amz-copy-source": `/${this.config.bucket}/${encodeURIComponent(sourceKey)}` };
+			if (metadata) {
+				headers["x-amz-metadata-directive"] = "REPLACE";
+				Object.entries(metadata).forEach(([key, value]) => {
+					headers[`x-amz-meta-${key}`] = value;
+				});
+			}
+			const signature = await createAwsSignature({
+				method: "PUT",
+				url,
+				region: this.config.region || "auto",
+				service: "s3",
+				accessKeyId: this.config.accessKeyId,
+				secretAccessKey: this.config.secretAccessKey,
+				headers
+			});
+			const response = await fetch(url, {
+				method: "PUT",
+				headers: {
+					...signature.headers,
+					...headers
+				}
+			});
+			if (!response.ok) throw new Error(`Failed to copy: ${response.statusText}`);
+			return {
+				success: true,
+				key: destinationKey
+			};
+		} catch (error) {
+			return {
+				success: false,
+				key: sourceKey,
+				error: error instanceof Error ? error.message : "Unknown error"
+			};
+		}
+	}
+	/**
+	* Rename a file (same as move)
+	*/
+	async rename(oldKey, newKey) {
+		return this.move({
+			sourceKey: oldKey,
+			destinationKey: newKey
+		});
+	}
+	/**
+	* Parse XML list response
+	*/
+	parseListResponse(xmlText) {
+		const files = [];
+		const contentsRegex = /<Contents>([\s\S]*?)<\/Contents>/g;
+		let match;
+		while ((match = contentsRegex.exec(xmlText)) !== null) {
+			const content = match[1];
+			const key = this.extractXmlValue(content, "Key");
+			const size = this.extractXmlValue(content, "Size");
+			const lastModified = this.extractXmlValue(content, "LastModified");
+			const etag = this.extractXmlValue(content, "ETag");
+			if (key) files.push({
+				key,
+				bucket: this.config.bucket,
+				size: parseInt(size || "0", 10),
+				lastModified: new Date(lastModified || Date.now()),
+				etag: etag?.replace(/"/g, "")
+			});
+		}
+		return files;
+	}
+	/**
+	* Extract continuation token from XML
+	*/
+	extractContinuationToken(xmlText) {
+		return this.extractXmlValue(xmlText, "NextContinuationToken") || void 0;
+	}
+	/**
+	* Extract value from XML tag
+	*/
+	extractXmlValue(xml, tag) {
+		const regex = /* @__PURE__ */ new RegExp(`<${tag}>([^<]*)<\/${tag}>`);
+		const match = xml.match(regex);
+		return match ? match[1] : null;
+	}
+	/**
+	* Sort files by specified field
+	*/
+	sortFiles(files, sortBy, sortOrder) {
+		return files.sort((a, b) => {
+			let comparison = 0;
+			switch (sortBy) {
+				case "name":
+					comparison = a.key.localeCompare(b.key);
+					break;
+				case "size":
+					comparison = a.size - b.size;
+					break;
+				case "lastModified":
+					comparison = a.lastModified.getTime() - b.lastModified.getTime();
+					break;
+			}
+			return sortOrder === "asc" ? comparison : -comparison;
+		});
+	}
+};
+
+//#endregion
+//#region src/database/postgres-provider.ts
+/**
+* PostgreSQL Database Provider Implementation
+*/
+var PostgresDatabaseProvider = class {
+	sql;
+	tableName;
+	constructor(config) {
+		this.tableName = config.tableName || "files";
+		this.initializeConnection(config);
+	}
+	/**
+	* Initialize PostgreSQL connection
+	*/
+	async initializeConnection(config) {
+		try {
+			const postgres = await import("postgres");
+			if (config.connectionString) this.sql = postgres.default(config.connectionString);
+			else this.sql = postgres.default({
+				host: config.host,
+				port: config.port || 5432,
+				database: config.database,
+				user: config.user,
+				password: config.password
+			});
+			await this.ensureTableExists();
+		} catch (error) {
+			if (error.code === "ERR_MODULE_NOT_FOUND") throw new FileManagerError("PostgreSQL dependency not found. Install \"postgres\" package to use database mode.", "MISSING_DEPENDENCY", 500);
+			throw error;
+		}
+	}
+	/**
+	* Create files table if it doesn't exist
+	*/
+	async ensureTableExists() {
+		await this.sql`
+      CREATE TABLE IF NOT EXISTS ${this.sql(this.tableName)} (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        key TEXT NOT NULL UNIQUE,
+        size BIGINT NOT NULL,
+        content_type TEXT,
+        etag TEXT,
+        user_id TEXT,
+        custom_metadata JSONB,
+        last_modified TIMESTAMP NOT NULL,
+        uploaded_at TIMESTAMP NOT NULL DEFAULT NOW(),
+        updated_at TIMESTAMP NOT NULL DEFAULT NOW()
+      )
+    `;
+		await this.sql`
+      CREATE INDEX IF NOT EXISTS ${this.sql(`idx_${this.tableName}_key`)}
+      ON ${this.sql(this.tableName)} (key)
+    `;
+		await this.sql`
+      CREATE INDEX IF NOT EXISTS ${this.sql(`idx_${this.tableName}_user_id`)}
+      ON ${this.sql(this.tableName)} (user_id)
+    `;
+		await this.sql`
+      CREATE INDEX IF NOT EXISTS ${this.sql(`idx_${this.tableName}_uploaded_at`)}
+      ON ${this.sql(this.tableName)} (uploaded_at DESC)
+    `;
+	}
+	/**
+	* List files from database
+	*/
+	async list(options = {}) {
+		const { prefix = "", maxKeys = 1e3, cursor, sortBy = "lastModified", sortOrder = "desc", userId } = options;
+		const offset = cursor?.offset || 0;
+		let query = this.sql`
+      SELECT
+        id::text,
+        key,
+        size,
+        content_type,
+        etag,
+        user_id,
+        custom_metadata,
+        last_modified,
+        uploaded_at,
+        updated_at
+      FROM ${this.sql(this.tableName)}
+      WHERE 1=1
+    `;
+		if (prefix) query = this.sql`${query} AND key LIKE ${prefix + "%"}`;
+		if (userId) query = this.sql`${query} AND user_id = ${userId}`;
+		const sortColumn = this.getSortColumn(sortBy);
+		const order = sortOrder.toUpperCase();
+		query = this.sql`${query} ORDER BY ${this.sql(sortColumn)} ${this.sql.unsafe(order)}`;
+		query = this.sql`${query} LIMIT ${maxKeys + 1} OFFSET ${offset}`;
+		const rows = await query;
+		const hasMore = rows.length > maxKeys;
+		return {
+			data: (hasMore ? rows.slice(0, maxKeys) : rows).map((row) => ({
+				id: row.id,
+				key: row.key,
+				size: Number(row.size),
+				contentType: row.content_type,
+				etag: row.etag,
+				userId: row.user_id,
+				customMetadata: row.custom_metadata,
+				lastModified: new Date(row.last_modified),
+				uploadedAt: new Date(row.uploaded_at),
+				updatedAt: new Date(row.updated_at)
+			})),
+			nextCursor: hasMore ? { offset: offset + maxKeys } : void 0,
+			hasMore
+		};
+	}
+	/**
+	* Get a single file by key
+	*/
+	async get(key) {
+		const rows = await this.sql`
+      SELECT
+        id::text,
+        key,
+        size,
+        content_type,
+        etag,
+        user_id,
+        custom_metadata,
+        last_modified,
+        uploaded_at,
+        updated_at
+      FROM ${this.sql(this.tableName)}
+      WHERE key = ${key}
+      LIMIT 1
+    `;
+		if (rows.length === 0) return null;
+		const row = rows[0];
+		return {
+			id: row.id,
+			key: row.key,
+			size: Number(row.size),
+			contentType: row.content_type,
+			etag: row.etag,
+			userId: row.user_id,
+			customMetadata: row.custom_metadata,
+			lastModified: new Date(row.last_modified),
+			uploadedAt: new Date(row.uploaded_at),
+			updatedAt: new Date(row.updated_at)
+		};
+	}
+	/**
+	* Create a new file record
+	*/
+	async create(file) {
+		const row = (await this.sql`
+      INSERT INTO ${this.sql(this.tableName)} (
+        key,
+        size,
+        content_type,
+        etag,
+        user_id,
+        custom_metadata,
+        last_modified
+      )
+      VALUES (
+        ${file.key},
+        ${file.size},
+        ${file.contentType || null},
+        ${file.etag || null},
+        ${file.userId || null},
+        ${file.customMetadata ? JSON.stringify(file.customMetadata) : null},
+        ${file.lastModified}
+      )
+      ON CONFLICT (key) DO UPDATE SET
+        size = EXCLUDED.size,
+        content_type = EXCLUDED.content_type,
+        etag = EXCLUDED.etag,
+        last_modified = EXCLUDED.last_modified,
+        updated_at = NOW()
+      RETURNING
+        id::text,
+        key,
+        size,
+        content_type,
+        etag,
+        user_id,
+        custom_metadata,
+        last_modified,
+        uploaded_at,
+        updated_at
+    `)[0];
+		return {
+			id: row.id,
+			key: row.key,
+			size: Number(row.size),
+			contentType: row.content_type,
+			etag: row.etag,
+			userId: row.user_id,
+			customMetadata: row.custom_metadata,
+			lastModified: new Date(row.last_modified),
+			uploadedAt: new Date(row.uploaded_at),
+			updatedAt: new Date(row.updated_at)
+		};
+	}
+	/**
+	* Update file metadata
+	*/
+	async update(key, data) {
+		const updates = { updated_at: /* @__PURE__ */ new Date() };
+		if (data.size !== void 0) updates.size = data.size;
+		if (data.contentType !== void 0) updates.content_type = data.contentType;
+		if (data.etag !== void 0) updates.etag = data.etag;
+		if (data.userId !== void 0) updates.user_id = data.userId;
+		if (data.customMetadata !== void 0) updates.custom_metadata = JSON.stringify(data.customMetadata);
+		if (data.lastModified !== void 0) updates.last_modified = data.lastModified;
+		const rows = await this.sql`
+      UPDATE ${this.sql(this.tableName)}
+      SET ${this.sql(updates)}
+      WHERE key = ${key}
+      RETURNING
+        id::text,
+        key,
+        size,
+        content_type,
+        etag,
+        user_id,
+        custom_metadata,
+        last_modified,
+        uploaded_at,
+        updated_at
+    `;
+		if (rows.length === 0) return null;
+		const row = rows[0];
+		return {
+			id: row.id,
+			key: row.key,
+			size: Number(row.size),
+			contentType: row.content_type,
+			etag: row.etag,
+			userId: row.user_id,
+			customMetadata: row.custom_metadata,
+			lastModified: new Date(row.last_modified),
+			uploadedAt: new Date(row.uploaded_at),
+			updatedAt: new Date(row.updated_at)
+		};
+	}
+	/**
+	* Delete a file record
+	*/
+	async delete(key) {
+		try {
+			await this.sql`
+        DELETE FROM ${this.sql(this.tableName)}
+        WHERE key = ${key}
+      `;
+			return {
+				success: true,
+				key
+			};
+		} catch (error) {
+			return {
+				success: false,
+				key,
+				error: error instanceof Error ? error.message : "Unknown error"
+			};
+		}
+	}
+	/**
+	* Delete multiple file records
+	*/
+	async deleteBatch(keys) {
+		try {
+			const deleted = (await this.sql`
+        DELETE FROM ${this.sql(this.tableName)}
+        WHERE key = ANY(${keys})
+        RETURNING key
+      `).map((row) => row.key);
+			return {
+				succeeded: deleted,
+				failed: keys.filter((key) => !deleted.includes(key)).map((key) => ({
+					key,
+					error: "Not found"
+				})),
+				totalProcessed: keys.length
+			};
+		} catch (error) {
+			return {
+				succeeded: [],
+				failed: keys.map((key) => ({
+					key,
+					error: error instanceof Error ? error.message : "Unknown error"
+				})),
+				totalProcessed: keys.length
+			};
+		}
+	}
+	/**
+	* Check if file exists
+	*/
+	async exists(key) {
+		return (await this.sql`
+      SELECT 1 FROM ${this.sql(this.tableName)}
+      WHERE key = ${key}
+      LIMIT 1
+    `).length > 0;
+	}
+	/**
+	* Sync storage files to database
+	*/
+	async sync(storageFiles) {
+		if (storageFiles.length === 0) return;
+		const values = storageFiles.map((file) => ({
+			key: file.key,
+			size: file.size,
+			content_type: file.contentType || null,
+			etag: file.etag || null,
+			last_modified: file.lastModified
+		}));
+		await this.sql`
+      INSERT INTO ${this.sql(this.tableName)} ${this.sql(values)}
+      ON CONFLICT (key) DO UPDATE SET
+        size = EXCLUDED.size,
+        content_type = EXCLUDED.content_type,
+        etag = EXCLUDED.etag,
+        last_modified = EXCLUDED.last_modified,
+        updated_at = NOW()
+    `;
+	}
+	/**
+	* Get sort column for SQL query
+	*/
+	getSortColumn(sortBy) {
+		switch (sortBy) {
+			case "name": return "key";
+			case "size": return "size";
+			case "lastModified": return "last_modified";
+			default: return "last_modified";
+		}
+	}
+	/**
+	* Close database connection
+	*/
+	async close() {
+		if (this.sql) await this.sql.end();
+	}
+};
+
+//#endregion
+//#region src/file-manager.ts
+/**
+* Main FileManager class - Orchestrates file operations across storage and database
+*/
+var FileManager = class {
+	storage;
+	database;
+	defaultSource;
+	autoSync;
+	hooks;
+	constructor(config, hooks) {
+		this.storage = new S3StorageProvider(config.storage);
+		this.database = config.database ? new PostgresDatabaseProvider(config.database) : void 0;
+		this.defaultSource = config.defaultSource || (this.database ? "database" : "storage");
+		this.autoSync = config.autoSync ?? true;
+		this.hooks = hooks;
+	}
+	/**
+	* List files from specified source
+	*/
+	async list(options = {}, source) {
+		const dataSource = source || this.defaultSource;
+		switch (dataSource) {
+			case "storage": return this.listFromStorage(options);
+			case "database":
+				if (!this.database) throw new FileManagerError("Database not configured", "DATABASE_NOT_CONFIGURED", 400);
+				return this.listFromDatabase(options);
+			case "both": return this.listFromBoth(options);
+			default: throw new FileManagerError(`Invalid data source: ${dataSource}`, "INVALID_DATA_SOURCE", 400);
+		}
+	}
+	/**
+	* List files from storage only
+	*/
+	async listFromStorage(options = {}) {
+		return this.storage.list(options);
+	}
+	/**
+	* List files from database only
+	*/
+	async listFromDatabase(options = {}) {
+		if (!this.database) throw new FileManagerError("Database not configured", "DATABASE_NOT_CONFIGURED", 400);
+		return this.database.list(options);
+	}
+	/**
+	* List files from both storage and database, merged
+	*/
+	async listFromBoth(options = {}) {
+		if (!this.database) return this.listFromStorage(options);
+		const [storageResult, dbResult] = await Promise.all([this.storage.list(options), this.database.list(options)]);
+		const dbKeys = new Set(dbResult.data.map((f) => f.key));
+		return {
+			data: [...dbResult.data, ...storageResult.data.filter((f) => !dbKeys.has(f.key))],
+			nextCursor: dbResult.nextCursor || storageResult.nextCursor,
+			hasMore: dbResult.hasMore || storageResult.hasMore
+		};
+	}
+	/**
+	* Get file metadata
+	*/
+	async getMetadata(key, source) {
+		if ((source || this.defaultSource) === "database" && this.database) return this.database.get(key);
+		return this.storage.getMetadata(key);
+	}
+	/**
+	* Check if file exists
+	*/
+	async exists(key, source) {
+		if ((source || this.defaultSource) === "database" && this.database) return this.database.exists(key);
+		return this.storage.exists(key);
+	}
+	/**
+	* Get download URL for a file
+	*/
+	async getDownloadUrl(key, options) {
+		return this.storage.getDownloadUrl(key, options);
+	}
+	/**
+	* Delete a single file
+	*/
+	async delete(key) {
+		if (this.hooks?.beforeDelete) await this.hooks.beforeDelete([key]);
+		const storageResult = await this.storage.delete(key);
+		if (this.database && storageResult.success) await this.database.delete(key);
+		if (this.hooks?.afterDelete) await this.hooks.afterDelete([key]);
+		return storageResult;
+	}
+	/**
+	* Delete multiple files in batch
+	*/
+	async deleteBatch(keys) {
+		if (this.hooks?.beforeDelete) await this.hooks.beforeDelete(keys);
+		const storageResult = await this.storage.deleteBatch(keys);
+		if (this.database && storageResult.succeeded.length > 0) await this.database.deleteBatch(storageResult.succeeded);
+		if (this.hooks?.afterDelete) await this.hooks.afterDelete(storageResult.succeeded);
+		return storageResult;
+	}
+	/**
+	* Move a file to a new location
+	*/
+	async move(options) {
+		if (this.hooks?.beforeMove) await this.hooks.beforeMove(options);
+		const result = await this.storage.move(options);
+		if (this.database && result.success) {
+			const dbFile = await this.database.get(options.sourceKey);
+			if (dbFile) {
+				await this.database.delete(options.sourceKey);
+				await this.database.create({
+					...dbFile,
+					key: options.destinationKey
+				});
+			} else if (this.autoSync) {
+				const metadata = await this.storage.getMetadata(options.destinationKey);
+				if (metadata) await this.database.create({
+					key: metadata.key,
+					size: metadata.size,
+					lastModified: metadata.lastModified,
+					contentType: metadata.contentType,
+					etag: metadata.etag
+				});
+			}
+		}
+		if (this.hooks?.afterMove) await this.hooks.afterMove(options);
+		return result;
+	}
+	/**
+	* Copy a file to a new location
+	*/
+	async copy(options) {
+		if (this.hooks?.beforeCopy) await this.hooks.beforeCopy(options);
+		const result = await this.storage.copy(options);
+		if (this.database && result.success) {
+			const sourceFile = await this.database.get(options.sourceKey);
+			if (sourceFile) await this.database.create({
+				...sourceFile,
+				key: options.destinationKey
+			});
+			else if (this.autoSync) {
+				const metadata = await this.storage.getMetadata(options.destinationKey);
+				if (metadata) await this.database.create({
+					key: metadata.key,
+					size: metadata.size,
+					lastModified: metadata.lastModified,
+					contentType: metadata.contentType,
+					etag: metadata.etag
+				});
+			}
+		}
+		if (this.hooks?.afterCopy) await this.hooks.afterCopy(options);
+		return result;
+	}
+	/**
+	* Rename a file (alias for move)
+	*/
+	async rename(oldKey, newKey) {
+		return this.move({
+			sourceKey: oldKey,
+			destinationKey: newKey
+		});
+	}
+	/**
+	* Sync storage files to database
+	*/
+	async syncToDatabase(options = {}) {
+		if (!this.database) throw new FileManagerError("Database not configured", "DATABASE_NOT_CONFIGURED", 400);
+		let hasMore = true;
+		let cursor = options.cursor;
+		while (hasMore) {
+			const result = await this.storage.list({
+				...options,
+				cursor
+			});
+			await this.database.sync(result.data);
+			hasMore = result.hasMore;
+			cursor = result.nextCursor;
+		}
+	}
+	/**
+	* Create a file record in database (useful after upload)
+	*/
+	async createDatabaseRecord(file) {
+		if (!this.database) return null;
+		return this.database.create(file);
+	}
+	/**
+	* Update file metadata in database
+	*/
+	async updateDatabaseRecord(key, data) {
+		if (!this.database) return null;
+		return this.database.update(key, data);
+	}
+};
+
+//#endregion
+//#region src/router.ts
+/**
+* Request validation schemas
+*/
+const ListOptionsSchema = z.object({
+	prefix: z.string().optional(),
+	delimiter: z.string().optional(),
+	maxKeys: z.number().min(1).max(1e4).optional(),
+	cursor: z.object({
+		continuationToken: z.string().optional(),
+		offset: z.number().optional()
+	}).optional(),
+	sortBy: z.enum([
+		"name",
+		"size",
+		"lastModified"
+	]).optional(),
+	sortOrder: z.enum(["asc", "desc"]).optional(),
+	userId: z.string().optional()
+});
+const DownloadUrlOptionsSchema = z.object({
+	expiresIn: z.number().optional(),
+	disposition: z.enum(["inline", "attachment"]).optional(),
+	filename: z.string().optional()
+});
+const MoveOptionsSchema = z.object({
+	sourceKey: z.string().min(1),
+	destinationKey: z.string().min(1),
+	deleteSource: z.boolean().optional()
+});
+const CopyOptionsSchema = z.object({
+	sourceKey: z.string().min(1),
+	destinationKey: z.string().min(1),
+	metadata: z.record(z.string()).optional()
+});
+const RenameOptionsSchema = z.object({ newKey: z.string().min(1) });
+const FileOperationRequestSchema = z.object({
+	action: z.enum([
+		"list",
+		"delete",
+		"batchDelete",
+		"exists",
+		"getMetadata",
+		"getUrl",
+		"move",
+		"copy",
+		"rename",
+		"createFolder"
+	]),
+	key: z.string().optional(),
+	keys: z.array(z.string()).optional(),
+	options: z.record(z.string(), z.unknown()).optional(),
+	source: z.enum([
+		"storage",
+		"database",
+		"both"
+	]).optional()
+});
+/**
+* FileManager Router - Handles HTTP requests for file operations
+*/
+var FileManagerRouter = class {
+	fileManager;
+	authorize;
+	getAuthContext;
+	constructor(config) {
+		this.fileManager = config.fileManager;
+		this.authorize = config.authorize;
+		this.getAuthContext = config.getAuthContext;
+	}
+	/**
+	* Handle incoming request
+	*/
+	async handle(request) {
+		try {
+			const body = await request.json();
+			const validatedRequest = FileOperationRequestSchema.parse(body);
+			const authContext = this.getAuthContext ? await this.getAuthContext(request) : {};
+			if (this.authorize) {
+				if (!await this.authorize(authContext, validatedRequest.action, validatedRequest.key || "batch")) return this.errorResponse("Unauthorized", "UNAUTHORIZED", 403);
+			}
+			const result = await this.routeAction(validatedRequest, authContext);
+			return this.successResponse(result);
+		} catch (error) {
+			return this.handleError(error);
+		}
+	}
+	/**
+	* Route action to appropriate handler
+	*/
+	async routeAction(request, authContext) {
+		const { action, key, keys, options, source } = request;
+		switch (action) {
+			case "list": return this.fileManager.list(ListOptionsSchema.parse(options ?? {}), source);
+			case "delete":
+				if (!key) throw new FileManagerError("Key is required for delete", "MISSING_KEY", 400);
+				return this.fileManager.delete(key);
+			case "batchDelete":
+				if (!keys || keys.length === 0) throw new FileManagerError("Keys are required for batchDelete", "MISSING_KEYS", 400);
+				return this.fileManager.deleteBatch(keys);
+			case "exists":
+				if (!key) throw new FileManagerError("Key is required for exists", "MISSING_KEY", 400);
+				return { exists: await this.fileManager.exists(key, source) };
+			case "getMetadata":
+				if (!key) throw new FileManagerError("Key is required for getMetadata", "MISSING_KEY", 400);
+				return this.fileManager.getMetadata(key, source);
+			case "getUrl":
+				if (!key) throw new FileManagerError("Key is required for getUrl", "MISSING_KEY", 400);
+				return { url: await this.fileManager.getDownloadUrl(key, DownloadUrlOptionsSchema.parse(options ?? {})) };
+			case "move":
+				const moveOpts = MoveOptionsSchema.parse(options);
+				return this.fileManager.move(moveOpts);
+			case "copy":
+				const copyOpts = CopyOptionsSchema.parse(options);
+				return this.fileManager.copy(copyOpts);
+			case "rename":
+				if (!key) throw new FileManagerError("Key is required for rename", "MISSING_KEY", 400);
+				const renameOpts = RenameOptionsSchema.parse(options);
+				return this.fileManager.rename(key, renameOpts.newKey);
+			case "createFolder":
+				if (!key) throw new FileManagerError("Key is required for createFolder", "MISSING_KEY", 400);
+				return {
+					success: true,
+					key,
+					message: "Folder created"
+				};
+			default: throw new FileManagerError(`Unknown action: ${action}`, "UNKNOWN_ACTION", 400);
+		}
+	}
+	/**
+	* Success response
+	*/
+	successResponse(data) {
+		const response = {
+			success: true,
+			data
+		};
+		return new Response(JSON.stringify(response), {
+			status: 200,
+			headers: { "Content-Type": "application/json" }
+		});
+	}
+	/**
+	* Error response
+	*/
+	errorResponse(message, code, status) {
+		const response = {
+			success: false,
+			error: message,
+			code
+		};
+		return new Response(JSON.stringify(response), {
+			status,
+			headers: { "Content-Type": "application/json" }
+		});
+	}
+	/**
+	* Handle errors
+	*/
+	handleError(error) {
+		console.error("FileManager Router Error:", error);
+		if (error instanceof FileManagerError) return this.errorResponse(error.message, error.code, error.statusCode);
+		if (error instanceof z.ZodError) return this.errorResponse(`Validation error: ${error.errors.map((e) => e.message).join(", ")}`, "VALIDATION_ERROR", 400);
+		return this.errorResponse("Internal server error", "INTERNAL_ERROR", 500);
+	}
+};
+/**
+* Create a new FileManager router instance
+*/
+function createFileManagerRouter(config) {
+	return new FileManagerRouter(config);
+}
+
+//#endregion
+export { S3StorageProvider as a, PostgresDatabaseProvider as i, createFileManagerRouter as n, FileManagerError as o, FileManager as r, FileManagerRouter as t };