json-rest-api 1.0.14 → 1.0.15

package/plugins/core/rest-api-plugin-hooks/register-relationship-routes.js

@@ -1,72 +1,71 @@
-
-import { parseJsonApiQuery } from "../lib/querying-writing/connectors-query-parser.js";
+import { parseJsonApiQuery } from '../lib/querying-writing/connectors-query-parser.js'
 
 export default async function registerRelationshipRoutes ({ context, api, log }) {
-  const { scopeName } = context;
-  const basePath = api.scopes[scopeName].vars.transport?.mountPath || '';
-  const scopePath = `${basePath}/${scopeName}`;
+  const { scopeName } = context
+  const basePath = api.scopes[scopeName].vars.transport?.mountPath || ''
+  const scopePath = `${basePath}/${scopeName}`
 
   // Helper to create route handlers
   const createRouteHandler = (methodName) => {
     return async ({ params, body, queryString }) => {
-      const scope = api.scopes[scopeName];
-      
+      const scope = api.scopes[scopeName]
+
       const methodParams = {
         id: params.id,
         relationshipName: params.relationshipName,
         isTransport: true
-      };
+      }
 
       // Add query params for getRelated
       if (methodName === 'getRelated' && queryString) {
-        methodParams.queryParams = parseJsonApiQuery(queryString);
+        methodParams.queryParams = parseJsonApiQuery(queryString)
       }
 
       // Add body data for write operations
       if (body && body.data !== undefined) {
-        methodParams.relationshipData = body.data;
+        methodParams.relationshipData = body.data
       }
 
-      return await scope[methodName](methodParams);
-    };
-  };
+      return await scope[methodName](methodParams)
+    }
+  }
 
   // Register relationship routes
-  
+
   // GET /api/{scope}/{id}/relationships/{relationshipName}
   await api.addRoute({
     method: 'GET',
     path: `${scopePath}/:id/relationships/:relationshipName`,
     handler: createRouteHandler('getRelationship')
-  });
+  })
 
   // GET /api/{scope}/{id}/{relationshipName}
   await api.addRoute({
     method: 'GET',
     path: `${scopePath}/:id/:relationshipName`,
     handler: createRouteHandler('getRelated')
-  });
+  })
 
   // POST /api/{scope}/{id}/relationships/{relationshipName}
   await api.addRoute({
     method: 'POST',
     path: `${scopePath}/:id/relationships/:relationshipName`,
     handler: createRouteHandler('postRelationship')
-  });
+  })
 
   // PATCH /api/{scope}/{id}/relationships/{relationshipName}
   await api.addRoute({
     method: 'PATCH',
     path: `${scopePath}/:id/relationships/:relationshipName`,
     handler: createRouteHandler('patchRelationship')
-  });
+  })
 
   // DELETE /api/{scope}/{id}/relationships/{relationshipName}
   await api.addRoute({
     method: 'DELETE',
     path: `${scopePath}/:id/relationships/:relationshipName`,
     handler: createRouteHandler('deleteRelationship')
-  });
+  })
 
-  log.trace(`Registered relationship routes for scope: ${scopeName}`);
-}
+  log.trace(`Registered relationship routes for scope: ${scopeName}`)
+}

package/plugins/core/rest-api-plugin-hooks/register-scope-routes.js

