@effect-kit/storage 0.0.0-stage → 0.0.0

package/dist/b2/admin.d.ts

@@ -0,0 +1,149 @@
+import { StorageError } from "../core/errors.js";
+import "../index.js";
+import { Context, Effect, Layer, Redacted } from "effect";
+import { HttpClient } from "effect/http";
+export interface B2AdminConfig {
+  readonly applicationKeyId: string;
+  readonly applicationKey: Redacted.Redacted<string>;
+  readonly accountEndpoint?: string;
+}
+declare const B2Administration_base: Context.ServiceClass<B2Administration, "@effect-kit/storage/b2/B2Administration", {
+  listBuckets: () => Effect.Effect<{
+    readonly [x: string]: unknown;
+  }, StorageError, never>;
+  create: (input: {
+    readonly name: string;
+  }) => Effect.Effect<{
+    readonly [x: string]: unknown;
+  }, StorageError, never>;
+  deleteEmpty: (input: {
+    readonly bucketId: string;
+  }) => Effect.Effect<{
+    readonly [x: string]: unknown;
+  }, StorageError, never>;
+  updateBucket: (input: {
+    readonly bucketId: string;
+    readonly expectedRevision: number;
+    readonly configuration: Readonly<Record<string, unknown>>;
+    readonly intent: "change-storage-protection";
+  }) => Effect.Effect<{
+    readonly [x: string]: unknown;
+  }, StorageError, never>;
+  listFileVersions: (input: {
+    readonly bucketId: string;
+    readonly prefix?: string;
+    readonly startFileName?: string;
+    readonly startFileId?: string;
+    readonly limit?: number;
+  }) => Effect.Effect<{
+    readonly [x: string]: unknown;
+  }, StorageError, never>;
+  hideFile: (input: {
+    readonly bucketId: string;
+    readonly fileName: string;
+  }) => Effect.Effect<{
+    readonly [x: string]: unknown;
+  }, StorageError, never>;
+  deleteFileVersion: (input: {
+    readonly fileId: string;
+    readonly fileName: string;
+  } & {
+    readonly intent: "delete-exact-file-version";
+    readonly bypassGovernance?: {
+      readonly intent: "bypass-governance";
+      readonly reason: string;
+    };
+  }) => Effect.Effect<{
+    readonly [x: string]: unknown;
+  }, StorageError, never>;
+  restoreVersion: (input: {
+    readonly sourceFileId: string;
+    readonly destinationBucketId: string;
+    readonly fileName: string;
+    readonly intent: "create-new-file-version";
+  }) => Effect.Effect<{
+    readonly [x: string]: unknown;
+  }, StorageError, never>;
+  setLegalHold: (input: {
+    readonly fileId: string;
+    readonly fileName: string;
+  } & {
+    readonly status: "on" | "off";
+    readonly releaseIntent?: "release-object-hold";
+  }) => Effect.Effect<{
+    readonly [x: string]: unknown;
+  }, StorageError, never>;
+}>;
+export declare class B2Administration extends B2Administration_base {
+  static readonly make: (settings: B2AdminConfig) => Effect.Effect<{
+    listBuckets: () => Effect.Effect<{
+      readonly [x: string]: unknown;
+    }, StorageError, never>;
+    create: (input: {
+      readonly name: string;
+    }) => Effect.Effect<{
+      readonly [x: string]: unknown;
+    }, StorageError, never>;
+    deleteEmpty: (input: {
+      readonly bucketId: string;
+    }) => Effect.Effect<{
+      readonly [x: string]: unknown;
+    }, StorageError, never>;
+    updateBucket: (input: {
+      readonly bucketId: string;
+      readonly expectedRevision: number;
+      readonly configuration: Readonly<Record<string, unknown>>;
+      readonly intent: "change-storage-protection";
+    }) => Effect.Effect<{
+      readonly [x: string]: unknown;
+    }, StorageError, never>;
+    listFileVersions: (input: {
+      readonly bucketId: string;
+      readonly prefix?: string;
+      readonly startFileName?: string;
+      readonly startFileId?: string;
+      readonly limit?: number;
+    }) => Effect.Effect<{
+      readonly [x: string]: unknown;
+    }, StorageError, never>;
+    hideFile: (input: {
+      readonly bucketId: string;
+      readonly fileName: string;
+    }) => Effect.Effect<{
+      readonly [x: string]: unknown;
+    }, StorageError, never>;
+    deleteFileVersion: (input: {
+      readonly fileId: string;
+      readonly fileName: string;
+    } & {
+      readonly intent: "delete-exact-file-version";
+      readonly bypassGovernance?: {
+        readonly intent: "bypass-governance";
+        readonly reason: string;
+      };
+    }) => Effect.Effect<{
+      readonly [x: string]: unknown;
+    }, StorageError, never>;
+    restoreVersion: (input: {
+      readonly sourceFileId: string;
+      readonly destinationBucketId: string;
+      readonly fileName: string;
+      readonly intent: "create-new-file-version";
+    }) => Effect.Effect<{
+      readonly [x: string]: unknown;
+    }, StorageError, never>;
+    setLegalHold: (input: {
+      readonly fileId: string;
+      readonly fileName: string;
+    } & {
+      readonly status: "on" | "off";
+      readonly releaseIntent?: "release-object-hold";
+    }) => Effect.Effect<{
+      readonly [x: string]: unknown;
+    }, StorageError, never>;
+  }, StorageError, HttpClient.HttpClient>;
+  static layerHttp(config: B2AdminConfig): Layer.Layer<B2Administration, StorageError, HttpClient.HttpClient>;
+  static layer(config: B2AdminConfig): Layer.Layer<B2Administration, StorageError, never>;
+}
+export {};
+//# sourceMappingURL=admin.d.ts.map

package/dist/b2/admin.js

