@tulip-systems/core 0.7.0 → 0.8.0

package/dist/modules/storage/lib/service.server.mjs

@@ -1,304 +1,515 @@
 import { ServerError } from "../../router/lib/error.server.mjs";
-import { BUCKET_NAME } from "../../../lib/config/constants.mjs";
-import { getDriveBucketKey, inferNodeSubtype, isFile, isFolder } from "./helpers.mjs";
-import { generateDefaultUUID } from "../../config/db/helpers.mjs";
-import { convertSearchToQueryParams } from "../../data-tables/lib/converters/search.mjs";
-import { convertOrderByToQueryParams } from "../../data-tables/lib/converters/sorting.mjs";
-import { deviceSizes } from "./constants.mjs";
-import { nodePresignedUrls, nodeVariants, nodes } from "./schema.mjs";
-import { getFileURLSchemaDefaults, getObjectSchema, putObjectSchema } from "./validators.mjs";
-import { addSeconds } from "date-fns";
-import { and, asc, eq, inArray, isNotNull, isNull } from "drizzle-orm";
-import { after } from "next/server";
-import { DeleteObjectsCommand, GetObjectCommand, PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
-import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+import { generateDefaultUUID } from "../../database/lib/helpers.mjs";
+import { storageAssets } from "./schema.mjs";
+import { confirmUploadInputSchema, presignUploadInputSchema, uploadInputSchema } from "./validators.mjs";
+import { StorageAdapterError } from "../providers/lib/errors.mjs";
+import z from "zod";
+import { and, desc, eq, inArray, isNotNull, isNull } from "drizzle-orm";
 
 //#region src/modules/storage/lib/service.server.ts
 /**
-* Storage Service
+* Storage service for working with asset metadata and object storage.
+*
+* Use `Storage.init()` to create a fully configured instance in app code.
+*
+* @param props - Storage configuration, including `db` and `adapter`
+* @returns A ready-to-use `Storage` instance
+* @example
+* const storage = Storage.init({
+*   db: drizzle(dbConnection),
+*   adapter: new StorageS3Adapter({
+*     bucketName: "my-app-uploads",
+*     region: "us-east-1",
+*     credentials: {
+*       accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+*       secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+*     },
+*   }),
+* });
 */
-var StorageService = class {
-	/**
-	* S3 Client
-	*/
-	#blob;
+var Storage = class Storage {
+	#adapter;
 	#db;
+	prefix;
+	constructor({ db, adapter, prefix }) {
+		this.#db = db;
+		this.#adapter = adapter;
+		this.prefix = prefix ?? "uploads";
+	}
 	/**
-	* Constructor
+	* Create a storage service instance.
+	*
+	* This keeps the public API aligned with other Tulip services such as
+	* `Database.init()`, `Email.init()`, and `Auth.init()`.
+	*
+	* @param props - Storage configuration, including `db` and `adapter`
+	* @returns A new `Storage` instance
+	* @example
+	* const storage = Storage.init({
+	*   db: drizzle(dbConnection),
+	*   adapter: new StorageS3Adapter({
+	*     bucketName: "my-app-uploads",
+	*     region: "us-east-1",
+	*     credentials: {
+	*       accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+	*       secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+	*     },
+	*   }),
+	* });
 	*/
-	constructor({ db, config }) {
-		this.#db = db;
-		this.#blob = new S3Client(config);
+	static init(props) {
+		return new Storage(props);
 	}
 	/**
-	* Get Blob
+	* Generates the canonical object key for a storage asset id.
+	*
+	* This keeps bucket key structure internal to the storage service,
+	* so callers only work with asset ids and do not manage object paths.
+	*
+	* @param input - Storage asset id (UUID)
+	* @returns Canonical storage key (e.g. `uploads/<id>`)
+	* @example
+	* const key = this.#generateKey("019d0051-2c0d-741e-9e3c-e5a5bc4d16a2");
+	* // key => "uploads/019d0051-2c0d-741e-9e3c-e5a5bc4d16a2"
 	*/
-	blob() {
-		return this.#blob;
+	#generateKey(input) {
+		const id = z.uuid().parse(input);
+		return `${this.prefix}/${id}`;
 	}
 	/**
-	* Create get command
+	* Builds a query to fetch a storage asset by its ID and the current adapter's provider.
+	* @param id - The asset ID to search for
+	* @returns A dynamic Drizzle query for fetching a single asset
+	* @example
+	* let query = storageService.getAssetByIdQuery("asset-123");
+	* query = query.where(eq(storageAssets.contentType, "image/png")); // Add additional conditions if needed
+	* const [asset] = await query;
 	*/
-	#createGetCommand(props) {
-		const input = getObjectSchema.parse(props);
-		return new GetObjectCommand({
-			Bucket: BUCKET_NAME,
-			Key: getDriveBucketKey(input.id, input.variant),
-			ResponseContentDisposition: input.disposition
-		});
+	getAssetByIdQuery(id) {
+		return this.#db.select().from(storageAssets).where(and(eq(storageAssets.id, id), eq(storageAssets.provider, this.#adapter.key), eq(storageAssets.bucket, this.#adapter.bucketName), isNull(storageAssets.deletedAt))).limit(1).$dynamic();
 	}
 	/**
-	* Get object
+	* Fetches a storage asset by its ID.
+	* @param id - The asset ID to retrieve
+	* @returns The asset object if found, otherwise null
+	* @example
+	* const asset = await storageService.getAssetById("asset-123");
+	* if (asset) {
+	*   console.log(asset.key, asset.contentType);
+	* }
 	*/
-	async getObject(id, options = getFileURLSchemaDefaults) {
-		const getCommand = this.#createGetCommand({
-			...options,
-			id
-		});
-		return await this.#blob.send(getCommand);
+	async getAssetById(id) {
+		const parsedId = z.uuid().parse(id);
+		const [asset] = await this.getAssetByIdQuery(parsedId);
+		return asset ?? null;
 	}
 	/**
-	* Create put command
+	* Builds a query to fetch a single ready storage asset by key
+	* within the current adapter provider scope.
+	*
+	* Notes:
+	* - Scoped to `this.#adapter.key` to avoid cross-provider leakage.
+	* - Targets ready assets by default.
+	* - Uniqueness is expected on `(provider, bucket, key)`.
+	*
+	* @param key - The object key stored in `storage_assets.key`
+	* @returns A dynamic Drizzle query returning max 1 row
+	* @example
+	* let query = storageService.getAssetByKeyQuery("uploads/abc/main");
+	* query = query.leftJoin(otherTable, eq(otherTable.assetId, storageAssets.id));
+	* const [asset] = await query;
 	*/
-	#createPutCommand(props) {
-		const input = putObjectSchema.parse(props);
-		return new PutObjectCommand({
-			Bucket: BUCKET_NAME,
-			Key: getDriveBucketKey(input.id, input.variant),
-			Body: input.body,
-			ContentType: input.contentType ?? void 0,
-			ContentLength: input.size ?? void 0,
-			Metadata: { nodeId: input.id }
-		});
+	getAssetByKeyQuery(key) {
+		return this.#db.select().from(storageAssets).where(and(eq(storageAssets.key, key), eq(storageAssets.provider, this.#adapter.key), eq(storageAssets.bucket, this.#adapter.bucketName), eq(storageAssets.status, "ready"), isNull(storageAssets.deletedAt))).limit(1).$dynamic();
 	}
 	/**
-	* Put object
+	* Fetches a single ready storage asset by key.
+	*
+	* This is the convenience wrapper around `getAssetByKeyQuery`.
+	* Use this when you only need the result, not query composition.
+	*
+	* @param key - Asset key to look up
+	* @returns The matching asset or `null` if none is found
+	* @example
+	* const asset = await storageService.getAssetByKey("uploads/abc/main");
+	* if (!asset) return;
 	*/
-	async #putObject(props) {
-		const putCommand = this.#createPutCommand(props);
-		return await this.#blob.send(putCommand);
+	async getAssetByKey(key) {
+		const [result] = await this.getAssetByKeyQuery(key);
+		return result ?? null;
 	}
 	/**
-	* Get node by id
+	* Builds a base query for listing storage assets.
+	*
+	* Scope and defaults:
+	* - Scoped to the current adapter provider (`this.#adapter.key`)
+	* - Orders by newest first (`createdAt DESC`)
+	*
+	* This method returns a dynamic query so callers can extend it with
+	* custom filters, joins, pagination, and limits.
+	*
+	* @returns A dynamic Drizzle query for listing assets
+	* @example
+	* const query = storageService
+	*   .listAssetsQuery()
+	*   .limit(50);
+	* const assets = await query;
 	*/
-	async getNodeById(id) {
-		return this.#db.select().from(nodes).where(eq(nodes.id, id));
+	listAssetsQuery() {
+		return this.#db.select().from(storageAssets).where(and(eq(storageAssets.provider, this.#adapter.key), eq(storageAssets.bucket, this.#adapter.bucketName), isNull(storageAssets.deletedAt))).orderBy(desc(storageAssets.createdAt)).$dynamic();
 	}
 	/**
-	* Get nodes by parent id
+	* Lists storage assets using safe default pagination.
+	*
+	* This is the convenience wrapper around `listAssetsQuery`.
+	* Use `listAssetsQuery()` directly when you need custom query composition.
+	*
+	* @returns Up to 100 storage assets sorted by newest first
+	* @example
+	* const assets = await storageService.listAssets();
 	*/
-	async getNodesByParentId({ filters, ...query }) {
-		const orderBy = convertOrderByToQueryParams(query, nodes, asc(nodes.createdAt));
-		const search = convertSearchToQueryParams(query, [nodes.name]);
-		return this.#db.select().from(nodes).where(and(filters.nodeIds != null ? inArray(nodes.id, filters.nodeIds) : void 0, filters.types != null ? inArray(nodes.type, filters.types) : void 0, filters.isDeleted != null ? eq(nodes.isDeleted, filters.isDeleted) : void 0, filters.isOrphaned === true ? isNotNull(nodes.orphanedAt) : filters.isOrphaned === false ? isNull(nodes.orphanedAt) : void 0, filters.hidden != null ? eq(nodes.hidden, filters.hidden) : void 0, filters.parentId ? eq(nodes.parentId, filters.parentId) : isNull(nodes.parentId), eq(nodes.namespace, filters.namespace), search)).orderBy(orderBy);
+	async listAssets() {
+		return await this.listAssetsQuery().limit(100) ?? [];
 	}
 	/**
-	* Get file url
+	* Creates a pending storage asset record and generates a presigned upload URL.
+	*
+	* Flow:
+	* - Validates the input payload
+	* - Inserts a `pending` asset in the catalog (`storage_assets`)
+	* - Requests a presigned PUT URL from the storage adapter
+	* - Marks the asset as `error` if URL generation fails
+	*
+	* This method is intended for direct-to-storage browser uploads.
+	* The upload should be finalized later via a confirm step.
+	*
+	* @param props - Presign upload input (contentType, size, metadata)
+	* @returns The created asset id, key, and presigned URL
+	* @throws {ServerError} If intent creation or URL generation fails
+	* @example
+	* const result = await storageService.presignUpload({
+	*   contentType: "image/png",
+	*   size: 120_000,
+	*   metadata: { uploadToken: crypto.randomUUID() },
+	* });
+	* // result => { id, uploadId, key, presignedUrl }
 	*/
-	async getSignedURL(node, options = getFileURLSchemaDefaults) {
-		const [presignedUrl] = await this.#db.select({
-			url: nodePresignedUrls.url,
-			expiresAt: nodePresignedUrls.expiresAt
-		}).from(nodePresignedUrls).where(and(eq(nodePresignedUrls.nodeId, node.id), eq(nodePresignedUrls.variant, options.variant), eq(nodePresignedUrls.disposition, options.disposition)));
-		if (presignedUrl && presignedUrl.expiresAt > /* @__PURE__ */ new Date()) return presignedUrl.url;
-		const expiresIn = 3600 * 24;
-		const variant = (await this.#db.select().from(nodeVariants).where(eq(nodeVariants.nodeId, node.id))).find((v) => v.variant === options.variant) ? options.variant : "main";
-		console.info(`Generating new signed url for file: ${node.id} with variant: ${variant} and disposition: ${options.disposition}`);
-		const getCommand = this.#createGetCommand({
-			id: node.id,
-			variant,
-			disposition: `${options.disposition}; filename="${node.name}"`
-		});
-		const url = await getSignedUrl(this.#blob, getCommand, { expiresIn });
-		after(async () => {
-			await this.#db.insert(nodePresignedUrls).values({
-				nodeId: node.id,
-				url,
-				variant,
-				disposition: options.disposition,
-				expiresAt: addSeconds(/* @__PURE__ */ new Date(), expiresIn)
-			}).onConflictDoUpdate({
-				target: [
-					nodePresignedUrls.nodeId,
-					nodePresignedUrls.variant,
-					nodePresignedUrls.disposition
-				],
-				set: {
-					url,
-					expiresAt: addSeconds(/* @__PURE__ */ new Date(), expiresIn)
-				}
+	async presignUpload(props) {
+		const input = presignUploadInputSchema.parse(props);
+		const id = generateDefaultUUID();
+		const uploadId = input.uploadId ?? generateDefaultUUID();
+		const key = this.#generateKey(id);
+		const { contentType, size, metadata, name, visibility } = input;
+		const [record] = await this.#db.insert(storageAssets).values({
+			id,
+			uploadId,
+			key,
+			size,
+			contentType,
+			name,
+			visibility,
+			provider: this.#adapter.key,
+			bucket: this.#adapter.bucketName,
+			status: "pending",
+			metadata
+		}).returning();
+		if (!record) throw new ServerError("INTERNAL_SERVER_ERROR", { message: "Failed to create upload intent" });
+		try {
+			const presignedUrl = await this.#adapter.putObjectURL({
+				key,
+				contentType,
+				size,
+				metadata
 			});
-		});
-		return url;
+			return {
+				...record,
+				presignedUrl
+			};
+		} catch (error) {
+			await this.#db.update(storageAssets).set({ status: "error" }).where(eq(storageAssets.id, record.id));
+			throw this.#parseError(error, { fallbackMessage: "Failed to generate upload URL" });
+		}
 	}
 	/**
-	* Upload file to S3 and add it to the database
-	**/
-	async uploadFile(input) {
-		const id = input.id ?? generateDefaultUUID();
-		return await this.#db.transaction(async (tx) => {
-			const [result] = await tx.insert(nodes).values({
-				id,
-				type: "file",
-				name: input.name,
-				namespace: input.namespace,
-				parentId: input.parentId,
-				size: input.size,
-				contentType: input.contentType,
-				mode: input.mode,
-				subtype: inferNodeSubtype(input)
-			}).returning();
-			if (!result) throw new ServerError("INTERNAL_SERVER_ERROR", { message: "Oep! Er is iets fout gegaan" });
-			await this.#putObject({
-				id,
-				body: input.body,
-				variant: "main",
-				name: input.name,
-				contentType: input.contentType,
-				size: input.size
+	* Confirms a direct-to-storage upload by verifying object existence
+	* and transitioning the asset from `pending` to `ready`.
+	*
+	* Flow:
+	* - Validates confirm input
+	* - Loads the asset record scoped to the current adapter provider
+	* - Returns early if asset is already `ready` (idempotent behavior)
+	* - Verifies object existence/metadata via `adapter.headObject`
+	* - Marks asset as `error` if verification fails
+	* - Updates status to `ready` and stores upload metadata
+	*
+	* @param props - Confirm upload payload containing the asset uploadId
+	* @returns The updated storage asset record
+	* @throws {ServerError} If the asset is missing, verification fails, or update fails
+	* @example
+	* const asset = await storageService.confirmUpload("019d0051-2c0d-741e-9e3c-e5a5bc4d16a2");
+	* // asset.status === "ready"
+	*/
+	async confirmUpload(props) {
+		const uploadId = confirmUploadInputSchema.parse(props);
+		const [record] = await this.#db.select().from(storageAssets).where(and(eq(storageAssets.uploadId, uploadId), eq(storageAssets.provider, this.#adapter.key), eq(storageAssets.bucket, this.#adapter.bucketName), isNull(storageAssets.deletedAt))).limit(1);
+		if (!record) throw new ServerError("NOT_FOUND", { message: "Storage asset not found" });
+		if (record.status === "ready") return record;
+		let head;
+		try {
+			head = await this.#adapter.headObject({ key: record.key });
+		} catch (error) {
+			await this.#db.update(storageAssets).set({ status: "error" }).where(eq(storageAssets.id, record.id));
+			throw this.#parseError(error, { fallbackMessage: "Failed to verify uploaded object" });
+		}
+		const [updated] = await this.#db.update(storageAssets).set({
+			status: "ready",
+			uploadedAt: /* @__PURE__ */ new Date(),
+			size: head.size ?? record.size,
+			contentType: head.contentType ?? record.contentType
+		}).where(and(eq(storageAssets.id, record.id), eq(storageAssets.status, "pending"))).returning();
+		if (!updated) throw new ServerError("INTERNAL_SERVER_ERROR", { message: "Failed to confirm upload" });
+		return updated;
+	}
+	/**
+	* Uploads an asset directly from the server and persists its catalog record.
+	*
+	* Flow:
+	* - Validates upload input
+	* - Creates a `pending` asset record in `storage_assets`
+	* - Uploads the object bytes through the storage adapter
+	* - Marks the record as `ready` and stores upload metadata
+	* - Marks the record as `error` if upload fails
+	*
+	* This method is intended for server-side uploads (non-presigned flow).
+	* For browser direct uploads, use `presignUpload` + `confirmUpload`.
+	*
+	* @param props - Upload payload (body, contentType, size)
+	* @returns The finalized storage asset record
+	* @throws {ServerError} If record creation, upload, or finalization fails
+	* @example
+	* const asset = await storageService.upload({
+	*   body: fileBuffer,
+	*   contentType: "application/pdf",
+	*   size: fileBuffer.byteLength,
+	* });
+	*/
+	async upload(props) {
+		const { body, contentType, size, metadata, name, visibility } = uploadInputSchema.parse(props);
+		const id = generateDefaultUUID();
+		const key = this.#generateKey(id);
+		const [record] = await this.#db.insert(storageAssets).values({
+			id,
+			key,
+			size,
+			contentType,
+			name,
+			visibility,
+			provider: this.#adapter.key,
+			bucket: this.#adapter.bucketName,
+			status: "pending",
+			metadata
+		}).returning();
+		if (!record) throw new ServerError("INTERNAL_SERVER_ERROR", { message: "Failed to create upload record" });
+		try {
+			const uploaded = await this.#adapter.putObject({
+				key,
+				body,
+				contentType,
+				size,
+				metadata
 			});
