@effect-kit/storage 0.0.0-stage → 0.1.0

package/dist/core/object.js

@@ -0,0 +1,55 @@
+import { Schema } from "effect";
+
+// src/core/object.ts
+/** An opaque key. Provider-specific encoding and limits are checked by adapters. */
+const ObjectKey = Schema.NonEmptyString.check(Schema.makeFilter((value) => value.isWellFormed() && !value.includes("\0"), { expected: "a well-formed opaque key without NUL" }));
+/** A JSON-safe byte count. Unsafe integers are rejected rather than rounded. */
+const ObjectSize = Schema.Natural;
+const NativeVersion = Schema.Union([
+	Schema.TaggedStruct("S3Version", { id: Schema.NonEmptyString }),
+	Schema.TaggedStruct("GcsGeneration", {
+		id: Schema.NonEmptyString,
+		metageneration: Schema.optional(Schema.NonEmptyString)
+	}),
+	Schema.TaggedStruct("AzureVersion", { id: Schema.NonEmptyString }),
+	Schema.TaggedStruct("AzureSnapshot", { id: Schema.NonEmptyString }),
+	Schema.TaggedStruct("OpaqueVersion", {
+		provider: Schema.NonEmptyString,
+		id: Schema.NonEmptyString
+	})
+]);
+const ObjectRef = Schema.Struct({
+	storeId: Schema.NonEmptyString,
+	key: ObjectKey,
+	version: Schema.optional(NativeVersion)
+});
+const Checksum = Schema.Struct({
+	algorithm: Schema.NonEmptyString,
+	encoding: Schema.Literals(["hex", "base64"]),
+	scope: Schema.Literals(["full-object", "composite"]),
+	value: Schema.NonEmptyString,
+	partCount: Schema.optional(Schema.Int.check(Schema.isGreaterThan(0)))
+});
+const HeaderValue = Schema.String.check(Schema.makeFilter((value) => value.isWellFormed() && !/[\r\n\0]/u.test(value), { expected: "a well-formed header value without CR, LF or NUL" }));
+const ObjectValidator = HeaderValue.check(Schema.isNonEmpty());
+const ObjectHeaders = Schema.Struct({
+	contentType: Schema.optional(HeaderValue),
+	contentEncoding: Schema.optional(HeaderValue),
+	contentLanguage: Schema.optional(HeaderValue),
+	contentDisposition: Schema.optional(HeaderValue),
+	cacheControl: Schema.optional(HeaderValue),
+	customMetadata: Schema.optional(Schema.Record(Schema.String.check(Schema.isPattern(/^[A-Za-z0-9._-]+$/u)), HeaderValue))
+});
+/** Type-side timestamps are DateTime.Utc; the encoded representation uses ISO strings. */
+const ObjectMetadata = Schema.Struct({
+	...ObjectHeaders.fields,
+	ref: ObjectRef,
+	size: Schema.optional(ObjectSize),
+	etag: Schema.optional(ObjectValidator),
+	lastModified: Schema.optional(Schema.DateTimeUtcFromString),
+	checksums: Schema.optional(Schema.Array(Checksum)),
+	storageClass: Schema.optional(Schema.NonEmptyString)
+});
+
+export { Checksum, HeaderValue, NativeVersion, ObjectHeaders, ObjectKey, ObjectMetadata, ObjectRef, ObjectSize, ObjectValidator };
+//# sourceMappingURL=object.js.map

