@effect-kit/storage 0.0.0-stage → 0.0.0

package/dist/gcs.js

@@ -0,0 +1,91 @@
+import { storageError } from "./core/errors.js";
+import { Storage as Storage$1 } 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/gcs/config.js";
+import { validateKey } from "./providers/gcs/validation.js";
+import { nativeOperations, preconditions } from "./providers/gcs/native.js";
+import { primitives, putObject } from "./providers/gcs/primitives.js";
+import { offsetUploads } from "./providers/gcs/resumable.js";
+import { Context, Effect, Layer } from "effect";
+import { Storage } from "@google-cloud/storage";
+
+// src/providers/gcs/index.ts
+function assemble(connection) {
+	return {
+		...primitives(connection),
+		...connection,
+		...nativeOperations(connection),
+		offsets: offsetUploads(connection),
+		putObject: (request, conditions = {}) => preconditions(conditions).pipe(Effect.flatMap((value) => putObject(connection, request, value)))
+	};
+}
+function services(storage) {
+	const driver = {
+		storage,
+		maximumObjectBytes: 5 * 1024 ** 4,
+		maximumSingleUploadBytes: 256 * 1024 ** 2,
+		transportOverheadBytes: 1024 ** 2,
+		offsets: storage.offsets,
+		validateUpload: ({ key }) => validateKey(key, "upload", true).pipe(Effect.asVoid),
+		reconcile: ({ key, operationId, size }) => storage.head({ key }).pipe(Effect.map((observed) => observed.size === size && observed.customMetadata?.["effect-storage-operation"] === operationId ? observed : void 0), Effect.catchReason("StorageError", "NotFound", () => Effect.succeed(void 0)))
+	};
+	return Context.make(Storage$1, storage).pipe(Context.add(GcsStorage, storage), Context.add(TransferDriver, driver));
+}
+var GcsStorage = class GcsStorage extends Context.Service()("@effect-kit/storage/gcs/GcsStorage") {
+	static make = Effect.fnUntraced(function* (input) {
+		const config = yield* resolveConfig(input);
+		const client = yield* Effect.try({
+			try: () => new Storage({
+				...input.projectId ? { projectId: input.projectId } : {},
+				...input.credentials ? { credentials: input.credentials } : {},
+				...input.authClient ? { authClient: input.authClient } : {},
+				...input.keyFilename ? { keyFilename: input.keyFilename } : {},
+				...input.apiEndpoint ? {
+					apiEndpoint: input.apiEndpoint,
+					useAuthWithCustomEndpoint: input.useAuthWithCustomEndpoint ?? true
+				} : {},
+				retryOptions: {
+					autoRetry: false,
+					maxRetries: 0
+				}
+			}),
+			catch: () => storageError("make", "gcs", {
+				_tag: "InvalidConfiguration",
+				field: "client"
+			})
+		});
+		if (client.apiEndpoint.replace(/\/$/u, "") !== config.apiEndpoint) return yield* storageError("make", "gcs", {
+			_tag: "InvalidConfiguration",
+			field: "client.endpoint"
+		});
+		return assemble({
+			config,
+			client
+		});
+	});
+	static makeClient = Effect.fnUntraced(function* (client, input) {
+		const config = yield* resolveConfig(input);
+		if (!input.storeId || input.credentials || input.authClient || input.keyFilename || client.apiEndpoint.replace(/\/$/u, "") !== config.apiEndpoint || client.retryOptions.autoRetry !== false || client.retryOptions.maxRetries !== 0) return yield* storageError("makeClient", "gcs", {
+			_tag: "InvalidConfiguration",
+			field: "client.policy"
+		});
+		return assemble({
+			config,
+			client
+		});
+	});
+	static layer(config) {
+		return Layer.effectContext(Effect.map(GcsStorage.make(config), services));
+	}
+	static layerClient(client, config) {
+		return Layer.effectContext(Effect.map(GcsStorage.makeClient(client, config), services));
+	}
+	static publicUrls(baseUrl) {
+		return Layer.effect(StoragePublicUrls, Effect.flatMap(GcsStorage, (storage) => makePublicUrls(storage, baseUrl ?? `${storage.config.apiEndpoint}/${encodeURIComponent(storage.config.bucket)}/`)));
+	}
+};
+
+export { GcsStorage };
+//# sourceMappingURL=gcs.js.map

