json-rest-api 1.0.14 → 1.0.16

package/plugins/core/lib/querying-writing/compile-schemas.js

@@ -1,28 +1,28 @@
-import { createSchema } from 'json-rest-schema';
-import { ensureSearchFieldsAreIndexed, generateSearchSchemaFromSchema, sortFieldsByDependencies } from './schema-helpers.js';
+import { createSchema } from 'json-rest-schema'
+import { ensureSearchFieldsAreIndexed, generateSearchSchemaFromSchema, sortFieldsByDependencies } from './schema-helpers.js'
 
 /**
  * Compiles and enriches schemas for a resource scope
- * 
+ *
  * @param {Object} scope - Scope containing raw schema options
  * @param {Object} deps - Dependencies with context and hooks
  * @returns {Promise<void>} Resolves when compilation complete
- * 
+ *
  * @example
  * // Input: Raw schema with computed field
  * const rawFields = {
  *   title: { type: 'string', required: true },
  *   content: { type: 'string' },
  *   author_id: { belongsTo: 'users', as: 'author' },  // Missing type
- *   word_count: { 
- *     type: 'number', 
+ *   word_count: {
+ *     type: 'number',
  *     computed: true,
  *     compute: (record) => record.content.split(' ').length
  *   }
  * };
- * 
+ *
  * await compileSchemas(scope, deps);
- * 
+ *
  * // Output in scope.vars.schemaInfo:
  * // {
  * //   schema: Schema {},           // json-rest-schema instance
@@ -36,7 +36,7 @@ import { ensureSearchFieldsAreIndexed, generateSearchSchemaFromSchema, sortField
  * //     word_count: { type: 'number', computed: true, compute: [Function] }
  * //   }
  * // }
- * 
+ *
  * @example
  * // Input: Schema with search fields
  * const rawFields = {
@@ -44,17 +44,17 @@ import { ensureSearchFieldsAreIndexed, generateSearchSchemaFromSchema, sortField
  *   status: { type: 'string' },                 // Not searchable
  *   author_id: { belongsTo: 'users', as: 'author' }
  * };
- * 
+ *
  * // Output: Auto-generated searchSchema
  * // searchSchemaObject contains:
  * // {
- * //   title: { 
- * //     type: 'string', 
+ * //   title: {
+ * //     type: 'string',
  * //     indexed: true,        // Added for DB optimization
  * //     filterOperator: '='   // Default operator
  * //   }
  * // }
- * 
+ *
  * @example
  * // Input: Pivot table auto-detection
  * const pivotSchema = {
@@ -62,7 +62,7 @@ import { ensureSearchFieldsAreIndexed, generateSearchSchemaFromSchema, sortField
  *   tag_id: { belongsTo: 'tags', as: 'tag' },
  *   display_order: { type: 'number' }
  * };
- * 
+ *
  * // Output: Both foreign keys become searchable
  * // schemaStructure will have:
  * // {
@@ -71,8 +71,8 @@ import { ensureSearchFieldsAreIndexed, generateSearchSchemaFromSchema, sortField
  * //   display_order: { type: 'number' }
  * // }
  * // This enables efficient many-to-many filtering!
- * 
- * @example  
+ *
+ * @example
  * // Input: Schema with dependent getters
  * const schema = {
  *   first_name: { type: 'string' },
@@ -87,7 +87,7 @@ import { ensureSearchFieldsAreIndexed, generateSearchSchemaFromSchema, sortField
  *     setter: (value) => value.toLowerCase().trim()
  *   }
  * };
- * 
+ *
  * // Output includes dependency-sorted fields:
  * // {
  * //   fieldGetters: { full_name: { getter: [Function], runGetterAfter: [...] } },
@@ -95,12 +95,12 @@ import { ensureSearchFieldsAreIndexed, generateSearchSchemaFromSchema, sortField
  * //   fieldSetters: { email: { setter: [Function], runSetterAfter: [] } },
  * //   sortedSetterFields: ['email']
  * // }
- * 
+ *
  * @description
  * Used by:
  * - Every REST method calls this before any operations
  * - Compilation happens once per scope (cached)
- * 
+ *
  * Purpose:
  * - Separates computed fields from database fields
  * - Adds missing types to belongsTo relationships
@@ -109,7 +109,7 @@ import { ensureSearchFieldsAreIndexed, generateSearchSchemaFromSchema, sortField
  * - Validates getter/setter dependencies
  * - Provides hooks for schema enrichment
  * - Caches everything for performance
- * 
+ *
  * Data flow:
  * 1. Extracts computed fields to separate object
  * 2. Adds type:'id' to belongsTo fields
@@ -121,77 +121,77 @@ import { ensureSearchFieldsAreIndexed, generateSearchSchemaFromSchema, sortField
  * 8. Extracts and topologically sorts getters/setters
  * 9. Caches all results in scope.vars.schemaInfo
  */
