@effect-kit/storage 0.0.0-stage → 0.0.0

package/dist/providers/tigris/configuration.js

@@ -0,0 +1,118 @@
+import { storageError } from "../../core/errors.js";
+import { decodeRequest } from "../../internal/request-validation.js";
+import { call } from "./transport.js";
+import { Effect, Redacted, Schema } from "effect";
+import * as Tigris from "@tigrisdata/storage";
+
+// src/providers/tigris/configuration.ts
+const Bucket = Schema.NonEmptyString;
+const Strings = Schema.Union([Schema.String, Schema.Array(Schema.String)]);
+const Cors = Schema.Struct({
+	allowedOrigins: Strings,
+	allowedMethods: Schema.optional(Strings),
+	allowedHeaders: Schema.optional(Strings),
+	exposeHeaders: Schema.optional(Strings),
+	maxAge: Schema.optional(Schema.Natural)
+});
+const Tier = Schema.Literals([
+	"STANDARD",
+	"STANDARD_IA",
+	"GLACIER",
+	"GLACIER_IR"
+]);
+const Lifecycle = Schema.Struct({
+	id: Schema.optional(Schema.String),
+	enabled: Schema.optional(Schema.Boolean),
+	storageClass: Schema.optional(Schema.Literals([
+		"STANDARD_IA",
+		"GLACIER",
+		"GLACIER_IR"
+	])),
+	days: Schema.optional(Schema.Natural),
+	date: Schema.optional(Schema.String),
+	expiration: Schema.optional(Schema.Struct({
+		days: Schema.optional(Schema.Natural),
+		date: Schema.optional(Schema.String)
+	})),
+	filter: Schema.optional(Schema.Struct({ prefix: Schema.String }))
+});
+const Settings = Schema.Struct({
+	access: Schema.optional(Schema.Literals(["public", "private"])),
+	allowObjectAcl: Schema.optional(Schema.Boolean),
+	defaultTier: Schema.optional(Tier),
+	disableDirectoryListing: Schema.optional(Schema.Boolean),
+	cacheControl: Schema.optional(Schema.String),
+	customDomain: Schema.optional(Schema.String),
+	enableAdditionalHeaders: Schema.optional(Schema.Boolean),
+	softDelete: Schema.optional(Schema.Union([Schema.Struct({
+		enabled: Schema.Literal(true),
+		retentionDays: Schema.Int.check(Schema.isGreaterThan(0))
+	}), Schema.Struct({ enabled: Schema.Literal(false) })]))
+});
+/** Native replacement operations have no provider CAS. Inspect with head before applying. */
+const configuration = (native) => ({
+	update: Effect.fnUntraced(function* (input) {
+		const value = yield* decodeRequest(Schema.Struct({
+			bucket: Bucket,
+			settings: Settings,
+			intent: Schema.Literal("change-storage-protection")
+		}), input, "updateBucket", "tigris", true);
+		const config = yield* native;
+		return yield* call("updateBucket", true, () => Tigris.updateBucket(value.bucket, {
+			...structuredClone(value.settings),
+			config
+		}));
+	}),
+	setCors: Effect.fnUntraced(function* (input) {
+		const value = yield* decodeRequest(Schema.Struct({
+			bucket: Bucket,
+			rules: Schema.Array(Cors)
+		}), input, "setCors", "tigris", true);
+		const config = yield* native;
+		return yield* call("setCors", true, () => Tigris.setBucketCors(value.bucket, {
+			rules: structuredClone(value.rules),
+			override: true,
+			config
+		}));
+	}),
+	setLifecycle: Effect.fnUntraced(function* (input) {
+		const value = yield* decodeRequest(Schema.Struct({
+			bucket: Bucket,
+			rules: Schema.Array(Lifecycle),
+			intent: Schema.Literal("change-storage-protection")
+		}), input, "setLifecycle", "tigris", true);
+		const config = yield* native;
+		return yield* call("setLifecycle", true, () => Tigris.setBucketLifecycle(value.bucket, {
+			lifecycleRules: structuredClone(value.rules),
+			config
+		}));
+	}),
+	setNotifications: Effect.fnUntraced(function* (input) {
+		const value = yield* decodeRequest(Schema.Struct({
+			bucket: Bucket,
+			enabled: Schema.Boolean,
+			url: Schema.optional(Schema.String),
+			filter: Schema.optional(Schema.String),
+			token: Schema.optional(Schema.Redacted(Schema.NonEmptyString))
+		}), input, "setNotifications", "tigris", true);
+		const url = value.url ? URL.parse(value.url) : void 0;
+		if (value.enabled && (!url || url.protocol !== "https:" || url.username || url.password || !value.token)) return yield* storageError("setNotifications", "tigris", {
+			_tag: "InvalidInput",
+			field: "authenticated-https-webhook"
+		}, "not-started");
+		const config = yield* native;
+		return yield* call("setNotifications", true, () => Tigris.setBucketNotifications(value.bucket, {
+			override: true,
+			notificationConfig: {
+				enabled: value.enabled,
+				...value.url ? { url: value.url } : {},
+				...value.filter ? { filter: value.filter } : {},
+				...value.token ? { auth: { token: Redacted.value(value.token) } } : {}
+			},
+			config
+		}));
+	})
+});
+
+export { configuration };
+//# sourceMappingURL=configuration.js.map