package/dist/gcs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gcs.js","names":["Storage","GcsClient"],"sources":["../src/providers/gcs/index.ts"],"sourcesContent":["import { Context, Effect, Layer } from \"effect\";\n\nimport { Storage as GcsClient } from \"@google-cloud/storage\";\n\nimport { StoragePublicUrls } from \"../../core/capabilities.js\";\nimport { storageError } from \"../../core/errors.js\";\nimport type { PutRequest } from \"../../core/requests.js\";\nimport { Storage } from \"../../core/storage.js\";\nimport { makePublicUrls } from \"../../internal/public-urls.js\";\nimport { TransferDriver } from \"../../transfers/dependencies.js\";\nimport type { TransferEndpoint } from \"../../transfers/models.js\";\nimport { resolveConfig } from \"./config.js\";\nimport type { GcsConfig, GcsConnection } from \"./config.js\";\nimport { nativeOperations, preconditions } from \"./native.js\";\nimport type { GcsPreconditions } from \"./native.js\";\nimport { primitives, putObject } from \"./primitives.js\";\nimport { offsetUploads } from \"./resumable.js\";\nimport { validateKey } from \"./validation.js\";\n\nexport type { GcsConfig } from \"./config.js\";\nexport type { GcsPreconditions } from \"./native.js\";\nfunction assemble(connection: GcsConnection) {\n  return {\n    ...primitives(connection),\n    ...connection,\n    ...nativeOperations(connection),\n    offsets: offsetUploads(connection),\n    putObject: <E = never, R = never>(\n      request: PutRequest<E, R>,\n      conditions: GcsPreconditions = {},\n    ) =>\n      preconditions(conditions).pipe(\n        Effect.flatMap((value) => putObject(connection, request, value)),\n      ),\n  };\n}\nexport type GcsStorageService = ReturnType<typeof assemble>;\nfunction services(storage: GcsStorageService) {\n  const driver: TransferEndpoint = {\n    storage,\n    maximumObjectBytes: 5 * 1024 ** 4,\n    maximumSingleUploadBytes: 256 * 1024 ** 2,\n    transportOverheadBytes: 1024 ** 2,\n    offsets: storage.offsets,\n    validateUpload: ({ key }) => validateKey(key, \"upload\", true).pipe(Effect.asVoid),\n    reconcile: ({ key, operationId, size }) =>\n      storage.head({ key }).pipe(\n        Effect.map((observed) =>\n          observed.size === size &&\n          observed.customMetadata?.[\"effect-storage-operation\"] === operationId\n            ? observed\n            : undefined,\n        ),\n        Effect.catchReason(\"StorageError\", \"NotFound\", () => Effect.succeed(undefined)),\n      ),\n  };\n  return Context.make(Storage, storage).pipe(\n    Context.add(GcsStorage, storage),\n    Context.add(TransferDriver, driver),\n  );\n}\nexport class GcsStorage extends Context.Service<GcsStorage, GcsStorageService>()(\n  \"@effect-kit/storage/gcs/GcsStorage\",\n) {\n  static readonly make = Effect.fnUntraced(function* (input: GcsConfig) {\n    const config = yield* resolveConfig(input);\n    const client = yield* Effect.try({\n      try: () =>\n        new GcsClient({\n          ...(input.projectId ? { projectId: input.projectId } : {}),\n          ...(input.credentials ? { credentials: input.credentials } : {}),\n          ...(input.authClient ? { authClient: input.authClient } : {}),\n          ...(input.keyFilename ? { keyFilename: input.keyFilename } : {}),\n          ...(input.apiEndpoint\n            ? {\n                apiEndpoint: input.apiEndpoint,\n                useAuthWithCustomEndpoint: input.useAuthWithCustomEndpoint ?? true,\n              }\n            : {}),\n          retryOptions: { autoRetry: false, maxRetries: 0 },\n        }),\n      catch: () => storageError(\"make\", \"gcs\", { _tag: \"InvalidConfiguration\", field: \"client\" }),\n    });\n    if (client.apiEndpoint.replace(/\\/$/u, \"\") !== config.apiEndpoint)\n      return yield* storageError(\"make\", \"gcs\", {\n        _tag: \"InvalidConfiguration\",\n        field: \"client.endpoint\",\n      });\n    return assemble({ config, client });\n  });\n  static readonly makeClient = Effect.fnUntraced(function* (client: GcsClient, input: GcsConfig) {\n    const config = yield* resolveConfig(input);\n    if (\n      !input.storeId ||\n      input.credentials ||\n      input.authClient ||\n      input.keyFilename ||\n      client.apiEndpoint.replace(/\\/$/u, \"\") !== config.apiEndpoint ||\n      client.retryOptions.autoRetry !== false ||\n      client.retryOptions.maxRetries !== 0\n    )\n      return yield* storageError(\"makeClient\", \"gcs\", {\n        _tag: \"InvalidConfiguration\",\n        field: \"client.policy\",\n      });\n    return assemble({ config, client });\n  });\n  static layer(config: GcsConfig) {\n    return Layer.effectContext(Effect.map(GcsStorage.make(config), services));\n  }\n  static layerClient(client: GcsClient, config: GcsConfig) {\n    return Layer.effectContext(Effect.map(GcsStorage.makeClient(client, config), services));\n  }\n  static publicUrls(baseUrl?: string) {\n    return Layer.effect(\n      StoragePublicUrls,\n      Effect.flatMap(GcsStorage, (storage) =>\n        makePublicUrls(\n          storage,\n          baseUrl ?? `${storage.config.apiEndpoint}/${encodeURIComponent(storage.config.bucket)}/`,\n        ),\n      ),\n    );\n  }\n}\n"],"mappings":"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"}

