@effect-kit/storage 0.0.0-stage → 0.1.0

package/dist/supabase/admin.js

@@ -0,0 +1,74 @@
+import { decodeRequest } from "../internal/request-validation.js";
+import { resolveConfig } from "../providers/supabase/config.js";
+import { json, request } from "../providers/supabase/transport.js";
+import { Context, Effect, Layer, Schema } from "effect";
+import { FetchHttpClient, HttpClient } from "effect/http";
+
+// src/providers/supabase/admin.ts
+const Name = Schema.String.check(Schema.isPattern(/^[A-Za-z0-9._-]+$/u));
+const Settings = Schema.Struct({
+	bucket: Name,
+	public: Schema.Boolean,
+	fileSizeLimit: Schema.optional(Schema.Natural),
+	allowedMimeTypes: Schema.optional(Schema.Array(Schema.NonEmptyString))
+});
+const Native = Schema.Record(Schema.String, Schema.Unknown);
+const make = Effect.fnUntraced(function* (settings) {
+	const connection = {
+		config: yield* resolveConfig({
+			url: settings.url,
+			bucket: "administration",
+			storeId: "supabase-administration",
+			auth: {
+				mode: "service",
+				token: settings.token,
+				...settings.apiKey ? { apiKey: settings.apiKey } : {}
+			}
+		}),
+		http: yield* HttpClient.HttpClient
+	};
+	return {
+		list: () => Effect.scoped(request(connection, "listBuckets", "GET", "/bucket").pipe(Effect.flatMap((response) => json(response, Schema.Array(Native), "listBuckets")))),
+		head: Effect.fnUntraced(function* (input) {
+			const value = yield* decodeRequest(Schema.Struct({ bucket: Name }), input, "headBucket", "supabase");
+			return yield* Effect.scoped(request(connection, "headBucket", "GET", `/bucket/${encodeURIComponent(value.bucket)}`).pipe(Effect.flatMap((response) => json(response, Native, "headBucket"))));
+		}),
+		create: Effect.fnUntraced(function* (input) {
+			const value = yield* decodeRequest(Settings, input, "createBucket", "supabase", true);
+			return yield* Effect.scoped(request(connection, "createBucket", "POST", "/bucket", { json: {
+				id: value.bucket,
+				name: value.bucket,
+				public: value.public,
+				file_size_limit: value.fileSizeLimit,
+				allowed_mime_types: value.allowedMimeTypes
+			} }).pipe(Effect.flatMap((response) => json(response, Native, "createBucket"))));
+		}),
+		update: Effect.fnUntraced(function* (input) {
+			const value = yield* decodeRequest(Schema.Struct({
+				...Settings.fields,
+				intent: Schema.Literal("change-bucket-access-and-limits")
+			}), input, "updateBucket", "supabase", true);
+			return yield* Effect.scoped(request(connection, "updateBucket", "PUT", `/bucket/${encodeURIComponent(value.bucket)}`, { json: {
+				public: value.public,
+				file_size_limit: value.fileSizeLimit,
+				allowed_mime_types: value.allowedMimeTypes
+			} }).pipe(Effect.flatMap((response) => json(response, Native, "updateBucket"))));
+		}),
+		deleteEmpty: Effect.fnUntraced(function* (input) {
+			const value = yield* decodeRequest(Schema.Struct({ bucket: Name }), input, "deleteBucket", "supabase", true);
+			yield* Effect.scoped(request(connection, "deleteBucket", "DELETE", `/bucket/${encodeURIComponent(value.bucket)}`).pipe(Effect.asVoid));
+		})
+	};
+});
+var SupabaseAdministration = class SupabaseAdministration extends Context.Service()("@effect-kit/storage/supabase/SupabaseAdministration") {
+	static make = make;
+	static layerHttp(config) {
+		return Layer.effect(SupabaseAdministration, make(config));
+	}
+	static layer(config) {
+		return SupabaseAdministration.layerHttp(config).pipe(Layer.provide(FetchHttpClient.layer));
+	}
+};
+
+export { SupabaseAdministration };
+//# sourceMappingURL=admin.js.map

