@effect-kit/storage 0.0.0-stage → 0.0.0

package/dist/workflows/mirror/schema.d.ts

@@ -0,0 +1,68 @@
+import { StorageError } from "../../core/errors.js";
+import { Schema } from "effect";
+export declare const MirrorOperation: Schema.Struct<{
+  readonly id: Schema.String;
+  readonly binding: Schema.String;
+  readonly generation: Schema.Natural;
+  readonly key: Schema.String;
+  readonly kind: Schema.Literals<readonly ["put", "delete"]>;
+  readonly requestHash: Schema.optional<Schema.String>;
+  readonly state: Schema.Literals<readonly ["pending", "completed", "partial", "superseded"]>;
+  readonly sha256: Schema.String;
+  readonly size: Schema.Natural;
+  readonly createdAt: Schema.Number;
+  readonly outcomes: Schema.$Array<Schema.Struct<{
+    readonly storeId: Schema.String;
+    readonly required: Schema.Boolean;
+    readonly state: Schema.Literals<readonly ["pending", "succeeded", "unknown", "conflict"]>;
+    readonly metadata: Schema.optional<Schema.Struct<{
+      readonly contentType: Schema.optional<Schema.String>;
+      readonly contentEncoding: Schema.optional<Schema.String>;
+      readonly contentLanguage: Schema.optional<Schema.String>;
+      readonly contentDisposition: Schema.optional<Schema.String>;
+      readonly cacheControl: Schema.optional<Schema.String>;
+      readonly customMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+      readonly ref: Schema.Struct<{
+        readonly storeId: Schema.NonEmptyString;
+        readonly key: Schema.NonEmptyString;
+        readonly version: Schema.optional<Schema.Union<readonly [Schema.TaggedStruct<"S3Version", {
+          readonly id: Schema.NonEmptyString;
+        }>, Schema.TaggedStruct<"GcsGeneration", {
+          readonly id: Schema.NonEmptyString;
+          readonly metageneration: Schema.optional<Schema.NonEmptyString>;
+        }>, Schema.TaggedStruct<"AzureVersion", {
+          readonly id: Schema.NonEmptyString;
+        }>, Schema.TaggedStruct<"AzureSnapshot", {
+          readonly id: Schema.NonEmptyString;
+        }>, Schema.TaggedStruct<"OpaqueVersion", {
+          readonly provider: Schema.NonEmptyString;
+          readonly id: Schema.NonEmptyString;
+        }>]>>;
+      }>;
+      readonly size: Schema.optional<Schema.Natural>;
+      readonly etag: Schema.optional<Schema.String>;
+      readonly lastModified: Schema.optional<Schema.DateTimeUtcFromString>;
+      readonly checksums: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly algorithm: Schema.NonEmptyString;
+        readonly encoding: Schema.Literals<readonly ["hex", "base64"]>;
+        readonly scope: Schema.Literals<readonly ["full-object", "composite"]>;
+        readonly value: Schema.NonEmptyString;
+        readonly partCount: Schema.optional<Schema.Int>;
+      }>>>;
+      readonly storageClass: Schema.optional<Schema.NonEmptyString>;
+    }>>;
+    readonly error: Schema.optional<typeof StorageError>;
+  }>>;
+}>;
+export type MirrorOperation = typeof MirrorOperation.Type;
+export declare const MirrorRepairPlan: Schema.Struct<{
+  readonly id: Schema.String;
+  readonly binding: Schema.String;
+  readonly count: Schema.Natural;
+  readonly offset: Schema.Natural;
+  readonly state: Schema.Literals<readonly ["planned", "applying", "completed", "partial"]>;
+  readonly unresolved: Schema.Natural;
+  readonly prefix: Schema.String;
+}>;
+export type MirrorRepairPlan = typeof MirrorRepairPlan.Type;
+//# sourceMappingURL=schema.d.ts.map

package/dist/workflows/mirror/schema.js

@@ -0,0 +1,57 @@
+import { ObjectMetadata } from "../../core/object.js";
+import { StorageError } from "../../core/errors.js";
+import { Schema } from "effect";
+
+// src/workflows/mirror/schema.ts
+const MirrorOutcome = Schema.Struct({
+	storeId: Schema.String,
+	required: Schema.Boolean,
+	state: Schema.Literals([
+		"pending",
+		"succeeded",
+		"unknown",
+		"conflict"
+	]),
+	metadata: Schema.optional(ObjectMetadata),
+	error: Schema.optional(StorageError)
+});
+const MirrorOperation = Schema.Struct({
+	id: Schema.String,
+	binding: Schema.String,
+	generation: Schema.Natural,
+	key: Schema.String,
+	kind: Schema.Literals(["put", "delete"]),
+	requestHash: Schema.optional(Schema.String),
+	state: Schema.Literals([
+		"pending",
+		"completed",
+		"partial",
+		"superseded"
+	]),
+	sha256: Schema.String,
+	size: Schema.Natural,
+	createdAt: Schema.Number,
+	outcomes: Schema.Array(MirrorOutcome)
+});
+const MirrorPointer = Schema.Struct({
+	id: Schema.String,
+	generation: Schema.Natural,
+	kind: Schema.Literals(["put", "delete"])
+});
+const MirrorRepairPlan = Schema.Struct({
+	id: Schema.String,
+	binding: Schema.String,
+	count: Schema.Natural,
+	offset: Schema.Natural,
+	state: Schema.Literals([
+		"planned",
+		"applying",
+		"completed",
+		"partial"
+	]),
+	unresolved: Schema.Natural,
+	prefix: Schema.String
+});
+
+export { MirrorOperation, MirrorOutcome, MirrorPointer, MirrorRepairPlan };
+//# sourceMappingURL=schema.js.map

