@effect-kit/storage 0.0.0-stage → 0.1.0

package/dist/vercel/uploads.d.ts

@@ -0,0 +1,36 @@
+import { ObjectMetadata } from "../core/object.js";
+import { StorageError } from "../core/errors.js";
+import "../index.js";
+import { VercelStorage } from "../vercel.js";
+import { Effect, Schema } from "effect";
+import { KeyValueStore } from "effect/persistence";
+declare const Authorization: Schema.Struct<{
+  readonly maximumSizeInBytes: Schema.Int;
+  readonly allowedContentTypes: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+  readonly allowOverwrite: Schema.optionalKey<Schema.Boolean>;
+  readonly tokenPayload: Schema.optionalKey<Schema.String>;
+}>;
+export interface VercelUploadHandlerOptions<E, R> {
+  readonly namespace: string;
+  readonly ownership: "exclusive";
+  readonly callbackUrl: string;
+  readonly expiresInSeconds?: number;
+  readonly authorize: (input: {
+    readonly request: Request;
+    readonly key: string;
+    readonly clientPayload: string | null;
+    readonly multipart: boolean;
+  }) => Effect.Effect<typeof Authorization.Type, E, R>;
+  /** Use idempotencyKey in the application's transaction: a crash before receipt persistence can redeliver. */
+  readonly onObserved: (event: {
+    readonly idempotencyKey: string;
+    readonly metadata: ObjectMetadata;
+    readonly tokenPayload: string | null;
+  }) => Effect.Effect<void, E, R>;
+}
+/** Creates an HTTP runtime boundary. The owning Effect scope must outlive the returned handler. */
+export declare const VercelUploadHandler: {
+  make: <E, R>(options: VercelUploadHandlerOptions<E, R>) => Effect.Effect<(request: Request) => Promise<Response>, StorageError, R | KeyValueStore.KeyValueStore | VercelStorage>;
+};
+export {};
+//# sourceMappingURL=uploads.d.ts.map

package/dist/vercel/uploads.js

