@protobase/server 0.30.0 → 0.30.2

package/dist/storage/upload-object.js

@@ -0,0 +1,37 @@
+import { accepts } from "../files/media-types.js";
+import { findBucket } from "./bucket-sql.js";
+import { bucketNotFound, mimeTypeRefused } from "./storage-error.js";
+import { asApp } from "./storage-db.js";
+import { writeObject } from "./write-object.js";
+import { incomingObject } from "./object-body.js";
+//#region src/storage/upload-object.ts
+/** The bucket an upload goes to, read as the app, as Supabase Storage reads it: its size limit and allowed types. */
+const uploadBucket = async (deps, id) => {
+	const bucket = await asApp(deps, (trx) => findBucket(trx, id));
+	if (!bucket) throw bucketNotFound();
+	return bucket;
+};
+/**
+* Stores the object a request uploads at `target` (see `writeObject`), within the bucket's size limit and the app's,
+* and of a type the bucket allows. Answers what storage-js reads back: the row's id and `<bucket>/<name>`.
+*/
+const uploadObject = async (deps, request, target) => {
+	const bucket = await uploadBucket(deps, target.bucket);
+	const maxBytes = Math.min(bucket.file_size_limit ?? Infinity, deps.maxBytes);
+	const incoming = await incomingObject(request, maxBytes);
+	const type = incoming.type.split(";", 1)[0].trim().toLowerCase();
+	if (bucket.allowed_mime_types?.length && !accepts(bucket.allowed_mime_types, type)) {
+		await incoming.body.cancel();
+		throw mimeTypeRefused(type);
+	}
+	const { id } = await writeObject(deps, target, {
+		...incoming,
+		store: (key) => deps.store.put(key, incoming.body)
+	});
+	return {
+		Id: id,
+		Key: `${target.bucket}/${target.name}`
+	};
+};
+//#endregion
+export { uploadBucket, uploadObject };

package/dist/storage/write-object.js

@@ -0,0 +1,85 @@
+import { accessDenied, alreadyExists } from "./storage-error.js";
+import { objectKey } from "./object-key.js";
+import { findObject, insertObject, updateObject } from "./object-sql.js";
+import { asApp, becomeCaller } from "./storage-db.js";
+//#region src/storage/write-object.ts
+/** The owner Supabase records for a write: the signed-in user, or nobody for the keys alone. */
+const ownerOf = (caller) => caller.role === "authenticated" && typeof caller.claims.sub === "string" ? caller.claims.sub : null;
+const writeRow = async (trx, deps, target, write) => {
+	const existing = await findObject(trx, target.bucket, target.name, true);
+	if (existing && !target.upsert) throw alreadyExists();
+	await becomeCaller(trx, deps, target.caller);
+	if (!existing) return {
+		id: await insertObject(trx, target.bucket, target.name, write),
+		replaced: void 0
+	};
+	if (!await updateObject(trx, existing.id, write)) throw accessDenied();
+	return {
+		id: existing.id,
+		replaced: existing
+	};
+};
+var ProbeDone = class extends Error {};
+/**
+* Whether the caller may write the object, decided by the restored policies on a row written and rolled back, before
+* any byte is stored: a refused upload costs no storage. Throws the refusal.
+*/
+const probeWrite = async (deps, target, type) => {
+	const metadata = {
+		eTag: "",
+		size: 0,
+		mimetype: type,
+		cacheControl: "",
+		lastModified: (/* @__PURE__ */ new Date()).toISOString(),
+		contentLength: 0,
+		httpStatusCode: 200
+	};
+	await asApp(deps, async (trx) => {
+		await writeRow(trx, deps, target, {
+			owner: target.owner,
+			version: crypto.randomUUID(),
+			metadata,
+			user_metadata: null
+		});
+		throw new ProbeDone();
+	}).catch((error) => {
+		if (!(error instanceof ProbeDone)) throw error;
+	});
+};
+/**
+* Writes an object: checks the caller may (`probeWrite`), stores the bytes under a new version, then writes the row
+* as the caller in one transaction, so the policies decide again on the real row. When that fails, the new bytes are
+* deleted; once it commits, the bytes of the object it replaced are.
+*/
+const writeObject = async (deps, target, bytes) => {
+	await probeWrite(deps, target, bytes.type);
+	const version = crypto.randomUUID();
+	const key = await objectKey(target.bucket, target.name, version);
+	const { size } = await bytes.store(key);
+	const metadata = {
+		eTag: `"${version}"`,
+		size,
+		mimetype: bytes.type,
+		cacheControl: bytes.cacheControl,
+		lastModified: (/* @__PURE__ */ new Date()).toUTCString(),
+		contentLength: size,
+		httpStatusCode: 200
+	};
+	const write = {
+		owner: target.owner,
+		version,
+		metadata,
+		user_metadata: bytes.userMetadata
+	};
+	const written = await asApp(deps, (trx) => writeRow(trx, deps, target, write)).catch(async (error) => {
+		await deps.store.delete(key);
+		throw error;
+	});
+	if (written.replaced) await deps.store.delete(await objectKey(target.bucket, target.name, written.replaced.version));
+	return {
+		id: written.id,
+		metadata
+	};
+};
+//#endregion
+export { ownerOf, probeWrite, writeObject };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@protobase/server",
-  "version": "0.30.0",
+  "version": "0.30.2",
   "description": "The Protobase REST API as a Hono app, with Better Auth sign-in.",
   "license": "Apache-2.0",
   "repository": {
@@ -32,9 +32,9 @@
   "dependencies": {
     "@better-auth/passkey": "^1.7.7",
     "@better-auth/sso": "^1.7.7",
-    "@protobase/layout": "0.30.0",
-    "@protobase/query": "0.30.0",
-    "@protobase/schema": "0.30.0",
+    "@protobase/layout": "0.30.2",
+    "@protobase/query": "0.30.2",
+    "@protobase/schema": "0.30.2",
     "@react-email/render": "^2.1.0",
     "@scalar/hono-api-reference": "^0.12.10",
     "@sentry/core": "^11.7.0",