package/dist/workflows/mirror/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","names":[],"sources":["../../../src/workflows/mirror/schema.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\nimport { StorageError } from \"../../core/errors.js\";\nimport { ObjectMetadata } from \"../../core/object.js\";\n\nexport const MirrorOutcome = Schema.Struct({\n  storeId: Schema.String,\n  required: Schema.Boolean,\n  state: Schema.Literals([\"pending\", \"succeeded\", \"unknown\", \"conflict\"]),\n  metadata: Schema.optional(ObjectMetadata),\n  error: Schema.optional(StorageError),\n});\nexport const MirrorOperation = Schema.Struct({\n  id: Schema.String,\n  binding: Schema.String,\n  generation: Schema.Natural,\n  key: Schema.String,\n  kind: Schema.Literals([\"put\", \"delete\"]),\n  requestHash: Schema.optional(Schema.String),\n  state: Schema.Literals([\"pending\", \"completed\", \"partial\", \"superseded\"]),\n  sha256: Schema.String,\n  size: Schema.Natural,\n  createdAt: Schema.Number,\n  outcomes: Schema.Array(MirrorOutcome),\n});\nexport type MirrorOperation = typeof MirrorOperation.Type;\nexport const MirrorPointer = Schema.Struct({\n  id: Schema.String,\n  generation: Schema.Natural,\n  kind: Schema.Literals([\"put\", \"delete\"]),\n});\nexport const MirrorRepairPlan = Schema.Struct({\n  id: Schema.String,\n  binding: Schema.String,\n  count: Schema.Natural,\n  offset: Schema.Natural,\n  state: Schema.Literals([\"planned\", \"applying\", \"completed\", \"partial\"]),\n  unresolved: Schema.Natural,\n  prefix: Schema.String,\n});\nexport type MirrorRepairPlan = typeof MirrorRepairPlan.Type;\n"],"mappings":";;;;;AAKA,MAAa,gBAAgB,OAAO,OAAO;CACzC,SAAS,OAAO;CAChB,UAAU,OAAO;CACjB,OAAO,OAAO,SAAS;EAAC;EAAW;EAAa;EAAW;CAAU,CAAC;CACtE,UAAU,OAAO,SAAS,cAAc;CACxC,OAAO,OAAO,SAAS,YAAY;AACrC,CAAC;AACD,MAAa,kBAAkB,OAAO,OAAO;CAC3C,IAAI,OAAO;CACX,SAAS,OAAO;CAChB,YAAY,OAAO;CACnB,KAAK,OAAO;CACZ,MAAM,OAAO,SAAS,CAAC,OAAO,QAAQ,CAAC;CACvC,aAAa,OAAO,SAAS,OAAO,MAAM;CAC1C,OAAO,OAAO,SAAS;EAAC;EAAW;EAAa;EAAW;CAAY,CAAC;CACxE,QAAQ,OAAO;CACf,MAAM,OAAO;CACb,WAAW,OAAO;CAClB,UAAU,OAAO,MAAM,aAAa;AACtC,CAAC;AAED,MAAa,gBAAgB,OAAO,OAAO;CACzC,IAAI,OAAO;CACX,YAAY,OAAO;CACnB,MAAM,OAAO,SAAS,CAAC,OAAO,QAAQ,CAAC;AACzC,CAAC;AACD,MAAa,mBAAmB,OAAO,OAAO;CAC5C,IAAI,OAAO;CACX,SAAS,OAAO;CAChB,OAAO,OAAO;CACd,QAAQ,OAAO;CACf,OAAO,OAAO,SAAS;EAAC;EAAW;EAAY;EAAa;CAAS,CAAC;CACtE,YAAY,OAAO;CACnB,QAAQ,OAAO;AACjB,CAAC"}

package/dist/workflows/mirror/view.js

