json-rest-api 1.0.6 → 1.0.8

package/plugins/core/rest-api-knex-plugin.js

@@ -1,38 +1,51 @@
 import { requirePackage } from 'hooked-api';
 import { createSchema, createKnexTable } from 'json-rest-schema';
-import { createCrossTableSearchHelpers } from './lib/knex-cross-table-search.js';
-import { getForeignKeyFields, buildFieldSelection, isNonDatabaseField } from './lib/knex-field-helpers.js';
-import { buildQuerySelection } from './utils/knex-query-helpers-base.js';
-import { toJsonApiRecord, buildJsonApiResponse, processBelongsToRelationships, toJsonApiRecordWithBelongsTo } from './lib/knex-json-api-transformers.js';
-import { processIncludes } from './lib/knex-process-includes.js';
+import { createCrossTableSearchHelpers } from './lib/querying/knex-cross-table-search.js';
+import { buildFieldSelection, isNonDatabaseField } from './lib/querying-writing/knex-field-helpers.js';
+import { getForeignKeyFields } from './lib/querying-writing/field-utils.js';
+import { buildQuerySelection } from './lib/querying/knex-query-helpers-base.js';
+import { toJsonApiRecord, buildJsonApiResponse } from './lib/querying/knex-json-api-transformers-querying.js';
+import { processBelongsToRelationships } from './lib/writing/knex-json-api-transformers-writing.js';
+import { toJsonApiRecordWithBelongsTo } from './lib/querying-writing/knex-json-api-transformers.js';
+import { processIncludes } from './lib/querying/knex-process-includes.js';
+import { loadRelationshipIdentifiers } from './lib/querying/knex-relationship-includes.js';
 import {
   polymorphicFiltersHook,
   crossTableFiltersHook,
   basicFiltersHook
-} from './lib/knex-query-helpers.js';
+} from './lib/querying/knex-query-helpers.js';
 import { RestApiResourceError, RestApiValidationError } from '../../lib/rest-api-errors.js';
-import { supportsWindowFunctions, getDatabaseInfo } from './lib/database-capabilities.js';
-import { ERROR_SUBTYPES, DEFAULT_QUERY_LIMIT, DEFAULT_MAX_QUERY_LIMIT } from './utils/knex-constants.js';
+import { supportsWindowFunctions, getDatabaseInfo } from './lib/querying-writing/database-capabilities.js';
+import { ERROR_SUBTYPES, DEFAULT_QUERY_LIMIT, DEFAULT_MAX_QUERY_LIMIT } from './lib/querying-writing/knex-constants.js';
 import { 
   calculatePaginationMeta, 
   generatePaginationLinks,
   generateCursorPaginationLinks,
   buildCursorMeta,
   parseCursor
-} from './lib/knex-pagination-helpers.js';
+} from './lib/querying/knex-pagination-helpers.js';
 
 /**
  * Strips non-database fields (computed and virtual) from attributes before database operations
  * @param {Object} attributes - The attributes object
- * @param {Object} schemaInfo - The schema info containing computed and virtual field definitions
+ * @param {Object} schemaInfo - The schema info containing computed field definitions and schema structure
  * @returns {Object} Attributes with computed and virtual fields removed
  */
 const stripNonDatabaseFields = (attributes, schemaInfo) => {
   if (!attributes || !schemaInfo) return attributes || {};
   
-  const { computed = {}, virtual = {} } = schemaInfo;
+  const { computed = {}, schemaStructure = {} } = schemaInfo;
   return Object.entries(attributes)
-    .filter(([key]) => !(key in computed || key in virtual))
+    .filter(([key]) => {
+      // Remove computed fields
+      if (key in computed) return false;
+      // Remove fields marked as virtual in the schema
+      const fieldDef = schemaStructure[key];
+      if (fieldDef && fieldDef.virtual === true) {
+        return false;
+      }
+      return true;
+    })
     .reduce((acc, [key, val]) => ({ ...acc, [key]: val }), {});
 };
 
