@voltro/plugin-storage 0.86.0 → 0.88.0

package/dist/ingest.js

@@ -1,6 +1,6 @@
 import { StorageError as e, StorageRejected as t } from "./types.js";
 import { Effect as n } from "effect";
-//#region src/ingest.ts
+// src/ingest.ts
 var r = 67108864, i = (e) => new t({
 	reason: "too-large",
 	detail: `remote body exceeds the ${e}-byte ingest limit`
@@ -13,6 +13,11 @@ var r = 67108864, i = (e) => new t({
 		provider: "ingest",
 		message: "limits.maxBytes must be a non-negative safe integer",
 		transient: !1
+	})) : typeof c != "object" || !c || Array.isArray(c) || c.requireHttps !== void 0 && typeof c.requireHttps != "boolean" ? n.fail(new e({
+		provider: "ingest",
+		message: "Ingest policy must be an object with an optional boolean requireHttps",
+		transient: !1,
+		status: 400
 	})) : n.tryPromise({
 		try: async (t) => {
 			let { ssrfReason: n } = await import("./ingestPolicy.js");
@@ -21,6 +26,7 @@ var r = 67108864, i = (e) => new t({
 			for (let e = 0;; e++) {
 				let i = n(r, { ...c.allowHosts === void 0 ? {} : { allowHosts: c.allowHosts } });
 				if (i !== null) throw a(r, i);
+				if (c.requireHttps === !0 && new URL(r).protocol !== "https:") throw a(r, "HTTPS is required for this source and its redirects");
 				s = await fetch(r, {
 					signal: t,
 					redirect: "manual"
@@ -77,5 +83,4 @@ var r = 67108864, i = (e) => new t({
 	});
 	return n.raceFirst(e, r);
 });
-//#endregion
 export { o as fetchIngestBody, s as withIngestAbort };

package/dist/ingestPolicy.js

@@ -1 +1 @@
-export { ssrfReason } from "@voltro/runtime";
+export { ssrfReason } from "@voltro/protocol";

package/dist/metadataError.js

@@ -1,19 +1,18 @@
 import { StorageError as e, StorageRejected as t } from "./types.js";
-import { causeBranches as n, extractDbCause as r, isTransientContention as i, wireSafeCause as a } from "@voltro/database";
-import { Schema as o } from "effect";
-//#region src/metadataError.ts
+import { Schema as n } from "effect";
+import { causeBranches as r, extractDbCause as i, isTransientContention as a, wireSafeCause as o } from "@voltro/database";
+// src/metadataError.ts
 var s = (t, s, c = !1) => {
-	let l = n(t).find(o.is(e));
+	let l = r(t).find(n.is(e));
 	if (l !== void 0) return l;
-	let u = r(t), d = u.dbCode === "22003" || u.dbSqlState === "22003" || u.dbCode === "ER_WARN_DATA_OUT_OF_RANGE" || u.dbErrno === 1264 || u.dbNumber === 8115 || u.dbNumber === 248, f = new e({
+	let u = i(t), d = u.dbCode === "22003" || u.dbSqlState === "22003" || u.dbCode === "ER_WARN_DATA_OUT_OF_RANGE" || u.dbErrno === 1264 || u.dbNumber === 8115 || u.dbNumber === 248, f = new e({
 		provider: s,
-		message: `${d ? "Storage metadata numeric value out of range: " : ""}${a(t)}`,
-		transient: d ? !1 : i(t) || c
+		message: `${d ? "Storage metadata numeric value out of range: " : ""}${o(t)}`,
+		transient: d ? !1 : a(t) || c
 	});
 	return Object.defineProperty(f, "cause", {
 		value: t,
 		configurable: !0
 	}), f;
-}, c = (e) => n(e).find(o.is(t));
-//#endregion
+}, c = (e) => r(e).find(n.is(t));
 export { s as storageMetadataError, c as storageRejectedCause };

package/dist/objectAbandon.js

@@ -0,0 +1,15 @@
+import { storageMetadataError as e } from "./metadataError.js";
+import { beginStorageObjectAbandon as t, makeStorageObjectMetadata as n } from "./objectMetadata.js";
+import { Effect as r } from "effect";
+// src/objectAbandon.ts
+var i = (t) => r.tryPromise({
+	try: t,
+	catch: (t) => e(t, "metadata")
+}), a = (e, a, o) => r.gen(function* () {
+	let r = yield* i(() => t(e, o));
+	return r.state === "retired" ? (r.operation.deleteKey !== null && (yield* a.delete(r.operation.deleteKey)), yield* i(() => n(e, o).confirmDelete(r.identity)), {
+		state: "abandoned",
+		refId: r.operation.refId
+	}) : r;
+});
+export { a as abandonStorageObject };

package/dist/objectLifecycle.js

@@ -1,74 +1,100 @@
 import { requireStorageReferenceScope as e } from "./storageNamespaces.js";
 import { StorageRejected as t } from "./types.js";
 import { storageInteger as n, storageIntegerSum as r } from "./storageNumbers.js";
-import { createHash as i, randomUUID as a } from "node:crypto";
-import { and as o, bigint as s, eq as c, neq as l, table as u, text as d } from "@voltro/database";
-import { Schema as f } from "effect";
-//#region src/objectLifecycle.ts
+import { Schema as i } from "effect";
+import { createHash as a, randomUUID as o } from "node:crypto";
+import { and as s, bigint as c, eq as l, neq as u, table as d, text as f } from "@voltro/database";
+// src/objectLifecycle.ts
 var p = "_voltro_storage_operation_locks", m = "_voltro_storage_object_heads", h = "_voltro_storage_operations", g = "_voltro_storage_object_claims", _ = [
-	u(p, {
-		id: d().maxLength(64),
-		nonce: d()
+	d(p, {
+		id: f().maxLength(64),
+		nonce: f()
 	}).primaryKey(["id"]).nonReactive(),
-	u(m, {
-		id: d().maxLength(64),
-		objectNamespace: d().maxLength(64).nullable(),
-		generation: d(),
-		key: d(),
-		reservations: s()
+	d(m, {
+		id: f().maxLength(64),
+		objectNamespace: f().maxLength(64).nullable(),
+		generation: f(),
+		key: f(),
+		reservations: c()
 	}).primaryKey(["id"]).nonReactive(),
-	u(h, {
-		id: d().maxLength(64),
-		storageInstance: d().nullable(),
-		objectNamespace: d().maxLength(64).nullable(),
-		objectId: d().maxLength(64),
-		fingerprint: d().maxLength(64),
-		generation: d(),
-		key: d(),
-		refId: d(),
-		state: d(),
-		deleteKey: d().nullable()
+	d(h, {
+		id: f().maxLength(64),
+		storageInstance: f().nullable(),
+		objectNamespace: f().maxLength(64).nullable(),
+		objectId: f().maxLength(64),
+		fingerprint: f().maxLength(64),
+		generation: f(),
+		key: f(),
+		refId: f(),
+		state: f(),
+		deleteKey: f().nullable()
 	}).primaryKey(["id"]).nonReactive(),
-	u(g, {
-		id: d().maxLength(64),
-		operationId: d().maxLength(64),
-		claim: d()
+	d(g, {
+		id: f().maxLength(64),
+		operationId: f().maxLength(64),
+		claim: f()
 	}).primaryKey(["id"]).nonReactive()
-], v = f.Struct({
-	id: f.String,
-	storageInstance: f.String,
-	objectNamespace: f.String,
-	objectId: f.String,
-	fingerprint: f.String,
-	generation: f.String,
-	key: f.String,
-	refId: f.String,
-	state: f.Literals([
+], v = i.Struct({
+	id: i.String,
+	storageInstance: i.String,
+	objectNamespace: i.String,
+	objectId: i.String,
+	fingerprint: i.String,
+	generation: i.String,
+	key: i.String,
+	refId: i.String,
+	state: i.Literals([
 		"reserved",
 		"ready",
 		"deleting",
 		"deleted"
 	]),
-	deleteKey: f.NullOr(f.String)
-}), y = f.Struct({
-	id: f.String,
-	objectNamespace: f.String,
-	generation: f.String,
-	key: f.String,
-	reservations: f.Int.pipe(f.check(f.isGreaterThanOrEqualTo(0)))
-}), b = (e) => f.decodeUnknownSync(y)({
+	deleteKey: i.NullOr(i.String)
+}), y = i.Struct({
+	id: i.String,
+	objectNamespace: i.String,
+	generation: i.String,
+	key: i.String,
+	reservations: i.Int.pipe(i.check(i.isGreaterThanOrEqualTo(0)))
+}), b = (e) => i.decodeUnknownSync(y)({
 	...e,
 	reservations: n(e.reservations, "shared-object reservation count")
-}), x = (e) => i("sha256").update(JSON.stringify(e)).digest("hex"), S = (e, t) => x([e, t]), C = (t) => {
-	if (e(t), !t.bucket || !t.operationId || !t.logicalKey || !/^[a-f0-9]{64}$/.test(t.fingerprint) || !/^[a-f0-9]{64}$/.test(t.checksum)) throw Error("Storage operation requires a bucket, operation identity, key and SHA-256 fingerprint");
+}), x = (e) => a("sha256").update(JSON.stringify(e)).digest("hex"), S = (e, t) => x([e, t]), C = (n) => {
+	if (n.tenantId !== null && (typeof n.tenantId != "string" || !n.tenantId.trim() || n.tenantId.length > 191) || typeof n.bucket != "string" || !n.bucket.trim() || n.bucket.length > 200 || typeof n.operationId != "string" || !n.operationId.trim() || n.operationId.length > 200) throw new t({
+		reason: "operation-identity-reused",
+		detail: "Storage operation lookup requires explicit valid tenant, destination and operation identity"
+	});
+	return e(n), x([
+		n.storageInstance,
+		n.objectNamespace,
+		n.bucket,
+		n.tenantId,
+		n.operationId
+	]);
+}, w = (e) => C(e), T = async (e, t) => {
+	let n = await e.query({
+		table: h,
+		predicate: l("id", C(t)),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	return n[0] ? i.decodeUnknownSync(v)(n[0]) : void 0;
+}, E = async (e, t, n) => {
+	if (typeof n != "string" || !n.trim() || n.length > 200) throw Error("Storage operation lookup requires a bounded claim");
+	return (await e.query({
+		table: g,
+		predicate: s(l("id", S(t, n)), l("operationId", t), l("claim", n)),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: ["id"]
+	})).length === 1;
+}, D = (t) => {
+	if (e(t), !t.bucket || !t.operationId || !t.logicalKey || !/^[a-f0-9]{64}$/.test(t.fingerprint) || !/^[a-f0-9]{64}$/.test(t.checksum) || t.retainedSource !== void 0 && (!t.retainedSource.refId || !/^[a-f0-9]{64}$/.test(t.retainedSource.digest))) throw Error("Storage operation requires a bucket, operation identity, key and SHA-256 fingerprint");
 	return {
-		id: x([
-			t.storageInstance,
-			t.objectNamespace,
-			t.bucket,
-			t.tenantId,
-			t.operationId
-		]),
+		id: C(t),
 		objectId: x([
 			t.objectNamespace,
 			t.bucket,
@@ -78,52 +104,52 @@ var p = "_voltro_storage_operation_locks", m = "_voltro_storage_object_heads", h
 		]),
 		lockId: x([t.tenantId])
 	};
-}, w = async (e, t, n) => {
-	let { lockId: r } = C(t);
+}, O = async (e, t, n) => {
+	let { lockId: r } = D(t);
 	return await e.insertIgnoreWithOutcome(p, {
 		id: r,
-		nonce: a()
+		nonce: o()
 	}, { conflictColumns: ["id"] }), e.transactional(async (e) => {
 		if ((await e.query({
 			table: p,
-			predicate: c("id", r),
+			predicate: l("id", r),
 			lock: "update",
 			order: [],
 			take: 1,
 			skip: void 0,
 			projection: void 0
-		})).length !== 1 || await e.update(p, r, { nonce: a() }) === null) throw Error("Storage operation lock is unavailable");
+		})).length !== 1 || await e.update(p, r, { nonce: o() }) === null) throw Error("Storage operation lock is unavailable");
 		return n(e);
 	});
-}, T = async (e, n) => {
-	let r = C(n), i = await e.query({
+}, k = async (e, n) => {
+	let r = D(n), a = await e.query({
 		table: h,
-		predicate: c("id", r.id),
+		predicate: l("id", r.id),
 		order: [],
 		take: 1,
 		skip: void 0,
 		projection: void 0
 	});
-	if (!i[0]) return;
-	let a = f.decodeUnknownSync(v)(i[0]);
-	if (a.storageInstance !== n.storageInstance || a.objectNamespace !== n.objectNamespace || a.fingerprint !== n.fingerprint || a.objectId !== r.objectId) throw new t({
+	if (!a[0]) return;
+	let o = i.decodeUnknownSync(v)(a[0]);
+	if (o.storageInstance !== n.storageInstance || o.objectNamespace !== n.objectNamespace || o.fingerprint !== n.fingerprint || o.objectId !== r.objectId) throw new t({
 		reason: "operation-identity-reused",
 		detail: `storage operation '${n.operationId}' was already used with different inputs`
 	});
-	return a;
-}, E = async (e, t) => {
-	let n = await T(e, t);
+	return o;
+}, A = async (e, t) => {
+	let n = await k(e, t);
 	if (n) return n;
-	let { id: i, objectId: o } = C(t), s = await e.query({
+	let { id: i, objectId: a } = D(t), s = await e.query({
 		table: m,
-		predicate: c("id", o),
+		predicate: l("id", a),
 		order: [],
 		take: 1,
 		skip: void 0,
 		projection: void 0
-	}), l = s[0] ? b(s[0]) : void 0, u = l?.generation ?? a(), d = l?.key ?? `${t.logicalKey}/g-${u}`;
-	l ? await e.update(m, o, { reservations: String(r(l.reservations, 1, "shared-object reservation count")) }) : await e.insert(m, {
-		id: o,
+	}), c = s[0] ? b(s[0]) : void 0, u = c?.generation ?? o(), d = c?.key ?? `${t.logicalKey}/g-${u}`;
+	c ? await e.update(m, a, { reservations: String(r(c.reservations, 1, "shared-object reservation count")) }) : await e.insert(m, {
+		id: a,
 		objectNamespace: t.objectNamespace,
 		generation: u,
 		key: d,
@@ -133,77 +159,84 @@ var p = "_voltro_storage_operation_locks", m = "_voltro_storage_object_heads", h
 		id: i,
 		storageInstance: t.storageInstance,
 		objectNamespace: t.objectNamespace,
-		objectId: o,
+		objectId: a,
 		fingerprint: t.fingerprint,
 		generation: u,
 		key: d,
-		refId: `file_${a()}`,
+		refId: `file_${o()}`,
 		state: "reserved",
 		deleteKey: null
 	};
 	return await e.insert(h, f), f;
-}, D = async (e, t) => {
-	let n = await T(e, t);
+}, j = async (e, t) => {
+	let n = await k(e, t);
 	if (!n) throw Error("Storage operation is missing");
 	if (n.state === "deleting" || n.state === "deleted") throw Error("Deleted storage operation cannot be confirmed by a late put");
 	return await e.update(h, n.id, { state: "ready" }), {
 		...n,
 		state: "ready"
 	};
-}, O = async (e, t) => {
-	let n = await T(e, t);
-	if (!n) throw Error("Storage operation is missing");
-	if (n.state === "deleting" || n.state === "deleted") return n;
-	if (n.state !== "ready") throw Error("An unconfirmed put cannot be deleted");
-	let r = await e.query({
+}, M = async (e, t, n) => {
+	let r = await k(e, t);
+	if (!r) throw Error("Storage operation is missing");
+	if (r.state === "deleting" || r.state === "deleted") return r;
+	if (r.state !== n) throw Error(n === "ready" ? "An unconfirmed put cannot be deleted" : "A confirmed put cannot be abandoned");
+	if (n === "reserved" && (await e.query({
+		table: g,
+		predicate: l("operationId", r.id),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: ["id"]
+	})).length !== 0) throw Error("An unconfirmed operation unexpectedly holds claims");
+	let i = await e.query({
 		table: m,
-		predicate: c("id", n.objectId),
+		predicate: l("id", r.objectId),
 		order: [],
 		take: 1,
 		skip: void 0,
 		projection: void 0
-	}), i = r[0] ? b(r[0]) : void 0;
-	if (!i || i.generation !== n.generation || i.reservations < 1) throw Error("Storage object generation does not own its reservation");
-	let a = i.reservations === 1 ? i.key : null;
-	return a === null ? await e.update(m, i.id, { reservations: String(i.reservations - 1) }) : await e.delete(m, i.id), a !== null && (await e.query({
+	}), a = i[0] ? b(i[0]) : void 0;
+	if (!a || a.generation !== r.generation || a.reservations < 1) throw Error("Storage object generation does not own its reservation");
+	let o = a.reservations === 1 ? a.key : null;
+	return o === null ? await e.update(m, a.id, { reservations: String(a.reservations - 1) }) : await e.delete(m, a.id), o !== null && (await e.query({
 		table: m,
-		predicate: o(c("objectNamespace", t.objectNamespace), c("key", a)),
+		predicate: s(l("objectNamespace", t.objectNamespace), l("key", o)),
 		order: [],
 		take: 1,
 		skip: void 0,
 		projection: ["id"]
-	})).length && (a = null), await e.update(h, n.id, {
+	})).length && (o = null), await e.update(h, r.id, {
 		state: "deleting",
-		deleteKey: a
+		deleteKey: o
 	}), {
-		...n,
+		...r,
 		state: "deleting",
-		deleteKey: a
+		deleteKey: o
 	};
-}, k = async (e, t) => {
-	let n = await T(e, t);
+}, N = (e, t) => M(e, t, "ready"), P = (e, t) => M(e, t, "reserved"), F = async (e, t) => {
+	let n = await k(e, t);
 	if (!n || n.state !== "deleting" && n.state !== "deleted") throw Error("Storage deletion has not been accepted");
 	return n.state !== "deleted" && (await e.update(h, n.id, { state: "deleted" }), !0);
-}, A = async (e, t, n) => {
+}, I = async (e, t, n) => {
 	if (!n) throw Error("Storage object claim must be a non-empty string");
 	await e.insertIgnoreWithOutcome(g, {
 		id: S(t, n),
 		operationId: t,
 		claim: n
 	}, { conflictColumns: ["id"] });
-}, j = async (e, t, n) => {
+}, L = async (e, t, n) => {
 	let r = S(t, n);
 	return {
 		held: await e.delete(g, r),
 		others: (await e.query({
 			table: g,
-			predicate: o(c("operationId", t), l("claim", n)),
+			predicate: s(l("operationId", t), u("claim", n)),
 			order: [],
 			take: 1,
 			skip: void 0,
 			projection: void 0
 		})).length > 0
 	};
-}, M = (e, t) => e.deleteMany(g, { where: c("operationId", t) });
-//#endregion
-export { O as beginStorageObjectDeleteInTransaction, A as claimStorageObjectInTransaction, M as clearStorageObjectClaimsInTransaction, k as confirmStorageObjectDeleteInTransaction, D as confirmStorageObjectInTransaction, T as readStorageObjectOperationInTransaction, j as releaseStorageObjectClaimInTransaction, E as reserveStorageObjectInTransaction, S as storageObjectClaimId, C as storageObjectIdentifiers, _ as storageObjectLifecycleTables, w as withStorageOperationTransaction };
+}, R = (e, t) => e.deleteMany(g, { where: l("operationId", t) });
+export { P as beginStorageObjectAbandonInTransaction, N as beginStorageObjectDeleteInTransaction, I as claimStorageObjectInTransaction, R as clearStorageObjectClaimsInTransaction, F as confirmStorageObjectDeleteInTransaction, j as confirmStorageObjectInTransaction, E as hasStorageObjectClaimInTransaction, T as lookupStorageObjectOperationInTransaction, k as readStorageObjectOperationInTransaction, L as releaseStorageObjectClaimInTransaction, A as reserveStorageObjectInTransaction, S as storageObjectClaimId, D as storageObjectIdentifiers, _ as storageObjectLifecycleTables, w as storageObjectOperationId, O as withStorageOperationTransaction };