package/dist/supabase/admin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin.js","names":[],"sources":["../../src/providers/supabase/admin.ts"],"sourcesContent":["import type { Redacted } from \"effect\";\nimport { Context, Effect, Layer, Schema } from \"effect\";\nimport { FetchHttpClient, HttpClient } from \"effect/http\";\n\nimport { decodeRequest } from \"../../internal/request-validation.js\";\nimport { resolveConfig } from \"./config.js\";\nimport { json, request } from \"./transport.js\";\n\nexport interface SupabaseAdminConfig {\n  readonly url: string;\n  readonly token: Redacted.Redacted<string>;\n  readonly apiKey?: Redacted.Redacted<string>;\n}\nconst Name = Schema.String.check(Schema.isPattern(/^[A-Za-z0-9._-]+$/u));\nconst Settings = Schema.Struct({\n  bucket: Name,\n  public: Schema.Boolean,\n  fileSizeLimit: Schema.optional(Schema.Natural),\n  allowedMimeTypes: Schema.optional(Schema.Array(Schema.NonEmptyString)),\n});\nconst Native = Schema.Record(Schema.String, Schema.Unknown);\nconst make = Effect.fnUntraced(function* (settings: SupabaseAdminConfig) {\n  const config = yield* resolveConfig({\n    url: settings.url,\n    bucket: \"administration\",\n    storeId: \"supabase-administration\",\n    auth: {\n      mode: \"service\",\n      token: settings.token,\n      ...(settings.apiKey ? { apiKey: settings.apiKey } : {}),\n    },\n  });\n  const connection = { config, http: yield* HttpClient.HttpClient };\n  return {\n    list: () =>\n      Effect.scoped(\n        request(connection, \"listBuckets\", \"GET\", \"/bucket\").pipe(\n          Effect.flatMap((response) => json(response, Schema.Array(Native), \"listBuckets\")),\n        ),\n      ),\n    head: Effect.fnUntraced(function* (input: { readonly bucket: string }) {\n      const value = yield* decodeRequest(\n        Schema.Struct({ bucket: Name }),\n        input,\n        \"headBucket\",\n        \"supabase\",\n      );\n      return yield* Effect.scoped(\n        request(\n          connection,\n          \"headBucket\",\n          \"GET\",\n          `/bucket/${encodeURIComponent(value.bucket)}`,\n        ).pipe(Effect.flatMap((response) => json(response, Native, \"headBucket\"))),\n      );\n    }),\n    create: Effect.fnUntraced(function* (input: typeof Settings.Type) {\n      const value = yield* decodeRequest(Settings, input, \"createBucket\", \"supabase\", true);\n      return yield* Effect.scoped(\n        request(connection, \"createBucket\", \"POST\", \"/bucket\", {\n          json: {\n            id: value.bucket,\n            name: value.bucket,\n            public: value.public,\n            file_size_limit: value.fileSizeLimit,\n            allowed_mime_types: value.allowedMimeTypes,\n          },\n        }).pipe(Effect.flatMap((response) => json(response, Native, \"createBucket\"))),\n      );\n    }),\n    update: Effect.fnUntraced(function* (\n      input: typeof Settings.Type & { readonly intent: \"change-bucket-access-and-limits\" },\n    ) {\n      const value = yield* decodeRequest(\n        Schema.Struct({\n          ...Settings.fields,\n          intent: Schema.Literal(\"change-bucket-access-and-limits\"),\n        }),\n        input,\n        \"updateBucket\",\n        \"supabase\",\n        true,\n      );\n      return yield* Effect.scoped(\n        request(connection, \"updateBucket\", \"PUT\", `/bucket/${encodeURIComponent(value.bucket)}`, {\n          json: {\n            public: value.public,\n            file_size_limit: value.fileSizeLimit,\n            allowed_mime_types: value.allowedMimeTypes,\n          },\n        }).pipe(Effect.flatMap((response) => json(response, Native, \"updateBucket\"))),\n      );\n    }),\n    deleteEmpty: Effect.fnUntraced(function* (input: { readonly bucket: string }) {\n      const value = yield* decodeRequest(\n        Schema.Struct({ bucket: Name }),\n        input,\n        \"deleteBucket\",\n        \"supabase\",\n        true,\n      );\n      yield* Effect.scoped(\n        request(\n          connection,\n          \"deleteBucket\",\n          \"DELETE\",\n          `/bucket/${encodeURIComponent(value.bucket)}`,\n        ).pipe(Effect.asVoid),\n      );\n    }),\n  };\n});\nexport class SupabaseAdministration extends Context.Service<\n  SupabaseAdministration,\n  Effect.Success<ReturnType<typeof make>>\n>()(\"@effect-kit/storage/supabase/SupabaseAdministration\") {\n  static readonly make = make;\n  static layerHttp(config: SupabaseAdminConfig) {\n    return Layer.effect(SupabaseAdministration, make(config));\n  }\n  static layer(config: SupabaseAdminConfig) {\n    return SupabaseAdministration.layerHttp(config).pipe(Layer.provide(FetchHttpClient.layer));\n  }\n}\n"],"mappings":"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"}

package/dist/supabase/s3.d.ts

