json-rest-api 1.0.0 → 1.0.1

package/test-examples/test-file-upload.js

@@ -0,0 +1,132 @@
+import { Api } from 'hooked-api';
+import { RestApiPlugin, FileHandlingPlugin, ExpressPlugin } from 'json-rest-api';
+import { LocalStorage } from 'json-rest-api';
+import express from 'express';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import fs from 'fs/promises';
+import path from 'path';
+
+const execAsync = promisify(exec);
+
+const api = new Api({
+  name: 'my-library-api',
+  version: '1.0.0'
+});
+
+// Create a storage adapter
+const coverStorage = new LocalStorage({
+  directory: './uploads/covers',
+  baseUrl: 'http://localhost:3000/uploads/covers'
+});
+
+// Add plugins (ORDER MATTERS!)
+api.use(RestApiPlugin);
+api.use(FileHandlingPlugin);  // Must come after RestApiPlugin
+api.use(ExpressPlugin);       // Must come after FileHandlingPlugin
+
+// Update the books schema to include a cover image
+api.addResource('books', {
+  schema: {
+    title: { type: 'string', required: true },
+    author: { type: 'string', required: true },
+    year: { type: 'number' },
+    isbn: { type: 'string' },
+    cover: {
+      type: 'file',
+      storage: coverStorage,
+      accepts: ['image/jpeg', 'image/png', 'image/gif'],
+      maxSize: '5mb'
+    }
+  }
+});
+
+// Add dataPost helper to handle the cover URL
+api.customize({
+  vars: {
+    helpers: {
+      dataPost: async ({ scopeName, inputRecord }) => {
+        const newBook = {
+          id: String(Date.now()),
+          ...inputRecord.data.attributes
+        };
+        
+        // The file has already been uploaded and replaced with a URL
+        console.log('Book cover URL:', newBook.cover);
+        
+        return {
+          data: {
+            type: 'books',
+            id: newBook.id,
+            attributes: {
+              title: newBook.title,
+              author: newBook.author,
+              year: newBook.year,
+              cover: newBook.cover  // This is now a URL!
+            }
+          }
+        };
+      },
+      
+      dataQuery: async () => ({ data: [] })
+    }
+  }
+});
+
+// Wait for async plugin initialization
+await new Promise(resolve => setTimeout(resolve, 100));
+
+// Create Express app
+const app = express();
+
+// Serve uploaded files
+app.use('/uploads', express.static('./uploads'));
+
+// Mount the API
+app.use(api.http.express.router);
+
+const server = app.listen(3000, async () => {
+  console.log('✓ File upload API running at http://localhost:3000/api');
+  
+  // Create a test image file
+  const testImagePath = './test-cover.png';
+  await fs.writeFile(testImagePath, Buffer.from('PNG_TEST_DATA'));
+  
+  try {
+    // Test file upload with curl
+    console.log('\nTesting file upload with multipart/form-data...\n');
+    
+    const { stdout, stderr } = await execAsync(`curl -s -X POST http://localhost:3000/api/books \
+      -F "title=The Hobbit" \
+      -F "author=J.R.R. Tolkien" \
+      -F "year=1937" \
+      -F "cover=@${testImagePath}"`);
+    
+    if (stderr) {
+      console.error('Curl error:', stderr);
+    } else {
+      console.log('Response:', stdout);
+      
+      // Parse response to check if it worked
+      try {
+        const response = JSON.parse(stdout);
+        if (response.data && response.data.attributes && response.data.attributes.cover) {
+          console.log('\n✓ File upload successful!');
+          console.log('  Book ID:', response.data.id);
+          console.log('  Cover URL:', response.data.attributes.cover);
+        } else if (response.errors) {
+          console.log('\n✗ File upload failed with errors:', response.errors);
+        }
+      } catch (e) {
+        console.log('\n✗ Could not parse response');
+      }
+    }
+  } catch (error) {
+    console.error('Test failed:', error.message);
+  } finally {
+    // Cleanup
+    await fs.unlink(testImagePath).catch(() => {});
+    server.close();
+    process.exit(0);
+  }
+});

package/test-examples/test-http-plugin.js