@@ -1,102 +1,102 @@
-import { RestApiResourceError } from '../../../lib/rest-api-errors.js';
-import { parseJsonApiQuery } from '../lib/querying-writing/connectors-query-parser.js';
+import { RestApiResourceError } from '../../../lib/rest-api-errors.js'
+import { parseJsonApiQuery } from '../lib/querying-writing/connectors-query-parser.js'
+
+export default async function registerScopeRoutes ({ context, api, vars, log }) {
+  const { scopeName } = context
+  const basePath = vars.transport?.mountPath || ''
 
-export default async function registerScopeRoutes({ context, api, vars, log }) {
-  const { scopeName } = context;
-  const basePath = vars.transport?.mountPath || '';
-  
   // Helper to create route handlers
   const createRouteHandler = (scopeName, methodName) => {
     return async ({ queryString, headers, params, body, context }) => {
-      const scope = api.scopes[scopeName];
+      const scope = api.scopes[scopeName]
       if (!scope) {
         throw new RestApiResourceError(
           `Scope '${scopeName}' not found`,
-          { 
+          {
             subtype: 'not_found',
             resourceType: 'scope',
             resourceId: scopeName
           }
-        );
+        )
       }
-      
+
       // Build parameters for the scope method
-      const methodParams = {};
-      
+      const methodParams = {}
+
       // Add ID for single-resource operations
       if (['get', 'put', 'patch', 'delete'].includes(methodName)) {
-        methodParams.id = params.id;
+        methodParams.id = params.id
       }
-      
+
       // Parse query parameters for read operations
       if (['query', 'get'].includes(methodName)) {
-        methodParams.queryParams = parseJsonApiQuery(queryString);
-        methodParams.isTransport = true;
+        methodParams.queryParams = parseJsonApiQuery(queryString)
+        methodParams.isTransport = true
       }
-      
+
       // Add body for write operations
       if (['post', 'put', 'patch'].includes(methodName)) {
-        methodParams.inputRecord = body;
-        methodParams.isTransport = true;
-        
+        methodParams.inputRecord = body
+        methodParams.isTransport = true
+
         // Add query params for includes/fields on write operations
         if (queryString) {
-          methodParams.queryParams = parseJsonApiQuery(queryString);
+          methodParams.queryParams = parseJsonApiQuery(queryString)
         }
       }
-      
+
       // Call the scope method
-      const result = await scope[methodName](methodParams, context);
-      
+      const result = await scope[methodName](methodParams, context)
+
       // Return the result (transport plugin handles response formatting)
-      return result;
-    };
-  };
-  
-  const scopePath = `${basePath}/${scopeName}`;
-  
+      return result
+    }
+  }
+
+  const scopePath = `${basePath}/${scopeName}`
+
   // Register routes for each HTTP method
   // GET /api/{scope} - Query collection
   await api.addRoute({
     method: 'GET',
     path: scopePath,
     handler: createRouteHandler(scopeName, 'query')
-  });
-  
+  })
+
   // GET /api/{scope}/{id} - Get single resource
   await api.addRoute({
     method: 'GET',
     path: `${scopePath}/:id`,
     handler: createRouteHandler(scopeName, 'get')
-  });
-  
+  })
+
   // POST /api/{scope} - Create resource
   await api.addRoute({
     method: 'POST',
     path: scopePath,
     handler: createRouteHandler(scopeName, 'post')
-  });
-  
+  })
+
   // PUT /api/{scope}/{id} - Replace resource
   await api.addRoute({
     method: 'PUT',
     path: `${scopePath}/:id`,
     handler: createRouteHandler(scopeName, 'put')
-  });
-  
+  })
+
   // PATCH /api/{scope}/{id} - Update resource
   await api.addRoute({
     method: 'PATCH',
     path: `${scopePath}/:id`,
     handler: createRouteHandler(scopeName, 'patch')
-  });
-  
+  })
+
   // DELETE /api/{scope}/{id} - Delete resource
   await api.addRoute({
     method: 'DELETE',
     path: `${scopePath}/:id`,
     handler: createRouteHandler(scopeName, 'delete')
-  });
-  
-  log.info(`Routes registered for scope '${scopeName}'`);
-}
+  })
+
+  log.info(`Routes registered for scope '${scopeName}'`)
+}

package/plugins/core/rest-api-plugin-hooks/turn-scope-init-into-vars.js

