json-rest-api 1.0.6 → 1.0.8

package/plugins/core/lib/querying/knex-window-queries.js

@@ -0,0 +1,328 @@
+import { RestApiResourceError } from '../../../../lib/rest-api-errors.js';
+import { ROW_NUMBER_KEY, DEFAULT_QUERY_LIMIT, DEFAULT_MAX_QUERY_LIMIT, DEFAULT_MAX_INCLUDE_LIMIT } from '../querying-writing/knex-constants.js';
+
+/**
+ * Builds a window function query for limited includes per parent record
+ * 
+ * @param {Object} knex - Knex instance
+ * @param {string} tableName - Target table name
+ * @param {string} foreignKey - Foreign key field
+ * @param {Array} parentIds - Parent record IDs
+ * @param {Array} fieldsToSelect - Fields to select
+ * @param {Object} includeConfig - Include configuration (limit, orderBy)
+ * @param {Object} capabilities - Database capabilities
+ * @param {Object} scopeVars - Scope variables for defaults and limits
+ * @returns {Object} Knex query
+ * 
+ * @example
+ * // Input: Load max 3 comments per article, ordered by newest first
+ * const query = buildWindowedIncludeQuery(
+ *   knex,
+ *   'comments',
+ *   'article_id',
+ *   [1, 2, 3],  // Article IDs
+ *   ['id', 'text', 'created_at'],
+ *   { limit: 3, orderBy: ['-created_at'] },
+ *   { windowFunctions: true },
+ *   { queryDefaultLimit: 10 }
+ * );
+ * 
+ * // Generated SQL:
+ * // WITH _windowed AS (
+ * //   SELECT id, text, created_at, article_id,
+ * //          ROW_NUMBER() OVER (
+ * //            PARTITION BY article_id 
+ * //            ORDER BY created_at DESC
+ * //          ) as __$jsonrestapi_rn$__
+ * //   FROM comments
+ * //   WHERE article_id IN (1, 2, 3)
+ * // )
+ * // SELECT * FROM _windowed 
+ * // WHERE __$jsonrestapi_rn$__ <= 3
+ * 
+ * // Result: Each article gets max 3 comments, not 3 total
+ * 
+ * @example
+ * // Input: Database doesn't support window functions
+ * const query = buildWindowedIncludeQuery(
+ *   knex,
+ *   'comments',
+ *   'article_id',
+ *   [1, 2, 3],
+ *   '*',
+ *   { limit: 5 },
+ *   { windowFunctions: false, dbInfo: { client: 'mysql', version: '5.7' } }
+ * );
+ * 
+ * // Throws RestApiResourceError:
+ * // "Include limits require window function support. Your database (mysql 5.7) 
+ * //  does not support this feature. Window functions are supported in: 
+ * //  PostgreSQL 8.4+, MySQL 8.0+, MariaDB 10.2+, SQLite 3.25+, SQL Server 2005+"
+ * 
+ * @description
+ * Used by:
+ * - loadHasMany when strategy: 'window' and database supports window functions
+ * - Enables per-parent limits for one-to-many relationships
+ * 
+ * Purpose:
+ * - Solves the "N+1 limit" problem where you want X records per parent
+ * - Without window functions, LIMIT 10 gives 10 total across all parents
+ * - With window functions, each parent gets up to 10 related records
+ * - Critical for consistent API responses with includes
+ * 
+ * Data flow:
+ * 1. Creates subquery with ROW_NUMBER() partitioned by foreign key
+ * 2. Numbers rows within each partition based on orderBy
+ * 3. Outer query filters to keep only rows within limit
+ * 4. Returns query ready for execution
+ * 5. Caller removes the ROW_NUMBER column from results
+ */
+export const buildWindowedIncludeQuery = (
+  knex,
+  tableName,
+  foreignKey,
+  parentIds,
+  fieldsToSelect,
+  includeConfig,
+  capabilities,
+  scopeVars = {}
+) => {
+  const { orderBy = [] } = includeConfig;
+  
+  // Apply defaults for limit
+  const effectiveLimit = includeConfig.limit ?? scopeVars.queryDefaultLimit ?? DEFAULT_QUERY_LIMIT;
+  
+  // Validate against max
+  if (scopeVars.queryMaxLimit && effectiveLimit > scopeVars.queryMaxLimit) {
+    throw new RestApiResourceError({
+      title: 'Include Limit Exceeds Maximum',
+      detail: `Requested include limit (${effectiveLimit}) exceeds queryMaxLimit (${scopeVars.queryMaxLimit})`,
+      status: 400
+    });
+  }
+  
+  // Check if window functions are supported
+  if (!capabilities.windowFunctions) {
+    const { dbInfo } = capabilities;
+    throw new RestApiResourceError(
+      `Include limits require window function support. Your database (${dbInfo.client} ${dbInfo.version}) does not support this feature. ` +
+      `Window functions are supported in: PostgreSQL 8.4+, MySQL 8.0+, MariaDB 10.2+, SQLite 3.25+, SQL Server 2005+`,
+      {
+        subtype: 'unsupported_operation',
+        database: dbInfo.client,
+        version: dbInfo.version,
+        requiredFeature: 'window_functions'
+      }
+    );
+  }
+  
+  // Build the window function query
+  // This creates a subquery that partitions by the foreign key and numbers rows
+  const subquery = knex(tableName)
+    .select('*')
+    .select(
+      knex.raw(
+        'ROW_NUMBER() OVER (PARTITION BY ?? ORDER BY ' + 
+        buildOrderByClause(orderBy) + 
+        ') as ' + ROW_NUMBER_KEY,
+        [foreignKey]
+      )
+    )
+    .whereIn(foreignKey, parentIds);
+  
+  // Apply field selection if specified
+  if (fieldsToSelect !== '*' && Array.isArray(fieldsToSelect)) {
+    // Include the foreign key and row number in selection
+    const fieldsWithFK = [...new Set([...fieldsToSelect, foreignKey, ROW_NUMBER_KEY])];
+    subquery.select(fieldsWithFK);
+  }
+  
+  // Wrap in outer query to filter by row number
+  const query = knex
+    .select('*')
+    .from(subquery.as('_windowed'))
+    .where(ROW_NUMBER_KEY, '<=', effectiveLimit);
+  
+  return query;
+};
+
+/**
+ * Builds ORDER BY clause from array of sort fields
+ * 
+ * @param {Array<string>} orderBy - Array of field names, prefix with '-' for DESC
+ * @param {string} tablePrefix - Optional table name to prefix fields
+ * @returns {string} SQL ORDER BY clause
+ * 
+ * @example
+ * // Input: Simple ascending sort
+ * const clause = buildOrderByClause(['name', 'created_at']);
+ * // Output: "name ASC, created_at ASC"
+ * 
+ * @example
+ * // Input: Mixed ascending/descending with '-' prefix
+ * const clause = buildOrderByClause(['name', '-created_at', 'status']);
+ * // Output: "name ASC, created_at DESC, status ASC"
+ * 
+ * @example
+ * // Input: With table prefix for joins
+ * const clause = buildOrderByClause(['-updated_at', 'title'], 'articles');
+ * // Output: "articles.updated_at DESC, articles.title ASC"
+ * 
+ * @example
+ * // Input: Empty array (default to id)
+ * const clause = buildOrderByClause([]);
+ * // Output: "id ASC"
+ * 
+ * @description
+ * Used by:
+ * - buildWindowedIncludeQuery for PARTITION BY ordering
+ * - applyStandardIncludeConfig for regular ORDER BY
+ * - Query builders that need consistent sort syntax
+ * 
+ * Purpose:
+ * - Converts API sort syntax (with '-' prefix) to SQL ORDER BY
+ * - Handles table prefixing for queries with joins
+ * - Provides default ordering by id when none specified
+ * - Ensures consistent sort behavior across the API
+ * 
+ * Data flow:
+ * 1. Receives array of sort fields from API parameters
+ * 2. Detects DESC sorts by '-' prefix
+ * 3. Optionally prefixes with table name
+ * 4. Joins into SQL-compatible ORDER BY clause
+ */
+export const buildOrderByClause = (orderBy, tablePrefix) => {
+  if (!orderBy || orderBy.length === 0) {
+    const defaultField = tablePrefix ? `${tablePrefix}.id` : 'id';
+    return `${defaultField} ASC`; // Default ordering
+  }
+  
+  return orderBy.map(field => {
+    const isDesc = field.startsWith('-');
+    const fieldName = isDesc ? field.substring(1) : field;
+    const qualifiedField = tablePrefix ? `${tablePrefix}.${fieldName}` : fieldName;
+    return `${qualifiedField} ${isDesc ? 'DESC' : 'ASC'}`;
+  }).join(', ');
+};
+
+/**
+ * Applies standard (non-windowed) include configuration to a query
+ * 
+ * @param {Object} query - Knex query builder instance
+ * @param {Object} includeConfig - Include configuration object
+ * @param {Object} scopeVars - Scope variables with defaults and limits
+ * @param {Object} log - Logger instance
+ * @returns {Object} Modified query builder
+ * 
+ * @example
+ * // Input: Basic include with limit and ordering
+ * let query = knex('comments').whereIn('article_id', [1, 2, 3]);
+ * query = applyStandardIncludeConfig(
+ *   query,
+ *   { limit: 20, orderBy: ['-created_at', 'id'] },
+ *   { queryDefaultLimit: 100, queryMaxLimit: 1000 },
+ *   logger
+ * );
+ * 
+ * // Result: Query modified with:
+ * // ORDER BY created_at DESC, id ASC
+ * // LIMIT 20
+ * 
+ * @example
+ * // Input: No explicit limit, uses defaults
+ * let query = knex('tags');
+ * query = applyStandardIncludeConfig(
+ *   query,
+ *   { orderBy: ['name'] },  // No limit specified
+ *   { queryDefaultLimit: 50, queryMaxLimit: 500 },
+ *   logger
+ * );
+ * 
+ * // Result: Uses default limit
+ * // ORDER BY name ASC
+ * // LIMIT 50
+ * // Log: "Using default limit"
+ * 
+ * @example
+ * // Input: Limit exceeds maximum
+ * let query = knex('reviews');
+ * query = applyStandardIncludeConfig(
+ *   query,
+ *   { limit: 5000 },  // Exceeds max
+ *   { queryMaxLimit: 1000, maxIncludeLimit: 500 },
+ *   logger  
+ * );
+ * 
+ * // Result: Clamped to effective maximum
+ * // LIMIT 500 (min of maxIncludeLimit and queryMaxLimit)
+ * 
+ * @example
+ * // Input: Explicitly disable limit
+ * let query = knex('categories');
+ * query = applyStandardIncludeConfig(
+ *   query,
+ *   { limit: null },  // Explicitly no limit
+ *   { queryDefaultLimit: 100 },
+ *   logger
+ * );
+ * 
+ * // Result: No LIMIT clause added
+ * // Log: "No limit applied to include query (explicitly disabled)"
+ * 
+ * @description
+ * Used by:
+ * - loadHasMany when window functions not available or not requested
+ * - loadReversePolymorphic for standard relationship queries
+ * - Any include loader that needs consistent limit/order handling
+ * 
+ * Purpose:
+ * - Provides fallback when window functions unavailable
+ * - Applies consistent ordering based on API sort syntax
+ * - Enforces limit hierarchy: explicit > default > max
+ * - Respects both queryMaxLimit and maxIncludeLimit
+ * - Logs decisions for debugging
+ * 
+ * Data flow:
+ * 1. Applies ORDER BY for each field in orderBy array
+ * 2. Determines effective limit from explicit/default/max values
+ * 3. Clamps limit to maximum allowed values
+ * 4. Adds LIMIT clause unless explicitly disabled
+ * 5. Logs the reasoning for the applied limit
+ */
+export const applyStandardIncludeConfig = (query, includeConfig, scopeVars, log) => {
+  const { orderBy = [] } = includeConfig;
+  
+  // Apply ordering
+  orderBy.forEach(field => {
+    const desc = field.startsWith('-');
+    const column = desc ? field.substring(1) : field;
+    query = query.orderBy(column, desc ? 'desc' : 'asc');
+  });
+  
+  // Apply limit with defaults
+  const requestedLimit = includeConfig.limit;
+  const defaultLimit = scopeVars.queryDefaultLimit ?? DEFAULT_QUERY_LIMIT;
+  const limit = requestedLimit ?? defaultLimit;
+  
+  // Allow explicit null/false to mean no limit
+  if (limit !== null && limit !== false) {
+    const maxInclude = scopeVars.maxIncludeLimit || DEFAULT_MAX_INCLUDE_LIMIT;
+    const maxQuery = scopeVars.queryMaxLimit || DEFAULT_MAX_QUERY_LIMIT;
+    const effectiveMax = Math.min(maxInclude, maxQuery);
+    const effectiveLimit = Math.min(limit, effectiveMax);
+    
+    query = query.limit(effectiveLimit);
+    
+    log.debug('Applied include limit:', {
+      requested: requestedLimit,
+      default: defaultLimit,
+      effective: effectiveLimit,
+      maxAllowed: effectiveMax,
+      note: requestedLimit !== undefined ? 'Using explicit limit' : 'Using default limit'
+    });
+  } else {
+    log.debug('No limit applied to include query (explicitly disabled)');
+  }
+  
+  return query;
+};

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