package/dist/providers/tigris/configuration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"configuration.js","names":[],"sources":["../../../src/providers/tigris/configuration.ts"],"sourcesContent":["import { Effect, Redacted, Schema } from \"effect\";\n\nimport * as Tigris from \"@tigrisdata/storage\";\n\nimport { storageError } from \"../../core/errors.js\";\nimport { decodeRequest } from \"../../internal/request-validation.js\";\nimport { call } from \"./transport.js\";\n\nconst Bucket = Schema.NonEmptyString;\nconst Strings = Schema.Union([Schema.String, Schema.Array(Schema.String)]);\nconst Cors = Schema.Struct({\n  allowedOrigins: Strings,\n  allowedMethods: Schema.optional(Strings),\n  allowedHeaders: Schema.optional(Strings),\n  exposeHeaders: Schema.optional(Strings),\n  maxAge: Schema.optional(Schema.Natural),\n});\nconst Tier = Schema.Literals([\"STANDARD\", \"STANDARD_IA\", \"GLACIER\", \"GLACIER_IR\"]);\nconst Lifecycle = Schema.Struct({\n  id: Schema.optional(Schema.String),\n  enabled: Schema.optional(Schema.Boolean),\n  storageClass: Schema.optional(Schema.Literals([\"STANDARD_IA\", \"GLACIER\", \"GLACIER_IR\"])),\n  days: Schema.optional(Schema.Natural),\n  date: Schema.optional(Schema.String),\n  expiration: Schema.optional(\n    Schema.Struct({ days: Schema.optional(Schema.Natural), date: Schema.optional(Schema.String) }),\n  ),\n  filter: Schema.optional(Schema.Struct({ prefix: Schema.String })),\n});\nconst Settings = Schema.Struct({\n  access: Schema.optional(Schema.Literals([\"public\", \"private\"])),\n  allowObjectAcl: Schema.optional(Schema.Boolean),\n  defaultTier: Schema.optional(Tier),\n  disableDirectoryListing: Schema.optional(Schema.Boolean),\n  cacheControl: Schema.optional(Schema.String),\n  customDomain: Schema.optional(Schema.String),\n  enableAdditionalHeaders: Schema.optional(Schema.Boolean),\n  softDelete: Schema.optional(\n    Schema.Union([\n      Schema.Struct({\n        enabled: Schema.Literal(true),\n        retentionDays: Schema.Int.check(Schema.isGreaterThan(0)),\n      }),\n      Schema.Struct({ enabled: Schema.Literal(false) }),\n    ]),\n  ),\n});\n\n/** Native replacement operations have no provider CAS. Inspect with head before applying. */\nexport const configuration = (\n  native: Effect.Effect<Tigris.TigrisConfig, ReturnType<typeof storageError>>,\n) => ({\n  update: Effect.fnUntraced(function* (input: {\n    readonly bucket: string;\n    readonly settings: typeof Settings.Type;\n    readonly intent: \"change-storage-protection\";\n  }) {\n    const value = yield* decodeRequest(\n      Schema.Struct({\n        bucket: Bucket,\n        settings: Settings,\n        intent: Schema.Literal(\"change-storage-protection\"),\n      }),\n      input,\n      \"updateBucket\",\n      \"tigris\",\n      true,\n    );\n    const config = yield* native;\n    return yield* call(\"updateBucket\", true, () =>\n      Tigris.updateBucket(value.bucket, {\n        ...(structuredClone(value.settings) as Omit<Tigris.UpdateBucketOptions, \"config\">),\n        config,\n      }),\n    );\n  }),\n  setCors: Effect.fnUntraced(function* (input: {\n    readonly bucket: string;\n    readonly rules: ReadonlyArray<typeof Cors.Type>;\n  }) {\n    const value = yield* decodeRequest(\n      Schema.Struct({ bucket: Bucket, rules: Schema.Array(Cors) }),\n      input,\n      \"setCors\",\n      \"tigris\",\n      true,\n    );\n    const config = yield* native;\n    return yield* call(\"setCors\", true, () =>\n      Tigris.setBucketCors(value.bucket, {\n        rules: structuredClone(value.rules) as Tigris.BucketCorsRule[],\n        override: true,\n        config,\n      }),\n    );\n  }),\n  setLifecycle: Effect.fnUntraced(function* (input: {\n    readonly bucket: string;\n    readonly rules: ReadonlyArray<typeof Lifecycle.Type>;\n    readonly intent: \"change-storage-protection\";\n  }) {\n    const value = yield* decodeRequest(\n      Schema.Struct({\n        bucket: Bucket,\n        rules: Schema.Array(Lifecycle),\n        intent: Schema.Literal(\"change-storage-protection\"),\n      }),\n      input,\n      \"setLifecycle\",\n      \"tigris\",\n      true,\n    );\n    const config = yield* native;\n    return yield* call(\"setLifecycle\", true, () =>\n      Tigris.setBucketLifecycle(value.bucket, {\n        lifecycleRules: structuredClone(value.rules) as Tigris.BucketLifecycleRule[],\n        config,\n      }),\n    );\n  }),\n  setNotifications: Effect.fnUntraced(function* (input: {\n    readonly bucket: string;\n    readonly enabled: boolean;\n    readonly url?: string;\n    readonly filter?: string;\n    readonly token?: Redacted.Redacted<string>;\n  }) {\n    const value = yield* decodeRequest(\n      Schema.Struct({\n        bucket: Bucket,\n        enabled: Schema.Boolean,\n        url: Schema.optional(Schema.String),\n        filter: Schema.optional(Schema.String),\n        token: Schema.optional(Schema.Redacted(Schema.NonEmptyString)),\n      }),\n      input,\n      \"setNotifications\",\n      \"tigris\",\n      true,\n    );\n    const url = value.url ? URL.parse(value.url) : undefined;\n    if (\n      value.enabled &&\n      (!url || url.protocol !== \"https:\" || url.username || url.password || !value.token)\n    )\n      return yield* storageError(\n        \"setNotifications\",\n        \"tigris\",\n        { _tag: \"InvalidInput\", field: \"authenticated-https-webhook\" },\n        \"not-started\",\n      );\n    const config = yield* native;\n    return yield* call(\"setNotifications\", true, () =>\n      Tigris.setBucketNotifications(value.bucket, {\n        override: true,\n        notificationConfig: {\n          enabled: value.enabled,\n          ...(value.url ? { url: value.url } : {}),\n          ...(value.filter ? { filter: value.filter } : {}),\n          ...(value.token ? { auth: { token: Redacted.value(value.token) } } : {}),\n        },\n        config,\n      }),\n    );\n  }),\n});\n"],"mappings":"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"}

package/dist/providers/tigris/snapshots.js

@@ -0,0 +1,87 @@
+import { storageError } from "../../core/errors.js";
+import { decodeRequest } from "../../internal/request-validation.js";
+import { request } from "../s3/transport.js";
+import { extendRequest } from "../s3/request-extension.js";
+import { Effect, Schema } from "effect";
+import { CreateBucketCommand, DeleteBucketCommand, ListBucketsCommand } from "@aws-sdk/client-s3";
+
+// src/providers/tigris/snapshots.ts
+const Bucket = Schema.String.check(Schema.isPattern(/^[a-z0-9][a-z0-9.-]{1,61}[a-z0-9]$/u));
+const createBucket = Effect.fnUntraced(function* (storage, input) {
+	const value = yield* decodeRequest(Schema.Struct({
+		bucket: Bucket,
+		sourceBucket: Schema.optional(Bucket),
+		snapshot: Schema.optional(Schema.NonEmptyString)
+	}), input, "createBucket", "tigris", true);
+	const command = new CreateBucketCommand({ Bucket: value.bucket });
+	extendRequest(command, { headers: {
+		"X-Amz-Acl": "private",
+		"X-Amz-Acl-Public-List-Objects-Enabled": "false",
+		...value.sourceBucket ? { "X-Tigris-Fork-Source-Bucket": value.sourceBucket } : {},
+		...value.snapshot ? { "X-Tigris-Fork-Source-Bucket-Snapshot": value.snapshot } : {}
+	} });
+	yield* request(storage, "createBucket", true, (signal) => storage.client.send(command, { abortSignal: signal }));
+	return {
+		_tag: "Accepted",
+		bucket: value.bucket
+	};
+});
+const snapshots = (storage) => ({
+	create: Effect.fnUntraced(function* (input) {
+		const value = yield* decodeRequest(Schema.Struct({
+			bucket: Bucket,
+			name: Schema.optional(Schema.String.check(Schema.isPattern(/^[A-Za-z0-9._-]{1,128}$/u)))
+		}), input, "createSnapshot", "tigris", true);
+		let version;
+		const command = new CreateBucketCommand({ Bucket: value.bucket });
+		extendRequest(command, {
+			headers: { "X-Tigris-Snapshot": value.name ? `true; name=${value.name}` : "true" },
+			observeHeaders: (headers) => {
+				version = headers["x-tigris-snapshot-version"];
+			}
+		});
+		yield* request(storage, "createSnapshot", true, (signal) => storage.client.send(command, { abortSignal: signal }));
+		if (!version) return yield* storageError("createSnapshot", "tigris", {
+			_tag: "ProviderFailure",
+			code: "MissingSnapshotReceipt"
+		}, "unknown");
+		return { snapshotVersion: version };
+	}),
+	listPage: Effect.fnUntraced(function* (input) {
+		const value = yield* decodeRequest(Schema.Struct({
+			bucket: Bucket,
+			cursor: Schema.optional(Schema.NonEmptyString),
+			limit: Schema.optional(Schema.Int.check(Schema.isBetween({
+				minimum: 1,
+				maximum: 1e3
+			})))
+		}), input, "listSnapshots", "tigris");
+		const command = new ListBucketsCommand({
+			ContinuationToken: value.cursor,
+			MaxBuckets: value.limit
+		});
+		extendRequest(command, { headers: { "X-Tigris-Snapshot": value.bucket } });
+		const response = yield* request(storage, "listSnapshots", false, (signal) => storage.client.send(command, { abortSignal: signal }));
+		return {
+			snapshots: (response.Buckets ?? []).map((snapshot) => ({
+				version: snapshot.Name?.split(";")[0],
+				name: snapshot.Name?.split("; name=")[1],
+				createdAt: snapshot.CreationDate
+			})),
+			cursor: response.ContinuationToken
+		};
+	}),
+	delete: Effect.fnUntraced(function* (input) {
+		const value = yield* decodeRequest(Schema.Struct({
+			bucket: Bucket,
+			version: Schema.NonEmptyString,
+			intent: Schema.Literal("delete-snapshot")
+		}), input, "deleteSnapshot", "tigris", true);
+		const command = new DeleteBucketCommand({ Bucket: value.bucket });
+		extendRequest(command, { headers: { "X-Tigris-Snapshot-Version": value.version } });
+		yield* request(storage, "deleteSnapshot", true, (signal) => storage.client.send(command, { abortSignal: signal }));
+	})
+});
+
+export { Bucket, createBucket, snapshots };
+//# sourceMappingURL=snapshots.js.map

