@voltro/plugin-storage 0.85.0 → 0.87.0

package/dist/sourceIdentity.js

@@ -0,0 +1,14 @@
+import { createHash as e } from "node:crypto";
+import { canonicalJson as t } from "@voltro/protocol";
+//#region src/sourceIdentity.ts
+var n = (n) => e("sha256").update(t({
+	id: n.id,
+	tenantId: n.tenantId,
+	bucket: n.bucket,
+	key: n.key,
+	contentType: n.contentType,
+	size: n.size,
+	checksum: n.checksum
+})).digest("hex");
+//#endregion
+export { n as retainedSourceDigest };

package/dist/sourcePin.js

@@ -0,0 +1,35 @@
+import { StorageError as e } from "./types.js";
+import { retainedSourceDigest as t } from "./sourceIdentity.js";
+import { ownRenditionRef as n } from "./renditionProof.js";
+import { createHash as r } from "node:crypto";
+import { canonicalJson as i } from "@voltro/protocol";
+//#region src/sourcePin.ts
+var a = (e) => r("sha256").update(i(e)).digest("hex"), o = (e, t) => typeof e == "string" && e.length > 0 && e.length <= t, s = (e, t) => e == null || typeof e == "string" && e.length <= t, c = (r, i) => {
+	let c = n(r);
+	if (!o(i, 256) || !o(c.id, 64) || !o(c.bucket, 128) || c.tenantId !== null && !o(c.tenantId, 64) || !o(c.checksum, 512) || !o(c.contentType, 512) || !Number.isSafeInteger(c.size) || c.size < 0 || !s(c.derivedFrom, 64) || !s(c.kind, 512)) throw new e({
+		provider: "custody",
+		message: "Invalid custody source metadata",
+		status: 409,
+		transient: !1
+	});
+	let l = {
+		version: 1,
+		instance: i,
+		tenantId: c.tenantId,
+		bucket: c.bucket,
+		id: c.id,
+		sourceDigest: t(c),
+		checksum: c.checksum,
+		size: c.size,
+		contentType: c.contentType,
+		derivedFrom: c.derivedFrom ?? null,
+		kind: c.kind ?? null,
+		renditionProof: c.renditionProof ?? null
+	};
+	return {
+		...l,
+		digest: a(l)
+	};
+};
+//#endregion
+export { c as pinStorageSource };

package/dist/storageNamespaces.js