@@ -0,0 +1,157 @@
+import { storageError } from "../core/errors.js";
+import { decodeRequest } from "../internal/request-validation.js";
+import { decodeResponse } from "../internal/provider-response.js";
+import { controlEndpoint, controlRequest } from "../internal/http/control-plane.js";
+import { Context, Effect, Layer, Redacted, Schema } from "effect";
+import { FetchHttpClient, HttpClient } from "effect/http";
+
+// src/providers/b2/admin.ts
+const Native = Schema.Record(Schema.String, Schema.Unknown);
+const File = Schema.Struct({
+	fileId: Schema.NonEmptyString,
+	fileName: Schema.NonEmptyString
+});
+const make = Effect.fnUntraced(function* (settings) {
+	const config = yield* decodeRequest(Schema.Struct({
+		applicationKeyId: Schema.NonEmptyString,
+		applicationKey: Schema.Redacted(Schema.NonEmptyString),
+		accountEndpoint: Schema.optional(Schema.String)
+	}), settings, "makeAdministration", "b2");
+	const endpoint = yield* controlEndpoint(config.accountEndpoint ?? "https://api.backblazeb2.com", "b2");
+	const http = yield* HttpClient.HttpClient;
+	const call = Effect.fnUntraced(function* (operation, method, body) {
+		const auth = yield* controlRequest(http, "b2", "authorizeAccount", `${endpoint}/b2api/v4/b2_authorize_account`, "GET", { authorization: `Basic ${Buffer.from(`${config.applicationKeyId}:${Redacted.value(config.applicationKey)}`).toString("base64")}` });
+		const identity = yield* decodeResponse(Schema.Struct({
+			accountId: Schema.NonEmptyString,
+			authorizationToken: Schema.NonEmptyString,
+			apiInfo: Schema.Struct({ storageApi: Schema.Struct({ apiUrl: Schema.String }) })
+		}), auth, "authorizeAccount", "b2");
+		const api = yield* controlEndpoint(identity.apiInfo.storageApi.apiUrl, "b2");
+		if (api !== endpoint && !new URL(api).hostname.endsWith(".backblazeb2.com")) return yield* storageError(operation, "b2", {
+			_tag: "ProviderFailure",
+			code: "UntrustedApiOrigin"
+		}, "not-started");
+		const result = yield* controlRequest(http, "b2", operation, `${api}/b2api/v4/${method}`, "POST", { authorization: identity.authorizationToken }, {
+			accountId: identity.accountId,
+			...body
+		});
+		return yield* decodeRequest(Native, result, operation, "b2");
+	});
+	return {
+		listBuckets: () => call("listBuckets", "b2_list_buckets", {}),
+		create: Effect.fnUntraced(function* (input) {
+			const value = yield* decodeRequest(Schema.Struct({ name: Schema.String.check(Schema.isPattern(/^[A-Za-z0-9-]{6,63}$/u)) }), input, "createBucket", "b2", true);
+			return yield* call("createBucket", "b2_create_bucket", {
+				bucketName: value.name,
+				bucketType: "allPrivate"
+			});
+		}),
+		deleteEmpty: Effect.fnUntraced(function* (input) {
+			const value = yield* decodeRequest(Schema.Struct({ bucketId: Schema.NonEmptyString }), input, "deleteBucket", "b2", true);
+			return yield* call("deleteBucket", "b2_delete_bucket", value);
+		}),
+		updateBucket: Effect.fnUntraced(function* (input) {
+			const value = yield* decodeRequest(Schema.Struct({
+				bucketId: Schema.NonEmptyString,
+				expectedRevision: Schema.Natural,
+				configuration: Schema.Struct({
+					bucketType: Schema.optional(Schema.Literals(["allPublic", "allPrivate"])),
+					lifecycleRules: Schema.optional(Schema.Array(Native)),
+					defaultServerSideEncryption: Schema.optional(Native),
+					defaultRetention: Schema.optional(Native),
+					replicationConfiguration: Schema.optional(Native),
+					corsRules: Schema.optional(Schema.Array(Native))
+				}),
+				intent: Schema.Literal("change-storage-protection")
+			}), input, "updateBucket", "b2", true);
+			return yield* call("updateBucket", "b2_update_bucket", {
+				bucketId: value.bucketId,
+				ifRevisionIs: value.expectedRevision,
+				...value.configuration
+			});
+		}),
+		listFileVersions: Effect.fnUntraced(function* (input) {
+			const value = yield* decodeRequest(Schema.Struct({
+				bucketId: Schema.NonEmptyString,
+				prefix: Schema.optional(Schema.String),
+				startFileName: Schema.optional(Schema.String),
+				startFileId: Schema.optional(Schema.String),
+				limit: Schema.optional(Schema.Int.check(Schema.isBetween({
+					minimum: 1,
+					maximum: 1e3
+				})))
+			}), input, "listFileVersions", "b2");
+			return yield* call("listFileVersions", "b2_list_file_versions", {
+				bucketId: value.bucketId,
+				prefix: value.prefix,
+				startFileName: value.startFileName,
+				startFileId: value.startFileId,
+				maxFileCount: value.limit ?? 1e3
+			});
+		}),
+		hideFile: Effect.fnUntraced(function* (input) {
+			const value = yield* decodeRequest(Schema.Struct({
+				bucketId: Schema.NonEmptyString,
+				fileName: Schema.NonEmptyString
+			}), input, "hideFile", "b2", true);
+			return yield* call("hideFile", "b2_hide_file", value);
+		}),
+		deleteFileVersion: Effect.fnUntraced(function* (input) {
+			const value = yield* decodeRequest(Schema.Struct({
+				...File.fields,
+				intent: Schema.Literal("delete-exact-file-version"),
+				bypassGovernance: Schema.optional(Schema.Struct({
+					intent: Schema.Literal("bypass-governance"),
+					reason: Schema.NonEmptyString
+				}))
+			}), input, "deleteFileVersion", "b2", true);
+			return yield* call("deleteFileVersion", "b2_delete_file_version", {
+				fileId: value.fileId,
+				fileName: value.fileName,
+				...value.bypassGovernance ? { bypassGovernance: true } : {}
+			});
+		}),
+		restoreVersion: Effect.fnUntraced(function* (input) {
+			const value = yield* decodeRequest(Schema.Struct({
+				sourceFileId: Schema.NonEmptyString,
+				destinationBucketId: Schema.NonEmptyString,
+				fileName: Schema.NonEmptyString,
+				intent: Schema.Literal("create-new-file-version")
+			}), input, "restoreVersion", "b2", true);
+			return yield* call("restoreVersion", "b2_copy_file", {
+				sourceFileId: value.sourceFileId,
+				destinationBucketId: value.destinationBucketId,
+				fileName: value.fileName,
+				metadataDirective: "COPY"
+			});
+		}),
+		setLegalHold: Effect.fnUntraced(function* (input) {
+			const value = yield* decodeRequest(Schema.Struct({
+				...File.fields,
+				status: Schema.Literals(["on", "off"]),
+				releaseIntent: Schema.optional(Schema.Literal("release-object-hold"))
+			}), input, "setLegalHold", "b2", true);
+			if (value.status === "off" && !value.releaseIntent) return yield* storageError("setLegalHold", "b2", {
+				_tag: "InvalidInput",
+				field: "releaseIntent"
+			}, "not-started");
+			return yield* call("setLegalHold", "b2_update_file_legal_hold", {
+				fileName: value.fileName,
+				fileId: value.fileId,
+				legalHold: value.status
+			});
+		})
+	};
+});
+var B2Administration = class B2Administration extends Context.Service()("@effect-kit/storage/b2/B2Administration") {
+	static make = make;
+	static layerHttp(config) {
+		return Layer.effect(B2Administration, make(config));
+	}
+	static layer(config) {
+		return B2Administration.layerHttp(config).pipe(Layer.provide(FetchHttpClient.layer));
+	}
+};
+
+export { B2Administration };
+//# sourceMappingURL=admin.js.map