-			return result;
+			const [updated] = await this.#db.update(storageAssets).set({
+				status: "ready",
+				uploadedAt: /* @__PURE__ */ new Date(),
+				size: uploaded.size ?? size ?? record.size,
+				contentType: uploaded.contentType ?? contentType ?? record.contentType
+			}).where(and(eq(storageAssets.id, record.id), eq(storageAssets.status, "pending"))).returning();
+			if (!updated) throw new ServerError("INTERNAL_SERVER_ERROR", { message: "Failed to finalize upload" });
+			return updated;
+		} catch (error) {
+			await this.#db.update(storageAssets).set({ status: "error" }).where(and(eq(storageAssets.id, record.id), eq(storageAssets.status, "pending")));
+			throw this.#parseError(error, { fallbackMessage: "Failed to upload object" });
+		}
+	}
+	/**
+	* Retrieves the object content for a ready storage asset.
+	*
+	* Flow:
+	* - Looks up the asset record by id, scoped to the current adapter provider
+	* - Ensures the asset is in `ready` status
+	* - Fetches object content from the storage adapter using the stored key
+	*
+	* @param id - The storage asset id
+	* @returns The adapter object response (stream/body + metadata)
+	* @throws {ServerError} If the asset does not exist or is not ready
+	* @example
+	* const object = await storageService.getObject("asset-123");
+	* // object.body can be streamed/consumed by caller
+	*/
+	async getObject(input) {
+		const id = z.uuid().parse(input);
+		const [record] = await this.#db.select().from(storageAssets).where(and(eq(storageAssets.id, id), eq(storageAssets.provider, this.#adapter.key), eq(storageAssets.bucket, this.#adapter.bucketName), eq(storageAssets.status, "ready"), isNull(storageAssets.deletedAt))).limit(1);
+		if (!record) throw new ServerError("NOT_FOUND", { message: "Storage asset not found" });
+		return this.#adapter.getObject(record.key).catch((error) => {
+			throw this.#parseError(error, { fallbackMessage: "Failed to retrieve object" });
 		});
 	}
 	/**
-	* Presign a new upload
+	* Generates a presigned read URL for a ready storage asset.
+	*
+	* Flow:
+	* - Validates the asset id
+	* - Resolves the asset record scoped to the current adapter provider
+	* - Ensures the asset is in `ready` status
+	* - Delegates URL signing to the storage adapter using the stored key
+	*
+	* @param input - Storage asset id (UUID)
+	* @param options - Optional URL options (for example expiration/disposition)
+	* @returns A presigned URL for reading the object
+	* @throws {ServerError} If the asset does not exist or is not ready
+	* @example
+	* const url = await storageService.getObjectURL("019d0051-2c0d-741e-9e3c-e5a5bc4d16a2", {
+	*   expiresIn: 3600,
+	* });
 	*/
