fs-object-storage 1.0.0

package/samples/minio-connection-test.js

@@ -0,0 +1,66 @@
+// MinIO接続テスト用サンプル
+import * as Minio from 'minio';
+
+console.log('=== MinIO接続テスト ===');
+
+const minioClient = new Minio.Client({
+    endPoint: 'localhost',
+    port: 9000,
+    useSSL: false,
+    accessKey: 'minioadmin',
+    secretKey: 'minioadmin123'
+});
+
+async function testMinIOConnection() {
+    try {
+        console.log('\n1. MinIOサーバーへの接続テスト');
+        
+        // バケット一覧の取得テスト
+        const buckets = await minioClient.listBuckets();
+        console.log('✅ 接続成功！現在のバケット数:', buckets.length);
+        
+        // テスト用バケットの作成
+        const testBucket = 'fs-storage-test';
+        const bucketExists = await minioClient.bucketExists(testBucket);
+        
+        if (!bucketExists) {
+            await minioClient.makeBucket(testBucket);
+            console.log(`✅ テストバケット '${testBucket}' を作成したのだ`);
+        } else {
+            console.log(`✅ テストバケット '${testBucket}' は既に存在するのだ`);
+        }
+        
+        // テストファイルの書き込み
+        const testData = 'Hello MinIO from Node.js!';
+        const testFileName = 'test-file.txt';
+        
+        await minioClient.putObject(testBucket, testFileName, testData);
+        console.log(`✅ テストファイル '${testFileName}' を書き込んだのだ`);
+        
+        // テストファイルの読み込み
+        const dataStream = await minioClient.getObject(testBucket, testFileName);
+        let result = '';
+        
+        dataStream.on('data', (chunk) => {
+            result += chunk;
+        });
+        
+        dataStream.on('end', () => {
+            console.log(`✅ テストファイル読み込み結果: ${result}`);
+            console.log('\n🎉 MinIO環境は正常に動作しているのだ！');
+        });
+        
+        dataStream.on('error', (err) => {
+            console.error('❌ ファイル読み込みエラー:', err);
+        });
+        
+    } catch (error) {
+        console.error('❌ MinIO接続エラー:', error.message);
+        console.log('\n💡 MinIOサーバーが起動しているか確認するのだ：');
+        console.log('   - docker compose ps');
+        console.log('   - http://localhost:9001 でWebコンソールにアクセス');
+    }
+}
+
+// 接続テスト実行
+testMinIOConnection();

package/samples/minio-sample.js

@@ -0,0 +1,64 @@
+// MinIOライブラリのAPI調査用サンプル（接続なし確認）
+import * as Minio from 'minio';
+
+console.log('=== MinIO API調査 ===');
+
+// 1. MinIOクライアントの基本的なAPI確認
+console.log('\n1. MinIOクライアントの利用可能なメソッド:');
+const client = new Minio.Client({
+    endPoint: 'localhost',
+    port: 9000,
+    useSSL: false,
+    accessKey: 'dummy',
+    secretKey: 'dummy'
+});
+
+const clientMethods = Object.getOwnPropertyNames(Object.getPrototypeOf(client))
+    .filter(name => typeof client[name] === 'function' && !name.startsWith('_'));
+console.log('主要メソッド:', clientMethods);
+
+// 2. 重要なメソッドの詳細確認
+console.log('\n2. 重要なメソッドの詳細:');
+const importantMethods = [
+    'getObject',
+    'putObject', 
+    'removeObject',
+    'statObject',
+    'listObjects',
+    'bucketExists',
+    'makeBucket'
+];
+
+importantMethods.forEach(method => {
+    if (typeof client[method] === 'function') {
+        console.log(`✓ ${method}: 利用可能`);
+    } else {
+        console.log(`✗ ${method}: 利用不可`);
+    }
+});
+
+// 3. fs互換APIとの対応関係の分析
+console.log('\n3. fs互換APIとMinIO APIの対応関係:');
+const fsToMinioMapping = {
+    'fs.readFile': 'client.getObject',
+    'fs.writeFile': 'client.putObject',
+    'fs.exists': 'client.statObject (catchでfalse)',
+    'fs.stat': 'client.statObject',
+    'fs.unlink': 'client.removeObject',
+    'fs.readdir': 'client.listObjects'
+};
+
+Object.entries(fsToMinioMapping).forEach(([fsMethod, minioMethod]) => {
+    console.log(`${fsMethod} → ${minioMethod}`);
+});
+
+// 4. 設定可能なオプションの確認
+console.log('\n4. 主要設定項目:');
+console.log('- endPoint: MinIOサーバーのホスト');
+console.log('- port: ポート番号');
+console.log('- useSSL: SSL使用有無');
+console.log('- accessKey: アクセスキー');
+console.log('- secretKey: シークレットキー');
+console.log('- region: リージョン（オプション）');
+
+console.log('\n=== MinIO調査完了 ===');

package/src/index.d.ts