@@ -0,0 +1,161 @@
+import { storageError } from "../core/errors.js";
+import { validateKey } from "../providers/vercel/mapping.js";
+import { VercelStorage } from "../vercel.js";
+import { Clock, Effect, Redacted, Schema, Semaphore } from "effect";
+import { KeyValueStore } from "effect/persistence";
+import { handleUpload } from "@vercel/blob/client";
+
+// src/providers/vercel/uploads.ts
+const Event = Schema.Union([Schema.Struct({
+	type: Schema.Literal("blob.generate-client-token"),
+	payload: Schema.Struct({
+		pathname: Schema.String,
+		clientPayload: Schema.NullOr(Schema.String),
+		multipart: Schema.Boolean
+	})
+}), Schema.Struct({
+	type: Schema.Literal("blob.upload-completed"),
+	payload: Schema.Struct({
+		blob: Schema.Struct({
+			url: Schema.String,
+			downloadUrl: Schema.String,
+			pathname: Schema.String,
+			contentType: Schema.String,
+			contentDisposition: Schema.String,
+			etag: Schema.String
+		}),
+		tokenPayload: Schema.optionalKey(Schema.NullOr(Schema.String))
+	})
+})]);
+const Authorization = Schema.Struct({
+	maximumSizeInBytes: Schema.Int.check(Schema.isGreaterThan(0)),
+	allowedContentTypes: Schema.optionalKey(Schema.Array(Schema.NonEmptyString).check(Schema.isMinLength(1))),
+	allowOverwrite: Schema.optionalKey(Schema.Boolean),
+	tokenPayload: Schema.optionalKey(Schema.String)
+});
+const readEvent = Effect.fnUntraced(function* (request) {
+	const bytes = yield* Effect.tryPromise({
+		try: async () => {
+			const reader = request.body?.getReader();
+			if (!reader) throw new Error("Missing body");
+			const chunks = [];
+			let size = 0;
+			try {
+				while (true) {
+					const next = await reader.read();
+					if (next.done) break;
+					size += next.value.length;
+					if (size > 65536) throw new Error("Body limit");
+					chunks.push(next.value);
+				}
+			} finally {
+				await reader.cancel().catch(() => void 0);
+				reader.releaseLock();
+			}
+			const joined = new Uint8Array(size);
+			let offset = 0;
+			for (const chunk of chunks) {
+				joined.set(chunk, offset);
+				offset += chunk.length;
+			}
+			return joined;
+		},
+		catch: () => storageError("upload.handler", "vercel", {
+			_tag: "InvalidInput",
+			field: "body"
+		})
+	});
+	const parsed = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown))(new TextDecoder().decode(bytes)).pipe(Effect.mapError(() => storageError("upload.handler", "vercel", {
+		_tag: "InvalidInput",
+		field: "body"
+	})));
+	yield* Schema.decodeUnknownEffect(Event)(parsed).pipe(Effect.mapError(() => storageError("upload.handler", "vercel", {
+		_tag: "InvalidInput",
+		field: "body"
+	})));
+	return parsed;
+});
+/** Creates an HTTP runtime boundary. The owning Effect scope must outlive the returned handler. */
+const VercelUploadHandler = { make: Effect.fnUntraced(function* (options) {
+	const storage = yield* VercelStorage;
+	const receipts = yield* KeyValueStore.KeyValueStore;
+	const context = yield* Effect.context();
+	const lock = yield* Semaphore.make(1);
+	const callback = URL.parse(options.callbackUrl);
+	const lifetime = options.expiresInSeconds ?? 3600;
+	if (options.ownership !== "exclusive" || !options.namespace || !callback || !["https:", "http:"].includes(callback.protocol) || callback.username || callback.password || callback.hash || !Number.isSafeInteger(lifetime) || lifetime < 1 || lifetime > 604800 || storage.config.credential.mode !== "token") return yield* storageError("upload.handler", "vercel", {
+		_tag: "InvalidConfiguration",
+		field: "options-or-token-authority"
+	});
+	const execute = Effect.runPromiseWith(context);
+	const run = (program, runOptions) => execute(Effect.scoped(program), runOptions);
+	const authorizeGrant = Effect.fnUntraced(function* (request, key, clientPayload, multipart) {
+		yield* validateKey(key, "grant");
+		const authorized = yield* options.authorize({
+			request,
+			key,
+			clientPayload,
+			multipart
+		}).pipe(Effect.flatMap(Schema.decodeUnknownEffect(Authorization)), Effect.mapError(() => storageError("grant", "vercel", { _tag: "AccessDenied" })));
+		if (authorized.maximumSizeInBytes > storage.config.maxObjectBytes) return yield* storageError("grant", "vercel", {
+			_tag: "LimitExceeded",
+			limit: storage.config.maxObjectBytes
+		});
+		const now = yield* Clock.currentTimeMillis;
+		return {
+			maximumSizeInBytes: authorized.maximumSizeInBytes,
+			...authorized.allowedContentTypes ? { allowedContentTypes: [...authorized.allowedContentTypes] } : {},
+			...authorized.allowOverwrite === void 0 ? {} : { allowOverwrite: authorized.allowOverwrite },
+			tokenPayload: authorized.tokenPayload ?? "",
+			addRandomSuffix: false,
+			callbackUrl: callback.href,
+			validUntil: now + lifetime * 1e3
+		};
+	});
+	const observeCompletion = Effect.fnUntraced(function* ({ blob, tokenPayload }) {
+		yield* validateKey(blob.pathname, "callback");
+		const metadata = yield* storage.head({ key: blob.pathname });
+		if (!metadata.etag || metadata.etag !== blob.etag) return yield* storageError("callback", "vercel", { _tag: "PreconditionFailed" });
+		const idempotencyKey = JSON.stringify([
+			storage.storeId,
+			blob.pathname,
+			blob.etag
+		]);
+		const receiptKey = `${options.namespace}:${encodeURIComponent(idempotencyKey)}`;
+		if (yield* receipts.has(receiptKey)) return;
+		yield* options.onObserved({
+			idempotencyKey,
+			metadata,
+			tokenPayload: tokenPayload ?? null
+		});
+		yield* receipts.set(receiptKey, "delivered");
+	});
+	const handle = Effect.fnUntraced(function* (request) {
+		if (request.method !== "POST") return new Response(null, {
+			status: 405,
+			headers: { allow: "POST" }
+		});
+		const body = yield* readEvent(request);
+		const credential = storage.config.credential.token;
+		const token = yield* Effect.isEffect(credential) ? credential : Effect.succeed(credential);
+		if (!Redacted.isRedacted(token) || Redacted.value(token).split("_")[3] !== storage.config.storeId) return yield* storageError("upload.handler", "vercel", { _tag: "AccessDenied" });
+		let callbackFailed = false;
+		const result = yield* Effect.tryPromise({
+			try: (signal) => handleUpload({
+				request,
+				body,
+				token: Redacted.value(token),
+				onBeforeGenerateToken: (key, clientPayload, multipart) => run(authorizeGrant(request, key, clientPayload, multipart), { signal }),
+				onUploadCompleted: (completion) => run(lock.withPermits(1)(observeCompletion(completion)).pipe(Effect.tapError(() => Effect.sync(() => {
+					callbackFailed = true;
+				}))), { signal })
+			}),
+			catch: () => storageError("upload.handler", "vercel", { _tag: callbackFailed ? "ProviderFailure" : "AccessDenied" })
+		});
+		return Response.json(result);
+	});
+	return (request) => run(handle(request).pipe(Effect.catch((error) => Effect.succeed(Response.json({ error: error.reason._tag }, { status: error.reason._tag === "InvalidInput" ? 400 : error.reason._tag === "AccessDenied" ? 403 : 500 })))), { signal: request.signal });
+}) };
+
+export { VercelUploadHandler };
+//# sourceMappingURL=uploads.js.map