-	async presignUpload(input) {
-		const putCommand = this.#createPutCommand({
-			id: input.id,
-			name: input.name,
-			variant: "main",
-			contentType: input.contentType,
-			size: input.size
+	async getObjectURL(input, options) {
+		const id = z.uuid().parse(input);
+		const [record] = await this.#db.select().from(storageAssets).where(and(eq(storageAssets.id, id), eq(storageAssets.provider, this.#adapter.key), eq(storageAssets.bucket, this.#adapter.bucketName), eq(storageAssets.status, "ready"), isNull(storageAssets.deletedAt))).limit(1);
+		if (!record) throw new ServerError("NOT_FOUND", { message: "Storage asset not found" });
+		return this.#adapter.getObjectURL(record.key, options).catch((error) => {
+			throw this.#parseError(error, { fallbackMessage: "Failed to generate object URL" });
 		});
-		const presignedUrl = await getSignedUrl(this.#blob, putCommand, { expiresIn: 3600 });
-		const [node] = await this.#db.insert(nodes).values({
-			...input,
-			subtype: inferNodeSubtype(input),
-			isPending: true,
-			type: "file",
-			id: input.id
-		}).returning();
-		if (!node) throw new ServerError("INTERNAL_SERVER_ERROR", { message: "Oep! Er is iets fout gegaan" });
-		return {
-			id: input.id,
-			presignedUrl,
-			node
-		};
 	}
 	/**
-	* Confirm a new upload
+	* Soft deletes a single storage asset by id.
+	*
+	* This is a convenience wrapper around `deleteAssets`.
+	*
+	* @param input - Storage asset id (UUID)
+	* @returns The soft-deleted asset record, or null if not found/already deleted
 	*/