@@ -0,0 +1,103 @@
+import { storageError } from "../../core/errors.js";
+import { workflowError } from "../store.js";
+import { MirrorPointer } from "./schema.js";
+import { marker, pointerKey } from "./operations.js";
+import { Effect, Schema } from "effect";
+
+// src/workflows/mirror/view.ts
+const Cursor = Schema.Struct({
+	binding: Schema.String,
+	prefix: Schema.String,
+	next: Schema.Natural,
+	upper: Schema.Natural
+});
+const makeView = (store, binding, endpoints, operations) => {
+	const storeId = `mirror:${binding}`;
+	const virtual = (operation, metadata) => {
+		const customMetadata = { ...metadata.customMetadata };
+		delete customMetadata[marker];
+		return {
+			...metadata,
+			customMetadata,
+			size: operation.size,
+			etag: `"mirror:${operation.id}"`,
+			ref: {
+				storeId,
+				key: operation.key,
+				version: {
+					_tag: "OpaqueVersion",
+					provider: "mirror",
+					id: operation.id
+				}
+			}
+		};
+	};
+	const current = Effect.fnUntraced(function* (target, requireCommitted = true) {
+		const key = "key" in target ? target.key : target.ref.key;
+		const pointer = yield* store.read(pointerKey(key), MirrorPointer);
+		if (!pointer || pointer.kind === "delete") return yield* storageError("get", "mirror", { _tag: "NotFound" });
+		if ("ref" in target && (target.ref.storeId !== storeId || target.ref.version && (target.ref.version._tag !== "OpaqueVersion" || target.ref.version.provider !== "mirror" || target.ref.version.id !== pointer.id))) return yield* storageError("get", "mirror", { _tag: "NotFound" });
+		const operation = yield* operations.load(pointer.id);
+		if (requireCommitted && operation.outcomes.some((outcome) => outcome.required && outcome.state !== "succeeded")) return yield* workflowError("RequiredReplicationPending");
+		return operation;
+	});
+	const resolve = Effect.fnUntraced(function* (operation) {
+		for (let index = 0; index < endpoints.length; index++) {
+			const endpoint = endpoints[index];
+			const outcome = operation.outcomes[index];
+			if (!endpoint || !outcome?.metadata || outcome.state !== "succeeded") continue;
+			const observed = yield* Effect.result(endpoint.endpoint.storage.head({ ref: outcome.metadata.ref }));
+			if (observed._tag === "Success" && observed.success.customMetadata?.["effect-storage-mirror"] === operation.id) return {
+				endpoint: endpoint.endpoint,
+				metadata: observed.success
+			};
+			if (observed._tag === "Failure" && [
+				"AccessDenied",
+				"PreconditionFailed",
+				"InvalidInput"
+			].includes(observed.failure.reason._tag)) return yield* observed.failure;
+		}
+		return yield* workflowError("NoVerifiedReplicaAvailable");
+	});
+	const listPage = (request = {}) => store.exclusive(Effect.gen(function* () {
+		const prefix = request.prefix ?? "";
+		const cursor = request.cursor ? yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Cursor))(request.cursor).pipe(Effect.mapError(() => workflowError("InvalidCursor"))) : {
+			binding,
+			prefix,
+			next: 1,
+			upper: (yield* store.read("sequence", Schema.Natural)) ?? 0
+		};
+		if (cursor.binding !== binding || cursor.prefix !== prefix) return yield* workflowError("ForeignCursor");
+		const entries = [];
+		let index = cursor.next;
+		let scanned = 0;
+		while (index <= cursor.upper && entries.length < (request.limit ?? 100) && scanned++ < 1e3) {
+			const id = yield* store.read(`index:${index++}`, Schema.String);
+			if (!id) continue;
+			const operation = yield* operations.load(id);
+			const pointer = yield* store.read(pointerKey(operation.key), MirrorPointer);
+			if (pointer?.id !== id || pointer.kind === "delete" || !operation.key.startsWith(prefix)) continue;
+			const source = yield* resolve(operation);
+			entries.push({
+				_tag: "Object",
+				metadata: virtual(operation, source.metadata)
+			});
+		}
+		return {
+			entries,
+			...index <= cursor.upper ? { cursor: JSON.stringify({
+				...cursor,
+				next: index
+			}) } : {}
+		};
+	}));
+	return {
+		virtual,
+		current,
+		resolve,
+		listPage
+	};
+};
+
+export { makeView };
+//# sourceMappingURL=view.js.map