@@ -0,0 +1,80 @@
+import { StorageError as e } from "@voltro/kv/storage";
+import { Effect as t } from "effect";
+import { createHash as n, randomUUID as r } from "node:crypto";
+import { authoredError as i } from "@voltro/database";
+import { linkSync as a, mkdirSync as o, readFileSync as s, realpathSync as c, rmSync as l, writeFileSync as u } from "node:fs";
+import { basename as d, dirname as f, join as p, resolve as m } from "node:path";
+//#region src/storageNamespaces.ts
+var h = (e) => n("sha256").update(JSON.stringify(e)).digest("hex"), g = (n, r) => ("resolveNamespace" in n ? n.resolveNamespace(r) : t.succeed(n.objectNamespace)).pipe(t.flatMap((r) => t.try({
+	try: () => {
+		let e = {
+			storageInstance: n.storageInstance,
+			objectNamespace: r
+		};
+		return _(e), e;
+	},
+	catch: () => new e({
+		provider: "metadata",
+		message: "Storage reference scope is invalid",
+		transient: !1
+	})
+}))), _ = (e) => {
+	if (!e?.storageInstance?.trim() || !/^[a-f0-9]{64}$/.test(e.objectNamespace)) throw i("Storage requires a configured instance and a stable physical objectNamespace SHA-256 identity");
+}, v = (e) => {
+	let t = m(e), n = [];
+	for (;;) try {
+		return p(c(t), ...n.reverse());
+	} catch (e) {
+		if (!(e instanceof Error && "code" in e && e.code === "ENOENT")) throw e;
+		let r = f(t);
+		if (r === t) throw e;
+		n.push(d(t)), t = r;
+	}
+}, y = (e) => {
+	let t = new URL(e);
+	return t.username = "", t.password = "", t.search = "", t.hash = "", t.href.replace(/\/+$/, "");
+}, b = ".voltro-object-namespace", x = (e) => {
+	o(e, { recursive: !0 });
+	let t = p(e, b), n;
+	try {
+		n = s(t, "utf8");
+	} catch (e) {
+		if (!(e instanceof Error && "code" in e && e.code === "ENOENT")) throw e;
+		let i = h(["filesystem-volume", r()]), o = `${t}-${r()}`;
+		try {
+			u(o, i, {
+				flag: "wx",
+				mode: 384
+			});
+			try {
+				a(o, t);
+			} catch (e) {
+				if (!(e instanceof Error && "code" in e && e.code === "EEXIST")) throw e;
+			}
+			n = s(t, "utf8");
+		} finally {
+			l(o, { force: !0 });
+		}
+	}
+	if (!/^[a-f0-9]{64}$/.test(n)) throw i("Filesystem storage object namespace marker is invalid; restore the volume marker before serving storage");
+	return n;
+}, S = (e) => {
+	let t;
+	try {
+		t = s(p(e, b), "utf8");
+	} catch (t) {
+		throw t instanceof Error && "code" in t && t.code === "ENOENT" ? i(`Filesystem storage volume at ${e} carries no ${b} marker; mount the volume the serving replicas use before assigning namespaces`) : t;
+	}
+	if (!/^[a-f0-9]{64}$/.test(t)) throw i("Filesystem storage object namespace marker is invalid; restore the volume marker before serving storage");
+	return t;
+}, C = (e) => {
+	if (_(e), typeof e.catalogueId != "string" || !e.catalogueId.trim()) throw i("Storage upload tickets require an actual reference catalogue identity");
+	return h([
+		"upload-ticket-destination",
+		e.storageInstance,
+		e.catalogueId,
+		e.objectNamespace
+	]);
+};
+//#endregion
+export { b as FILESYSTEM_NAMESPACE_FILE, v as canonicalStorageRoot, S as existingFilesystemObjectNamespace, x as filesystemObjectNamespace, _ as requireStorageReferenceScope, y as storageEndpointIdentity, h as storageObjectNamespace, g as storageReferenceScopeFor, C as storageUploadTicketScope };

package/dist/storageNumbers.js

@@ -0,0 +1,13 @@
+import { StorageError as e } from "./types.js";
+//#region src/storageNumbers.ts
+var t = (t, n) => {
+	let r = typeof t == "number" ? t : typeof t == "bigint" || typeof t == "string" && /^\d+$/.test(t) ? Number(t) : NaN;
+	if (!Number.isSafeInteger(r) || r < 0) throw new e({
+		provider: "metadata",
+		message: `Storage ${n} must be a non-negative safe integer at most Number.MAX_SAFE_INTEGER`,
+		transient: !1
+	});
+	return r;
+}, n = (e, n, r) => t(e + n, r);
+//#endregion
+export { t as storageInteger, n as storageIntegerSum };

package/dist/storageObjectNamespaces.js