@@ -0,0 +1,311 @@
+import { ObjectHeaders, ObjectMetadata } from "../core/object.js";
+import { StorageError } from "../core/errors.js";
+import { DeleteRequest, GetRequest, GetResult, HeadRequest, ListPage, ListRequest, PutRequest, UploadBody } from "../core/requests.js";
+import { StorageCapabilities } from "../core/capabilities.js";
+import { Storage } from "../core/storage.js";
+import { MultipartHandle, MultipartUploads, UploadedPart } from "../core/contracts/multipart.js";
+import "../index.js";
+import { TransferDriver } from "../transfers/dependencies.js";
+import { S3ChecksumOptions, S3MultipartHandle } from "../providers/s3/multipart.js";
+import { Context, Effect, Layer, Redacted } from "effect";
+import { S3Client } from "@aws-sdk/client-s3";
+export interface SupabaseS3Config {
+  readonly endpoint: string;
+  readonly region: string;
+  readonly bucket: string;
+  readonly storeId: string;
+  readonly auth: {
+    readonly mode: "server-keys";
+    readonly accessKeyId: string;
+    readonly secretAccessKey: Redacted.Redacted<string>;
+  } | {
+    readonly mode: "user-session";
+    readonly projectRef: string;
+    readonly anonKey: Redacted.Redacted<string>;
+    readonly token: () => Promise<Redacted.Redacted<string>>;
+  };
+  readonly maxUnknownLengthBytes?: number;
+  readonly maxObjectBytes?: number;
+}
+declare const make: (input: SupabaseS3Config) => 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>;
+  client: S3Client;
+  multipart: {
+    abort: (upload: MultipartHandle) => Effect.Effect<void, StorageError>;
+    initiate: (input: {
+      readonly key: string;
+      readonly headers?: ObjectHeaders;
+      readonly checksum?: S3ChecksumOptions;
+    }) => Effect.Effect<S3MultipartHandle, StorageError>;
+    uploadPart: <E = never, R = never>(input: {
+      readonly upload: MultipartHandle;
+      readonly partNumber: number;
+      readonly contentLength?: number;
+      readonly body: UploadBody<E, R>;
+      readonly checksum?: S3ChecksumOptions;
+    }) => Effect.Effect<UploadedPart, StorageError | E, R>;
+    listUploads: (input: ListRequest) => Effect.Effect<{
+      readonly uploads: ReadonlyArray<S3MultipartHandle>;
+      readonly cursor?: string;
+    }, StorageError>;
+    listParts: (input: {
+      readonly upload: MultipartHandle;
+      readonly cursor?: string;
+    }) => Effect.Effect<{
+      readonly parts: ReadonlyArray<UploadedPart>;
+      readonly cursor?: string;
+      readonly checksumAlgorithm?: S3ChecksumOptions["ChecksumAlgorithm"];
+      readonly checksumType?: S3ChecksumOptions["ChecksumType"];
+    }, StorageError>;
+    limits: {
+      minimumPartBytes: number;
+      maximumPartBytes: number;
+      maximumParts: number;
+      completeConditions: never[];
+    };
+    complete: (request: Parameters<(input: Parameters<MultipartUploads["complete"]>[0] & {
+      readonly checksum?: S3ChecksumOptions;
+    }) => ReturnType<MultipartUploads["complete"]>>[0]) => Effect.Effect<{
+      readonly contentType?: string | undefined;
+      readonly contentEncoding?: string | undefined;
+      readonly contentLanguage?: string | undefined;
+      readonly contentDisposition?: string | undefined;
+      readonly cacheControl?: string | undefined;
+      readonly customMetadata?: {
+        readonly [x: string]: string;
+      } | undefined;
+      readonly ref: {
+        readonly storeId: string;
+        readonly key: string;
+        readonly version?: {
+          readonly _tag: "S3Version";
+          readonly id: string;
+        } | {
+          readonly _tag: "GcsGeneration";
+          readonly id: string;
+          readonly metageneration?: string | undefined;
+        } | {
+          readonly _tag: "AzureVersion";
+          readonly id: string;
+        } | {
+          readonly _tag: "AzureSnapshot";
+          readonly id: string;
+        } | {
+          readonly _tag: "OpaqueVersion";
+          readonly provider: string;
+          readonly id: string;
+        } | undefined;
+      };
+      readonly size?: number | undefined;
+      readonly etag?: string | undefined;
+      readonly lastModified?: import("effect/DateTime").Utc | undefined;
+      readonly checksums?: readonly {
+        readonly algorithm: string;
+        readonly encoding: "base64" | "hex";
+        readonly scope: "composite" | "full-object";
+        readonly value: string;
+        readonly partCount?: number | undefined;
+      }[] | undefined;
+      readonly storageClass?: string | undefined;
+    }, StorageError, never>;
+  };
+  authMode: "server-keys" | "user-session";
+  maxObjectBytes: number;
+}, StorageError, import("effect/Scope").Scope>;
+export type SupabaseS3Service = Effect.Success<ReturnType<typeof make>>;
+declare const SupabaseS3Storage_base: Context.ServiceClass<SupabaseS3Storage, "@effect-kit/storage/supabase/SupabaseS3Storage", {
+  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>;
+  client: S3Client;
+  multipart: {
+    abort: (upload: MultipartHandle) => Effect.Effect<void, StorageError>;
+    initiate: (input: {
+      readonly key: string;
+      readonly headers?: ObjectHeaders;
+      readonly checksum?: S3ChecksumOptions;
+    }) => Effect.Effect<S3MultipartHandle, StorageError>;
+    uploadPart: <E = never, R = never>(input: {
+      readonly upload: MultipartHandle;
+      readonly partNumber: number;
+      readonly contentLength?: number;
+      readonly body: UploadBody<E, R>;
+      readonly checksum?: S3ChecksumOptions;
+    }) => Effect.Effect<UploadedPart, StorageError | E, R>;
+    listUploads: (input: ListRequest) => Effect.Effect<{
+      readonly uploads: ReadonlyArray<S3MultipartHandle>;
+      readonly cursor?: string;
+    }, StorageError>;
+    listParts: (input: {
+      readonly upload: MultipartHandle;
+      readonly cursor?: string;
+    }) => Effect.Effect<{
+      readonly parts: ReadonlyArray<UploadedPart>;
+      readonly cursor?: string;
+      readonly checksumAlgorithm?: S3ChecksumOptions["ChecksumAlgorithm"];
+      readonly checksumType?: S3ChecksumOptions["ChecksumType"];
+    }, StorageError>;
+    limits: {
+      minimumPartBytes: number;
+      maximumPartBytes: number;
+      maximumParts: number;
+      completeConditions: never[];
+    };
+    complete: (request: Parameters<(input: Parameters<MultipartUploads["complete"]>[0] & {
+      readonly checksum?: S3ChecksumOptions;
+    }) => ReturnType<MultipartUploads["complete"]>>[0]) => Effect.Effect<{
+      readonly contentType?: string | undefined;
+      readonly contentEncoding?: string | undefined;
+      readonly contentLanguage?: string | undefined;
+      readonly contentDisposition?: string | undefined;
+      readonly cacheControl?: string | undefined;
+      readonly customMetadata?: {
+        readonly [x: string]: string;
+      } | undefined;
+      readonly ref: {
+        readonly storeId: string;
+        readonly key: string;
+        readonly version?: {
+          readonly _tag: "S3Version";
+          readonly id: string;
+        } | {
+          readonly _tag: "GcsGeneration";
+          readonly id: string;
+          readonly metageneration?: string | undefined;
+        } | {
+          readonly _tag: "AzureVersion";
+          readonly id: string;
+        } | {
+          readonly _tag: "AzureSnapshot";
+          readonly id: string;
+        } | {
+          readonly _tag: "OpaqueVersion";
+          readonly provider: string;
+          readonly id: string;
+        } | undefined;
+      };
+      readonly size?: number | undefined;
+      readonly etag?: string | undefined;
+      readonly lastModified?: import("effect/DateTime").Utc | undefined;
+      readonly checksums?: readonly {
+        readonly algorithm: string;
+        readonly encoding: "base64" | "hex";
+        readonly scope: "composite" | "full-object";
+        readonly value: string;
+        readonly partCount?: number | undefined;
+      }[] | undefined;
+      readonly storageClass?: string | undefined;
+    }, StorageError, never>;
+  };
+  authMode: "server-keys" | "user-session";
+  maxObjectBytes: number;
+}>;
+export declare class SupabaseS3Storage extends SupabaseS3Storage_base {
+  static readonly make: (input: SupabaseS3Config) => 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>;
+    client: S3Client;
+    multipart: {
+      abort: (upload: MultipartHandle) => Effect.Effect<void, StorageError>;
+      initiate: (input: {
+        readonly key: string;
+        readonly headers?: ObjectHeaders;
+        readonly checksum?: S3ChecksumOptions;
+      }) => Effect.Effect<S3MultipartHandle, StorageError>;
+      uploadPart: <E = never, R = never>(input: {
+        readonly upload: MultipartHandle;
+        readonly partNumber: number;
+        readonly contentLength?: number;
+        readonly body: UploadBody<E, R>;
+        readonly checksum?: S3ChecksumOptions;
+      }) => Effect.Effect<UploadedPart, StorageError | E, R>;
+      listUploads: (input: ListRequest) => Effect.Effect<{
+        readonly uploads: ReadonlyArray<S3MultipartHandle>;
+        readonly cursor?: string;
+      }, StorageError>;
+      listParts: (input: {
+        readonly upload: MultipartHandle;
+        readonly cursor?: string;
+      }) => Effect.Effect<{
+        readonly parts: ReadonlyArray<UploadedPart>;
+        readonly cursor?: string;
+        readonly checksumAlgorithm?: S3ChecksumOptions["ChecksumAlgorithm"];
+        readonly checksumType?: S3ChecksumOptions["ChecksumType"];
+      }, StorageError>;
+      limits: {
+        minimumPartBytes: number;
+        maximumPartBytes: number;
+        maximumParts: number;
+        completeConditions: never[];
+      };
+      complete: (request: Parameters<(input: Parameters<MultipartUploads["complete"]>[0] & {
+        readonly checksum?: S3ChecksumOptions;
+      }) => ReturnType<MultipartUploads["complete"]>>[0]) => Effect.Effect<{
+        readonly contentType?: string | undefined;
+        readonly contentEncoding?: string | undefined;
+        readonly contentLanguage?: string | undefined;
+        readonly contentDisposition?: string | undefined;
+        readonly cacheControl?: string | undefined;
+        readonly customMetadata?: {
+          readonly [x: string]: string;
+        } | undefined;
+        readonly ref: {
+          readonly storeId: string;
+          readonly key: string;
+          readonly version?: {
+            readonly _tag: "S3Version";
+            readonly id: string;
+          } | {
+            readonly _tag: "GcsGeneration";
+            readonly id: string;
+            readonly metageneration?: string | undefined;
+          } | {
+            readonly _tag: "AzureVersion";
+            readonly id: string;
+          } | {
+            readonly _tag: "AzureSnapshot";
+            readonly id: string;
+          } | {
+            readonly _tag: "OpaqueVersion";
+            readonly provider: string;
+            readonly id: string;
+          } | undefined;
+        };
+        readonly size?: number | undefined;
+        readonly etag?: string | undefined;
+        readonly lastModified?: import("effect/DateTime").Utc | undefined;
+        readonly checksums?: readonly {
+          readonly algorithm: string;
+          readonly encoding: "base64" | "hex";
+          readonly scope: "composite" | "full-object";
+          readonly value: string;
+          readonly partCount?: number | undefined;
+        }[] | undefined;
+        readonly storageClass?: string | undefined;
+      }, StorageError, never>;
+    };
+    authMode: "server-keys" | "user-session";
+    maxObjectBytes: number;
+  }, StorageError, import("effect/Scope").Scope>;
+  static layer(input: SupabaseS3Config): Layer.Layer<Storage | SupabaseS3Storage | TransferDriver, StorageError, never>;
+}
+export {};
+//# sourceMappingURL=s3.d.ts.map