-export async function compileSchemas(scope, deps) {
+export async function compileSchemas (scope, deps) {
   // Extract scopeName from context
-  const { context, runHooks } = deps;
-  const scopeName = context.scopeName;
+  const { context, runHooks } = deps
+  const scopeName = context.scopeName
 
   // Get raw schema
-  const rawFields = scope.scopeOptions?.schema || {};
-  
+  const rawFields = scope.scopeOptions?.schema || {}
+
   // Extract computed fields from schema and build enriched schema
-  const computedFields = {};
-  const enrichedFields = {};
-  
+  const computedFields = {}
+  const enrichedFields = {}
+
   for (const [fieldName, fieldDef] of Object.entries(rawFields)) {
     if (fieldDef.computed === true) {
       // Extract computed field - copy entire definition
-      computedFields[fieldName] = { ...fieldDef };
-      
+      computedFields[fieldName] = { ...fieldDef }
+
       // Validate computed field
       if (!fieldDef.type) {
-        throw new Error(`Computed field '${fieldName}' in scope '${scopeName}' must have a type`);
+        throw new Error(`Computed field '${fieldName}' in scope '${scopeName}' must have a type`)
       }
-      
+
       if (fieldDef.compute && typeof fieldDef.compute !== 'function') {
-        throw new Error(`Computed field '${fieldName}' in scope '${scopeName}' has invalid compute function`);
+        throw new Error(`Computed field '${fieldName}' in scope '${scopeName}' has invalid compute function`)
       }
-      
+
       // Don't include computed fields in the validation schema
     } else {
-      enrichedFields[fieldName] = { ...fieldDef };
+      enrichedFields[fieldName] = { ...fieldDef }
     }
   }
-  
+
   // Default enrichment: Add type to belongsTo fields
   for (const [fieldName, fieldDef] of Object.entries(enrichedFields)) {
     if (fieldDef.belongsTo && !fieldDef.type) {
-      fieldDef.type = 'id';
+      fieldDef.type = 'id'
     }
   }
-  
+
   // ADD LOGIC TO MAKE FIELDS SEARCHABLE HERE
   // Auto-detect pivot tables and make their foreign key fields searchable
   // This is critical for many-to-many relationship operations which need to filter pivot records
-  const fields = Object.entries(enrichedFields);
-  const belongsToFields = fields.filter(([_, def]) => def.belongsTo);
-  
+  const fields = Object.entries(enrichedFields)
+  const belongsToFields = fields.filter(([_, def]) => def.belongsTo)
+
   // If 2+ belongsTo fields and they make up 40%+ of non-id fields, likely a pivot table
-  const nonIdFields = fields.filter(([name, _]) => name !== 'id');
-  const isProbablyPivot = belongsToFields.length >= 2 && 
-    (nonIdFields.length === 0 || belongsToFields.length / nonIdFields.length >= 0.4);
-  
+  const nonIdFields = fields.filter(([name, _]) => name !== 'id')
+  const isProbablyPivot = belongsToFields.length >= 2 &&
+    (nonIdFields.length === 0 || belongsToFields.length / nonIdFields.length >= 0.4)
+
   if (isProbablyPivot) {
     // Make all belongsTo fields searchable for pivot operations
     for (const [fieldName, fieldDef] of belongsToFields) {
       if (!fieldDef.search) {
-        fieldDef.search = true;
+        fieldDef.search = true
       }
     }
   }
 
-
   // Hook: schema:enrich
   const schemaContext = {
     fields: enrichedFields,    // Mutable
     originalFields: rawFields,  // Read-only
-    scopeName
-  };
-  await runHooks('schema:enrich', schemaContext);
-  
+    scopeName,
+    scopeOptions: scope.scopeOptions || {}
+  }
+  await runHooks('schema:enrich', schemaContext)
+
   // Create schema object
-  const schemaObject = createSchema(schemaContext.fields);
-  
+  const schemaObject = createSchema(schemaContext.fields)
+
   // Generate searchSchema by merging explicit searchSchema with fields marked search:true.
   // This allows two ways to define searchable fields: either mark fields with search:true
   // in the main schema, or provide an explicit searchSchema with more control over filtering.
@@ -200,11 +200,11 @@ export async function compileSchemas(scope, deps) {
   // searchSchema will be added automatically.
   // Example: title: {search: true} auto-generates a searchable field with sensible defaults,
   // while searchSchema can specify filterOperator: 'contains' or complex join configurations.
-  let rawSearchFields = generateSearchSchemaFromSchema(
+  const rawSearchFields = generateSearchSchemaFromSchema(
     schemaContext.fields,
     scope.scopeOptions.searchSchema
-  );
-  
+  )
+
   if (rawSearchFields) {
     // Mark all search fields as indexed for database optimization.
     // This ensures that any field used for filtering will have a database index created,
@@ -212,106 +212,106 @@ export async function compileSchemas(scope, deps) {
     // would require full table scans. The storage plugin uses these hints to create indexes.
     // Example: A status field marked for search gets indexed: true, enabling efficient
     // WHERE status = 'published' queries that can use index lookups instead of scanning all rows.
-    ensureSearchFieldsAreIndexed(rawSearchFields);
-    
+    ensureSearchFieldsAreIndexed(rawSearchFields)
+
     // Hook: searchSchema:enrich
     const searchSchemaContext = {
       fields: schemaContext.fields,       // Mutable
       originalFields: rawSearchFields,    // Read-only enriched schema
       scopeName
-    };
-    await runHooks('searchSchema:enrich', searchSchemaContext);
-    
+    }
+    await runHooks('searchSchema:enrich', searchSchemaContext)
+
     // Create searchSchema object
-    var searchSchemaObject = createSchema(rawSearchFields);
+    var searchSchemaObject = createSchema(rawSearchFields)
   } else {
-    var searchSchemaObject = createSchema({});
+    var searchSchemaObject = createSchema({})
   }
 
   // Build schemaRelationships including polymorphic fields from schema
-  const schemaRelationships = { ...(scope.scopeOptions.relationships || {}) };
-  
+  const schemaRelationships = { ...(scope.scopeOptions.relationships || {}) }
+
   // Validate belongsTo fields
   for (const [fieldName, fieldDef] of Object.entries(schemaContext.fields)) {
     // Validate that belongsTo fields have 'as' property
     if (fieldDef.belongsTo && !fieldDef.as) {
       throw new Error(
         `Field '${fieldName}' in resource '${scopeName}' has belongsTo: '${fieldDef.belongsTo}' but is missing the required 'as' property. ` +
-        `The 'as' property defines the relationship name used in JSON:API payloads. ` +
+        'The \'as\' property defines the relationship name used in JSON:API payloads. ' +
         `Example: ${fieldName}: { type: 'number', belongsTo: '${fieldDef.belongsTo}', as: '${fieldName.replace(/_id$/, '')}' }`
-      );
+      )
     }
   }
 
   // Extract and validate getter definitions
-  const fieldGetters = {};
-  const getterFields = [];
-  
+  const fieldGetters = {}
+  const getterFields = []
+
   for (const [fieldName, fieldDef] of Object.entries(schemaContext.fields)) {
     if (fieldDef.getter && typeof fieldDef.getter === 'function') {
       fieldGetters[fieldName] = {
         getter: fieldDef.getter,
         runGetterAfter: fieldDef.runGetterAfter || [],
-        fieldDef: fieldDef
-      };
-      getterFields.push(fieldName);
-      
+        fieldDef
+      }
+      getterFields.push(fieldName)
+
       // Validate dependencies exist
       if (fieldDef.runGetterAfter && Array.isArray(fieldDef.runGetterAfter)) {
         for (const dep of fieldDef.runGetterAfter) {
           if (!schemaContext.fields[dep]) {
             throw new Error(
               `Field '${fieldName}' in resource '${scopeName}' has getter dependency '${dep}' that does not exist in schema`
-            );
+            )
           }
         }
       }
     }
   }
