@effect-kit/storage 0.0.0-stage → 0.0.0

package/dist/testing/faults.js

@@ -0,0 +1,111 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { StorageReason, storageError } from "../core/errors.js";
+import { Storage } from "../core/storage.js";
+import { failBody } from "./body-failure.js";
+import { Cause, Effect, Exit, Predicate, Ref, Schema, Stream } from "effect";
+
+// src/testing/faults.ts
+var faults_exports = /* @__PURE__ */ __exportAll({ make: () => make });
+const Operation = Schema.Literals([
+	"put",
+	"get",
+	"head",
+	"delete",
+	"listPage"
+]);
+const FaultStep = Schema.Struct({
+	operation: Operation,
+	delayMillis: Schema.optional(Schema.Natural),
+	beforeFailure: Schema.optional(StorageReason),
+	afterFailure: Schema.optional(StorageReason),
+	bodyFailure: Schema.optional(Schema.Struct({
+		afterBytes: Schema.Natural,
+		reason: StorageReason
+	})),
+	cleanupFailure: Schema.optional(Schema.NonEmptyString),
+	observerFailure: Schema.optional(Schema.NonEmptyString)
+});
+const make = Effect.fnUntraced(function* (base, script) {
+	const steps = yield* Schema.decodeUnknownEffect(Schema.Array(FaultStep), { onExcessProperty: "error" })(script).pipe(Effect.mapError(() => storageError("faults", base.provider, {
+		_tag: "InvalidConfiguration",
+		field: "script"
+	})));
+	if (steps.some((step) => step.cleanupFailure && step.operation !== "get" || step.bodyFailure && step.operation !== "put" && step.operation !== "get")) return yield* storageError("faults", base.provider, {
+		_tag: "InvalidConfiguration",
+		field: "script.phase"
+	});
+	const index = yield* Ref.make(0);
+	const attempts = yield* Ref.make([]);
+	const diagnostics = yield* Ref.make([]);
+	const recordDiagnostic = (step, position, kind, code) => Ref.update(diagnostics, (current) => [...current, {
+		operation: step.operation,
+		index: position,
+		kind,
+		code
+	}]);
+	const perform = (operation, execute) => Effect.gen(function* () {
+		const position = yield* Ref.getAndUpdate(index, (current) => current + 1);
+		const step = steps[position];
+		if (step === void 0 || step.operation !== operation) return yield* Effect.die(/* @__PURE__ */ new Error(step === void 0 ? "Storage fault script exhausted" : "Storage fault script operation mismatch"));
+		yield* Ref.update(attempts, (current) => [...current, {
+			index: position,
+			operation,
+			status: "started"
+		}]);
+		const effect = Effect.gen(function* () {
+			if (step.delayMillis) yield* Effect.sleep(step.delayMillis);
+			if (step.beforeFailure) return yield* storageError(operation, base.provider, step.beforeFailure, operation === "put" || operation === "delete" ? "not-started" : "not-applicable");
+			const value = yield* execute(step, position);
+			if (step.observerFailure) yield* recordDiagnostic(step, position, "observer", step.observerFailure);
+			if (step.afterFailure) return yield* storageError(operation, base.provider, step.afterFailure, operation === "put" || operation === "delete" ? "unknown" : "not-applicable");
+			return value;
+		});
+		return yield* Effect.onExit(effect, (exit) => Ref.update(attempts, (current) => current.map((attempt) => attempt.index !== position ? attempt : {
+			...attempt,
+			status: Exit.isSuccess(exit) ? operation === "get" ? "acquired" : "succeeded" : Cause.hasInterrupts(exit.cause) ? "interrupted" : Cause.hasDies(exit.cause) ? "defect" : "failed"
+		})));
+	});
+	return {
+		storage: Storage.make({
+			...base,
+			put: (request) => perform("put", (step) => {
+				if (!step.bodyFailure) return base.put(request);
+				const source = Predicate.isUint8Array(request.body) ? Stream.succeed(request.body) : request.body;
+				return base.put({
+					...request,
+					body: failBody(source, step.bodyFailure.afterBytes, storageError("put", base.provider, step.bodyFailure.reason, "unknown"))
+				});
+			}),
+			get: (request) => perform("get", (step, position) => Effect.gen(function* () {
+				yield* Effect.addFinalizer(() => Effect.gen(function* () {
+					yield* Ref.update(attempts, (current) => current.map((attempt) => attempt.index === position && attempt.status === "acquired" ? {
+						...attempt,
+						status: "closed"
+					} : attempt));
+					if (step.cleanupFailure) yield* recordDiagnostic(step, position, "cleanup", step.cleanupFailure);
+				}));
+				const response = yield* base.get(request);
+				if (response._tag === "NotModified") return response;
+				const body = step.bodyFailure === void 0 ? response.body : failBody(response.body, step.bodyFailure.afterBytes, storageError("get", base.provider, step.bodyFailure.reason));
+				return {
+					...response,
+					body: Stream.onExit(body, (exit) => Ref.update(attempts, (current) => current.map((attempt) => attempt.index !== position ? attempt : {
+						...attempt,
+						status: Exit.isSuccess(exit) ? "succeeded" : Cause.hasInterrupts(exit.cause) ? "interrupted" : Cause.hasDies(exit.cause) ? "defect" : "failed"
+					})))
+				};
+			})),
+			head: (request) => perform("head", () => base.head(request)),
+			delete: (request) => perform("delete", () => base.delete(request)),
+			listPage: (request) => perform("listPage", () => base.listPage(request))
+		}),
+		attempts: Ref.get(attempts).pipe(Effect.map((current) => current.map((attempt) => ({ ...attempt })))),
+		diagnostics: Ref.get(diagnostics).pipe(Effect.map((current) => current.map((diagnostic) => ({ ...diagnostic })))),
+		assertDone: Effect.gen(function* () {
+			if ((yield* Ref.get(index)) !== steps.length) return yield* Effect.die(/* @__PURE__ */ new Error("Storage fault script has unconsumed steps"));
+		})
+	};
+});
+
+export { faults_exports, make };
+//# sourceMappingURL=faults.js.map

