@voltro/plugin-storage 0.85.0 → 0.87.0

package/dist/objectWriter.js

@@ -0,0 +1,87 @@
+import { StorageError as e, StorageRejected as t } from "./types.js";
+import { putObjectStream as n } from "./streamBridge.js";
+import { storageMetadataError as r, storageRejectedCause as i } from "./metadataError.js";
+import { Effect as a, Stream as o } from "effect";
+import { createHash as s } from "node:crypto";
+//#region src/objectWriter.ts
+var c = (c) => {
+	let l = (t) => a.gen(function* () {
+		(yield* c.provider.objectNamespace) !== (yield* a.tryPromise({
+			try: () => c.metadata.scopeFor(t),
+			catch: (e) => r(e, "metadata")
+		})).objectNamespace && (yield* a.fail(new e({
+			provider: "metadata",
+			message: "Storage metadata is bound to another physical object namespace",
+			transient: !1,
+			status: 409
+		})));
+	}), u = (t, n) => a.tryPromise({
+		try: n,
+		catch: (n) => {
+			let a = i(n);
+			if (a !== void 0) return a;
+			let o = r(n, "metadata"), s = new e({
+				provider: "metadata",
+				message: `Storage ${t} was not confirmed: ${o.message}; retain the operation identity for recovery`,
+				transient: o.transient,
+				...o.status === void 0 ? {} : { status: o.status }
+			});
+			return Object.defineProperty(s, "cause", {
+				value: n,
+				configurable: !0
+			}), s;
+		}
+	});
+	return {
+		put: (e) => a.gen(function* () {
+			if (e.bytes.byteLength !== e.ref.size || s("sha256").update(e.bytes).digest("hex") !== e.identity.checksum) return yield* a.fail(new t({
+				reason: "operation-content-mismatch",
+				detail: "Storage operation bytes do not match their reserved identity"
+			}));
+			yield* l(e.identity);
+			let n = yield* u("put reservation", () => c.metadata.reserve(e.identity, e.ref, e.quota, e.claim)), r = n.outcome;
+			return n.ready ? {
+				ref: n.ref,
+				outcome: r
+			} : (yield* c.provider.put(n.ref.key, e.bytes, {
+				contentType: n.ref.contentType,
+				public: n.ref.visibility === "public"
+			}), {
+				ref: yield* u("put confirmation", () => c.metadata.confirm(e.identity, e.claim)),
+				outcome: r
+			});
+		}),
+		putStream: (t) => a.gen(function* () {
+			let r = yield* u("put reservation", () => c.metadata.reserve(t.identity, t.ref, t.quota, t.claim)), i = r.outcome;
+			if (r.ready) return {
+				ref: r.ref,
+				outcome: i
+			};
+			let l = () => new e({
+				provider: "integrity",
+				message: "Storage operation stream does not match its reserved checksum and size",
+				transient: !1,
+				status: 409
+			}), d = s("sha256"), f = 0, p = !1, m = t.stream.pipe(o.mapEffect((e) => a.suspend(() => {
+				if (e.byteLength > r.ref.size - f) return a.fail(l());
+				let t = Uint8Array.from(e);
+				return f += t.byteLength, d.update(t), a.succeed(t);
+			})), o.concat(o.fromEffect(a.suspend(() => f !== r.ref.size || d.digest("hex") !== t.identity.checksum ? a.fail(l()) : (p = !0, a.succeed(/* @__PURE__ */ new Uint8Array())))))), h = yield* n(c.provider, r.ref.key, m, {
+				contentType: r.ref.contentType,
+				public: r.ref.visibility === "public",
+				totalSize: r.ref.size
+			});
+			return !p || h.size !== r.ref.size ? yield* a.fail(l()) : {
+				ref: yield* u("put confirmation", () => c.metadata.confirm(t.identity, t.claim)),
+				outcome: i
+			};
+		}),
+		delete: (e, t, n) => a.gen(function* () {
+			yield* l({ refId: e });
+			let r = yield* u("delete acceptance", () => c.metadata.beginDelete(e, t, n));
+			"operation" in r && (r.operation.deleteKey !== null && (yield* c.provider.delete(r.operation.deleteKey)), yield* u("delete confirmation", () => c.metadata.confirmDelete(r.identity)));
+		})
+	};
+};
+//#endregion
+export { c as makeStorageObjectWriter };