package/dist/hetzner/admin.d.ts

@@ -0,0 +1,112 @@
+import { StorageError } from "../core/errors.js";
+import "../index.js";
+import { HetznerConfig } 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 HetznerAdminConfig = Omit<HetznerConfig, "bucket" | "storeId">;
+declare const HetznerAdministration_base: Context.ServiceClass<HetznerAdministration, "@effect-kit/storage/hetzner/HetznerAdministration", {
+  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 HetznerAdministration extends HetznerAdministration_base {
+  static make(config: HetznerAdminConfig): 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: HetznerAdminConfig): Layer.Layer<HetznerAdministration, StorageError, never>;
+}
+export {};
+//# sourceMappingURL=admin.d.ts.map

package/dist/hetzner/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/hetzner/admin.ts
+var HetznerAdministration = class HetznerAdministration extends Context.Service()("@effect-kit/storage/hetzner/HetznerAdministration") {
+	static make(config) {
+		return makeCompatible("hetzner", {
+			...config,
+			bucket: "administration"
+		}).pipe(Effect.map(makeAdministration));
+	}
+	static layer(config) {
+		return Layer.effect(HetznerAdministration, HetznerAdministration.make(config));
+	}
+};
+
+export { HetznerAdministration };
+//# sourceMappingURL=admin.js.map

package/dist/hetzner/admin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin.js","names":[],"sources":["../../src/providers/hetzner/admin.ts"],"sourcesContent":["import { Context, Effect, Layer } from \"effect\";\n\nimport type { HetznerConfig } 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 HetznerAdminConfig = Omit<HetznerConfig, \"bucket\" | \"storeId\">;\nexport class HetznerAdministration extends Context.Service<\n  HetznerAdministration,\n  S3AdministrationService\n>()(\"@effect-kit/storage/hetzner/HetznerAdministration\") {\n  static make(config: HetznerAdminConfig) {\n    return makeCompatible(\"hetzner\", { ...config, bucket: \"administration\" }).pipe(\n      Effect.map(makeAdministration),\n    );\n  }\n  static layer(config: HetznerAdminConfig) {\n    return Layer.effect(HetznerAdministration, HetznerAdministration.make(config));\n  }\n}\n"],"mappings":";;;;;AAQA,IAAa,wBAAb,MAAa,8BAA8B,QAAQ,QAGjD,CAAC,CAAC,mDAAmD,CAAC,CAAC;CACvD,OAAO,KAAK,QAA4B;EACtC,OAAO,eAAe,WAAW;GAAE,GAAG;GAAQ,QAAQ;EAAiB,CAAC,CAAC,CAAC,KACxE,OAAO,IAAI,kBAAkB,CAC/B;CACF;CACA,OAAO,MAAM,QAA4B;EACvC,OAAO,MAAM,OAAO,uBAAuB,sBAAsB,KAAK,MAAM,CAAC;CAC/E;AACF"}

package/dist/hetzner.d.ts

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

package/dist/hetzner.js

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