@@ -0,0 +1,243 @@
+import { requireStorageReferenceScope as e } from "./storageNamespaces.js";
+import { STORAGE_GRANTS_TABLE as t, STORAGE_REFS_TABLE as n } from "./table.js";
+import { storageInteger as r, storageIntegerSum as i } from "./storageNumbers.js";
+import { storageObjectClaimId as a, storageObjectIdentifiers as o } from "./objectLifecycle.js";
+import { Schema as s } from "effect";
+import { createHash as c } from "node:crypto";
+import { authoredError as l, inSet as u, isNull as d, or as f } from "@voltro/database";
+//#region src/storageObjectNamespaces.ts
+var p = "_voltro_storage_put_intents", m = "_voltro_storage_operations", h = "_voltro_storage_object_heads", g = "_voltro_storage_object_claims", _ = [
+	n,
+	t,
+	p,
+	m
+], v = s.Struct({
+	tenantId: s.NullOr(s.String),
+	bucket: s.String,
+	operationId: s.String,
+	fingerprint: s.String,
+	checksum: s.String,
+	logicalKey: s.String
+}), y = s.Struct({
+	id: s.String,
+	objectId: s.String,
+	fingerprint: s.String,
+	generation: s.String,
+	key: s.String,
+	refId: s.String,
+	state: s.Literals([
+		"reserved",
+		"ready",
+		"deleting",
+		"deleted"
+	]),
+	deleteKey: s.NullOr(s.String)
+}), b = (e) => c("sha256").update(JSON.stringify(e)).digest("hex"), x = (e) => JSON.stringify([e.storageInstance, e.objectNamespace]), S = (e, t) => JSON.stringify([e.objectNamespace, t]), C = (e, t) => e.query({
+	table: t,
+	predicate: void 0,
+	lock: "update",
+	order: [],
+	take: void 0,
+	skip: void 0,
+	projection: void 0
+}), w = 500, T = (e) => {
+	let t = [];
+	for (let n = 0; n < e.length; n += w) t.push(e.slice(n, n + w));
+	return t;
+}, E = async (e) => {
+	let t = [];
+	for (let n of [..._, h]) {
+		let r = n === h ? d("objectNamespace") : f(d("storageInstance"), d("objectNamespace")), [i] = await e.query({
+			table: n,
+			predicate: r,
+			order: [],
+			take: void 0,
+			skip: void 0,
+			projection: void 0,
+			aggregations: [{
+				op: "count",
+				alias: "unassigned"
+			}]
+		}), a = Number(i?.unassigned ?? 0);
+		a > 0 && t.push(`${n}: ${a}`);
+	}
+	if (t.length > 0) throw l(`Storage physical namespace migration required: assign references and retained operations to their configured storageInstance and provider objectNamespace before starting the app (unassigned rows — ${t.join(", ")}). Rows written after an assignment already ran — by a replica of the previous version — need the assignment again: a recorded file migration does not re-run, so repeat the idempotent assignment over every reference in a new migration.`);
+}, D = async (e, t, n) => k(e, t, n), O = async (t, n, r) => {
+	let i = /* @__PURE__ */ new Map();
+	for (let t of r) {
+		if (e(t.from), t.from.storageInstance !== t.storageInstance) throw l("Storage snapshot relocation must preserve the configured plugin instance");
+		let n = i.get(t.refId);
+		if (n && x(n) !== x(t.from)) throw l("Storage snapshot source scope is ambiguous");
+		i.set(t.refId, t.from);
+	}
+	return k(t, n, r.map(({ from: e, ...t }) => t), i);
+}, k = async (c, d, f, _) => {
+	for (let t of d) e(t);
+	if (!d.length || new Set(d.map(x)).size !== d.length) throw l("Provide distinct configured storage instance and physical namespace pairs");
+	let w = new Set(d.map(x)), D = /* @__PURE__ */ new Map();
+	for (let { refId: t, ...n } of f) {
+		if (e(n), !t.trim() || !w.has(x(n))) throw l("Storage namespace assignment must name a reference and a configured physical scope");
+		let r = D.get(t);
+		if (r && x(r) !== x(n)) throw l("Storage physical namespace assignment is ambiguous");
+		D.set(t, n);
+	}
+	let O = [];
+	for (let e of [
+		n,
+		t,
+		p,
+		m,
+		h,
+		g
+	]) O.push(await C(c, e));
+	let [k, A, j, M, N, P] = O, F = /* @__PURE__ */ new Set(), I = (e, t) => {
+		let n = D.get(e);
+		if (!n) throw l("Storage physical namespace assignment is incomplete");
+		if (_ !== void 0) {
+			let r = _.get(e);
+			if (r === void 0 || ![r, n].some((e) => t.storageInstance === e.storageInstance && t.objectNamespace === e.objectNamespace)) throw l("Storage snapshot metadata does not match its declared source or restored target scope");
+		} else for (let e of ["storageInstance", "objectNamespace"]) if (t[e] != null && t[e] !== n[e]) throw l("Storage metadata already belongs to another physical scope; assignment does not move objects");
+		return F.add(e), n;
+	};
+	for (let e of k) I(String(e.id), e);
+	let L = new Map(k.map((e) => [e.id, e]));
+	for (let e of A) if (I(String(e.refId), e), !L.has(e.refId)) throw l("Storage grant has no readable reference");
+	let R = /* @__PURE__ */ new Map();
+	for (let e of j) {
+		if (I(String(e.refId), e), R.has(String(e.id))) throw l("Storage put intent ownership is ambiguous");
+		R.set(String(e.id), e);
+	}
+	let z = /* @__PURE__ */ new Map(), B = M.map((e) => {
+		let t = s.decodeUnknownSync(y)(e), n = I(t.refId, e), a = R.get(t.id);
+		if (!a || a.refId !== t.refId) throw l("Storage operation lost its retained put intent");
+		let c = {
+			...s.decodeUnknownSync(v)(a.identity),
+			...n
+		};
+		typeof a.identity == "object" && a.identity !== null && I(t.refId, a.identity);
+		let u = o(c), d = b([
+			c.bucket,
+			c.tenantId,
+			c.operationId
+		]), f = b([
+			c.bucket,
+			c.tenantId,
+			c.logicalKey,
+			c.checksum
+		]), p = _ === void 0 ? void 0 : o({
+			...c,
+			storageInstance: String(e.storageInstance),
+			objectNamespace: String(e.objectNamespace)
+		});
+		if (!(p === void 0 ? [d, u.id].includes(t.id) && [f, u.objectId].includes(t.objectId) : t.id === p.id && t.objectId === p.objectId) || t.fingerprint !== c.fingerprint) throw l("Storage operation identity does not match its retained intent");
+		if (typeof a.ref != "object" || a.ref === null || Array.isArray(a.ref)) throw l("Storage put intent reference is unreadable");
+		let m = a.ref;
+		if (m.id !== t.refId || m.key !== t.key || m.checksum !== c.checksum || m.tenantId !== c.tenantId || m.bucket !== c.bucket) throw l("Storage operation reference does not match its retained intent");
+		let h = L.get(t.refId);
+		if (t.state === "ready") {
+			if (!h || h.key !== t.key || h.checksum !== c.checksum) throw l("Ready storage operation lost its readable reference");
+		} else if (h) throw l("Unreadable storage operation still owns a readable reference");
+		if (t.state === "ready" || t.state === "reserved") {
+			let e = z.get(u.objectId);
+			if (e && (e.generation !== t.generation || e.key !== t.key)) throw l("Storage physical namespace has conflicting active generations");
+			z.set(u.objectId, {
+				id: u.objectId,
+				objectNamespace: n.objectNamespace,
+				generation: t.generation,
+				key: t.key,
+				reservations: String(i(e ? r(e.reservations, "shared-object reservation count") : 0, 1, "shared-object reservation count"))
+			});
+		}
+		return {
+			previous: t,
+			previousNamespace: e.objectNamespace,
+			row: {
+				...t,
+				...n,
+				id: u.id,
+				objectId: u.objectId
+			},
+			intent: a,
+			identity: c
+		};
+	});
+	if (B.length !== j.length || new Set(B.map((e) => e.row.id)).size !== B.length) throw l("Storage operation namespace migration has unmatched or conflicting identities");
+	let V = /* @__PURE__ */ new Map();
+	for (let e of B) (e.previous.state === "ready" || e.previous.state === "reserved") && V.set(e.previous.objectId, [...V.get(e.previous.objectId) ?? [], e]);
+	for (let e of N) {
+		let t = V.get(String(e.id)) ?? [];
+		if (!t.length || t.length !== r(e.reservations, "shared-object reservation count") || t.some(({ previous: t, previousNamespace: n, identity: r }) => t.generation !== e.generation || t.key !== e.key || e.objectNamespace != null && e.objectNamespace !== (_ === void 0 ? r.objectNamespace : n))) throw l("Storage object head does not match its active reservations");
+	}
+	let H = new Set(N.map((e) => e.id));
+	for (let { previous: e } of B) if ((e.state === "ready" || e.state === "reserved") && !H.has(e.objectId)) throw l("Storage operation lost its active object head");
+	if ([...D.keys()].some((e) => !F.has(e))) throw l("Storage namespace assignment target does not exist");
+	let U = new Map(B.map((e) => [e.previous.id, e])), W = P.map((e) => {
+		let t = U.get(String(e.operationId));
+		if (!t || typeof e.claim != "string" || !e.claim || e.id !== a(String(e.operationId), e.claim)) throw l("Storage operation claim does not match its retained operation");
+		return {
+			...e,
+			id: a(t.row.id, e.claim),
+			operationId: t.row.id
+		};
+	}), G = /* @__PURE__ */ new Set([...k.map((e) => S(D.get(String(e.id)), String(e.key))), ...[...z.values()].map((e) => JSON.stringify([e.objectNamespace, e.key]))]), K = [];
+	for (let e of B) {
+		let t = G.has(S(e.identity, e.row.key));
+		(e.row.state === "deleting" || e.row.state === "deleted") && (t ? e.row.deleteKey = null : e.row.state === "deleted" && e.row.deleteKey === null && (e.row.state = "deleting", e.row.deleteKey = e.row.key), e.row.state === "deleting" && e.row.deleteKey !== null && K.push({
+			refId: e.row.refId,
+			storageInstance: e.identity.storageInstance,
+			objectNamespace: e.identity.objectNamespace
+		}));
+	}
+	let q = 0;
+	for (let [e, r, i] of [[
+		n,
+		k,
+		"id"
+	], [
+		t,
+		A,
+		"refId"
+	]]) {
+		let t = /* @__PURE__ */ new Map();
+		for (let e of r) {
+			let n = D.get(String(e[i]));
+			if (e.storageInstance === n.storageInstance && e.objectNamespace === n.objectNamespace) continue;
+			let r = t.get(x(n)) ?? {
+				scope: n,
+				ids: []
+			};
+			r.ids.push(String(e.id)), t.set(x(n), r);
+		}
+		for (let { scope: n, ids: r } of t.values()) for (let t of T(r)) {
+			let r = await c.updateMany(e, {
+				storageInstance: n.storageInstance,
+				objectNamespace: n.objectNamespace
+			}, { where: u("id", t) });
+			if (r !== t.length) throw l("Storage physical namespace assignment lost its metadata row");
+			q += r;
+		}
+	}
+	for (let [e, t] of [
+		[g, P],
+		[p, j],
+		[m, M],
+		[h, N]
+	]) for (let n of T(t.map((e) => String(e.id)))) if (await c.deleteMany(e, { where: u("id", n) }) !== n.length) throw l("Storage physical namespace assignment lost a retained row");
+	let J = async (e, t) => {
+		for (let n of T(t)) await c.insertMany(e, n, { returning: "none" });
+	};
+	await J(h, [...z.values()]), await J(m, B.map((e) => e.row)), await J(p, B.map((e) => ({
+		...e.intent,
+		id: e.row.id,
+		storageInstance: e.identity.storageInstance,
+		objectNamespace: e.identity.objectNamespace,
+		identity: e.identity
+	})));
+	for (let e of B) (e.previous.id !== e.row.id || e.intent.objectNamespace !== e.identity.objectNamespace || e.previous.state !== e.row.state || e.previous.deleteKey !== e.row.deleteKey) && q++;
+	return await J(g, W), await E(c), {
+		assigned: q,
+		pendingDeletes: K
+	};
+};
+//#endregion
+export { D as assignStorageObjectNamespacesInTransaction, O as relocateRestoredStorageObjectNamespacesInTransaction, E as requireStorageObjectNamespaces };

