json-rest-api 1.0.14 → 1.0.15

package/plugins/storage/local-storage.js

@@ -1,94 +1,94 @@
 /**
  * Local File Storage Adapter
- * 
+ *
  * Production-ready local storage with secure filename handling
  */
 
-import { promises as fs } from 'fs';
-import path from 'path';
-import crypto from 'crypto';
+import { promises as fs } from 'fs'
+import path from 'path'
+import crypto from 'crypto'
 
 export class LocalStorage {
-  constructor(options = {}) {
-    this.directory = path.resolve(options.directory || './uploads');
-    this.fileBaseUrl = options.fileBaseUrl || '/uploads';
-    this.nameStrategy = options.nameStrategy || 'hash'; // 'hash', 'timestamp', 'original', 'custom'
-    this.nameGenerator = options.nameGenerator; // Custom function
-    this.preserveExtension = options.preserveExtension !== false;
-    this.allowedExtensions = options.allowedExtensions; // Whitelist
-    this.maxFilenameLength = options.maxFilenameLength || 255;
+  constructor (options = {}) {
+    this.directory = path.resolve(options.directory || './uploads')
+    this.fileBaseUrl = options.fileBaseUrl || '/uploads'
+    this.nameStrategy = options.nameStrategy || 'hash' // 'hash', 'timestamp', 'original', 'custom'
+    this.nameGenerator = options.nameGenerator // Custom function
+    this.preserveExtension = options.preserveExtension !== false
+    this.allowedExtensions = options.allowedExtensions // Whitelist
+    this.maxFilenameLength = options.maxFilenameLength || 255
   }
-  
+
   /**
    * Generate a safe filename
    */
-  async generateFilename(file) {
-    let basename, extension;
-    
+  async generateFilename (file) {
+    let basename, extension
+
     // Extract and validate extension
-    const originalExt = path.extname(file.filename).toLowerCase();
+    const originalExt = path.extname(file.filename).toLowerCase()
     if (this.preserveExtension && originalExt) {
       // Validate extension against whitelist if provided
       if (this.allowedExtensions && !this.allowedExtensions.includes(originalExt)) {
-        throw new Error(`File extension '${originalExt}' is not allowed`);
+        throw new Error(`File extension '${originalExt}' is not allowed`)
       }
-      extension = originalExt;
+      extension = originalExt
     } else {
       // Determine extension from MIME type for safety
-      extension = this.getExtensionFromMimeType(file.mimetype);
+      extension = this.getExtensionFromMimeType(file.mimetype)
     }
-    
+
     // Generate basename based on strategy
     switch (this.nameStrategy) {
       case 'hash':
         // Cryptographically secure random name
-        basename = crypto.randomBytes(16).toString('hex');
-        break;
-        
+        basename = crypto.randomBytes(16).toString('hex')
+        break
+
       case 'timestamp':
         // Timestamp + random suffix to prevent collisions
-        basename = `${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
-        break;
-        
+        basename = `${Date.now()}_${crypto.randomBytes(4).toString('hex')}`
+        break
+
       case 'original':
         // Sanitized original filename
         basename = this.sanitizeFilename(
           path.basename(file.filename, originalExt)
-        );
-        break;
-        
+        )
+        break
+
       case 'custom':
         if (!this.nameGenerator) {
-          throw new Error('nameGenerator function required for custom strategy');
+          throw new Error('nameGenerator function required for custom strategy')
         }
-        basename = await this.nameGenerator(file);
-        break;
-        
+        basename = await this.nameGenerator(file)
+        break
+
       default:
-        throw new Error(`Unknown name strategy: ${this.nameStrategy}`);
+        throw new Error(`Unknown name strategy: ${this.nameStrategy}`)
     }
-    
+
     // Combine basename and extension
-    let filename = extension ? `${basename}${extension}` : basename;
-    
+    let filename = extension ? `${basename}${extension}` : basename
+
     // Ensure filename doesn't exceed max length
     if (filename.length > this.maxFilenameLength) {
       // Truncate basename to fit
-      const maxBasename = this.maxFilenameLength - (extension?.length || 0);
-      basename = basename.substring(0, maxBasename);
-      filename = extension ? `${basename}${extension}` : basename;
+      const maxBasename = this.maxFilenameLength - (extension?.length || 0)
+      basename = basename.substring(0, maxBasename)
+      filename = extension ? `${basename}${extension}` : basename
     }
-    
+
     // Handle duplicates
-    filename = await this.ensureUnique(filename);
-    
-    return filename;
+    filename = await this.ensureUnique(filename)
+
+    return filename
   }
-  
+
   /**
    * Sanitize filename for safe storage
    */
-  sanitizeFilename(filename) {
+  sanitizeFilename (filename) {
     return filename
       // Remove path traversal attempts
       .replace(/\.\./g, '')
@@ -98,53 +98,53 @@ export class LocalStorage {
       // Remove leading/trailing dots and spaces
       .replace(/^[\s.]+|[\s.]+$/g, '')
       // Collapse multiple underscores
-      .replace(/_+/g, '_')
+      .replace(/_+/g, '_') ||
       // Default if empty
-      || 'unnamed';
+      'unnamed'
   }
-  
+
   /**
    * Ensure filename is unique
    */
-  async ensureUnique(filename) {
-    const filepath = path.join(this.directory, filename);
-    
+  async ensureUnique (filename) {
+    const filepath = path.join(this.directory, filename)
+
     try {
-      await fs.access(filepath);
+      await fs.access(filepath)
       // File exists, generate unique name
-      const ext = path.extname(filename);
-      const base = path.basename(filename, ext);
-      let counter = 1;
-      let newFilename;
-      
+      const ext = path.extname(filename)
+      const base = path.basename(filename, ext)
+      let counter = 1
+      let newFilename
+
       do {
-        newFilename = `${base}_${counter}${ext}`;
-        counter++;
-      } while (await this.fileExists(path.join(this.directory, newFilename)));
-      
-      return newFilename;
+        newFilename = `${base}_${counter}${ext}`
+        counter++
+      } while (await this.fileExists(path.join(this.directory, newFilename)))
+
+      return newFilename
     } catch (error) {
       // File doesn't exist, name is unique
-      return filename;
+      return filename
     }
   }
-  
+
   /**
    * Check if file exists
    */
-  async fileExists(filepath) {
+  async fileExists (filepath) {
     try {
-      await fs.access(filepath);
-      return true;
+      await fs.access(filepath)
+      return true
     } catch {
-      return false;
+      return false
     }
   }
-  
+
   /**
    * Get safe extension from MIME type
    */
-  getExtensionFromMimeType(mimetype) {
+  getExtensionFromMimeType (mimetype) {
     // Safe mappings only
     const mimeToExt = {
       'image/jpeg': '.jpg',
@@ -157,62 +157,62 @@ export class LocalStorage {
       'video/mp4': '.mp4',
       'audio/mpeg': '.mp3',
       'application/zip': '.zip'
-    };
-    
-    return mimeToExt[mimetype] || '.bin';
+    }
+
+    return mimeToExt[mimetype] || '.bin'
   }
-  
+
   /**
    * Upload file with secure filename
    */
-  async upload(file) {
+  async upload (file) {
     // Ensure directory exists
-    await fs.mkdir(this.directory, { recursive: true });
-    
+    await fs.mkdir(this.directory, { recursive: true })
+
     // Generate secure filename
-    const filename = await this.generateFilename(file);
-    const filepath = path.join(this.directory, filename);
-    
+    const filename = await this.generateFilename(file)
+    const filepath = path.join(this.directory, filename)
+
     // Ensure we're not writing outside our directory (defense in depth)
-    const resolvedPath = path.resolve(filepath);
-    const resolvedDir = path.resolve(this.directory);
+    const resolvedPath = path.resolve(filepath)
+    const resolvedDir = path.resolve(this.directory)
     if (!resolvedPath.startsWith(resolvedDir)) {
-      throw new Error('Invalid file path');
+      throw new Error('Invalid file path')
     }
-    
+
     // Write file
     if (file.data) {
-      await fs.writeFile(filepath, file.data);
+      await fs.writeFile(filepath, file.data)
     } else if (file.filepath) {
-      await fs.rename(file.filepath, filepath);
+      await fs.rename(file.filepath, filepath)
     } else {
-      throw new Error('File has no data or filepath');
+      throw new Error('File has no data or filepath')
     }
-    
+
     // Return public URL
-    return `${this.fileBaseUrl}/${filename}`;
+    return `${this.fileBaseUrl}/${filename}`
   }
-  
+
   /**
    * Delete a file
    */
-  async delete(url) {
-    const filename = path.basename(url);
-    const filepath = path.join(this.directory, filename);
-    
+  async delete (url) {
+    const filename = path.basename(url)
+    const filepath = path.join(this.directory, filename)
+
     // Security check
-    const resolvedPath = path.resolve(filepath);
-    const resolvedDir = path.resolve(this.directory);
+    const resolvedPath = path.resolve(filepath)
+    const resolvedDir = path.resolve(this.directory)
     if (!resolvedPath.startsWith(resolvedDir)) {
-      throw new Error('Invalid file path');
+      throw new Error('Invalid file path')
     }
-    
+
     try {
-      await fs.unlink(filepath);
+      await fs.unlink(filepath)
     } catch (error) {
       if (error.code !== 'ENOENT') {
-        throw error;
+        throw error
       }
     }
   }
-}
+}

package/plugins/storage/s3-storage.js

@@ -1,12 +1,12 @@
 /**
  * S3 Storage Adapter
- * 
+ *
  * Stores uploaded files in Amazon S3 or S3-compatible storage.
- * 
+ *
  * Usage:
  * ```javascript
  * import { S3Storage } from 'jsonrestapi/lib/storage/s3-storage.js';
- * 
+ *
  * const storage = new S3Storage({
  *   bucket: 'my-uploads',
  *   region: 'us-east-1',
@@ -14,63 +14,63 @@
  *   secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
  *   prefix: 'uploads/' // optional path prefix
  * });
- * 
+ *
  * const schema = {
  *   image: { type: 'file', storage }
  * };
  * ```
  */
 
-import crypto from 'crypto';
-import path from 'path';
+import crypto from 'crypto'
+import path from 'path'
 
 export class S3Storage {
-  constructor(options = {}) {
-    this.bucket = options.bucket;
-    this.region = options.region || 'us-east-1';
-    this.prefix = options.prefix || '';
-    this.acl = options.acl || 'public-read';
-    
+  constructor (options = {}) {
+    this.bucket = options.bucket
+    this.region = options.region || 'us-east-1'
+    this.prefix = options.prefix || ''
+    this.acl = options.acl || 'public-read'
+
     if (!this.bucket) {
-      throw new Error('S3Storage requires a bucket name');
+      throw new Error('S3Storage requires a bucket name')
     }
-    
+
     // Note: In a real implementation, you would initialize the AWS SDK here
     // For this example, we'll just mock the behavior
-    this.mockMode = options.mockMode !== false; // Default to mock mode
-    
+    this.mockMode = options.mockMode !== false // Default to mock mode
+
     if (!this.mockMode) {
       // Real S3 initialization would go here
       // const { S3Client } = require('@aws-sdk/client-s3');
       // this.s3 = new S3Client({ region: this.region });
     }
   }
-  
+
   /**
    * Upload a file to S3
    * @param {Object} file - File object from detector
    * @returns {Promise<string>} URL of the uploaded file
    */
-  async upload(file) {
+  async upload (file) {
     // Generate S3 key
-    const ext = path.extname(file.filename);
-    const hash = crypto.randomBytes(16).toString('hex');
-    const key = `${this.prefix}${hash}${ext}`;
-    
+    const ext = path.extname(file.filename)
+    const hash = crypto.randomBytes(16).toString('hex')
+    const key = `${this.prefix}${hash}${ext}`
+
     if (this.mockMode) {
       // Mock mode - just return a fake URL
-      const url = `https://${this.bucket}.s3.${this.region}.amazonaws.com/${key}`;
-      
+      const url = `https://${this.bucket}.s3.${this.region}.amazonaws.com/${key}`
+
       // Simulate upload delay
-      await new Promise(resolve => setTimeout(resolve, 100));
-      
-      return url;
+      await new Promise(resolve => setTimeout(resolve, 100))
+
+      return url
     }
-    
+
     // Real S3 upload would go here
     /*
     const { PutObjectCommand } = require('@aws-sdk/client-s3');
-    
+
     const command = new PutObjectCommand({
       Bucket: this.bucket,
       Key: key,
@@ -81,9 +81,9 @@ export class S3Storage {
         originalName: file.filename
       }
     });
-    
+
     await this.s3.send(command);
-    
+
     // Return public URL
     if (this.acl === 'public-read') {
       return `https://${this.bucket}.s3.${this.region}.amazonaws.com/${key}`;
@@ -93,33 +93,32 @@ export class S3Storage {
     }
     */
   }
-  
+
   /**
    * Delete a file from S3
    * @param {string} url - URL returned by upload()
    * @returns {Promise<void>}
    */
-  async delete(url) {
+  async delete (url) {
     // Extract key from URL
-    const urlObj = new URL(url);
-    const key = urlObj.pathname.substring(1); // Remove leading /
-    
+    const urlObj = new URL(url)
+    const key = urlObj.pathname.substring(1) // Remove leading /
+
     if (this.mockMode) {
       // Mock mode - just simulate deletion
-      await new Promise(resolve => setTimeout(resolve, 50));
-      return;
+      await new Promise(resolve => setTimeout(resolve, 50))
     }
-    
+
     // Real S3 delete would go here
     /*
     const { DeleteObjectCommand } = require('@aws-sdk/client-s3');
-    
+
     const command = new DeleteObjectCommand({
       Bucket: this.bucket,
       Key: key
     });
-    
+
     await this.s3.send(command);
     */
   }
-}
+}

package/quickTest.js

@@ -1,11 +1,11 @@
 //
 // index.js
 //
-import { RestApiPlugin, RestApiKnexPlugin, ExpressPlugin } from './index.js'; // Added: ExpressPlugin
-import { Api } from 'hooked-api';
-import knexLib from 'knex';
-import util from 'util';
-import express from 'express'; // Added: Express
+import { RestApiPlugin, RestApiKnexPlugin, ExpressPlugin } from './index.js' // Added: ExpressPlugin
+import { Api } from 'hooked-api'
+import knexLib from 'knex'
+import util from 'util'
+import express from 'express' // Added: Express
 
 // Utility used throughout this guide
 const inspect = (obj) => util.inspect(obj, { depth: 8 })
@@ -17,15 +17,15 @@ const knex = knexLib({
     filename: ':memory:'
   },
   useNullAsDefault: true
-});
+})
 
 // Create API instance