package/dist/workflows/mirror/view.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"view.js","names":[],"sources":["../../../src/workflows/mirror/view.ts"],"sourcesContent":["import { Effect, Schema } from \"effect\";\n\nimport { storageError } from \"../../core/errors.js\";\nimport type { ObjectMetadata } from \"../../core/object.js\";\nimport type { HeadRequest, ListEntry } from \"../../core/requests.js\";\nimport type { StorageService } from \"../../core/storage.js\";\nimport { workflowError } from \"../store.js\";\nimport type { RecordStore } from \"../store.js\";\nimport { marker, pointerKey } from \"./operations.js\";\nimport type { makeOperations, MirrorEndpoint } from \"./operations.js\";\nimport { MirrorPointer } from \"./schema.js\";\nimport type { MirrorOperation } from \"./schema.js\";\nconst Cursor = Schema.Struct({\n  binding: Schema.String,\n  prefix: Schema.String,\n  next: Schema.Natural,\n  upper: Schema.Natural,\n});\n\nexport const makeView = (\n  store: RecordStore,\n  binding: string,\n  endpoints: ReadonlyArray<MirrorEndpoint>,\n  operations: ReturnType<typeof makeOperations>,\n) => {\n  const storeId = `mirror:${binding}`;\n  const virtual = (operation: MirrorOperation, metadata: ObjectMetadata): ObjectMetadata => {\n    const customMetadata = { ...metadata.customMetadata };\n    delete customMetadata[marker];\n    return {\n      ...metadata,\n      customMetadata,\n      size: operation.size,\n      etag: `\"mirror:${operation.id}\"`,\n      ref: {\n        storeId,\n        key: operation.key,\n        version: { _tag: \"OpaqueVersion\", provider: \"mirror\", id: operation.id },\n      },\n    };\n  };\n  const current = Effect.fnUntraced(function* (target: HeadRequest, requireCommitted = true) {\n    const key = \"key\" in target ? target.key : target.ref.key;\n    const pointer = yield* store.read(pointerKey(key), MirrorPointer);\n    if (!pointer || pointer.kind === \"delete\")\n      return yield* storageError(\"get\", \"mirror\", { _tag: \"NotFound\" });\n    if (\n      \"ref\" in target &&\n      (target.ref.storeId !== storeId ||\n        (target.ref.version &&\n          (target.ref.version._tag !== \"OpaqueVersion\" ||\n            target.ref.version.provider !== \"mirror\" ||\n            target.ref.version.id !== pointer.id)))\n    )\n      return yield* storageError(\"get\", \"mirror\", { _tag: \"NotFound\" });\n    const operation = yield* operations.load(pointer.id);\n    if (\n      requireCommitted &&\n      operation.outcomes.some((outcome) => outcome.required && outcome.state !== \"succeeded\")\n    )\n      return yield* workflowError(\"RequiredReplicationPending\");\n    return operation;\n  });\n  const resolve = Effect.fnUntraced(function* (operation: MirrorOperation) {\n    for (let index = 0; index < endpoints.length; index++) {\n      const endpoint = endpoints[index];\n      const outcome = operation.outcomes[index];\n      if (!endpoint || !outcome?.metadata || outcome.state !== \"succeeded\") continue;\n      const observed = yield* Effect.result(\n        endpoint.endpoint.storage.head({ ref: outcome.metadata.ref }),\n      );\n      if (observed._tag === \"Success\" && observed.success.customMetadata?.[marker] === operation.id)\n        return { endpoint: endpoint.endpoint, metadata: observed.success };\n      if (\n        observed._tag === \"Failure\" &&\n        [\"AccessDenied\", \"PreconditionFailed\", \"InvalidInput\"].includes(\n          observed.failure.reason._tag,\n        )\n      )\n        return yield* observed.failure;\n    }\n    return yield* workflowError(\"NoVerifiedReplicaAvailable\");\n  });\n  const listPage: StorageService[\"listPage\"] = (request = {}) =>\n    store.exclusive(\n      Effect.gen(function* () {\n        const prefix = request.prefix ?? \"\";\n        const cursor = request.cursor\n          ? yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Cursor))(request.cursor).pipe(\n              Effect.mapError(() => workflowError(\"InvalidCursor\")),\n            )\n          : {\n              binding,\n              prefix,\n              next: 1,\n              upper: (yield* store.read(\"sequence\", Schema.Natural)) ?? 0,\n            };\n        if (cursor.binding !== binding || cursor.prefix !== prefix)\n          return yield* workflowError(\"ForeignCursor\");\n        const entries: ListEntry[] = [];\n        let index = cursor.next;\n        let scanned = 0;\n        while (\n          index <= cursor.upper &&\n          entries.length < (request.limit ?? 100) &&\n          scanned++ < 1000\n        ) {\n          const id = yield* store.read(`index:${index++}`, Schema.String);\n          if (!id) continue;\n          const operation = yield* operations.load(id);\n          const pointer = yield* store.read(pointerKey(operation.key), MirrorPointer);\n          if (pointer?.id !== id || pointer.kind === \"delete\" || !operation.key.startsWith(prefix))\n            continue;\n          const source = yield* resolve(operation);\n          entries.push({ _tag: \"Object\", metadata: virtual(operation, source.metadata) });\n        }\n        return {\n          entries,\n          ...(index <= cursor.upper ? { cursor: JSON.stringify({ ...cursor, next: index }) } : {}),\n        };\n      }),\n    );\n  return { virtual, current, resolve, listPage };\n};\n"],"mappings":"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"}

package/dist/workflows/objects.js

@@ -0,0 +1,54 @@
+import { sha256 } from "../runtime/portable-hash.js";
+import { storageError } from "../core/errors.js";
+import { Effect, Stream } from "effect";
+
+// src/workflows/objects.ts
+const pin = (metadata) => metadata.ref.version ? Effect.succeed({ ref: metadata.ref }) : metadata.etag ? Effect.succeed({
+	ref: metadata.ref,
+	condition: {
+		_tag: "IfMatch",
+		etag: metadata.etag
+	}
+}) : Effect.fail(storageError("verify", "workflow", {
+	_tag: "Unsupported",
+	capability: "pinned-read"
+}));
+const hashObject = Effect.fnUntraced(function* (storage, metadata) {
+	return yield* Effect.scoped(Effect.gen(function* () {
+		const object = yield* storage.get(yield* pin(metadata));
+		if (object._tag !== "Object") return yield* storageError("verify", storage.provider, { _tag: "IntegrityMismatch" });
+		const hash = sha256.create();
+		let size = 0;
+		yield* Stream.runForEach(object.body, (chunk) => Effect.sync(() => {
+			size += chunk.length;
+			hash.update(chunk);
+		}));
+		if (metadata.size !== void 0 && size !== metadata.size) return yield* storageError("verify", storage.provider, {
+			_tag: "LengthMismatch",
+			expected: metadata.size,
+			actual: size
+		});
+		return {
+			size,
+			sha256: hash.finish().value
+		};
+	}));
+});
+const deletePinned = Effect.fnUntraced(function* (storage, metadata) {
+	if (metadata.ref.version) return yield* storage.delete({ ref: metadata.ref }).pipe(Effect.catchReason("StorageError", "NotFound", () => Effect.void));
+	if (!metadata.etag || !storage.capabilities.deleteConditions.includes("if-match")) return yield* storageError("delete", storage.provider, {
+		_tag: "Unsupported",
+		capability: "pinned-delete"
+	}, "not-started");
+	yield* storage.delete({
+		ref: metadata.ref,
+		condition: {
+			_tag: "IfMatch",
+			etag: metadata.etag
+		}
+	}).pipe(Effect.catchReason("StorageError", "NotFound", () => Effect.void));
+});
+const headOptional = (storage, key) => storage.head({ key }).pipe(Effect.catchReason("StorageError", "NotFound", () => Effect.succeed(void 0)));
+
+export { deletePinned, hashObject, headOptional, pin };
+//# sourceMappingURL=objects.js.map