package/dist/storageReferenceInstances.js

@@ -0,0 +1,52 @@
+import { STORAGE_GRANTS_TABLE as e, STORAGE_REFS_TABLE as t } from "./table.js";
+import { authoredError as n, eq as r, isNull as i } from "@voltro/database";
+//#region src/storageReferenceInstances.ts
+var a = "@voltro/plugin-storage", o = [
+	t,
+	e,
+	"_voltro_storage_put_intents"
+], s = async (e) => {
+	for (let t of o) if ((await e.query({
+		table: t,
+		predicate: i("storageInstance"),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: ["id"]
+	})).length) throw n("Storage reference ownership migration required: assign existing references, grants and put intents to their configured storageInstance before starting the app");
+}, c = async (e, t, i) => {
+	if (t.length === 0 || t.some((e) => !e.trim()) || new Set(t).size !== t.length) throw n("Provide distinct configured storage instance names");
+	let a = new Set(t), s = /* @__PURE__ */ new Map();
+	for (let e of i) {
+		if (!e.refId.trim() || !a.has(e.storageInstance)) throw n("Storage reference assignment must name a reference and a configured instance");
+		let t = s.get(e.refId);
+		if (t !== void 0 && t !== e.storageInstance) throw n("Storage reference assignment is ambiguous");
+		s.set(e.refId, e.storageInstance);
+	}
+	let c = e, l = 0;
+	for (let [e, t] of s) {
+		let i = !1;
+		for (let a of o) {
+			let o = await c.query({
+				table: a,
+				predicate: r(a === "_voltro_storage_refs" ? "id" : "refId", e),
+				lock: "update",
+				order: [],
+				take: void 0,
+				skip: void 0,
+				projection: void 0
+			});
+			for (let e of o) {
+				if (i = !0, e.storageInstance !== null && e.storageInstance !== void 0 && e.storageInstance !== t) throw n("Storage reference already belongs to another instance; assignment does not move objects");
+				if (e.storageInstance !== t) {
+					if (await c.update(a, String(e.id), { storageInstance: t }) === null) throw n("Storage reference assignment lost its metadata row");
+					l++;
+				}
+			}
+		}
+		if (!i) throw n("Storage reference assignment target does not exist");
+	}
+	return { assigned: l };
+};
+//#endregion
+export { a as DEFAULT_STORAGE_INSTANCE, c as assignStorageReferenceInstancesInTransaction, s as requireStorageReferenceOwnership };