package/dist/b2/admin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin.js","names":[],"sources":["../../src/providers/b2/admin.ts"],"sourcesContent":["import { Context, Effect, Layer, Redacted, Schema } from \"effect\";\nimport { FetchHttpClient, HttpClient } from \"effect/http\";\n\nimport { storageError } from \"../../core/errors.js\";\nimport { controlEndpoint, controlRequest } from \"../../internal/http/control-plane.js\";\nimport { decodeResponse } from \"../../internal/provider-response.js\";\nimport { decodeRequest } from \"../../internal/request-validation.js\";\n\nexport interface B2AdminConfig {\n  readonly applicationKeyId: string;\n  readonly applicationKey: Redacted.Redacted<string>;\n  readonly accountEndpoint?: string;\n}\nconst Native = Schema.Record(Schema.String, Schema.Unknown);\nconst File = Schema.Struct({ fileId: Schema.NonEmptyString, fileName: Schema.NonEmptyString });\nconst make = Effect.fnUntraced(function* (settings: B2AdminConfig) {\n  const config = yield* decodeRequest(\n    Schema.Struct({\n      applicationKeyId: Schema.NonEmptyString,\n      applicationKey: Schema.Redacted(Schema.NonEmptyString),\n      accountEndpoint: Schema.optional(Schema.String),\n    }),\n    settings,\n    \"makeAdministration\",\n    \"b2\",\n  );\n  const endpoint = yield* controlEndpoint(\n    config.accountEndpoint ?? \"https://api.backblazeb2.com\",\n    \"b2\",\n  );\n  const http = yield* HttpClient.HttpClient;\n  const call = Effect.fnUntraced(function* (\n    operation: string,\n    method: string,\n    body: Readonly<Record<string, unknown>>,\n  ) {\n    const auth = yield* controlRequest(\n      http,\n      \"b2\",\n      \"authorizeAccount\",\n      `${endpoint}/b2api/v4/b2_authorize_account`,\n      \"GET\",\n      {\n        authorization: `Basic ${Buffer.from(`${config.applicationKeyId}:${Redacted.value(config.applicationKey)}`).toString(\"base64\")}`,\n      },\n    );\n    const identity = yield* decodeResponse(\n      Schema.Struct({\n        accountId: Schema.NonEmptyString,\n        authorizationToken: Schema.NonEmptyString,\n        apiInfo: Schema.Struct({ storageApi: Schema.Struct({ apiUrl: Schema.String }) }),\n      }),\n      auth,\n      \"authorizeAccount\",\n      \"b2\",\n    );\n    const api = yield* controlEndpoint(identity.apiInfo.storageApi.apiUrl, \"b2\");\n    if (api !== endpoint && !new URL(api).hostname.endsWith(\".backblazeb2.com\"))\n      return yield* storageError(\n        operation,\n        \"b2\",\n        { _tag: \"ProviderFailure\", code: \"UntrustedApiOrigin\" },\n        \"not-started\",\n      );\n    const result = yield* controlRequest(\n      http,\n      \"b2\",\n      operation,\n      `${api}/b2api/v4/${method}`,\n      \"POST\",\n      { authorization: identity.authorizationToken },\n      { accountId: identity.accountId, ...body },\n    );\n    return yield* decodeRequest(Native, result, operation, \"b2\");\n  });\n  return {\n    listBuckets: () => call(\"listBuckets\", \"b2_list_buckets\", {}),\n    create: Effect.fnUntraced(function* (input: { readonly name: string }) {\n      const value = yield* decodeRequest(\n        Schema.Struct({ name: Schema.String.check(Schema.isPattern(/^[A-Za-z0-9-]{6,63}$/u)) }),\n        input,\n        \"createBucket\",\n        \"b2\",\n        true,\n      );\n      return yield* call(\"createBucket\", \"b2_create_bucket\", {\n        bucketName: value.name,\n        bucketType: \"allPrivate\",\n      });\n    }),\n    deleteEmpty: Effect.fnUntraced(function* (input: { readonly bucketId: string }) {\n      const value = yield* decodeRequest(\n        Schema.Struct({ bucketId: Schema.NonEmptyString }),\n        input,\n        \"deleteBucket\",\n        \"b2\",\n        true,\n      );\n      return yield* call(\"deleteBucket\", \"b2_delete_bucket\", value);\n    }),\n    updateBucket: Effect.fnUntraced(function* (input: {\n      readonly bucketId: string;\n      readonly expectedRevision: number;\n      readonly configuration: Readonly<Record<string, unknown>>;\n      readonly intent: \"change-storage-protection\";\n    }) {\n      const value = yield* decodeRequest(\n        Schema.Struct({\n          bucketId: Schema.NonEmptyString,\n          expectedRevision: Schema.Natural,\n          configuration: Schema.Struct({\n            bucketType: Schema.optional(Schema.Literals([\"allPublic\", \"allPrivate\"])),\n            lifecycleRules: Schema.optional(Schema.Array(Native)),\n            defaultServerSideEncryption: Schema.optional(Native),\n            defaultRetention: Schema.optional(Native),\n            replicationConfiguration: Schema.optional(Native),\n            corsRules: Schema.optional(Schema.Array(Native)),\n          }),\n          intent: Schema.Literal(\"change-storage-protection\"),\n        }),\n        input,\n        \"updateBucket\",\n        \"b2\",\n        true,\n      );\n      return yield* call(\"updateBucket\", \"b2_update_bucket\", {\n        bucketId: value.bucketId,\n        ifRevisionIs: value.expectedRevision,\n        ...value.configuration,\n      });\n    }),\n    listFileVersions: Effect.fnUntraced(function* (input: {\n      readonly bucketId: string;\n      readonly prefix?: string;\n      readonly startFileName?: string;\n      readonly startFileId?: string;\n      readonly limit?: number;\n    }) {\n      const value = yield* decodeRequest(\n        Schema.Struct({\n          bucketId: Schema.NonEmptyString,\n          prefix: Schema.optional(Schema.String),\n          startFileName: Schema.optional(Schema.String),\n          startFileId: Schema.optional(Schema.String),\n          limit: Schema.optional(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 1000 }))),\n        }),\n        input,\n        \"listFileVersions\",\n        \"b2\",\n      );\n      return yield* call(\"listFileVersions\", \"b2_list_file_versions\", {\n        bucketId: value.bucketId,\n        prefix: value.prefix,\n        startFileName: value.startFileName,\n        startFileId: value.startFileId,\n        maxFileCount: value.limit ?? 1000,\n      });\n    }),\n    hideFile: Effect.fnUntraced(function* (input: {\n      readonly bucketId: string;\n      readonly fileName: string;\n    }) {\n      const value = yield* decodeRequest(\n        Schema.Struct({ bucketId: Schema.NonEmptyString, fileName: Schema.NonEmptyString }),\n        input,\n        \"hideFile\",\n        \"b2\",\n        true,\n      );\n      return yield* call(\"hideFile\", \"b2_hide_file\", value);\n    }),\n    deleteFileVersion: Effect.fnUntraced(function* (\n      input: typeof File.Type & {\n        readonly intent: \"delete-exact-file-version\";\n        readonly bypassGovernance?: {\n          readonly intent: \"bypass-governance\";\n          readonly reason: string;\n        };\n      },\n    ) {\n      const value = yield* decodeRequest(\n        Schema.Struct({\n          ...File.fields,\n          intent: Schema.Literal(\"delete-exact-file-version\"),\n          bypassGovernance: Schema.optional(\n            Schema.Struct({\n              intent: Schema.Literal(\"bypass-governance\"),\n              reason: Schema.NonEmptyString,\n            }),\n          ),\n        }),\n        input,\n        \"deleteFileVersion\",\n        \"b2\",\n        true,\n      );\n      return yield* call(\"deleteFileVersion\", \"b2_delete_file_version\", {\n        fileId: value.fileId,\n        fileName: value.fileName,\n        ...(value.bypassGovernance ? { bypassGovernance: true } : {}),\n      });\n    }),\n    restoreVersion: Effect.fnUntraced(function* (input: {\n      readonly sourceFileId: string;\n      readonly destinationBucketId: string;\n      readonly fileName: string;\n      readonly intent: \"create-new-file-version\";\n    }) {\n      const value = yield* decodeRequest(\n        Schema.Struct({\n          sourceFileId: Schema.NonEmptyString,\n          destinationBucketId: Schema.NonEmptyString,\n          fileName: Schema.NonEmptyString,\n          intent: Schema.Literal(\"create-new-file-version\"),\n        }),\n        input,\n        \"restoreVersion\",\n        \"b2\",\n        true,\n      );\n      return yield* call(\"restoreVersion\", \"b2_copy_file\", {\n        sourceFileId: value.sourceFileId,\n        destinationBucketId: value.destinationBucketId,\n        fileName: value.fileName,\n        metadataDirective: \"COPY\",\n      });\n    }),\n    setLegalHold: Effect.fnUntraced(function* (\n      input: typeof File.Type & {\n        readonly status: \"on\" | \"off\";\n        readonly releaseIntent?: \"release-object-hold\";\n      },\n    ) {\n      const value = yield* decodeRequest(\n        Schema.Struct({\n          ...File.fields,\n          status: Schema.Literals([\"on\", \"off\"]),\n          releaseIntent: Schema.optional(Schema.Literal(\"release-object-hold\")),\n        }),\n        input,\n        \"setLegalHold\",\n        \"b2\",\n        true,\n      );\n      if (value.status === \"off\" && !value.releaseIntent)\n        return yield* storageError(\n          \"setLegalHold\",\n          \"b2\",\n          { _tag: \"InvalidInput\", field: \"releaseIntent\" },\n          \"not-started\",\n        );\n      return yield* call(\"setLegalHold\", \"b2_update_file_legal_hold\", {\n        fileName: value.fileName,\n        fileId: value.fileId,\n        legalHold: value.status,\n      });\n    }),\n  };\n});\nexport class B2Administration extends Context.Service<\n  B2Administration,\n  Effect.Success<ReturnType<typeof make>>\n>()(\"@effect-kit/storage/b2/B2Administration\") {\n  static readonly make = make;\n  static layerHttp(config: B2AdminConfig) {\n    return Layer.effect(B2Administration, make(config));\n  }\n  static layer(config: B2AdminConfig) {\n    return B2Administration.layerHttp(config).pipe(Layer.provide(FetchHttpClient.layer));\n  }\n}\n"],"mappings":"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"}