package/dist/testing/faults.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"faults.js","names":[],"sources":["../../src/testing/faults.ts"],"sourcesContent":["import { Cause, Effect, Exit, Predicate, Ref, Schema, Stream } from \"effect\";\n\nimport { StorageReason, storageError } from \"../core/errors.js\";\nimport type { StorageError } from \"../core/errors.js\";\nimport type { GetRequest, PutRequest } from \"../core/requests.js\";\nimport { Storage } from \"../core/storage.js\";\nimport type { StorageService } from \"../core/storage.js\";\nimport { failBody } from \"./body-failure.js\";\n\nconst Operation = Schema.Literals([\"put\", \"get\", \"head\", \"delete\", \"listPage\"]);\nconst FaultStep = Schema.Struct({\n  operation: Operation,\n  delayMillis: Schema.optional(Schema.Natural),\n  beforeFailure: Schema.optional(StorageReason),\n  afterFailure: Schema.optional(StorageReason),\n  bodyFailure: Schema.optional(\n    Schema.Struct({\n      afterBytes: Schema.Natural,\n      reason: StorageReason,\n    }),\n  ),\n  cleanupFailure: Schema.optional(Schema.NonEmptyString),\n  observerFailure: Schema.optional(Schema.NonEmptyString),\n});\n\nexport type FaultStep = typeof FaultStep.Type;\n\nexport interface FaultAttempt {\n  readonly index: number;\n  readonly operation: typeof Operation.Type;\n  readonly status:\n    | \"started\"\n    | \"acquired\"\n    | \"closed\"\n    | \"succeeded\"\n    | \"failed\"\n    | \"interrupted\"\n    | \"defect\";\n}\n\nexport interface FaultDiagnostic {\n  readonly index: number;\n  readonly operation: typeof Operation.Type;\n  readonly kind: \"cleanup\" | \"observer\";\n  readonly code: string;\n}\n\nexport interface FaultController {\n  readonly storage: StorageService;\n  readonly attempts: Effect.Effect<ReadonlyArray<FaultAttempt>>;\n  readonly diagnostics: Effect.Effect<ReadonlyArray<FaultDiagnostic>>;\n  readonly assertDone: Effect.Effect<void>;\n}\n\nexport const make = Effect.fnUntraced(function* (\n  base: StorageService,\n  script: ReadonlyArray<FaultStep>,\n): Effect.fn.Return<FaultController, StorageError> {\n  const steps = yield* Schema.decodeUnknownEffect(Schema.Array(FaultStep), {\n    onExcessProperty: \"error\",\n  })(script).pipe(\n    Effect.mapError(() =>\n      storageError(\"faults\", base.provider, { _tag: \"InvalidConfiguration\", field: \"script\" }),\n    ),\n  );\n\n  if (\n    steps.some(\n      (step) =>\n        (step.cleanupFailure && step.operation !== \"get\") ||\n        (step.bodyFailure && step.operation !== \"put\" && step.operation !== \"get\"),\n    )\n  ) {\n    return yield* storageError(\"faults\", base.provider, {\n      _tag: \"InvalidConfiguration\",\n      field: \"script.phase\",\n    });\n  }\n\n  const index = yield* Ref.make(0);\n  const attempts = yield* Ref.make<ReadonlyArray<FaultAttempt>>([]);\n  const diagnostics = yield* Ref.make<ReadonlyArray<FaultDiagnostic>>([]);\n  const recordDiagnostic = (\n    step: FaultStep,\n    position: number,\n    kind: \"cleanup\" | \"observer\",\n    code: string,\n  ) =>\n    Ref.update(diagnostics, (current) => [\n      ...current,\n      { operation: step.operation, index: position, kind, code },\n    ]);\n\n  const perform = <A, E, R>(\n    operation: typeof Operation.Type,\n    execute: (step: FaultStep, position: number) => Effect.Effect<A, E, R>,\n  ): Effect.Effect<A, E | StorageError, R> =>\n    Effect.gen(function* () {\n      const position = yield* Ref.getAndUpdate(index, (current) => current + 1);\n      const step = steps[position];\n      if (step === undefined || step.operation !== operation) {\n        return yield* Effect.die(\n          new Error(\n            step === undefined\n              ? \"Storage fault script exhausted\"\n              : \"Storage fault script operation mismatch\",\n          ),\n        );\n      }\n\n      yield* Ref.update(attempts, (current) => [\n        ...current,\n        {\n          index: position,\n          operation,\n          status: \"started\",\n        } satisfies FaultAttempt,\n      ]);\n\n      const effect = Effect.gen(function* () {\n        if (step.delayMillis) yield* Effect.sleep(step.delayMillis);\n        if (step.beforeFailure) {\n          return yield* storageError(\n            operation,\n            base.provider,\n            step.beforeFailure,\n            operation === \"put\" || operation === \"delete\" ? \"not-started\" : \"not-applicable\",\n          );\n        }\n\n        const value = yield* execute(step, position);\n        if (step.observerFailure)\n          yield* recordDiagnostic(step, position, \"observer\", step.observerFailure);\n        if (step.afterFailure) {\n          return yield* storageError(\n            operation,\n            base.provider,\n            step.afterFailure,\n            operation === \"put\" || operation === \"delete\" ? \"unknown\" : \"not-applicable\",\n          );\n        }\n        return value;\n      });\n\n      return yield* Effect.onExit(effect, (exit) =>\n        Ref.update(attempts, (current) =>\n          current.map((attempt) =>\n            attempt.index !== position\n              ? attempt\n              : {\n                  ...attempt,\n                  status: Exit.isSuccess(exit)\n                    ? operation === \"get\"\n                      ? \"acquired\"\n                      : \"succeeded\"\n                    : Cause.hasInterrupts(exit.cause)\n                      ? \"interrupted\"\n                      : Cause.hasDies(exit.cause)\n                        ? \"defect\"\n                        : \"failed\",\n                },\n          ),\n        ),\n      );\n    });\n\n  const storage = Storage.make({\n    ...base,\n    put: <E = never, R = never>(request: PutRequest<E, R>) =>\n      perform(\"put\", (step) => {\n        if (!step.bodyFailure) return base.put(request);\n\n        const source = Predicate.isUint8Array(request.body)\n          ? Stream.succeed(request.body)\n          : request.body;\n        return base.put({\n          ...request,\n          body: failBody(\n            source,\n            step.bodyFailure.afterBytes,\n            storageError(\"put\", base.provider, step.bodyFailure.reason, \"unknown\"),\n          ),\n        });\n      }),\n    get: (request: GetRequest) =>\n      perform(\"get\", (step, position) =>\n        Effect.gen(function* () {\n          yield* Effect.addFinalizer(() =>\n            Effect.gen(function* () {\n              yield* Ref.update(attempts, (current) =>\n                current.map((attempt) =>\n                  attempt.index === position && attempt.status === \"acquired\"\n                    ? { ...attempt, status: \"closed\" as const }\n                    : attempt,\n                ),\n              );\n              if (step.cleanupFailure) {\n                yield* recordDiagnostic(step, position, \"cleanup\", step.cleanupFailure);\n              }\n            }),\n          );\n\n          const response = yield* base.get(request);\n          if (response._tag === \"NotModified\") return response;\n\n          const body =\n            step.bodyFailure === undefined\n              ? response.body\n              : failBody(\n                  response.body,\n                  step.bodyFailure.afterBytes,\n                  storageError(\"get\", base.provider, step.bodyFailure.reason),\n                );\n\n          return {\n            ...response,\n            body: Stream.onExit(body, (exit) =>\n              Ref.update(attempts, (current) =>\n                current.map((attempt) =>\n                  attempt.index !== position\n                    ? attempt\n                    : {\n                        ...attempt,\n                        status: Exit.isSuccess(exit)\n                          ? \"succeeded\"\n                          : Cause.hasInterrupts(exit.cause)\n                            ? \"interrupted\"\n                            : Cause.hasDies(exit.cause)\n                              ? \"defect\"\n                              : \"failed\",\n                      },\n                ),\n              ),\n            ),\n          };\n        }),\n      ),\n    head: (request) => perform(\"head\", () => base.head(request)),\n    delete: (request) => perform(\"delete\", () => base.delete(request)),\n    listPage: (request) => perform(\"listPage\", () => base.listPage(request)),\n  });\n\n  return {\n    storage,\n    attempts: Ref.get(attempts).pipe(\n      Effect.map((current) => current.map((attempt) => ({ ...attempt }))),\n    ),\n    diagnostics: Ref.get(diagnostics).pipe(\n      Effect.map((current) => current.map((diagnostic) => ({ ...diagnostic }))),\n    ),\n    assertDone: Effect.gen(function* () {\n      const consumed = yield* Ref.get(index);\n      if (consumed !== steps.length)\n        return yield* Effect.die(new Error(\"Storage fault script has unconsumed steps\"));\n    }),\n  };\n});\n"],"mappings":"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"}

package/dist/testing/memory-list.js