@@ -1,29 +1,29 @@
-export default async function turnScopeInitIntoVars({ context, scopes, vars: apiVars }) {
+export default async function turnScopeInitIntoVars ({ context, scopes, vars: apiVars }) {
   // Refer to the scope's vars
-  const scope = scopes[context.scopeName];
-  const scopeOptions = scope?.scopeOptions || context.scopeOptions || {};
-  const vars = scope?.vars || apiVars;
+  const scope = scopes[context.scopeName]
+  const scopeOptions = scope?.scopeOptions || context.scopeOptions || {}
+  const vars = scope?.vars || apiVars
 
   // The scope-specific ones
-  vars.sortableFields = scopeOptions.sortableFields || [];
-  vars.defaultSort = scopeOptions.defaultSort || null;     
+  vars.sortableFields = scopeOptions.sortableFields || []
+  vars.defaultSort = scopeOptions.defaultSort || null
 
   // The general ones that are also set at api level, but overrideable
-  if (typeof scopeOptions.queryDefaultLimit !== 'undefined') vars.queryDefaultLimit = scopeOptions.queryDefaultLimit;
-  if (typeof scopeOptions.queryMaxLimit !== 'undefined') vars.queryMaxLimit = scopeOptions.queryMaxLimit;
-  if (typeof scopeOptions.includeDepthLimit !== 'undefined') vars.includeDepthLimit = scopeOptions.includeDepthLimit;
-  if (typeof scopeOptions.enablePaginationCounts !== 'undefined') vars.enablePaginationCounts = scopeOptions.enablePaginationCounts;
-  
+  if (typeof scopeOptions.queryDefaultLimit !== 'undefined') vars.queryDefaultLimit = scopeOptions.queryDefaultLimit
+  if (typeof scopeOptions.queryMaxLimit !== 'undefined') vars.queryMaxLimit = scopeOptions.queryMaxLimit
+  if (typeof scopeOptions.includeDepthLimit !== 'undefined') vars.includeDepthLimit = scopeOptions.includeDepthLimit
+  if (typeof scopeOptions.enablePaginationCounts !== 'undefined') vars.enablePaginationCounts = scopeOptions.enablePaginationCounts
+
   // Set simplified settings as scope vars
-  if (typeof scopeOptions.simplifiedApi !== 'undefined') vars.simplifiedApi = scopeOptions.simplifiedApi;
-  if (typeof scopeOptions.simplifiedTransport !== 'undefined') vars.simplifiedTransport = scopeOptions.simplifiedTransport;
-  
+  if (typeof scopeOptions.simplifiedApi !== 'undefined') vars.simplifiedApi = scopeOptions.simplifiedApi
+  if (typeof scopeOptions.simplifiedTransport !== 'undefined') vars.simplifiedTransport = scopeOptions.simplifiedTransport
+
   // Set returnRecord settings as scope vars
-  if (typeof scopeOptions.returnRecordApi !== 'undefined') vars.returnRecordApi = scopeOptions.returnRecordApi;
-  if (typeof scopeOptions.returnRecordTransport !== 'undefined') vars.returnRecordTransport = scopeOptions.returnRecordTransport;
-  
+  if (typeof scopeOptions.returnRecordApi !== 'undefined') vars.returnRecordApi = scopeOptions.returnRecordApi
+  if (typeof scopeOptions.returnRecordTransport !== 'undefined') vars.returnRecordTransport = scopeOptions.returnRecordTransport
+
   // Set idProperty as scope var
-  if (typeof scopeOptions.idProperty !== 'undefined') vars.idProperty = scopeOptions.idProperty;
+  if (typeof scopeOptions.idProperty !== 'undefined') vars.idProperty = scopeOptions.idProperty
 
   // Add validation for query limits
   if (vars.queryDefaultLimit && vars.queryMaxLimit) {
@@ -31,10 +31,10 @@ export default async function turnScopeInitIntoVars({ context, scopes, vars: api
       throw new Error(
         `Invalid scope '${context.scopeName}' configuration: ` +
         `queryDefaultLimit (${vars.queryDefaultLimit}) cannot exceed queryMaxLimit (${vars.queryMaxLimit})`
-      );
+      )
     }
   }
-  
+
   // Validate relationship include limits at scope creation time
   Object.entries(scopeOptions.relationships || {}).forEach(([relName, relDef]) => {
     if (relDef.include?.limit && vars.queryMaxLimit) {
@@ -42,8 +42,8 @@ export default async function turnScopeInitIntoVars({ context, scopes, vars: api
         throw new Error(
           `Invalid relationship '${context.scopeName}.${relName}' configuration: ` +
           `include.limit (${relDef.include.limit}) cannot exceed queryMaxLimit (${vars.queryMaxLimit})`
-        );
+        )
       }
     }
-  });
-}
+  })
+}