package/dist/b2.d.ts

@@ -0,0 +1,15 @@
+import { StorageError } from "./core/errors.js";
+import { StorageCopy } from "./core/capabilities.js";
+import { Storage } from "./core/storage.js";
+import "./index.js";
+import { TransferDriver } from "./transfers/dependencies.js";
+import { S3Storage, S3StorageService } from "./s3.js";
+import { RegionalConfig } from "./providers/s3-compatible/config.js";
+import { Context } from "effect";
+declare const B2Storage_base: Context.ServiceClass<B2Storage, "@effect-kit/storage/b2/B2Storage", S3StorageService>;
+export declare class B2Storage extends B2Storage_base {
+  static make(config: RegionalConfig): import("effect/Effect").Effect<S3StorageService, StorageError, import("effect/Scope").Scope>;
+  static layer(config: RegionalConfig): import("effect/Layer").Layer<B2Storage | S3Storage | Storage | StorageCopy | TransferDriver, StorageError, never>;
+}
+export type { RegionalConfig as B2Config };
+//# sourceMappingURL=b2.d.ts.map

package/dist/b2.js

@@ -0,0 +1,15 @@
+import { compatibleLayer, makeCompatible } from "./providers/s3-compatible/service.js";
+import { Context } from "effect";
+
+// src/providers/b2/index.ts
+var B2Storage = class B2Storage extends Context.Service()("@effect-kit/storage/b2/B2Storage") {
+	static make(config) {
+		return makeCompatible("b2", config);
+	}
+	static layer(config) {
+		return compatibleLayer(B2Storage, B2Storage.make(config));
+	}
+};
+
+export { B2Storage };
+//# sourceMappingURL=b2.js.map