package/dist/vercel/uploads.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploads.js","names":[],"sources":["../../src/providers/vercel/uploads.ts"],"sourcesContent":["import { Clock, Effect, Redacted, Schema, Semaphore } from \"effect\";\nimport { KeyValueStore } from \"effect/persistence\";\n\nimport { handleUpload } from \"@vercel/blob/client\";\n\nimport { storageError } from \"../../core/errors.js\";\nimport type { ObjectMetadata } from \"../../core/object.js\";\nimport { VercelStorage } from \"./index.js\";\nimport { validateKey } from \"./mapping.js\";\n\nconst Event = Schema.Union([\n  Schema.Struct({\n    type: Schema.Literal(\"blob.generate-client-token\"),\n    payload: Schema.Struct({\n      pathname: Schema.String,\n      clientPayload: Schema.NullOr(Schema.String),\n      multipart: Schema.Boolean,\n    }),\n  }),\n  Schema.Struct({\n    type: Schema.Literal(\"blob.upload-completed\"),\n    payload: Schema.Struct({\n      blob: Schema.Struct({\n        url: Schema.String,\n        downloadUrl: Schema.String,\n        pathname: Schema.String,\n        contentType: Schema.String,\n        contentDisposition: Schema.String,\n        etag: Schema.String,\n      }),\n      tokenPayload: Schema.optionalKey(Schema.NullOr(Schema.String)),\n    }),\n  }),\n]);\nconst Authorization = Schema.Struct({\n  maximumSizeInBytes: Schema.Int.check(Schema.isGreaterThan(0)),\n  allowedContentTypes: Schema.optionalKey(\n    Schema.Array(Schema.NonEmptyString).check(Schema.isMinLength(1)),\n  ),\n  allowOverwrite: Schema.optionalKey(Schema.Boolean),\n  tokenPayload: Schema.optionalKey(Schema.String),\n});\nexport interface VercelUploadHandlerOptions<E, R> {\n  readonly namespace: string;\n  readonly ownership: \"exclusive\";\n  readonly callbackUrl: string;\n  readonly expiresInSeconds?: number;\n  readonly authorize: (input: {\n    readonly request: Request;\n    readonly key: string;\n    readonly clientPayload: string | null;\n    readonly multipart: boolean;\n  }) => Effect.Effect<typeof Authorization.Type, E, R>;\n  /** Use idempotencyKey in the application's transaction: a crash before receipt persistence can redeliver. */\n  readonly onObserved: (event: {\n    readonly idempotencyKey: string;\n    readonly metadata: ObjectMetadata;\n    readonly tokenPayload: string | null;\n  }) => Effect.Effect<void, E, R>;\n}\n\nconst readEvent = Effect.fnUntraced(function* (request: Request) {\n  const bytes = yield* Effect.tryPromise({\n    try: async () => {\n      const reader = request.body?.getReader();\n      if (!reader) throw new Error(\"Missing body\");\n      const chunks: Uint8Array[] = [];\n      let size = 0;\n      try {\n        while (true) {\n          // oxlint-disable-next-line no-await-in-loop -- Request chunks must be read sequentially under the body limit.\n          const next = await reader.read();\n          if (next.done) break;\n          size += next.value.length;\n          if (size > 65536) throw new Error(\"Body limit\");\n          chunks.push(next.value);\n        }\n      } finally {\n        await reader.cancel().catch(() => undefined);\n        reader.releaseLock();\n      }\n      const joined = new Uint8Array(size);\n      let offset = 0;\n      for (const chunk of chunks) {\n        joined.set(chunk, offset);\n        offset += chunk.length;\n      }\n      return joined;\n    },\n    catch: () => storageError(\"upload.handler\", \"vercel\", { _tag: \"InvalidInput\", field: \"body\" }),\n  });\n  // Preserve the parsed JSON property order: the SDK verifies JSON.stringify(body).\n  const parsed = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown))(\n    new TextDecoder().decode(bytes),\n  ).pipe(\n    Effect.mapError(() =>\n      storageError(\"upload.handler\", \"vercel\", { _tag: \"InvalidInput\", field: \"body\" }),\n    ),\n  );\n  yield* Schema.decodeUnknownEffect(Event)(parsed).pipe(\n    Effect.mapError(() =>\n      storageError(\"upload.handler\", \"vercel\", { _tag: \"InvalidInput\", field: \"body\" }),\n    ),\n  );\n  return parsed as typeof Event.Type;\n});\n\n/** Creates an HTTP runtime boundary. The owning Effect scope must outlive the returned handler. */\nexport const VercelUploadHandler = {\n  make: Effect.fnUntraced(function* <E, R>(options: VercelUploadHandlerOptions<E, R>) {\n    const storage = yield* VercelStorage;\n    const receipts = yield* KeyValueStore.KeyValueStore;\n    const context = yield* Effect.context<R>();\n    const lock = yield* Semaphore.make(1);\n    const callback = URL.parse(options.callbackUrl);\n    const lifetime = options.expiresInSeconds ?? 3600;\n    if (\n      options.ownership !== \"exclusive\" ||\n      !options.namespace ||\n      !callback ||\n      ![\"https:\", \"http:\"].includes(callback.protocol) ||\n      callback.username ||\n      callback.password ||\n      callback.hash ||\n      !Number.isSafeInteger(lifetime) ||\n      lifetime < 1 ||\n      lifetime > 604800 ||\n      storage.config.credential.mode !== \"token\"\n    )\n      return yield* storageError(\"upload.handler\", \"vercel\", {\n        _tag: \"InvalidConfiguration\",\n        field: \"options-or-token-authority\",\n      });\n\n    const execute = Effect.runPromiseWith(context);\n    const run: typeof execute = (program, runOptions) =>\n      execute(Effect.scoped(program), runOptions);\n    const authorizeGrant = Effect.fnUntraced(function* (\n      request: Request,\n      key: string,\n      clientPayload: string | null,\n      multipart: boolean,\n    ) {\n      yield* validateKey(key, \"grant\");\n      const authorized = yield* options.authorize({ request, key, clientPayload, multipart }).pipe(\n        Effect.flatMap(Schema.decodeUnknownEffect(Authorization)),\n        Effect.mapError(() => storageError(\"grant\", \"vercel\", { _tag: \"AccessDenied\" })),\n      );\n      if (authorized.maximumSizeInBytes > storage.config.maxObjectBytes)\n        return yield* storageError(\"grant\", \"vercel\", {\n          _tag: \"LimitExceeded\",\n          limit: storage.config.maxObjectBytes,\n        });\n      const now = yield* Clock.currentTimeMillis;\n      return {\n        maximumSizeInBytes: authorized.maximumSizeInBytes,\n        ...(authorized.allowedContentTypes\n          ? { allowedContentTypes: [...authorized.allowedContentTypes] }\n          : {}),\n        ...(authorized.allowOverwrite === undefined\n          ? {}\n          : { allowOverwrite: authorized.allowOverwrite }),\n        // Avoid the SDK's fallback to untrusted clientPayload when no server payload is supplied.\n        tokenPayload: authorized.tokenPayload ?? \"\",\n        addRandomSuffix: false,\n        callbackUrl: callback.href,\n        validUntil: now + lifetime * 1000,\n      };\n    });\n    type Completion = Extract<typeof Event.Type, { type: \"blob.upload-completed\" }>[\"payload\"];\n    const observeCompletion = Effect.fnUntraced(function* ({ blob, tokenPayload }: Completion) {\n      yield* validateKey(blob.pathname, \"callback\");\n      const metadata = yield* storage.head({ key: blob.pathname });\n      if (!metadata.etag || metadata.etag !== blob.etag)\n        return yield* storageError(\"callback\", \"vercel\", { _tag: \"PreconditionFailed\" });\n      const idempotencyKey = JSON.stringify([storage.storeId, blob.pathname, blob.etag]);\n      const receiptKey = `${options.namespace}:${encodeURIComponent(idempotencyKey)}`;\n      if (yield* receipts.has(receiptKey)) return;\n\n      yield* options.onObserved({ idempotencyKey, metadata, tokenPayload: tokenPayload ?? null });\n      yield* receipts.set(receiptKey, \"delivered\");\n    });\n    const handle = Effect.fnUntraced(function* (request: Request) {\n      if (request.method !== \"POST\")\n        return new Response(null, { status: 405, headers: { allow: \"POST\" } });\n      const body = yield* readEvent(request);\n      const credential = storage.config.credential.token;\n      const token = yield* Effect.isEffect(credential) ? credential : Effect.succeed(credential);\n      if (\n        !Redacted.isRedacted(token) ||\n        Redacted.value(token).split(\"_\")[3] !== storage.config.storeId\n      )\n        return yield* storageError(\"upload.handler\", \"vercel\", { _tag: \"AccessDenied\" });\n\n      let callbackFailed = false;\n      const result = yield* Effect.tryPromise({\n        try: (signal) =>\n          handleUpload({\n            request,\n            body,\n            token: Redacted.value(token),\n            onBeforeGenerateToken: (key, clientPayload, multipart) =>\n              run(authorizeGrant(request, key, clientPayload, multipart), { signal }),\n            // The SDK authenticates the callback signature before invoking this effect.\n            onUploadCompleted: (completion) =>\n              run(\n                lock\n                  .withPermits(1)(observeCompletion(completion))\n                  .pipe(\n                    Effect.tapError(() =>\n                      Effect.sync(() => {\n                        callbackFailed = true;\n                      }),\n                    ),\n                  ),\n                { signal },\n              ),\n          }),\n        catch: () =>\n          storageError(\"upload.handler\", \"vercel\", {\n            _tag: callbackFailed ? \"ProviderFailure\" : \"AccessDenied\",\n          }),\n      });\n      return Response.json(result);\n    });\n    return (request: Request): Promise<Response> =>\n      run(\n        handle(request).pipe(\n          Effect.catch((error) =>\n            Effect.succeed(\n              Response.json(\n                { error: error.reason._tag },\n                {\n                  status:\n                    error.reason._tag === \"InvalidInput\"\n                      ? 400\n                      : error.reason._tag === \"AccessDenied\"\n                        ? 403\n                        : 500,\n                },\n              ),\n            ),\n          ),\n        ),\n        { signal: request.signal },\n      );\n  }),\n};\n"],"mappings":"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"}