@@ -0,0 +1,79 @@
+import { storageError } from "../core/errors.js";
+import { cloneMetadata } from "./memory-state.js";
+import { Effect, Ref, Schema } from "effect";
+import { Base64Url } from "effect/encoding";
+
+// src/testing/memory-list.ts
+const Cursor = Schema.fromJsonString(Schema.Struct({
+	version: Schema.Literal(1),
+	storeId: Schema.String,
+	instanceId: Schema.String,
+	prefix: Schema.String,
+	delimiter: Schema.NullOr(Schema.String),
+	limit: Schema.Natural,
+	after: Schema.String
+}));
+const listMemory = Effect.fnUntraced(function* (context, request = {}) {
+	const prefix = request.prefix ?? "";
+	const delimiter = request.delimiter ?? null;
+	const limit = request.limit ?? 100;
+	let after;
+	if (request.cursor !== void 0) {
+		if (request.cursor.length > 32768) return yield* storageError("listPage", "memory", {
+			_tag: "InvalidInput",
+			field: "cursor"
+		});
+		const decoded = yield* Effect.fromResult(Base64Url.decodeString(request.cursor)).pipe(Effect.mapError(() => storageError("listPage", "memory", {
+			_tag: "InvalidInput",
+			field: "cursor"
+		})));
+		const cursor = yield* Schema.decodeUnknownEffect(Cursor)(decoded).pipe(Effect.mapError(() => storageError("listPage", "memory", {
+			_tag: "InvalidInput",
+			field: "cursor"
+		})));
+		if (cursor.storeId !== context.storeId || cursor.instanceId !== context.instanceId || cursor.prefix !== prefix || cursor.delimiter !== delimiter || cursor.limit !== limit) return yield* storageError("listPage", "memory", {
+			_tag: "InvalidInput",
+			field: "cursor"
+		});
+		after = cursor.after;
+	}
+	const state = yield* Ref.get(context.state);
+	const entries = /* @__PURE__ */ new Map();
+	for (const [key, entry] of state.objects) {
+		if (!key.startsWith(prefix)) continue;
+		const index = delimiter === null ? -1 : key.indexOf(delimiter, prefix.length);
+		if (index >= 0 && delimiter !== null) {
+			const common = key.slice(0, index + delimiter.length);
+			entries.set(common, {
+				_tag: "CommonPrefix",
+				prefix: common
+			});
+		} else entries.set(key, {
+			_tag: "Object",
+			metadata: cloneMetadata(entry.metadata)
+		});
+	}
+	const sorted = Array.from(entries.keys()).toSorted().filter((key) => after === void 0 || key > after);
+	const keys = sorted.slice(0, limit);
+	const page = [];
+	for (const key of keys) {
+		const entry = entries.get(key);
+		if (entry !== void 0) page.push(entry);
+	}
+	const last = keys.at(-1);
+	return {
+		entries: page,
+		...sorted.length > limit && last !== void 0 ? { cursor: Base64Url.encode(Schema.encodeSync(Cursor)({
+			version: 1,
+			storeId: context.storeId,
+			instanceId: context.instanceId,
+			prefix,
+			delimiter,
+			limit,
+			after: last
+		})) } : {}
+	};
+});
+
+export { listMemory };
+//# sourceMappingURL=memory-list.js.map

package/dist/testing/memory-list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-list.js","names":[],"sources":["../../src/testing/memory-list.ts"],"sourcesContent":["import { Effect, Ref, Schema } from \"effect\";\nimport { Base64Url } from \"effect/encoding\";\n\nimport { storageError } from \"../core/errors.js\";\nimport type { StorageError } from \"../core/errors.js\";\nimport type { ListEntry, ListPage, ListRequest } from \"../core/requests.js\";\nimport { cloneMetadata } from \"./memory-state.js\";\nimport type { MemoryContext } from \"./memory-state.js\";\n\nconst Cursor = Schema.fromJsonString(\n  Schema.Struct({\n    version: Schema.Literal(1),\n    storeId: Schema.String,\n    instanceId: Schema.String,\n    prefix: Schema.String,\n    delimiter: Schema.NullOr(Schema.String),\n    limit: Schema.Natural,\n    after: Schema.String,\n  }),\n);\n\nexport const listMemory = Effect.fnUntraced(function* (\n  context: MemoryContext,\n  request: ListRequest = {},\n): Effect.fn.Return<ListPage, StorageError> {\n  const prefix = request.prefix ?? \"\";\n  const delimiter = request.delimiter ?? null;\n  const limit = request.limit ?? 100;\n  let after: string | undefined;\n\n  if (request.cursor !== undefined) {\n    if (request.cursor.length > 32768) {\n      return yield* storageError(\"listPage\", \"memory\", { _tag: \"InvalidInput\", field: \"cursor\" });\n    }\n\n    const decoded = yield* Effect.fromResult(Base64Url.decodeString(request.cursor)).pipe(\n      Effect.mapError(() =>\n        storageError(\"listPage\", \"memory\", { _tag: \"InvalidInput\", field: \"cursor\" }),\n      ),\n    );\n    const cursor = yield* Schema.decodeUnknownEffect(Cursor)(decoded).pipe(\n      Effect.mapError(() =>\n        storageError(\"listPage\", \"memory\", { _tag: \"InvalidInput\", field: \"cursor\" }),\n      ),\n    );\n\n    if (\n      cursor.storeId !== context.storeId ||\n      cursor.instanceId !== context.instanceId ||\n      cursor.prefix !== prefix ||\n      cursor.delimiter !== delimiter ||\n      cursor.limit !== limit\n    ) {\n      return yield* storageError(\"listPage\", \"memory\", { _tag: \"InvalidInput\", field: \"cursor\" });\n    }\n    after = cursor.after;\n  }\n\n  const state = yield* Ref.get(context.state);\n  const entries = new Map<string, ListEntry>();\n  for (const [key, entry] of state.objects) {\n    if (!key.startsWith(prefix)) continue;\n    const index = delimiter === null ? -1 : key.indexOf(delimiter, prefix.length);\n    if (index >= 0 && delimiter !== null) {\n      const common = key.slice(0, index + delimiter.length);\n      entries.set(common, { _tag: \"CommonPrefix\", prefix: common });\n    } else {\n      entries.set(key, { _tag: \"Object\", metadata: cloneMetadata(entry.metadata) });\n    }\n  }\n\n  const sorted = Array.from(entries.keys())\n    .toSorted()\n    .filter((key) => after === undefined || key > after);\n  const keys = sorted.slice(0, limit);\n  const page: ListEntry[] = [];\n  for (const key of keys) {\n    const entry = entries.get(key);\n    if (entry !== undefined) page.push(entry);\n  }\n\n  const last = keys.at(-1);\n  return {\n    entries: page,\n    ...(sorted.length > limit && last !== undefined\n      ? {\n          cursor: Base64Url.encode(\n            Schema.encodeSync(Cursor)({\n              version: 1,\n              storeId: context.storeId,\n              instanceId: context.instanceId,\n              prefix,\n              delimiter,\n              limit,\n              after: last,\n            }),\n          ),\n        }\n      : {}),\n  };\n});\n"],"mappings":";;;;;;AASA,MAAM,SAAS,OAAO,eACpB,OAAO,OAAO;CACZ,SAAS,OAAO,QAAQ,CAAC;CACzB,SAAS,OAAO;CAChB,YAAY,OAAO;CACnB,QAAQ,OAAO;CACf,WAAW,OAAO,OAAO,OAAO,MAAM;CACtC,OAAO,OAAO;CACd,OAAO,OAAO;AAChB,CAAC,CACH;AAEA,MAAa,aAAa,OAAO,WAAW,WAC1C,SACA,UAAuB,CAAC,GACkB;CAC1C,MAAM,SAAS,QAAQ,UAAU;CACjC,MAAM,YAAY,QAAQ,aAAa;CACvC,MAAM,QAAQ,QAAQ,SAAS;CAC/B,IAAI;CAEJ,IAAI,QAAQ,WAAW,QAAW;EAChC,IAAI,QAAQ,OAAO,SAAS,OAC1B,OAAO,OAAO,aAAa,YAAY,UAAU;GAAE,MAAM;GAAgB,OAAO;EAAS,CAAC;EAG5F,MAAM,UAAU,OAAO,OAAO,WAAW,UAAU,aAAa,QAAQ,MAAM,CAAC,CAAC,CAAC,KAC/E,OAAO,eACL,aAAa,YAAY,UAAU;GAAE,MAAM;GAAgB,OAAO;EAAS,CAAC,CAC9E,CACF;EACA,MAAM,SAAS,OAAO,OAAO,oBAAoB,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,KAChE,OAAO,eACL,aAAa,YAAY,UAAU;GAAE,MAAM;GAAgB,OAAO;EAAS,CAAC,CAC9E,CACF;EAEA,IACE,OAAO,YAAY,QAAQ,WAC3B,OAAO,eAAe,QAAQ,cAC9B,OAAO,WAAW,UAClB,OAAO,cAAc,aACrB,OAAO,UAAU,OAEjB,OAAO,OAAO,aAAa,YAAY,UAAU;GAAE,MAAM;GAAgB,OAAO;EAAS,CAAC;EAE5F,QAAQ,OAAO;CACjB;CAEA,MAAM,QAAQ,OAAO,IAAI,IAAI,QAAQ,KAAK;CAC1C,MAAM,0BAAU,IAAI,IAAuB;CAC3C,KAAK,MAAM,CAAC,KAAK,UAAU,MAAM,SAAS;EACxC,IAAI,CAAC,IAAI,WAAW,MAAM,GAAG;EAC7B,MAAM,QAAQ,cAAc,OAAO,KAAK,IAAI,QAAQ,WAAW,OAAO,MAAM;EAC5E,IAAI,SAAS,KAAK,cAAc,MAAM;GACpC,MAAM,SAAS,IAAI,MAAM,GAAG,QAAQ,UAAU,MAAM;GACpD,QAAQ,IAAI,QAAQ;IAAE,MAAM;IAAgB,QAAQ;GAAO,CAAC;EAC9D,OACE,QAAQ,IAAI,KAAK;GAAE,MAAM;GAAU,UAAU,cAAc,MAAM,QAAQ;EAAE,CAAC;CAEhF;CAEA,MAAM,SAAS,MAAM,KAAK,QAAQ,KAAK,CAAC,CAAC,CACtC,SAAS,CAAC,CACV,QAAQ,QAAQ,UAAU,UAAa,MAAM,KAAK;CACrD,MAAM,OAAO,OAAO,MAAM,GAAG,KAAK;CAClC,MAAM,OAAoB,CAAC;CAC3B,KAAK,MAAM,OAAO,MAAM;EACtB,MAAM,QAAQ,QAAQ,IAAI,GAAG;EAC7B,IAAI,UAAU,QAAW,KAAK,KAAK,KAAK;CAC1C;CAEA,MAAM,OAAO,KAAK,GAAG,EAAE;CACvB,OAAO;EACL,SAAS;EACT,GAAI,OAAO,SAAS,SAAS,SAAS,SAClC,EACE,QAAQ,UAAU,OAChB,OAAO,WAAW,MAAM,CAAC,CAAC;GACxB,SAAS;GACT,SAAS,QAAQ;GACjB,YAAY,QAAQ;GACpB;GACA;GACA;GACA,OAAO;EACT,CAAC,CACH,EACF,IACA,CAAC;CACP;AACF,CAAC"}