-	async confirmUpload(input) {
-		const [result] = await this.#db.update(nodes).set({ isPending: false }).where(eq(nodes.id, input.id)).returning();
-		if (!result) throw new ServerError("NOT_FOUND", { message: "File not found" });
-		/**
-		* Generate the preview version of the file
-		*/
-		await this.generatePreviews(input);
-		return result;
+	async deleteAsset(input) {
+		const id = z.uuid().parse(input);
+		const [deleted] = await this.deleteAssets([id]);
+		return deleted ?? null;
 	}
 	/**
-	* Generate preview version of the file
+	* Soft deletes multiple storage assets by setting `deletedAt`.
+	*
+	* Flow:
+	* - Validates and de-duplicates ids
+	* - Resolves provider-scoped active records
+	* - Marks matching rows as deleted by setting `deletedAt`
+	*
+	* @param input - Storage asset ids (UUID[])
+	* @returns Soft-deleted asset records
 	*/
-	async generatePreviews(input) {
-		/**
-		* Get the main version of the file
-		*/
-		const getCommand = this.#createGetCommand({
-			id: input.id,
-			variant: "main"
-		});
-		const response = await this.#blob.send(getCommand);
-		const contentType = response.ContentType;
-		if (!response.Body) throw new ServerError("INTERNAL_SERVER_ERROR", { message: "Oep! Er is iets fout gegaan" });
-		/**
-		* Transform the main version of the file to a buffer
-		*/
-		const byteArray = await response.Body.transformToByteArray();
-		const buffer = Buffer.from(byteArray);
-		/**
-		* Generate the preview versions for images
-		*/
-		if (contentType?.startsWith("image/")) {
-			const sharp = await import("sharp");
-			await Promise.allSettled(deviceSizes.flatMap(async (width) => {
-				const preview = await sharp.default(buffer).resize({ width }).webp().toBuffer();
-				return this.#db.transaction(async (tx) => {
-					await this.#putObject({
-						id: input.id,
-						body: preview,
-						variant: `preview-${width}`,
-						contentType: "image/webp",
-						size: preview.byteLength
-					});
-					await tx.insert(nodeVariants).values({
-						nodeId: input.id,
-						variant: `preview-${width}`,
-						width
-					});
-				});
-			}));
-		}
+	async deleteAssets(input) {
+		const ids = [...new Set(z.array(z.uuid()).parse(input))];
+		if (ids.length === 0) return [];
+		return this.#db.update(storageAssets).set({ deletedAt: /* @__PURE__ */ new Date() }).where(and(inArray(storageAssets.id, ids), eq(storageAssets.provider, this.#adapter.key), eq(storageAssets.bucket, this.#adapter.bucketName), isNull(storageAssets.deletedAt))).returning();
 	}
 	/**
-	* Create a new folder
+	* Restores a single soft-deleted storage asset.
+	*
+	* This is a convenience wrapper around `restoreAssets`.
+	*
+	* @param input - Storage asset id (UUID)
+	* @returns The restored asset record, or null if not found/not deleted
 	*/