package/dist/workflows/objects.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"objects.js","names":[],"sources":["../../src/workflows/objects.ts"],"sourcesContent":["import { Effect, Stream } from \"effect\";\n\nimport { storageError } from \"../core/errors.js\";\nimport type { ObjectMetadata } from \"../core/object.js\";\nimport type { StorageService } from \"../core/storage.js\";\nimport { sha256 } from \"../runtime/portable-hash.js\";\n\nexport const pin = (metadata: ObjectMetadata) =>\n  metadata.ref.version\n    ? Effect.succeed({ ref: metadata.ref })\n    : metadata.etag\n      ? Effect.succeed({\n          ref: metadata.ref,\n          condition: { _tag: \"IfMatch\" as const, etag: metadata.etag },\n        })\n      : Effect.fail(\n          storageError(\"verify\", \"workflow\", { _tag: \"Unsupported\", capability: \"pinned-read\" }),\n        );\nexport const hashObject = Effect.fnUntraced(function* (\n  storage: StorageService,\n  metadata: ObjectMetadata,\n) {\n  return yield* Effect.scoped(\n    Effect.gen(function* () {\n      const object = yield* storage.get(yield* pin(metadata));\n      if (object._tag !== \"Object\")\n        return yield* storageError(\"verify\", storage.provider, { _tag: \"IntegrityMismatch\" });\n      const hash = sha256.create();\n      let size = 0;\n      yield* Stream.runForEach(object.body, (chunk) =>\n        Effect.sync(() => {\n          size += chunk.length;\n          hash.update(chunk);\n        }),\n      );\n      if (metadata.size !== undefined && size !== metadata.size)\n        return yield* storageError(\"verify\", storage.provider, {\n          _tag: \"LengthMismatch\",\n          expected: metadata.size,\n          actual: size,\n        });\n      return { size, sha256: hash.finish().value };\n    }),\n  );\n});\nexport const deletePinned = Effect.fnUntraced(function* (\n  storage: StorageService,\n  metadata: ObjectMetadata,\n) {\n  if (metadata.ref.version)\n    return yield* storage\n      .delete({ ref: metadata.ref })\n      .pipe(Effect.catchReason(\"StorageError\", \"NotFound\", () => Effect.void));\n  if (!metadata.etag || !storage.capabilities.deleteConditions.includes(\"if-match\"))\n    return yield* storageError(\n      \"delete\",\n      storage.provider,\n      {\n        _tag: \"Unsupported\",\n        capability: \"pinned-delete\",\n      },\n      \"not-started\",\n    );\n  yield* storage\n    .delete({ ref: metadata.ref, condition: { _tag: \"IfMatch\", etag: metadata.etag } })\n    .pipe(Effect.catchReason(\"StorageError\", \"NotFound\", () => Effect.void));\n});\nexport const headOptional = (storage: StorageService, key: string) =>\n  storage\n    .head({ key })\n    .pipe(Effect.catchReason(\"StorageError\", \"NotFound\", () => Effect.succeed(undefined)));\n"],"mappings":";;;;;AAOA,MAAa,OAAO,aAClB,SAAS,IAAI,UACT,OAAO,QAAQ,EAAE,KAAK,SAAS,IAAI,CAAC,IACpC,SAAS,OACP,OAAO,QAAQ;CACb,KAAK,SAAS;CACd,WAAW;EAAE,MAAM;EAAoB,MAAM,SAAS;CAAK;AAC7D,CAAC,IACD,OAAO,KACL,aAAa,UAAU,YAAY;CAAE,MAAM;CAAe,YAAY;AAAc,CAAC,CACvF;AACR,MAAa,aAAa,OAAO,WAAW,WAC1C,SACA,UACA;CACA,OAAO,OAAO,OAAO,OACnB,OAAO,IAAI,aAAa;EACtB,MAAM,SAAS,OAAO,QAAQ,IAAI,OAAO,IAAI,QAAQ,CAAC;EACtD,IAAI,OAAO,SAAS,UAClB,OAAO,OAAO,aAAa,UAAU,QAAQ,UAAU,EAAE,MAAM,oBAAoB,CAAC;EACtF,MAAM,OAAO,OAAO,OAAO;EAC3B,IAAI,OAAO;EACX,OAAO,OAAO,WAAW,OAAO,OAAO,UACrC,OAAO,WAAW;GAChB,QAAQ,MAAM;GACd,KAAK,OAAO,KAAK;EACnB,CAAC,CACH;EACA,IAAI,SAAS,SAAS,UAAa,SAAS,SAAS,MACnD,OAAO,OAAO,aAAa,UAAU,QAAQ,UAAU;GACrD,MAAM;GACN,UAAU,SAAS;GACnB,QAAQ;EACV,CAAC;EACH,OAAO;GAAE;GAAM,QAAQ,KAAK,OAAO,CAAC,CAAC;EAAM;CAC7C,CAAC,CACH;AACF,CAAC;AACD,MAAa,eAAe,OAAO,WAAW,WAC5C,SACA,UACA;CACA,IAAI,SAAS,IAAI,SACf,OAAO,OAAO,QACX,OAAO,EAAE,KAAK,SAAS,IAAI,CAAC,CAAC,CAC7B,KAAK,OAAO,YAAY,gBAAgB,kBAAkB,OAAO,IAAI,CAAC;CAC3E,IAAI,CAAC,SAAS,QAAQ,CAAC,QAAQ,aAAa,iBAAiB,SAAS,UAAU,GAC9E,OAAO,OAAO,aACZ,UACA,QAAQ,UACR;EACE,MAAM;EACN,YAAY;CACd,GACA,aACF;CACF,OAAO,QACJ,OAAO;EAAE,KAAK,SAAS;EAAK,WAAW;GAAE,MAAM;GAAW,MAAM,SAAS;EAAK;CAAE,CAAC,CAAC,CAClF,KAAK,OAAO,YAAY,gBAAgB,kBAAkB,OAAO,IAAI,CAAC;AAC3E,CAAC;AACD,MAAa,gBAAgB,SAAyB,QACpD,QACG,KAAK,EAAE,IAAI,CAAC,CAAC,CACb,KAAK,OAAO,YAAY,gBAAgB,kBAAkB,OAAO,QAAQ,MAAS,CAAC,CAAC"}

