@uploadista/data-store-gcs 0.0.3

package/dist/services/gcs-client-rest.service.js

@@ -0,0 +1,299 @@
+import { UploadistaError } from "@uploadista/core/errors";
+import { Effect, Layer } from "effect";
+import { GCSClientService, } from "./gcs-client.service";
+function createRESTGCSClient(config) {
+    if (!config.accessToken) {
+        throw new Error("accessToken is required for REST API implementation");
+    }
+    const baseUrl = `https://storage.googleapis.com/storage/v1/b/${config.bucket}`;
+    const uploadUrl = `https://storage.googleapis.com/upload/storage/v1/b/${config.bucket}/o`;
+    const accessToken = config.accessToken;
+    const getAuthHeaders = () => ({
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json",
+    });
+    const getObject = (key) => Effect.tryPromise({
+        try: async () => {
+            const response = await fetch(`${baseUrl}/o/${encodeURIComponent(key)}?alt=media`, {
+                headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                },
+            });
+            if (!response.ok) {
+                if (response.status === 404) {
+                    throw new Error("File not found");
+                }
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            if (!response.body) {
+                throw new Error("body not found");
+            }
+            return response.body;
+        },
+        catch: (error) => {
+            if (error instanceof Error && error.message.includes("not found")) {
+                return UploadistaError.fromCode("FILE_NOT_FOUND");
+            }
+            return UploadistaError.fromCode("UNKNOWN_ERROR", { cause: error });
+        },
+    });
+    const getObjectMetadata = (key) => Effect.tryPromise({
+        try: async () => {
+            const response = await fetch(`${baseUrl}/o/${encodeURIComponent(key)}`, {
+                headers: getAuthHeaders(),
+            });
+            if (!response.ok) {
+                if (response.status === 404) {
+                    throw new Error("File not found");
+                }
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const data = (await response.json());
+            return {
+                name: data.name,
+                bucket: data.bucket,
+                size: data.size ? Number.parseInt(data.size, 10) : undefined,
+                contentType: data.contentType,
+                metadata: data.metadata || {},
+                generation: data.generation,
+                timeCreated: data.timeCreated,
+                updated: data.updated,
+            };
+        },
+        catch: (error) => {
+            if (error instanceof Error && error.message.includes("not found")) {
+                return UploadistaError.fromCode("FILE_NOT_FOUND");
+            }
+            return UploadistaError.fromCode("UNKNOWN_ERROR", { cause: error });
+        },
+    });
+    const objectExists = (key) => Effect.tryPromise({
+        try: async () => {
+            const response = await fetch(`${baseUrl}/o/${encodeURIComponent(key)}`, {
+                method: "HEAD",
+                headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                },
+            });
+            return response.ok;
+        },
+        catch: (error) => {
+            return UploadistaError.fromCode("UNKNOWN_ERROR", { cause: error });
+        },
+    });
+    const putObject = (key, body, context) => Effect.tryPromise({
+        try: async () => {
+            const metadata = {
+                name: key,
+                contentType: context?.contentType || "application/octet-stream",
+                metadata: context?.metadata || {},
+            };
+            const response = await fetch(`${uploadUrl}?uploadType=media&name=${encodeURIComponent(key)}`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                    "Content-Type": metadata.contentType,
+                    "Content-Length": body.length.toString(),
+                },
+                body: body,
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            return key;
+        },
+        catch: (error) => {
+            return UploadistaError.fromCode("FILE_WRITE_ERROR", { cause: error });
+        },
+    });
+    const deleteObject = (key) => Effect.tryPromise({
+        try: async () => {
+            const response = await fetch(`${baseUrl}/o/${encodeURIComponent(key)}`, {
+                method: "DELETE",
+                headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                },
+            });
+            // 404 is OK - object didn't exist
+            if (!response.ok && response.status !== 404) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+        },
+        catch: (error) => {
+            return UploadistaError.fromCode("UNKNOWN_ERROR", { cause: error });
+        },
+    });
+    const createResumableUpload = (context) => Effect.tryPromise({
+        try: async () => {
+            const metadata = {
+                name: context.key,
+                contentType: context.contentType || "application/octet-stream",
+                metadata: context.metadata || {},
+            };
+            const response = await fetch(`${uploadUrl}?uploadType=resumable&name=${encodeURIComponent(context.key)}`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(metadata),
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const resumableUploadUrl = response.headers.get("Location");
+            if (!resumableUploadUrl) {
+                throw new Error("No upload URL returned");
+            }
+            return resumableUploadUrl;
+        },
+        catch: (error) => {
+            return UploadistaError.fromCode("FILE_WRITE_ERROR", { cause: error });
+        },
+    });
+    const uploadChunk = (uploadUrl, chunk, start, total) => Effect.tryPromise({
+        try: async () => {
+            const end = start + chunk.length - 1;
+            const contentRange = total
+                ? `bytes ${start}-${end}/${total}`
+                : `bytes ${start}-${end}/*`;
+            const response = await fetch(uploadUrl, {
+                method: "PUT",
+                headers: {
+                    "Content-Length": chunk.length.toString(),
+                    "Content-Range": contentRange,
+                },
+                body: chunk,
+            });
+            // 308 means more data needed, 200/201 means complete
+            const completed = response.status === 200 || response.status === 201;
+            if (!completed && response.status !== 308) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            return {
+                completed,
+                bytesUploaded: end + 1,
+            };
+        },
+        catch: (error) => {
+            return UploadistaError.fromCode("FILE_WRITE_ERROR", { cause: error });
+        },
+    });
+    const getUploadStatus = (uploadUrl) => Effect.tryPromise({
+        try: async () => {
+            const response = await fetch(uploadUrl, {
+                method: "PUT",
+                headers: {
+                    "Content-Range": "bytes */*",
+                },
+            });
+            if (response.status === 308) {
+                // Upload incomplete
+                const range = response.headers.get("Range");
+                const bytesUploaded = range
+                    ? Number.parseInt(range.split("-")[1], 10) + 1
+                    : 0;
+                return {
+                    bytesUploaded,
+                    completed: false,
+                };
+            }
+            else if (response.status === 200 || response.status === 201) {
+                // Upload complete
+                return {
+                    bytesUploaded: 0, // We don't know the exact size
+                    completed: true,
+                };
+            }
+            else {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+        },
+        catch: (error) => {
+            return UploadistaError.fromCode("UNKNOWN_ERROR", { cause: error });
+        },
+    });
+    const cancelUpload = (uploadUrl) => Effect.tryPromise({
+        try: async () => {
+            // Cancel by sending DELETE to upload URL
+            await fetch(uploadUrl, {
+                method: "DELETE",
+            });
+        },
+        catch: (error) => {
+            return UploadistaError.fromCode("UNKNOWN_ERROR", { cause: error });
+        },
+    });
+    const composeObjects = (sourceKeys, destinationKey, context) => Effect.tryPromise({
+        try: async () => {
+            const composeRequest = {
+                kind: "storage#composeRequest",
+                sourceObjects: sourceKeys.map((key) => ({ name: key })),
+                destination: {
+                    name: destinationKey,
+                    contentType: context?.contentType || "application/octet-stream",
+                    metadata: context?.metadata || {},
+                },
+            };
+            const response = await fetch(`${baseUrl}/o/${encodeURIComponent(destinationKey)}/compose`, {
+                method: "POST",
+                headers: getAuthHeaders(),
+                body: JSON.stringify(composeRequest),
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            return destinationKey;
+        },
+        catch: (error) => {
+            return UploadistaError.fromCode("FILE_WRITE_ERROR", { cause: error });
+        },
+    });
+    const putTemporaryObject = (key, body, context) => putObject(`${key}_tmp`, body, context);
+    const getTemporaryObject = (key) => Effect.tryPromise({
+        try: async () => {
+            try {
+                return await getObject(`${key}_tmp`).pipe(Effect.runPromise);
+            }
+            catch {
+                return undefined;
+            }
+        },
+        catch: () => {
+            return UploadistaError.fromCode("UNKNOWN_ERROR");
+        },
+    });
+    const deleteTemporaryObject = (key) => deleteObject(`${key}_tmp`);
+    const getObjectBuffer = (key) => Effect.tryPromise({
+        try: async () => {
+            const response = await fetch(`${baseUrl}/o/${encodeURIComponent(key)}?alt=media`, {
+                headers: getAuthHeaders(),
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            return new Uint8Array(await response.arrayBuffer());
+        },
+        catch: (error) => {
+            return UploadistaError.fromCode("FILE_READ_ERROR", { cause: error });
+        },
+    });
+    return {
+        bucket: config.bucket,
+        getObject,
+        getObjectBuffer,
+        getObjectMetadata,
+        objectExists,
+        putObject,
+        deleteObject,
+        createResumableUpload,
+        uploadChunk,
+        getUploadStatus,
+        cancelUpload,
+        composeObjects,
+        putTemporaryObject,
+        getTemporaryObject,
+        deleteTemporaryObject,
+    };
+}
+export const GCSClientRESTLayer = (config) => Layer.succeed(GCSClientService, createRESTGCSClient(config));

package/dist/services/gcs-client.service.d.ts

@@ -0,0 +1,56 @@
+import type { UploadistaError } from "@uploadista/core/errors";
+import { Context, type Effect } from "effect";
+export interface GCSOperationContext {
+    bucket: string;
+    key: string;
+    contentType?: string;
+    metadata?: Record<string, string | null>;
+}
+export interface GCSObjectMetadata {
+    name: string;
+    bucket: string;
+    size?: number;
+    contentType?: string;
+    metadata?: Record<string, string | null>;
+    generation?: string;
+    timeCreated?: string;
+    updated?: string;
+}
+export type GCSClient = {
+    readonly bucket: string;
+    readonly getObject: (key: string) => Effect.Effect<ReadableStream, UploadistaError>;
+    readonly getObjectMetadata: (key: string) => Effect.Effect<GCSObjectMetadata, UploadistaError>;
+    readonly getObjectBuffer: (key: string) => Effect.Effect<Uint8Array, UploadistaError>;
+    readonly objectExists: (key: string) => Effect.Effect<boolean, UploadistaError>;
+    readonly putObject: (key: string, body: Uint8Array, context?: Partial<GCSOperationContext>) => Effect.Effect<string, UploadistaError>;
+    readonly putObjectFromStream?: (key: string, offset: number, readableStream: ReadableStream, context?: Partial<GCSOperationContext>, onProgress?: (chunkSize: number) => void) => Effect.Effect<number, UploadistaError>;
+    readonly putObjectFromStreamWithPatching?: (key: string, offset: number, readableStream: ReadableStream, context?: Partial<GCSOperationContext>, onProgress?: (chunkSize: number) => void, // Called with incremental bytes per chunk
+    isAppend?: boolean) => Effect.Effect<number, UploadistaError>;
+    readonly deleteObject: (key: string) => Effect.Effect<void, UploadistaError>;
+    readonly createResumableUpload: (context: GCSOperationContext) => Effect.Effect<string, UploadistaError>;
+    readonly uploadChunk: (uploadUrl: string, chunk: Uint8Array, start: number, total?: number) => Effect.Effect<{
+        completed: boolean;
+        bytesUploaded: number;
+    }, UploadistaError>;
+    readonly getUploadStatus: (uploadUrl: string) => Effect.Effect<{
+        bytesUploaded: number;
+        completed: boolean;
+    }, UploadistaError>;
+    readonly cancelUpload: (uploadUrl: string) => Effect.Effect<void, UploadistaError>;
+    readonly composeObjects: (sourceKeys: string[], destinationKey: string, context?: Partial<GCSOperationContext>) => Effect.Effect<string, UploadistaError>;
+    readonly putTemporaryObject: (key: string, body: Uint8Array, context?: Partial<GCSOperationContext>) => Effect.Effect<string, UploadistaError>;
+    readonly getTemporaryObject: (key: string) => Effect.Effect<ReadableStream | undefined, UploadistaError>;
+    readonly deleteTemporaryObject: (key: string) => Effect.Effect<void, UploadistaError>;
+};
+declare const GCSClientService_base: Context.TagClass<GCSClientService, "GCSClientService", GCSClient>;
+export declare class GCSClientService extends GCSClientService_base {
+}
+export interface GCSClientConfig {
+    bucket: string;
+    keyFilename?: string;
+    credentials?: object;
+    projectId?: string;
+    accessToken?: string;
+}
+export {};
+//# sourceMappingURL=gcs-client.service.d.ts.map

package/dist/services/gcs-client.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gcs-client.service.d.ts","sourceRoot":"","sources":["../../src/services/gcs-client.service.ts"],"names":[],"mappings":"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"}

package/dist/services/gcs-client.service.js

@@ -0,0 +1,3 @@
+import { Context } from "effect";
+export class GCSClientService extends Context.Tag("GCSClientService")() {
+}

package/dist/services/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./gcs-client.service";
+export * from "./gcs-client-nodejs.service";
+export * from "./gcs-client-rest.service";
+//# sourceMappingURL=index.d.ts.map

package/dist/services/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/services/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC"}

package/dist/services/index.js

@@ -0,0 +1,3 @@
+export * from "./gcs-client.service";
+export * from "./gcs-client-nodejs.service";
+export * from "./gcs-client-rest.service";

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@uploadista/data-store-gcs",
+  "type": "module",
+  "version": "0.0.3",
+  "description": "Google Cloud Storage data store for Uploadista",
+  "license": "MIT",
+  "author": "Uploadista",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@google-cloud/storage": "7.17.2",
+    "effect": "3.18.4",
+    "@uploadista/observability": "0.0.3",
+    "@uploadista/core": "0.0.3"
+  },
+  "devDependencies": {
+    "@uploadista/typescript-config": "0.0.3"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "format": "biome format --write ./src",
+    "lint": "biome lint --write ./src",
+    "check": "biome check --write ./src",
+    "typecheck": "tsc --noEmit"
+  }
+}