package/dist/supabase/s3.js

@@ -0,0 +1,153 @@
+import { storageError } from "../core/errors.js";
+import { Storage } from "../core/storage.js";
+import { TransferDriver } from "../transfers/dependencies.js";
+import { multipart } from "../providers/s3/multipart.js";
+import { primitives } from "../providers/s3/primitives.js";
+import { Context, Effect, Layer, Redacted, Schema } from "effect";
+import { S3Client } from "@aws-sdk/client-s3";
+
+// src/providers/supabase/s3.ts
+const Profile = Schema.Struct({
+	endpoint: Schema.String,
+	region: Schema.String.check(Schema.isPattern(/^[a-z0-9-]+$/u)),
+	bucket: Schema.String.check(Schema.isPattern(/^(?!\.{1,2}$)[A-Za-z0-9._-]+$/u)),
+	storeId: Schema.NonEmptyString,
+	auth: Schema.Union([Schema.Struct({
+		mode: Schema.Literal("server-keys"),
+		accessKeyId: Schema.NonEmptyString,
+		secretAccessKey: Schema.Redacted(Schema.NonEmptyString)
+	}), Schema.Struct({
+		mode: Schema.Literal("user-session"),
+		projectRef: Schema.NonEmptyString,
+		anonKey: Schema.Redacted(Schema.NonEmptyString),
+		token: Schema.declare((value) => typeof value === "function")
+	})]),
+	maxObjectBytes: Schema.optional(Schema.Int.check(Schema.isGreaterThan(0))),
+	maxUnknownLengthBytes: Schema.optional(Schema.Int.check(Schema.isGreaterThan(0)))
+});
+const make = Effect.fnUntraced(function* (input) {
+	yield* Schema.decodeUnknownEffect(Profile, { onExcessProperty: "error" })(input).pipe(Effect.mapError(() => storageError("make", "supabase-s3", {
+		_tag: "InvalidConfiguration",
+		field: "config"
+	})));
+	const maxObjectBytes = input.maxObjectBytes ?? 50 * 1024 ** 2;
+	const url = URL.parse(input.endpoint);
+	if (!url || !["http:", "https:"].includes(url.protocol) || url.pathname !== "/storage/v1/s3" || url.username || url.password || url.search || url.hash) return yield* storageError("make", "supabase-s3", {
+		_tag: "InvalidConfiguration",
+		field: "endpoint"
+	});
+	const config = {
+		bucket: input.bucket,
+		region: input.region,
+		storeId: input.storeId,
+		endpoint: input.endpoint,
+		forcePathStyle: true,
+		requestTimeoutMillis: 3e4,
+		maxUnknownLengthBytes: input.maxUnknownLengthBytes ?? 8 * 1024 ** 2
+	};
+	const credentials = async () => {
+		if (input.auth.mode === "server-keys") return {
+			accessKeyId: input.auth.accessKeyId,
+			secretAccessKey: Redacted.value(input.auth.secretAccessKey)
+		};
+		const sessionToken = Redacted.value(await input.auth.token());
+		const parseExpiry = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Struct({ exp: Schema.Natural })));
+		let payload;
+		try {
+			payload = parseExpiry(Buffer.from(sessionToken.split(".")[1] ?? "", "base64url").toString("utf8"));
+		} catch {
+			throw storageError("credentials", "supabase-s3", { _tag: "AccessDenied" }, "not-started");
+		}
+		return {
+			accessKeyId: input.auth.projectRef,
+			secretAccessKey: Redacted.value(input.auth.anonKey),
+			sessionToken,
+			expiration: /* @__PURE__ */ new Date(payload.exp * 1e3)
+		};
+	};
+	const client = yield* Effect.acquireRelease(Effect.try({
+		try: () => new S3Client({
+			endpoint: input.endpoint,
+			region: input.region,
+			credentials,
+			forcePathStyle: true,
+			maxAttempts: 1,
+			followRegionRedirects: false,
+			requestChecksumCalculation: "WHEN_REQUIRED",
+			responseChecksumValidation: "WHEN_REQUIRED"
+		}),
+		catch: () => storageError("make", "supabase-s3", {
+			_tag: "InvalidConfiguration",
+			field: "client"
+		})
+	}), (owned) => Effect.sync(() => owned.destroy()));
+	const connection = {
+		client,
+		readChecksums: false,
+		multipartChecksums: false,
+		config: {
+			...config,
+			endpoint: input.endpoint
+		}
+	};
+	const native = multipart(connection);
+	const base = primitives(connection);
+	const storage = Storage.make({
+		...base,
+		put: (request) => base.put({
+			...request,
+			maxBytes: Math.min(request.maxBytes ?? maxObjectBytes, maxObjectBytes)
+		}),
+		provider: "supabase-s3",
+		capabilities: {
+			putConditions: [],
+			getConditions: ["if-match", "if-none-match"],
+			deleteConditions: [],
+			ranges: [
+				"bounded",
+				"from",
+				"suffix"
+			],
+			versionedReads: "none",
+			list: {
+				maxPageSize: 1e3,
+				delimiter: true,
+				cursorPersistence: "provider",
+				snapshot: false
+			}
+		}
+	});
+	const uploads = {
+		...native,
+		limits: {
+			...native.limits,
+			completeConditions: []
+		},
+		complete: (request) => request.condition ? Effect.fail(storageError("complete", "supabase-s3", {
+			_tag: "Unsupported",
+			capability: "conditional-completion"
+		}, "not-started")) : native.complete(request)
+	};
+	return {
+		...storage,
+		client,
+		multipart: uploads,
+		authMode: input.auth.mode,
+		maxObjectBytes
+	};
+});
+var SupabaseS3Storage = class SupabaseS3Storage extends Context.Service()("@effect-kit/storage/supabase/SupabaseS3Storage") {
+	static make = make;
+	static layer(input) {
+		return Layer.effectContext(Effect.map(make(input), (storage) => Context.make(Storage, storage).pipe(Context.add(SupabaseS3Storage, storage), Context.add(TransferDriver, {
+			storage,
+			multipart: storage.multipart,
+			maximumObjectBytes: storage.maxObjectBytes,
+			maximumSingleUploadBytes: Math.min(storage.maxObjectBytes, 5 * 1024 ** 3),
+			transportOverheadBytes: 1024 ** 2
+		}))));
+	}
+};
+
+export { SupabaseS3Storage };
+//# sourceMappingURL=s3.js.map

