@effect-kit/storage 0.0.0-stage → 0.0.0

package/dist/client/transport.js

@@ -0,0 +1,78 @@
+import { failUpload } from "../uploads/schema.js";
+import { Effect } from "effect";
+
+// src/client/transport.ts
+const providerUrl = (value) => Effect.try({
+	try: () => {
+		const url = new URL(value);
+		if (url.username || url.password || url.hash || url.protocol !== "https:" && !(url.protocol === "http:" && [
+			"127.0.0.1",
+			"localhost",
+			"[::1]"
+		].includes(url.hostname))) throw new Error("Invalid grant endpoint");
+		return url.href;
+	},
+	catch: () => failUpload("BadRequest")
+});
+const fetchTransfer = (url, method, headers, body) => Effect.tryPromise({
+	try: async (signal) => {
+		const response = await fetch(url, {
+			method,
+			headers,
+			body,
+			credentials: "omit",
+			redirect: "error",
+			signal
+		});
+		await response.body?.cancel();
+		return {
+			status: response.status,
+			headers: response.headers
+		};
+	},
+	catch: () => failUpload("Unavailable")
+});
+const xhrTransfer = (url, method, headers, body, progress) => Effect.callback((resume) => {
+	if (typeof XMLHttpRequest === "undefined") {
+		resume(Effect.fail(failUpload("Unsupported")));
+		return;
+	}
+	const xhr = new XMLHttpRequest();
+	const listeners = new AbortController();
+	try {
+		xhr.open(method, url);
+		xhr.withCredentials = false;
+		for (const [name, value] of Object.entries(headers)) if (!["content-length", "host"].includes(name.toLowerCase())) xhr.setRequestHeader(name, value);
+		xhr.upload.addEventListener("progress", (event) => {
+			try {
+				progress(event.loaded);
+			} catch {
+				xhr.abort();
+				resume(Effect.fail(failUpload("Unavailable")));
+			}
+		}, { signal: listeners.signal });
+		xhr.addEventListener("load", () => {
+			const parsed = new Headers();
+			for (const line of xhr.getAllResponseHeaders().trim().split(/[\r\n]+/u)) {
+				const colon = line.indexOf(":");
+				if (colon > 0) parsed.append(line.slice(0, colon), line.slice(colon + 1).trim());
+			}
+			resume(Effect.succeed({
+				status: xhr.status,
+				headers: parsed
+			}));
+		}, { signal: listeners.signal });
+		xhr.addEventListener("error", () => resume(Effect.fail(failUpload("Unavailable"))), { signal: listeners.signal });
+		xhr.addEventListener("abort", () => resume(Effect.fail(failUpload("Unavailable"))), { signal: listeners.signal });
+		xhr.send(body);
+	} catch {
+		resume(Effect.fail(failUpload("Unavailable")));
+	}
+	return Effect.sync(() => {
+		listeners.abort();
+		xhr.abort();
+	});
+});
+
+export { fetchTransfer, providerUrl, xhrTransfer };
+//# sourceMappingURL=transport.js.map

