@iskra-bun/web-kit 0.1.0 → 0.2.0

package/src/features/storage/adapters/local.ts

@@ -1,133 +0,0 @@
-import { BaseStorageAdapter, type PutOptions, type StorageConfig, type StorageFile } from "../base";
-import path from "node:path";
-import fs from "node:fs/promises";
-import { existsSync } from "node:fs";
-
-export class LocalStorageAdapter extends BaseStorageAdapter {
-    private basePath: string;
-
-    constructor(config: StorageConfig) {
-        super();
-        this.basePath = config.basePath || "./storage";
-    }
-
-    async connect(): Promise<void> {
-        await fs.mkdir(this.basePath, { recursive: true });
-        this.connected = true;
-        console.log(`✅ Local storage connected at: ${this.basePath}`);
-    }
-
-    async disconnect(): Promise<void> {
-        this.connected = false;
-    }
-
-    async put(filePath: string, data: Uint8Array | Buffer, options?: PutOptions): Promise<StorageFile> {
-        this.ensureConnected();
-
-        const sanitizedPath = this.sanitizePath(filePath);
-        const fullPath = path.join(this.basePath, sanitizedPath);
-
-        await fs.mkdir(path.dirname(fullPath), { recursive: true });
-        await fs.writeFile(fullPath, data);
-
-        const stat = await fs.stat(fullPath);
-
-        return {
-            name: path.basename(sanitizedPath),
-            path: sanitizedPath,
-            size: stat.size,
-            mimeType: options?.contentType || this.getMimeType(sanitizedPath),
-            lastModified: stat.mtime,
-            url: await this.url(sanitizedPath),
-        };
-    }
-
-    async get(filePath: string): Promise<Uint8Array | null> {
-        this.ensureConnected();
-        const sanitizedPath = this.sanitizePath(filePath);
-        const fullPath = path.join(this.basePath, sanitizedPath);
-
-        try {
-            return await fs.readFile(fullPath);
-        } catch (error: any) {
-            if (error.code === 'ENOENT') return null;
-            throw error;
-        }
-    }
-
-    async delete(filePath: string): Promise<void> {
-        this.ensureConnected();
-        const sanitizedPath = this.sanitizePath(filePath);
-        const fullPath = path.join(this.basePath, sanitizedPath);
-
-        try {
-            await fs.unlink(fullPath);
-        } catch (error: any) {
-            if (error.code !== 'ENOENT') throw error;
-        }
-    }
-
-    async exists(filePath: string): Promise<boolean> {
-        this.ensureConnected();
-        const sanitizedPath = this.sanitizePath(filePath);
-        const fullPath = path.join(this.basePath, sanitizedPath);
-        try {
-            await fs.access(fullPath);
-            return true;
-        } catch {
-            return false;
-        }
-    }
-
-    async isDirectory(filePath: string): Promise<boolean> {
-        this.ensureConnected();
-        const sanitizedPath = this.sanitizePath(filePath);
-        const fullPath = path.join(this.basePath, sanitizedPath);
-        try {
-            const stat = await fs.stat(fullPath);
-            return stat.isDirectory();
-        } catch {
-            return false;
-        }
-    }
-
-    async list(prefix?: string): Promise<StorageFile[]> {
-        this.ensureConnected();
-        const searchPath = prefix ? path.join(this.basePath, this.sanitizePath(prefix)) : this.basePath;
-        const files: StorageFile[] = [];
-
-        // Simple recursive walk
-        const walk = async (dir: string) => {
-            try {
-                const entries = await fs.readdir(dir, { withFileTypes: true });
-                for (const entry of entries) {
-                    const fullPath = path.join(dir, entry.name);
-                    if (entry.isDirectory()) {
-                        await walk(fullPath);
-                    } else {
-                        const relativePath = path.relative(this.basePath, fullPath);
-                        const stat = await fs.stat(fullPath);
-                        files.push({
-                            name: entry.name,
-                            path: this.sanitizePath(relativePath),
-                            size: stat.size,
-                            mimeType: this.getMimeType(entry.name),
-                            lastModified: stat.mtime,
-                            url: await this.url(this.sanitizePath(relativePath))
-                        });
-                    }
-                }
-            } catch (e: any) {
-                if (e.code !== 'ENOENT') throw e;
-            }
-        };
-
-        await walk(searchPath);
-        return files;
-    }
-
-    async url(filePath: string, _expiresIn?: number): Promise<string> {
-        const sanitizedPath = this.sanitizePath(filePath);
-        return `/storage/${sanitizedPath}`;
-    }
-}

package/src/features/storage/adapters/s3.ts