package/dist/storageRequest.js

@@ -0,0 +1,10 @@
+import { Effect as e } from "effect";
+//#region src/storageRequest.ts
+var t = (t, n, r) => e.callback((i) => {
+	let a = new AbortController(), o = Promise.resolve().then(() => t(a.signal));
+	return o.then((t) => i(e.succeed(t)), (t) => i(e.fail(n(t)))), e.sync(() => {
+		a.abort();
+	}).pipe(e.andThen(e.promise(() => o.then((e) => ({ value: e }), () => void 0))), e.flatMap((t) => t !== void 0 && r !== void 0 ? r(t.value) : e.void));
+});
+//#endregion
+export { t as storageRequest };

package/dist/storageRouting.js

@@ -0,0 +1,46 @@
+import { StorageAddress as e, StorageError as t } from "@voltro/kv/storage";
+import { Effect as n, Schema as r } from "effect";
+//#region src/storageRouting.ts
+var i = () => new t({
+	provider: "storage",
+	message: "Storage destination is unknown, ambiguous or unavailable for this tenant",
+	transient: !1
+}), a = (e, t, r) => n.suspend(() => {
+	if (e === void 0 || !t.startsWith("storage:")) return n.fail(i());
+	let a = t;
+	return e.validate(a).pipe(n.mapError(() => i()), n.flatMap((t) => t.tenantScoped && r === null ? n.fail(i()) : e.storage(a, r === null ? void 0 : { tenantId: r }).pipe(n.mapError(() => i()))));
+}), o = (t) => {
+	let o = (e, r) => e.startsWith("storage:") ? a(t.registry(), e, r) : e === t.directDestination ? n.try({
+		try: t.directProvider,
+		catch: () => i()
+	}) : n.fail(i());
+	return {
+		select: (a) => n.suspend(() => {
+			let s = t.selected();
+			return r.decodeUnknownEffect(e)({
+				destination: s,
+				tenantId: a,
+				key: "selection"
+			}).pipe(n.mapError(() => i()), n.flatMap((e) => o(e.destination, e.tenantId)), n.map((e) => ({
+				destination: s,
+				provider: e
+			})));
+		}),
+		resolve: (t) => r.decodeUnknownEffect(e)(t).pipe(n.mapError(() => i()), n.flatMap((e) => o(e.destination, e.tenantId)))
+	};
+}, s = (t) => {
+	let o = t.flatMap((e) => e.capabilities?.storageDestinations === void 0 ? [] : [e.capabilities.storageDestinations]);
+	return {
+		select: (e) => o.length === 1 ? o[0].router.select(e) : n.fail(i()),
+		resolve: (t) => r.decodeUnknownEffect(e)(t).pipe(n.mapError(() => i()), n.flatMap((e) => {
+			if (e.destination.startsWith("storage:")) {
+				let t = new Set(o.map((e) => e.registry()).filter((e) => e !== void 0));
+				return t.size === 1 ? a([...t][0], e.destination, e.tenantId) : n.fail(i());
+			}
+			let t = o.filter((t) => t.directDestination === e.destination);
+			return t.length === 1 ? t[0].router.resolve(e) : n.fail(i());
+		}))
+	};
+};
+//#endregion
+export { s as appStorageRouter, o as makeStorageDestinationRouter };

