bro-framework 2.4.5 → 3.0.0

package/src/testing.js

@@ -0,0 +1,142 @@
+import path from 'path';
+import { createServer } from './server.js';
+import { signJwt } from './auth.js';
+
+/**
+ * Creates a native Fetch-based testing harness for bro.js
+ */
+export async function createTestHarness(globalConfig = {}, options = {}) {
+  let instance;
+  const port = options.port || 0;
+  let runningServer;
+  let testUrl = '';
+  
+  const harness = {
+    fixtures: options.fixtures || {},
+    stores: options.stores || {},
+    
+    async start() {
+      const routesDir = options.routesDir || path.join(process.cwd(), 'routes');
+      
+      // Inject testing fixtures into the framework config
+      const testConfig = {
+        ...globalConfig,
+        fixtures: this.fixtures,
+        stores: this.stores,
+        // Override for testing
+        jwtSecret: globalConfig.jwtSecret || 'test_secret_for_harness'
+      };
+
+      instance = await createServer(testConfig, routesDir, options.db || null);
+      
+      runningServer = instance.server;
+      await new Promise(resolve => runningServer.listen(port, resolve));
+      testUrl = `http://localhost:${runningServer.address().port}`;
+    },
+    
+    async stop() {
+      if (runningServer && runningServer.closeAllConnections) {
+        runningServer.closeAllConnections();
+      }
+      if (instance?.shutdown) {
+        await instance.shutdown();
+      } else if (runningServer) {
+        await new Promise(resolve => runningServer.close(resolve));
+      }
+      runningServer = null;
+      if (typeof jest !== 'undefined' && jest.clearAllTimers) {
+        jest.clearAllTimers();
+      }
+    },
+
+    auth(payload) {
+       const secret = globalConfig.jwtSecret || 'test_secret_for_harness';
+       return signJwt(payload, secret, { expiresIn: '1h' });
+    },
+
+        // Clock hooks
+    useFakeTimers(now) {
+      if (typeof jest !== 'undefined') {
+        jest.useFakeTimers();
+        if (now) jest.setSystemTime(now);
+      } else {
+        console.warn('Fake timers only supported when running under Jest/Vitest environments.');
+      }
+    },
+    useRealTimers() {
+      if (typeof jest !== 'undefined') {
+        jest.useRealTimers();
+      }
+    },
+
+    // DB Transactions
+    async runInTransaction(testFn) {
+      if (!options.db || typeof options.db.transaction !== 'function') {
+        throw new Error('Database adapter does not support transactions or no DB provided.');
+      }
+      return options.db.transaction(async (trx) => {
+        try {
+          await testFn(trx);
+        } finally {
+          // If the test framework supports rollback via error, we would throw here, 
+          // but for isolated testing we assume the trx handles rollback gracefully if test fails.
+          if (trx.rollback) await trx.rollback();
+        }
+      });
+    },
+
+    // Direct route testing without network
+    async testRoute(routeModule, mockCtx = {}) {
+      const config = routeModule.default || routeModule;
+      const ctx = {
+        env: globalConfig.env || {},
+        db: options.db || null,
+        user: null,
+        body: {},
+        query: {},
+        params: {},
+        ...mockCtx
+      };
+      return config.handler(ctx);
+    },
+
+    client(defaultHeaders = {}) {
+       return {
+         async fetch(route, fetchOpts = {}) {
+           const headers = { ...defaultHeaders, ...(fetchOpts.headers || {}) };
+           return fetch(`${testUrl}${route}`, { ...fetchOpts, headers });
+         },
+         async get(route, fetchOpts) { 
+           return this.fetch(route, { method: 'GET', ...fetchOpts }); 
+         },
+         async post(route, body, fetchOpts = {}) { 
+           return this.fetch(route, { 
+             method: 'POST', 
+             body: JSON.stringify(body), 
+             headers: { 'Content-Type': 'application/json', ...(fetchOpts.headers || {}) }, 
+             ...fetchOpts 
+           }); 
+         },
+         async put(route, body, fetchOpts = {}) {
+           return this.fetch(route, { 
+             method: 'PUT', 
+             body: JSON.stringify(body), 
+             headers: { 'Content-Type': 'application/json', ...(fetchOpts.headers || {}) }, 
+             ...fetchOpts 
+           });
+         },
+         async delete(route, fetchOpts) { 
+           return this.fetch(route, { method: 'DELETE', ...fetchOpts }); 
+         },
+         
+         // Contract test helper
+         async assertContract(response, schema) {
+           const json = await response.json();
+           return schema.parse(json);
+         }
+       };
+    }
+  };
+
+  return harness;
+}