package/dist/hetzner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hetzner.js","names":[],"sources":["../src/providers/hetzner/index.ts"],"sourcesContent":["import { Context } from \"effect\";\n\nimport type { HetznerConfig } from \"../s3-compatible/config.js\";\nimport { compatibleLayer, makeCompatible } from \"../s3-compatible/service.js\";\nimport type { S3StorageService } from \"../s3/index.js\";\n\nexport type { HetznerConfig } from \"../s3-compatible/config.js\";\n\nexport class HetznerStorage extends Context.Service<HetznerStorage, S3StorageService>()(\n  \"@effect-kit/storage/hetzner/HetznerStorage\",\n) {\n  static make(config: HetznerConfig) {\n    return makeCompatible(\"hetzner\", config);\n  }\n  static layer(config: HetznerConfig) {\n    return compatibleLayer(HetznerStorage, HetznerStorage.make(config));\n  }\n}\n"],"mappings":";;;;AAQA,IAAa,iBAAb,MAAa,uBAAuB,QAAQ,QAA0C,CAAC,CACrF,4CACF,CAAC,CAAC;CACA,OAAO,KAAK,QAAuB;EACjC,OAAO,eAAe,WAAW,MAAM;CACzC;CACA,OAAO,MAAM,QAAuB;EAClC,OAAO,gBAAgB,gBAAgB,eAAe,KAAK,MAAM,CAAC;CACpE;AACF"}

package/dist/http/api.d.ts