package/dist/streamBridge.js

@@ -0,0 +1,33 @@
+import { StorageError as e } from "./types.js";
+import { Effect as t, Stream as n } from "effect";
+//#region src/streamBridge.ts
+var r = 1 << 20, i = (t, n, r = !1) => new e({
+	provider: t,
+	message: n,
+	transient: r
+}), a = (e) => {
+	let t = 0;
+	for (let n of e) t += n.byteLength;
+	let n = new Uint8Array(t), r = 0;
+	for (let t of e) n.set(t, r), r += t.byteLength;
+	return n;
+}, o = (e, t = r) => {
+	let i = [];
+	for (let n = 0; n < e.byteLength; n += t) i.push(e.subarray(n, Math.min(n + t, e.byteLength)));
+	return n.fromIterable(i);
+}, s = (e) => e.pipe(n.runCollect, t.map((e) => a(e))), c = (e, t) => n.suspend(() => n.fromAsyncIterable(t(), (t) => i(e, `read stream failed: ${String(t?.message ?? t)}`, !0))).pipe(n.map((e) => e instanceof Uint8Array ? e : new Uint8Array(e))), l = async (e) => {
+	let { Readable: t } = await import("node:stream");
+	return t.fromWeb(n.toReadableStream(e));
+}, u = (e, r) => e.getStream ? e.getStream(r).pipe(t.map((e) => e.close === void 0 ? e : {
+	...e,
+	stream: e.stream.pipe(n.ensuring(e.close))
+})) : e.get(r).pipe(t.map((e) => ({
+	stream: o(e.bytes),
+	contentType: e.contentType,
+	size: e.bytes.byteLength
+}))), d = (e, n, r, i) => e.putStream ? e.putStream(n, r, i) : s(r).pipe(t.flatMap((t) => e.put(n, t, {
+	contentType: i.contentType,
+	...i.public === void 0 ? {} : { public: i.public }
+})));
+//#endregion
+export { o as bytesToStream, s as collectStream, a as concatBytes, c as fromNodeReadable, u as getObjectStream, d as putObjectStream, l as toNodeReadable };