package/dist/providers/tigris/snapshots.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshots.js","names":[],"sources":["../../../src/providers/tigris/snapshots.ts"],"sourcesContent":["import { Effect, Schema } from \"effect\";\n\nimport { CreateBucketCommand, DeleteBucketCommand, ListBucketsCommand } from \"@aws-sdk/client-s3\";\n\nimport { storageError } from \"../../core/errors.js\";\nimport { decodeRequest } from \"../../internal/request-validation.js\";\nimport type { S3StorageService } from \"../s3/index.js\";\nimport { extendRequest } from \"../s3/request-extension.js\";\nimport { request } from \"../s3/transport.js\";\n\nexport const Bucket = Schema.String.check(Schema.isPattern(/^[a-z0-9][a-z0-9.-]{1,61}[a-z0-9]$/u));\nexport const createBucket = Effect.fnUntraced(function* (\n  storage: S3StorageService,\n  input: { readonly bucket: string; readonly sourceBucket?: string; readonly snapshot?: string },\n) {\n  const value = yield* decodeRequest(\n    Schema.Struct({\n      bucket: Bucket,\n      sourceBucket: Schema.optional(Bucket),\n      snapshot: Schema.optional(Schema.NonEmptyString),\n    }),\n    input,\n    \"createBucket\",\n    \"tigris\",\n    true,\n  );\n  const command = new CreateBucketCommand({ Bucket: value.bucket });\n  extendRequest(command, {\n    headers: {\n      \"X-Amz-Acl\": \"private\",\n      \"X-Amz-Acl-Public-List-Objects-Enabled\": \"false\",\n      ...(value.sourceBucket ? { \"X-Tigris-Fork-Source-Bucket\": value.sourceBucket } : {}),\n      ...(value.snapshot ? { \"X-Tigris-Fork-Source-Bucket-Snapshot\": value.snapshot } : {}),\n    },\n  });\n  yield* request(storage, \"createBucket\", true, (signal) =>\n    storage.client.send(command, { abortSignal: signal }),\n  );\n  return { _tag: \"Accepted\" as const, bucket: value.bucket };\n});\nexport const snapshots = (storage: S3StorageService) => ({\n  create: Effect.fnUntraced(function* (input: { readonly bucket: string; readonly name?: string }) {\n    const value = yield* decodeRequest(\n      Schema.Struct({\n        bucket: Bucket,\n        name: Schema.optional(Schema.String.check(Schema.isPattern(/^[A-Za-z0-9._-]{1,128}$/u))),\n      }),\n      input,\n      \"createSnapshot\",\n      \"tigris\",\n      true,\n    );\n    let version: string | undefined;\n    const command = new CreateBucketCommand({ Bucket: value.bucket });\n    extendRequest(command, {\n      headers: { \"X-Tigris-Snapshot\": value.name ? `true; name=${value.name}` : \"true\" },\n      observeHeaders: (headers) => {\n        version = headers[\"x-tigris-snapshot-version\"];\n      },\n    });\n    yield* request(storage, \"createSnapshot\", true, (signal) =>\n      storage.client.send(command, { abortSignal: signal }),\n    );\n    if (!version)\n      return yield* storageError(\n        \"createSnapshot\",\n        \"tigris\",\n        { _tag: \"ProviderFailure\", code: \"MissingSnapshotReceipt\" },\n        \"unknown\",\n      );\n    return { snapshotVersion: version };\n  }),\n  listPage: Effect.fnUntraced(function* (input: {\n    readonly bucket: string;\n    readonly cursor?: string;\n    readonly limit?: number;\n  }) {\n    const value = yield* decodeRequest(\n      Schema.Struct({\n        bucket: Bucket,\n        cursor: Schema.optional(Schema.NonEmptyString),\n        limit: Schema.optional(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 1000 }))),\n      }),\n      input,\n      \"listSnapshots\",\n      \"tigris\",\n    );\n    const command = new ListBucketsCommand({\n      ContinuationToken: value.cursor,\n      MaxBuckets: value.limit,\n    });\n    extendRequest(command, { headers: { \"X-Tigris-Snapshot\": value.bucket } });\n    const response = yield* request(storage, \"listSnapshots\", false, (signal) =>\n      storage.client.send(command, { abortSignal: signal }),\n    );\n    return {\n      snapshots: (response.Buckets ?? []).map((snapshot) => ({\n        version: snapshot.Name?.split(\";\")[0],\n        name: snapshot.Name?.split(\"; name=\")[1],\n        createdAt: snapshot.CreationDate,\n      })),\n      cursor: response.ContinuationToken,\n    };\n  }),\n  delete: Effect.fnUntraced(function* (input: {\n    readonly bucket: string;\n    readonly version: string;\n    readonly intent: \"delete-snapshot\";\n  }) {\n    const value = yield* decodeRequest(\n      Schema.Struct({\n        bucket: Bucket,\n        version: Schema.NonEmptyString,\n        intent: Schema.Literal(\"delete-snapshot\"),\n      }),\n      input,\n      \"deleteSnapshot\",\n      \"tigris\",\n      true,\n    );\n    const command = new DeleteBucketCommand({ Bucket: value.bucket });\n    extendRequest(command, { headers: { \"X-Tigris-Snapshot-Version\": value.version } });\n    yield* request(storage, \"deleteSnapshot\", true, (signal) =>\n      storage.client.send(command, { abortSignal: signal }),\n    );\n  }),\n});\n"],"mappings":"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"}

package/dist/providers/tigris/transport.js

@@ -0,0 +1,18 @@
+import { storageError } from "../../core/errors.js";
+import { providerError } from "../../internal/node/provider-errors.js";
+import { Effect } from "effect";
+
+// src/providers/tigris/transport.ts
+const call = (operation, mutation, run) => Effect.tryPromise({
+	try: run,
+	catch: (error) => providerError("tigris", operation, mutation, error)
+}).pipe(Effect.flatMap((result) => result.error ? Effect.fail(providerError("tigris", operation, mutation, result.error)) : Effect.succeed(result.data)), Effect.timeoutOrElse({
+	duration: "30 seconds",
+	orElse: () => Effect.fail(storageError(operation, "tigris", {
+		_tag: "TransportFailure",
+		code: "DeadlineExceeded"
+	}, mutation ? "unknown" : "not-applicable"))
+}));
+
+export { call };
+//# sourceMappingURL=transport.js.map