-	async createFolder(input) {
-		const [parent] = input.parentId ? await this.#db.select().from(nodes).where(eq(nodes.id, input.parentId)) : [];
-		/**
-		* Validate
-		*/
-		if (input.parentId && !parent) throw new ServerError("BAD_REQUEST", { message: "Parent not found" });
-		if (parent && !isFolder(parent)) throw new ServerError("BAD_REQUEST", { message: "Parent is not a folder" });
-		if (parent && parent.namespace !== input.namespace) throw new ServerError("BAD_REQUEST", { message: "Parent is not in the same namespace" });
-		/**
-		* Create the folder
-		*/
-		const [result] = await this.#db.insert(nodes).values({
-			...input,
-			type: "folder"
-		}).returning();
-		if (!result) throw new ServerError("INTERNAL_SERVER_ERROR", { message: "Folder kon niet worden aangemaakt" });
-		return result;
+	async restoreAsset(input) {
+		const id = z.uuid().parse(input);
+		const [restored] = await this.restoreAssets([id]);
+		return restored ?? null;
+	}
+	/**
+	* Restores multiple soft-deleted storage assets by clearing `deletedAt`.
+	*
+	* @param input - Storage asset ids (UUID[])
+	* @returns Restored asset records
+	*/
+	async restoreAssets(input) {
+		const ids = [...new Set(z.array(z.uuid()).parse(input))];
+		if (ids.length === 0) return [];
+		return this.#db.update(storageAssets).set({ deletedAt: null }).where(and(inArray(storageAssets.id, ids), eq(storageAssets.provider, this.#adapter.key), eq(storageAssets.bucket, this.#adapter.bucketName), isNotNull(storageAssets.deletedAt))).returning();
 	}
 	/**
-	* Update a node
+	* Hard deletes a single storage asset.
+	*
+	* This is a convenience wrapper around `purgeAssets`.
+	*
+	* @param input - Storage asset id (UUID)
+	* @returns The purged asset record, or null if not found
 	*/