@@ -0,0 +1,328 @@
+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 rawSchema = {
+ *   title: { type: 'string', required: true },
+ *   content: { type: 'string' },
+ *   author_id: { belongsTo: 'users', as: 'author' },  // Missing type
+ *   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
+ * //   schemaStructure: {
+ * //     title: { type: 'string', required: true },
+ * //     content: { type: 'string' },
+ * //     author_id: { type: 'id', belongsTo: 'users', as: 'author' }  // Type added!
+ * //     // Note: word_count removed (it's computed)
+ * //   },
+ * //   computed: {
+ * //     word_count: { type: 'number', computed: true, compute: [Function] }
+ * //   }
+ * // }
+ * 
+ * @example
+ * // Input: Schema with search fields
+ * const rawSchema = {
+ *   title: { type: 'string', search: true },    // Searchable
+ *   status: { type: 'string' },                 // Not searchable
+ *   author_id: { belongsTo: 'users', as: 'author' }
+ * };
+ * 
+ * // Output: Auto-generated searchSchema
+ * // searchSchemaObject contains:
+ * // {
+ * //   title: { 
+ * //     type: 'string', 
+ * //     indexed: true,        // Added for DB optimization
+ * //     filterOperator: '='   // Default operator
+ * //   }
+ * // }
+ * 
+ * @example
+ * // Input: Pivot table auto-detection
+ * const pivotSchema = {
+ *   article_id: { belongsTo: 'articles', as: 'article' },
+ *   tag_id: { belongsTo: 'tags', as: 'tag' },
+ *   display_order: { type: 'number' }
+ * };
+ * 
+ * // Output: Both foreign keys become searchable
+ * // schemaStructure will have:
+ * // {
+ * //   article_id: { type: 'id', belongsTo: 'articles', as: 'article', search: true },
+ * //   tag_id: { type: 'id', belongsTo: 'tags', as: 'tag', search: true },
+ * //   display_order: { type: 'number' }
+ * // }
+ * // This enables efficient many-to-many filtering!
+ * 
+ * @example  
+ * // Input: Schema with dependent getters
+ * const schema = {
+ *   first_name: { type: 'string' },
+ *   last_name: { type: 'string' },
+ *   full_name: {
+ *     type: 'string',
+ *     getter: (record) => `${record.first_name} ${record.last_name}`,
+ *     runGetterAfter: ['first_name', 'last_name']  // Dependencies
+ *   },
+ *   email: {
+ *     type: 'string',
+ *     setter: (value) => value.toLowerCase().trim()
+ *   }
+ * };
+ * 
+ * // Output includes dependency-sorted fields:
+ * // {
+ * //   fieldGetters: { full_name: { getter: [Function], runGetterAfter: [...] } },
+ * //   sortedGetterFields: ['full_name'],    // Topologically sorted
+ * //   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
+ * - Auto-detects pivot tables for many-to-many
+ * - Generates search schemas from field markers
+ * - 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
+ * 3. Detects pivot tables (2+ foreign keys, 40%+ of fields)
+ * 4. Runs schema:enrich hook for plugins
+ * 5. Creates json-rest-schema validation instance
+ * 6. Generates searchSchema from search:true fields
+ * 7. Runs searchSchema:enrich hook
+ * 8. Extracts and topologically sorts getters/setters
+ * 9. Caches all results in scope.vars.schemaInfo
+ */
+export async function compileSchemas(scope, deps) {
+  // Extract scopeName from context
+  const { context, runHooks } = deps;
+  const scopeName = context.scopeName;
+
+  // Get raw schema
+  const rawSchema = scope.scopeOptions?.schema || {};
+  
+  // Extract computed fields from schema and build enriched schema
+  const computedFields = {};
+  const enrichedSchema = {};
+  
+  for (const [fieldName, fieldDef] of Object.entries(rawSchema)) {
+    if (fieldDef.computed === true) {
+      // Extract computed field - copy entire definition
+      computedFields[fieldName] = { ...fieldDef };
+      
+      // Validate computed field
+      if (!fieldDef.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`);
+      }
+      
+      // Don't include computed fields in the validation schema
+    } else {
+      enrichedSchema[fieldName] = { ...fieldDef };
+    }
+  }
+  
+  // Default enrichment: Add type to belongsTo fields
+  for (const [fieldName, fieldDef] of Object.entries(enrichedSchema)) {
+    if (fieldDef.belongsTo && !fieldDef.type) {
+      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(enrichedSchema);
+  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);
+  
+  if (isProbablyPivot) {
+    // Make all belongsTo fields searchable for pivot operations
+    for (const [fieldName, fieldDef] of belongsToFields) {
+      if (!fieldDef.search) {
+        fieldDef.search = true;
+      }
+    }
+  }
+
+
+  // Hook: schema:enrich
+  const schemaContext = {
+    schema: enrichedSchema,    // Mutable
+    originalSchema: rawSchema,  // Read-only
+    scopeName
+  };
+  await runHooks('schema:enrich', schemaContext);
+  
+  // Create schema object
+  const schemaObject = createSchema(schemaContext.schema);
+  
+  // 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.
+  // The explicit searchSchema takes precedence and can define virtual fields for joins.
+  // Example: title: {search: true} auto-generates a searchable field with sensible defaults,
+  // while searchSchema can specify filterOperator: 'contains' or complex join configurations.
+  let rawSearchSchema = scope.scopeOptions.searchSchema ||
+  generateSearchSchemaFromSchema(schemaContext.schema);
+  
+  if (rawSearchSchema) {
+    // Mark all search fields as indexed for database optimization.
+    // This ensures that any field used for filtering will have a database index created,
+    // dramatically improving query performance. Without indexes, filtering large tables
+    // 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(rawSearchSchema);
+    
+    // Hook: searchSchema:enrich
+    const searchSchemaContext = {
+      searchSchema: rawSearchSchema,    // Mutable
+      schema: schemaContext.schema,     // Read-only enriched schema
+      scopeName
+    };
+    await runHooks('searchSchema:enrich', searchSchemaContext);
+    
+    // Create searchSchema object
+    var searchSchemaObject = createSchema(searchSchemaContext.searchSchema);
+  } else {
+    var searchSchemaObject = null;
+  }
+
+  // Build schemaRelationships including polymorphic fields from schema
+  const schemaRelationships = { ...(scope.scopeOptions.relationships || {}) };
+  
+  // Validate belongsTo fields
+  for (const [fieldName, fieldDef] of Object.entries(schemaContext.schema)) {
+    // 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. ` +
+        `Example: ${fieldName}: { type: 'number', belongsTo: '${fieldDef.belongsTo}', as: '${fieldName.replace(/_id$/, '')}' }`
+      );
+    }
+  }
+
+  // Extract and validate getter definitions
+  const fieldGetters = {};
+  const getterFields = [];
+  
+  for (const [fieldName, fieldDef] of Object.entries(schemaContext.schema)) {
+    if (fieldDef.getter && typeof fieldDef.getter === 'function') {
+      fieldGetters[fieldName] = {
+        getter: fieldDef.getter,
+        runGetterAfter: fieldDef.runGetterAfter || [],
+        fieldDef: fieldDef
+      };
+      getterFields.push(fieldName);
+      
+      // Validate dependencies exist
+      if (fieldDef.runGetterAfter && Array.isArray(fieldDef.runGetterAfter)) {
+        for (const dep of fieldDef.runGetterAfter) {
+          if (!schemaContext.schema[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 = [];
+  if (Object.keys(fieldGetters).length > 0) {
+    try {
+      sortedGetterFields = sortFieldsByDependencies(fieldGetters, 'runGetterAfter');
+    } catch (error) {
+      throw new Error(`Invalid getter dependencies in ${scopeName}: ${error.message}`);
+    }
+  }
+
+  // Extract and validate setter definitions
+  const fieldSetters = {};
+  const setterFields = [];
+  
+  for (const [fieldName, fieldDef] of Object.entries(schemaContext.schema)) {
+    if (fieldDef.setter && typeof fieldDef.setter === 'function') {
+      fieldSetters[fieldName] = {
+        setter: fieldDef.setter,
+        runSetterAfter: fieldDef.runSetterAfter || [],
+        fieldDef: fieldDef
+      };
+      setterFields.push(fieldName);
+      
+      // Validate dependencies exist
+      if (fieldDef.runSetterAfter && Array.isArray(fieldDef.runSetterAfter)) {
+        for (const dep of fieldDef.runSetterAfter) {
+          if (!schemaContext.schema[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 = [];
+  if (Object.keys(fieldSetters).length > 0) {
+    try {
+      sortedSetterFields = sortFieldsByDependencies(fieldSetters, 'runSetterAfter');
+    } catch (error) {
+      throw new Error(`Invalid setter dependencies in ${scopeName}: ${error.message}`);
+    }
+  }
+
+  // Cache everything
+  scope.vars.schemaInfo = {
+    schema: schemaObject,
+    schemaStructure: schemaContext.schema,
+    computed: computedFields,
+    searchSchema: searchSchemaObject,
+    schemaRelationships: schemaRelationships,
+    tableName: scope.scopeOptions.tableName || scopeName,
+    idProperty: scope.scopeOptions.idProperty || scope.vars.idProperty,
+    fieldGetters: fieldGetters,
+    sortedGetterFields: sortedGetterFields,
+    fieldSetters: fieldSetters,
+    sortedSetterFields: sortedSetterFields
+  };  
+}