package/dist/core/object.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.js","names":[],"sources":["../../src/core/object.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\n/** An opaque key. Provider-specific encoding and limits are checked by adapters. */\nexport const ObjectKey = Schema.NonEmptyString.check(\n  Schema.makeFilter<string>((value) => value.isWellFormed() && !value.includes(\"\\0\"), {\n    expected: \"a well-formed opaque key without NUL\",\n  }),\n);\n\nexport type ObjectKey = typeof ObjectKey.Type;\n\n/** A JSON-safe byte count. Unsafe integers are rejected rather than rounded. */\nexport const ObjectSize = Schema.Natural;\n\nexport type ObjectSize = typeof ObjectSize.Type;\n\nexport const NativeVersion = Schema.Union([\n  Schema.TaggedStruct(\"S3Version\", { id: Schema.NonEmptyString }),\n  Schema.TaggedStruct(\"GcsGeneration\", {\n    id: Schema.NonEmptyString,\n    metageneration: Schema.optional(Schema.NonEmptyString),\n  }),\n  Schema.TaggedStruct(\"AzureVersion\", { id: Schema.NonEmptyString }),\n  Schema.TaggedStruct(\"AzureSnapshot\", { id: Schema.NonEmptyString }),\n  Schema.TaggedStruct(\"OpaqueVersion\", {\n    provider: Schema.NonEmptyString,\n    id: Schema.NonEmptyString,\n  }),\n]);\n\nexport type NativeVersion = typeof NativeVersion.Type;\n\nexport const ObjectRef = Schema.Struct({\n  storeId: Schema.NonEmptyString,\n  key: ObjectKey,\n  version: Schema.optional(NativeVersion),\n});\n\nexport type ObjectRef = typeof ObjectRef.Type;\n\nexport const Checksum = Schema.Struct({\n  algorithm: Schema.NonEmptyString,\n  encoding: Schema.Literals([\"hex\", \"base64\"]),\n  scope: Schema.Literals([\"full-object\", \"composite\"]),\n  value: Schema.NonEmptyString,\n  partCount: Schema.optional(Schema.Int.check(Schema.isGreaterThan(0))),\n});\n\nexport type Checksum = typeof Checksum.Type;\n\nexport const HeaderValue = Schema.String.check(\n  Schema.makeFilter<string>((value) => value.isWellFormed() && !/[\\r\\n\\0]/u.test(value), {\n    expected: \"a well-formed header value without CR, LF or NUL\",\n  }),\n);\n\nexport const ObjectValidator = HeaderValue.check(Schema.isNonEmpty());\nexport type ObjectValidator = typeof ObjectValidator.Type;\n\nexport const ObjectHeaders = Schema.Struct({\n  contentType: Schema.optional(HeaderValue),\n  contentEncoding: Schema.optional(HeaderValue),\n  contentLanguage: Schema.optional(HeaderValue),\n  contentDisposition: Schema.optional(HeaderValue),\n  cacheControl: Schema.optional(HeaderValue),\n  customMetadata: Schema.optional(\n    Schema.Record(Schema.String.check(Schema.isPattern(/^[A-Za-z0-9._-]+$/u)), HeaderValue),\n  ),\n});\n\nexport type ObjectHeaders = typeof ObjectHeaders.Type;\n\n/** Type-side timestamps are DateTime.Utc; the encoded representation uses ISO strings. */\nexport const ObjectMetadata = Schema.Struct({\n  ...ObjectHeaders.fields,\n  ref: ObjectRef,\n  size: Schema.optional(ObjectSize),\n  etag: Schema.optional(ObjectValidator),\n  lastModified: Schema.optional(Schema.DateTimeUtcFromString),\n  checksums: Schema.optional(Schema.Array(Checksum)),\n  storageClass: Schema.optional(Schema.NonEmptyString),\n});\n\nexport type ObjectMetadata = typeof ObjectMetadata.Type;\n"],"mappings":";;;;AAGA,MAAa,YAAY,OAAO,eAAe,MAC7C,OAAO,YAAoB,UAAU,MAAM,aAAa,KAAK,CAAC,MAAM,SAAS,IAAI,GAAG,EAClF,UAAU,uCACZ,CAAC,CACH;;AAKA,MAAa,aAAa,OAAO;AAIjC,MAAa,gBAAgB,OAAO,MAAM;CACxC,OAAO,aAAa,aAAa,EAAE,IAAI,OAAO,eAAe,CAAC;CAC9D,OAAO,aAAa,iBAAiB;EACnC,IAAI,OAAO;EACX,gBAAgB,OAAO,SAAS,OAAO,cAAc;CACvD,CAAC;CACD,OAAO,aAAa,gBAAgB,EAAE,IAAI,OAAO,eAAe,CAAC;CACjE,OAAO,aAAa,iBAAiB,EAAE,IAAI,OAAO,eAAe,CAAC;CAClE,OAAO,aAAa,iBAAiB;EACnC,UAAU,OAAO;EACjB,IAAI,OAAO;CACb,CAAC;AACH,CAAC;AAID,MAAa,YAAY,OAAO,OAAO;CACrC,SAAS,OAAO;CAChB,KAAK;CACL,SAAS,OAAO,SAAS,aAAa;AACxC,CAAC;AAID,MAAa,WAAW,OAAO,OAAO;CACpC,WAAW,OAAO;CAClB,UAAU,OAAO,SAAS,CAAC,OAAO,QAAQ,CAAC;CAC3C,OAAO,OAAO,SAAS,CAAC,eAAe,WAAW,CAAC;CACnD,OAAO,OAAO;CACd,WAAW,OAAO,SAAS,OAAO,IAAI,MAAM,OAAO,cAAc,CAAC,CAAC,CAAC;AACtE,CAAC;AAID,MAAa,cAAc,OAAO,OAAO,MACvC,OAAO,YAAoB,UAAU,MAAM,aAAa,KAAK,CAAC,YAAY,KAAK,KAAK,GAAG,EACrF,UAAU,mDACZ,CAAC,CACH;AAEA,MAAa,kBAAkB,YAAY,MAAM,OAAO,WAAW,CAAC;AAGpE,MAAa,gBAAgB,OAAO,OAAO;CACzC,aAAa,OAAO,SAAS,WAAW;CACxC,iBAAiB,OAAO,SAAS,WAAW;CAC5C,iBAAiB,OAAO,SAAS,WAAW;CAC5C,oBAAoB,OAAO,SAAS,WAAW;CAC/C,cAAc,OAAO,SAAS,WAAW;CACzC,gBAAgB,OAAO,SACrB,OAAO,OAAO,OAAO,OAAO,MAAM,OAAO,UAAU,oBAAoB,CAAC,GAAG,WAAW,CACxF;AACF,CAAC;;AAKD,MAAa,iBAAiB,OAAO,OAAO;CAC1C,GAAG,cAAc;CACjB,KAAK;CACL,MAAM,OAAO,SAAS,UAAU;CAChC,MAAM,OAAO,SAAS,eAAe;CACrC,cAAc,OAAO,SAAS,OAAO,qBAAqB;CAC1D,WAAW,OAAO,SAAS,OAAO,MAAM,QAAQ,CAAC;CACjD,cAAc,OAAO,SAAS,OAAO,cAAc;AACrD,CAAC"}

package/dist/core/ranges.d.ts

@@ -0,0 +1,17 @@
+import "./errors.js";
+import { Result, Schema } from "effect";
+export declare const ByteRange: Schema.Union<readonly [Schema.TaggedStruct<"Bounded", {
+  readonly start: Schema.Natural;
+  readonly end: Schema.Natural;
+}>, Schema.TaggedStruct<"From", {
+  readonly start: Schema.Natural;
+}>, Schema.TaggedStruct<"Suffix", {
+  readonly length: Schema.Int;
+}>]>;
+export type ByteRange = typeof ByteRange.Type;
+export interface ResolvedRange {
+  readonly start: number;
+  readonly end: number;
+  readonly totalSize: number;
+}
+//# sourceMappingURL=ranges.d.ts.map

package/dist/core/ranges.js

@@ -0,0 +1,27 @@
+import { ObjectSize } from "./object.js";
+import { storageError } from "./errors.js";
+import { Result, Schema } from "effect";
+
+// src/core/ranges.ts
+const ByteRange = Schema.Union([
+	Schema.TaggedStruct("Bounded", {
+		start: ObjectSize,
+		end: ObjectSize
+	}),
+	Schema.TaggedStruct("From", { start: ObjectSize }),
+	Schema.TaggedStruct("Suffix", { length: Schema.Int.check(Schema.isGreaterThan(0)) })
+]);
+/** Resolves inclusive HTTP-style bounds against a known complete object size. */
+function resolveRange(range, size, provider) {
+	const start = range._tag === "Suffix" ? Math.max(0, size - range.length) : range.start;
+	const end = range._tag === "Bounded" ? Math.min(size - 1, range.end) : size - 1;
+	if (size === 0 || start >= size || end < start) return Result.fail(storageError("get", provider, { _tag: "RangeNotSatisfiable" }));
+	return Result.succeed({
+		start,
+		end,
+		totalSize: size
+	});
+}
+
+export { ByteRange, resolveRange };
+//# sourceMappingURL=ranges.js.map

package/dist/core/ranges.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ranges.js","names":[],"sources":["../../src/core/ranges.ts"],"sourcesContent":["import { Result, Schema } from \"effect\";\n\nimport { storageError } from \"./errors.js\";\nimport type { StorageError } from \"./errors.js\";\nimport { ObjectSize } from \"./object.js\";\n\nexport const ByteRange = Schema.Union([\n  Schema.TaggedStruct(\"Bounded\", { start: ObjectSize, end: ObjectSize }),\n  Schema.TaggedStruct(\"From\", { start: ObjectSize }),\n  Schema.TaggedStruct(\"Suffix\", { length: Schema.Int.check(Schema.isGreaterThan(0)) }),\n]);\n\nexport type ByteRange = typeof ByteRange.Type;\n\nexport interface ResolvedRange {\n  readonly start: number;\n  readonly end: number;\n  readonly totalSize: number;\n}\n\n/** Resolves inclusive HTTP-style bounds against a known complete object size. */\nexport function resolveRange(\n  range: ByteRange,\n  size: number,\n  provider: string,\n): Result.Result<ResolvedRange, StorageError> {\n  const start = range._tag === \"Suffix\" ? Math.max(0, size - range.length) : range.start;\n  const end = range._tag === \"Bounded\" ? Math.min(size - 1, range.end) : size - 1;\n\n  if (size === 0 || start >= size || end < start) {\n    return Result.fail(storageError(\"get\", provider, { _tag: \"RangeNotSatisfiable\" }));\n  }\n\n  return Result.succeed({ start, end, totalSize: size });\n}\n"],"mappings":";;;;;AAMA,MAAa,YAAY,OAAO,MAAM;CACpC,OAAO,aAAa,WAAW;EAAE,OAAO;EAAY,KAAK;CAAW,CAAC;CACrE,OAAO,aAAa,QAAQ,EAAE,OAAO,WAAW,CAAC;CACjD,OAAO,aAAa,UAAU,EAAE,QAAQ,OAAO,IAAI,MAAM,OAAO,cAAc,CAAC,CAAC,EAAE,CAAC;AACrF,CAAC;;AAWD,SAAgB,aACd,OACA,MACA,UAC4C;CAC5C,MAAM,QAAQ,MAAM,SAAS,WAAW,KAAK,IAAI,GAAG,OAAO,MAAM,MAAM,IAAI,MAAM;CACjF,MAAM,MAAM,MAAM,SAAS,YAAY,KAAK,IAAI,OAAO,GAAG,MAAM,GAAG,IAAI,OAAO;CAE9E,IAAI,SAAS,KAAK,SAAS,QAAQ,MAAM,OACvC,OAAO,OAAO,KAAK,aAAa,OAAO,UAAU,EAAE,MAAM,sBAAsB,CAAC,CAAC;CAGnF,OAAO,OAAO,QAAQ;EAAE;EAAO;EAAK,WAAW;CAAK,CAAC;AACvD"}