-	async updateNode(input) {
-		const [node] = await this.#db.select({ readonly: nodes.readonly }).from(nodes).where(eq(nodes.id, input.id));
-		if (node?.readonly) throw new ServerError("BAD_REQUEST", { message: "Node is readonly" });
-		const [result] = await this.#db.update(nodes).set(input.data).where(eq(nodes.id, input.id)).returning();
-		if (!result) throw new ServerError("INTERNAL_SERVER_ERROR", { message: "Node kon niet worden gewijzigd" });
-		return result;
+	async purgeAsset(input) {
+		const id = z.uuid().parse(input);
+		const [deleted] = await this.purgeAssets([id]);
+		return deleted ?? null;
 	}
 	/**
-	* Delete nodes
+	* Hard deletes multiple storage assets.
+	*
+	* Flow:
+	* - Validates and de-duplicates ids
+	* - Resolves provider-scoped records
+	* - Deletes physical objects from the adapter by key
+	* - Hard deletes DB records
+	*
+	* @param input - Storage asset ids (UUID[])
+	* @returns Purged asset records
+	* @throws {ServerError} If provider deletion fails
 	*/
-	async deleteNodes(input) {
-		const items = await this.#db.select({
-			id: nodes.id,
-			type: nodes.type,
-			readonly: nodes.readonly
-		}).from(nodes).where(inArray(nodes.id, input.ids));
-		if (items.some((item) => item.readonly)) throw new ServerError("BAD_REQUEST", { message: "Nodes are readonly" });
-		const folders = items.filter(isFolder).map((folder) => folder.id);
-		const files = items.filter(isFile).map((file) => file.id);
-		const deleteCommand = files.length > 0 ? new DeleteObjectsCommand({
-			Bucket: BUCKET_NAME,
-			Delete: { Objects: files.map((id) => ({ Key: id })) }
-		}) : void 0;
-		/**
-		* Delete files and folders in a transaction
-		*/
-		await this.#db.transaction(async (tx) => {
-			await tx.delete(nodes).where(inArray(nodes.id, folders));
-			await tx.delete(nodes).where(inArray(nodes.id, files));
-			if (deleteCommand) await this.#blob.send(deleteCommand);
+	async purgeAssets(input) {
+		const ids = [...new Set(z.array(z.uuid()).parse(input))];
+		if (ids.length === 0) return [];
+		const records = await this.#db.select({
+			id: storageAssets.id,
+			key: storageAssets.key
+		}).from(storageAssets).where(and(inArray(storageAssets.id, ids), eq(storageAssets.provider, this.#adapter.key), eq(storageAssets.bucket, this.#adapter.bucketName)));
+		if (records.length === 0) return [];
+		const keys = records.map((r) => r.key);
+		try {
+			await this.#adapter.deleteObjects(keys);
+		} catch (error) {
+			throw this.#parseError(error, { fallbackMessage: "Failed to delete storage objects" });
+		}
+		const deletedIds = records.map((r) => r.id);
+		return await this.#db.delete(storageAssets).where(and(inArray(storageAssets.id, deletedIds), eq(storageAssets.provider, this.#adapter.key), eq(storageAssets.bucket, this.#adapter.bucketName))).returning();
+	}
+	/**
+	* Normalizes unknown adapter/service errors into a consistent `ServerError`.
+	*
+	* Behavior:
+	* - Returns existing `ServerError` instances unchanged
+	* - Maps known storage adapter errors to application-level server errors
+	* - Falls back to a generic internal server error for unknown failures
+	*
+	* This keeps adapter-specific errors inside the storage layer while exposing
+	* a stable error contract to route handlers and RPC procedures.
+	*
+	* @param error - The unknown error to normalize
+	* @param options - Optional fallback message for non-specific failures
+	* @returns A normalized `ServerError`
+	*/
+	#parseError(error, options) {
+		if (error instanceof ServerError) return error;
+		if (error instanceof StorageAdapterError) {
+			if (error.code === "OBJECT_NOT_FOUND") return new ServerError("NOT_FOUND", {
+				message: "Storage asset not found",
+				cause: error
+			});
+			return new ServerError("INTERNAL_SERVER_ERROR", {
+				message: options?.fallbackMessage ?? "Storage adapter error",
+				cause: error
+			});
+		}
+		return new ServerError("INTERNAL_SERVER_ERROR", {
+			message: options?.fallbackMessage ?? "Unknown storage error",
+			cause: error instanceof Error ? error : void 0
 		});
 	}
 };
 
 //#endregion
-export { StorageService };
+export { Storage };
 //# sourceMappingURL=service.server.mjs.map