@@ -0,0 +1,98 @@
+import { Readable, Writable } from 'stream';
+
+export interface MinioConfig {
+  endPoint: string;
+  port?: number;
+  useSSL?: boolean;
+  accessKey: string;
+  secretKey: string;
+  region?: string;
+  sessionToken?: string;
+  partSize?: number;
+}
+
+export interface StatResult {
+  size: number;
+  mtime: Date;
+  isFile(): boolean;
+  isDirectory(): boolean;
+  isBlockDevice(): boolean;
+  isCharacterDevice(): boolean;
+  isSymbolicLink(): boolean;
+  isFIFO(): boolean;
+  isSocket(): boolean;
+}
+
+export interface WriteFileOptions {
+  encoding?: BufferEncoding;
+  mode?: number;
+  flag?: string;
+}
+
+export interface MkdirOptions {
+  recursive?: boolean;
+  mode?: number;
+}
+
+export interface FileSystemError extends Error {
+  code: string;
+  errno: number;
+  path?: string;
+  syscall?: string;
+}
+
+export default class FsMinioClient {
+  constructor(config: MinioConfig);
+
+  // File operations
+  readFile(path: string): Promise<Buffer>;
+  readFile(path: string, encoding: BufferEncoding): Promise<string>;
+  readFile(path: string, encoding?: BufferEncoding): Promise<Buffer | string>;
+
+  writeFile(path: string, data: string | Buffer | Uint8Array, options?: WriteFileOptions): Promise<void>;
+
+  exists(path: string): Promise<boolean>;
+
+  stat(path: string): Promise<StatResult>;
+
+  unlink(path: string): Promise<void>;
+
+  copyFile(src: string, dest: string): Promise<void>;
+
+  // Directory operations
+  readdir(path: string): Promise<string[]>;
+
+  mkdir(path: string, options?: MkdirOptions): Promise<void>;
+
+  rmdir(path: string): Promise<void>;
+
+  // Stream operations
+  createReadStream(path: string): Promise<Readable>;
+
+  createWriteStream(path: string): Promise<Writable>;
+}
+
+export class ErrorHandler {
+  static convertMinioError(error: Error, path?: string): FileSystemError;
+  static createFileSystemError(code: string, path?: string, syscall?: string): FileSystemError;
+}
+
+export class PathConverter {
+  static splitPath(path: string): { bucket: string; key: string };
+  static joinPath(bucket: string, key: string): string;
+  static normalizePath(path: string): string;
+  static isDirectory(path: string): boolean;
+  static getParentPath(path: string): string;
+  static getBasename(path: string): string;
+}
+
+export class StreamConverter {
+  static bufferToString(buffer: Buffer, encoding?: BufferEncoding): string;
+  static stringToBuffer(str: string, encoding?: BufferEncoding): Buffer;
+  static streamToBuffer(stream: Readable): Promise<Buffer>;
+  static bufferToStream(buffer: Buffer): Readable;
+  static createPassThroughStream(): { stream: Writable; promise: Promise<Buffer> };
+  static normalizeData(data: any): Buffer;
+}
+
+export default FsMinioClient;

package/src/index.js

@@ -0,0 +1,17 @@
+// fs-minio - fs-compatible API for MinIO/S3 object storage
+// Main entry point
+
+import FsMinioClient from './lib/FsMinioClient.js';
+import PathConverter from './lib/PathConverter.js';
+import StreamConverter from './lib/StreamConverter.js';
+import ErrorHandler from './lib/ErrorHandler.js';
+
+export {
+  FsMinioClient,
+  PathConverter,
+  StreamConverter,
+  ErrorHandler
+};
+
+// Default export for convenience
+export default FsMinioClient;

package/src/lib/ErrorHandler.js