package/dist/vercel.d.ts

@@ -0,0 +1,86 @@
+import { ObjectMetadata } from "./core/object.js";
+import { StorageError } from "./core/errors.js";
+import { DeleteRequest, GetRequest, GetResult, HeadRequest, ListPage, ListRequest, PutRequest } from "./core/requests.js";
+import { StorageCapabilities, StoragePublicUrls } from "./core/capabilities.js";
+import { Storage } from "./core/storage.js";
+import { MultipartUploads } from "./core/contracts/multipart.js";
+import "./index.js";
+import { TransferDriver } from "./transfers/dependencies.js";
+import { VercelConfig } from "./providers/vercel/config.js";
+import { Context, Effect, Layer } from "effect";
+declare const make: (input: VercelConfig) => Effect.Effect<{
+  provider: string;
+  storeId: string;
+  capabilities: StorageCapabilities;
+  put: <E = never, R = never>(request: PutRequest<E, R>) => Effect.Effect<ObjectMetadata, StorageError | E, R>;
+  get: (request: GetRequest) => Effect.Effect<GetResult, StorageError, import("effect/Scope").Scope>;
+  head: (request: HeadRequest) => Effect.Effect<ObjectMetadata, StorageError>;
+  delete: (request: DeleteRequest) => Effect.Effect<void, StorageError>;
+  listPage: (request?: ListRequest) => Effect.Effect<ListPage, StorageError>;
+  config: {
+    access: "public" | "private";
+    credential: {
+      readonly mode: "token" | "oidc";
+      readonly token: Effect.Effect<import("effect/Redacted").Redacted<string>, StorageError, never> | import("effect/Redacted").Redacted<string>;
+    };
+    apiOrigin: string | undefined;
+    storeId: string;
+    maxObjectBytes: number;
+    maxUnknownLengthBytes: number;
+    requestTimeoutMillis: number;
+  };
+  multipart: MultipartUploads;
+}, StorageError, never>;
+export type VercelStorageService = Effect.Success<ReturnType<typeof make>>;
+declare const VercelStorage_base: Context.ServiceClass<VercelStorage, "@effect-kit/storage/vercel/VercelStorage", {
+  provider: string;
+  storeId: string;
+  capabilities: StorageCapabilities;
+  put: <E = never, R = never>(request: PutRequest<E, R>) => Effect.Effect<ObjectMetadata, StorageError | E, R>;
+  get: (request: GetRequest) => Effect.Effect<GetResult, StorageError, import("effect/Scope").Scope>;
+  head: (request: HeadRequest) => Effect.Effect<ObjectMetadata, StorageError>;
+  delete: (request: DeleteRequest) => Effect.Effect<void, StorageError>;
+  listPage: (request?: ListRequest) => Effect.Effect<ListPage, StorageError>;
+  config: {
+    access: "public" | "private";
+    credential: {
+      readonly mode: "token" | "oidc";
+      readonly token: Effect.Effect<import("effect/Redacted").Redacted<string>, StorageError, never> | import("effect/Redacted").Redacted<string>;
+    };
+    apiOrigin: string | undefined;
+    storeId: string;
+    maxObjectBytes: number;
+    maxUnknownLengthBytes: number;
+    requestTimeoutMillis: number;
+  };
+  multipart: MultipartUploads;
+}>;
+export declare class VercelStorage extends VercelStorage_base {
+  static readonly make: (input: VercelConfig) => Effect.Effect<{
+    provider: string;
+    storeId: string;
+    capabilities: StorageCapabilities;
+    put: <E = never, R = never>(request: PutRequest<E, R>) => Effect.Effect<ObjectMetadata, StorageError | E, R>;
+    get: (request: GetRequest) => Effect.Effect<GetResult, StorageError, import("effect/Scope").Scope>;
+    head: (request: HeadRequest) => Effect.Effect<ObjectMetadata, StorageError>;
+    delete: (request: DeleteRequest) => Effect.Effect<void, StorageError>;
+    listPage: (request?: ListRequest) => Effect.Effect<ListPage, StorageError>;
+    config: {
+      access: "public" | "private";
+      credential: {
+        readonly mode: "token" | "oidc";
+        readonly token: Effect.Effect<import("effect/Redacted").Redacted<string>, StorageError, never> | import("effect/Redacted").Redacted<string>;
+      };
+      apiOrigin: string | undefined;
+      storeId: string;
+      maxObjectBytes: number;
+      maxUnknownLengthBytes: number;
+      requestTimeoutMillis: number;
+    };
+    multipart: MultipartUploads;
+  }, StorageError, never>;
+  static layer(config: VercelConfig): Layer.Layer<Storage | TransferDriver | VercelStorage, StorageError, never>;
+  static publicUrls(): Layer.Layer<StoragePublicUrls, StorageError, VercelStorage>;
+}
+export type { VercelConfig };
+//# sourceMappingURL=vercel.d.ts.map