package/src/uploads.js

@@ -0,0 +1,129 @@
+import crypto from 'crypto';
+
+/**
+ * Secure Upload Pipeline for bro.js
+ * Provides streaming abstractions and adapters for object storage.
+ */
+
+export class SecureUploadPipeline {
+  constructor(config = {}) {
+    this.adapters = config.adapters || {};
+    this.defaultAdapter = config.defaultAdapter || 'local';
+    this.maxSize = config.maxSize || 50 * 1024 * 1024; // 50MB default
+    this.allowedMimeTypes = config.allowedMimeTypes || ['image/jpeg', 'image/png', 'application/pdf'];
+  }
+
+  async processUpload(file, options = {}) {
+    this._validateFile(file, options);
+    
+    const adapterName = options.adapter || this.defaultAdapter;
+    const adapter = this.adapters[adapterName];
+    
+    if (!adapter) {
+      throw new Error(`Upload adapter '${adapterName}' not found.`);
+    }
+
+    const key = crypto.randomUUID() + '-' + file.originalname;
+    const url = await adapter.upload(key, file.buffer || file.stream(), file.mimetype);
+    
+    return { key, url, size: file.size, mimetype: file.mimetype };
+  }
+
+  _validateFile(file, options) {
+    const size = file.size;
+    const maxSize = options.maxSize || this.maxSize;
+    if (size > maxSize) {
+      throw new Error(`File size ${size} exceeds quota of ${maxSize} bytes.`);
+    }
+
+    const mime = file.mimetype || file.type;
+    const allowed = options.allowedMimeTypes || this.allowedMimeTypes;
+    if (allowed !== '*' && !allowed.includes(mime)) {
+      throw new Error(`MIME type ${mime} is not allowed.`);
+    }
+  }
+
+  async getSignedUrl(key, adapterName = this.defaultAdapter, expiresIn = 3600) {
+    const adapter = this.adapters[adapterName];
+    if (!adapter || typeof adapter.getSignedUrl !== 'function') {
+      throw new Error(`Adapter '${adapterName}' does not support signed URLs.`);
+    }
+    return await adapter.getSignedUrl(key, expiresIn);
+  }
+}
+
+/**
+ * Example Local Storage Adapter
+ */
+import fs from 'fs';
+import path from 'path';
+
+export class LocalStorageAdapter {
+  constructor(uploadDir) {
+    this.uploadDir = uploadDir || path.join(process.cwd(), 'uploads');
+    if (!fs.existsSync(this.uploadDir)) {
+      fs.mkdirSync(this.uploadDir, { recursive: true });
+    }
+  }
+
+  async save(fileStream, originalName, mimeType) {
+    const fileName = `${Date.now()}-${originalName}`;
+    const filePath = path.join(this.uploadDir, fileName);
+    const writeStream = fs.createWriteStream(filePath);
+    await new Promise((resolve, reject) => {
+      fileStream.pipe(writeStream);
+      fileStream.on('end', resolve);
+      fileStream.on('error', reject);
+    });
+    return { url: `/uploads/${fileName}`, id: fileName, path: filePath };
+  }
+
+  async delete(id) {
+    const filePath = path.join(this.uploadDir, id);
+    if (fs.existsSync(filePath)) {
+      await fs.promises.unlink(filePath);
+    }
+  }
+}
+
+export class S3StorageAdapter {
+  constructor(config) {
+    this.config = config;
+  }
+
+  async save(fileStream, originalName, mimeType) {
+    let AWS;
+    try {
+      AWS = await import('@aws-sdk/client-s3');
+    } catch (e) {
+      throw new Error('Please install @aws-sdk/client-s3 to use S3StorageAdapter');
+    }
+    const { S3Client } = AWS;
+    const { Upload } = await import('@aws-sdk/lib-storage');
+    
+    const client = new S3Client(this.config);
+    const key = `${Date.now()}-${originalName}`;
+    
+    const upload = new Upload({
+      client,
+      params: {
+        Bucket: this.config.bucket,
+        Key: key,
+        Body: fileStream,
+        ContentType: mimeType
+      }
+    });
+
+    const result = await upload.done();
+    return { url: result.Location, id: key };
+  }
+  
+  async delete(id) {
+    let AWS = await import('@aws-sdk/client-s3');
+    const client = new AWS.S3Client(this.config);
+    await client.send(new AWS.DeleteObjectCommand({
+      Bucket: this.config.bucket,
+      Key: id
+    }));
+  }
+}