package/dist/testing/memory-state.d.ts

@@ -0,0 +1,18 @@
+import "../core/object.js";
+import "../core/errors.js";
+import "../core/requests.js";
+import "../core/capabilities.js";
+import { Ref, Result, Schema } from "effect";
+export declare const MemoryOptions: Schema.Struct<{
+  readonly storeId: Schema.optional<Schema.NonEmptyString>;
+  readonly maxObjectBytes: Schema.optional<Schema.Int>;
+  readonly maxTotalBytes: Schema.optional<Schema.Int>;
+  readonly maxPendingBytes: Schema.optional<Schema.Int>;
+  readonly maxReadBytes: Schema.optional<Schema.Int>;
+  readonly maxObjects: Schema.optional<Schema.Int>;
+  readonly maxKeyBytes: Schema.optional<Schema.Int>;
+  readonly maxMetadataBytes: Schema.optional<Schema.Int>;
+  readonly chunkSize: Schema.optional<Schema.Int>;
+}>;
+export type MemoryOptions = typeof MemoryOptions.Type;
+//# sourceMappingURL=memory-state.d.ts.map

package/dist/testing/memory-state.js

@@ -0,0 +1,57 @@
+import { storageError } from "../core/errors.js";
+import { Result, Schema } from "effect";
+
+// src/testing/memory-state.ts
+const Positive = Schema.Int.check(Schema.isGreaterThan(0));
+const MemoryOptions = Schema.Struct({
+	storeId: Schema.optional(Schema.NonEmptyString),
+	maxObjectBytes: Schema.optional(Positive),
+	maxTotalBytes: Schema.optional(Positive),
+	maxPendingBytes: Schema.optional(Positive),
+	maxReadBytes: Schema.optional(Positive),
+	maxObjects: Schema.optional(Positive),
+	maxKeyBytes: Schema.optional(Positive),
+	maxMetadataBytes: Schema.optional(Positive),
+	chunkSize: Schema.optional(Positive)
+});
+const memoryCapabilities = {
+	putConditions: ["create-only", "if-match"],
+	getConditions: ["if-match", "if-none-match"],
+	deleteConditions: ["if-match"],
+	ranges: [
+		"bounded",
+		"from",
+		"suffix"
+	],
+	versionedReads: "current-only",
+	list: {
+		maxPageSize: 1e3,
+		delimiter: true,
+		cursorPersistence: "process",
+		snapshot: false
+	}
+};
+function matchesVersion(entry, target) {
+	if (!("ref" in target) || target.ref.version === void 0) return true;
+	const version = target.ref.version;
+	return version._tag === "OpaqueVersion" && version.provider === "memory" && version.id === entry.metadata.ref.version?.id;
+}
+function findObject(state, target, operation) {
+	const key = "ref" in target ? target.ref.key : target.key;
+	const entry = state.objects.get(key);
+	return entry && matchesVersion(entry, target) ? Result.succeed(entry) : Result.fail(storageError(operation, "memory", { _tag: "NotFound" }));
+}
+function cloneMetadata(metadata) {
+	return {
+		...metadata,
+		ref: {
+			...metadata.ref,
+			...metadata.ref.version ? { version: { ...metadata.ref.version } } : {}
+		},
+		...metadata.customMetadata ? { customMetadata: { ...metadata.customMetadata } } : {},
+		...metadata.checksums ? { checksums: metadata.checksums.map((checksum) => ({ ...checksum })) } : {}
+	};
+}
+
+export { MemoryOptions, cloneMetadata, findObject, matchesVersion, memoryCapabilities };
+//# sourceMappingURL=memory-state.js.map