@@ -0,0 +1,236 @@
+import { Schema } from "effect";
+import { HttpApi, HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
+export declare const makeStorageUploadApi: (prefix?: `/${string}`) => HttpApi.HttpApi<"storage-uploads-v1", HttpApiGroup.HttpApiGroup<"uploads", HttpApiEndpoint.HttpApiEndpoint<"abort", "DELETE", `/${string}/uploads/:id`, Schema.toCodecStringTree<Schema.Struct<{
+  id: Schema.String;
+}>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
+  readonly version: Schema.Literal<1>;
+  readonly id: Schema.String;
+  readonly state: Schema.Literals<readonly ["reserving", "ready", "initiating", "uploading", "verifying", "publishing", "published", "aborted", "rejected"]>;
+  readonly expiresAt: Schema.Number;
+  readonly cleanupPending: Schema.Boolean;
+  readonly result: Schema.optional<Schema.Unknown>;
+}>>, Schema.toCodecJson<Schema.Struct<{
+  readonly _tag: Schema.Literal<"UploadError">;
+  readonly code: Schema.Literal<"BadRequest" | "Conflict" | "Expired" | "Forbidden" | "NotFound" | "Unauthorized" | "Unavailable" | "Unsupported" | "VerificationFailed">;
+}>>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"complete", "POST", `/${string}/uploads/:id/complete`, Schema.toCodecStringTree<Schema.Struct<{
+  id: Schema.String;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+  readonly parts: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly partNumber: Schema.Int;
+    readonly receipt: Schema.NonEmptyString;
+  }>>>;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+  readonly version: Schema.Literal<1>;
+  readonly id: Schema.String;
+  readonly state: Schema.Literals<readonly ["reserving", "ready", "initiating", "uploading", "verifying", "publishing", "published", "aborted", "rejected"]>;
+  readonly expiresAt: Schema.Number;
+  readonly cleanupPending: Schema.Boolean;
+  readonly result: Schema.optional<Schema.Unknown>;
+}>>, Schema.toCodecJson<Schema.Struct<{
+  readonly _tag: Schema.Literal<"UploadError">;
+  readonly code: Schema.Literal<"BadRequest" | "Conflict" | "Expired" | "Forbidden" | "NotFound" | "Unauthorized" | "Unavailable" | "Unsupported" | "VerificationFailed">;
+}>>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"create", "POST", `/${string}/uploads`, never, never, Schema.toCodecJson<Schema.Struct<{
+  readonly version: Schema.Literal<1>;
+  readonly idempotencyKey: Schema.String;
+  readonly input: Schema.Struct<{
+    readonly purpose: Schema.NonEmptyString;
+    readonly file: Schema.Struct<{
+      readonly name: Schema.String;
+      readonly size: Schema.Natural;
+      readonly contentType: Schema.String;
+      readonly sha256: Schema.String;
+    }>;
+    readonly context: Schema.$Record<Schema.String, Schema.String>;
+    readonly strategy: Schema.optional<Schema.Literals<readonly ["auto", "single", "post", "multipart", "resumable", "proxy"]>>;
+  }>;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+  readonly version: Schema.Literal<1>;
+  readonly id: Schema.String;
+  readonly state: Schema.Literals<readonly ["reserving", "ready", "initiating", "uploading", "verifying", "publishing", "published", "aborted", "rejected"]>;
+  readonly expiresAt: Schema.Number;
+  readonly cleanupPending: Schema.Boolean;
+  readonly result: Schema.optional<Schema.Unknown>;
+}>>, Schema.toCodecJson<Schema.Struct<{
+  readonly _tag: Schema.Literal<"UploadError">;
+  readonly code: Schema.Literal<"BadRequest" | "Conflict" | "Expired" | "Forbidden" | "NotFound" | "Unauthorized" | "Unavailable" | "Unsupported" | "VerificationFailed">;
+}>>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"grant", "POST", `/${string}/uploads/:id/grants`, Schema.toCodecStringTree<Schema.Struct<{
+  id: Schema.String;
+}>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
+  readonly version: Schema.Literal<1>;
+  readonly id: Schema.String;
+  readonly grant: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"SignedRequest">;
+    readonly constraints: Schema.optional<Schema.$Array<Schema.Struct<{
+      readonly kind: Schema.String;
+      readonly enforcement: Schema.Literals<readonly ["provider", "backend", "advisory"]>;
+      readonly value: Schema.Union<readonly [Schema.String, Schema.Number]>;
+    }>>>;
+    readonly method: Schema.Literal<"PUT">;
+    readonly url: Schema.String;
+    readonly headers: Schema.$Record<Schema.String, Schema.String>;
+    readonly expiresAt: Schema.Number;
+    readonly partReceipt: Schema.optional<Schema.String>;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"PostForm">;
+    readonly constraints: Schema.optional<Schema.$Array<Schema.Struct<{
+      readonly kind: Schema.String;
+      readonly enforcement: Schema.Literals<readonly ["provider", "backend", "advisory"]>;
+      readonly value: Schema.Union<readonly [Schema.String, Schema.Number]>;
+    }>>>;
+    readonly url: Schema.String;
+    readonly fields: Schema.$Record<Schema.String, Schema.String>;
+    readonly expiresAt: Schema.Number;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Multipart">;
+    readonly constraints: Schema.optional<Schema.$Array<Schema.Struct<{
+      readonly kind: Schema.String;
+      readonly enforcement: Schema.Literals<readonly ["provider", "backend", "advisory"]>;
+      readonly value: Schema.Union<readonly [Schema.String, Schema.Number]>;
+    }>>>;
+    readonly partBytes: Schema.Int;
+    readonly checksum: Schema.optional<Schema.Literal<"sha256">>;
+    readonly expiresAt: Schema.Number;
+    readonly completed: Schema.$Array<Schema.Struct<{
+      readonly partNumber: Schema.Natural;
+      readonly etag: Schema.String;
+    }>>;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Blocks">;
+    readonly constraints: Schema.optional<Schema.$Array<Schema.Struct<{
+      readonly kind: Schema.String;
+      readonly enforcement: Schema.Literals<readonly ["provider", "backend", "advisory"]>;
+      readonly value: Schema.Union<readonly [Schema.String, Schema.Number]>;
+    }>>>;
+    readonly partBytes: Schema.Int;
+    readonly completed: Schema.$Array<Schema.Natural>;
+    readonly expiresAt: Schema.Number;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Resumable">;
+    readonly constraints: Schema.optional<Schema.$Array<Schema.Struct<{
+      readonly kind: Schema.String;
+      readonly enforcement: Schema.Literals<readonly ["provider", "backend", "advisory"]>;
+      readonly value: Schema.Union<readonly [Schema.String, Schema.Number]>;
+    }>>>;
+    readonly protocol: Schema.Literals<readonly ["gcs", "tus"]>;
+    readonly url: Schema.String;
+    readonly headers: Schema.$Record<Schema.String, Schema.String>;
+    readonly offset: Schema.Natural;
+    readonly chunkBytes: Schema.Int;
+    readonly expiresAt: Schema.Number;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Proxy">;
+    readonly constraints: Schema.optional<Schema.$Array<Schema.Struct<{
+      readonly kind: Schema.String;
+      readonly enforcement: Schema.Literals<readonly ["provider", "backend", "advisory"]>;
+      readonly value: Schema.Union<readonly [Schema.String, Schema.Number]>;
+    }>>>;
+    readonly expiresAt: Schema.Number;
+  }>]>;
+}>>, Schema.toCodecJson<Schema.Struct<{
+  readonly _tag: Schema.Literal<"UploadError">;
+  readonly code: Schema.Literal<"BadRequest" | "Conflict" | "Expired" | "Forbidden" | "NotFound" | "Unauthorized" | "Unavailable" | "Unsupported" | "VerificationFailed">;
+}>>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"part", "POST", `/${string}/uploads/:id/parts/sign`, Schema.toCodecStringTree<Schema.Struct<{
+  id: Schema.String;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+  readonly sha256: Schema.optional<Schema.String>;
+  readonly partNumber: Schema.Int;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+  readonly version: Schema.Literal<1>;
+  readonly id: Schema.String;
+  readonly grant: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"SignedRequest">;
+    readonly constraints: Schema.optional<Schema.$Array<Schema.Struct<{
+      readonly kind: Schema.String;
+      readonly enforcement: Schema.Literals<readonly ["provider", "backend", "advisory"]>;
+      readonly value: Schema.Union<readonly [Schema.String, Schema.Number]>;
+    }>>>;
+    readonly method: Schema.Literal<"PUT">;
+    readonly url: Schema.String;
+    readonly headers: Schema.$Record<Schema.String, Schema.String>;
+    readonly expiresAt: Schema.Number;
+    readonly partReceipt: Schema.optional<Schema.String>;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"PostForm">;
+    readonly constraints: Schema.optional<Schema.$Array<Schema.Struct<{
+      readonly kind: Schema.String;
+      readonly enforcement: Schema.Literals<readonly ["provider", "backend", "advisory"]>;
+      readonly value: Schema.Union<readonly [Schema.String, Schema.Number]>;
+    }>>>;
+    readonly url: Schema.String;
+    readonly fields: Schema.$Record<Schema.String, Schema.String>;
+    readonly expiresAt: Schema.Number;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Multipart">;
+    readonly constraints: Schema.optional<Schema.$Array<Schema.Struct<{
+      readonly kind: Schema.String;
+      readonly enforcement: Schema.Literals<readonly ["provider", "backend", "advisory"]>;
+      readonly value: Schema.Union<readonly [Schema.String, Schema.Number]>;
+    }>>>;
+    readonly partBytes: Schema.Int;
+    readonly checksum: Schema.optional<Schema.Literal<"sha256">>;
+    readonly expiresAt: Schema.Number;
+    readonly completed: Schema.$Array<Schema.Struct<{
+      readonly partNumber: Schema.Natural;
+      readonly etag: Schema.String;
+    }>>;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Blocks">;
+    readonly constraints: Schema.optional<Schema.$Array<Schema.Struct<{
+      readonly kind: Schema.String;
+      readonly enforcement: Schema.Literals<readonly ["provider", "backend", "advisory"]>;
+      readonly value: Schema.Union<readonly [Schema.String, Schema.Number]>;
+    }>>>;
+    readonly partBytes: Schema.Int;
+    readonly completed: Schema.$Array<Schema.Natural>;
+    readonly expiresAt: Schema.Number;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Resumable">;
+    readonly constraints: Schema.optional<Schema.$Array<Schema.Struct<{
+      readonly kind: Schema.String;
+      readonly enforcement: Schema.Literals<readonly ["provider", "backend", "advisory"]>;
+      readonly value: Schema.Union<readonly [Schema.String, Schema.Number]>;
+    }>>>;
+    readonly protocol: Schema.Literals<readonly ["gcs", "tus"]>;
+    readonly url: Schema.String;
+    readonly headers: Schema.$Record<Schema.String, Schema.String>;
+    readonly offset: Schema.Natural;
+    readonly chunkBytes: Schema.Int;
+    readonly expiresAt: Schema.Number;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Proxy">;
+    readonly constraints: Schema.optional<Schema.$Array<Schema.Struct<{
+      readonly kind: Schema.String;
+      readonly enforcement: Schema.Literals<readonly ["provider", "backend", "advisory"]>;
+      readonly value: Schema.Union<readonly [Schema.String, Schema.Number]>;
+    }>>>;
+    readonly expiresAt: Schema.Number;
+  }>]>;
+}>>, Schema.toCodecJson<Schema.Struct<{
+  readonly _tag: Schema.Literal<"UploadError">;
+  readonly code: Schema.Literal<"BadRequest" | "Conflict" | "Expired" | "Forbidden" | "NotFound" | "Unauthorized" | "Unavailable" | "Unsupported" | "VerificationFailed">;
+}>>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"reconcile", "POST", `/${string}/uploads/:id/reconcile`, Schema.toCodecStringTree<Schema.Struct<{
+  id: Schema.String;
+}>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
+  readonly version: Schema.Literal<1>;
+  readonly id: Schema.String;
+  readonly state: Schema.Literals<readonly ["reserving", "ready", "initiating", "uploading", "verifying", "publishing", "published", "aborted", "rejected"]>;
+  readonly expiresAt: Schema.Number;
+  readonly cleanupPending: Schema.Boolean;
+  readonly result: Schema.optional<Schema.Unknown>;
+}>>, Schema.toCodecJson<Schema.Struct<{
+  readonly _tag: Schema.Literal<"UploadError">;
+  readonly code: Schema.Literal<"BadRequest" | "Conflict" | "Expired" | "Forbidden" | "NotFound" | "Unauthorized" | "Unavailable" | "Unsupported" | "VerificationFailed">;
+}>>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"status", "GET", `/${string}/uploads/:id`, Schema.toCodecStringTree<Schema.Struct<{
+  id: Schema.String;
+}>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
+  readonly version: Schema.Literal<1>;
+  readonly id: Schema.String;
+  readonly state: Schema.Literals<readonly ["reserving", "ready", "initiating", "uploading", "verifying", "publishing", "published", "aborted", "rejected"]>;
+  readonly expiresAt: Schema.Number;
+  readonly cleanupPending: Schema.Boolean;
+  readonly result: Schema.optional<Schema.Unknown>;
+}>>, Schema.toCodecJson<Schema.Struct<{
+  readonly _tag: Schema.Literal<"UploadError">;
+  readonly code: Schema.Literal<"BadRequest" | "Conflict" | "Expired" | "Forbidden" | "NotFound" | "Unauthorized" | "Unavailable" | "Unsupported" | "VerificationFailed">;
+}>>, never, never>, false>>;
+//# sourceMappingURL=api.d.ts.map