@@ -0,0 +1,159 @@
+import { Api } from 'hooked-api';
+import { RestApiPlugin, FileHandlingPlugin, HttpPlugin } from 'json-rest-api';
+
+const api = new Api({
+  name: 'my-library-api',
+  version: '1.0.0'
+});
+
+// Add plugins
+api.use(RestApiPlugin);
+api.use(FileHandlingPlugin);
+api.use(HttpPlugin, {
+  port: 3000,                // Server port (default: 3000)
+  basePath: '/api',          // API base path (default: '/api')
+  strictContentType: true,   // Enforce JSON content types (default: true)
+  requestSizeLimit: '10mb'   // Max request body size (default: '1mb')
+});
+
+// Add your books resource
+api.addResource('books', {
+  schema: {
+    title: { type: 'string', required: true },
+    author: { type: 'string', required: true },
+    year: { type: 'number' },
+    isbn: { type: 'string' }
+  }
+});
+
+// Add simple data helpers
+api.customize({
+  vars: {
+    helpers: {
+      dataQuery: async ({ scopeName, queryParams }) => {
+        const fakeBooks = [
+          { id: '1', title: 'The Great Gatsby', author: 'F. Scott Fitzgerald', year: 1925 },
+          { id: '2', title: '1984', author: 'George Orwell', year: 1949 },
+          { id: '3', title: 'To Kill a Mockingbird', author: 'Harper Lee', year: 1960 }
+        ];
+        
+        return {
+          data: fakeBooks.map(book => ({
+            type: 'books',
+            id: book.id,
+            attributes: {
+              title: book.title,
+              author: book.author,
+              year: book.year
+            }
+          }))
+        };
+      },
+      
+      dataGet: async ({ scopeName, id }) => {
+        const book = { id, title: 'Example Book', author: 'Example Author', year: 2024 };
+        
+        return {
+          data: {
+            type: 'books',
+            id: book.id,
+            attributes: {
+              title: book.title,
+              author: book.author,
+              year: book.year
+            }
+          }
+        };
+      },
+      
+      dataPost: async ({ scopeName, inputRecord }) => {
+        const newBook = {
+          id: String(Date.now()),
+          ...inputRecord.data.attributes
+        };
+        
+        return {
+          data: {
+            type: 'books',
+            id: newBook.id,
+            attributes: {
+              title: newBook.title,
+              author: newBook.author,
+              year: newBook.year
+            }
+          }
+        };
+      },
+      
+      dataPut: async ({ scopeName, id, inputRecord }) => {
+        return {
+          data: {
+            type: 'books',
+            id: id,
+            attributes: inputRecord.data.attributes
+          }
+        };
+      },
+      
+      dataPatch: async ({ scopeName, id, inputRecord }) => {
+        return {
+          data: {
+            type: 'books',
+            id: id,
+            attributes: inputRecord.data.attributes
+          }
+        };
+      },
+      
+      dataDelete: async ({ scopeName, id }) => {
+        return { success: true };
+      }
+    }
+  }
+});
+
+// Wait for async plugin installation to complete
+await new Promise(resolve => setTimeout(resolve, 100));
+
+// Start the HTTP server - multiple options:
+console.log('Testing HTTP plugin options...\n');
+
+// Check if api.http namespace exists
+console.log('api.http exists?', !!api.http);
+console.log('api.http.startServer exists?', typeof api.http?.startServer);
+
+// Option 1: Start on configured port (3000 by default)
+api.http.startServer();
+
+console.log('✓ HTTP server started successfully!');
+console.log('  API running at http://localhost:3000/api');
+
+// Test with curl commands after a short delay
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+
+setTimeout(async () => {
+  try {
+    console.log('\nTesting endpoints...\n');
+    
+    // Test GET all books
+    console.log('1. Testing GET /api/books:');
+    const { stdout: getAll } = await execAsync('curl -s http://localhost:3000/api/books');
+    console.log('✓ Response:', getAll.substring(0, 100) + '...');
+    
+    // Test GET single book
+    console.log('\n2. Testing GET /api/books/1:');
+    const { stdout: getOne } = await execAsync('curl -s http://localhost:3000/api/books/1');
+    console.log('✓ Response:', getOne.substring(0, 100) + '...');
+    
+    // Close server
+    console.log('\nClosing server...');
+    api.http.server.close();
+    process.exit(0);
+    
+  } catch (error) {
+    console.error('Test error:', error.message);
+    process.exit(1);
+  }
+}, 500);

package/test-examples/test-programmatic-api.js