package/dist/supabase/s3.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"s3.js","names":[],"sources":["../../src/providers/supabase/s3.ts"],"sourcesContent":["import { Context, Effect, Layer, Redacted, Schema } from \"effect\";\n\nimport { S3Client } from \"@aws-sdk/client-s3\";\n\nimport { storageError } from \"../../core/errors.js\";\nimport { Storage } from \"../../core/storage.js\";\nimport { TransferDriver } from \"../../transfers/dependencies.js\";\nimport { multipart } from \"../s3/multipart.js\";\nimport { primitives } from \"../s3/primitives.js\";\n\nexport interface SupabaseS3Config {\n  readonly endpoint: string;\n  readonly region: string;\n  readonly bucket: string;\n  readonly storeId: string;\n  readonly auth:\n    | {\n        readonly mode: \"server-keys\";\n        readonly accessKeyId: string;\n        readonly secretAccessKey: Redacted.Redacted<string>;\n      }\n    | {\n        readonly mode: \"user-session\";\n        readonly projectRef: string;\n        readonly anonKey: Redacted.Redacted<string>;\n        readonly token: () => Promise<Redacted.Redacted<string>>;\n      };\n  readonly maxUnknownLengthBytes?: number;\n  readonly maxObjectBytes?: number;\n}\nconst Profile = Schema.Struct({\n  endpoint: Schema.String,\n  region: Schema.String.check(Schema.isPattern(/^[a-z0-9-]+$/u)),\n  bucket: Schema.String.check(Schema.isPattern(/^(?!\\.{1,2}$)[A-Za-z0-9._-]+$/u)),\n  storeId: Schema.NonEmptyString,\n  auth: Schema.Union([\n    Schema.Struct({\n      mode: Schema.Literal(\"server-keys\"),\n      accessKeyId: Schema.NonEmptyString,\n      secretAccessKey: Schema.Redacted(Schema.NonEmptyString),\n    }),\n    Schema.Struct({\n      mode: Schema.Literal(\"user-session\"),\n      projectRef: Schema.NonEmptyString,\n      anonKey: Schema.Redacted(Schema.NonEmptyString),\n      token: Schema.declare<() => Promise<Redacted.Redacted<string>>>(\n        (value): value is () => Promise<Redacted.Redacted<string>> => typeof value === \"function\",\n      ),\n    }),\n  ]),\n  maxObjectBytes: Schema.optional(Schema.Int.check(Schema.isGreaterThan(0))),\n  maxUnknownLengthBytes: Schema.optional(Schema.Int.check(Schema.isGreaterThan(0))),\n});\nconst make = Effect.fnUntraced(function* (input: SupabaseS3Config) {\n  yield* Schema.decodeUnknownEffect(Profile, { onExcessProperty: \"error\" })(input).pipe(\n    Effect.mapError(() =>\n      storageError(\"make\", \"supabase-s3\", { _tag: \"InvalidConfiguration\", field: \"config\" }),\n    ),\n  );\n  const maxObjectBytes = input.maxObjectBytes ?? 50 * 1024 ** 2;\n\n  const url = URL.parse(input.endpoint);\n  if (\n    !url ||\n    ![\"http:\", \"https:\"].includes(url.protocol) ||\n    url.pathname !== \"/storage/v1/s3\" ||\n    url.username ||\n    url.password ||\n    url.search ||\n    url.hash\n  )\n    return yield* storageError(\"make\", \"supabase-s3\", {\n      _tag: \"InvalidConfiguration\",\n      field: \"endpoint\",\n    });\n  const config = {\n    bucket: input.bucket,\n    region: input.region,\n    storeId: input.storeId,\n    endpoint: input.endpoint,\n    forcePathStyle: true,\n    requestTimeoutMillis: 30000,\n    maxUnknownLengthBytes: input.maxUnknownLengthBytes ?? 8 * 1024 ** 2,\n  };\n  const credentials = async () => {\n    if (input.auth.mode === \"server-keys\")\n      return {\n        accessKeyId: input.auth.accessKeyId,\n        secretAccessKey: Redacted.value(input.auth.secretAccessKey),\n      };\n    const sessionToken = Redacted.value(await input.auth.token());\n    const parseExpiry = Schema.decodeUnknownSync(\n      Schema.fromJsonString(Schema.Struct({ exp: Schema.Natural })),\n    );\n    let payload: { readonly exp: number };\n    try {\n      payload = parseExpiry(\n        Buffer.from(sessionToken.split(\".\")[1] ?? \"\", \"base64url\").toString(\"utf8\"),\n      );\n    } catch {\n      throw storageError(\"credentials\", \"supabase-s3\", { _tag: \"AccessDenied\" }, \"not-started\");\n    }\n    return {\n      accessKeyId: input.auth.projectRef,\n      secretAccessKey: Redacted.value(input.auth.anonKey),\n      sessionToken,\n      expiration: new Date(payload.exp * 1000),\n    };\n  };\n  const client = yield* Effect.acquireRelease(\n    Effect.try({\n      try: () =>\n        new S3Client({\n          endpoint: input.endpoint,\n          region: input.region,\n          credentials,\n          forcePathStyle: true,\n          maxAttempts: 1,\n          followRegionRedirects: false,\n          requestChecksumCalculation: \"WHEN_REQUIRED\",\n          responseChecksumValidation: \"WHEN_REQUIRED\",\n        }),\n      catch: () =>\n        storageError(\"make\", \"supabase-s3\", { _tag: \"InvalidConfiguration\", field: \"client\" }),\n    }),\n    (owned) => Effect.sync(() => owned.destroy()),\n  );\n  const connection = {\n    client,\n    readChecksums: false as const,\n    multipartChecksums: false as const,\n    config: { ...config, endpoint: input.endpoint },\n  };\n  const native = multipart(connection);\n  const base = primitives(connection);\n  const storage = Storage.make({\n    ...base,\n    put: (request) =>\n      base.put({\n        ...request,\n        maxBytes: Math.min(request.maxBytes ?? maxObjectBytes, maxObjectBytes),\n      }),\n    provider: \"supabase-s3\",\n    capabilities: {\n      putConditions: [],\n      getConditions: [\"if-match\", \"if-none-match\"],\n      deleteConditions: [],\n      ranges: [\"bounded\", \"from\", \"suffix\"],\n      versionedReads: \"none\",\n      list: { maxPageSize: 1000, delimiter: true, cursorPersistence: \"provider\", snapshot: false },\n    },\n  });\n  const uploads = {\n    ...native,\n    limits: { ...native.limits, completeConditions: [] },\n    complete: (request: Parameters<typeof native.complete>[0]) =>\n      request.condition\n        ? Effect.fail(\n            storageError(\n              \"complete\",\n              \"supabase-s3\",\n              { _tag: \"Unsupported\", capability: \"conditional-completion\" },\n              \"not-started\",\n            ),\n          )\n        : native.complete(request),\n  };\n  return { ...storage, client, multipart: uploads, authMode: input.auth.mode, maxObjectBytes };\n});\nexport type SupabaseS3Service = Effect.Success<ReturnType<typeof make>>;\nexport class SupabaseS3Storage extends Context.Service<SupabaseS3Storage, SupabaseS3Service>()(\n  \"@effect-kit/storage/supabase/SupabaseS3Storage\",\n) {\n  static readonly make = make;\n  static layer(input: SupabaseS3Config) {\n    return Layer.effectContext(\n      Effect.map(make(input), (storage) =>\n        Context.make(Storage, storage).pipe(\n          Context.add(SupabaseS3Storage, storage),\n          Context.add(TransferDriver, {\n            storage,\n            multipart: storage.multipart,\n            maximumObjectBytes: storage.maxObjectBytes,\n            maximumSingleUploadBytes: Math.min(storage.maxObjectBytes, 5 * 1024 ** 3),\n            transportOverheadBytes: 1024 ** 2,\n          }),\n        ),\n      ),\n    );\n  }\n}\n"],"mappings":"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"}