package/dist/vercel.js

@@ -0,0 +1,46 @@
+import { storageError } from "./core/errors.js";
+import { Storage } from "./core/storage.js";
+import { TransferDriver } from "./transfers/dependencies.js";
+import { StoragePublicUrls } from "./core/capabilities.js";
+import { makePublicUrls } from "./internal/public-urls.js";
+import { resolveConfig } from "./providers/vercel/config.js";
+import { validateKey, writeOptions } from "./providers/vercel/mapping.js";
+import { multipart } from "./providers/vercel/multipart.js";
+import { primitives } from "./providers/vercel/primitives.js";
+import { Context, Effect, Layer } from "effect";
+
+// src/providers/vercel/index.ts
+const make = Effect.fnUntraced(function* (input) {
+	const connection = { config: yield* resolveConfig(input) };
+	return {
+		...primitives(connection),
+		...connection,
+		multipart: multipart(connection)
+	};
+});
+var VercelStorage = class VercelStorage extends Context.Service()("@effect-kit/storage/vercel/VercelStorage") {
+	static make = make;
+	static layer(config) {
+		return Layer.effectContext(Effect.map(make(config), (storage) => Context.make(Storage, storage).pipe(Context.add(VercelStorage, storage), Context.add(TransferDriver, {
+			storage,
+			multipart: storage.multipart,
+			maximumObjectBytes: storage.config.maxObjectBytes,
+			maximumSingleUploadBytes: Math.min(storage.config.maxObjectBytes, 256 * 1024 ** 2),
+			transportOverheadBytes: 1024 ** 2,
+			validateUpload: ({ key, headers }) => validateKey(key, "upload").pipe(Effect.andThen(writeOptions(headers, "upload")), Effect.asVoid)
+		}))));
+	}
+	static publicUrls() {
+		return Layer.effect(StoragePublicUrls, Effect.gen(function* () {
+			const storage = yield* VercelStorage;
+			if (storage.config.access !== "public") return yield* storageError("publicUrls", "vercel", {
+				_tag: "Unsupported",
+				capability: "private-store-public-url"
+			});
+			return yield* makePublicUrls(storage, `${storage.config.apiOrigin ?? `https://${storage.config.storeId}.public.blob.vercel-storage.com`}/`);
+		}));
+	}
+};
+
+export { VercelStorage };
+//# sourceMappingURL=vercel.js.map

package/dist/vercel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vercel.js","names":[],"sources":["../src/providers/vercel/index.ts"],"sourcesContent":["import { Context, Effect, Layer } from \"effect\";\n\nimport { StoragePublicUrls } from \"../../core/capabilities.js\";\nimport { storageError } from \"../../core/errors.js\";\nimport { Storage } from \"../../core/storage.js\";\nimport { makePublicUrls } from \"../../internal/public-urls.js\";\nimport { TransferDriver } from \"../../transfers/dependencies.js\";\nimport { resolveConfig } from \"./config.js\";\nimport type { VercelConfig } from \"./config.js\";\nimport { validateKey, writeOptions } from \"./mapping.js\";\nimport { multipart } from \"./multipart.js\";\nimport { primitives } from \"./primitives.js\";\n\nexport type { VercelConfig } from \"./config.js\";\nconst make = Effect.fnUntraced(function* (input: VercelConfig) {\n  const connection = { config: yield* resolveConfig(input) };\n  return { ...primitives(connection), ...connection, multipart: multipart(connection) };\n});\nexport type VercelStorageService = Effect.Success<ReturnType<typeof make>>;\nexport class VercelStorage extends Context.Service<VercelStorage, VercelStorageService>()(\n  \"@effect-kit/storage/vercel/VercelStorage\",\n) {\n  static readonly make = make;\n  static layer(config: VercelConfig) {\n    return Layer.effectContext(\n      Effect.map(make(config), (storage) =>\n        Context.make(Storage, storage).pipe(\n          Context.add(VercelStorage, storage),\n          Context.add(TransferDriver, {\n            storage,\n            multipart: storage.multipart,\n            maximumObjectBytes: storage.config.maxObjectBytes,\n            maximumSingleUploadBytes: Math.min(storage.config.maxObjectBytes, 256 * 1024 ** 2),\n            transportOverheadBytes: 1024 ** 2,\n            validateUpload: ({ key, headers }) =>\n              validateKey(key, \"upload\").pipe(\n                Effect.andThen(writeOptions(headers, \"upload\")),\n                Effect.asVoid,\n              ),\n            // No public inventory/abort, operation marker or durable handle codec. Never adopt by pathname alone.\n          }),\n        ),\n      ),\n    );\n  }\n  static publicUrls() {\n    return Layer.effect(\n      StoragePublicUrls,\n      Effect.gen(function* () {\n        const storage = yield* VercelStorage;\n        if (storage.config.access !== \"public\")\n          return yield* storageError(\"publicUrls\", \"vercel\", {\n            _tag: \"Unsupported\",\n            capability: \"private-store-public-url\",\n          });\n        return yield* makePublicUrls(\n          storage,\n          `${storage.config.apiOrigin ?? `https://${storage.config.storeId}.public.blob.vercel-storage.com`}/`,\n        );\n      }),\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAcA,MAAM,OAAO,OAAO,WAAW,WAAW,OAAqB;CAC7D,MAAM,aAAa,EAAE,QAAQ,OAAO,cAAc,KAAK,EAAE;CACzD,OAAO;EAAE,GAAG,WAAW,UAAU;EAAG,GAAG;EAAY,WAAW,UAAU,UAAU;CAAE;AACtF,CAAC;AAED,IAAa,gBAAb,MAAa,sBAAsB,QAAQ,QAA6C,CAAC,CACvF,0CACF,CAAC,CAAC;CACA,OAAgB,OAAO;CACvB,OAAO,MAAM,QAAsB;EACjC,OAAO,MAAM,cACX,OAAO,IAAI,KAAK,MAAM,IAAI,YACxB,QAAQ,KAAK,SAAS,OAAO,CAAC,CAAC,KAC7B,QAAQ,IAAI,eAAe,OAAO,GAClC,QAAQ,IAAI,gBAAgB;GAC1B;GACA,WAAW,QAAQ;GACnB,oBAAoB,QAAQ,OAAO;GACnC,0BAA0B,KAAK,IAAI,QAAQ,OAAO,gBAAgB,MAAM,QAAQ,CAAC;GACjF,wBAAwB,QAAQ;GAChC,iBAAiB,EAAE,KAAK,cACtB,YAAY,KAAK,QAAQ,CAAC,CAAC,KACzB,OAAO,QAAQ,aAAa,SAAS,QAAQ,CAAC,GAC9C,OAAO,MACT;EAEJ,CAAC,CACH,CACF,CACF;CACF;CACA,OAAO,aAAa;EAClB,OAAO,MAAM,OACX,mBACA,OAAO,IAAI,aAAa;GACtB,MAAM,UAAU,OAAO;GACvB,IAAI,QAAQ,OAAO,WAAW,UAC5B,OAAO,OAAO,aAAa,cAAc,UAAU;IACjD,MAAM;IACN,YAAY;GACd,CAAC;GACH,OAAO,OAAO,eACZ,SACA,GAAG,QAAQ,OAAO,aAAa,WAAW,QAAQ,OAAO,QAAQ,iCAAiC,EACpG;EACF,CAAC,CACH;CACF;AACF"}