package/dist/providers/tigris/transport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.js","names":[],"sources":["../../../src/providers/tigris/transport.ts"],"sourcesContent":["import { Effect } from \"effect\";\n\nimport { storageError } from \"../../core/errors.js\";\nimport { providerError } from \"../../internal/node/provider-errors.js\";\nexport const call = <A>(\n  operation: string,\n  mutation: boolean,\n  run: () => Promise<{ data: A; error?: never } | { error: Error; data?: never }>,\n) =>\n  Effect.tryPromise({\n    try: run,\n    catch: (error) => providerError(\"tigris\", operation, mutation, error),\n  }).pipe(\n    Effect.flatMap((result) =>\n      result.error\n        ? Effect.fail(providerError(\"tigris\", operation, mutation, result.error))\n        : Effect.succeed(result.data),\n    ),\n    Effect.timeoutOrElse({\n      duration: \"30 seconds\",\n      orElse: () =>\n        Effect.fail(\n          storageError(\n            operation,\n            \"tigris\",\n            { _tag: \"TransportFailure\", code: \"DeadlineExceeded\" },\n            mutation ? \"unknown\" : \"not-applicable\",\n          ),\n        ),\n    }),\n  );\n"],"mappings":";;;;;AAIA,MAAa,QACX,WACA,UACA,QAEA,OAAO,WAAW;CAChB,KAAK;CACL,QAAQ,UAAU,cAAc,UAAU,WAAW,UAAU,KAAK;AACtE,CAAC,CAAC,CAAC,KACD,OAAO,SAAS,WACd,OAAO,QACH,OAAO,KAAK,cAAc,UAAU,WAAW,UAAU,OAAO,KAAK,CAAC,IACtE,OAAO,QAAQ,OAAO,IAAI,CAChC,GACA,OAAO,cAAc;CACnB,UAAU;CACV,cACE,OAAO,KACL,aACE,WACA,UACA;EAAE,MAAM;EAAoB,MAAM;CAAmB,GACrD,WAAW,YAAY,gBACzB,CACF;AACJ,CAAC,CACH"}

package/dist/providers/vercel/config.d.ts

@@ -0,0 +1,16 @@
+import { StorageError } from "../../core/errors.js";
+import { Effect, Redacted } from "effect";
+type Secret = Redacted.Redacted<string> | Effect.Effect<Redacted.Redacted<string>, StorageError>;
+export interface VercelConfig {
+  readonly storeId: string;
+  readonly access: "public" | "private";
+  readonly credential: {
+    readonly mode: "token" | "oidc";
+    readonly token: Secret;
+  };
+  readonly maxObjectBytes?: number;
+  readonly maxUnknownLengthBytes?: number;
+  readonly requestTimeoutMillis?: number;
+}
+export {};
+//# sourceMappingURL=config.d.ts.map

package/dist/providers/vercel/config.js

@@ -0,0 +1,48 @@
+import { storageError } from "../../core/errors.js";
+import { Effect, Redacted, Schema } from "effect";
+
+// src/providers/vercel/config.ts
+const Positive = Schema.Int.check(Schema.isGreaterThan(0));
+const Config$1 = Schema.Struct({
+	storeId: Schema.String.check(Schema.isPattern(/^(?:store_)?[A-Za-z0-9]+$/u)),
+	access: Schema.Literals(["public", "private"]),
+	credential: Schema.Struct({
+		mode: Schema.Literals(["token", "oidc"]),
+		token: Schema.declare((value) => Redacted.isRedacted(value) || Effect.isEffect(value))
+	}),
+	maxObjectBytes: Schema.optional(Positive),
+	maxUnknownLengthBytes: Schema.optional(Positive),
+	requestTimeoutMillis: Schema.optional(Positive)
+});
+const resolveConfig = Effect.fnUntraced(function* (input) {
+	yield* Schema.decodeUnknownEffect(Config$1, { onExcessProperty: "error" })(input).pipe(Effect.mapError(() => storageError("make", "vercel", {
+		_tag: "InvalidConfiguration",
+		field: "config"
+	})));
+	yield* retryPolicy();
+	const override = process.env.VERCEL_BLOB_API_URL ?? process.env.NEXT_PUBLIC_VERCEL_BLOB_API_URL;
+	const endpoint = override ? URL.parse(override) : void 0;
+	if (override && (!endpoint || !["https:", "http:"].includes(endpoint.protocol) || endpoint.username || endpoint.password || endpoint.search || endpoint.hash || endpoint.pathname !== "/")) return yield* storageError("make", "vercel", {
+		_tag: "InvalidConfiguration",
+		field: "VERCEL_BLOB_API_URL"
+	});
+	return {
+		...input,
+		apiOrigin: endpoint?.origin,
+		storeId: input.storeId.replace(/^store_/u, ""),
+		maxObjectBytes: input.maxObjectBytes ?? 1024 ** 3,
+		maxUnknownLengthBytes: input.maxUnknownLengthBytes ?? 8 * 1024 ** 2,
+		requestTimeoutMillis: input.requestTimeoutMillis ?? 3e4
+	};
+});
+/** The pinned SDK reads this switch per request; never change global application policy here. */
+const retryPolicy = () => Effect.suspend(() => {
+	const version = process.env.VERCEL_BLOB_API_VERSION_OVERRIDE ?? process.env.NEXT_PUBLIC_VERCEL_BLOB_API_VERSION_OVERRIDE;
+	return process.env.VERCEL_BLOB_RETRIES === "0" && (version === void 0 || version === "13") ? Effect.void : Effect.fail(storageError("sdk.policy", "vercel", {
+		_tag: "InvalidConfiguration",
+		field: "sdk-retries-or-api-version"
+	}, "not-started"));
+});
+
+export { resolveConfig, retryPolicy };
+//# sourceMappingURL=config.js.map