package/dist/testing/memory-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-state.js","names":[],"sources":["../../src/testing/memory-state.ts"],"sourcesContent":["import { Result, Schema } from \"effect\";\nimport type { Ref } from \"effect\";\n\nimport type { StorageCapabilities } from \"../core/capabilities.js\";\nimport { storageError } from \"../core/errors.js\";\nimport type { StorageError } from \"../core/errors.js\";\nimport type { ObjectMetadata } from \"../core/object.js\";\nimport type { ObjectTarget } from \"../core/requests.js\";\n\nconst Positive = Schema.Int.check(Schema.isGreaterThan(0));\nexport const MemoryOptions = Schema.Struct({\n  storeId: Schema.optional(Schema.NonEmptyString),\n  maxObjectBytes: Schema.optional(Positive),\n  maxTotalBytes: Schema.optional(Positive),\n  maxPendingBytes: Schema.optional(Positive),\n  maxReadBytes: Schema.optional(Positive),\n  maxObjects: Schema.optional(Positive),\n  maxKeyBytes: Schema.optional(Positive),\n  maxMetadataBytes: Schema.optional(Positive),\n  chunkSize: Schema.optional(Positive),\n});\n\nexport type MemoryOptions = typeof MemoryOptions.Type;\nexport type MemoryLimits = { readonly [Key in Exclude<keyof MemoryOptions, \"storeId\">]: number };\n\nexport interface StoredObject {\n  readonly metadata: ObjectMetadata;\n  readonly bytes: Uint8Array;\n}\n\nexport interface MemoryState {\n  readonly objects: ReadonlyMap<string, StoredObject>;\n  readonly revision: bigint;\n  readonly totalBytes: number;\n  readonly pendingBytes: number;\n  readonly activeReadBytes: number;\n}\n\nexport interface MemoryContext {\n  readonly storeId: string;\n  readonly instanceId: string;\n  readonly state: Ref.Ref<MemoryState>;\n  readonly limits: MemoryLimits;\n}\n\nexport const memoryCapabilities: StorageCapabilities = {\n  putConditions: [\"create-only\", \"if-match\"],\n  getConditions: [\"if-match\", \"if-none-match\"],\n  deleteConditions: [\"if-match\"],\n  ranges: [\"bounded\", \"from\", \"suffix\"],\n  versionedReads: \"current-only\",\n  list: { maxPageSize: 1000, delimiter: true, cursorPersistence: \"process\", snapshot: false },\n};\n\nexport function matchesVersion(entry: StoredObject, target: ObjectTarget): boolean {\n  if (!(\"ref\" in target) || target.ref.version === undefined) return true;\n\n  const version = target.ref.version;\n  return (\n    version._tag === \"OpaqueVersion\" &&\n    version.provider === \"memory\" &&\n    version.id === entry.metadata.ref.version?.id\n  );\n}\n\nexport function findObject(\n  state: MemoryState,\n  target: ObjectTarget,\n  operation: string,\n): Result.Result<StoredObject, StorageError> {\n  const key = \"ref\" in target ? target.ref.key : target.key;\n  const entry = state.objects.get(key);\n  return entry && matchesVersion(entry, target)\n    ? Result.succeed(entry)\n    : Result.fail(storageError(operation, \"memory\", { _tag: \"NotFound\" }));\n}\n\nexport function cloneMetadata(metadata: ObjectMetadata): ObjectMetadata {\n  return {\n    ...metadata,\n    ref: {\n      ...metadata.ref,\n      ...(metadata.ref.version ? { version: { ...metadata.ref.version } } : {}),\n    },\n    ...(metadata.customMetadata ? { customMetadata: { ...metadata.customMetadata } } : {}),\n    ...(metadata.checksums\n      ? { checksums: metadata.checksums.map((checksum) => ({ ...checksum })) }\n      : {}),\n  };\n}\n"],"mappings":";;;;AASA,MAAM,WAAW,OAAO,IAAI,MAAM,OAAO,cAAc,CAAC,CAAC;AACzD,MAAa,gBAAgB,OAAO,OAAO;CACzC,SAAS,OAAO,SAAS,OAAO,cAAc;CAC9C,gBAAgB,OAAO,SAAS,QAAQ;CACxC,eAAe,OAAO,SAAS,QAAQ;CACvC,iBAAiB,OAAO,SAAS,QAAQ;CACzC,cAAc,OAAO,SAAS,QAAQ;CACtC,YAAY,OAAO,SAAS,QAAQ;CACpC,aAAa,OAAO,SAAS,QAAQ;CACrC,kBAAkB,OAAO,SAAS,QAAQ;CAC1C,WAAW,OAAO,SAAS,QAAQ;AACrC,CAAC;AAyBD,MAAa,qBAA0C;CACrD,eAAe,CAAC,eAAe,UAAU;CACzC,eAAe,CAAC,YAAY,eAAe;CAC3C,kBAAkB,CAAC,UAAU;CAC7B,QAAQ;EAAC;EAAW;EAAQ;CAAQ;CACpC,gBAAgB;CAChB,MAAM;EAAE,aAAa;EAAM,WAAW;EAAM,mBAAmB;EAAW,UAAU;CAAM;AAC5F;AAEA,SAAgB,eAAe,OAAqB,QAA+B;CACjF,IAAI,EAAE,SAAS,WAAW,OAAO,IAAI,YAAY,QAAW,OAAO;CAEnE,MAAM,UAAU,OAAO,IAAI;CAC3B,OACE,QAAQ,SAAS,mBACjB,QAAQ,aAAa,YACrB,QAAQ,OAAO,MAAM,SAAS,IAAI,SAAS;AAE/C;AAEA,SAAgB,WACd,OACA,QACA,WAC2C;CAC3C,MAAM,MAAM,SAAS,SAAS,OAAO,IAAI,MAAM,OAAO;CACtD,MAAM,QAAQ,MAAM,QAAQ,IAAI,GAAG;CACnC,OAAO,SAAS,eAAe,OAAO,MAAM,IACxC,OAAO,QAAQ,KAAK,IACpB,OAAO,KAAK,aAAa,WAAW,UAAU,EAAE,MAAM,WAAW,CAAC,CAAC;AACzE;AAEA,SAAgB,cAAc,UAA0C;CACtE,OAAO;EACL,GAAG;EACH,KAAK;GACH,GAAG,SAAS;GACZ,GAAI,SAAS,IAAI,UAAU,EAAE,SAAS,EAAE,GAAG,SAAS,IAAI,QAAQ,EAAE,IAAI,CAAC;EACzE;EACA,GAAI,SAAS,iBAAiB,EAAE,gBAAgB,EAAE,GAAG,SAAS,eAAe,EAAE,IAAI,CAAC;EACpF,GAAI,SAAS,YACT,EAAE,WAAW,SAAS,UAAU,KAAK,cAAc,EAAE,GAAG,SAAS,EAAE,EAAE,IACrE,CAAC;CACP;AACF"}

package/dist/testing/memory-upload.js

@@ -0,0 +1,123 @@
+import { storageError } from "../core/errors.js";
+import { cloneMetadata } from "./memory-state.js";
+import { DateTime, Effect, Predicate, Ref, Result, Stream } from "effect";
+
+// src/testing/memory-upload.ts
+const putMemory = Effect.fnUntraced(function* (context, request) {
+	const { limits, state, storeId } = context;
+	const headers = {
+		contentType: request.contentType,
+		contentEncoding: request.contentEncoding,
+		contentLanguage: request.contentLanguage,
+		contentDisposition: request.contentDisposition,
+		cacheControl: request.cacheControl,
+		customMetadata: request.customMetadata ? { ...request.customMetadata } : void 0
+	};
+	const limit = Math.min(limits.maxObjectBytes, request.maxBytes ?? limits.maxObjectBytes);
+	if (new TextEncoder().encode(request.key).length > limits.maxKeyBytes) return yield* storageError("put", "memory", {
+		_tag: "InvalidInput",
+		field: "key"
+	}, "not-started");
+	if (new TextEncoder().encode(JSON.stringify(headers)).length > limits.maxMetadataBytes) return yield* storageError("put", "memory", {
+		_tag: "InvalidInput",
+		field: "metadata"
+	}, "not-started");
+	if (request.contentLength !== void 0 && request.contentLength > limit) return yield* storageError("put", "memory", {
+		_tag: "LimitExceeded",
+		limit
+	}, "not-started");
+	return yield* Effect.acquireUseRelease(Effect.sync(() => ({
+		chunks: [],
+		length: 0,
+		reserved: 0
+	})), (staging) => Effect.gen(function* () {
+		const source = Predicate.isUint8Array(request.body) ? Stream.succeed(request.body) : request.body;
+		yield* Stream.runForEach(source, (chunk) => Effect.gen(function* () {
+			if (!Predicate.isUint8Array(chunk)) return yield* storageError("put", "memory", {
+				_tag: "InvalidInput",
+				field: "body"
+			}, "rejected");
+			if (chunk.length > limit - staging.length) return yield* storageError("put", "memory", {
+				_tag: "LimitExceeded",
+				limit
+			}, "rejected");
+			for (let offset = 0; offset < chunk.length; offset += limits.chunkSize) {
+				const length = Math.min(limits.chunkSize, chunk.length - offset);
+				if (!(yield* Ref.modify(state, (current) => {
+					if (length > Math.floor((limits.maxPendingBytes - current.pendingBytes) / 2)) return [false, current];
+					staging.reserved += length * 2;
+					return [true, {
+						...current,
+						pendingBytes: current.pendingBytes + length * 2
+					}];
+				}))) return yield* storageError("put", "memory", {
+					_tag: "QuotaExceeded",
+					limit: limits.maxPendingBytes
+				}, "rejected");
+				staging.chunks.push(Uint8Array.from(chunk.subarray(offset, offset + length)));
+				staging.length += length;
+			}
+		}));
+		if (request.contentLength !== void 0 && request.contentLength !== staging.length) return yield* storageError("put", "memory", {
+			_tag: "LengthMismatch",
+			expected: request.contentLength,
+			actual: staging.length
+		}, "rejected");
+		const bytes = new Uint8Array(staging.length);
+		let offset = 0;
+		for (const chunk of staging.chunks) {
+			bytes.set(chunk, offset);
+			offset += chunk.length;
+		}
+		const now = yield* DateTime.now;
+		const committed = yield* Ref.modify(state, (current) => {
+			const previous = current.objects.get(request.key);
+			const rejected = (error) => [Result.fail(error), current];
+			if (request.condition?._tag === "CreateOnly" && previous !== void 0 || request.condition?._tag === "IfMatch" && (previous === void 0 || request.condition.etag !== "*" && previous.metadata.etag !== request.condition.etag)) return rejected(storageError("put", "memory", { _tag: "PreconditionFailed" }, "rejected"));
+			const retained = current.totalBytes - (previous?.bytes.length ?? 0);
+			if (bytes.length > limits.maxTotalBytes - retained) return rejected(storageError("put", "memory", {
+				_tag: "QuotaExceeded",
+				limit: limits.maxTotalBytes
+			}, "rejected"));
+			if (previous === void 0 && current.objects.size >= limits.maxObjects) return rejected(storageError("put", "memory", {
+				_tag: "QuotaExceeded",
+				limit: limits.maxObjects
+			}, "rejected"));
+			const revision = current.revision + 1n;
+			const metadata = {
+				...headers,
+				ref: {
+					storeId,
+					key: request.key,
+					version: {
+						_tag: "OpaqueVersion",
+						provider: "memory",
+						id: `${context.instanceId}:${String(revision)}`
+					}
+				},
+				size: bytes.length,
+				etag: `"memory-${String(revision)}"`,
+				lastModified: now
+			};
+			const objects = new Map(current.objects);
+			const entry = {
+				metadata,
+				bytes
+			};
+			objects.set(request.key, entry);
+			return [Result.succeed(cloneMetadata(metadata)), {
+				...current,
+				objects,
+				revision,
+				totalBytes: retained + bytes.length
+			}];
+		});
+		return yield* Effect.fromResult(committed);
+	}), (staging) => Ref.update(state, (current) => ({
+		...current,
+		pendingBytes: current.pendingBytes - staging.reserved
+	})));
+});
+
+export { putMemory };
+//# sourceMappingURL=memory-upload.js.map