@@ -1,193 +0,0 @@
-import { BaseStorageAdapter } from "../base";
-import type { StorageConfig, StorageFile, PutOptions } from "../base";
-import {
-    S3Client,
-    PutObjectCommand,
-    GetObjectCommand,
-    DeleteObjectCommand,
-    HeadObjectCommand,
-    HeadBucketCommand,
-    ListObjectsV2Command,
-    CopyObjectCommand,
-} from "@aws-sdk/client-s3";
-import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
-
-export class S3StorageAdapter extends BaseStorageAdapter {
-    private client: S3Client;
-    private bucket: string;
-
-    constructor(private config: StorageConfig) {
-        super();
-        const conn = config.connection || {};
-
-        this.bucket = conn.bucket || "iskra-storage";
-
-        this.client = new S3Client({
-            endpoint: conn.endpoint,
-            region: conn.region || "us-east-1",
-            credentials: conn.accessKey && conn.secretKey
-                ? { accessKeyId: conn.accessKey, secretAccessKey: conn.secretKey }
-                : undefined,
-            forcePathStyle: !!conn.endpoint, // true for MinIO
-        });
-    }
-
-    async connect(): Promise<void> {
-        try {
-            await this.client.send(new HeadBucketCommand({ Bucket: this.bucket }));
-            this.connected = true;
-        } catch (err: any) {
-            throw new Error(`Failed to connect to S3 bucket "${this.bucket}": ${err.message}`);
-        }
-    }
-
-    async disconnect(): Promise<void> {
-        this.client.destroy();
-        this.connected = false;
-    }
-
-    async put(path: string, data: Uint8Array | Buffer | ReadableStream, options?: PutOptions): Promise<StorageFile> {
-        this.ensureConnected();
-        const key = this.sanitizePath(path);
-
-        let body: Uint8Array | Buffer;
-        if (data instanceof ReadableStream) {
-            const response = new Response(data);
-            body = new Uint8Array(await response.arrayBuffer());
-        } else {
-            body = data;
-        }
-
-        await this.client.send(new PutObjectCommand({
-            Bucket: this.bucket,
-            Key: key,
-            Body: body,
-            ContentType: options?.contentType || this.getMimeType(key),
-            Metadata: options?.metadata,
-        }));
-
-        return {
-            name: key.split("/").pop() || key,
-            path: key,
-            size: body.length,
-            mimeType: options?.contentType || this.getMimeType(key),
-            lastModified: new Date(),
-        };
-    }
-
-    async get(path: string): Promise<Uint8Array | null> {
-        this.ensureConnected();
-        const key = this.sanitizePath(path);
-
-        try {
-            const response = await this.client.send(new GetObjectCommand({
-                Bucket: this.bucket,
-                Key: key,
-            }));
-
-            if (!response.Body) return null;
-            return new Uint8Array(await response.Body.transformToByteArray());
-        } catch (err: any) {
-            if (err.name === "NoSuchKey" || err.$metadata?.httpStatusCode === 404) {
-                return null;
-            }
-            throw err;
-        }
-    }
-
-    async delete(path: string): Promise<void> {
-        this.ensureConnected();
-        const key = this.sanitizePath(path);
-
-        await this.client.send(new DeleteObjectCommand({
-            Bucket: this.bucket,
-            Key: key,
-        }));
-    }
-
-    async exists(path: string): Promise<boolean> {
-        this.ensureConnected();
-        const key = this.sanitizePath(path);
-
-        try {
-            await this.client.send(new HeadObjectCommand({
-                Bucket: this.bucket,
-                Key: key,
-            }));
-            return true;
-        } catch (err: any) {
-            if (err.name === "NotFound" || err.$metadata?.httpStatusCode === 404) {
-                return false;
-            }
-            throw err;
-        }
-    }
-
-    async list(prefix?: string): Promise<StorageFile[]> {
-        this.ensureConnected();
-        const files: StorageFile[] = [];
-        let continuationToken: string | undefined;
-
-        do {
-            const response = await this.client.send(new ListObjectsV2Command({
-                Bucket: this.bucket,
-                Prefix: prefix ? this.sanitizePath(prefix) : undefined,
-                ContinuationToken: continuationToken,
-            }));
-
-            if (response.Contents) {
-                for (const obj of response.Contents) {
-                    if (!obj.Key) continue;
-                    files.push({
-                        name: obj.Key.split("/").pop() || obj.Key,
-                        path: obj.Key,
-                        size: obj.Size || 0,
-                        mimeType: this.getMimeType(obj.Key),
-                        lastModified: obj.LastModified,
-                    });
-                }
-            }
-
-            continuationToken = response.IsTruncated ? response.NextContinuationToken : undefined;
-        } while (continuationToken);
-
-        return files;
-    }
-
-    async url(path: string, expiresIn: number = 3600): Promise<string> {
-        this.ensureConnected();
-        const key = this.sanitizePath(path);
-
-        const command = new GetObjectCommand({
-            Bucket: this.bucket,
-            Key: key,
-        });
-
-        return await getSignedUrl(this.client, command, { expiresIn });
-    }
-
-    async copy(from: string, to: string): Promise<void> {
-        this.ensureConnected();
-        const sourceKey = this.sanitizePath(from);
-        const destKey = this.sanitizePath(to);
-
-        await this.client.send(new CopyObjectCommand({
-            Bucket: this.bucket,
-            CopySource: `${this.bucket}/${sourceKey}`,
-            Key: destKey,
-        }));
-    }
-
-    async isDirectory(path: string): Promise<boolean> {
-        this.ensureConnected();
-        const prefix = this.sanitizePath(path).replace(/\/?$/, "/");
-
-        const response = await this.client.send(new ListObjectsV2Command({
-            Bucket: this.bucket,
-            Prefix: prefix,
-            MaxKeys: 1,
-        }));
-
-        return (response.Contents?.length || 0) > 0;
-    }
-}