-  
+
   // Sort getters by dependencies
-  let sortedGetterFields = [];
+  let sortedGetterFields = []
   if (Object.keys(fieldGetters).length > 0) {
     try {
-      sortedGetterFields = sortFieldsByDependencies(fieldGetters, 'runGetterAfter');
+      sortedGetterFields = sortFieldsByDependencies(fieldGetters, 'runGetterAfter')
     } catch (error) {
-      throw new Error(`Invalid getter dependencies in ${scopeName}: ${error.message}`);
+      throw new Error(`Invalid getter dependencies in ${scopeName}: ${error.message}`)
     }
   }
 
   // Extract and validate setter definitions
-  const fieldSetters = {};
-  const setterFields = [];
-  
+  const fieldSetters = {}
+  const setterFields = []
+
   for (const [fieldName, fieldDef] of Object.entries(schemaContext.fields)) {
     if (fieldDef.setter && typeof fieldDef.setter === 'function') {
       fieldSetters[fieldName] = {
         setter: fieldDef.setter,
         runSetterAfter: fieldDef.runSetterAfter || [],
-        fieldDef: fieldDef
-      };
-      setterFields.push(fieldName);
-      
+        fieldDef
+      }
+      setterFields.push(fieldName)
+
       // Validate dependencies exist
       if (fieldDef.runSetterAfter && Array.isArray(fieldDef.runSetterAfter)) {
         for (const dep of fieldDef.runSetterAfter) {
           if (!schemaContext.fields[dep]) {
             throw new Error(
               `Field '${fieldName}' in resource '${scopeName}' has setter dependency '${dep}' that does not exist in schema`
-            );
+            )
           }
         }
       }
     }
   }