package/dist/testing/memory-upload.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-upload.js","names":[],"sources":["../../src/testing/memory-upload.ts"],"sourcesContent":["import { DateTime, Effect, Predicate, Ref, Result, Stream } from \"effect\";\n\nimport { storageError } from \"../core/errors.js\";\nimport type { StorageError } from \"../core/errors.js\";\nimport type { ObjectHeaders, ObjectMetadata } from \"../core/object.js\";\nimport type { PutRequest } from \"../core/requests.js\";\nimport { cloneMetadata } from \"./memory-state.js\";\nimport type { MemoryContext, MemoryState, StoredObject } from \"./memory-state.js\";\n\nexport const putMemory = Effect.fnUntraced(function* <E = never, R = never>(\n  context: MemoryContext,\n  request: PutRequest<E, R>,\n): Effect.fn.Return<ObjectMetadata, StorageError | E, R> {\n  const { limits, state, storeId } = context;\n  const headers: ObjectHeaders = {\n    contentType: request.contentType,\n    contentEncoding: request.contentEncoding,\n    contentLanguage: request.contentLanguage,\n    contentDisposition: request.contentDisposition,\n    cacheControl: request.cacheControl,\n    customMetadata: request.customMetadata ? { ...request.customMetadata } : undefined,\n  };\n\n  const limit = Math.min(limits.maxObjectBytes, request.maxBytes ?? limits.maxObjectBytes);\n  if (new TextEncoder().encode(request.key).length > limits.maxKeyBytes) {\n    return yield* storageError(\n      \"put\",\n      \"memory\",\n      { _tag: \"InvalidInput\", field: \"key\" },\n      \"not-started\",\n    );\n  }\n  if (new TextEncoder().encode(JSON.stringify(headers)).length > limits.maxMetadataBytes) {\n    return yield* storageError(\n      \"put\",\n      \"memory\",\n      { _tag: \"InvalidInput\", field: \"metadata\" },\n      \"not-started\",\n    );\n  }\n  if (request.contentLength !== undefined && request.contentLength > limit) {\n    return yield* storageError(\"put\", \"memory\", { _tag: \"LimitExceeded\", limit }, \"not-started\");\n  }\n\n  return yield* Effect.acquireUseRelease(\n    Effect.sync(() => ({ chunks: [] as Uint8Array[], length: 0, reserved: 0 })),\n    (staging) =>\n      Effect.gen(function* () {\n        const source = Predicate.isUint8Array(request.body)\n          ? Stream.succeed(request.body)\n          : request.body;\n        yield* Stream.runForEach(source, (chunk) =>\n          Effect.gen(function* () {\n            if (!Predicate.isUint8Array(chunk)) {\n              return yield* storageError(\n                \"put\",\n                \"memory\",\n                { _tag: \"InvalidInput\", field: \"body\" },\n                \"rejected\",\n              );\n            }\n            if (chunk.length > limit - staging.length) {\n              return yield* storageError(\n                \"put\",\n                \"memory\",\n                { _tag: \"LimitExceeded\", limit },\n                \"rejected\",\n              );\n            }\n\n            for (let offset = 0; offset < chunk.length; offset += limits.chunkSize) {\n              const length = Math.min(limits.chunkSize, chunk.length - offset);\n              const reserved = yield* Ref.modify(state, (current) => {\n                // Reserve both staged copies and final concatenation before retaining bytes.\n                if (length > Math.floor((limits.maxPendingBytes - current.pendingBytes) / 2)) {\n                  return [false, current] as const;\n                }\n                staging.reserved += length * 2;\n                return [\n                  true,\n                  { ...current, pendingBytes: current.pendingBytes + length * 2 },\n                ] as const;\n              });\n\n              if (!reserved) {\n                return yield* storageError(\n                  \"put\",\n                  \"memory\",\n                  { _tag: \"QuotaExceeded\", limit: limits.maxPendingBytes },\n                  \"rejected\",\n                );\n              }\n              staging.chunks.push(Uint8Array.from(chunk.subarray(offset, offset + length)));\n              staging.length += length;\n            }\n          }),\n        );\n\n        if (request.contentLength !== undefined && request.contentLength !== staging.length) {\n          return yield* storageError(\n            \"put\",\n            \"memory\",\n            {\n              _tag: \"LengthMismatch\",\n              expected: request.contentLength,\n              actual: staging.length,\n            },\n            \"rejected\",\n          );\n        }\n\n        const bytes = new Uint8Array(staging.length);\n        let offset = 0;\n        for (const chunk of staging.chunks) {\n          bytes.set(chunk, offset);\n          offset += chunk.length;\n        }\n\n        const now = yield* DateTime.now;\n        const committed = yield* Ref.modify(\n          state,\n          (current): readonly [Result.Result<ObjectMetadata, StorageError>, MemoryState] => {\n            const previous = current.objects.get(request.key);\n            const rejected = (error: StorageError) => [Result.fail(error), current] as const;\n            if (\n              (request.condition?._tag === \"CreateOnly\" && previous !== undefined) ||\n              (request.condition?._tag === \"IfMatch\" &&\n                (previous === undefined ||\n                  (request.condition.etag !== \"*\" &&\n                    previous.metadata.etag !== request.condition.etag)))\n            ) {\n              return rejected(\n                storageError(\"put\", \"memory\", { _tag: \"PreconditionFailed\" }, \"rejected\"),\n              );\n            }\n\n            const retained = current.totalBytes - (previous?.bytes.length ?? 0);\n            if (bytes.length > limits.maxTotalBytes - retained) {\n              return rejected(\n                storageError(\n                  \"put\",\n                  \"memory\",\n                  { _tag: \"QuotaExceeded\", limit: limits.maxTotalBytes },\n                  \"rejected\",\n                ),\n              );\n            }\n            if (previous === undefined && current.objects.size >= limits.maxObjects) {\n              return rejected(\n                storageError(\n                  \"put\",\n                  \"memory\",\n                  { _tag: \"QuotaExceeded\", limit: limits.maxObjects },\n                  \"rejected\",\n                ),\n              );\n            }\n\n            const revision = current.revision + 1n;\n            const metadata: ObjectMetadata = {\n              ...headers,\n              ref: {\n                storeId,\n                key: request.key,\n                version: {\n                  _tag: \"OpaqueVersion\",\n                  provider: \"memory\",\n                  id: `${context.instanceId}:${String(revision)}`,\n                },\n              },\n              size: bytes.length,\n              etag: `\"memory-${String(revision)}\"`,\n              lastModified: now,\n            };\n            const objects = new Map(current.objects);\n            const entry: StoredObject = { metadata, bytes };\n            objects.set(request.key, entry);\n\n            return [\n              Result.succeed(cloneMetadata(metadata)),\n              {\n                ...current,\n                objects,\n                revision,\n                totalBytes: retained + bytes.length,\n              },\n            ] as const;\n          },\n        );\n\n        return yield* Effect.fromResult(committed);\n      }),\n    (staging) =>\n      Ref.update(state, (current) => ({\n        ...current,\n        pendingBytes: current.pendingBytes - staging.reserved,\n      })),\n  );\n});\n"],"mappings":"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"}

