@rx-ted/packages-honest-plugins 1.0.1

package/s3/src/s3.driver.ts

@@ -0,0 +1,259 @@
+import type { Logger } from '@rx-ted/packages-core';
+import type { FileDriver, FileMetadata, FileUploadOptions, S3Options } from './types';
+
+let awsS3: any = null;
+async function getAwsS3() {
+  if (!awsS3) {
+    const name = '@aws-sdk/client-s3';
+    awsS3 = await import(name);
+  }
+  return awsS3;
+}
+
+let awsPresigner: any = null;
+async function getAwsPresigner() {
+  if (!awsPresigner) {
+    const name = '@aws-sdk/s3-request-presigner';
+    awsPresigner = await import(name);
+  }
+  return awsPresigner;
+}
+
+export type S3DriverOptions = S3Options & {
+  logger?: Logger;
+};
+
+export async function createS3Driver(options: S3DriverOptions): Promise<FileDriver> {
+  const logger = options.logger;
+  if (logger) {
+    logger.debug(
+      {
+        bucket: options.bucket,
+        endpoint: options.endpoint,
+        region: options.region,
+      },
+      'S3Driver: initializing',
+    );
+  }
+
+  const s3 = await getAwsS3();
+  const client = new s3.S3Client({
+    endpoint: options.endpoint,
+    region: options.region || 'us-east-1',
+    credentials: {
+      accessKeyId: options.accessKeyId,
+      secretAccessKey: options.secretAccessKey,
+    },
+    forcePathStyle: options.forcePathStyle,
+  });
+
+  const driver = new S3Driver(client, options, logger);
+
+  if (logger) {
+    logger.info('S3Driver: initialized');
+  }
+
+  return driver;
+}
+
+class S3Driver implements FileDriver {
+  constructor(
+    private client: any,
+    private options: S3Options & { logger?: Logger },
+    private logger?: Logger,
+  ) {}
+
+  async upload(
+    key: string,
+    data: Uint8Array | ReadableStream,
+    uploadOptions?: FileUploadOptions,
+  ): Promise<FileMetadata> {
+    let body: Uint8Array | undefined;
+    if (data instanceof Uint8Array) {
+      body = data;
+    } else {
+      const chunks: Uint8Array[] = [];
+      const reader = data.getReader();
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        chunks.push(value);
+      }
+      const totalLength = chunks.reduce((sum, c) => sum + c.byteLength, 0);
+      const merged = new Uint8Array(totalLength);
+      let offset = 0;
+      for (const chunk of chunks) {
+        merged.set(chunk, offset);
+        offset += chunk.byteLength;
+      }
+      body = merged;
+    }
+
+    const s3 = await getAwsS3();
+    const command = new s3.PutObjectCommand({
+      Bucket: this.options.bucket,
+      Key: key,
+      Body: body,
+      ContentType: uploadOptions?.contentType,
+      Metadata: uploadOptions?.metadata,
+    });
+
+    await this.client.send(command);
+
+    const url = this.options.baseUrl
+      ? `${this.options.baseUrl.replace(/\/$/, '')}/${key}`
+      : undefined;
+
+    if (this.logger) {
+      this.logger.debug({ key, size: body?.length }, 'S3Driver: uploaded');
+    }
+
+    return {
+      key,
+      size: body?.length || 0,
+      contentType: uploadOptions?.contentType || this.guessContentType(key),
+      lastModified: new Date(),
+      url,
+    };
+  }
+
+  async download(key: string): Promise<Uint8Array> {
+    const s3 = await getAwsS3();
+    const command = new s3.GetObjectCommand({
+      Bucket: this.options.bucket,
+      Key: key,
+    });
+
+    const response = await this.client.send(command);
+    if (!response.Body) {
+      return new Uint8Array();
+    }
+
+    const chunks: Uint8Array[] = [];
+    for await (const chunk of response.Body) {
+      chunks.push(chunk);
+    }
+    const totalLength = chunks.reduce((sum, c) => sum + c.byteLength, 0);
+    const merged = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+      merged.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return merged;
+  }
+
+  async getUrl(key: string, expiresIn?: number): Promise<string> {
+    if (this.options.baseUrl) {
+      return `${this.options.baseUrl.replace(/\/$/, '')}/${key}`;
+    }
+
+    const [s3, presigner] = await Promise.all([getAwsS3(), getAwsPresigner()]);
+    const command = new s3.GetObjectCommand({
+      Bucket: this.options.bucket,
+      Key: key,
+    });
+
+    return presigner.getSignedUrl(this.client, command, {
+      expiresIn: expiresIn || 3600,
+    });
+  }
+
+  async delete(key: string): Promise<boolean> {
+    try {
+      const s3 = await getAwsS3();
+      const command = new s3.DeleteObjectCommand({
+        Bucket: this.options.bucket,
+        Key: key,
+      });
+
+      await this.client.send(command);
+
+      if (this.logger) {
+        this.logger.debug({ key }, 'S3Driver: deleted');
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async exists(key: string): Promise<boolean> {
+    try {
+      const s3 = await getAwsS3();
+      const command = new s3.HeadObjectCommand({
+        Bucket: this.options.bucket,
+        Key: key,
+      });
+
+      await this.client.send(command);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async list(prefix?: string): Promise<FileMetadata[]> {
+    const s3 = await getAwsS3();
+    const command = new s3.ListObjectsV2Command({
+      Bucket: this.options.bucket,
+      Prefix: prefix,
+    });
+
+    const response = await this.client.send(command);
+    const results: FileMetadata[] = [];
+
+    if (response.Contents) {
+      for (const item of response.Contents) {
+        results.push({
+          key: item.Key || '',
+          size: item.Size || 0,
+          contentType: this.guessContentType(item.Key || ''),
+          lastModified: item.LastModified || new Date(),
+        });
+      }
+    }
+
+    return results;
+  }
+
+  async close(): Promise<void> {
+    this.client.destroy();
+    if (this.logger) {
+      this.logger.info('S3Driver: closed');
+    }
+  }
+
+  async healthCheck(): Promise<boolean> {
+    try {
+      const s3 = await getAwsS3();
+      const command = new s3.ListObjectsV2Command({
+        Bucket: this.options.bucket,
+        MaxKeys: 1,
+      });
+
+      await this.client.send(command);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  private guessContentType(key: string): string {
+    const ext = key.split('.').pop()?.toLowerCase() || '';
+    const mimeTypes: Record<string, string> = {
+      html: 'text/html',
+      css: 'text/css',
+      js: 'application/javascript',
+      json: 'application/json',
+      png: 'image/png',
+      jpg: 'image/jpeg',
+      jpeg: 'image/jpeg',
+      gif: 'image/gif',
+      svg: 'image/svg+xml',
+      pdf: 'application/pdf',
+      txt: 'text/plain',
+    };
+    return mimeTypes[ext] || 'application/octet-default';
+  }
+}

package/s3/src/s3.plugin.ts

@@ -0,0 +1,80 @@
+import type { Hono } from 'hono';
+import type { ILogger } from '@rx-ted/packages-core';
+import type { Application, IPlugin } from '@rx-ted/packages-honest';
+import { ComponentManager, maskSensitive } from '@rx-ted/packages-honest';
+import { createS3Driver } from './s3.driver';
+import type { FileDriver, S3Options } from './types';
+
+export const S3_CONTEXT_KEY = 'honest:s3';
+export const S3_GLOBAL_KEY = 's3';
+
+export interface S3PluginOptions {
+  connection: S3Options;
+  contextKey?: string;
+}
+
+export class S3Plugin implements IPlugin {
+  static readonly globalKey = S3_GLOBAL_KEY;
+  readonly name = 's3-plugin';
+  readonly version = '1.0.0';
+
+  logger?: ILogger;
+
+  private driver: FileDriver | null = null;
+  private readonly connection: S3Options;
+  private readonly contextKey: string;
+
+  constructor(options: S3PluginOptions) {
+    this.connection = options.connection;
+    this.contextKey = options.contextKey ?? S3_CONTEXT_KEY;
+  }
+
+  getClient(): FileDriver {
+    if (!this.driver) {
+      throw new Error('S3 not connected. Ensure beforeModulesRegistered has run.');
+    }
+    return this.driver;
+  }
+
+  async beforeModulesRegistered(app: Application, _hono: Hono): Promise<void> {
+    this.logger?.info('S3: initializing...');
+
+    const connInfo: Record<string, unknown> = {
+      category: 'plugins',
+      endpoint: this.connection.endpoint,
+      region: this.connection.region,
+      bucket: this.connection.bucket,
+      accessKeyId: maskSensitive(this.connection.accessKeyId),
+    };
+
+    try {
+      this.driver = await createS3Driver(this.connection);
+      app.getContext().set(this.contextKey, this.driver);
+      ComponentManager.registerPlugin(S3_GLOBAL_KEY, this.driver);
+
+      const ok = await this.driver.healthCheck();
+      if (!ok) throw new Error('S3: health check failed');
+      this.logger?.info(connInfo, 'success to s3');
+    } catch (error) {
+      this.logger?.error(
+        { ...connInfo, error: error instanceof Error ? error.message : String(error) },
+        'fail to connect s3',
+      );
+      throw error;
+    }
+  }
+
+  async afterModulesRegistered(_app: Application, _hono: Hono): Promise<void> {
+    if (this.driver) {
+      const ok = await this.driver.healthCheck();
+      if (ok) {
+        this.logger?.info('S3: health check passed');
+      }
+    }
+  }
+
+  async close(): Promise<void> {
+    await this.driver?.close();
+    this.driver = null;
+  }
+}

package/s3/src/types.ts

@@ -0,0 +1,37 @@
+export interface FileUploadOptions {
+  contentType?: string;
+  metadata?: Record<string, string>;
+}
+
+export interface FileMetadata {
+  key: string;
+  size: number;
+  contentType: string;
+  lastModified: Date;
+  url?: string;
+}
+
+export interface S3Options {
+  endpoint?: string;
+  accessKeyId: string;
+  secretAccessKey: string;
+  bucket: string;
+  region?: string;
+  forcePathStyle?: boolean;
+  baseUrl?: string;
+}
+
+export interface FileDriver {
+  upload(
+    key: string,
+    data: Uint8Array | ReadableStream,
+    options?: FileUploadOptions,
+  ): Promise<FileMetadata>;
+  download(key: string): Promise<Uint8Array>;
+  getUrl(key: string, expiresIn?: number): Promise<string>;
+  delete(key: string): Promise<boolean>;
+  exists(key: string): Promise<boolean>;
+  list(prefix?: string): Promise<FileMetadata[]>;
+  close(): Promise<void>;
+  healthCheck(): Promise<boolean>;
+}

package/s3/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "declaration": true,
+    "sourceMap": false,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "types": ["node"],
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true,
+    "rootDir": "./src",
+    "outDir": "./dist"
+  },
+  "include": ["src"],
+  "exclude": ["**/*.test.ts"]
+}

package/s3/vitest.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from 'vitest/config';
+import { getWorkspaceAliases } from '../../../vitest.workspace-aliases';
+
+export default defineConfig({
+  resolve: {
+    alias: getWorkspaceAliases(),
+  },
+  test: {
+    globals: true,
+    environment: 'node',
+    exclude: ['node_modules'],
+  },
+});