package/dist/providers/vercel/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","names":["Config"],"sources":["../../../src/providers/vercel/config.ts"],"sourcesContent":["import { Effect, Redacted, Schema } from \"effect\";\n\nimport { storageError } from \"../../core/errors.js\";\nimport type { StorageError } from \"../../core/errors.js\";\n\ntype Secret = Redacted.Redacted<string> | Effect.Effect<Redacted.Redacted<string>, StorageError>;\nexport interface VercelConfig {\n  readonly storeId: string;\n  readonly access: \"public\" | \"private\";\n  readonly credential: { readonly mode: \"token\" | \"oidc\"; readonly token: Secret };\n  readonly maxObjectBytes?: number;\n  readonly maxUnknownLengthBytes?: number;\n  readonly requestTimeoutMillis?: number;\n}\nconst Positive = Schema.Int.check(Schema.isGreaterThan(0));\nconst Config = Schema.Struct({\n  storeId: Schema.String.check(Schema.isPattern(/^(?:store_)?[A-Za-z0-9]+$/u)),\n  access: Schema.Literals([\"public\", \"private\"]),\n  credential: Schema.Struct({\n    mode: Schema.Literals([\"token\", \"oidc\"]),\n    token: Schema.declare<Secret>(\n      (value): value is Secret => Redacted.isRedacted(value) || Effect.isEffect(value),\n    ),\n  }),\n  maxObjectBytes: Schema.optional(Positive),\n  maxUnknownLengthBytes: Schema.optional(Positive),\n  requestTimeoutMillis: Schema.optional(Positive),\n});\nexport const resolveConfig = Effect.fnUntraced(function* (input: VercelConfig) {\n  yield* Schema.decodeUnknownEffect(Config, { onExcessProperty: \"error\" })(input).pipe(\n    Effect.mapError(() =>\n      storageError(\"make\", \"vercel\", { _tag: \"InvalidConfiguration\", field: \"config\" }),\n    ),\n  );\n  yield* retryPolicy();\n  const override = process.env.VERCEL_BLOB_API_URL ?? process.env.NEXT_PUBLIC_VERCEL_BLOB_API_URL;\n  const endpoint = override ? URL.parse(override) : undefined;\n  if (\n    override &&\n    (!endpoint ||\n      ![\"https:\", \"http:\"].includes(endpoint.protocol) ||\n      endpoint.username ||\n      endpoint.password ||\n      endpoint.search ||\n      endpoint.hash ||\n      endpoint.pathname !== \"/\")\n  )\n    return yield* storageError(\"make\", \"vercel\", {\n      _tag: \"InvalidConfiguration\",\n      field: \"VERCEL_BLOB_API_URL\",\n    });\n  return {\n    ...input,\n    apiOrigin: endpoint?.origin,\n    storeId: input.storeId.replace(/^store_/u, \"\"),\n    maxObjectBytes: input.maxObjectBytes ?? 1024 ** 3,\n    maxUnknownLengthBytes: input.maxUnknownLengthBytes ?? 8 * 1024 ** 2,\n    requestTimeoutMillis: input.requestTimeoutMillis ?? 30000,\n  };\n});\nexport type VercelConnection = {\n  readonly config: Effect.Success<ReturnType<typeof resolveConfig>>;\n};\n/** The pinned SDK reads this switch per request; never change global application policy here. */\nexport const retryPolicy = () =>\n  Effect.suspend(() => {\n    const version =\n      process.env.VERCEL_BLOB_API_VERSION_OVERRIDE ??\n      process.env.NEXT_PUBLIC_VERCEL_BLOB_API_VERSION_OVERRIDE;\n    return process.env.VERCEL_BLOB_RETRIES === \"0\" && (version === undefined || version === \"13\")\n      ? Effect.void\n      : Effect.fail(\n          storageError(\n            \"sdk.policy\",\n            \"vercel\",\n            { _tag: \"InvalidConfiguration\", field: \"sdk-retries-or-api-version\" },\n            \"not-started\",\n          ),\n        );\n  });\n"],"mappings":";;;;AAcA,MAAM,WAAW,OAAO,IAAI,MAAM,OAAO,cAAc,CAAC,CAAC;AACzD,MAAMA,WAAS,OAAO,OAAO;CAC3B,SAAS,OAAO,OAAO,MAAM,OAAO,UAAU,4BAA4B,CAAC;CAC3E,QAAQ,OAAO,SAAS,CAAC,UAAU,SAAS,CAAC;CAC7C,YAAY,OAAO,OAAO;EACxB,MAAM,OAAO,SAAS,CAAC,SAAS,MAAM,CAAC;EACvC,OAAO,OAAO,SACX,UAA2B,SAAS,WAAW,KAAK,KAAK,OAAO,SAAS,KAAK,CACjF;CACF,CAAC;CACD,gBAAgB,OAAO,SAAS,QAAQ;CACxC,uBAAuB,OAAO,SAAS,QAAQ;CAC/C,sBAAsB,OAAO,SAAS,QAAQ;AAChD,CAAC;AACD,MAAa,gBAAgB,OAAO,WAAW,WAAW,OAAqB;CAC7E,OAAO,OAAO,oBAAoBA,UAAQ,EAAE,kBAAkB,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,KAC9E,OAAO,eACL,aAAa,QAAQ,UAAU;EAAE,MAAM;EAAwB,OAAO;CAAS,CAAC,CAClF,CACF;CACA,OAAO,YAAY;CACnB,MAAM,WAAW,QAAQ,IAAI,uBAAuB,QAAQ,IAAI;CAChE,MAAM,WAAW,WAAW,IAAI,MAAM,QAAQ,IAAI;CAClD,IACE,aACC,CAAC,YACA,CAAC,CAAC,UAAU,OAAO,CAAC,CAAC,SAAS,SAAS,QAAQ,KAC/C,SAAS,YACT,SAAS,YACT,SAAS,UACT,SAAS,QACT,SAAS,aAAa,MAExB,OAAO,OAAO,aAAa,QAAQ,UAAU;EAC3C,MAAM;EACN,OAAO;CACT,CAAC;CACH,OAAO;EACL,GAAG;EACH,WAAW,UAAU;EACrB,SAAS,MAAM,QAAQ,QAAQ,YAAY,EAAE;EAC7C,gBAAgB,MAAM,kBAAkB,QAAQ;EAChD,uBAAuB,MAAM,yBAAyB,IAAI,QAAQ;EAClE,sBAAsB,MAAM,wBAAwB;CACtD;AACF,CAAC;;AAKD,MAAa,oBACX,OAAO,cAAc;CACnB,MAAM,UACJ,QAAQ,IAAI,oCACZ,QAAQ,IAAI;CACd,OAAO,QAAQ,IAAI,wBAAwB,QAAQ,YAAY,UAAa,YAAY,QACpF,OAAO,OACP,OAAO,KACL,aACE,cACA,UACA;EAAE,MAAM;EAAwB,OAAO;CAA6B,GACpE,aACF,CACF;AACN,CAAC"}

package/dist/providers/vercel/mapping.js