package/dist/b2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"b2.js","names":[],"sources":["../src/providers/b2/index.ts"],"sourcesContent":["import { Context } from \"effect\";\n\nimport type { RegionalConfig } from \"../s3-compatible/config.js\";\nimport { compatibleLayer, makeCompatible } from \"../s3-compatible/service.js\";\nimport type { S3StorageService } from \"../s3/index.js\";\n\nexport type { RegionalConfig as B2Config } from \"../s3-compatible/config.js\";\n\nexport class B2Storage extends Context.Service<B2Storage, S3StorageService>()(\n  \"@effect-kit/storage/b2/B2Storage\",\n) {\n  static make(config: RegionalConfig) {\n    return makeCompatible(\"b2\", config);\n  }\n  static layer(config: RegionalConfig) {\n    return compatibleLayer(B2Storage, B2Storage.make(config));\n  }\n}\n"],"mappings":";;;;AAQA,IAAa,YAAb,MAAa,kBAAkB,QAAQ,QAAqC,CAAC,CAC3E,kCACF,CAAC,CAAC;CACA,OAAO,KAAK,QAAwB;EAClC,OAAO,eAAe,MAAM,MAAM;CACpC;CACA,OAAO,MAAM,QAAwB;EACnC,OAAO,gBAAgB,WAAW,UAAU,KAAK,MAAM,CAAC;CAC1D;AACF"}

package/dist/browser.d.ts

@@ -0,0 +1,7 @@
+import { TransferHash } from "./transfers/dependencies.js";
+import { sha256 } from "./runtime/portable-hash.js";
+import { aes256Gcm } from "./runtime/web-protection.js";
+import { Layer } from "effect";
+export declare const layer: Layer.Layer<import("effect/crypto/Aead").Aead | import("effect/crypto/Digest").Digest | import("effect/crypto/SecureRandom").SecureRandom | TransferHash, never, never>;
+export { aes256Gcm, sha256 };
+//# sourceMappingURL=browser.d.ts.map

package/dist/browser.js

@@ -0,0 +1,11 @@
+import { sha256 } from "./runtime/portable-hash.js";
+import { TransferHash } from "./transfers/dependencies.js";
+import { aes256Gcm } from "./runtime/web-protection.js";
+import { Layer } from "effect";
+import * as BrowserCrypto from "@effect/platform-browser/BrowserCrypto";
+
+// src/runtime/browser.ts
+const layer = Layer.mergeAll(BrowserCrypto.layerSecureRandom, BrowserCrypto.layerDigest, BrowserCrypto.layerAead, Layer.succeed(TransferHash, sha256));
+
+export { aes256Gcm, layer, sha256 };
+//# sourceMappingURL=browser.js.map

package/dist/browser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.js","names":[],"sources":["../src/runtime/browser.ts"],"sourcesContent":["import * as BrowserCrypto from \"@effect/platform-browser/BrowserCrypto\";\nimport { Layer } from \"effect\";\n\nimport { TransferHash } from \"../transfers/dependencies.js\";\nimport { sha256 } from \"./portable-hash.js\";\n\nexport { sha256 };\nexport { aes256Gcm } from \"./web-protection.js\";\nexport const layer = Layer.mergeAll(\n  BrowserCrypto.layerSecureRandom,\n  BrowserCrypto.layerDigest,\n  BrowserCrypto.layerAead,\n  Layer.succeed(TransferHash, sha256),\n);\n"],"mappings":";;;;;;;AAQA,MAAa,QAAQ,MAAM,SACzB,cAAc,mBACd,cAAc,aACd,cAAc,WACd,MAAM,QAAQ,cAAc,MAAM,CACpC"}

package/dist/bun.d.ts