package/dist/client/transport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.js","names":[],"sources":["../../src/client/transport.ts"],"sourcesContent":["import { Effect } from \"effect\";\n\nimport { failUpload } from \"../uploads/schema.js\";\nexport interface UploadProgress {\n  readonly phase: \"hashing\" | \"authorizing\" | \"uploading\" | \"verifying\" | \"completed\";\n  readonly bytesSent?: number;\n  readonly bytesAccepted: number;\n  readonly totalBytes: number;\n  readonly measurement: \"xhr\" | \"provider-accepted\" | \"indeterminate\";\n}\nexport type Progress = (progress: UploadProgress) => void;\nexport const providerUrl = (value: string) =>\n  Effect.try({\n    try: () => {\n      const url = new URL(value);\n      if (\n        url.username ||\n        url.password ||\n        url.hash ||\n        (url.protocol !== \"https:\" &&\n          !(url.protocol === \"http:\" && [\"127.0.0.1\", \"localhost\", \"[::1]\"].includes(url.hostname)))\n      )\n        throw new Error(\"Invalid grant endpoint\");\n      return url.href;\n    },\n    catch: () => failUpload(\"BadRequest\"),\n  });\nexport const fetchTransfer = (\n  url: string,\n  method: string,\n  headers: Readonly<Record<string, string>>,\n  body: Blob | FormData,\n) =>\n  Effect.tryPromise({\n    try: async (signal) => {\n      const response = await fetch(url, {\n        method,\n        headers,\n        body,\n        credentials: \"omit\",\n        redirect: \"error\",\n        signal,\n      });\n      await response.body?.cancel();\n      return { status: response.status, headers: response.headers };\n    },\n    catch: () => failUpload(\"Unavailable\"),\n  });\nexport const xhrTransfer = (\n  url: string,\n  method: string,\n  headers: Readonly<Record<string, string>>,\n  body: Blob | FormData,\n  progress: (sent: number) => void,\n) =>\n  Effect.callback<\n    { readonly status: number; readonly headers: Headers },\n    ReturnType<typeof failUpload>\n  >((resume) => {\n    if (typeof XMLHttpRequest === \"undefined\") {\n      resume(Effect.fail(failUpload(\"Unsupported\")));\n      return;\n    }\n    const xhr = new XMLHttpRequest();\n    const listeners = new AbortController();\n    try {\n      xhr.open(method, url);\n      xhr.withCredentials = false;\n      for (const [name, value] of Object.entries(headers))\n        if (![\"content-length\", \"host\"].includes(name.toLowerCase()))\n          xhr.setRequestHeader(name, value);\n      xhr.upload.addEventListener(\n        \"progress\",\n        (event) => {\n          try {\n            progress(event.loaded);\n          } catch {\n            xhr.abort();\n            resume(Effect.fail(failUpload(\"Unavailable\")));\n          }\n        },\n        { signal: listeners.signal },\n      );\n      xhr.addEventListener(\n        \"load\",\n        () => {\n          const parsed = new Headers();\n          for (const line of xhr\n            .getAllResponseHeaders()\n            .trim()\n            .split(/[\\r\\n]+/u)) {\n            const colon = line.indexOf(\":\");\n            if (colon > 0) parsed.append(line.slice(0, colon), line.slice(colon + 1).trim());\n          }\n          resume(Effect.succeed({ status: xhr.status, headers: parsed }));\n        },\n        { signal: listeners.signal },\n      );\n      xhr.addEventListener(\"error\", () => resume(Effect.fail(failUpload(\"Unavailable\"))), {\n        signal: listeners.signal,\n      });\n      xhr.addEventListener(\"abort\", () => resume(Effect.fail(failUpload(\"Unavailable\"))), {\n        signal: listeners.signal,\n      });\n      xhr.send(body);\n    } catch {\n      resume(Effect.fail(failUpload(\"Unavailable\")));\n    }\n    return Effect.sync(() => {\n      listeners.abort();\n      xhr.abort();\n    });\n  });\n"],"mappings":";;;;AAWA,MAAa,eAAe,UAC1B,OAAO,IAAI;CACT,WAAW;EACT,MAAM,MAAM,IAAI,IAAI,KAAK;EACzB,IACE,IAAI,YACJ,IAAI,YACJ,IAAI,QACH,IAAI,aAAa,YAChB,EAAE,IAAI,aAAa,WAAW;GAAC;GAAa;GAAa;EAAO,CAAC,CAAC,SAAS,IAAI,QAAQ,IAEzF,MAAM,IAAI,MAAM,wBAAwB;EAC1C,OAAO,IAAI;CACb;CACA,aAAa,WAAW,YAAY;AACtC,CAAC;AACH,MAAa,iBACX,KACA,QACA,SACA,SAEA,OAAO,WAAW;CAChB,KAAK,OAAO,WAAW;EACrB,MAAM,WAAW,MAAM,MAAM,KAAK;GAChC;GACA;GACA;GACA,aAAa;GACb,UAAU;GACV;EACF,CAAC;EACD,MAAM,SAAS,MAAM,OAAO;EAC5B,OAAO;GAAE,QAAQ,SAAS;GAAQ,SAAS,SAAS;EAAQ;CAC9D;CACA,aAAa,WAAW,aAAa;AACvC,CAAC;AACH,MAAa,eACX,KACA,QACA,SACA,MACA,aAEA,OAAO,UAGJ,WAAW;CACZ,IAAI,OAAO,mBAAmB,aAAa;EACzC,OAAO,OAAO,KAAK,WAAW,aAAa,CAAC,CAAC;EAC7C;CACF;CACA,MAAM,MAAM,IAAI,eAAe;CAC/B,MAAM,YAAY,IAAI,gBAAgB;CACtC,IAAI;EACF,IAAI,KAAK,QAAQ,GAAG;EACpB,IAAI,kBAAkB;EACtB,KAAK,MAAM,CAAC,MAAM,UAAU,OAAO,QAAQ,OAAO,GAChD,IAAI,CAAC,CAAC,kBAAkB,MAAM,CAAC,CAAC,SAAS,KAAK,YAAY,CAAC,GACzD,IAAI,iBAAiB,MAAM,KAAK;EACpC,IAAI,OAAO,iBACT,aACC,UAAU;GACT,IAAI;IACF,SAAS,MAAM,MAAM;GACvB,QAAQ;IACN,IAAI,MAAM;IACV,OAAO,OAAO,KAAK,WAAW,aAAa,CAAC,CAAC;GAC/C;EACF,GACA,EAAE,QAAQ,UAAU,OAAO,CAC7B;EACA,IAAI,iBACF,cACM;GACJ,MAAM,SAAS,IAAI,QAAQ;GAC3B,KAAK,MAAM,QAAQ,IAChB,sBAAsB,CAAC,CACvB,KAAK,CAAC,CACN,MAAM,UAAU,GAAG;IACpB,MAAM,QAAQ,KAAK,QAAQ,GAAG;IAC9B,IAAI,QAAQ,GAAG,OAAO,OAAO,KAAK,MAAM,GAAG,KAAK,GAAG,KAAK,MAAM,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC;GACjF;GACA,OAAO,OAAO,QAAQ;IAAE,QAAQ,IAAI;IAAQ,SAAS;GAAO,CAAC,CAAC;EAChE,GACA,EAAE,QAAQ,UAAU,OAAO,CAC7B;EACA,IAAI,iBAAiB,eAAe,OAAO,OAAO,KAAK,WAAW,aAAa,CAAC,CAAC,GAAG,EAClF,QAAQ,UAAU,OACpB,CAAC;EACD,IAAI,iBAAiB,eAAe,OAAO,OAAO,KAAK,WAAW,aAAa,CAAC,CAAC,GAAG,EAClF,QAAQ,UAAU,OACpB,CAAC;EACD,IAAI,KAAK,IAAI;CACf,QAAQ;EACN,OAAO,OAAO,KAAK,WAAW,aAAa,CAAC,CAAC;CAC/C;CACA,OAAO,OAAO,WAAW;EACvB,UAAU,MAAM;EAChB,IAAI,MAAM;CACZ,CAAC;AACH,CAAC"}

