json-rest-api 1.0.22 → 1.0.24

package/audit/evidence/code/critical-pass1/json-rest-api__plugins__core__lib__querying__knex-window-queries.js.txt

@@ -1,328 +0,0 @@
-     1	import { RestApiResourceError } from '../../../../lib/rest-api-errors.js'
-     2	import { ROW_NUMBER_KEY, DEFAULT_QUERY_LIMIT, DEFAULT_MAX_QUERY_LIMIT, DEFAULT_MAX_INCLUDE_LIMIT } from '../querying-writing/knex-constants.js'
-     3	
-     4	/**
-     5	 * Builds a window function query for limited includes per parent record
-     6	 *
-     7	 * @param {Object} knex - Knex instance
-     8	 * @param {string} tableName - Target table name
-     9	 * @param {string} foreignKey - Foreign key field
-    10	 * @param {Array} parentIds - Parent record IDs
-    11	 * @param {Array} fieldsToSelect - Fields to select
-    12	 * @param {Object} includeConfig - Include configuration (limit, orderBy)
-    13	 * @param {Object} capabilities - Database capabilities
-    14	 * @param {Object} scopeVars - Scope variables for defaults and limits
-    15	 * @returns {Object} Knex query
-    16	 *
-    17	 * @example
-    18	 * // Input: Load max 3 comments per article, ordered by newest first
-    19	 * const query = buildWindowedIncludeQuery(
-    20	 *   knex,
-    21	 *   'comments',
-    22	 *   'article_id',
-    23	 *   [1, 2, 3],  // Article IDs
-    24	 *   ['id', 'text', 'created_at'],
-    25	 *   { limit: 3, orderBy: ['-created_at'] },
-    26	 *   { windowFunctions: true },
-    27	 *   { queryDefaultLimit: 10 }
-    28	 * );
-    29	 *
-    30	 * // Generated SQL:
-    31	 * // WITH _windowed AS (
-    32	 * //   SELECT id, text, created_at, article_id,
-    33	 * //          ROW_NUMBER() OVER (
-    34	 * //            PARTITION BY article_id
-    35	 * //            ORDER BY created_at DESC
-    36	 * //          ) as __$jsonrestapi_rn$__
-    37	 * //   FROM comments
-    38	 * //   WHERE article_id IN (1, 2, 3)
-    39	 * // )
-    40	 * // SELECT * FROM _windowed
-    41	 * // WHERE __$jsonrestapi_rn$__ <= 3
-    42	 *
-    43	 * // Result: Each article gets max 3 comments, not 3 total
-    44	 *
-    45	 * @example
-    46	 * // Input: Database doesn't support window functions
-    47	 * const query = buildWindowedIncludeQuery(
-    48	 *   knex,
-    49	 *   'comments',
-    50	 *   'article_id',
-    51	 *   [1, 2, 3],
-    52	 *   '*',
-    53	 *   { limit: 5 },
-    54	 *   { windowFunctions: false, dbInfo: { client: 'mysql', version: '5.7' } }
-    55	 * );
-    56	 *
-    57	 * // Throws RestApiResourceError:
-    58	 * // "Include limits require window function support. Your database (mysql 5.7)
-    59	 * //  does not support this feature. Window functions are supported in:
-    60	 * //  PostgreSQL 8.4+, MySQL 8.0+, MariaDB 10.2+, SQLite 3.25+, SQL Server 2005+"
-    61	 *
-    62	 * @description
-    63	 * Used by:
-    64	 * - loadHasMany when strategy: 'window' and database supports window functions
-    65	 * - Enables per-parent limits for one-to-many relationships
-    66	 *
-    67	 * Purpose:
-    68	 * - Solves the "N+1 limit" problem where you want X records per parent
-    69	 * - Without window functions, LIMIT 10 gives 10 total across all parents
-    70	 * - With window functions, each parent gets up to 10 related records
-    71	 * - Critical for consistent API responses with includes
-    72	 *
-    73	 * Data flow:
-    74	 * 1. Creates subquery with ROW_NUMBER() partitioned by foreign key
-    75	 * 2. Numbers rows within each partition based on orderBy
-    76	 * 3. Outer query filters to keep only rows within limit
-    77	 * 4. Returns query ready for execution
-    78	 * 5. Caller removes the ROW_NUMBER column from results
-    79	 */
-    80	export const buildWindowedIncludeQuery = (
-    81	  knex,
-    82	  tableName,
-    83	  foreignKey,
-    84	  parentIds,
-    85	  fieldsToSelect,
-    86	  includeConfig,
-    87	  capabilities,
-    88	  scopeVars = {}
-    89	) => {
-    90	  const { orderBy = [] } = includeConfig
-    91	
-    92	  // Apply defaults for limit
-    93	  const effectiveLimit = includeConfig.limit ?? scopeVars.queryDefaultLimit ?? DEFAULT_QUERY_LIMIT
-    94	
-    95	  // Validate against max
-    96	  if (scopeVars.queryMaxLimit && effectiveLimit > scopeVars.queryMaxLimit) {
-    97	    throw new RestApiResourceError({
-    98	      title: 'Include Limit Exceeds Maximum',
-    99	      detail: `Requested include limit (${effectiveLimit}) exceeds queryMaxLimit (${scopeVars.queryMaxLimit})`,
-   100	      status: 400
-   101	    })
-   102	  }
-   103	
-   104	  // Check if window functions are supported
-   105	  if (!capabilities.windowFunctions) {
-   106	    const { dbInfo } = capabilities
-   107	    throw new RestApiResourceError(
-   108	      `Include limits require window function support. Your database (${dbInfo.client} ${dbInfo.version}) does not support this feature. ` +
-   109	      'Window functions are supported in: PostgreSQL 8.4+, MySQL 8.0+, MariaDB 10.2+, SQLite 3.25+, SQL Server 2005+',
-   110	      {
-   111	        subtype: 'unsupported_operation',
-   112	        database: dbInfo.client,
-   113	        version: dbInfo.version,
-   114	        requiredFeature: 'window_functions'
-   115	      }
-   116	    )
-   117	  }
-   118	
-   119	  // Build the window function query
-   120	  // This creates a subquery that partitions by the foreign key and numbers rows
-   121	  const subquery = knex(tableName)
-   122	    .select('*')
-   123	    .select(
-   124	      knex.raw(
-   125	        'ROW_NUMBER() OVER (PARTITION BY ?? ORDER BY ' +
-   126	        buildOrderByClause(orderBy) +
-   127	        ') as ' + ROW_NUMBER_KEY,
-   128	        [foreignKey]
-   129	      )
-   130	    )
-   131	    .whereIn(foreignKey, parentIds)
-   132	
-   133	  // Apply field selection if specified
-   134	  if (fieldsToSelect !== '*' && Array.isArray(fieldsToSelect)) {
-   135	    // Include the foreign key and row number in selection
-   136	    const fieldsWithFK = [...new Set([...fieldsToSelect, foreignKey, ROW_NUMBER_KEY])]
-   137	    subquery.select(fieldsWithFK)
-   138	  }
-   139	
-   140	  // Wrap in outer query to filter by row number
-   141	  const query = knex
-   142	    .select('*')
-   143	    .from(subquery.as('_windowed'))
-   144	    .where(ROW_NUMBER_KEY, '<=', effectiveLimit)
-   145	
-   146	  return query
-   147	}
-   148	
-   149	/**
-   150	 * Builds ORDER BY clause from array of sort fields
-   151	 *
-   152	 * @param {Array<string>} orderBy - Array of field names, prefix with '-' for DESC
-   153	 * @param {string} tablePrefix - Optional table name to prefix fields
-   154	 * @returns {string} SQL ORDER BY clause
-   155	 *
-   156	 * @example
-   157	 * // Input: Simple ascending sort
-   158	 * const clause = buildOrderByClause(['name', 'created_at']);
-   159	 * // Output: "name ASC, created_at ASC"
-   160	 *
-   161	 * @example
-   162	 * // Input: Mixed ascending/descending with '-' prefix
-   163	 * const clause = buildOrderByClause(['name', '-created_at', 'status']);
-   164	 * // Output: "name ASC, created_at DESC, status ASC"
-   165	 *
-   166	 * @example
-   167	 * // Input: With table prefix for joins
-   168	 * const clause = buildOrderByClause(['-updated_at', 'title'], 'articles');
-   169	 * // Output: "articles.updated_at DESC, articles.title ASC"
-   170	 *
-   171	 * @example
-   172	 * // Input: Empty array (default to id)
-   173	 * const clause = buildOrderByClause([]);
-   174	 * // Output: "id ASC"
-   175	 *
-   176	 * @description
-   177	 * Used by:
-   178	 * - buildWindowedIncludeQuery for PARTITION BY ordering
-   179	 * - applyStandardIncludeConfig for regular ORDER BY
-   180	 * - Query builders that need consistent sort syntax
-   181	 *
-   182	 * Purpose:
-   183	 * - Converts API sort syntax (with '-' prefix) to SQL ORDER BY
-   184	 * - Handles table prefixing for queries with joins
-   185	 * - Provides default ordering by id when none specified
-   186	 * - Ensures consistent sort behavior across the API
-   187	 *
-   188	 * Data flow:
-   189	 * 1. Receives array of sort fields from API parameters
-   190	 * 2. Detects DESC sorts by '-' prefix
-   191	 * 3. Optionally prefixes with table name
-   192	 * 4. Joins into SQL-compatible ORDER BY clause
-   193	 */
-   194	export const buildOrderByClause = (orderBy, tablePrefix) => {
-   195	  if (!orderBy || orderBy.length === 0) {
-   196	    const defaultField = tablePrefix ? `${tablePrefix}.id` : 'id'
-   197	    return `${defaultField} ASC` // Default ordering
-   198	  }
-   199	
-   200	  return orderBy.map(field => {
-   201	    const isDesc = field.startsWith('-')
-   202	    const fieldName = isDesc ? field.substring(1) : field
-   203	    const qualifiedField = tablePrefix ? `${tablePrefix}.${fieldName}` : fieldName
-   204	    return `${qualifiedField} ${isDesc ? 'DESC' : 'ASC'}`
-   205	  }).join(', ')
-   206	}
-   207	
-   208	/**
-   209	 * Applies standard (non-windowed) include configuration to a query
-   210	 *
-   211	 * @param {Object} query - Knex query builder instance
-   212	 * @param {Object} includeConfig - Include configuration object
-   213	 * @param {Object} scopeVars - Scope variables with defaults and limits
-   214	 * @param {Object} log - Logger instance
-   215	 * @returns {Object} Modified query builder
-   216	 *
-   217	 * @example
-   218	 * // Input: Basic include with limit and ordering
-   219	 * let query = knex('comments').whereIn('article_id', [1, 2, 3]);
-   220	 * query = applyStandardIncludeConfig(
-   221	 *   query,
-   222	 *   { limit: 20, orderBy: ['-created_at', 'id'] },
-   223	 *   { queryDefaultLimit: 100, queryMaxLimit: 1000 },
-   224	 *   logger
-   225	 * );
-   226	 *
-   227	 * // Result: Query modified with:
-   228	 * // ORDER BY created_at DESC, id ASC
-   229	 * // LIMIT 20
-   230	 *
-   231	 * @example
-   232	 * // Input: No explicit limit, uses defaults
-   233	 * let query = knex('tags');
-   234	 * query = applyStandardIncludeConfig(
-   235	 *   query,
-   236	 *   { orderBy: ['name'] },  // No limit specified
-   237	 *   { queryDefaultLimit: 50, queryMaxLimit: 500 },
-   238	 *   logger
-   239	 * );
-   240	 *
-   241	 * // Result: Uses default limit
-   242	 * // ORDER BY name ASC
-   243	 * // LIMIT 50
-   244	 * // Log: "Using default limit"
-   245	 *
-   246	 * @example
-   247	 * // Input: Limit exceeds maximum
-   248	 * let query = knex('reviews');
-   249	 * query = applyStandardIncludeConfig(
-   250	 *   query,
-   251	 *   { limit: 5000 },  // Exceeds max
-   252	 *   { queryMaxLimit: 1000, maxIncludeLimit: 500 },
-   253	 *   logger
-   254	 * );
-   255	 *
-   256	 * // Result: Clamped to effective maximum
-   257	 * // LIMIT 500 (min of maxIncludeLimit and queryMaxLimit)
-   258	 *
-   259	 * @example
-   260	 * // Input: Explicitly disable limit
-   261	 * let query = knex('categories');
-   262	 * query = applyStandardIncludeConfig(
-   263	 *   query,
-   264	 *   { limit: null },  // Explicitly no limit
-   265	 *   { queryDefaultLimit: 100 },
-   266	 *   logger
-   267	 * );
-   268	 *
-   269	 * // Result: No LIMIT clause added
-   270	 * // Log: "No limit applied to include query (explicitly disabled)"
-   271	 *
-   272	 * @description
-   273	 * Used by:
-   274	 * - loadHasMany when window functions not available or not requested
-   275	 * - loadReversePolymorphic for standard relationship queries
-   276	 * - Any include loader that needs consistent limit/order handling
-   277	 *
-   278	 * Purpose:
-   279	 * - Provides fallback when window functions unavailable
-   280	 * - Applies consistent ordering based on API sort syntax
-   281	 * - Enforces limit hierarchy: explicit > default > max
-   282	 * - Respects both queryMaxLimit and maxIncludeLimit
-   283	 * - Logs decisions for debugging
-   284	 *
-   285	 * Data flow:
-   286	 * 1. Applies ORDER BY for each field in orderBy array
-   287	 * 2. Determines effective limit from explicit/default/max values
-   288	 * 3. Clamps limit to maximum allowed values
-   289	 * 4. Adds LIMIT clause unless explicitly disabled
-   290	 * 5. Logs the reasoning for the applied limit
-   291	 */
-   292	export const applyStandardIncludeConfig = (query, includeConfig, scopeVars, log) => {
-   293	  const { orderBy = [] } = includeConfig
-   294	
-   295	  // Apply ordering
-   296	  orderBy.forEach(field => {
-   297	    const desc = field.startsWith('-')
-   298	    const column = desc ? field.substring(1) : field
-   299	    query = query.orderBy(column, desc ? 'desc' : 'asc')
-   300	  })
-   301	
-   302	  // Apply limit with defaults
-   303	  const requestedLimit = includeConfig.limit
-   304	  const defaultLimit = scopeVars.queryDefaultLimit ?? DEFAULT_QUERY_LIMIT
-   305	  const limit = requestedLimit ?? defaultLimit
-   306	
-   307	  // Allow explicit null/false to mean no limit
-   308	  if (limit !== null && limit !== false) {
-   309	    const maxInclude = scopeVars.maxIncludeLimit || DEFAULT_MAX_INCLUDE_LIMIT
-   310	    const maxQuery = scopeVars.queryMaxLimit || DEFAULT_MAX_QUERY_LIMIT
-   311	    const effectiveMax = Math.min(maxInclude, maxQuery)
-   312	    const effectiveLimit = Math.min(limit, effectiveMax)
-   313	
-   314	    query = query.limit(effectiveLimit)
-   315	
-   316	    log.debug('Applied include limit:', {
-   317	      requested: requestedLimit,
-   318	      default: defaultLimit,
-   319	      effective: effectiveLimit,
-   320	      maxAllowed: effectiveMax,
-   321	      note: requestedLimit !== undefined ? 'Using explicit limit' : 'Using default limit'
-   322	    })
-   323	  } else {
-   324	    log.debug('No limit applied to include query (explicitly disabled)')
-   325	  }
-   326	
-   327	  return query
-   328	}