@@ -0,0 +1,14 @@
+import { StorageError } from "./core/errors.js";
+import "./index.js";
+import { TransferHash } from "./transfers/dependencies.js";
+import { UploadSessionStore } from "./sessions/store.js";
+import { sha256 } from "./runtime/node-hash.js";
+import { aes256Gcm } from "./runtime/node-protection.js";
+import { FileSessionStoreOptions } from "./runtime/session-store.js";
+import { atomicFileStore } from "./runtime/filesystem.js";
+import { fileDownloadTarget } from "./runtime/file-target.js";
+import { Layer } from "effect";
+export declare const layer: Layer.Layer<import("effect/crypto/Digest").Digest | import("effect/FileSystem").FileSystem | import("effect/Path").Path | import("effect/crypto/SecureRandom").SecureRandom | TransferHash, never, never>;
+export declare const sessionStore: (options: FileSessionStoreOptions) => Layer.Layer<UploadSessionStore, import("effect/persistence/KeyValueStore").KeyValueStoreError | StorageError, import("effect/crypto/Digest").Digest | import("effect/FileSystem").FileSystem | import("effect/Path").Path | import("effect/crypto/SecureRandom").SecureRandom>;
+export { type FileSessionStoreOptions, aes256Gcm, atomicFileStore, fileDownloadTarget, sha256 };
+//# sourceMappingURL=bun.d.ts.map

package/dist/bun.js

@@ -0,0 +1,17 @@
+import { TransferHash } from "./transfers/dependencies.js";
+import { sha256 } from "./runtime/node-hash.js";
+import { aes256Gcm } from "./runtime/node-protection.js";
+import { atomicFileStore } from "./runtime/filesystem.js";
+import { fileSessionStore } from "./runtime/session-store.js";
+import { fileDownloadTarget } from "./runtime/file-target.js";
+import { layer as layer$1 } from "./runtime/bun-filesystem.js";
+import { Effect, Layer } from "effect";
+import * as BunCrypto from "@effect/platform-bun/BunCrypto";
+import * as BunPath from "@effect/platform-bun/BunPath";
+
+// src/runtime/bun.ts
+const layer = Layer.mergeAll(layer$1, BunPath.layer, BunCrypto.layerSecureRandom, BunCrypto.layerDigest, Layer.succeed(TransferHash, sha256));
+const sessionStore = (options) => fileSessionStore(options, Effect.sync(() => aes256Gcm(options.key)));
+
+export { aes256Gcm, atomicFileStore, fileDownloadTarget, layer, sessionStore, sha256 };
+//# sourceMappingURL=bun.js.map

package/dist/bun.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bun.js","names":["BunFileSystem.layer"],"sources":["../src/runtime/bun.ts"],"sourcesContent":["import * as BunCrypto from \"@effect/platform-bun/BunCrypto\";\nimport * as BunPath from \"@effect/platform-bun/BunPath\";\nimport { Effect, Layer } from \"effect\";\n\nimport { TransferHash } from \"../transfers/dependencies.js\";\nimport * as BunFileSystem from \"./bun-filesystem.js\";\nimport { sha256 } from \"./node-hash.js\";\nimport { aes256Gcm } from \"./node-protection.js\";\nimport { fileSessionStore } from \"./session-store.js\";\nimport type { FileSessionStoreOptions } from \"./session-store.js\";\n\nexport { sha256, aes256Gcm };\nexport { atomicFileStore } from \"./filesystem.js\";\nexport { fileDownloadTarget } from \"./file-target.js\";\nexport type { FileSessionStoreOptions } from \"./session-store.js\";\n\nexport const layer = Layer.mergeAll(\n  BunFileSystem.layer,\n  BunPath.layer,\n  BunCrypto.layerSecureRandom,\n  BunCrypto.layerDigest,\n  Layer.succeed(TransferHash, sha256),\n);\nexport const sessionStore = (options: FileSessionStoreOptions) =>\n  fileSessionStore(\n    options,\n    Effect.sync(() => aes256Gcm(options.key)),\n  );\n"],"mappings":";;;;;;;;;;;;AAgBA,MAAa,QAAQ,MAAM,SACzBA,SACA,QAAQ,OACR,UAAU,mBACV,UAAU,aACV,MAAM,QAAQ,cAAc,MAAM,CACpC;AACA,MAAa,gBAAgB,YAC3B,iBACE,SACA,OAAO,WAAW,UAAU,QAAQ,GAAG,CAAC,CAC1C"}

package/dist/cache.d.ts

@@ -0,0 +1,18 @@
+import { StorageError } from "./core/errors.js";
+import { Storage, StorageService } from "./core/storage.js";
+import "./index.js";
+import { TransferDriver } from "./transfers/dependencies.js";
+import { Duration, Effect } from "effect";
+export interface StorageCacheOptions {
+  readonly capacity: number;
+  readonly timeToLive: Duration.Input;
+  readonly objects?: {
+    readonly capacity: number;
+    readonly maxObjectBytes: number;
+  };
+}
+export declare const StorageCache: {
+  make: (options: StorageCacheOptions) => Effect.Effect<StorageService, StorageError, Storage>;
+  layer(options: StorageCacheOptions): import("effect/Layer").Layer<Storage | TransferDriver, StorageError, Storage | TransferDriver>;
+};
+//# sourceMappingURL=cache.d.ts.map

package/dist/cache.js