@@ -0,0 +1,188 @@
+import { Api } from 'hooked-api';
+import { RestApiPlugin } from 'json-rest-api';
+
+const api = new Api({
+  name: 'my-library-api',
+  version: '1.0.0'
+});
+
+// Use the REST API plugin
+api.use(RestApiPlugin);
+
+// Define a books resource
+api.addResource('books', {
+  schema: {
+    title: { type: 'string', required: true },
+    author: { type: 'string', required: true },
+    year: { type: 'number' },
+    isbn: { type: 'string' }
+  }
+});
+
+// Add simple data helpers
+api.customize({
+  vars: {
+    helpers: {
+      dataQuery: async ({ scopeName, queryParams }) => {
+        const fakeBooks = [
+          { id: '1', title: 'The Great Gatsby', author: 'F. Scott Fitzgerald', year: 1925 },
+          { id: '2', title: '1984', author: 'George Orwell', year: 1949 },
+          { id: '3', title: 'To Kill a Mockingbird', author: 'Harper Lee', year: 1960 }
+        ];
+        
+        return {
+          data: fakeBooks.map(book => ({
+            type: 'books',
+            id: book.id,
+            attributes: {
+              title: book.title,
+              author: book.author,
+              year: book.year
+            }
+          }))
+        };
+      },
+      
+      dataGet: async ({ scopeName, id }) => {
+        const book = { id, title: 'Example Book', author: 'Example Author', year: 2024 };
+        
+        return {
+          data: {
+            type: 'books',
+            id: book.id,
+            attributes: {
+              title: book.title,
+              author: book.author,
+              year: book.year
+            }
+          }
+        };
+      },
+      
+      dataPost: async ({ scopeName, inputRecord }) => {
+        const newBook = {
+          id: String(Date.now()),
+          ...inputRecord.data.attributes
+        };
+        
+        return {
+          data: {
+            type: 'books',
+            id: newBook.id,
+            attributes: {
+              title: newBook.title,
+              author: newBook.author,
+              year: newBook.year
+            }
+          }
+        };
+      },
+      
+      dataPut: async ({ scopeName, id, inputRecord }) => {
+        return {
+          data: {
+            type: 'books',
+            id: id,
+            attributes: inputRecord.data.attributes
+          }
+        };
+      },
+      
+      dataPatch: async ({ scopeName, id, inputRecord }) => {
+        return {
+          data: {
+            type: 'books',
+            id: id,
+            attributes: inputRecord.data.attributes
+          }
+        };
+      },
+      
+      dataDelete: async ({ scopeName, id }) => {
+        return { success: true };
+      }
+    }
+  }
+});
+
+// Test programmatic API usage
+console.log('Testing programmatic API usage...\n');
+
+// First check what methods are available
+console.log('Available methods on api.resources.books:');
+if (api.resources && api.resources.books) {
+  const methods = Object.keys(api.resources.books).filter(k => typeof api.resources.books[k] === 'function');
+  console.log('  Methods:', methods.join(', '));
+} else {
+  console.log('  ERROR: api.resources.books is not available');
+}
+
+try {
+  // Query all books
+  console.log('\n1. Testing query():');
+  const allBooks = await api.resources.books.query({});
+  console.log('✓ Query successful:', JSON.stringify(allBooks, null, 2));
+  
+  // Get a single book
+  console.log('\n2. Testing get():');
+  const book = await api.resources.books.get({ id: '1' });
+  console.log('✓ Get successful:', JSON.stringify(book, null, 2));
+  
+  // Create a new book
+  console.log('\n3. Testing post():');
+  const newBook = await api.resources.books.post({
+    inputRecord: {
+      data: {
+        type: 'books',
+        attributes: {
+          title: 'New Book',
+          author: 'New Author',
+          year: 2024
+        }
+      }
+    }
+  });
+  console.log('✓ Post successful:', JSON.stringify(newBook, null, 2));
+  
+  // Update a book (replace all fields)
+  console.log('\n4. Testing put():');
+  const updatedBook = await api.resources.books.put({
+    id: '1',
+    inputRecord: {
+      data: {
+        type: 'books',
+        attributes: {
+          title: 'Updated Title',
+          author: 'Updated Author',
+          year: 2024
+        }
+      }
+    }
+  });
+  console.log('✓ Put successful:', JSON.stringify(updatedBook, null, 2));
+  
+  // Partially update a book
+  console.log('\n5. Testing patch():');
+  const patchedBook = await api.resources.books.patch({
+    id: '1',
+    inputRecord: {
+      data: {
+        type: 'books',
+        attributes: {
+          title: 'New Title Only'
+        }
+      }
+    }
+  });
+  console.log('✓ Patch successful:', JSON.stringify(patchedBook, null, 2));
+  
+  // Delete a book
+  console.log('\n6. Testing delete():');
+  const deleteResult = await api.resources.books.delete({ id: '1' });
+  console.log('✓ Delete successful:', JSON.stringify(deleteResult, null, 2));
+  
+  console.log('\n✅ All programmatic API tests passed!');
+} catch (error) {
+  console.error('❌ Error:', error.message);
+  console.error(error.stack);
+}