package/dist/core/requests.d.ts

@@ -0,0 +1,185 @@
+import { ObjectMetadata } from "./object.js";
+import { StorageError } from "./errors.js";
+import { ResolvedRange } from "./ranges.js";
+import { Schema, Scope, Stream } from "effect";
+export declare const WriteCondition: Schema.Union<readonly [Schema.TaggedStruct<"CreateOnly", {}>, Schema.TaggedStruct<"IfMatch", {
+  readonly etag: Schema.String;
+}>]>;
+export type WriteCondition = typeof WriteCondition.Type;
+export declare const ReadCondition: Schema.Union<readonly [Schema.TaggedStruct<"IfMatch", {
+  readonly etag: Schema.String;
+}>, Schema.TaggedStruct<"IfNoneMatch", {
+  readonly etag: Schema.String;
+}>]>;
+export type ReadCondition = typeof ReadCondition.Type;
+export type UploadBody<E = never, R = never> = Uint8Array | Stream.Stream<Uint8Array, E, R>;
+export declare const PutRequest: 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 key: Schema.NonEmptyString;
+  readonly body: Schema.Unknown;
+  readonly condition: Schema.optional<Schema.Union<readonly [Schema.TaggedStruct<"CreateOnly", {}>, Schema.TaggedStruct<"IfMatch", {
+    readonly etag: Schema.String;
+  }>]>>;
+  readonly contentLength: Schema.optional<Schema.Natural>;
+  readonly maxBytes: Schema.optional<Schema.Natural>;
+}>;
+export type PutRequest<E = never, R = never> = Omit<typeof PutRequest.Type, "body"> & {
+  readonly body: UploadBody<E, R>;
+};
+declare const Target: Schema.Union<readonly [Schema.Struct<{
+  readonly key: Schema.NonEmptyString;
+}>, Schema.Struct<{
+  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;
+    }>]>>;
+  }>;
+}>]>;
+export type ObjectTarget = typeof Target.Type;
+export declare const HeadRequest: Schema.Union<readonly [Schema.Struct<{
+  readonly key: Schema.NonEmptyString;
+}>, Schema.Struct<{
+  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;
+    }>]>>;
+  }>;
+}>]>;
+export type HeadRequest = ObjectTarget;
+export declare const GetRequest: Schema.Union<readonly [Schema.Struct<{
+  readonly key: Schema.NonEmptyString;
+  readonly range: Schema.optional<Schema.Union<readonly [Schema.TaggedStruct<"Bounded", {
+    readonly start: Schema.Natural;
+    readonly end: Schema.Natural;
+  }>, Schema.TaggedStruct<"From", {
+    readonly start: Schema.Natural;
+  }>, Schema.TaggedStruct<"Suffix", {
+    readonly length: Schema.Int;
+  }>]>>;
+  readonly condition: Schema.optional<Schema.Union<readonly [Schema.TaggedStruct<"IfMatch", {
+    readonly etag: Schema.String;
+  }>, Schema.TaggedStruct<"IfNoneMatch", {
+    readonly etag: Schema.String;
+  }>]>>;
+}>, Schema.Struct<{
+  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 range: Schema.optional<Schema.Union<readonly [Schema.TaggedStruct<"Bounded", {
+    readonly start: Schema.Natural;
+    readonly end: Schema.Natural;
+  }>, Schema.TaggedStruct<"From", {
+    readonly start: Schema.Natural;
+  }>, Schema.TaggedStruct<"Suffix", {
+    readonly length: Schema.Int;
+  }>]>>;
+  readonly condition: Schema.optional<Schema.Union<readonly [Schema.TaggedStruct<"IfMatch", {
+    readonly etag: Schema.String;
+  }>, Schema.TaggedStruct<"IfNoneMatch", {
+    readonly etag: Schema.String;
+  }>]>>;
+}>]>;
+export type GetRequest = typeof GetRequest.Type;
+export declare const DeleteRequest: Schema.Union<readonly [Schema.Struct<{
+  readonly key: Schema.NonEmptyString;
+  readonly condition: Schema.optional<Schema.TaggedStruct<"IfMatch", {
+    readonly etag: Schema.String;
+  }>>;
+}>, Schema.Struct<{
+  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 condition: Schema.optional<Schema.TaggedStruct<"IfMatch", {
+    readonly etag: Schema.String;
+  }>>;
+}>]>;
+export type DeleteRequest = typeof DeleteRequest.Type;
+export declare const ListRequest: Schema.Struct<{
+  readonly prefix: Schema.optional<Schema.String>;
+  readonly delimiter: Schema.optional<Schema.NonEmptyString>;
+  readonly limit: Schema.optional<Schema.Int>;
+  readonly cursor: Schema.optional<Schema.NonEmptyString>;
+}>;
+export type ListRequest = typeof ListRequest.Type;
+export interface ObjectDownload {
+  readonly _tag: "Object";
+  readonly metadata: ObjectMetadata;
+  readonly contentLength?: number | undefined;
+  readonly range?: ResolvedRange | undefined;
+  readonly body: Stream.Stream<Uint8Array, StorageError, Scope.Scope>;
+}
+export interface NotModified {
+  readonly _tag: "NotModified";
+  readonly metadata: ObjectMetadata;
+}
+export type GetResult = ObjectDownload | NotModified;
+export type ListEntry = {
+  readonly _tag: "Object";
+  readonly metadata: ObjectMetadata;
+} | {
+  readonly _tag: "CommonPrefix";
+  readonly prefix: string;
+};
+export interface ListPage {
+  readonly entries: ReadonlyArray<ListEntry>;
+  readonly cursor?: string | undefined;
+}
+export {};
+//# sourceMappingURL=requests.d.ts.map