@@ -0,0 +1,79 @@
+import { ObjectKey, ObjectMetadata } from "../../core/object.js";
+import { storageError } from "../../core/errors.js";
+import { DateTime, Effect, Option, Schema } from "effect";
+import * as Blob from "@vercel/blob";
+
+// src/providers/vercel/mapping.ts
+const validateKey = Effect.fnUntraced(function* (key, operation) {
+	yield* Schema.decodeUnknownEffect(ObjectKey)(key).pipe(Effect.mapError(() => storageError(operation, "vercel", {
+		_tag: "InvalidInput",
+		field: "key"
+	}, "not-started")));
+	if (key.startsWith("/") || /^https?:/iu.test(key) || key.split("/").some((part) => !part || part === "." || part === "..") || new TextEncoder().encode(key).length > 950) return yield* storageError(operation, "vercel", {
+		_tag: "InvalidInput",
+		field: "key"
+	}, "not-started");
+	return key;
+});
+const writeOptions = Effect.fnUntraced(function* (headers, operation) {
+	if (Object.keys(headers.customMetadata ?? {}).filter((key) => key !== "effect-storage-operation").length || headers.contentDisposition || headers.contentLanguage || headers.contentEncoding || headers.cacheControl) return yield* storageError(operation, "vercel", {
+		_tag: "Unsupported",
+		capability: "object-headers"
+	}, "not-started");
+	return {
+		...headers.contentType ? { contentType: headers.contentType } : {},
+		addRandomSuffix: false
+	};
+});
+const Observation = Schema.Struct({
+	pathname: Schema.String,
+	etag: Schema.optional(Schema.String),
+	size: Schema.optional(Schema.NullOr(Schema.Natural)),
+	contentType: Schema.optional(Schema.NullOr(Schema.String)),
+	contentDisposition: Schema.optional(Schema.String),
+	cacheControl: Schema.optional(Schema.String)
+});
+const metadata = Effect.fnUntraced(function* (connection, value, operation, key, mutation = false) {
+	const observed = yield* Schema.decodeUnknownEffect(Observation)(value).pipe(Effect.mapError(() => storageError(operation, "vercel", { _tag: "ProviderFailure" }, mutation ? "unknown" : "not-applicable")));
+	if (key !== void 0 && observed.pathname !== key) return yield* storageError(operation, "vercel", { _tag: "IntegrityMismatch" }, mutation ? "unknown" : "not-applicable");
+	const uploadedAt = value !== null && typeof value === "object" ? Reflect.get(value, "uploadedAt") : void 0;
+	const modified = uploadedAt instanceof Date ? Option.getOrUndefined(DateTime.make(uploadedAt)) : void 0;
+	return yield* Schema.decodeUnknownEffect(Schema.toType(ObjectMetadata))({
+		ref: {
+			storeId: `vercel:${connection.config.access}:${connection.config.storeId}`,
+			key: observed.pathname
+		},
+		...observed.size !== void 0 && observed.size !== null ? { size: observed.size } : {},
+		...observed.etag ? { etag: observed.etag } : {},
+		...observed.contentType ? { contentType: observed.contentType } : {},
+		...observed.contentDisposition ? { contentDisposition: observed.contentDisposition } : {},
+		...observed.cacheControl ? { cacheControl: observed.cacheControl } : {},
+		...modified ? { lastModified: modified } : {}
+	}).pipe(Effect.mapError(() => storageError(operation, "vercel", { _tag: "ProviderFailure" }, mutation ? "unknown" : "not-applicable")));
+});
+function providerError(operation, mutation, error) {
+	const overwriteRejected = mutation && error instanceof Blob.BlobError && error.message.startsWith("Vercel Blob: This blob already exists,");
+	const readStatus = error instanceof Blob.BlobError ? /^Vercel Blob: Failed to fetch blob: (\d{3}) /u.exec(error.message)?.[1] : void 0;
+	const reason = readStatus === "401" || readStatus === "403" ? { _tag: "AccessDenied" } : readStatus === "412" || overwriteRejected ? { _tag: "PreconditionFailed" } : readStatus === "416" ? { _tag: "RangeNotSatisfiable" } : error instanceof Blob.BlobStoreNotFoundError ? {
+		_tag: "InvalidConfiguration",
+		field: "store"
+	} : error instanceof Blob.BlobNotFoundError ? { _tag: "NotFound" } : error instanceof Blob.BlobAccessError || error instanceof Blob.BlobStoreSuspendedError ? { _tag: "AccessDenied" } : error instanceof Blob.BlobClientTokenExpiredError ? { _tag: "Expired" } : error instanceof Blob.BlobPreconditionFailedError ? { _tag: "PreconditionFailed" } : error instanceof Blob.BlobServiceRateLimited ? {
+		_tag: "Throttled",
+		retryAfterMillis: Math.max(0, error.retryAfter * 1e3)
+	} : error instanceof Blob.BlobContentTypeNotAllowedError || error instanceof Blob.BlobPathnameMismatchError || error instanceof Blob.BlobFileTooLargeError ? {
+		_tag: "InvalidInput",
+		field: "upload"
+	} : { _tag: "TransportFailure" };
+	const rejected = [
+		"NotFound",
+		"AccessDenied",
+		"Expired",
+		"PreconditionFailed",
+		"InvalidInput",
+		"Throttled"
+	].includes(reason._tag);
+	return storageError(operation, "vercel", reason, mutation ? rejected ? "rejected" : "unknown" : "not-applicable");
+}
+
+export { metadata, providerError, validateKey, writeOptions };
+//# sourceMappingURL=mapping.js.map

package/dist/providers/vercel/mapping.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapping.js","names":[],"sources":["../../../src/providers/vercel/mapping.ts"],"sourcesContent":["import { DateTime, Effect, Option, Schema } from \"effect\";\n\nimport * as Blob from \"@vercel/blob\";\n\nimport { storageError } from \"../../core/errors.js\";\nimport type { ObjectHeaders } from \"../../core/object.js\";\nimport { ObjectKey, ObjectMetadata } from \"../../core/object.js\";\nimport type { VercelConnection } from \"./config.js\";\n\nexport const validateKey = Effect.fnUntraced(function* (key: string, operation: string) {\n  yield* Schema.decodeUnknownEffect(ObjectKey)(key).pipe(\n    Effect.mapError(() =>\n      storageError(operation, \"vercel\", { _tag: \"InvalidInput\", field: \"key\" }, \"not-started\"),\n    ),\n  );\n  if (\n    key.startsWith(\"/\") ||\n    /^https?:/iu.test(key) ||\n    key.split(\"/\").some((part) => !part || part === \".\" || part === \"..\") ||\n    new TextEncoder().encode(key).length > 950\n  )\n    return yield* storageError(\n      operation,\n      \"vercel\",\n      { _tag: \"InvalidInput\", field: \"key\" },\n      \"not-started\",\n    );\n  return key;\n});\nexport const writeOptions = Effect.fnUntraced(function* (\n  headers: ObjectHeaders,\n  operation: string,\n) {\n  const metadata = Object.keys(headers.customMetadata ?? {}).filter(\n    (key) => key !== \"effect-storage-operation\",\n  );\n  if (\n    metadata.length ||\n    headers.contentDisposition ||\n    headers.contentLanguage ||\n    headers.contentEncoding ||\n    headers.cacheControl\n  )\n    return yield* storageError(\n      operation,\n      \"vercel\",\n      { _tag: \"Unsupported\", capability: \"object-headers\" },\n      \"not-started\",\n    );\n  return {\n    ...(headers.contentType ? { contentType: headers.contentType } : {}),\n    addRandomSuffix: false,\n  };\n});\nconst Observation = Schema.Struct({\n  pathname: Schema.String,\n  etag: Schema.optional(Schema.String),\n  size: Schema.optional(Schema.NullOr(Schema.Natural)),\n  contentType: Schema.optional(Schema.NullOr(Schema.String)),\n  contentDisposition: Schema.optional(Schema.String),\n  cacheControl: Schema.optional(Schema.String),\n});\nexport const metadata = Effect.fnUntraced(function* (\n  connection: VercelConnection,\n  value: unknown,\n  operation: string,\n  key?: string,\n  mutation = false,\n) {\n  const observed = yield* Schema.decodeUnknownEffect(Observation)(value).pipe(\n    Effect.mapError(() =>\n      storageError(\n        operation,\n        \"vercel\",\n        { _tag: \"ProviderFailure\" },\n        mutation ? \"unknown\" : \"not-applicable\",\n      ),\n    ),\n  );\n  if (key !== undefined && observed.pathname !== key)\n    return yield* storageError(\n      operation,\n      \"vercel\",\n      { _tag: \"IntegrityMismatch\" },\n      mutation ? \"unknown\" : \"not-applicable\",\n    );\n  const uploadedAt =\n    value !== null && typeof value === \"object\" ? Reflect.get(value, \"uploadedAt\") : undefined;\n  const modified =\n    uploadedAt instanceof Date ? Option.getOrUndefined(DateTime.make(uploadedAt)) : undefined;\n  return yield* Schema.decodeUnknownEffect(Schema.toType(ObjectMetadata))({\n    ref: {\n      storeId: `vercel:${connection.config.access}:${connection.config.storeId}`,\n      key: observed.pathname,\n    },\n    ...(observed.size !== undefined && observed.size !== null ? { size: observed.size } : {}),\n    ...(observed.etag ? { etag: observed.etag } : {}),\n    ...(observed.contentType ? { contentType: observed.contentType } : {}),\n    ...(observed.contentDisposition ? { contentDisposition: observed.contentDisposition } : {}),\n    ...(observed.cacheControl ? { cacheControl: observed.cacheControl } : {}),\n    ...(modified ? { lastModified: modified } : {}),\n  }).pipe(\n    Effect.mapError(() =>\n      storageError(\n        operation,\n        \"vercel\",\n        { _tag: \"ProviderFailure\" },\n        mutation ? \"unknown\" : \"not-applicable\",\n      ),\n    ),\n  );\n});\nexport function providerError(operation: string, mutation: boolean, error: unknown) {\n  // The SDK exposes create-only collisions as generic bad_request errors, without a typed code.\n  const overwriteRejected =\n    mutation &&\n    error instanceof Blob.BlobError &&\n    error.message.startsWith(\"Vercel Blob: This blob already exists,\");\n  const readStatus =\n    error instanceof Blob.BlobError\n      ? /^Vercel Blob: Failed to fetch blob: (\\d{3}) /u.exec(error.message)?.[1]\n      : undefined;\n  const reason =\n    readStatus === \"401\" || readStatus === \"403\"\n      ? { _tag: \"AccessDenied\" as const }\n      : readStatus === \"412\" || overwriteRejected\n        ? { _tag: \"PreconditionFailed\" as const }\n        : readStatus === \"416\"\n          ? { _tag: \"RangeNotSatisfiable\" as const }\n          : error instanceof Blob.BlobStoreNotFoundError\n            ? { _tag: \"InvalidConfiguration\" as const, field: \"store\" }\n            : error instanceof Blob.BlobNotFoundError\n              ? { _tag: \"NotFound\" as const }\n              : error instanceof Blob.BlobAccessError ||\n                  error instanceof Blob.BlobStoreSuspendedError\n                ? { _tag: \"AccessDenied\" as const }\n                : error instanceof Blob.BlobClientTokenExpiredError\n                  ? { _tag: \"Expired\" as const }\n                  : error instanceof Blob.BlobPreconditionFailedError\n                    ? { _tag: \"PreconditionFailed\" as const }\n                    : error instanceof Blob.BlobServiceRateLimited\n                      ? {\n                          _tag: \"Throttled\" as const,\n                          retryAfterMillis: Math.max(0, error.retryAfter * 1000),\n                        }\n                      : error instanceof Blob.BlobContentTypeNotAllowedError ||\n                          error instanceof Blob.BlobPathnameMismatchError ||\n                          error instanceof Blob.BlobFileTooLargeError\n                        ? { _tag: \"InvalidInput\" as const, field: \"upload\" }\n                        : { _tag: \"TransportFailure\" as const };\n  const rejected = [\n    \"NotFound\",\n    \"AccessDenied\",\n    \"Expired\",\n    \"PreconditionFailed\",\n    \"InvalidInput\",\n    \"Throttled\",\n  ].includes(reason._tag);\n  return storageError(\n    operation,\n    \"vercel\",\n    reason,\n    mutation ? (rejected ? \"rejected\" : \"unknown\") : \"not-applicable\",\n  );\n}\n"],"mappings":"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"}