package/dist/pathDurability.js

@@ -0,0 +1,16 @@
+import { statSync as e } from "node:fs";
+//#region src/pathDurability.ts
+var t = (t) => {
+	try {
+		let n = e(t), r = e("/");
+		return typeof n.dev != "number" || typeof r.dev != "number" ? "unknown" : n.dev === r.dev ? "same-device-as-root" : "separate-mount";
+	} catch {
+		return "unknown";
+	}
+}, n = (e) => {
+	if (t(e) === "same-device-as-root") return `the capture is going to ${e}, which is on the SAME filesystem as \`/\`.\n  A mounted volume would be a separate one. If this process is a container, that means the capture
+  dies with it — which is the exact failure it exists for. On a development machine this is normal
+  and can be ignored.`;
+};
+//#endregion
+export { n as durabilityNotice, t as pathDurability };

package/dist/physicalReferences.js

@@ -0,0 +1,54 @@
+import { StorageError as e } from "@voltro/kv/storage";
+import { Effect as t } from "effect";
+//#region src/physicalReferences.ts
+var n = (n, r, i, a) => {
+	let o = (o, s) => t.gen(function* () {
+		let c = (yield* r.listObjectReferences()).filter((e) => !s || e.visibility === "public"), l = yield* n.objectNamespace;
+		if (!s && r.hasObjectReservation !== void 0 && (yield* r.hasObjectReservation(l, o))) return !0;
+		if (c.length === 0) return !1;
+		let u, d = !1, f = !1;
+		for (let e of c) {
+			if (e.objectNamespace === l && e.key === o) return !0;
+			let t = yield* a === void 0 ? i({
+				destination: e.bucket,
+				tenantId: e.tenantId,
+				key: e.key
+			}) : a(e);
+			if (e.objectNamespace !== void 0 && (yield* t.objectNamespace) !== e.objectNamespace) {
+				f = !0;
+				continue;
+			}
+			if (n === t) {
+				if (o === e.key) return !0;
+				continue;
+			}
+			d ||= (u = n.objectLocation === void 0 ? void 0 : yield* n.objectLocation(o), !0);
+			let r = t.objectLocation === void 0 ? void 0 : yield* t.objectLocation(e.key);
+			if (u === void 0 || r === void 0) f = !0;
+			else if (u.namespace === r.namespace && u.key === r.key) return !0;
+		}
+		return f ? yield* t.fail(new e({
+			provider: "storage",
+			message: "Physical object ownership cannot be established for every storage destination",
+			transient: !1
+		})) : !1;
+	}), s = (e, n) => n === !0 ? t.succeed(!0) : o(e, !0);
+	return {
+		...n,
+		delete: (e) => o(e, !1).pipe(t.flatMap((r) => r ? n.setObjectPublic === void 0 ? t.void : o(e, !0).pipe(t.flatMap((t) => n.setObjectPublic(e, t))) : n.delete(e))),
+		...n.setObjectPublic === void 0 ? {} : {
+			setObjectPublic: (e, r) => s(e, r).pipe(t.flatMap((t) => n.setObjectPublic(e, t))),
+			put: (e, r, i) => s(e, i.public).pipe(t.flatMap((t) => n.put(e, r, {
+				...i,
+				public: t
+			}))),
+			...n.putStream === void 0 ? {} : { putStream: (e, r, i) => s(e, i.public).pipe(t.flatMap((t) => n.putStream(e, r, {
+				...i,
+				public: t
+			}))) },
+			...n.createMultipartUpload === void 0 ? {} : { createMultipartUpload: (e, r, i) => s(e, i?.public).pipe(t.flatMap((t) => n.createMultipartUpload(e, r, { public: t }))) }
+		}
+	};
+};
+//#endregion
+export { n as protectStorageReferences };