package/dist/core/requests.js

@@ -0,0 +1,42 @@
+import { ObjectHeaders, ObjectKey, ObjectRef, ObjectSize, ObjectValidator } from "./object.js";
+import { ByteRange } from "./ranges.js";
+import { Schema } from "effect";
+
+// src/core/requests.ts
+const WriteCondition = Schema.Union([Schema.TaggedStruct("CreateOnly", {}), Schema.TaggedStruct("IfMatch", { etag: ObjectValidator })]);
+const ReadCondition = Schema.Union([Schema.TaggedStruct("IfMatch", { etag: ObjectValidator }), Schema.TaggedStruct("IfNoneMatch", { etag: ObjectValidator })]);
+const PutRequest = Schema.Struct({
+	...ObjectHeaders.fields,
+	key: ObjectKey,
+	body: Schema.Unknown,
+	condition: Schema.optional(WriteCondition),
+	contentLength: Schema.optional(ObjectSize),
+	maxBytes: Schema.optional(ObjectSize)
+});
+const Target = Schema.Union([Schema.Struct({ key: ObjectKey }), Schema.Struct({ ref: ObjectRef })]);
+const HeadRequest = Target;
+const GetRequest = Schema.Union([Schema.Struct({
+	key: ObjectKey,
+	range: Schema.optional(ByteRange),
+	condition: Schema.optional(ReadCondition)
+}), Schema.Struct({
+	ref: ObjectRef,
+	range: Schema.optional(ByteRange),
+	condition: Schema.optional(ReadCondition)
+})]);
+const DeleteRequest = Schema.Union([Schema.Struct({
+	key: ObjectKey,
+	condition: Schema.optional(Schema.TaggedStruct("IfMatch", { etag: ObjectValidator }))
+}), Schema.Struct({
+	ref: ObjectRef,
+	condition: Schema.optional(Schema.TaggedStruct("IfMatch", { etag: ObjectValidator }))
+})]);
+const ListRequest = Schema.Struct({
+	prefix: Schema.optional(Schema.String),
+	delimiter: Schema.optional(Schema.NonEmptyString),
+	limit: Schema.optional(Schema.Int.check(Schema.isGreaterThan(0))),
+	cursor: Schema.optional(Schema.NonEmptyString)
+});
+
+export { DeleteRequest, GetRequest, HeadRequest, ListRequest, PutRequest, ReadCondition, WriteCondition };
+//# sourceMappingURL=requests.js.map