package/dist/providers/vercel/multipart.js

@@ -0,0 +1,113 @@
+import { ObjectRef } from "../../core/object.js";
+import { storageError } from "../../core/errors.js";
+import { webUploadBody } from "../../internal/web-upload-body.js";
+import { metadata, validateKey, writeOptions } from "./mapping.js";
+import { call } from "./transport.js";
+import { Effect, Redacted, Schema } from "effect";
+import * as Blob from "@vercel/blob";
+
+// src/providers/vercel/multipart.ts
+const Handle = Schema.Struct({
+	key: Schema.String,
+	uploadId: Schema.String
+});
+function multipart(connection) {
+	const decode = Effect.fnUntraced(function* (upload) {
+		yield* Schema.decodeUnknownEffect(Schema.Struct({
+			ref: ObjectRef,
+			uploadId: Schema.Redacted(Schema.String)
+		}))(upload).pipe(Effect.mapError(() => storageError("multipart", "vercel", { _tag: "InvalidSession" })));
+		if (upload.ref.storeId !== `vercel:${connection.config.access}:${connection.config.storeId}` || upload.ref.version) return yield* storageError("multipart", "vercel", { _tag: "InvalidSession" });
+		yield* validateKey(upload.ref.key, "multipart");
+		return yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Handle))(Redacted.value(upload.uploadId)).pipe(Effect.mapError(() => storageError("multipart", "vercel", { _tag: "InvalidSession" })));
+	});
+	return {
+		limits: {
+			minimumPartBytes: 5 * 1024 ** 2,
+			maximumPartBytes: 256 * 1024 ** 2,
+			maximumParts: 1e4,
+			completeConditions: []
+		},
+		initiate: Effect.fnUntraced(function* (input) {
+			yield* validateKey(input.key, "initiate");
+			const headers = yield* writeOptions(input.headers ?? {}, "initiate");
+			const result = yield* call(connection, "initiate", true, (options) => Blob.createMultipartUpload(input.key, {
+				...options,
+				...headers,
+				access: connection.config.access,
+				allowOverwrite: true
+			}));
+			yield* Schema.decodeUnknownEffect(Handle)(result).pipe(Effect.mapError(() => storageError("initiate", "vercel", { _tag: "ProviderFailure" }, "unknown")));
+			return {
+				ref: {
+					storeId: `vercel:${connection.config.access}:${connection.config.storeId}`,
+					key: input.key
+				},
+				uploadId: Redacted.make(JSON.stringify(result))
+			};
+		}),
+		uploadPart: Effect.fnUntraced(function* (input) {
+			const handle = yield* decode(input.upload);
+			if (!Number.isSafeInteger(input.partNumber) || input.partNumber < 1 || input.partNumber > 1e4) return yield* storageError("part", "vercel", {
+				_tag: "InvalidInput",
+				field: "partNumber"
+			}, "not-started");
+			return yield* webUploadBody("vercel", {
+				body: input.body,
+				...input.contentLength !== void 0 ? { contentLength: input.contentLength } : {},
+				maxBytes: 256 * 1024 ** 2
+			}, connection.config.maxUnknownLengthBytes, (body, length) => call(connection, "part", true, (options) => Blob.uploadPart(input.upload.ref.key, body instanceof Uint8Array ? new ReadableStream({ start(controller) {
+				controller.enqueue(body);
+				controller.close();
+			} }) : body, {
+				...options,
+				...handle,
+				access: connection.config.access,
+				partNumber: input.partNumber
+			})).pipe(Effect.map((part) => ({
+				...part,
+				size: length
+			}))));
+		}),
+		complete: Effect.fnUntraced(function* (input) {
+			if (input.condition) return yield* storageError("complete", "vercel", {
+				_tag: "Unsupported",
+				capability: "conditional-multipart-completion"
+			}, "not-started");
+			const handle = yield* decode(input.upload);
+			yield* Schema.decodeUnknownEffect(Schema.Array(Schema.Struct({
+				partNumber: Schema.Int.check(Schema.isBetween({
+					minimum: 1,
+					maximum: 1e4
+				})),
+				etag: Schema.NonEmptyString,
+				size: Schema.optional(Schema.Natural)
+			})).check(Schema.isMaxLength(1e4)))(input.parts).pipe(Effect.mapError(() => storageError("complete", "vercel", {
+				_tag: "InvalidInput",
+				field: "parts"
+			}, "not-started")));
+			if (input.parts.length === 0 || input.parts.some((part, index) => part.partNumber !== index + 1)) return yield* storageError("complete", "vercel", {
+				_tag: "InvalidInput",
+				field: "parts"
+			}, "not-started");
+			return yield* call(connection, "complete", true, (options) => Blob.completeMultipartUpload(input.upload.ref.key, [...input.parts], {
+				...options,
+				...handle,
+				access: connection.config.access,
+				addRandomSuffix: false,
+				allowOverwrite: true
+			})).pipe(Effect.flatMap((result) => metadata(connection, result, "complete", input.upload.ref.key, true)));
+		}),
+		listParts: () => Effect.fail(storageError("listParts", "vercel", {
+			_tag: "Unsupported",
+			capability: "multipart-inventory"
+		})),
+		abort: () => Effect.fail(storageError("abort", "vercel", {
+			_tag: "Unsupported",
+			capability: "remote-multipart-abort"
+		}))
+	};
+}
+
+export { multipart };
+//# sourceMappingURL=multipart.js.map