-const api = new Api({ name: 'book-catalog-api', logLevel: 'trace' });
+const api = new Api({ name: 'book-catalog-api', logLevel: 'trace' })
 
 // Install plugins
-await api.use(RestApiPlugin, {returnBasePath: '/api' });
-await api.use(RestApiKnexPlugin, { knex });
-await api.use(ExpressPlugin, {  mountPath: '/api' }); // Added: Express Plugin
+await api.use(RestApiPlugin, { returnBasePath: '/api' })
+await api.use(RestApiKnexPlugin, { knex })
+await api.use(ExpressPlugin, { mountPath: '/api' }) // Added: Express Plugin
 
 // Define publishers resource
 await api.addResource('publishers', {
@@ -39,8 +39,8 @@ await api.addResource('publishers', {
   searchSchema: { // Adding search schema for publishers
     name: { type: 'string', filterOperator: 'like' }
   }
-});
-await api.resources.publishers.createKnexTable();
+})
+await api.resources.publishers.createKnexTable()
 
 // Define authors resource, which belongs to a publisher
 await api.addResource('authors', {
@@ -55,21 +55,21 @@ await api.addResource('authors', {
     publisher: { type: 'id', actualField: 'publisher_id', nullable: true },
     publisherName: { type: 'string', actualField: 'publishers.name', filterOperator: 'like' } // Cross-table search
   }
-});
-await api.resources.authors.createKnexTable();
+})
+await api.resources.authors.createKnexTable()
 
 // Method 1: Simplified mode without inputRecord (most concise)
 const penguinResult = await api.resources.publishers.post({
   name: 'Penguin Random House'
-});
-console.log('Created publisher:', inspect(penguinResult));
+})
+console.log('Created publisher:', inspect(penguinResult))
 
 // Method 2: Simplified mode with inputRecord (explicit)
 const harperResult = await api.resources.publishers.post({
   inputRecord: {
     name: 'HarperCollins'
   }
-});
+})
 
 // Method 3: Full JSON:API mode (standards compliant)
 const oxfordResult = await api.resources.publishers.post({
@@ -82,54 +82,54 @@ const oxfordResult = await api.resources.publishers.post({
     }
   },
   simplified: false
-});
-console.log('JSON:API response:', inspect(oxfordResult));
+})
+console.log('JSON:API response:', inspect(oxfordResult))
 
 // Create an author linked to the first publisher (simplified)
 const authorResult = await api.resources.authors.post({
   name: 'George',
   surname: 'Orwell',
   publisher_id: penguinResult.id
-});
-console.log('Created author:', inspect(authorResult));
+})
+console.log('Created author:', inspect(authorResult))
 
 // Get all publishers