package/dist/core/requests.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"requests.js","names":[],"sources":["../../src/core/requests.ts"],"sourcesContent":["import { Schema } from \"effect\";\nimport type { Scope, Stream } from \"effect\";\n\nimport type { StorageError } from \"./errors.js\";\nimport type { ObjectMetadata } from \"./object.js\";\nimport { ObjectHeaders, ObjectKey, ObjectRef, ObjectSize, ObjectValidator } from \"./object.js\";\nimport { ByteRange } from \"./ranges.js\";\nimport type { ResolvedRange } from \"./ranges.js\";\n\nexport const WriteCondition = Schema.Union([\n  Schema.TaggedStruct(\"CreateOnly\", {}),\n  Schema.TaggedStruct(\"IfMatch\", { etag: ObjectValidator }),\n]);\n\nexport type WriteCondition = typeof WriteCondition.Type;\n\nexport const ReadCondition = Schema.Union([\n  Schema.TaggedStruct(\"IfMatch\", { etag: ObjectValidator }),\n  Schema.TaggedStruct(\"IfNoneMatch\", { etag: ObjectValidator }),\n]);\n\nexport type ReadCondition = typeof ReadCondition.Type;\n\nexport type UploadBody<E = never, R = never> = Uint8Array | Stream.Stream<Uint8Array, E, R>;\n\nexport const PutRequest = Schema.Struct({\n  ...ObjectHeaders.fields,\n  key: ObjectKey,\n  body: Schema.Unknown,\n  condition: Schema.optional(WriteCondition),\n  contentLength: Schema.optional(ObjectSize),\n  maxBytes: Schema.optional(ObjectSize),\n});\n\nexport type PutRequest<E = never, R = never> = Omit<typeof PutRequest.Type, \"body\"> & {\n  readonly body: UploadBody<E, R>;\n};\n\nconst Target = Schema.Union([Schema.Struct({ key: ObjectKey }), Schema.Struct({ ref: ObjectRef })]);\n\nexport type ObjectTarget = typeof Target.Type;\nexport const HeadRequest = Target;\nexport type HeadRequest = ObjectTarget;\n\nexport const GetRequest = Schema.Union([\n  Schema.Struct({\n    key: ObjectKey,\n    range: Schema.optional(ByteRange),\n    condition: Schema.optional(ReadCondition),\n  }),\n  Schema.Struct({\n    ref: ObjectRef,\n    range: Schema.optional(ByteRange),\n    condition: Schema.optional(ReadCondition),\n  }),\n]);\n\nexport type GetRequest = typeof GetRequest.Type;\n\nexport const DeleteRequest = Schema.Union([\n  Schema.Struct({\n    key: ObjectKey,\n    condition: Schema.optional(Schema.TaggedStruct(\"IfMatch\", { etag: ObjectValidator })),\n  }),\n  Schema.Struct({\n    ref: ObjectRef,\n    condition: Schema.optional(Schema.TaggedStruct(\"IfMatch\", { etag: ObjectValidator })),\n  }),\n]);\n\nexport type DeleteRequest = typeof DeleteRequest.Type;\n\nexport const ListRequest = Schema.Struct({\n  prefix: Schema.optional(Schema.String),\n  delimiter: Schema.optional(Schema.NonEmptyString),\n  limit: Schema.optional(Schema.Int.check(Schema.isGreaterThan(0))),\n  cursor: Schema.optional(Schema.NonEmptyString),\n});\n\nexport type ListRequest = typeof ListRequest.Type;\n\nexport interface ObjectDownload {\n  readonly _tag: \"Object\";\n  readonly metadata: ObjectMetadata;\n  readonly contentLength?: number | undefined;\n  readonly range?: ResolvedRange | undefined;\n  readonly body: Stream.Stream<Uint8Array, StorageError, Scope.Scope>;\n}\n\nexport interface NotModified {\n  readonly _tag: \"NotModified\";\n  readonly metadata: ObjectMetadata;\n}\n\nexport type GetResult = ObjectDownload | NotModified;\n\nexport type ListEntry =\n  | { readonly _tag: \"Object\"; readonly metadata: ObjectMetadata }\n  | { readonly _tag: \"CommonPrefix\"; readonly prefix: string };\n\nexport interface ListPage {\n  readonly entries: ReadonlyArray<ListEntry>;\n  readonly cursor?: string | undefined;\n}\n"],"mappings":";;;;;AASA,MAAa,iBAAiB,OAAO,MAAM,CACzC,OAAO,aAAa,cAAc,CAAC,CAAC,GACpC,OAAO,aAAa,WAAW,EAAE,MAAM,gBAAgB,CAAC,CAC1D,CAAC;AAID,MAAa,gBAAgB,OAAO,MAAM,CACxC,OAAO,aAAa,WAAW,EAAE,MAAM,gBAAgB,CAAC,GACxD,OAAO,aAAa,eAAe,EAAE,MAAM,gBAAgB,CAAC,CAC9D,CAAC;AAMD,MAAa,aAAa,OAAO,OAAO;CACtC,GAAG,cAAc;CACjB,KAAK;CACL,MAAM,OAAO;CACb,WAAW,OAAO,SAAS,cAAc;CACzC,eAAe,OAAO,SAAS,UAAU;CACzC,UAAU,OAAO,SAAS,UAAU;AACtC,CAAC;AAMD,MAAM,SAAS,OAAO,MAAM,CAAC,OAAO,OAAO,EAAE,KAAK,UAAU,CAAC,GAAG,OAAO,OAAO,EAAE,KAAK,UAAU,CAAC,CAAC,CAAC;AAGlG,MAAa,cAAc;AAG3B,MAAa,aAAa,OAAO,MAAM,CACrC,OAAO,OAAO;CACZ,KAAK;CACL,OAAO,OAAO,SAAS,SAAS;CAChC,WAAW,OAAO,SAAS,aAAa;AAC1C,CAAC,GACD,OAAO,OAAO;CACZ,KAAK;CACL,OAAO,OAAO,SAAS,SAAS;CAChC,WAAW,OAAO,SAAS,aAAa;AAC1C,CAAC,CACH,CAAC;AAID,MAAa,gBAAgB,OAAO,MAAM,CACxC,OAAO,OAAO;CACZ,KAAK;CACL,WAAW,OAAO,SAAS,OAAO,aAAa,WAAW,EAAE,MAAM,gBAAgB,CAAC,CAAC;AACtF,CAAC,GACD,OAAO,OAAO;CACZ,KAAK;CACL,WAAW,OAAO,SAAS,OAAO,aAAa,WAAW,EAAE,MAAM,gBAAgB,CAAC,CAAC;AACtF,CAAC,CACH,CAAC;AAID,MAAa,cAAc,OAAO,OAAO;CACvC,QAAQ,OAAO,SAAS,OAAO,MAAM;CACrC,WAAW,OAAO,SAAS,OAAO,cAAc;CAChD,OAAO,OAAO,SAAS,OAAO,IAAI,MAAM,OAAO,cAAc,CAAC,CAAC,CAAC;CAChE,QAAQ,OAAO,SAAS,OAAO,cAAc;AAC/C,CAAC"}