package/dist/testing/memory.d.ts

@@ -0,0 +1,23 @@
+import { StorageError } from "../core/errors.js";
+import { Storage, StorageService } from "../core/storage.js";
+import "../index.js";
+import { TransferDriver } from "../transfers/dependencies.js";
+import { MemoryOptions } from "./memory-state.js";
+import { Effect, Layer } from "effect";
+declare namespace memory_d_exports {
+  export { MemoryOptions, layer, make };
+}
+export declare const make: (options?: {
+  readonly storeId?: string | undefined;
+  readonly maxObjectBytes?: number | undefined;
+  readonly maxTotalBytes?: number | undefined;
+  readonly maxPendingBytes?: number | undefined;
+  readonly maxReadBytes?: number | undefined;
+  readonly maxObjects?: number | undefined;
+  readonly maxKeyBytes?: number | undefined;
+  readonly maxMetadataBytes?: number | undefined;
+  readonly chunkSize?: number | undefined;
+} | undefined) => Effect.Effect<StorageService, StorageError, never>;
+export declare const layer: (options?: MemoryOptions) => Layer.Layer<Storage | TransferDriver, StorageError, never>;
+export { type MemoryOptions, memory_d_exports };
+//# sourceMappingURL=memory.d.ts.map

package/dist/testing/memory.js

@@ -0,0 +1,121 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { storageError } from "../core/errors.js";
+import { resolveRange } from "../core/ranges.js";
+import { Storage } from "../core/storage.js";
+import { TransferDriver } from "../transfers/dependencies.js";
+import { MemoryOptions, cloneMetadata, findObject, matchesVersion, memoryCapabilities } from "./memory-state.js";
+import { listMemory } from "./memory-list.js";
+import { putMemory } from "./memory-upload.js";
+import { Context, Effect, Layer, Random, Ref, Result, Schema, Stream } from "effect";
+
+// src/testing/memory.ts
+var memory_exports = /* @__PURE__ */ __exportAll({
+	layer: () => layer,
+	make: () => make
+});
+const getMemory = Effect.fnUntraced(function* (context, request) {
+	const current = yield* Ref.get(context.state);
+	const entry = yield* Effect.fromResult(findObject(current, request, "get"));
+	const metadata = cloneMetadata(entry.metadata);
+	if (request.condition?._tag === "IfMatch" && request.condition.etag !== "*" && request.condition.etag !== metadata.etag) return yield* storageError("get", "memory", { _tag: "PreconditionFailed" });
+	if (request.condition?._tag === "IfNoneMatch" && (request.condition.etag === "*" || request.condition.etag === metadata.etag)) return {
+		_tag: "NotModified",
+		metadata
+	};
+	const range = request.range ? yield* Effect.fromResult(resolveRange(request.range, entry.bytes.length, "memory")) : void 0;
+	yield* Effect.acquireRelease(Ref.modify(context.state, (state) => {
+		if (entry.bytes.length > context.limits.maxReadBytes - state.activeReadBytes) return [false, state];
+		return [true, {
+			...state,
+			activeReadBytes: state.activeReadBytes + entry.bytes.length
+		}];
+	}).pipe(Effect.flatMap((reserved) => reserved ? Effect.void : Effect.fail(storageError("get", "memory", {
+		_tag: "QuotaExceeded",
+		limit: context.limits.maxReadBytes
+	})))), () => Ref.update(context.state, (state) => ({
+		...state,
+		activeReadBytes: state.activeReadBytes - entry.bytes.length
+	})));
+	const start = range?.start ?? 0;
+	const end = range?.end ?? entry.bytes.length - 1;
+	const chunks = { *[Symbol.iterator]() {
+		for (let offset = start; offset <= end; offset += context.limits.chunkSize) yield entry.bytes.slice(offset, Math.min(end + 1, offset + context.limits.chunkSize));
+	} };
+	return {
+		_tag: "Object",
+		metadata,
+		contentLength: Math.max(0, end - start + 1),
+		range,
+		body: Stream.fromIterable(chunks, { chunkSize: 1 })
+	};
+});
+const deleteMemory = Effect.fnUntraced(function* (context, request) {
+	const outcome = yield* Ref.modify(context.state, (state) => {
+		const key = "ref" in request ? request.ref.key : request.key;
+		const candidate = state.objects.get(key);
+		const entry = candidate && matchesVersion(candidate, request) ? candidate : void 0;
+		if (request.condition && (entry === void 0 || request.condition.etag !== "*" && entry.metadata.etag !== request.condition.etag)) return [Result.fail(storageError("delete", "memory", { _tag: "PreconditionFailed" }, "rejected")), state];
+		if (entry === void 0) return [Result.succeed(void 0), state];
+		const objects = new Map(state.objects);
+		objects.delete(key);
+		return [Result.succeed(void 0), {
+			...state,
+			objects,
+			totalBytes: state.totalBytes - entry.bytes.length
+		}];
+	});
+	yield* Effect.fromResult(outcome);
+});
+const make = Effect.fnUntraced(function* (options = {}) {
+	const input = yield* Schema.decodeUnknownEffect(MemoryOptions, { onExcessProperty: "error" })(options).pipe(Effect.mapError(() => storageError("make", "memory", {
+		_tag: "InvalidConfiguration",
+		field: "options"
+	})));
+	const storeId = input.storeId ?? `memory:${String(yield* Random.nextInt)}:${String(yield* Random.nextInt)}`;
+	const instanceId = `${String(yield* Random.nextInt)}:${String(yield* Random.nextInt)}`;
+	const state = yield* Ref.make({
+		objects: /* @__PURE__ */ new Map(),
+		revision: 0n,
+		totalBytes: 0,
+		pendingBytes: 0,
+		activeReadBytes: 0
+	});
+	const context = {
+		storeId,
+		instanceId,
+		state,
+		limits: {
+			maxObjectBytes: input.maxObjectBytes ?? 16777216,
+			maxTotalBytes: input.maxTotalBytes ?? 67108864,
+			maxPendingBytes: input.maxPendingBytes ?? 33554432,
+			maxReadBytes: input.maxReadBytes ?? 33554432,
+			maxObjects: input.maxObjects ?? 1e3,
+			maxKeyBytes: input.maxKeyBytes ?? 4096,
+			maxMetadataBytes: input.maxMetadataBytes ?? 8192,
+			chunkSize: input.chunkSize ?? 65536
+		}
+	};
+	return Storage.make({
+		provider: "memory",
+		storeId,
+		capabilities: memoryCapabilities,
+		put: (request) => putMemory(context, request),
+		get: (request) => getMemory(context, request),
+		head: Effect.fnUntraced(function* (request) {
+			const current = yield* Ref.get(state);
+			const entry = yield* Effect.fromResult(findObject(current, request, "head"));
+			return cloneMetadata(entry.metadata);
+		}),
+		delete: (request) => deleteMemory(context, request),
+		listPage: (request) => listMemory(context, request)
+	});
+});
+const layer = (options = {}) => Layer.effectContext(Effect.map(make(options), (storage) => Context.make(Storage, storage).pipe(Context.add(TransferDriver, {
+	storage,
+	maximumObjectBytes: options.maxObjectBytes ?? 16777216,
+	maximumSingleUploadBytes: options.maxObjectBytes ?? 16777216,
+	transportOverheadBytes: 0
+}))));
+
+export { layer, make, memory_exports };
+//# sourceMappingURL=memory.js.map