@@ -113,8 +126,22 @@ export const RestApiKnexPlugin = {
     api.knex.helpers.crossTableSearch = crossTableSearchHelpers;
 
     // Helper scope method to get all schema-related information
-      addScopeMethod('createKnexTable', async ({ vars, scope, scopeName, scopeOptions, runHooks }) => {   
-        await createKnexTable(api.knex.instance, vars.schemaInfo.tableName, vars.schemaInfo.schema)
+      addScopeMethod('createKnexTable', async ({ vars, scope, scopeName, scopeOptions, runHooks }) => {
+        // Create a filtered schema that excludes virtual fields
+        const schemaStructure = vars.schemaInfo.schemaStructure || {};
+        const filteredSchema = {};
+        
+        // Copy only non-virtual fields to the filtered schema
+        Object.entries(schemaStructure).forEach(([fieldName, fieldDef]) => {
+          if (!fieldDef.virtual) {
+            filteredSchema[fieldName] = fieldDef;
+          }
+        });
+        
+        // Create schema object from filtered fields
+        const tableSchema = createSchema(filteredSchema);
+        
+        await createKnexTable(api.knex.instance, vars.schemaInfo.tableName, tableSchema, vars.schemaInfo.idProperty)
       })
     
       helpers.newTransaction = async () => {
@@ -149,9 +176,12 @@ export const RestApiKnexPlugin = {
       
       log.debug(`[Knex] EXISTS ${tableName}/${id}`);
       
+      // Select with alias if idProperty is not 'id'
+      const selectClause = idProperty !== 'id' ? `${idProperty} as id` : 'id';
+      
       const record = await db(tableName)
         .where(idProperty, id)
-        .select(idProperty)
+        .select(selectClause)
         .first();
       
       return !!record;
@@ -231,8 +261,11 @@ export const RestApiKnexPlugin = {
         );
       }
       
-      // Process includes
+      // Load relationship identifiers for all hasMany relationships
       const records = [record]; // Wrap in array for processing
+      await loadRelationshipIdentifiers(records, scopeName, scopes, db);
+      
+      // Process includes
       const included = await processIncludes(scope, records, {
         log,
         scopes,
@@ -241,7 +274,7 @@ export const RestApiKnexPlugin = {
       });
       
       // Build and return response
-      return buildJsonApiResponse(scope, records, included, true, scopeName);
+      return buildJsonApiResponse(scope, records, included, true, scopeName, context);
     };
 
     /**
@@ -268,7 +301,12 @@ export const RestApiKnexPlugin = {
       
       // Build query - no filtering hooks for single records
       // Permission checks will handle access control
-      const query = db(tableName).where(idProperty, id);
+      let query = db(tableName).where(idProperty, id);
+      
+      // Add alias if idProperty is not 'id'
+      if (idProperty !== 'id') {
+        query = query.select('*', `${idProperty} as id`);
+      }
       
       // Execute query
       const record = await query.first();
@@ -337,6 +375,7 @@ export const RestApiKnexPlugin = {
       
       // Start building query with table prefix (for JOIN support)
       let query = db(tableName);
+
       query = buildQuerySelection(query, tableName, fieldSelectionInfo.fieldsToSelect, true);
       
       /* ═══════════════════════════════════════════════════════════════════
@@ -430,6 +469,9 @@ export const RestApiKnexPlugin = {
           // Fetch one extra record to determine if there are more
           query.limit(pageSize + 1);
           
+          // Get the configured ID property
+          const idProperty = context.schemaInfo.idProperty || 'id';
+          
           if (queryParams.page.after) {
             let cursorData;
             try {
@@ -447,28 +489,58 @@ export const RestApiKnexPlugin = {
                 }
               );
             }
-            // Add where conditions for cursor
-            // Use the actual sort from query params or default
-            let sortField = 'id';
-            let sortDirection = 'ASC';
             
+            // Build sort fields array with directions
+            const sortFields = [];
             if (queryParams.sort && queryParams.sort.length > 0) {
-              const firstSort = queryParams.sort[0];
-              sortDirection = firstSort.startsWith('-') ? 'DESC' : 'ASC';
-              sortField = firstSort.startsWith('-') ? firstSort.substring(1) : firstSort;
+              queryParams.sort.forEach(sortField => {
+                const desc = sortField.startsWith('-');
+                const field = desc ? sortField.substring(1) : sortField;
+                sortFields.push({ field, direction: desc ? 'DESC' : 'ASC' });
+              });
             } else if (scope.vars.defaultSort) {
-              sortField = scope.vars.defaultSort.field || 'id';
-              sortDirection = scope.vars.defaultSort.direction || 'ASC';
+              sortFields.push({
+                field: scope.vars.defaultSort.field || idProperty,
+                direction: scope.vars.defaultSort.direction || 'ASC'
+              });
+            } else {
+              sortFields.push({ field: idProperty, direction: 'ASC' });
             }
             
-            // Ensure the field is properly prefixed when JOINs might be present
-            const qualifiedField = `${tableName}.${sortField}`;
+            // Build compound WHERE clause for multi-field cursor
+            query.where(function() {
+              sortFields.forEach((sortInfo, index) => {
+                const { field, direction } = sortInfo;
+                const qualifiedField = `${tableName}.${field}`;
+                const cursorValue = cursorData[field];
+                
+                if (cursorValue === undefined) {
+                  log.warn(`Cursor missing value for sort field: ${field}`);
+                  return;
+                }
+                
+                // Build condition for this level and all previous levels
+                this.orWhere(function() {
+                  // All previous fields must be equal
+                  for (let i = 0; i < index; i++) {
+                    const prevField = sortFields[i].field;
+                    const prevQualifiedField = `${tableName}.${prevField}`;
+                    const prevValue = cursorData[prevField];
+                    if (prevValue !== undefined) {
+                      this.where(prevQualifiedField, '=', prevValue);
+                    }
+                  }
+                  
+                  // Current field must be greater/less than cursor value
+                  if (direction === 'DESC') {
+                    this.where(qualifiedField, '<', cursorValue);
+                  } else {
+                    this.where(qualifiedField, '>', cursorValue);
+                  }
+                });
+              });
+            });
             
-            if (sortDirection === 'DESC') {
-              query.where(qualifiedField, '<', cursorData[sortField]);
-            } else {
-              query.where(qualifiedField, '>', cursorData[sortField]);
-            }
           } else if (queryParams.page.before) {
             let cursorData;
             try {
@@ -486,27 +558,57 @@ export const RestApiKnexPlugin = {
                 }
               );
             }
-            // Use the actual sort from query params or default
-            let sortField = 'id';
-            let sortDirection = 'ASC';
             
+            // Build sort fields array with directions
+            const sortFields = [];
             if (queryParams.sort && queryParams.sort.length > 0) {
-              const firstSort = queryParams.sort[0];
-              sortDirection = firstSort.startsWith('-') ? 'DESC' : 'ASC';
-              sortField = firstSort.startsWith('-') ? firstSort.substring(1) : firstSort;
+              queryParams.sort.forEach(sortField => {
+                const desc = sortField.startsWith('-');
+                const field = desc ? sortField.substring(1) : sortField;
+                sortFields.push({ field, direction: desc ? 'DESC' : 'ASC' });
+              });
             } else if (scope.vars.defaultSort) {
-              sortField = scope.vars.defaultSort.field || 'id';
-              sortDirection = scope.vars.defaultSort.direction || 'ASC';
-            }
-            
-            // Ensure the field is properly prefixed when JOINs might be present
-            const qualifiedField = `${tableName}.${sortField}`;
-            
-            if (sortDirection === 'DESC') {
-              query.where(qualifiedField, '>', cursorData[sortField]);
+              sortFields.push({
+                field: scope.vars.defaultSort.field || idProperty,
+                direction: scope.vars.defaultSort.direction || 'ASC'
+              });
             } else {
-              query.where(qualifiedField, '<', cursorData[sortField]);
+              sortFields.push({ field: idProperty, direction: 'ASC' });
             }
+            
+            // Build compound WHERE clause for multi-field cursor (reversed for before)
+            query.where(function() {
+              sortFields.forEach((sortInfo, index) => {
+                const { field, direction } = sortInfo;
+                const qualifiedField = `${tableName}.${field}`;
+                const cursorValue = cursorData[field];
+                
+                if (cursorValue === undefined) {
+                  log.warn(`Cursor missing value for sort field: ${field}`);
+                  return;
+                }
+                
+                // Build condition for this level and all previous levels
+                this.orWhere(function() {
+                  // All previous fields must be equal
+                  for (let i = 0; i < index; i++) {
+                    const prevField = sortFields[i].field;
+                    const prevQualifiedField = `${tableName}.${prevField}`;
+                    const prevValue = cursorData[prevField];
+                    if (prevValue !== undefined) {
+                      this.where(prevQualifiedField, '=', prevValue);
+                    }
+                  }
+                  
+                  // Current field must be less/greater than cursor value (reversed)
+                  if (direction === 'DESC') {
+                    this.where(qualifiedField, '>', cursorValue);
+                  } else {
+                    this.where(qualifiedField, '<', cursorValue);
+                  }
+                });
+              });
+            });
           }
         }
         // Default pagination if only size is specified - treat as cursor-based for "load more"
@@ -552,7 +654,9 @@ export const RestApiKnexPlugin = {
         }
       });
       
-      scope.vars.queryString = queryParts.length > 0 ? `?${queryParts.join('&')}` : '';
+      // Initialize returnMeta namespace for thread-safe metadata
+      context.returnMeta = context.returnMeta || {};
+      context.returnMeta.queryString = queryParts.length > 0 ? `?${queryParts.join('&')}` : '';
 
       // Execute count query for pagination if offset-based pagination is used
       if (queryParams.page?.number !== undefined || (queryParams.page?.size !== undefined && !queryParams.page?.after && !queryParams.page?.before)) {
@@ -585,10 +689,10 @@ export const RestApiKnexPlugin = {
           const total = parseInt(countResult.total);
           
           // Calculate pagination metadata with total
-          scope.vars.paginationMeta = calculatePaginationMeta(total, page, pageSize);
+          context.returnMeta.paginationMeta = calculatePaginationMeta(total, page, pageSize);
         } else {
           // Without count, we can still provide basic pagination info
-          scope.vars.paginationMeta = {
+          context.returnMeta.paginationMeta = {
             page,
             pageSize
             // No total, pageCount, or hasMore when counts are disabled
@@ -596,11 +700,12 @@ export const RestApiKnexPlugin = {
         }
         
         // Generate links 
-        scope.vars.paginationLinks = generatePaginationLinks(
-          scope.vars.resourceUrlPrefix,
+        const urlPrefix = scope.vars.publicBaseUrl || scope.vars.transport?.mountPath || '';
+        context.returnMeta.paginationLinks = generatePaginationLinks(
+          urlPrefix,
           scopeName,
           queryParams,
-          scope.vars.paginationMeta
+          context.returnMeta.paginationMeta
         );
       }
       
@@ -620,14 +725,16 @@ export const RestApiKnexPlugin = {
         }
         
         // Determine sort fields for cursor
-        let sortFields = ['id'];
+        const idProperty = context.schemaInfo.idProperty || 'id';
+        let sortFields = [idProperty];
         if (queryParams.sort && queryParams.sort.length > 0) {
           sortFields = queryParams.sort.map(s => s.startsWith('-') ? s.substring(1) : s);
         }
         
-        scope.vars.paginationMeta = buildCursorMeta(records, pageSize, hasMore, sortFields);
-        scope.vars.paginationLinks = generateCursorPaginationLinks(
-          scope.vars.resourceUrlPrefix,
+        context.returnMeta.paginationMeta = buildCursorMeta(records, pageSize, hasMore, sortFields);
+        const urlPrefix = scope.vars.publicBaseUrl || scope.vars.transport?.mountPath || '';
+        context.returnMeta.paginationLinks = generateCursorPaginationLinks(
+          urlPrefix,
           scopeName,
           queryParams,
           records,
@@ -637,6 +744,9 @@ export const RestApiKnexPlugin = {
         );
       }
       
+      // Load relationship identifiers for all hasMany relationships
+      await loadRelationshipIdentifiers(records, scopeName, scopes, db);
+      
       // Process includes
       const included = await processIncludes(scope, records, {
         log,
@@ -648,7 +758,7 @@ export const RestApiKnexPlugin = {
       
 
       // Build and return response
-      return buildJsonApiResponse(scope, records, included, false, scopeName);
+      return buildJsonApiResponse(scope, records, included, false, scopeName, context);
     };
     
     /**
@@ -730,7 +840,12 @@ export const RestApiKnexPlugin = {
       
       // Strip non-database fields (computed and virtual) before database operation
       const finalAttributes = stripNonDatabaseFields(mergedAttributes, context.schemaInfo);
-      
+        
+      // Map 'id' to actual idProperty if needed (for PUT with specific ID)
+      if (idProperty !== 'id' && inputRecord.data.id) {
+        finalAttributes[idProperty] = inputRecord.data.id;
+      }
+
       if (isCreate) {
         // Create mode - insert new record with specified ID
         const recordData = {
@@ -756,6 +871,9 @@ export const RestApiKnexPlugin = {
           );
         }
         
+        // Remove the idProperty from attributes to prevent updating the primary key
+        delete finalAttributes[idProperty];
+        
         // Update the record (replace all fields)
         if (Object.keys(finalAttributes).length > 0) {
           await db(tableName)
@@ -823,6 +941,9 @@ export const RestApiKnexPlugin = {
       
       log.debug(`[Knex] PATCH finalAttributes:`, finalAttributes);
       
+      // Remove the idProperty from attributes to prevent updating the primary key
+      delete finalAttributes[idProperty];
+      
       // Update only if there are changes
       if (Object.keys(finalAttributes).length > 0) {
         await db(tableName)

package/plugins/core/rest-api-plugin-hooks/compile-resource-schemas.js

@@ -0,0 +1,7 @@
+import { compileSchemas } from '../lib/querying-writing/compile-schemas.js';
+
+export default async function compileResourceSchemas({ context, scopes, runHooks }) {
+  const scope = scopes[context.scopeName];
+  // Pass scopeOptions and vars from context since scope object structure is different
+  return compileSchemas({ ...scope, scopeOptions: context.scopeOptions, vars: context.vars }, { context: { scopeName: context.scopeName }, runHooks });
+}

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

@@ -0,0 +1,72 @@
+
+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}`;
+
+  // Helper to create route handlers
+  const createRouteHandler = (methodName) => {
+    return async ({ params, body, queryString }) => {
+      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);
+      }
+
+      // Add body data for write operations
+      if (body && body.data !== undefined) {
+        methodParams.relationshipData = body.data;
+      }
+
+      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}`);
+}

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

@@ -0,0 +1,102 @@
+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 || '';
+  
+  // Helper to create route handlers
+  const createRouteHandler = (scopeName, methodName) => {
+    return async ({ queryString, headers, params, body, context }) => {
+      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 = {};
+      
+      // Add ID for single-resource operations
+      if (['get', 'put', 'patch', 'delete'].includes(methodName)) {
+        methodParams.id = params.id;
+      }
+      
+      // Parse query parameters for read operations
+      if (['query', 'get'].includes(methodName)) {
+        methodParams.queryParams = parseJsonApiQuery(queryString);
+        methodParams.isTransport = true;
+      }
+      
+      // Add body for write operations
+      if (['post', 'put', 'patch'].includes(methodName)) {
+        methodParams.inputRecord = body;
+        methodParams.isTransport = true;
+        
+        // Add query params for includes/fields on write operations
+        if (queryString) {
+          methodParams.queryParams = parseJsonApiQuery(queryString);
+        }
+      }
+      
+      // Call the scope method
+      const result = await scope[methodName](methodParams, context);
+      
+      // Return the result (transport plugin handles response formatting)
+      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}'`);
+}

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

@@ -0,0 +1,50 @@
+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;
+
+  // The scope-specific ones
+  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.publicBaseUrl !== 'undefined') vars.publicBaseUrl = scopeOptions.publicBaseUrl;
+  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;
+  
+  // Set returnRecord settings as scope vars
+  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;
+
+  // Add validation for query limits
+  if (vars.queryDefaultLimit && vars.queryMaxLimit) {
+    if (vars.queryDefaultLimit > vars.queryMaxLimit) {
+      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) {
+      if (relDef.include.limit > vars.queryMaxLimit) {
+        throw new Error(
+          `Invalid relationship '${context.scopeName}.${relName}' configuration: ` +
+          `include.limit (${relDef.include.limit}) cannot exceed queryMaxLimit (${vars.queryMaxLimit})`
+        );
+      }
+    }
+  });
+}