-  
+
   // Sort setters by dependencies
-  let sortedSetterFields = [];
+  let sortedSetterFields = []
   if (Object.keys(fieldSetters).length > 0) {
     try {
-      sortedSetterFields = sortFieldsByDependencies(fieldSetters, 'runSetterAfter');
+      sortedSetterFields = sortFieldsByDependencies(fieldSetters, 'runSetterAfter')
     } catch (error) {
-      throw new Error(`Invalid setter dependencies in ${scopeName}: ${error.message}`);
+      throw new Error(`Invalid setter dependencies in ${scopeName}: ${error.message}`)
     }
   }
 
@@ -323,14 +323,14 @@ export async function compileSchemas(scope, deps) {
 
     searchSchemaInstance: searchSchemaObject,
     searchSchemaStructure: searchSchemaObject.structure,
-       
+
     computed: computedFields,
-    schemaRelationships: schemaRelationships,
+    schemaRelationships,
     tableName: scope.scopeOptions.tableName || scopeName,
     idProperty: scope.scopeOptions.idProperty || scope.vars.idProperty,
-    fieldGetters: fieldGetters,
-    sortedGetterFields: sortedGetterFields,
-    fieldSetters: fieldSetters,
-    sortedSetterFields: sortedSetterFields
-  };  
-}
+    fieldGetters,
+    sortedGetterFields,
+    fieldSetters,
+    sortedSetterFields
+  }
+}

package/plugins/core/lib/querying-writing/connectors-query-parser.js