package/audit/evidence/code/critical-pass1/json-rest-api__plugins__core__lib__querying__url-helpers.js.txt

@@ -1,119 +0,0 @@
-     1	/**
-     2	 * URL Helper Functions
-     3	 *
-     4	 * Centralized functions for URL generation to avoid code duplication
-     5	 * and support flexible URL prefix override capabilities.
-     6	 */
-     7	
-     8	/**
-     9	 * Get the complete URL prefix, handling all calculation and override logic
-    10	 *
-    11	 * Priority order:
-    12	 * 1. context.urlPrefixOverride - Explicit override (from hooks or middleware)
-    13	 * 2. context.urlPrefix - Pre-calculated URL prefix
-    14	 * 3. Calculate from request if provided
-    15	 * 4. scope.vars.transport?.mountPath - Fallback to mount path
-    16	 * 5. '' - Empty string as final fallback
-    17	 *
-    18	 * @param {Object} context - Request context (may have urlPrefixOverride or urlPrefix)
-    19	 * @param {Object} scope - Scope/resource object with transport vars
-    20	 * @param {Object} req - Optional Express request object for auto-calculation
-    21	 * @returns {string} The final URL prefix to use
-    22	 *
-    23	 * @example
-    24	 * // With full context
-    25	 * const urlPrefix = getUrlPrefix(context, scope);
-    26	 *
-    27	 * @example
-    28	 * // With request object for auto-calculation
-    29	 * const urlPrefix = getUrlPrefix({}, api, req);
-    30	 */
-    31	export function getUrlPrefix (context, scope, req = null) {
-    32	  // Priority 1: Explicit override
-    33	  if (context?.urlPrefixOverride) {
-    34	    return context.urlPrefixOverride
-    35	  }
-    36	
-    37	  // Priority 2: Pre-calculated urlPrefix
-    38	  if (context?.urlPrefix) {
-    39	    return context.urlPrefix
-    40	  }
-    41	
-    42	  // Priority 3: Calculate from request if provided
-    43	  if (req) {
-    44	    const protocol = req.get?.('x-forwarded-proto') || req.protocol || 'http'
-    45	    const host = req.get?.('x-forwarded-host') || req.get?.('host')
-    46	    const mountPath = scope?.vars?.transport?.mountPath || ''
-    47	
-    48	    if (host) {
-    49	      return `${protocol}://${host}${mountPath}`
-    50	    }
-    51	  }
-    52	
-    53	  // Priority 4: Fallback to mount path
-    54	  return scope?.vars?.transport?.mountPath || ''
-    55	}
-    56	
-    57	/**
-    58	 * Build a complete resource URL
-    59	 *
-    60	 * @param {Object} context - Request context
-    61	 * @param {Object} scope - Scope containing transport vars
-    62	 * @param {string} scopeName - Resource type name
-    63	 * @param {string} id - Resource ID
-    64	 * @returns {string} Complete resource URL
-    65	 *
-    66	 * @example
-    67	 * const url = buildResourceUrl(context, scope, 'books', '123');
-    68	 * // Returns: "https://api.example.com/api/books/123"
-    69	 */
-    70	export function buildResourceUrl (context, scope, scopeName, id) {
-    71	  const urlPrefix = getUrlPrefix(context, scope)
-    72	  return `${urlPrefix}/${scopeName}/${id}`
-    73	}
-    74	
-    75	/**
-    76	 * Build a relationship URL
-    77	 *
-    78	 * @param {Object} context - Request context
-    79	 * @param {Object} scope - Scope containing transport vars
-    80	 * @param {string} scopeName - Resource type name
-    81	 * @param {string} id - Resource ID
-    82	 * @param {string} relationshipName - Name of the relationship
-    83	 * @param {boolean} isRelationshipEndpoint - If true, builds /relationships/ URL
-    84	 * @returns {string} Complete relationship URL
-    85	 *
-    86	 * @example
-    87	 * // For relationship linkage endpoint
-    88	 * buildRelationshipUrl(context, scope, 'books', '1', 'author', true);
-    89	 * // Returns: "https://api.example.com/api/books/1/relationships/author"
-    90	 *
-    91	 * // For related resource endpoint
-    92	 * buildRelationshipUrl(context, scope, 'books', '1', 'author', false);
-    93	 * // Returns: "https://api.example.com/api/books/1/author"
-    94	 */
-    95	export function buildRelationshipUrl (context, scope, scopeName, id, relationshipName, isRelationshipEndpoint = false) {
-    96	  const urlPrefix = getUrlPrefix(context, scope)
-    97	  if (isRelationshipEndpoint) {
-    98	    return `${urlPrefix}/${scopeName}/${id}/relationships/${relationshipName}`
-    99	  }
-   100	  return `${urlPrefix}/${scopeName}/${id}/${relationshipName}`
-   101	}
-   102	
-   103	/**
-   104	 * Build a collection URL with optional query string
-   105	 *
-   106	 * @param {Object} context - Request context
-   107	 * @param {Object} scope - Scope containing transport vars
-   108	 * @param {string} scopeName - Resource type name
-   109	 * @param {string} queryString - Optional query string (with leading ?)
-   110	 * @returns {string} Complete collection URL
-   111	 *
-   112	 * @example
-   113	 * buildCollectionUrl(context, scope, 'books', '?page[size]=10');
-   114	 * // Returns: "https://api.example.com/api/books?page[size]=10"
-   115	 */
-   116	export function buildCollectionUrl (context, scope, scopeName, queryString = '') {
-   117	  const urlPrefix = getUrlPrefix(context, scope)
-   118	  return `${urlPrefix}/${scopeName}${queryString}`
-   119	}