package/dist/core/storage.d.ts

@@ -0,0 +1,249 @@
+import { ObjectMetadata } from "./object.js";
+import { StorageError } from "./errors.js";
+import { DeleteRequest, GetRequest, GetResult, HeadRequest, ListEntry, ListPage, ListRequest, PutRequest } from "./requests.js";
+import { StorageCapabilities } from "./capabilities.js";
+import { Context, Effect, Scope, Stream } from "effect";
+export interface StorageService {
+  readonly provider: string;
+  readonly storeId: string;
+  readonly capabilities: StorageCapabilities;
+  readonly put: <E = never, R = never>(request: PutRequest<E, R>) => Effect.Effect<ObjectMetadata, StorageError | E, R>;
+  readonly get: (request: GetRequest) => Effect.Effect<GetResult, StorageError, Scope.Scope>;
+  readonly head: (request: HeadRequest) => Effect.Effect<ObjectMetadata, StorageError>;
+  readonly delete: (request: DeleteRequest) => Effect.Effect<void, StorageError>;
+  readonly listPage: (request?: ListRequest) => Effect.Effect<ListPage, StorageError>;
+}
+declare const Storage_base: Context.ServiceClass<Storage, "@effect-kit/storage/Storage", StorageService>;
+export declare class Storage extends Storage_base {
+  /** Guards request boundaries and ties returned bodies to their acquisition scope. */
+  static make(service: StorageService): StorageService;
+  static readonly exists: (request: {
+    readonly key: string;
+  } | {
+    readonly ref: {
+      readonly storeId: string;
+      readonly key: string;
+      readonly version?: {
+        readonly _tag: "S3Version";
+        readonly id: string;
+      } | {
+        readonly _tag: "GcsGeneration";
+        readonly id: string;
+        readonly metageneration?: string | undefined;
+      } | {
+        readonly _tag: "AzureVersion";
+        readonly id: string;
+      } | {
+        readonly _tag: "AzureSnapshot";
+        readonly id: string;
+      } | {
+        readonly _tag: "OpaqueVersion";
+        readonly provider: string;
+        readonly id: string;
+      } | undefined;
+    };
+  }) => Effect.Effect<boolean, StorageError, Storage>;
+  static readonly getBytes: (request: ({
+    readonly key: string;
+    readonly range?: {
+      readonly _tag: "Bounded";
+      readonly start: number;
+      readonly end: number;
+    } | {
+      readonly _tag: "From";
+      readonly start: number;
+    } | {
+      readonly _tag: "Suffix";
+      readonly length: number;
+    } | undefined;
+    readonly condition?: {
+      readonly _tag: "IfMatch";
+      readonly etag: string;
+    } | {
+      readonly _tag: "IfNoneMatch";
+      readonly etag: string;
+    } | undefined;
+  } | {
+    readonly ref: {
+      readonly storeId: string;
+      readonly key: string;
+      readonly version?: {
+        readonly _tag: "S3Version";
+        readonly id: string;
+      } | {
+        readonly _tag: "GcsGeneration";
+        readonly id: string;
+        readonly metageneration?: string | undefined;
+      } | {
+        readonly _tag: "AzureVersion";
+        readonly id: string;
+      } | {
+        readonly _tag: "AzureSnapshot";
+        readonly id: string;
+      } | {
+        readonly _tag: "OpaqueVersion";
+        readonly provider: string;
+        readonly id: string;
+      } | undefined;
+    };
+    readonly range?: {
+      readonly _tag: "Bounded";
+      readonly start: number;
+      readonly end: number;
+    } | {
+      readonly _tag: "From";
+      readonly start: number;
+    } | {
+      readonly _tag: "Suffix";
+      readonly length: number;
+    } | undefined;
+    readonly condition?: {
+      readonly _tag: "IfMatch";
+      readonly etag: string;
+    } | {
+      readonly _tag: "IfNoneMatch";
+      readonly etag: string;
+    } | undefined;
+  }) & {
+    readonly maxBytes: number;
+  }) => Effect.Effect<Uint8Array<ArrayBuffer>, StorageError, Storage>;
+  static readonly getText: (request: ({
+    readonly key: string;
+    readonly range?: {
+      readonly _tag: "Bounded";
+      readonly start: number;
+      readonly end: number;
+    } | {
+      readonly _tag: "From";
+      readonly start: number;
+    } | {
+      readonly _tag: "Suffix";
+      readonly length: number;
+    } | undefined;
+    readonly condition?: {
+      readonly _tag: "IfMatch";
+      readonly etag: string;
+    } | {
+      readonly _tag: "IfNoneMatch";
+      readonly etag: string;
+    } | undefined;
+  } | {
+    readonly ref: {
+      readonly storeId: string;
+      readonly key: string;
+      readonly version?: {
+        readonly _tag: "S3Version";
+        readonly id: string;
+      } | {
+        readonly _tag: "GcsGeneration";
+        readonly id: string;
+        readonly metageneration?: string | undefined;
+      } | {
+        readonly _tag: "AzureVersion";
+        readonly id: string;
+      } | {
+        readonly _tag: "AzureSnapshot";
+        readonly id: string;
+      } | {
+        readonly _tag: "OpaqueVersion";
+        readonly provider: string;
+        readonly id: string;
+      } | undefined;
+    };
+    readonly range?: {
+      readonly _tag: "Bounded";
+      readonly start: number;
+      readonly end: number;
+    } | {
+      readonly _tag: "From";
+      readonly start: number;
+    } | {
+      readonly _tag: "Suffix";
+      readonly length: number;
+    } | undefined;
+    readonly condition?: {
+      readonly _tag: "IfMatch";
+      readonly etag: string;
+    } | {
+      readonly _tag: "IfNoneMatch";
+      readonly etag: string;
+    } | undefined;
+  }) & {
+    readonly maxBytes: number;
+  }) => Effect.Effect<string, StorageError, Storage>;
+  static list(request?: ListRequest): Stream.Stream<ListEntry, StorageError, Storage>;
+  static readonly deleteMany: (requests: readonly ({
+    readonly key: string;
+    readonly condition?: {
+      readonly _tag: "IfMatch";
+      readonly etag: string;
+    } | undefined;
+  } | {
+    readonly ref: {
+      readonly storeId: string;
+      readonly key: string;
+      readonly version?: {
+        readonly _tag: "S3Version";
+        readonly id: string;
+      } | {
+        readonly _tag: "GcsGeneration";
+        readonly id: string;
+        readonly metageneration?: string | undefined;
+      } | {
+        readonly _tag: "AzureVersion";
+        readonly id: string;
+      } | {
+        readonly _tag: "AzureSnapshot";
+        readonly id: string;
+      } | {
+        readonly _tag: "OpaqueVersion";
+        readonly provider: string;
+        readonly id: string;
+      } | undefined;
+    };
+    readonly condition?: {
+      readonly _tag: "IfMatch";
+      readonly etag: string;
+    } | undefined;
+  })[], options?: {
+    readonly concurrency?: number;
+  } | undefined) => Effect.Effect<{
+    request: {
+      readonly key: string;
+      readonly condition?: {
+        readonly _tag: "IfMatch";
+        readonly etag: string;
+      } | undefined;
+    } | {
+      readonly ref: {
+        readonly storeId: string;
+        readonly key: string;
+        readonly version?: {
+          readonly _tag: "S3Version";
+          readonly id: string;
+        } | {
+          readonly _tag: "GcsGeneration";
+          readonly id: string;
+          readonly metageneration?: string | undefined;
+        } | {
+          readonly _tag: "AzureVersion";
+          readonly id: string;
+        } | {
+          readonly _tag: "AzureSnapshot";
+          readonly id: string;
+        } | {
+          readonly _tag: "OpaqueVersion";
+          readonly provider: string;
+          readonly id: string;
+        } | undefined;
+      };
+      readonly condition?: {
+        readonly _tag: "IfMatch";
+        readonly etag: string;
+      } | undefined;
+    };
+    result: import("effect/Result").Result<void, StorageError>;
+  }[], StorageError, Storage>;
+}
+export {};
+//# sourceMappingURL=storage.d.ts.map