package/dist/wasabi/admin.d.ts

@@ -0,0 +1,112 @@
+import { StorageError } from "../core/errors.js";
+import "../index.js";
+import { RegionalConfig } from "../providers/s3-compatible/config.js";
+import { ConfigurationSection, S3Configuration } from "../providers/s3/admin-configuration.js";
+import { ConfigurationOutcome, ConfigurationPlan } from "../s3/admin.js";
+import { Context, Effect, Layer } from "effect";
+export type WasabiAdminConfig = Omit<RegionalConfig, "bucket" | "storeId">;
+declare const WasabiAdministration_base: Context.ServiceClass<WasabiAdministration, "@effect-kit/storage/wasabi/WasabiAdministration", {
+  listPage: (input?: {
+    readonly cursor?: string;
+    readonly limit?: number;
+  } | undefined) => Effect.Effect<{
+    buckets: {
+      name: string | undefined;
+      createdAt: Date | undefined;
+    }[];
+    cursor: string | undefined;
+  }, StorageError, never>;
+  head: (input: {
+    readonly bucket: string;
+  }) => Effect.Effect<{
+    bucket: string;
+    region: string | undefined;
+  }, StorageError, never>;
+  create: (input: {
+    readonly bucket: string;
+    readonly configuration?: import("@aws-sdk/client-s3").CreateBucketConfiguration;
+    readonly objectLockEnabled?: boolean;
+  }) => Effect.Effect<{
+    _tag: "Accepted";
+    bucket: string;
+  }, StorageError, never>;
+  deleteEmpty: (input: {
+    readonly bucket: string;
+  }) => Effect.Effect<void, StorageError, never>;
+  configuration: {
+    get: (input: {
+      readonly bucket: string;
+      readonly sections: ReadonlyArray<ConfigurationSection>;
+    }) => Effect.Effect<{
+      section: "cors" | "encryption" | "lifecycle" | "notifications" | "objectLock" | "policy" | "publicAccess" | "replication" | "versioning";
+      value: unknown;
+    }[], StorageError, never>;
+    plan: (input: {
+      readonly bucket: string;
+      readonly desired: S3Configuration;
+    }) => Effect.Effect<ConfigurationPlan, StorageError, never>;
+    apply: (input: {
+      readonly plan: ConfigurationPlan;
+      readonly allowUnconditional: true;
+      readonly protectionChange?: {
+        readonly intent: "change-storage-protection";
+        readonly reason: string;
+      };
+    }) => Effect.Effect<ConfigurationOutcome, StorageError, never>;
+  };
+}>;
+export declare class WasabiAdministration extends WasabiAdministration_base {
+  static make(config: WasabiAdminConfig): Effect.Effect<{
+    listPage: (input?: {
+      readonly cursor?: string;
+      readonly limit?: number;
+    } | undefined) => Effect.Effect<{
+      buckets: {
+        name: string | undefined;
+        createdAt: Date | undefined;
+      }[];
+      cursor: string | undefined;
+    }, StorageError, never>;
+    head: (input: {
+      readonly bucket: string;
+    }) => Effect.Effect<{
+      bucket: string;
+      region: string | undefined;
+    }, StorageError, never>;
+    create: (input: {
+      readonly bucket: string;
+      readonly configuration?: import("@aws-sdk/client-s3").CreateBucketConfiguration;
+      readonly objectLockEnabled?: boolean;
+    }) => Effect.Effect<{
+      _tag: "Accepted";
+      bucket: string;
+    }, StorageError, never>;
+    deleteEmpty: (input: {
+      readonly bucket: string;
+    }) => Effect.Effect<void, StorageError, never>;
+    configuration: {
+      get: (input: {
+        readonly bucket: string;
+        readonly sections: ReadonlyArray<ConfigurationSection>;
+      }) => Effect.Effect<{
+        section: "cors" | "encryption" | "lifecycle" | "notifications" | "objectLock" | "policy" | "publicAccess" | "replication" | "versioning";
+        value: unknown;
+      }[], StorageError, never>;
+      plan: (input: {
+        readonly bucket: string;
+        readonly desired: S3Configuration;
+      }) => Effect.Effect<ConfigurationPlan, StorageError, never>;
+      apply: (input: {
+        readonly plan: ConfigurationPlan;
+        readonly allowUnconditional: true;
+        readonly protectionChange?: {
+          readonly intent: "change-storage-protection";
+          readonly reason: string;
+        };
+      }) => Effect.Effect<ConfigurationOutcome, StorageError, never>;
+    };
+  }, StorageError, import("effect/Scope").Scope>;
+  static layer(config: WasabiAdminConfig): Layer.Layer<WasabiAdministration, StorageError, never>;
+}
+export {};
+//# sourceMappingURL=admin.d.ts.map