package/dist/table.js

@@ -0,0 +1,54 @@
+import { bigint as e, bytes as t, id as n, integer as r, json as i, table as a, text as o, timestamp as s } from "@voltro/database";
+//#region src/table.ts
+var c = "_voltro_storage_refs", l = "_voltro_storage_grants", u = "_voltro_storage_blobs", d = "_voltro_storage_usage", f = a(c, {
+	id: n({ prefix: "file" }),
+	storageInstance: o().nullable(),
+	objectNamespace: o().maxLength(64).nullable(),
+	tenantId: o().nullable(),
+	ownerId: o().nullable(),
+	bucket: o(),
+	key: o(),
+	contentType: o(),
+	size: e(),
+	checksum: o(),
+	visibility: o(),
+	accessPolicy: i().nullable(),
+	passwordHash: o().nullable(),
+	width: r().nullable(),
+	height: r().nullable(),
+	duration: r().nullable(),
+	placeholder: o().nullable(),
+	folder: o().nullable(),
+	tags: i().nullable(),
+	alt: o().nullable(),
+	caption: o().nullable(),
+	derivedFrom: o().nullable(),
+	kind: o().nullable(),
+	renditionProof: i().nullable(),
+	createdAt: s()
+}).index(["storageInstance"]).index(["objectNamespace"]).index(["key"]).index(["tenantId"]).index(["ownerId"]).index(["folder"]).index(["derivedFrom"]), p = a(l, {
+	id: n({ prefix: "sgrant" }),
+	storageInstance: o().nullable(),
+	objectNamespace: o().maxLength(64).nullable(),
+	refId: o(),
+	principalType: o(),
+	principalId: o(),
+	permission: o(),
+	createdAt: s(),
+	expiresAt: s().nullable(),
+	createdBy: o().nullable()
+}).index(["storageInstance"]).index(["objectNamespace"]).index(["refId"]).index(["principalId"]), m = a(d, {
+	id: n({ prefix: "susage" }),
+	tenantId: o().maxLength(191),
+	bytes: e().default("0"),
+	count: e().default("0"),
+	updatedAt: s()
+}).unique("byStorageUsageTenant", ["tenantId"]), h = a(u, {
+	id: n({ prefix: "blob" }),
+	key: o(),
+	data: t(),
+	contentType: o(),
+	size: e()
+}).index(["key"]);
+//#endregion
+export { u as STORAGE_BLOBS_TABLE, l as STORAGE_GRANTS_TABLE, c as STORAGE_REFS_TABLE, d as STORAGE_USAGE_TABLE, h as _voltroStorageBlobsTable, p as _voltroStorageGrantsTable, f as _voltroStorageRefsTable, m as _voltroStorageUsageTable };