package/dist/workflows/store.d.ts

@@ -0,0 +1,13 @@
+import "../index.js";
+import { CheckpointProtection, SessionOwnership } from "../sessions/store.js";
+import { Effect, Schema } from "effect";
+import { KeyValueStore } from "effect/persistence";
+export interface WorkflowStoreOptions {
+  readonly namespace: string;
+  /** Requires settled, linearizable KVS operations and exclusion through cancellation. */
+  readonly ownership: "exclusive" | SessionOwnership;
+  readonly protection: CheckpointProtection;
+  readonly maximumRecordBytes?: number;
+  readonly maximumOperationMillis?: number;
+}
+//# sourceMappingURL=store.d.ts.map

package/dist/workflows/store.js

@@ -0,0 +1,58 @@
+import { storageError } from "../core/errors.js";
+import { Effect, Redacted, Schema, Semaphore } from "effect";
+import { KeyValueStore } from "effect/persistence";
+
+// src/workflows/store.ts
+const locks = /* @__PURE__ */ new WeakMap();
+const workflowError = (code) => storageError("workflow", "storage", {
+	_tag: "ProviderFailure",
+	code
+});
+const makeRecordStore = Effect.fnUntraced(function* (options, domain) {
+	if (!/^[A-Za-z0-9_-]{1,100}$/u.test(options.namespace) || !options.ownership) return yield* workflowError("InvalidStoreConfiguration");
+	const maximum = options.maximumRecordBytes ?? 1048576;
+	if (!Number.isSafeInteger(maximum) || maximum < 1024) return yield* workflowError("InvalidRecordLimit");
+	const deadline = options.maximumOperationMillis ?? 18e5;
+	if (!Number.isSafeInteger(deadline) || deadline < 1) return yield* workflowError("InvalidOperationDeadline");
+	const kvs = yield* KeyValueStore.KeyValueStore;
+	const namespace = `${options.namespace}:${domain}`;
+	let domains = locks.get(kvs);
+	if (!domains) {
+		domains = /* @__PURE__ */ new Map();
+		locks.set(kvs, domains);
+	}
+	let lock = domains.get(namespace);
+	if (!lock) {
+		lock = Semaphore.makeUnsafe(1);
+		domains.set(namespace, lock);
+	}
+	const semaphore = lock;
+	const key = (id) => `${namespace}:${encodeURIComponent(id)}`;
+	return {
+		exclusive: (effect) => semaphore.withPermit(options.ownership === "exclusive" ? effect : options.ownership.withExclusive(effect)).pipe(Effect.timeoutOrElse({
+			duration: deadline,
+			orElse: () => Effect.fail(workflowError("DeadlineExceeded"))
+		})),
+		read: Effect.fnUntraced(function* (id, schema) {
+			const encrypted = yield* kvs.get(key(id)).pipe(Effect.mapError(() => workflowError("ReadFailed")));
+			if (encrypted === void 0) return void 0;
+			if (encrypted.length > maximum * 2 + 4096) return yield* workflowError("RecordTooLarge");
+			const json = yield* options.protection.open(Redacted.make(encrypted), key(id));
+			if (new TextEncoder().encode(json).length > maximum) return yield* workflowError("RecordTooLarge");
+			return yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.toCodecJson(schema)))(json).pipe(Effect.mapError(() => workflowError("InvalidRecord")));
+		}),
+		write: Effect.fnUntraced(function* (id, schema, value) {
+			const encoded = yield* Schema.encodeEffect(Schema.toCodecJson(schema))(value).pipe(Effect.mapError(() => workflowError("InvalidRecord")));
+			const json = yield* Effect.try({
+				try: () => JSON.stringify(encoded),
+				catch: () => workflowError("InvalidRecord")
+			});
+			if (new TextEncoder().encode(json).length > maximum) return yield* workflowError("RecordTooLarge");
+			const encrypted = yield* options.protection.seal(json, key(id));
+			yield* kvs.set(key(id), Redacted.value(encrypted)).pipe(Effect.mapError(() => workflowError("WriteFailed")));
+		}, Effect.uninterruptible)
+	};
+});
+
+export { makeRecordStore, workflowError };
+//# sourceMappingURL=store.js.map