@@ -0,0 +1,149 @@
+// ErrorHandler.js - MinIO errors to fs-compatible errors conversion
+
+class ErrorHandler {
+  static errorMapping = {
+    // MinIO/S3 specific errors
+    'NoSuchKey': { code: 'ENOENT', errno: -2, message: 'no such file or directory' },
+    'NoSuchBucket': { code: 'ENOENT', errno: -2, message: 'no such file or directory' },
+    'BucketNotFound': { code: 'ENOENT', errno: -2, message: 'no such file or directory' },
+    'AccessDenied': { code: 'EACCES', errno: -13, message: 'permission denied' },
+    'InvalidBucketName': { code: 'EINVAL', errno: -22, message: 'invalid argument' },
+    'BucketAlreadyExists': { code: 'EEXIST', errno: -17, message: 'file already exists' },
+    'KeyTooLong': { code: 'ENAMETOOLONG', errno: -36, message: 'file name too long' },
+    
+    // Network/Connection errors
+    'ENOTFOUND': { code: 'ENOTFOUND', errno: -3008, message: 'getaddrinfo ENOTFOUND' },
+    'ECONNREFUSED': { code: 'ECONNREFUSED', errno: -61, message: 'connect ECONNREFUSED' },
+    'ETIMEDOUT': { code: 'ETIMEDOUT', errno: -60, message: 'operation timed out' },
+    
+    // Default fallback
+    'Unknown': { code: 'EIO', errno: -5, message: 'input/output error' }
+  };
+
+  /**
+   * Convert MinIO error to fs-compatible error
+   * @param {Error} minioError - Original MinIO error
+   * @param {string} path - File path for context
+   * @param {string} operation - Operation that failed (e.g., 'open', 'read', 'write')
+   * @returns {Error} fs-compatible error
+   */
+  static convertError(minioError, path = null, operation = null) {
+    // If it's already an fs-style error, return as-is
+    if (minioError.code && minioError.errno) {
+      return minioError;
+    }
+
+    let errorInfo;
+    
+    // Try to identify error by MinIO error code
+    if (minioError.code && this.errorMapping[minioError.code]) {
+      errorInfo = this.errorMapping[minioError.code];
+    }    // Try to identify by error message patterns
+    else if (minioError.message) {
+      if (minioError.message.includes('key does not exist') || 
+          minioError.message.includes('NoSuchKey') ||
+          minioError.message.includes('Not Found')) {
+        errorInfo = this.errorMapping['NoSuchKey'];
+      } else if (minioError.message.includes('bucket does not exist') ||
+                 minioError.message.includes('NoSuchBucket')) {
+        errorInfo = this.errorMapping['NoSuchBucket'];
+      } else if (minioError.message.includes('access denied') ||
+                 minioError.message.includes('AccessDenied')) {
+        errorInfo = this.errorMapping['AccessDenied'];
+      } else if (minioError.message.includes('ENOTFOUND')) {
+        errorInfo = this.errorMapping['ENOTFOUND'];
+      } else if (minioError.message.includes('ECONNREFUSED')) {
+        errorInfo = this.errorMapping['ECONNREFUSED'];
+      } else if (minioError.message.includes('timeout') ||
+                 minioError.message.includes('ETIMEDOUT')) {
+        errorInfo = this.errorMapping['ETIMEDOUT'];
+      } else {
+        errorInfo = this.errorMapping['Unknown'];
+      }
+    } else {
+      errorInfo = this.errorMapping['Unknown'];
+    }
+
+    // Create fs-style error
+    const error = new Error();
+    error.code = errorInfo.code;
+    error.errno = errorInfo.errno;
+    error.syscall = operation || 'open';
+    error.path = path;
+    
+    // Create message in fs style: "ENOENT: no such file or directory, open '/path/to/file'"
+    if (path) {
+      error.message = `${errorInfo.code}: ${errorInfo.message}, ${error.syscall} '${path}'`;
+    } else {
+      error.message = `${errorInfo.code}: ${errorInfo.message}`;
+    }
+
+    // Preserve original error information
+    error.originalError = minioError;
+    
+    return error;
+  }
+
+  /**
+   * Create custom fs-style error
+   * @param {string} code - Error code (e.g., 'ENOENT')
+   * @param {string} path - File path
+   * @param {string} operation - Operation name
+   * @returns {Error} fs-compatible error
+   */
+  static createError(code, path = null, operation = 'open') {
+    // ENOENT, EACCES, EEXIST, EINVAL, ENAMETOOLONG など標準エラーコードにも対応
+    let errorInfo = this.errorMapping[code];
+    if (!errorInfo) {
+      // 標準的なfsエラーコードをサポート
+      switch (code) {
+        case 'ENOENT': errorInfo = { code: 'ENOENT', errno: -2, message: 'no such file or directory' }; break;
+        case 'EACCES': errorInfo = { code: 'EACCES', errno: -13, message: 'permission denied' }; break;
+        case 'EEXIST': errorInfo = { code: 'EEXIST', errno: -17, message: 'file already exists' }; break;
+        case 'EINVAL': errorInfo = { code: 'EINVAL', errno: -22, message: 'invalid argument' }; break;
+        case 'ENAMETOOLONG': errorInfo = { code: 'ENAMETOOLONG', errno: -36, message: 'file name too long' }; break;
+        default: errorInfo = this.errorMapping['Unknown'];
+      }
+    }
+    const error = new Error();
+    error.code = code;
+    error.errno = errorInfo.errno;
+    error.syscall = operation;
+    error.path = path;
+    if (path) {
+      error.message = `${code}: ${errorInfo.message}, ${operation} '${path}'`;
+    } else {
+      error.message = `${code}: ${errorInfo.message}`;
+    }
+    return error;
+  }
+
+  /**
+   * Check if error indicates file not found
+   * @param {Error} error - Error to check
+   * @returns {boolean} True if file not found error
+   */
+  static isNotFoundError(error) {
+    return error && error.code === 'ENOENT';
+  }
+
+  /**
+   * Check if error indicates access denied
+   * @param {Error} error - Error to check
+   * @returns {boolean} True if access denied error
+   */
+  static isAccessDeniedError(error) {
+    return error && error.code === 'EACCES';
+  }
+
+  /**
+   * Check if error indicates file already exists
+   * @param {Error} error - Error to check
+   * @returns {boolean} True if file exists error
+   */
+  static isExistsError(error) {
+    return error && error.code === 'EEXIST';
+  }
+}
+
+export default ErrorHandler;