package/audit/evidence/code/critical-pass1/json-rest-api__plugins__core__lib__storage__storage-adapter.js.txt

@@ -1,160 +0,0 @@
-     1	const passthrough = (value) => value
-     2	const identityTranslate = (_field, value) => value
-     3	const identityScope = (query) => query
-     4	
-     5	const selectColumnsOnBuilder = (builder, columns) => {
-     6	  if (!columns) return builder
-     7	  if (Array.isArray(columns)) {
-     8	    columns.forEach((column) => builder.select(column))
-     9	  } else if (typeof columns === 'object') {
-    10	    builder.select(columns)
-    11	  }
-    12	  return builder
-    13	}
-    14	
-    15	const normalizeArray = (value, normalizeFn) => value.map((entry) => normalizeFn(entry))
-    16	
-    17	const normalizeBelongsToValue = (value) => {
-    18	  if (value === null || value === undefined) return value
-    19	  if (Array.isArray(value)) {
-    20	    return normalizeArray(value, normalizeBelongsToValue)
-    21	  }
-    22	  return String(value)
-    23	}
-    24	
-    25	const baseAdapter = ({
-    26	  knex,
-    27	  tableName,
-    28	  idColumn,
-    29	  translateColumn,
-    30	  translateFilterValue = identityTranslate,
-    31	  applyResourceScope = identityScope,
-    32	  isCanonical = false,
-    33	}) => {
-    34	  const buildBaseQuery = ({ transaction } = {}) => {
-    35	    const query = (transaction || knex)(tableName)
-    36	    return applyResourceScope(query)
-    37	  }
-    38	
-    39	  return {
-    40	    isCanonical: () => isCanonical,
-    41	    getTableName: () => tableName,
-    42	    getIdColumn: () => idColumn,
-    43	    translateColumn,
-    44	    translateFilterValue,
-    45	    applyResourceScope,
-    46	    buildBaseQuery,
-    47	    selectColumns: (builder, columns) => selectColumnsOnBuilder(builder, columns),
-    48	  }
-    49	}
-    50	
-    51	const createLegacyAdapter = ({ knex, schemaInfo }) => {
-    52	  const tableName = schemaInfo.tableName
-    53	  const idColumn = schemaInfo.idProperty || 'id'
-    54	
-    55	  const translateColumn = (column) => column
-    56	
-    57	  return baseAdapter({
-    58	    knex,
-    59	    tableName,
-    60	    idColumn,
-    61	    translateColumn,
-    62	    translateFilterValue: identityTranslate,
-    63	    applyResourceScope: identityScope,
-    64	    isCanonical: false,
-    65	  })
-    66	}
-    67	
-    68	const createCanonicalAdapter = ({ knex, schemaInfo }) => {
-    69	  const descriptor = schemaInfo.descriptor || {}
-    70	  const canonical = descriptor.canonical || {}
-    71	  const canonicalFieldMap = descriptor.canonicalFieldMap || {}
-    72	  const fieldsInfo = descriptor.fields || {}
-    73	  const belongsToInfo = descriptor.belongsTo || {}
-    74	
-    75	  const translateColumn = (field) => {
-    76	    if (!field) return field
-    77	    if (field === 'id') return 'id'
-    78	
-    79	    const canonicalEntry = canonicalFieldMap[field]
-    80	    if (typeof canonicalEntry === 'string') {
-    81	      return canonicalEntry
-    82	    }
-    83	    if (canonicalEntry && typeof canonicalEntry === 'object') {
-    84	      if (canonicalEntry.slot) return canonicalEntry.slot
-    85	      if (canonicalEntry.slotColumn) return canonicalEntry.slotColumn
-    86	      if (canonicalEntry.idSlot) return canonicalEntry.idSlot
-    87	      if (canonicalEntry.typeSlot && field.endsWith('_type')) return canonicalEntry.typeSlot
-    88	    }
-    89	
-    90	    if (!canonicalEntry && field.endsWith('_id')) {
-    91	      const alias = field.slice(0, -3)
-    92	      const aliasEntry = canonicalFieldMap[alias]
-    93	      if (typeof aliasEntry === 'string') return aliasEntry
-    94	      if (aliasEntry?.idSlot) return aliasEntry.idSlot
-    95	    }
-    96	
-    97	    if (!canonicalEntry && field.endsWith('_type')) {
-    98	      const alias = field.slice(0, -5)
-    99	      const aliasEntry = canonicalFieldMap[alias]
-   100	      if (aliasEntry?.typeSlot) return aliasEntry.typeSlot
-   101	    }
-   102	
-   103	    const fieldInfo = fieldsInfo[field]
-   104	    if (fieldInfo?.slot) return fieldInfo.slot
-   105	
-   106	    const belongsInfo = belongsToInfo[field]
-   107	    if (belongsInfo?.idColumn) return belongsInfo.idColumn
-   108	
-   109	    return field
-   110	  }
-   111	
-   112	  const translateFilterValue = (field, value) => {
-   113	    if (value === null || value === undefined) return value
-   114	
-   115	    const searchField = schemaInfo.searchSchemaStructure?.[field]
-   116	    const schemaField = schemaInfo.schemaStructure?.[field]
-   117	    const isRelationship = Boolean(
-   118	      searchField?.isRelationship ||
-   119	      schemaField?.belongsTo ||
-   120	      schemaField?.belongsToPolymorphic
-   121	    )
-   122	
-   123	    if (!isRelationship) {
-   124	      if (Array.isArray(value)) {
-   125	        return normalizeArray(value, passthrough)
-   126	      }
-   127	      return value
-   128	    }
-   129	
-   130	    return normalizeBelongsToValue(value)
-   131	  }
-   132	
-   133	  const applyResourceScope = (query) => {
-   134	    return query
-   135	      .where(canonical.tenantColumn, descriptor.tenant)
-   136	      .where(canonical.resourceColumn, descriptor.resource)
-   137	  }
-   138	
-   139	  return baseAdapter({
-   140	    knex,
-   141	    tableName: canonical.tableName,
-   142	    idColumn: 'id',
-   143	    translateColumn,
-   144	    translateFilterValue,
-   145	    applyResourceScope,
-   146	    isCanonical: true,
-   147	  })
-   148	}
-   149	
-   150	export const createStorageAdapter = ({ knex, schemaInfo }) => {
-   151	  if (!schemaInfo) {
-   152	    throw new Error('createStorageAdapter requires schemaInfo')
-   153	  }
-   154	
-   155	  if (schemaInfo?.descriptor?.canonical?.tableName) {
-   156	    return createCanonicalAdapter({ knex, schemaInfo })
-   157	  }
-   158	
-   159	  return createLegacyAdapter({ knex, schemaInfo })
-   160	}