@@ -0,0 +1,116 @@
+import { storageError } from "./core/errors.js";
+import { Storage } from "./core/storage.js";
+import { storageLayer } from "./composition/layer.js";
+import { Cache, Data, Duration, Effect, Exit, Semaphore, Stream } from "effect";
+
+// src/composition/cache.ts
+var MetadataKey = class extends Data.Class {};
+var ObjectKey = class extends Data.Class {};
+const clone = (value) => ({
+	...value,
+	ref: {
+		...value.ref,
+		...value.ref.version ? { version: { ...value.ref.version } } : {}
+	},
+	...value.customMetadata ? { customMetadata: { ...value.customMetadata } } : {},
+	...value.checksums ? { checksums: value.checksums.map((checksum) => ({ ...checksum })) } : {}
+});
+const StorageCache = {
+	make: Effect.fnUntraced(function* (options) {
+		if (!Number.isSafeInteger(options.capacity) || options.capacity < 1 || options.objects && (!Number.isSafeInteger(options.objects.capacity) || options.objects.capacity < 1 || !Number.isSafeInteger(options.objects.maxObjectBytes) || options.objects.maxObjectBytes < 1)) return yield* storageError("cache", "composition", {
+			_tag: "InvalidConfiguration",
+			field: "capacity"
+		});
+		const ttl = yield* Effect.try({
+			try: () => Duration.fromInputUnsafe(options.timeToLive),
+			catch: () => storageError("cache", "composition", {
+				_tag: "InvalidConfiguration",
+				field: "timeToLive"
+			})
+		});
+		const source = yield* Storage;
+		let epoch = 0;
+		const metadata = yield* Cache.makeWith((key) => source.head(JSON.parse(key.target)), {
+			capacity: options.capacity,
+			timeToLive: (exit) => Exit.isSuccess(exit) ? ttl : 0
+		});
+		const objects = options.objects;
+		const fills = yield* Semaphore.make(1);
+		const bytes = objects ? yield* Cache.makeWith((key) => fills.withPermit(Effect.scoped(Effect.gen(function* () {
+			const result = yield* source.get(JSON.parse(key.target));
+			if (result._tag !== "Object" || result.metadata.size === void 0 || result.metadata.size > objects.maxObjectBytes) return yield* storageError("cache", source.provider, {
+				_tag: "Unsupported",
+				capability: "cache-fill"
+			});
+			let size = 0;
+			const joined = new Uint8Array(result.metadata.size);
+			yield* Stream.runForEach(result.body, (chunk) => Effect.suspend(() => {
+				if (chunk.length > joined.length - size) return Effect.fail(storageError("cache", source.provider, {
+					_tag: "LimitExceeded",
+					limit: joined.length
+				}));
+				joined.set(chunk, size);
+				size += chunk.length;
+				return Effect.void;
+			}));
+			if (size !== joined.length) return yield* storageError("cache", source.provider, {
+				_tag: "LengthMismatch",
+				expected: joined.length,
+				actual: size
+			});
+			return {
+				metadata: result.metadata,
+				bytes: joined
+			};
+		}))), {
+			capacity: objects.capacity,
+			timeToLive: (exit) => Exit.isSuccess(exit) ? ttl : 0
+		}) : void 0;
+		const invalidate = Effect.suspend(() => {
+			epoch++;
+			return Cache.invalidateAll(metadata).pipe(Effect.andThen(bytes ? Cache.invalidateAll(bytes) : Effect.void));
+		});
+		const rejectDenied = (error) => error.reason._tag === "AccessDenied" ? invalidate : Effect.void;
+		const getNative = (request) => source.get(request).pipe(Effect.tapError(rejectDenied));
+		return Storage.make({
+			...source,
+			head: (target) => Cache.get(metadata, new MetadataKey({
+				epoch,
+				target: JSON.stringify(target)
+			})).pipe(Effect.map((value) => clone(value))),
+			put: (request) => source.put(request).pipe(Effect.ensuring(invalidate)),
+			delete: (request) => source.delete(request).pipe(Effect.ensuring(invalidate)),
+			get: Effect.fnUntraced(function* (request) {
+				if (!bytes || !objects || request.range || request.condition) return yield* getNative(request);
+				const observed = yield* source.head(request).pipe(Effect.tapError(rejectDenied));
+				if (observed.size === void 0 || observed.size > objects.maxObjectBytes) return yield* getNative(request);
+				if (!observed.ref.version && !observed.etag) return yield* getNative(request);
+				const pinned = observed.ref.version ? { ref: observed.ref } : {
+					ref: observed.ref,
+					condition: {
+						_tag: "IfMatch",
+						etag: observed.etag ?? ""
+					}
+				};
+				const cached = yield* Cache.get(bytes, new ObjectKey({
+					epoch,
+					target: JSON.stringify(pinned)
+				}));
+				return {
+					_tag: "Object",
+					metadata: clone(cached.metadata),
+					contentLength: cached.bytes.length,
+					body: Stream.suspend(() => Stream.fromIterable((function* () {
+						for (let offset = 0; offset < cached.bytes.length; offset += 65536) yield cached.bytes.slice(offset, offset + 65536);
+					})(), { chunkSize: 1 }))
+				};
+			})
+		});
+	}),
+	layer(options) {
+		return storageLayer(StorageCache.make(options));
+	}
+};
+
+export { StorageCache };
+//# sourceMappingURL=cache.js.map

