json-rest-api 1.0.6 → 1.0.8

package/plugins/core/socketio-plugin.js

@@ -58,15 +58,15 @@ export const SocketIOPlugin = {
           continue;
         }
 
-        // Check if filterUsing is a function
-        if (typeof fieldDef.filterUsing === 'function') {
+        // Check if filterOperator is a function
+        if (typeof fieldDef.filterOperator === 'function') {
           // Must use filterRecord (validated during subscription)
           if (!fieldDef.filterRecord(record, filterValue)) {
             return false;
           }
         } else {
           // Use simple operator logic
-          const operator = fieldDef.filterUsing || '=';
+          const operator = fieldDef.filterOperator || '=';
 
           switch (operator) {
             case 'like':
@@ -137,6 +137,13 @@ export const SocketIOPlugin = {
 
     // Main broadcast function
     async function performBroadcast({ method, scopeName, id, context }) {
+      console.log(`[SOCKETIO DEBUG] performBroadcast called:`, { 
+        method, 
+        scopeName, 
+        id,
+        hasMinimalRecord: !!context.minimalRecord
+      });
+      
       const scope = api.resources[scopeName];
       if (!scope) {
         log.error(`Scope ${scopeName} not found for broadcasting`);
@@ -212,8 +219,11 @@ export const SocketIOPlugin = {
 
     // Create Socket.IO server
     api.startSocketServer = async (server, options = {}) => {
+      // Default path respects mountPath for consistency with REST API
+      const defaultPath = vars.transport?.mountPath ? `${vars.transport.mountPath}/socket.io` : '/socket.io';
+      
       const {
-        path = '/socket.io',
+        path = defaultPath,
         cors = { origin: '*', methods: ['GET', 'POST'] },
         redis = null
       } = options;
@@ -345,7 +355,7 @@ export const SocketIOPlugin = {
               for (const filterKey of Object.keys(filters)) {
                 const fieldDef = searchSchema.structure[filterKey];
 
-                if (fieldDef && typeof fieldDef.filterUsing === 'function' && !fieldDef.filterRecord) {
+                if (fieldDef && typeof fieldDef.filterOperator === 'function' && !fieldDef.filterRecord) {
                   const error = {
                     code: 'UNSUPPORTED_FILTER',
                     message: `Filter '${filterKey}' uses custom SQL logic and requires 'filterRecord' for real-time 
@@ -605,23 +615,35 @@ subscriptions`
     addHook('finish', 'socketio-broadcast', {}, async ({ context }) => {
       const { method, scopeName, id } = context;
 
+      console.log(`[SOCKETIO DEBUG] finish hook called:`, { 
+        method, 
+        scopeName, 
+        id, 
+        hasMinimalRecord: !!context.minimalRecord,
+        hasTransaction: !!context.transaction 
+      });
+
       // Only broadcast for write operations
       if (!['post', 'put', 'patch', 'delete'].includes(method)) {
+        log.debug(`[SOCKETIO DEBUG] Skipping broadcast for method: ${method}`);
         return;
       }
 
       // Skip if no ID (might happen in error cases)
       if (!id && method !== 'delete') {
+        log.debug(`[SOCKETIO DEBUG] Skipping broadcast - no ID for method: ${method}`);
         return;
       }
 
       // Skip if io not initialized
       if (!io) {
+        log.debug(`[SOCKETIO DEBUG] Skipping broadcast - io not initialized`);
         return;
       }
 
       // If there's a transaction, defer broadcasting
       if (context.transaction) {
+        console.log(`[SOCKETIO DEBUG] Deferring broadcast until transaction commit`);
         // Store broadcast info in WeakMap
         if (!pendingBroadcasts.has(context.transaction)) {
           pendingBroadcasts.set(context.transaction, []);
@@ -633,6 +655,7 @@ subscriptions`
       }
 
       // No transaction, broadcast immediately
+      console.log(`[SOCKETIO DEBUG] Broadcasting immediately (no transaction)`);
       await performBroadcast({ method, scopeName, id, context });
     });
 

package/plugins/storage/local-storage.js

@@ -11,7 +11,7 @@ import crypto from 'crypto';
 export class LocalStorage {
   constructor(options = {}) {
     this.directory = path.resolve(options.directory || './uploads');
-    this.baseUrl = options.baseUrl || '/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;
@@ -190,7 +190,7 @@ export class LocalStorage {
     }
     
     // Return public URL
-    return `${this.baseUrl}/${filename}`;
+    return `${this.fileBaseUrl}/${filename}`;
   }
   
   /**

package/tests/computed-fields.test.js

@@ -0,0 +1,483 @@
+import { describe, it, before, beforeEach, after } from 'node:test';
+import assert from 'node:assert/strict';
+import knexLib from 'knex';
+import { cleanTables } from './helpers/test-utils.js';
+import { createComputedFieldsApi } from './fixtures/api-configs.js';
+
+// Create Knex instance for tests
+const knex = knexLib({
+  client: 'better-sqlite3',
+  connection: {
+    filename: ':memory:'
+  },
+  useNullAsDefault: true
+});
+
+describe('Computed Fields and Sparse Fieldsets', () => {
+  let api;
+  let testData = {};
+
+  before(async () => {
+    api = await createComputedFieldsApi(knex);
+  });
+
+  after(async () => {
+    await knex.destroy();
+  });
+
+  beforeEach(async () => {
+    await cleanTables(knex, ['test_products', 'test_reviews']);
+    
+    // Create test data
+    const product = await api.resources.products.post({
+      name: 'Premium Widget',
+      price: 99.99,
+      cost: 45.00,
+      internal_notes: 'Supplier: ABC Corp'
+    });
+    testData.product = product;
+
+    const review1 = await api.resources.reviews.post({
+      product_id: product.id,
+      reviewer_name: 'Alice',
+      rating: 5,
+      comment: 'Excellent product!',
+      helpful_votes: 45,
+      total_votes: 50,
+      spam_score: 0.1
+    });
+    testData.review1 = review1;
+
+    const review2 = await api.resources.reviews.post({
+      product_id: product.id,
+      reviewer_name: 'Bob',
+      rating: 4,
+      comment: 'Good value',
+      helpful_votes: 8,
+      total_votes: 20,
+      spam_score: 0.2
+    });
+    testData.review2 = review2;
+  });
+
+  describe('Basic Computed Fields', () => {
+    it('should compute fields automatically when fetching', async () => {
+      const product = await api.resources.products.get({ id: testData.product.id });
+      
+      assert.equal(product.name, 'Premium Widget');
+      assert.equal(product.price, 99.99);
+      assert.equal(product.profit_margin, 55.00);
+      assert.equal(product.profit_amount, 54.99);
+      
+      // normallyHidden fields should not be included
+      assert.equal(product.cost, undefined);
+      assert.equal(product.internal_notes, undefined);
+    });
+
+    it('should handle division by zero in computed fields', async () => {
+      const freeProduct = await api.resources.products.post({
+        name: 'Free Sample',
+        price: 0,
+        cost: 0
+      });
+
+      const fetched = await api.resources.products.get({ id: freeProduct.id });
+      assert.equal(fetched.profit_margin, 0);
+      assert.equal(fetched.profit_amount, 0);
+    });
+
+    it('should handle null values in computed fields', async () => {
+      const review = await api.resources.reviews.post({
+        product_id: testData.product.id,
+        reviewer_name: 'Charlie',
+        rating: 3,
+        comment: 'Average',
+        helpful_votes: 0,
+        total_votes: 0
+      });
+
+      const fetched = await api.resources.reviews.get({ id: review.id });
+      assert.equal(fetched.helpfulness_score, null);
+      assert.equal(fetched.is_helpful, null);
+    });
+  });
+
+  describe('Sparse Fieldsets with Computed Fields', () => {
+    it('should return only requested fields including computed', async () => {
+      const product = await api.resources.products.get({
+        id: testData.product.id,
+        queryParams: {
+          fields: { products: 'name,profit_margin' }
+        }
+      });
+
+      assert.equal(product.id, testData.product.id);
+      assert.equal(product.name, 'Premium Widget');
+      assert.equal(product.profit_margin, 55.00);
+      
+      // Other fields should not be included
+      assert.equal(product.price, undefined);
+      assert.equal(product.profit_amount, undefined);
+      assert.equal(product.cost, undefined);
+    });
+
+    it('should fetch dependencies but not include them in response', async () => {
+      const product = await api.resources.products.get({
+        id: testData.product.id,
+        queryParams: {
+          fields: { products: 'profit_margin' }
+        }
+      });
+
+      assert.equal(product.id, testData.product.id);
+      assert.equal(product.profit_margin, 55.00);
+      
+      // Dependencies should not be included
+      assert.equal(product.price, undefined);
+      assert.equal(product.cost, undefined);
+    });
+
+    it('should allow explicitly requesting normallyHidden dependencies', async () => {
+      const product = await api.resources.products.get({
+        id: testData.product.id,
+        queryParams: {
+          fields: { products: 'name,cost,profit_margin' }
+        }
+      });
+
+      assert.equal(product.name, 'Premium Widget');
+      assert.equal(product.cost, 45); // Explicitly requested
+      assert.equal(product.profit_margin, 55.00);
+      
+      // Price was not requested
+      assert.equal(product.price, undefined);
+    });
+
+    it('should handle multiple computed fields with overlapping dependencies', async () => {
+      const product = await api.resources.products.get({
+        id: testData.product.id,
+        queryParams: {
+          fields: { products: 'profit_margin,profit_amount' }
+        }
+      });
+
+      assert.equal(product.profit_margin, 55.00);
+      assert.equal(product.profit_amount, 54.99);
+      
+      // Shared dependencies should not be included
+      assert.equal(product.price, undefined);
+      assert.equal(product.cost, undefined);
+    });
+  });
+
+  describe('Computed Fields in Included Resources', () => {
+    it('should compute fields in hasMany included resources', async () => {
+      const product = await api.resources.products.get({
+        id: testData.product.id,
+        queryParams: {
+          include: ['reviews']
+        }
+      });
+
+      assert.equal(product.reviews.length, 2);
+      
+      const review1 = product.reviews.find(r => r.reviewer_name === 'Alice');
+      assert.equal(review1.helpfulness_score, 90);
+      assert.equal(review1.is_helpful, true);
+      assert.equal(review1.spam_score, undefined); // normallyHidden
+      
+      const review2 = product.reviews.find(r => r.reviewer_name === 'Bob');
+      assert.equal(review2.helpfulness_score, 40);
+      assert.equal(review2.is_helpful, false); // Has enough votes but not helpful enough
+    });
+
+    it('should apply sparse fieldsets to included resources with computed fields', async () => {
+      const product = await api.resources.products.get({
+        id: testData.product.id,
+        queryParams: {
+          include: ['reviews'],
+          fields: {
+            products: 'name',
+            reviews: 'reviewer_name,rating,helpfulness_score'
+          }
+        }
+      });
+
+      assert.equal(product.name, 'Premium Widget');
+      assert.equal(product.price, undefined);
+      assert.equal(product.profit_margin, undefined);
+
+      const review = product.reviews[0];
+      assert.ok(review.reviewer_name);
+      assert.ok(review.rating);
+      assert.ok(review.helpfulness_score !== undefined);
+      
+      // Other fields should not be included
+      assert.equal(review.comment, undefined);
+      assert.equal(review.helpful_votes, undefined);
+      assert.equal(review.total_votes, undefined);
+      assert.equal(review.is_helpful, undefined); // Not requested
+    });
+
+    it('should handle computed dependencies in included resources', async () => {
+      const product = await api.resources.products.get({
+        id: testData.product.id,
+        queryParams: {
+          include: ['reviews'],
+          fields: {
+            products: 'name',
+            reviews: 'is_helpful' // Depends on helpful_votes, total_votes, spam_score
+          }
+        }
+      });
+
+      const review = product.reviews.find(r => r.id === testData.review1.id);
+      assert.equal(review.is_helpful, true);
+      
+      // Dependencies should not be included
+      assert.equal(review.helpful_votes, undefined);
+      assert.equal(review.total_votes, undefined);
+      assert.equal(review.spam_score, undefined);
+    });
+  });
+
+  describe('Collection Queries with Computed Fields', () => {
+    it('should compute fields for all records in collection', async () => {
+      const products = await api.resources.products.query();
+      
+      assert.equal(products.data.length, 1);
+      const product = products.data[0];
+      assert.equal(product.profit_margin, 55.00);
+      assert.equal(product.profit_amount, 54.99);
+    });
+
+    it('should apply sparse fieldsets to collections', async () => {
+      const products = await api.resources.products.query({
+        queryParams: {
+          fields: { products: 'name,profit_margin' }
+        }
+      });
+
+      const product = products.data[0];
+      assert.equal(product.name, 'Premium Widget');
+      assert.equal(product.profit_margin, 55.00);
+      assert.equal(product.price, undefined);
+      assert.equal(product.cost, undefined);
+    });
+
+    it('should handle includes with computed fields in collections', async () => {
+      const products = await api.resources.products.query({
+        queryParams: {
+          include: ['reviews'],
+          fields: {
+            products: 'name',
+            reviews: 'rating,helpfulness_score'
+          }
+        }
+      });
+
+      const product = products.data[0];
+      assert.equal(product.reviews.length, 2);
+      
+      product.reviews.forEach(review => {
+        assert.ok(review.rating);
+        assert.ok(review.helpfulness_score !== undefined);
+        assert.equal(review.reviewer_name, undefined);
+        assert.equal(review.comment, undefined);
+      });
+    });
+  });
+
+  describe('Relationship _ids Fields', () => {
+    it('should always include _ids fields regardless of sparse fieldsets', async () => {
+      const product = await api.resources.products.get({
+        id: testData.product.id,
+        queryParams: {
+          fields: { products: 'name' }
+        }
+      });
+
+      // Relationship _ids should still be included
+      assert.ok(Array.isArray(product.reviews_ids));
+      assert.equal(product.reviews_ids.length, 2);
+    });
+
+    it('should include _ids for empty relationships', async () => {
+      const newProduct = await api.resources.products.post({
+        name: 'New Product',
+        price: 50,
+        cost: 25
+      });
+
+      const fetched = await api.resources.products.get({
+        id: newProduct.id,
+        queryParams: {
+          fields: { products: 'name' }
+        }
+      });
+
+      assert.ok(Array.isArray(fetched.reviews_ids));
+      assert.equal(fetched.reviews_ids.length, 0);
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle errors in compute functions gracefully', async () => {
+      // Add a product resource with a faulty computed field
+      await api.addResource('faulty_products', {
+        schema: {
+          id: { type: 'id' },
+          value: { type: 'number' },
+          bad_compute: {
+            type: 'string',
+            computed: true,
+            dependencies: ['value'],
+            compute: ({ attributes }) => {
+              throw new Error('Computation failed');
+            }
+          }
+        },
+        tableName: 'test_faulty_products'
+      });
+      await api.resources.faulty_products.createKnexTable();
+
+      const faulty = await api.resources.faulty_products.post({ value: 42 });
+      const fetched = await api.resources.faulty_products.get({ id: faulty.id });
+
+      assert.equal(fetched.value, 42);
+      assert.equal(fetched.bad_compute, null); // Error results in null
+    });
+
+    it('should reject unknown fields in sparse fieldsets', async () => {
+      await assert.rejects(
+        api.resources.products.get({
+          id: testData.product.id,
+          queryParams: {
+            fields: { products: 'name,unknown_field' }
+          }
+        }),
+        /Unknown sparse field 'unknown_field'/
+      );
+    });
+
+    it('should reject requests for _ids fields in sparse fieldsets', async () => {
+      await assert.rejects(
+        api.resources.products.get({
+          id: testData.product.id,
+          queryParams: {
+            fields: { products: 'name,reviews_ids' }
+          }
+        }),
+        /Unknown sparse field 'reviews_ids'/
+      );
+    });
+  });
+
+  describe('Async Computed Fields', () => {
+    it('should support async compute functions', async () => {
+      // Add a resource with async computed field
+      await api.addResource('async_products', {
+        schema: {
+          id: { type: 'id' },
+          name: { type: 'string', required: true },
+          external_id: { type: 'string' },
+          external_data: {
+            type: 'string',
+            computed: true,
+            dependencies: ['external_id'],
+            compute: async ({ attributes }) => {
+              // Simulate async operation (e.g., external API call)
+              await new Promise(resolve => setTimeout(resolve, 10));
+              return `fetched-${attributes.external_id}`;
+            }
+          },
+          computed_name: {
+            type: 'string',
+            computed: true,
+            dependencies: ['name'],
+            compute: async ({ attributes }) => {
+              // Another async operation
+              await new Promise(resolve => setTimeout(resolve, 5));
+              return attributes.name.toUpperCase();
+            }
+          }
+        },
+        tableName: 'test_async_products'
+      });
+      await api.resources.async_products.createKnexTable();
+
+      const product = await api.resources.async_products.post({
+        name: 'Async Product',
+        external_id: 'ext-123'
+      });
+
+      const fetched = await api.resources.async_products.get({ id: product.id });
+      assert.equal(fetched.external_data, 'fetched-ext-123');
+      assert.equal(fetched.computed_name, 'ASYNC PRODUCT');
+    });
+
+    it('should handle errors in async compute functions', async () => {
+      // Add a resource with failing async computed field
+      await api.addResource('failing_async_products', {
+        schema: {
+          id: { type: 'id' },
+          value: { type: 'number' },
+          failing_async: {
+            type: 'string',
+            computed: true,
+            dependencies: ['value'],
+            compute: async ({ attributes }) => {
+              await new Promise(resolve => setTimeout(resolve, 5));
+              throw new Error('Async computation failed');
+            }
+          }
+        },
+        tableName: 'test_failing_async_products'
+      });
+      await api.resources.failing_async_products.createKnexTable();
+
+      const product = await api.resources.failing_async_products.post({ value: 42 });
+      const fetched = await api.resources.failing_async_products.get({ id: product.id });
+
+      assert.equal(fetched.value, 42);
+      assert.equal(fetched.failing_async, null); // Error results in null
+    });
+  });
+
+  describe('Performance Considerations', () => {
+    it('should only compute requested computed fields', async () => {
+      // Track compute calls
+      let profitMarginCalls = 0;
+      let profitAmountCalls = 0;
+
+      // Override compute functions to track calls
+      const originalProfitMargin = api.resources.products.vars.schemaInfo.computed.profit_margin.compute;
+      const originalProfitAmount = api.resources.products.vars.schemaInfo.computed.profit_amount.compute;
+
+      api.resources.products.vars.schemaInfo.computed.profit_margin.compute = (ctx) => {
+        profitMarginCalls++;
+        return originalProfitMargin(ctx);
+      };
+
+      api.resources.products.vars.schemaInfo.computed.profit_amount.compute = (ctx) => {
+        profitAmountCalls++;
+        return originalProfitAmount(ctx);
+      };
+
+      // Request only profit_margin
+      await api.resources.products.get({
+        id: testData.product.id,
+        queryParams: {
+          fields: { products: 'name,profit_margin' }
+        }
+      });
+
+      assert.equal(profitMarginCalls, 1);
+      assert.equal(profitAmountCalls, 0); // Should not be computed
+
+      // Restore original functions
+      api.resources.products.vars.schemaInfo.computed.profit_margin.compute = originalProfitMargin;
+      api.resources.products.vars.schemaInfo.computed.profit_amount.compute = originalProfitAmount;
+    });
+  });
+});

package/tests/cors.test.js

@@ -48,7 +48,7 @@ describe('CORS Plugin Tests', { timeout: 30000 }, () => {
       await baseUrlApi.use((await import('../plugins/core/rest-api-knex-plugin.js')).RestApiKnexPlugin, { knex });
       await baseUrlApi.use((await import('../plugins/core/connectors/express-plugin.js')).ExpressPlugin, {
         app: baseUrlApp,
-        basePath: '/v1'  // Set a base path
+        mountPath: '/v1/api'
       });
       
       // Add basic scope
@@ -74,7 +74,7 @@ describe('CORS Plugin Tests', { timeout: 30000 }, () => {
       } catch (error) {
         console.log('[TEST] CORS installation error:', error.message);
         console.log('[TEST] vars.transport.matchAll:', baseUrlApi.vars.transport?.matchAll);
-        console.log('[TEST] basePath from Express:', '/v1');
+        console.log('[TEST] mountPath from transport:', baseUrlApi.vars.transport?.mountPath);
         console.log('[TEST] Full wildcard path would be:', '/v1' + (baseUrlApi.vars.transport?.matchAll || '*'));
         throw error;
       }
@@ -369,7 +369,7 @@ describe('CORS Plugin Tests', { timeout: 30000 }, () => {
         .set('Content-Type', 'application/vnd.api+json')
         .send(putDoc);
       
-      assert.equal(response.status, 200);
+      assert.equal(response.status, 204);
       assert.equal(response.headers['access-control-allow-origin'], 'https://example.com');
       assert.equal(response.headers['vary'], 'Origin');
       assert.equal(response.headers['access-control-expose-headers'], 'X-Total-Count, X-Page-Count, Link');
@@ -754,7 +754,7 @@ describe('CORS Plugin Tests', { timeout: 30000 }, () => {
         .set('Content-Type', 'application/vnd.api+json')
         .set('Accept', 'application/vnd.api+json');
       
-      assert.equal(response.status, 200);
+      assert.equal(response.status, 204);
       assert.equal(response.headers['access-control-allow-origin'], 'https://example.com');
       assert.equal(response.headers['access-control-allow-credentials'], 'true');
       assert.equal(response.headers['vary'], 'Origin');

package/tests/curl.test.js

@@ -181,9 +181,10 @@ describe('CURL HTTP Abstraction Layer Tests', () => {
       
       const response = JSON.parse(result.stdout);
       
-      // PATCH is configured to return only ID, not full record
-      assert(response.id, 'Should return ID');
-      assert.equal(response.id, String(testData.country.id), 'Should return correct ID');
+      // PATCH is configured to return minimal JSON:API response
+      assert(response.data, 'Should have data');
+      assert.equal(response.data.type, 'countries', 'Should have correct type');
+      assert.equal(response.data.id, String(testData.country.id), 'Should return correct ID');
       
       // Verify the update by fetching the record
       const verifyResult = await basicApi.resources.countries.get({
@@ -429,7 +430,7 @@ describe('CURL HTTP Abstraction Layer Tests', () => {
       validateJsonApiStructure(response, true);
       
       assert.equal(response.data.length, 3, 'Should return 3 books per page');
-      // Note: Links are only included if resourceUrlPrefix is configured, which it isn't in basicApi
+      // Note: Links are now always included, using relative URLs when publicBaseUrl isn't configured
     });
 
     it('should handle sorting using CURL', async () => {