package/dist/providers/vercel/multipart.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"multipart.js","names":[],"sources":["../../../src/providers/vercel/multipart.ts"],"sourcesContent":["import { Effect, Redacted, Schema } from \"effect\";\n\nimport * as Blob from \"@vercel/blob\";\n\nimport type { MultipartHandle, MultipartUploads } from \"../../core/contracts/multipart.js\";\nimport { storageError } from \"../../core/errors.js\";\nimport { ObjectRef } from \"../../core/object.js\";\nimport { webUploadBody } from \"../../internal/web-upload-body.js\";\nimport type { VercelConnection } from \"./config.js\";\nimport { metadata, validateKey, writeOptions } from \"./mapping.js\";\nimport { call } from \"./transport.js\";\n\nconst Handle = Schema.Struct({ key: Schema.String, uploadId: Schema.String });\nexport function multipart(connection: VercelConnection): MultipartUploads {\n  const decode = Effect.fnUntraced(function* (upload: MultipartHandle) {\n    yield* Schema.decodeUnknownEffect(\n      Schema.Struct({ ref: ObjectRef, uploadId: Schema.Redacted(Schema.String) }),\n    )(upload).pipe(\n      Effect.mapError(() => storageError(\"multipart\", \"vercel\", { _tag: \"InvalidSession\" })),\n    );\n    if (\n      upload.ref.storeId !== `vercel:${connection.config.access}:${connection.config.storeId}` ||\n      upload.ref.version\n    )\n      return yield* storageError(\"multipart\", \"vercel\", { _tag: \"InvalidSession\" });\n    yield* validateKey(upload.ref.key, \"multipart\");\n    return yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Handle))(\n      Redacted.value(upload.uploadId),\n    ).pipe(Effect.mapError(() => storageError(\"multipart\", \"vercel\", { _tag: \"InvalidSession\" })));\n  });\n  return {\n    limits: {\n      minimumPartBytes: 5 * 1024 ** 2,\n      maximumPartBytes: 256 * 1024 ** 2,\n      maximumParts: 10000,\n      completeConditions: [],\n    },\n    initiate: Effect.fnUntraced(function* (input) {\n      yield* validateKey(input.key, \"initiate\");\n      const headers = yield* writeOptions(input.headers ?? {}, \"initiate\");\n      const result = yield* call(connection, \"initiate\", true, (options) =>\n        Blob.createMultipartUpload(input.key, {\n          ...options,\n          ...headers,\n          access: connection.config.access,\n          allowOverwrite: true,\n        }),\n      );\n      yield* Schema.decodeUnknownEffect(Handle)(result).pipe(\n        Effect.mapError(() =>\n          storageError(\"initiate\", \"vercel\", { _tag: \"ProviderFailure\" }, \"unknown\"),\n        ),\n      );\n      return {\n        ref: {\n          storeId: `vercel:${connection.config.access}:${connection.config.storeId}`,\n          key: input.key,\n        },\n        uploadId: Redacted.make(JSON.stringify(result)),\n      };\n    }),\n    uploadPart: Effect.fnUntraced(function* (input) {\n      const handle = yield* decode(input.upload);\n      if (\n        !Number.isSafeInteger(input.partNumber) ||\n        input.partNumber < 1 ||\n        input.partNumber > 10000\n      )\n        return yield* storageError(\n          \"part\",\n          \"vercel\",\n          { _tag: \"InvalidInput\", field: \"partNumber\" },\n          \"not-started\",\n        );\n      return yield* webUploadBody(\n        \"vercel\",\n        {\n          body: input.body,\n          ...(input.contentLength !== undefined ? { contentLength: input.contentLength } : {}),\n          maxBytes: 256 * 1024 ** 2,\n        },\n        connection.config.maxUnknownLengthBytes,\n        (body, length) =>\n          call(connection, \"part\", true, (options) =>\n            Blob.uploadPart(\n              input.upload.ref.key,\n              body instanceof Uint8Array\n                ? new ReadableStream({\n                    start(controller) {\n                      controller.enqueue(body);\n                      controller.close();\n                    },\n                  })\n                : body,\n              {\n                ...options,\n                ...handle,\n                access: connection.config.access,\n                partNumber: input.partNumber,\n              },\n            ),\n          ).pipe(Effect.map((part) => ({ ...part, size: length }))),\n      );\n    }),\n    complete: Effect.fnUntraced(function* (input) {\n      if (input.condition)\n        return yield* storageError(\n          \"complete\",\n          \"vercel\",\n          { _tag: \"Unsupported\", capability: \"conditional-multipart-completion\" },\n          \"not-started\",\n        );\n      const handle = yield* decode(input.upload);\n      yield* Schema.decodeUnknownEffect(\n        Schema.Array(\n          Schema.Struct({\n            partNumber: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 10000 })),\n            etag: Schema.NonEmptyString,\n            size: Schema.optional(Schema.Natural),\n          }),\n        ).check(Schema.isMaxLength(10000)),\n      )(input.parts).pipe(\n        Effect.mapError(() =>\n          storageError(\n            \"complete\",\n            \"vercel\",\n            { _tag: \"InvalidInput\", field: \"parts\" },\n            \"not-started\",\n          ),\n        ),\n      );\n      if (\n        input.parts.length === 0 ||\n        input.parts.some((part, index) => part.partNumber !== index + 1)\n      )\n        return yield* storageError(\n          \"complete\",\n          \"vercel\",\n          { _tag: \"InvalidInput\", field: \"parts\" },\n          \"not-started\",\n        );\n      return yield* call(connection, \"complete\", true, (options) =>\n        Blob.completeMultipartUpload(input.upload.ref.key, [...input.parts], {\n          ...options,\n          ...handle,\n          access: connection.config.access,\n          addRandomSuffix: false,\n          allowOverwrite: true,\n        }),\n      ).pipe(\n        Effect.flatMap((result) =>\n          metadata(connection, result, \"complete\", input.upload.ref.key, true),\n        ),\n      );\n    }),\n    listParts: () =>\n      Effect.fail(\n        storageError(\"listParts\", \"vercel\", {\n          _tag: \"Unsupported\",\n          capability: \"multipart-inventory\",\n        }),\n      ),\n    abort: () =>\n      Effect.fail(\n        storageError(\"abort\", \"vercel\", {\n          _tag: \"Unsupported\",\n          capability: \"remote-multipart-abort\",\n        }),\n      ),\n  };\n}\n"],"mappings":"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"}