package/plugins/core/rest-api-plugin-hooks/validate-include-configurations.js

@@ -1,39 +1,39 @@
-export default async function validateIncludeConfigurations({ context, scopes, log }) {
-  const { scopeName } = context;
-  const scope = scopes[scopeName];
-  const relationships = scope.vars.schemaInfo?.schemaRelationships;
-  
-  if (!relationships) return;
-  
+export default async function validateIncludeConfigurations ({ context, scopes, log }) {
+  const { scopeName } = context
+  const scope = scopes[scopeName]
+  const relationships = scope.vars.schemaInfo?.schemaRelationships
+
+  if (!relationships) return
+
   // Check each relationship for include configuration
   for (const [relName, relDef] of Object.entries(relationships)) {
     if (relDef.include?.strategy === 'window') {
       // This relationship requires window functions
       // We'll validate this at query time since the database might not be connected yet
-      log.debug(`Relationship ${scopeName}.${relName} configured for window function includes`);
+      log.debug(`Relationship ${scopeName}.${relName} configured for window function includes`)
     }
-    
+
     // Validate include configuration
     if (relDef.include?.limit) {
       if (typeof relDef.include.limit !== 'number') {
         throw new Error(
           `Invalid include limit for ${scopeName}.${relName}: limit must be a number`
-        );
+        )
       }
       // Check against queryMaxLimit if available
-      const maxLimit = scope.vars?.queryMaxLimit;
+      const maxLimit = scope.vars?.queryMaxLimit
       if (maxLimit && relDef.include.limit > maxLimit) {
         throw new Error(
           `Invalid include limit for ${scopeName}.${relName}: ` +
           `limit (${relDef.include.limit}) exceeds queryMaxLimit (${maxLimit})`
-        );
+        )
       }
     }
-    
+
     if (relDef.include?.orderBy && !Array.isArray(relDef.include.orderBy)) {
       throw new Error(
         `Invalid include orderBy for ${scopeName}.${relName}: orderBy must be an array`
-      );
+      )
     }
   }
-}
+}

package/plugins/core/rest-api-plugin-methods/add-route.js

@@ -1,23 +1,23 @@
-import { ValidationError } from 'hooked-api';
+import { ValidationError } from 'hooked-api'
 
 /**
  * addRoute
  * Registers a new route with the transport layer
  */
 export default async ({ params, context, runHooks }) => {
-  const { method, path, handler } = params;
-  
+  const { method, path, handler } = params
+
   // Validate route configuration
   if (!method || !path || !handler) {
-    throw new ValidationError('Route requires method, path, and handler');
+    throw new ValidationError('Route requires method, path, and handler')
   }
 
   // debugger
   // Create context for enrichAttributes hooks
   Object.assign(context, params)
-  
+
   // Run the addRoute hook to notify transport plugins
-  await runHooks('addRoute');
-  
-  return { registered: true, method, path };
-}
+  await runHooks('addRoute')
+
+  return { registered: true, method, path }
+}

package/plugins/core/rest-api-plugin-methods/check-permissions.js

@@ -1,14 +1,13 @@
 /**
  * checkPermissions
  * Check if ther are permissions to access a resource.
- * 
+ *
  */
-export default async function checkPermissionsMethod({ context, params, runHooks, scopeName, scopes, helpers }) {
- 
+export default async function checkPermissionsMethod ({ context, params, runHooks, scopeName, scopes, helpers }) {
   Object.assign(context, {
     method: params.method,
     originalContext: params.originalContext,
   })
-  
-  await runHooks('checkPermissions');
-}
+
+  await runHooks('checkPermissions')
+}