package/dist/client.d.ts

@@ -0,0 +1,259 @@
+import { UploadError, UploadInput, failUpload } from "./uploads/schema.js";
+import { Progress, UploadProgress } from "./client/transport.js";
+import { ClientUploadStore, UploadClientStore, UploadTicket } from "./client/store.js";
+import { Context, Effect, Layer } from "effect";
+export type UploadProtocol = "single" | "post" | "multipart" | "resumable" | "proxy";
+export interface UploadClientOptions<R = never> {
+  readonly baseUrl: string;
+  readonly credentials?: RequestCredentials;
+  readonly headers?: () => Effect.Effect<Readonly<Record<string, string>>, ReturnType<typeof failUpload>, R>;
+  readonly store?: ClientUploadStore;
+  readonly transport?: "fetch" | "xhr";
+  readonly deadlineMillis?: number;
+}
+declare const UploadClient_base: Context.ServiceClass<UploadClient, "@effect-kit/storage/UploadClient", {
+  create: (input: {
+    readonly file: File;
+    readonly purpose: string;
+    readonly context: Readonly<Record<string, string>>;
+    readonly strategy?: UploadInput["strategy"];
+    readonly idempotencyKey?: string;
+    readonly onProgress?: Progress;
+  }) => Effect.Effect<{
+    version: 1;
+    idempotencyKey: string;
+    input: {
+      readonly purpose: string;
+      readonly file: {
+        readonly name: string;
+        readonly size: number;
+        readonly contentType: string;
+        readonly sha256: string;
+      };
+      readonly context: {
+        readonly [x: string]: string;
+      };
+      readonly strategy?: "auto" | "multipart" | "post" | "proxy" | "resumable" | "single" | undefined;
+    };
+    id: string;
+  }, UploadError, never>;
+  transfer: (input: {
+    readonly uploadId: string;
+    readonly file: File;
+    readonly onProgress?: Progress;
+    readonly onProtocol?: (protocol: UploadProtocol, uploadId: string) => void;
+  }) => Effect.Effect<{
+    uploadId: string;
+    parts: {
+      partNumber: number;
+      receipt: string;
+    }[];
+  }, UploadError, never>;
+  complete: (input: {
+    readonly uploadId: string;
+    readonly parts?: readonly {
+      readonly partNumber: number;
+      readonly receipt: string;
+    }[];
+    readonly onProgress?: Progress;
+  }) => Effect.Effect<{
+    readonly version: 1;
+    readonly id: string;
+    readonly state: "aborted" | "initiating" | "published" | "publishing" | "ready" | "rejected" | "reserving" | "uploading" | "verifying";
+    readonly expiresAt: number;
+    readonly cleanupPending: boolean;
+    readonly result?: unknown;
+  }, UploadError, never>;
+  status: (input: {
+    readonly uploadId: string;
+  }) => Effect.Effect<{
+    readonly version: 1;
+    readonly id: string;
+    readonly state: "aborted" | "initiating" | "published" | "publishing" | "ready" | "rejected" | "reserving" | "uploading" | "verifying";
+    readonly expiresAt: number;
+    readonly cleanupPending: boolean;
+    readonly result?: unknown;
+  }, UploadError, never>;
+  abort: (input: {
+    readonly uploadId: string;
+  }) => Effect.Effect<{
+    readonly version: 1;
+    readonly id: string;
+    readonly state: "aborted" | "initiating" | "published" | "publishing" | "ready" | "rejected" | "reserving" | "uploading" | "verifying";
+    readonly expiresAt: number;
+    readonly cleanupPending: boolean;
+    readonly result?: unknown;
+  }, UploadError, never>;
+  reconcile: (input: {
+    readonly uploadId: string;
+  }) => Effect.Effect<{
+    readonly version: 1;
+    readonly id: string;
+    readonly state: "aborted" | "initiating" | "published" | "publishing" | "ready" | "rejected" | "reserving" | "uploading" | "verifying";
+    readonly expiresAt: number;
+    readonly cleanupPending: boolean;
+    readonly result?: unknown;
+  }, UploadError, never>;
+  upload: (input: {
+    readonly file: File;
+    readonly purpose: string;
+    readonly context: Readonly<Record<string, string>>;
+    readonly strategy?: UploadInput["strategy"];
+    readonly idempotencyKey?: string;
+    readonly onProgress?: Progress;
+  }) => Effect.Effect<{
+    readonly version: 1;
+    readonly id: string;
+    readonly state: "aborted" | "initiating" | "published" | "publishing" | "ready" | "rejected" | "reserving" | "uploading" | "verifying";
+    readonly expiresAt: number;
+    readonly cleanupPending: boolean;
+    readonly result?: unknown;
+  }, UploadError, never>;
+  resume: (input: {
+    readonly uploadId: string;
+    readonly file: File;
+    readonly onProgress?: Progress;
+    readonly onProtocol?: (protocol: UploadProtocol, uploadId: string) => void;
+  }) => Effect.Effect<{
+    readonly version: 1;
+    readonly id: string;
+    readonly state: "aborted" | "initiating" | "published" | "publishing" | "ready" | "rejected" | "reserving" | "uploading" | "verifying";
+    readonly expiresAt: number;
+    readonly cleanupPending: boolean;
+    readonly result?: unknown;
+  }, UploadError, never>;
+}>;
+export declare class UploadClient extends UploadClient_base {
+  static readonly make: <R>(options: UploadClientOptions<R>) => Effect.Effect<{
+    create: (input: {
+      readonly file: File;
+      readonly purpose: string;
+      readonly context: Readonly<Record<string, string>>;
+      readonly strategy?: UploadInput["strategy"];
+      readonly idempotencyKey?: string;
+      readonly onProgress?: Progress;
+    }) => Effect.Effect<{
+      version: 1;
+      idempotencyKey: string;
+      input: {
+        readonly purpose: string;
+        readonly file: {
+          readonly name: string;
+          readonly size: number;
+          readonly contentType: string;
+          readonly sha256: string;
+        };
+        readonly context: {
+          readonly [x: string]: string;
+        };
+        readonly strategy?: "auto" | "multipart" | "post" | "proxy" | "resumable" | "single" | undefined;
+      };
+      id: string;
+    }, UploadError, never>;
+    transfer: (input: {
+      readonly uploadId: string;
+      readonly file: File;
+      readonly onProgress?: Progress;
+      readonly onProtocol?: (protocol: UploadProtocol, uploadId: string) => void;
+    }) => Effect.Effect<{
+      uploadId: string;
+      parts: {
+        partNumber: number;
+        receipt: string;
+      }[];
+    }, UploadError, never>;
+    complete: (input: {
+      readonly uploadId: string;
+      readonly parts?: ReadonlyArray<{
+        readonly partNumber: number;
+        readonly receipt: string;
+      }>;
+      readonly onProgress?: Progress;
+    }) => Effect.Effect<{
+      readonly version: 1;
+      readonly id: string;
+      readonly state: "aborted" | "initiating" | "published" | "publishing" | "ready" | "rejected" | "reserving" | "uploading" | "verifying";
+      readonly expiresAt: number;
+      readonly cleanupPending: boolean;
+      readonly result?: unknown;
+    }, UploadError, never>;
+    status: (input: {
+      readonly uploadId: string;
+    }) => Effect.Effect<{
+      readonly version: 1;
+      readonly id: string;
+      readonly state: "aborted" | "initiating" | "published" | "publishing" | "ready" | "rejected" | "reserving" | "uploading" | "verifying";
+      readonly expiresAt: number;
+      readonly cleanupPending: boolean;
+      readonly result?: unknown;
+    }, UploadError, never>;
+    abort: (input: {
+      readonly uploadId: string;
+    }) => Effect.Effect<{
+      readonly version: 1;
+      readonly id: string;
+      readonly state: "aborted" | "initiating" | "published" | "publishing" | "ready" | "rejected" | "reserving" | "uploading" | "verifying";
+      readonly expiresAt: number;
+      readonly cleanupPending: boolean;
+      readonly result?: unknown;
+    }, UploadError, never>;
+    reconcile: (input: {
+      readonly uploadId: string;
+    }) => Effect.Effect<{
+      readonly version: 1;
+      readonly id: string;
+      readonly state: "aborted" | "initiating" | "published" | "publishing" | "ready" | "rejected" | "reserving" | "uploading" | "verifying";
+      readonly expiresAt: number;
+      readonly cleanupPending: boolean;
+      readonly result?: unknown;
+    }, UploadError, never>;
+    upload: (input: Parameters<(input: {
+      readonly file: File;
+      readonly purpose: string;
+      readonly context: Readonly<Record<string, string>>;
+      readonly strategy?: UploadInput["strategy"];
+      readonly idempotencyKey?: string;
+      readonly onProgress?: Progress;
+    }) => Effect.Effect<{
+      version: 1;
+      idempotencyKey: string;
+      input: {
+        readonly purpose: string;
+        readonly file: {
+          readonly name: string;
+          readonly size: number;
+          readonly contentType: string;
+          readonly sha256: string;
+        };
+        readonly context: {
+          readonly [x: string]: string;
+        };
+        readonly strategy?: "auto" | "multipart" | "post" | "proxy" | "resumable" | "single" | undefined;
+      };
+      id: string;
+    }, UploadError, never>>[0]) => Effect.Effect<{
+      readonly version: 1;
+      readonly id: string;
+      readonly state: "aborted" | "initiating" | "published" | "publishing" | "ready" | "rejected" | "reserving" | "uploading" | "verifying";
+      readonly expiresAt: number;
+      readonly cleanupPending: boolean;
+      readonly result?: unknown;
+    }, UploadError, never>;
+    resume: (input: {
+      readonly uploadId: string;
+      readonly file: File;
+      readonly onProgress?: Progress;
+      readonly onProtocol?: (protocol: UploadProtocol, uploadId: string) => void;
+    }) => Effect.Effect<{
+      readonly version: 1;
+      readonly id: string;
+      readonly state: "aborted" | "initiating" | "published" | "publishing" | "ready" | "rejected" | "reserving" | "uploading" | "verifying";
+      readonly expiresAt: number;
+      readonly cleanupPending: boolean;
+      readonly result?: unknown;
+    }, UploadError, never>;
+  }, UploadError, R>;
+  static layer<R>(options: UploadClientOptions<R>): Layer.Layer<UploadClient, UploadError, Exclude<R, import("effect/Scope").Scope>>;
+}
+export { type ClientUploadStore, UploadClientStore, type UploadProgress, type UploadTicket };
+//# sourceMappingURL=client.d.ts.map