package/dist/testing/memory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.js","names":[],"sources":["../../src/testing/memory.ts"],"sourcesContent":["import { Context, Effect, Layer, Random, Ref, Result, Schema, Stream } from \"effect\";\nimport type { Scope } from \"effect\";\n\nimport { storageError } from \"../core/errors.js\";\nimport type { StorageError } from \"../core/errors.js\";\nimport { resolveRange } from \"../core/ranges.js\";\nimport type { DeleteRequest, GetRequest, GetResult, HeadRequest } from \"../core/requests.js\";\nimport { Storage } from \"../core/storage.js\";\nimport { TransferDriver } from \"../transfers/dependencies.js\";\nimport { listMemory } from \"./memory-list.js\";\nimport {\n  MemoryOptions,\n  cloneMetadata,\n  findObject,\n  matchesVersion,\n  memoryCapabilities,\n} from \"./memory-state.js\";\nimport type { MemoryContext, MemoryState } from \"./memory-state.js\";\nimport { putMemory } from \"./memory-upload.js\";\n\nexport type { MemoryOptions } from \"./memory-state.js\";\n\nconst getMemory = Effect.fnUntraced(function* (\n  context: MemoryContext,\n  request: GetRequest,\n): Effect.fn.Return<GetResult, StorageError, Scope.Scope> {\n  const current = yield* Ref.get(context.state);\n  const entry = yield* Effect.fromResult(findObject(current, request, \"get\"));\n  const metadata = cloneMetadata(entry.metadata);\n\n  if (\n    request.condition?._tag === \"IfMatch\" &&\n    request.condition.etag !== \"*\" &&\n    request.condition.etag !== metadata.etag\n  ) {\n    return yield* storageError(\"get\", \"memory\", { _tag: \"PreconditionFailed\" });\n  }\n  if (\n    request.condition?._tag === \"IfNoneMatch\" &&\n    (request.condition.etag === \"*\" || request.condition.etag === metadata.etag)\n  ) {\n    return { _tag: \"NotModified\", metadata };\n  }\n\n  const range = request.range\n    ? yield* Effect.fromResult(resolveRange(request.range, entry.bytes.length, \"memory\"))\n    : undefined;\n\n  yield* Effect.acquireRelease(\n    Ref.modify(context.state, (state) => {\n      if (entry.bytes.length > context.limits.maxReadBytes - state.activeReadBytes) {\n        return [false, state] as const;\n      }\n      return [\n        true,\n        { ...state, activeReadBytes: state.activeReadBytes + entry.bytes.length },\n      ] as const;\n    }).pipe(\n      Effect.flatMap((reserved) =>\n        reserved\n          ? Effect.void\n          : Effect.fail(\n              storageError(\"get\", \"memory\", {\n                _tag: \"QuotaExceeded\",\n                limit: context.limits.maxReadBytes,\n              }),\n            ),\n      ),\n    ),\n    () =>\n      Ref.update(context.state, (state) => ({\n        ...state,\n        activeReadBytes: state.activeReadBytes - entry.bytes.length,\n      })),\n  );\n\n  const start = range?.start ?? 0;\n  const end = range?.end ?? entry.bytes.length - 1;\n  const chunks = {\n    *[Symbol.iterator]() {\n      for (let offset = start; offset <= end; offset += context.limits.chunkSize) {\n        yield entry.bytes.slice(offset, Math.min(end + 1, offset + context.limits.chunkSize));\n      }\n    },\n  };\n\n  return {\n    _tag: \"Object\",\n    metadata,\n    contentLength: Math.max(0, end - start + 1),\n    range,\n    body: Stream.fromIterable(chunks, { chunkSize: 1 }),\n  };\n});\n\nconst deleteMemory = Effect.fnUntraced(function* (context: MemoryContext, request: DeleteRequest) {\n  const outcome = yield* Ref.modify(\n    context.state,\n    (state): readonly [Result.Result<void, StorageError>, MemoryState] => {\n      const key = \"ref\" in request ? request.ref.key : request.key;\n      const candidate = state.objects.get(key);\n      const entry = candidate && matchesVersion(candidate, request) ? candidate : undefined;\n      if (\n        request.condition &&\n        (entry === undefined ||\n          (request.condition.etag !== \"*\" && entry.metadata.etag !== request.condition.etag))\n      ) {\n        return [\n          Result.fail(storageError(\"delete\", \"memory\", { _tag: \"PreconditionFailed\" }, \"rejected\")),\n          state,\n        ] as const;\n      }\n\n      if (entry === undefined) return [Result.succeed(undefined), state] as const;\n      const objects = new Map(state.objects);\n      objects.delete(key);\n\n      return [\n        Result.succeed(undefined),\n        { ...state, objects, totalBytes: state.totalBytes - entry.bytes.length },\n      ] as const;\n    },\n  );\n\n  yield* Effect.fromResult(outcome);\n});\n\nexport const make = Effect.fnUntraced(function* (options: MemoryOptions = {}) {\n  const input = yield* Schema.decodeUnknownEffect(MemoryOptions, { onExcessProperty: \"error\" })(\n    options,\n  ).pipe(\n    Effect.mapError(() =>\n      storageError(\"make\", \"memory\", { _tag: \"InvalidConfiguration\", field: \"options\" }),\n    ),\n  );\n\n  const storeId =\n    input.storeId ?? `memory:${String(yield* Random.nextInt)}:${String(yield* Random.nextInt)}`;\n  const instanceId = `${String(yield* Random.nextInt)}:${String(yield* Random.nextInt)}`;\n  const state = yield* Ref.make<MemoryState>({\n    objects: new Map(),\n    revision: 0n,\n    totalBytes: 0,\n    pendingBytes: 0,\n    activeReadBytes: 0,\n  });\n  const context: MemoryContext = {\n    storeId,\n    instanceId,\n    state,\n    limits: {\n      maxObjectBytes: input.maxObjectBytes ?? 16 * 1024 * 1024,\n      maxTotalBytes: input.maxTotalBytes ?? 64 * 1024 * 1024,\n      maxPendingBytes: input.maxPendingBytes ?? 32 * 1024 * 1024,\n      maxReadBytes: input.maxReadBytes ?? 32 * 1024 * 1024,\n      maxObjects: input.maxObjects ?? 1000,\n      maxKeyBytes: input.maxKeyBytes ?? 4096,\n      maxMetadataBytes: input.maxMetadataBytes ?? 8192,\n      chunkSize: input.chunkSize ?? 64 * 1024,\n    },\n  };\n\n  return Storage.make({\n    provider: \"memory\",\n    storeId,\n    capabilities: memoryCapabilities,\n    put: (request) => putMemory(context, request),\n    get: (request) => getMemory(context, request),\n    head: Effect.fnUntraced(function* (request: HeadRequest) {\n      const current = yield* Ref.get(state);\n      const entry = yield* Effect.fromResult(findObject(current, request, \"head\"));\n      return cloneMetadata(entry.metadata);\n    }),\n    delete: (request) => deleteMemory(context, request),\n    listPage: (request) => listMemory(context, request),\n  });\n});\n\nexport const layer = (options: MemoryOptions = {}) =>\n  Layer.effectContext(\n    Effect.map(make(options), (storage) =>\n      Context.make(Storage, storage).pipe(\n        Context.add(TransferDriver, {\n          storage,\n          maximumObjectBytes: options.maxObjectBytes ?? 16 * 1024 * 1024,\n          maximumSingleUploadBytes: options.maxObjectBytes ?? 16 * 1024 * 1024,\n          transportOverheadBytes: 0,\n        }),\n      ),\n    ),\n  );\n"],"mappings":"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"}