@@ -1,13 +1,13 @@
 /**
  * Parses URL query strings into JSON:API compliant parameter objects
- * 
+ *
  * @param {string} queryString - The query string part of URL (without ?)
  * @returns {object} Parsed query parameters in JSON:API format
- * 
+ *
  * @example
  * // Input: Basic include and sort
  * const query = parseJsonApiQuery('include=author&sort=-created_at');
- * 
+ *
  * // Output: Parsed into arrays
  * // {
  * //   include: ['author'],      // Split by comma
@@ -16,11 +16,11 @@
  * //   sort: ['-created_at'],    // Split by comma
  * //   page: {}
  * // }
- * 
+ *
  * @example
  * // Input: Filters with bracket notation
  * const query = parseJsonApiQuery('filter[status]=published&filter[author_id]=123');
- * 
+ *
  * // Output: Extracted filter keys
  * // {
  * //   include: [],
@@ -32,11 +32,11 @@
  * //   sort: [],
  * //   page: {}
  * // }
- * 
+ *
  * @example
- * // Input: Sparse fieldsets  
+ * // Input: Sparse fieldsets
  * const query = parseJsonApiQuery('fields[articles]=title,body&fields[users]=name');
- * 
+ *
  * // Output: Fields kept as comma-separated strings
  * // {
  * //   include: [],
@@ -48,11 +48,11 @@
  * //   sort: [],
  * //   page: {}
  * // }
- * 
+ *
  * @example
  * // Input: Pagination with numeric conversion
  * const query = parseJsonApiQuery('page[size]=20&page[number]=3&page[cursor]=abc123');
- * 
+ *
  * // Output: Numbers converted, strings preserved
  * // {
  * //   include: [],
@@ -65,43 +65,43 @@
  * //     cursor: 'abc123' // Non-numeric stays string
  * //   }
  * // }
- * 
+ *
  * @example
  * // Input: Complex real-world query
  * const query = parseJsonApiQuery(
  *   'include=author,comments.user&' +
  *   'filter[status]=published&' +
- *   'filter[created_after]=2024-01-01&' + 
+ *   'filter[created_after]=2024-01-01&' +
  *   'fields[articles]=title,summary&' +
  *   'sort=-created_at,title&' +
  *   'page[size]=10'
  * );
- * 
+ *
  * // Output: All parameters properly categorized
  * // {
  * //   include: ['author', 'comments.user'],
  * //   fields: { articles: 'title,summary' },
- * //   filters: { 
+ * //   filters: {
  * //     status: 'published',
  * //     created_after: '2024-01-01'
  * //   },
  * //   sort: ['-created_at', 'title'],
  * //   page: { size: 10 }
  * // }
- * 
+ *
  * @description
  * Used by:
  * - express-plugin parses req.query with this
  * - http-plugin parses URL query strings with this
  * - websocket-plugin parses message query parameters with this
- * 
+ *
  * Purpose:
  * - Provides uniform JSON:API query parsing across all transports
  * - Handles bracket notation without regex complexity
  * - Converts data types appropriately (numbers for pagination)
  * - Ignores non-JSON:API parameters gracefully
  * - Returns consistent structure even for empty input
- * 
+ *
  * Data flow:
  * 1. Uses URLSearchParams for reliable parsing
  * 2. Categorizes parameters by their prefix pattern
@@ -110,7 +110,7 @@
  * 5. Converts numeric strings for pagination
  * 6. Returns normalized structure for REST API
  */
-export function parseJsonApiQuery(queryString) {
+export function parseJsonApiQuery (queryString) {
   if (!queryString) {
     return {
       include: [],
@@ -118,48 +118,48 @@ export function parseJsonApiQuery(queryString) {
       filters: {},
       sort: [],
       page: {}
-    };
+    }
   }
 
-  const params = new URLSearchParams(queryString);
+  const params = new URLSearchParams(queryString)
   const result = {
     include: [],
     fields: {},
     filters: {},
     sort: [],
     page: {}
-  };
+  }
 
   for (const [key, value] of params) {
     if (key === 'include') {
       // Parse include (comma-separated string to array)
-      result.include = value.split(',').map(s => s.trim()).filter(s => s.length > 0);
+      result.include = value.split(',').map(s => s.trim()).filter(s => s.length > 0)
     } else if (key === 'sort') {
       // Parse sort (comma-separated string to array)
-      result.sort = value.split(',').map(s => s.trim()).filter(s => s.length > 0);
+      result.sort = value.split(',').map(s => s.trim()).filter(s => s.length > 0)
     } else if (key.startsWith('filter[') && key.endsWith(']')) {
       // Parse filter[key] = value into filters: { key: value }
-      const filterKey = key.slice(7, -1); // Remove 'filter[' and ']'
+      const filterKey = key.slice(7, -1) // Remove 'filter[' and ']'
       if (filterKey) {
-        result.filters[filterKey] = value;
+        result.filters[filterKey] = value
       }
     } else if (key.startsWith('fields[') && key.endsWith(']')) {
       // Parse fields[type] = fields into fields: { type: "field1,field2" }
       // Keep as comma-separated string to match REST API validation expectations
-      const fieldType = key.slice(7, -1); // Remove 'fields[' and ']'
+      const fieldType = key.slice(7, -1) // Remove 'fields[' and ']'
       if (fieldType) {
-        result.fields[fieldType] = value;
+        result.fields[fieldType] = value
       }
     } else if (key.startsWith('page[') && key.endsWith(']')) {
       // Parse page[size] = 10 into page: { size: 10 }
-      const pageKey = key.slice(5, -1); // Remove 'page[' and ']'
+      const pageKey = key.slice(5, -1) // Remove 'page[' and ']'
       if (pageKey) {
         // Convert to number if it's a valid number, otherwise keep as string
-        result.page[pageKey] = isNaN(value) ? value : parseInt(value, 10);
+        result.page[pageKey] = isNaN(value) ? value : parseInt(value, 10)
       }
     }
     // Ignore other query parameters that don't match JSON:API patterns
   }
 
-  return result;
-}
+  return result
+}