package/dist/supabase/signing.d.ts

@@ -0,0 +1,23 @@
+import { storageError } from "../core/errors.js";
+import { GrantConstraint, StorageSigning } from "../core/capabilities.js";
+import { SupabaseStorage } from "../supabase.js";
+import { Context, DateTime, Effect, Layer, Redacted } from "effect";
+declare const SupabaseUploadGrants_base: Context.ServiceClass<SupabaseUploadGrants, "@effect-kit/storage/supabase/SupabaseUploadGrants", {
+  readonly create: (input: {
+    readonly key: string;
+    readonly upsert?: boolean;
+  }) => Effect.Effect<{
+    readonly method: "PUT";
+    readonly url: Redacted.Redacted<string>;
+    readonly token: Redacted.Redacted<string>;
+    readonly headers: Redacted.Redacted<Readonly<Record<string, string>>>;
+    readonly expiresAt: DateTime.Utc;
+    readonly constraints: ReadonlyArray<GrantConstraint>;
+  }, ReturnType<typeof storageError>>;
+}>;
+export declare class SupabaseUploadGrants extends SupabaseUploadGrants_base {}
+export declare const SupabaseSigning: {
+  layer(): Layer.Layer<StorageSigning | SupabaseUploadGrants, never, SupabaseStorage>;
+};
+export {};
+//# sourceMappingURL=signing.d.ts.map