package/dist/workflows/store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","names":[],"sources":["../../src/workflows/store.ts"],"sourcesContent":["import { Effect, Redacted, Schema, Semaphore } from \"effect\";\nimport { KeyValueStore } from \"effect/persistence\";\n\nimport { storageError } from \"../core/errors.js\";\nimport type { CheckpointProtection, SessionOwnership } from \"../sessions/store.js\";\n\nexport interface WorkflowStoreOptions {\n  readonly namespace: string;\n  /** Requires settled, linearizable KVS operations and exclusion through cancellation. */\n  readonly ownership: \"exclusive\" | SessionOwnership;\n  readonly protection: CheckpointProtection;\n  readonly maximumRecordBytes?: number;\n  readonly maximumOperationMillis?: number;\n}\nconst locks = new WeakMap<KeyValueStore.KeyValueStore, Map<string, Semaphore.Semaphore>>();\nexport const workflowError = (code: string) =>\n  storageError(\"workflow\", \"storage\", { _tag: \"ProviderFailure\", code });\n\nexport const makeRecordStore = Effect.fnUntraced(function* (\n  options: WorkflowStoreOptions,\n  domain: string,\n) {\n  if (!/^[A-Za-z0-9_-]{1,100}$/u.test(options.namespace) || !options.ownership)\n    return yield* workflowError(\"InvalidStoreConfiguration\");\n  const maximum = options.maximumRecordBytes ?? 1024 * 1024;\n  if (!Number.isSafeInteger(maximum) || maximum < 1024)\n    return yield* workflowError(\"InvalidRecordLimit\");\n  const deadline = options.maximumOperationMillis ?? 30 * 60 * 1000;\n  if (!Number.isSafeInteger(deadline) || deadline < 1)\n    return yield* workflowError(\"InvalidOperationDeadline\");\n  const kvs = yield* KeyValueStore.KeyValueStore;\n  const namespace = `${options.namespace}:${domain}`;\n  let domains = locks.get(kvs);\n  if (!domains) {\n    domains = new Map();\n    locks.set(kvs, domains);\n  }\n  let lock = domains.get(namespace);\n  if (!lock) {\n    lock = Semaphore.makeUnsafe(1);\n    domains.set(namespace, lock);\n  }\n  const semaphore = lock;\n  const key = (id: string) => `${namespace}:${encodeURIComponent(id)}`;\n  return {\n    exclusive: <A, E, R>(effect: Effect.Effect<A, E, R>) =>\n      semaphore\n        .withPermit(\n          options.ownership === \"exclusive\" ? effect : options.ownership.withExclusive(effect),\n        )\n        .pipe(\n          Effect.timeoutOrElse({\n            duration: deadline,\n            orElse: () => Effect.fail(workflowError(\"DeadlineExceeded\")),\n          }),\n        ),\n    read: Effect.fnUntraced(function* <S extends Schema.Constraint>(id: string, schema: S) {\n      const encrypted = yield* kvs\n        .get(key(id))\n        .pipe(Effect.mapError(() => workflowError(\"ReadFailed\")));\n      if (encrypted === undefined) return undefined;\n      if (encrypted.length > maximum * 2 + 4096) return yield* workflowError(\"RecordTooLarge\");\n      const json = yield* options.protection.open(Redacted.make(encrypted), key(id));\n      if (new TextEncoder().encode(json).length > maximum)\n        return yield* workflowError(\"RecordTooLarge\");\n      return yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.toCodecJson(schema)))(\n        json,\n      ).pipe(Effect.mapError(() => workflowError(\"InvalidRecord\")));\n    }),\n    write: Effect.fnUntraced(function* <S extends Schema.Constraint>(\n      id: string,\n      schema: S,\n      value: S[\"Type\"],\n    ) {\n      const encoded = yield* Schema.encodeEffect(Schema.toCodecJson(schema))(value).pipe(\n        Effect.mapError(() => workflowError(\"InvalidRecord\")),\n      );\n      const json = yield* Effect.try({\n        try: () => JSON.stringify(encoded),\n        catch: () => workflowError(\"InvalidRecord\"),\n      });\n      if (new TextEncoder().encode(json).length > maximum)\n        return yield* workflowError(\"RecordTooLarge\");\n      const encrypted = yield* options.protection.seal(json, key(id));\n      yield* kvs\n        .set(key(id), Redacted.value(encrypted))\n        .pipe(Effect.mapError(() => workflowError(\"WriteFailed\")));\n    }, Effect.uninterruptible),\n  };\n});\nexport type RecordStore = Effect.Success<ReturnType<typeof makeRecordStore>>;\n"],"mappings":";;;;;AAcA,MAAM,wBAAQ,IAAI,QAAuE;AACzF,MAAa,iBAAiB,SAC5B,aAAa,YAAY,WAAW;CAAE,MAAM;CAAmB;AAAK,CAAC;AAEvE,MAAa,kBAAkB,OAAO,WAAW,WAC/C,SACA,QACA;CACA,IAAI,CAAC,0BAA0B,KAAK,QAAQ,SAAS,KAAK,CAAC,QAAQ,WACjE,OAAO,OAAO,cAAc,2BAA2B;CACzD,MAAM,UAAU,QAAQ,sBAAsB;CAC9C,IAAI,CAAC,OAAO,cAAc,OAAO,KAAK,UAAU,MAC9C,OAAO,OAAO,cAAc,oBAAoB;CAClD,MAAM,WAAW,QAAQ,0BAA0B;CACnD,IAAI,CAAC,OAAO,cAAc,QAAQ,KAAK,WAAW,GAChD,OAAO,OAAO,cAAc,0BAA0B;CACxD,MAAM,MAAM,OAAO,cAAc;CACjC,MAAM,YAAY,GAAG,QAAQ,UAAU,GAAG;CAC1C,IAAI,UAAU,MAAM,IAAI,GAAG;CAC3B,IAAI,CAAC,SAAS;EACZ,0BAAU,IAAI,IAAI;EAClB,MAAM,IAAI,KAAK,OAAO;CACxB;CACA,IAAI,OAAO,QAAQ,IAAI,SAAS;CAChC,IAAI,CAAC,MAAM;EACT,OAAO,UAAU,WAAW,CAAC;EAC7B,QAAQ,IAAI,WAAW,IAAI;CAC7B;CACA,MAAM,YAAY;CAClB,MAAM,OAAO,OAAe,GAAG,UAAU,GAAG,mBAAmB,EAAE;CACjE,OAAO;EACL,YAAqB,WACnB,UACG,WACC,QAAQ,cAAc,cAAc,SAAS,QAAQ,UAAU,cAAc,MAAM,CACrF,CAAC,CACA,KACC,OAAO,cAAc;GACnB,UAAU;GACV,cAAc,OAAO,KAAK,cAAc,kBAAkB,CAAC;EAC7D,CAAC,CACH;EACJ,MAAM,OAAO,WAAW,WAAwC,IAAY,QAAW;GACrF,MAAM,YAAY,OAAO,IACtB,IAAI,IAAI,EAAE,CAAC,CAAC,CACZ,KAAK,OAAO,eAAe,cAAc,YAAY,CAAC,CAAC;GAC1D,IAAI,cAAc,QAAW,OAAO;GACpC,IAAI,UAAU,SAAS,UAAU,IAAI,MAAM,OAAO,OAAO,cAAc,gBAAgB;GACvF,MAAM,OAAO,OAAO,QAAQ,WAAW,KAAK,SAAS,KAAK,SAAS,GAAG,IAAI,EAAE,CAAC;GAC7E,IAAI,IAAI,YAAY,CAAC,CAAC,OAAO,IAAI,CAAC,CAAC,SAAS,SAC1C,OAAO,OAAO,cAAc,gBAAgB;GAC9C,OAAO,OAAO,OAAO,oBAAoB,OAAO,eAAe,OAAO,YAAY,MAAM,CAAC,CAAC,CAAC,CACzF,IACF,CAAC,CAAC,KAAK,OAAO,eAAe,cAAc,eAAe,CAAC,CAAC;EAC9D,CAAC;EACD,OAAO,OAAO,WAAW,WACvB,IACA,QACA,OACA;GACA,MAAM,UAAU,OAAO,OAAO,aAAa,OAAO,YAAY,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,KAC5E,OAAO,eAAe,cAAc,eAAe,CAAC,CACtD;GACA,MAAM,OAAO,OAAO,OAAO,IAAI;IAC7B,WAAW,KAAK,UAAU,OAAO;IACjC,aAAa,cAAc,eAAe;GAC5C,CAAC;GACD,IAAI,IAAI,YAAY,CAAC,CAAC,OAAO,IAAI,CAAC,CAAC,SAAS,SAC1C,OAAO,OAAO,cAAc,gBAAgB;GAC9C,MAAM,YAAY,OAAO,QAAQ,WAAW,KAAK,MAAM,IAAI,EAAE,CAAC;GAC9D,OAAO,IACJ,IAAI,IAAI,EAAE,GAAG,SAAS,MAAM,SAAS,CAAC,CAAC,CACvC,KAAK,OAAO,eAAe,cAAc,aAAa,CAAC,CAAC;EAC7D,GAAG,OAAO,eAAe;CAC3B;AACF,CAAC"}