package/src/features/storage/base.ts

@@ -1,112 +0,0 @@
-import fs from "node:fs/promises";
-
-export interface StorageConfig {
-    adapter: "local" | "minio" | "s3";
-    basePath?: string; // For local storage
-    connection?: {
-        endpoint?: string;
-        accessKey?: string;
-        secretKey?: string;
-        bucket?: string;
-        region?: string;
-        useSSL?: boolean;
-    };
-}
-
-export interface StorageFile {
-    name: string;
-    path: string;
-    size: number;
-    mimeType?: string;
-    lastModified?: Date;
-    url?: string;
-}
-
-export interface PutOptions {
-    contentType?: string;
-    metadata?: Record<string, string>;
-    public?: boolean;
-}
-
-export interface StorageAdapter {
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    put(path: string, data: Uint8Array | Buffer | ReadableStream, options?: PutOptions): Promise<StorageFile>;
-    get(path: string): Promise<Uint8Array | null>;
-    // getStream(path: string): Promise<ReadableStream | null>; 
-    // Node streams are different, sticking to Buffer/Uint8Array for simplicity or using generic Stream
-    delete(path: string): Promise<void>;
-    exists(path: string): Promise<boolean>;
-    list(prefix?: string): Promise<StorageFile[]>;
-    url(path: string, expiresIn?: number): Promise<string>;
-    copy(from: string, to: string): Promise<void>;
-    move(from: string, to: string): Promise<void>;
-    isDirectory(path: string): Promise<boolean>;
-}
-
-export abstract class BaseStorageAdapter implements StorageAdapter {
-    protected connected = false;
-
-    abstract connect(): Promise<void>;
-    abstract disconnect(): Promise<void>;
-    abstract put(path: string, data: Uint8Array | Buffer | ReadableStream, options?: PutOptions): Promise<StorageFile>;
-    abstract get(path: string): Promise<Uint8Array | null>;
-
-    abstract delete(path: string): Promise<void>;
-    abstract exists(path: string): Promise<boolean>;
-    abstract list(prefix?: string): Promise<StorageFile[]>;
-    abstract url(path: string, expiresIn?: number): Promise<string>;
-    abstract isDirectory(path: string): Promise<boolean>;
-
-    isConnected(): boolean {
-        return this.connected;
-    }
-
-    protected ensureConnected(): void {
-        if (!this.connected) {
-            throw new Error("Storage not connected. Call connect() first.");
-        }
-    }
-
-    async copy(from: string, to: string): Promise<void> {
-        const data = await this.get(from);
-        if (!data) {
-            throw new Error(`Source file not found: ${from}`);
-        }
-        await this.put(to, data);
-    }
-
-    async move(from: string, to: string): Promise<void> {
-        await this.copy(from, to);
-        await this.delete(from);
-    }
-
-    protected generateFileName(originalName: string): string {
-        const ext = originalName.split(".").pop();
-        const timestamp = Date.now();
-        const random = Math.random().toString(36).substring(2, 15);
-        return `${timestamp}-${random}.${ext}`;
-    }
-
-    protected sanitizePath(path: string): string {
-        return path
-            .replace(/^\/+/, "")
-            .replace(/\/+/g, "/")
-            .replace(/\\/g, "/");
-    }
-
-    protected getMimeType(filename: string): string {
-        const ext = filename.split(".").pop()?.toLowerCase();
-        const mimeTypes: Record<string, string> = {
-            jpg: "image/jpeg",
-            jpeg: "image/jpeg",
-            png: "image/png",
-            gif: "image/gif",
-            pdf: "application/pdf",
-            txt: "text/plain",
-            json: "application/json",
-            zip: "application/zip",
-        };
-        return mimeTypes[ext || ""] || "application/octet-stream";
-    }
-}