package/dist/http/api.js

@@ -0,0 +1,54 @@
+import { GrantResponse, PartRequest, PartsRequest, UploadId, UploadRequest, UploadStatus } from "../uploads/schema.js";
+import { Record, Schema } from "effect";
+import { HttpApi, HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api";
+
+// src/http/api.ts
+const uploadErrorStatuses = {
+	BadRequest: 400,
+	Unauthorized: 401,
+	Forbidden: 403,
+	NotFound: 404,
+	Conflict: 409,
+	Expired: 410,
+	Unsupported: 422,
+	VerificationFailed: 422,
+	Unavailable: 503
+};
+const errors = Record.toEntries(uploadErrorStatuses).map(([code, status]) => Schema.Struct({
+	_tag: Schema.Literal("UploadError"),
+	code: Schema.Literal(code)
+}).pipe(HttpApiSchema.status(status)));
+const makeStorageUploadApi = (prefix = "/storage") => HttpApi.make("storage-uploads-v1").add(HttpApiGroup.make("uploads").add(HttpApiEndpoint.post("create", "/uploads", {
+	payload: UploadRequest,
+	success: UploadStatus,
+	error: errors
+}), HttpApiEndpoint.get("status", "/uploads/:id", {
+	params: { id: UploadId },
+	success: UploadStatus,
+	error: errors
+}), HttpApiEndpoint.post("grant", "/uploads/:id/grants", {
+	params: { id: UploadId },
+	success: GrantResponse,
+	error: errors
+}), HttpApiEndpoint.post("part", "/uploads/:id/parts/sign", {
+	params: { id: UploadId },
+	payload: PartRequest,
+	success: GrantResponse,
+	error: errors
+}), HttpApiEndpoint.post("complete", "/uploads/:id/complete", {
+	params: { id: UploadId },
+	payload: Schema.Struct({ parts: Schema.optional(PartsRequest.fields.parts) }),
+	success: UploadStatus,
+	error: errors
+}), HttpApiEndpoint.post("reconcile", "/uploads/:id/reconcile", {
+	params: { id: UploadId },
+	success: UploadStatus,
+	error: errors
+}), HttpApiEndpoint.delete("abort", "/uploads/:id", {
+	params: { id: UploadId },
+	success: UploadStatus,
+	error: errors
+})).prefix(prefix));
+
+export { makeStorageUploadApi, uploadErrorStatuses };
+//# sourceMappingURL=api.js.map

package/dist/http/api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.js","names":[],"sources":["../../src/http/api.ts"],"sourcesContent":["import { Record, Schema } from \"effect\";\nimport { HttpApi, HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from \"effect/http-api\";\n\nimport {\n  GrantResponse,\n  PartRequest,\n  PartsRequest,\n  UploadId,\n  UploadRequest,\n  UploadStatus,\n} from \"../uploads/schema.js\";\nexport const uploadErrorStatuses = {\n  BadRequest: 400,\n  Unauthorized: 401,\n  Forbidden: 403,\n  NotFound: 404,\n  Conflict: 409,\n  Expired: 410,\n  Unsupported: 422,\n  VerificationFailed: 422,\n  Unavailable: 503,\n} as const;\nconst errors = Record.toEntries(uploadErrorStatuses).map(([code, status]) =>\n  Schema.Struct({ _tag: Schema.Literal(\"UploadError\"), code: Schema.Literal(code) }).pipe(\n    HttpApiSchema.status(status),\n  ),\n);\nexport const makeStorageUploadApi = (prefix: `/${string}` = \"/storage\") =>\n  HttpApi.make(\"storage-uploads-v1\").add(\n    HttpApiGroup.make(\"uploads\")\n      .add(\n        HttpApiEndpoint.post(\"create\", \"/uploads\", {\n          payload: UploadRequest,\n          success: UploadStatus,\n          error: errors,\n        }),\n        HttpApiEndpoint.get(\"status\", \"/uploads/:id\", {\n          params: { id: UploadId },\n          success: UploadStatus,\n          error: errors,\n        }),\n        HttpApiEndpoint.post(\"grant\", \"/uploads/:id/grants\", {\n          params: { id: UploadId },\n          success: GrantResponse,\n          error: errors,\n        }),\n        HttpApiEndpoint.post(\"part\", \"/uploads/:id/parts/sign\", {\n          params: { id: UploadId },\n          payload: PartRequest,\n          success: GrantResponse,\n          error: errors,\n        }),\n        HttpApiEndpoint.post(\"complete\", \"/uploads/:id/complete\", {\n          params: { id: UploadId },\n          payload: Schema.Struct({ parts: Schema.optional(PartsRequest.fields.parts) }),\n          success: UploadStatus,\n          error: errors,\n        }),\n        HttpApiEndpoint.post(\"reconcile\", \"/uploads/:id/reconcile\", {\n          params: { id: UploadId },\n          success: UploadStatus,\n          error: errors,\n        }),\n        HttpApiEndpoint.delete(\"abort\", \"/uploads/:id\", {\n          params: { id: UploadId },\n          success: UploadStatus,\n          error: errors,\n        }),\n      )\n      .prefix(prefix),\n  );\n"],"mappings":";;;;;AAWA,MAAa,sBAAsB;CACjC,YAAY;CACZ,cAAc;CACd,WAAW;CACX,UAAU;CACV,UAAU;CACV,SAAS;CACT,aAAa;CACb,oBAAoB;CACpB,aAAa;AACf;AACA,MAAM,SAAS,OAAO,UAAU,mBAAmB,CAAC,CAAC,KAAK,CAAC,MAAM,YAC/D,OAAO,OAAO;CAAE,MAAM,OAAO,QAAQ,aAAa;CAAG,MAAM,OAAO,QAAQ,IAAI;AAAE,CAAC,CAAC,CAAC,KACjF,cAAc,OAAO,MAAM,CAC7B,CACF;AACA,MAAa,wBAAwB,SAAuB,eAC1D,QAAQ,KAAK,oBAAoB,CAAC,CAAC,IACjC,aAAa,KAAK,SAAS,CAAC,CACzB,IACC,gBAAgB,KAAK,UAAU,YAAY;CACzC,SAAS;CACT,SAAS;CACT,OAAO;AACT,CAAC,GACD,gBAAgB,IAAI,UAAU,gBAAgB;CAC5C,QAAQ,EAAE,IAAI,SAAS;CACvB,SAAS;CACT,OAAO;AACT,CAAC,GACD,gBAAgB,KAAK,SAAS,uBAAuB;CACnD,QAAQ,EAAE,IAAI,SAAS;CACvB,SAAS;CACT,OAAO;AACT,CAAC,GACD,gBAAgB,KAAK,QAAQ,2BAA2B;CACtD,QAAQ,EAAE,IAAI,SAAS;CACvB,SAAS;CACT,SAAS;CACT,OAAO;AACT,CAAC,GACD,gBAAgB,KAAK,YAAY,yBAAyB;CACxD,QAAQ,EAAE,IAAI,SAAS;CACvB,SAAS,OAAO,OAAO,EAAE,OAAO,OAAO,SAAS,aAAa,OAAO,KAAK,EAAE,CAAC;CAC5E,SAAS;CACT,OAAO;AACT,CAAC,GACD,gBAAgB,KAAK,aAAa,0BAA0B;CAC1D,QAAQ,EAAE,IAAI,SAAS;CACvB,SAAS;CACT,OAAO;AACT,CAAC,GACD,gBAAgB,OAAO,SAAS,gBAAgB;CAC9C,QAAQ,EAAE,IAAI,SAAS;CACvB,SAAS;CACT,OAAO;AACT,CAAC,CACH,CAAC,CACA,OAAO,MAAM,CAClB"}