package/dist/wasabi/admin.js

@@ -0,0 +1,19 @@
+import { makeCompatible } from "../providers/s3-compatible/service.js";
+import { makeAdministration } from "../s3/admin.js";
+import { Context, Effect, Layer } from "effect";
+
+// src/providers/wasabi/admin.ts
+var WasabiAdministration = class WasabiAdministration extends Context.Service()("@effect-kit/storage/wasabi/WasabiAdministration") {
+	static make(config) {
+		return makeCompatible("wasabi", {
+			...config,
+			bucket: "administration"
+		}).pipe(Effect.map(makeAdministration));
+	}
+	static layer(config) {
+		return Layer.effect(WasabiAdministration, WasabiAdministration.make(config));
+	}
+};
+
+export { WasabiAdministration };
+//# sourceMappingURL=admin.js.map

package/dist/wasabi/admin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin.js","names":[],"sources":["../../src/providers/wasabi/admin.ts"],"sourcesContent":["import { Context, Effect, Layer } from \"effect\";\n\nimport type { RegionalConfig } from \"../s3-compatible/config.js\";\nimport { makeCompatible } from \"../s3-compatible/service.js\";\nimport { makeAdministration } from \"../s3/admin.js\";\nimport type { S3AdministrationService } from \"../s3/admin.js\";\n\nexport type WasabiAdminConfig = Omit<RegionalConfig, \"bucket\" | \"storeId\">;\nexport class WasabiAdministration extends Context.Service<\n  WasabiAdministration,\n  S3AdministrationService\n>()(\"@effect-kit/storage/wasabi/WasabiAdministration\") {\n  static make(config: WasabiAdminConfig) {\n    return makeCompatible(\"wasabi\", { ...config, bucket: \"administration\" }).pipe(\n      Effect.map(makeAdministration),\n    );\n  }\n  static layer(config: WasabiAdminConfig) {\n    return Layer.effect(WasabiAdministration, WasabiAdministration.make(config));\n  }\n}\n"],"mappings":";;;;;AAQA,IAAa,uBAAb,MAAa,6BAA6B,QAAQ,QAGhD,CAAC,CAAC,iDAAiD,CAAC,CAAC;CACrD,OAAO,KAAK,QAA2B;EACrC,OAAO,eAAe,UAAU;GAAE,GAAG;GAAQ,QAAQ;EAAiB,CAAC,CAAC,CAAC,KACvE,OAAO,IAAI,kBAAkB,CAC/B;CACF;CACA,OAAO,MAAM,QAA2B;EACtC,OAAO,MAAM,OAAO,sBAAsB,qBAAqB,KAAK,MAAM,CAAC;CAC7E;AACF"}