package/test-examples/test-rest-api-plugin.js

@@ -0,0 +1,13 @@
+import { Api } from 'hooked-api';
+import { RestApiPlugin } from 'json-rest-api';
+
+const api = new Api({
+  name: 'my-library-api',
+  version: '1.0.0'
+});
+
+// Use the REST API plugin
+api.use(RestApiPlugin);
+
+console.log('✓ REST API Plugin loaded successfully!');
+console.log('  Plugin registered:', api.plugins.has(RestApiPlugin));

package/TODO.todo

@@ -1,113 +0,0 @@
-TODO
-
-10. Utility Features
-
-  - Missing from original:
-    - artificial delay for testing <-- ADD!!!
-    - Request decoration pattern <-- I DON'T KNOW WHAT THIS IS, BUT IF IT'S BEST PRACTICE/INDUSTRU STANDARD, TELL ME ABOUT IT
-    - Store inheritance/extension <--- THIS, I NEVER WANTED, NEVER USED IN 10 YEARS IN PRODUCTION
-    - Automatic timestamp fields <-- WOULD BE NICE
-    - Soft delete support <-- WOULD BE NICE BUT I DON'T THINK THE ORIGINAL HAD IT. I WILL IMPLEMENT IT IN THE FUTURE
-
-
-  5. Error Handling
-
-  - Missing structured error classes:
-    - BadRequest, NotFound, Conflict classes
-    - Error code standardization
-    - Multi-field validation errors
-    - Error context preservation
-
-  6. Hook System Gaps
-
-  - Missing hooks from original:
-    - beforeId, afterId
-    - beforeRetrieve, afterRetrieve
-    - beforeInsert, afterInsert (full lifecycle)
-    - queryFieldsAndJoins
-    - updateConditionsAndArgs
-    - deleteConditionsAndArgs
-
-  7. Store Templates
-
-  - No equivalent to storeTemplate.js:
-    - Automatic REST endpoint generation
-    - Built-in authentication handling
-    - Session management
-    - Request/response transformation
-
-  8. Memory Store Features
-
-  - Current memory plugin lacks:
-    - Query operators ($like, $in, $gt, etc.)
-    - Sorting by multiple fields
-    - Limit/offset with total count
-    - Deep object filtering
-
-
-
-  11. JSON:API Compliance Gaps
-
-  - Current HTTP plugin missing:
-    - Proper relationship handling
-    - Compound documents
-    - Sparse fieldsets
-    - Include parameter processing
-    - Meta information structure
-
-  12. Performance Features
-
-  - Not implemented:
-    - Connection pooling configuration
-    - Query result caching
-    - Batch operations
-    - Transaction support across operations
-
-
-
-    **************************************************************************
-    DONE
-    **************************************************************************
-    
-      2. MySQL Schema Synchronization
-
-  - Current MySQL plugin is basic, missing:
-    - Automatic table creation/modification
-    - Column type mapping from schema
-    - Index creation for searchable fields
-    - Foreign key constraint management
-    - Schema migration tracking
-
-  9. Schema Features
-
-  - SimplSchema integration missing:
-    - onlyObjectValues for partial updates
-    - Conditional defaults based on other fields
-    - Array validation with item schemas
-    - Custom error messages per validator
-
-1. Positioning System
-
-  - Current has basic positioning plugin but lacks:
-    - Filtering support during repositioning
-    - Gap-free positioning algorithm
-    - Complex position calculations with conditions
-    - Batch repositioning operations
-
-      3. Advanced Querying
-
-  - Missing query capabilities:
-    - Complex field joins (queryFieldsAndJoins hook)
-    - Nested object queries
-    - Array field queries
-    - Custom SQL conditions
-    - Aggregation support
-
-      4. Versioning Management
-
-  - Current versioning is rudimentary, missing:
-    - Version range negotiation
-    - Store registry with semver matching
-    - Version-specific schema transformations
-    - Backward compatibility helpers
-