-const allPublishers = await api.resources.publishers.query({});
-console.log('All publishers:', inspect(allPublishers));
+const allPublishers = await api.resources.publishers.query({})
+console.log('All publishers:', inspect(allPublishers))
 
 // Get publisher with included authors
 const publisherWithAuthors = await api.resources.publishers.get({
   id: penguinResult.id,
   include: ['authors']
-});
-console.log('Publisher with authors:', inspect(publisherWithAuthors));
+})
+console.log('Publisher with authors:', inspect(publisherWithAuthors))
 
 // Search authors by name
 const searchResult = await api.resources.authors.query({
   filter: { name: 'George' }
-});
-console.log('Search results:', inspect(searchResult));
+})
+console.log('Search results:', inspect(searchResult))
 
 // Update an author
 const updateResult = await api.resources.authors.patch({
   id: authorResult.id,
   surname: 'Orwell (Eric Blair)'
-});
-console.log('Updated author:', inspect(updateResult));
+})
+console.log('Updated author:', inspect(updateResult))
 
 /// *** ...programmatic calls here... ***
 
-// Create the express server and add the API's routes 
-const app = express();
-app.use(api.http.express.router);
-app.use(api.http.express.notFoundRouter);
+// Create the express server and add the API's routes
+const app = express()
+app.use(api.http.express.router)
+app.use(api.http.express.notFoundRouter)
 
 app.listen(3000, () => {
-  console.log('Express server started on port 3000. API available at http://localhost:3000/api');
+  console.log('Express server started on port 3000. API available at http://localhost:3000/api')
 }).on('error', (err) => {
-  console.error('Failed to start server:', err);
+  console.error('Failed to start server:', err)
   process.exit(1)
 }).on('error', (err) => {
-  console.error('Failed to start server:', err);
+  console.error('Failed to start server:', err)
   process.exit(1)
-});
+})