package/dist/cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.js","names":[],"sources":["../src/composition/cache.ts"],"sourcesContent":["import { Cache, Data, Duration, Effect, Exit, Semaphore, Stream } from \"effect\";\n\nimport type { StorageError } from \"../core/errors.js\";\nimport { storageError } from \"../core/errors.js\";\nimport type { ObjectMetadata } from \"../core/object.js\";\nimport type { GetRequest, HeadRequest, ObjectDownload } from \"../core/requests.js\";\nimport { Storage } from \"../core/storage.js\";\nimport { storageLayer } from \"./layer.js\";\n\nexport interface StorageCacheOptions {\n  readonly capacity: number;\n  readonly timeToLive: Duration.Input;\n  readonly objects?: { readonly capacity: number; readonly maxObjectBytes: number };\n}\nclass MetadataKey extends Data.Class<{ readonly epoch: number; readonly target: string }> {}\nclass ObjectKey extends Data.Class<{ readonly epoch: number; readonly target: string }> {}\ninterface CachedObject {\n  readonly metadata: ObjectMetadata;\n  readonly bytes: Uint8Array;\n}\n\nconst clone = (value: ObjectMetadata): ObjectMetadata => ({\n  ...value,\n  ref: { ...value.ref, ...(value.ref.version ? { version: { ...value.ref.version } } : {}) },\n  ...(value.customMetadata ? { customMetadata: { ...value.customMetadata } } : {}),\n  ...(value.checksums ? { checksums: value.checksums.map((checksum) => ({ ...checksum })) } : {}),\n});\n\nexport const StorageCache = {\n  make: Effect.fnUntraced(function* (options: StorageCacheOptions) {\n    if (\n      !Number.isSafeInteger(options.capacity) ||\n      options.capacity < 1 ||\n      (options.objects &&\n        (!Number.isSafeInteger(options.objects.capacity) ||\n          options.objects.capacity < 1 ||\n          !Number.isSafeInteger(options.objects.maxObjectBytes) ||\n          options.objects.maxObjectBytes < 1))\n    )\n      return yield* storageError(\"cache\", \"composition\", {\n        _tag: \"InvalidConfiguration\",\n        field: \"capacity\",\n      });\n    const ttl = yield* Effect.try({\n      try: () => Duration.fromInputUnsafe(options.timeToLive),\n      catch: () =>\n        storageError(\"cache\", \"composition\", { _tag: \"InvalidConfiguration\", field: \"timeToLive\" }),\n    });\n    const source = yield* Storage;\n    let epoch = 0;\n    // An epoch prevents a lookup racing a mutation from repopulating the current cache.\n    const metadata = yield* Cache.makeWith(\n      (key: MetadataKey) => source.head(JSON.parse(key.target) as HeadRequest),\n      {\n        capacity: options.capacity,\n        timeToLive: (exit) => (Exit.isSuccess(exit) ? ttl : 0),\n      },\n    );\n    const objects = options.objects;\n    const fills = yield* Semaphore.make(1);\n    const bytes = objects\n      ? yield* Cache.makeWith(\n          (key: ObjectKey): Effect.Effect<CachedObject, StorageError> =>\n            fills.withPermit(\n              Effect.scoped(\n                Effect.gen(function* () {\n                  const result = yield* source.get(JSON.parse(key.target) as GetRequest);\n                  if (\n                    result._tag !== \"Object\" ||\n                    result.metadata.size === undefined ||\n                    result.metadata.size > objects.maxObjectBytes\n                  )\n                    return yield* storageError(\"cache\", source.provider, {\n                      _tag: \"Unsupported\",\n                      capability: \"cache-fill\",\n                    });\n                  let size = 0;\n                  const joined = new Uint8Array(result.metadata.size);\n                  yield* Stream.runForEach(result.body, (chunk) =>\n                    Effect.suspend(() => {\n                      if (chunk.length > joined.length - size)\n                        return Effect.fail(\n                          storageError(\"cache\", source.provider, {\n                            _tag: \"LimitExceeded\",\n                            limit: joined.length,\n                          }),\n                        );\n                      joined.set(chunk, size);\n                      size += chunk.length;\n                      return Effect.void;\n                    }),\n                  );\n                  if (size !== joined.length)\n                    return yield* storageError(\"cache\", source.provider, {\n                      _tag: \"LengthMismatch\",\n                      expected: joined.length,\n                      actual: size,\n                    });\n                  return { metadata: result.metadata, bytes: joined };\n                }),\n              ),\n            ),\n          { capacity: objects.capacity, timeToLive: (exit) => (Exit.isSuccess(exit) ? ttl : 0) },\n        )\n      : undefined;\n    const invalidate = Effect.suspend(() => {\n      epoch++;\n      return Cache.invalidateAll(metadata).pipe(\n        Effect.andThen(bytes ? Cache.invalidateAll(bytes) : Effect.void),\n      );\n    });\n    const rejectDenied = (error: StorageError) =>\n      error.reason._tag === \"AccessDenied\" ? invalidate : Effect.void;\n    const getNative = (request: GetRequest) =>\n      source.get(request).pipe(Effect.tapError(rejectDenied));\n    return Storage.make({\n      ...source,\n      head: (target) =>\n        Cache.get(metadata, new MetadataKey({ epoch, target: JSON.stringify(target) })).pipe(\n          Effect.map((value) => clone(value)),\n        ),\n      // Invalidate even uncertain mutations; a failed response does not prove no write occurred.\n      put: (request) => source.put(request).pipe(Effect.ensuring(invalidate)),\n      delete: (request) => source.delete(request).pipe(Effect.ensuring(invalidate)),\n      get: Effect.fnUntraced(function* (request) {\n        if (!bytes || !objects || request.range || request.condition)\n          return yield* getNative(request);\n        const observed = yield* source.head(request).pipe(Effect.tapError(rejectDenied));\n        if (observed.size === undefined || observed.size > objects.maxObjectBytes)\n          return yield* getNative(request);\n        if (!observed.ref.version && !observed.etag) return yield* getNative(request);\n        const pinned: GetRequest = observed.ref.version\n          ? { ref: observed.ref }\n          : { ref: observed.ref, condition: { _tag: \"IfMatch\", etag: observed.etag ?? \"\" } };\n        const cached = yield* Cache.get(\n          bytes,\n          new ObjectKey({ epoch, target: JSON.stringify(pinned) }),\n        );\n        return {\n          _tag: \"Object\",\n          metadata: clone(cached.metadata),\n          contentLength: cached.bytes.length,\n          body: Stream.suspend(() =>\n            Stream.fromIterable(\n              (function* () {\n                for (let offset = 0; offset < cached.bytes.length; offset += 65536)\n                  yield cached.bytes.slice(offset, offset + 65536);\n              })(),\n              { chunkSize: 1 },\n            ),\n          ),\n        } satisfies ObjectDownload;\n      }),\n    });\n  }),\n  layer(options: StorageCacheOptions) {\n    return storageLayer(StorageCache.make(options));\n  },\n};\n"],"mappings":"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"}

package/dist/client/atoms/controller.d.ts

@@ -0,0 +1,10 @@
+import { UploadInput } from "../../uploads/schema.js";
+import "../../client.js";
+import "./state.js";
+import { Effect } from "effect";
+export interface UploadSlotOptions {
+  readonly purpose: string;
+  readonly context: Readonly<Record<string, string>>;
+  readonly strategy?: UploadInput["strategy"];
+}
+//# sourceMappingURL=controller.d.ts.map