package/dist/transcodeVideo.js

@@ -0,0 +1,91 @@
+import { createHash as e } from "node:crypto";
+import { join as t } from "node:path";
+import { canonicalJson as n } from "@voltro/protocol";
+import { mkdtemp as r, readFile as i, rm as a, writeFile as o } from "node:fs/promises";
+import { tmpdir as s } from "node:os";
+import { spawn as c } from "node:child_process";
+//#region src/transcodeVideo.ts
+var l = (e, t, n) => new Promise((r, i) => {
+	let a = c(e, [...t], { stdio: [
+		"ignore",
+		"pipe",
+		"pipe"
+	] }), o = "", s = "", l, u = (e) => {
+		l === void 0 && (l = Error(e), a.kill("SIGKILL"));
+	}, d = setTimeout(() => u("ffmpeg timed out"), n);
+	a.stdout?.on("data", (e) => {
+		if (o.length + e.length > 65536) return u("ffmpeg output exceeds its metadata bound");
+		o += String(e);
+	}), a.stderr?.on("data", (e) => {
+		s = (s + String(e)).slice(-400);
+	}), a.on("error", (e) => {
+		clearTimeout(d), i(e);
+	}), a.on("close", (e) => {
+		clearTimeout(d), l === void 0 ? e === 0 ? r(o) : i(/* @__PURE__ */ Error(`ffmpeg exited ${String(e)}: ${s}`)) : i(l);
+	});
+}), u = (t) => e("sha256").update(t).digest("hex"), d = (e) => {
+	let t = e.replace(/\r\n/g, "\n").trim(), n = t.split("\n")[0] ?? "";
+	if (!n.startsWith("ffmpeg version ") || n.length > 512) throw Error("ffmpeg version metadata unavailable");
+	return {
+		name: "ffmpeg",
+		version: n.slice(15),
+		digest: u(t)
+	};
+}, f = (e) => {
+	let c = e.ffmpegPath ?? "ffmpeg", f = e.timeoutMs ?? 3e5, p = e.renditions.map((e) => ({
+		...e,
+		args: [...e.args]
+	}));
+	return async ({ bytes: e }) => {
+		let m = await r(t(s(), "voltro-tc-")), h = t(m, "in"), g = [];
+		try {
+			await o(h, e);
+			for (let e of p) {
+				let r = t(m, `out.${e.ext}`);
+				try {
+					let t = performance.now() + f, o = (e) => {
+						let n = Math.ceil(t - performance.now());
+						if (n <= 0) throw Error("ffmpeg rendition timed out");
+						return l(c, e, n);
+					}, s = d(await o(["-version"]));
+					await o([
+						"-y",
+						"-i",
+						h,
+						...e.args,
+						r
+					]);
+					let p = d(await o(["-version"]));
+					if (s.digest !== p.digest) throw Error("ffmpeg build changed during rendition");
+					let m = await i(r);
+					g.push({
+						bytes: new Uint8Array(m),
+						contentType: e.contentType,
+						kind: e.kind,
+						derivation: {
+							engine: s,
+							recipe: {
+								format: "ffmpeg-cli/v1",
+								digest: u(n({
+									kind: e.kind,
+									contentType: e.contentType,
+									ext: e.ext,
+									args: e.args
+								}))
+							}
+						},
+						...e.label === void 0 ? {} : { label: e.label }
+					}), await a(r, { force: !0 });
+				} catch {}
+			}
+		} finally {
+			await a(m, {
+				recursive: !0,
+				force: !0
+			}).catch(() => void 0);
+		}
+		return g;
+	};
+};
+//#endregion
+export { f as ffmpegTranscoder };