json-rest-api 1.0.22 → 1.0.24

package/audit/evidence/code/critical-pass1/json-rest-api__plugins__core__lib__querying-writing__database-capabilities.js.txt

@@ -1,265 +0,0 @@
-     1	/**
-     2	 * Parses database version string to comparable format
-     3	 *
-     4	 * @param {string} versionString - Raw version string from database
-     5	 * @returns {Object|null} Parsed version with major, minor, patch
-     6	 *
-     7	 * @example
-     8	 * // Input: MySQL version
-     9	 * parseVersion("8.0.33");
-    10	 * // Output: { major: 8, minor: 0, patch: 33 }
-    11	 *
-    12	 * @example
-    13	 * // Input: PostgreSQL version with extra info
-    14	 * parseVersion("14.5 (Ubuntu 14.5-1.pgdg20.04+1)");
-    15	 * // Output: { major: 14, minor: 5, patch: 0 }
-    16	 *
-    17	 * @example
-    18	 * // Input: MariaDB version
-    19	 * parseVersion("10.6.12-MariaDB");
-    20	 * // Output: { major: 10, minor: 6, patch: 12 }
-    21	 */
-    22	const parseVersion = (versionString) => {
-    23	  // MySQL: "8.0.33"
-    24	  // PostgreSQL: "14.5 (Ubuntu 14.5-1.pgdg20.04+1)"
-    25	  // MariaDB: "10.6.12-MariaDB"
-    26	  // SQLite: "3.35.5"
-    27	
-    28	  const match = versionString.match(/(\d+)\.(\d+)(?:\.(\d+))?/)
-    29	  if (!match) return null
-    30	
-    31	  return {
-    32	    major: parseInt(match[1]),
-    33	    minor: parseInt(match[2]),
-    34	    patch: match[3] ? parseInt(match[3]) : 0
-    35	  }
-    36	}
-    37	
-    38	/**
-    39	 * Checks if the database supports window functions based on version
-    40	 *
-    41	 * @param {Object} knex - Knex instance
-    42	 * @returns {Promise<boolean>} True if window functions are supported
-    43	 *
-    44	 * @example
-    45	 * // Input: MySQL 8.0.33
-    46	 * const supports = await supportsWindowFunctions(knex);
-    47	 * // Output: true (MySQL 8.0+ supports window functions)
-    48	 *
-    49	 * @example
-    50	 * // Input: MySQL 5.7.42
-    51	 * const supports = await supportsWindowFunctions(knex);
-    52	 * // Output: false (MySQL < 8.0 doesn't support window functions)
-    53	 *
-    54	 * @example
-    55	 * // Input: PostgreSQL (any modern version)
-    56	 * const supports = await supportsWindowFunctions(knex);
-    57	 * // Output: true (PostgreSQL 8.4+ supports window functions)
-    58	 *
-    59	 * @example
-    60	 * // Input: SQLite 3.24.0
-    61	 * const supports = await supportsWindowFunctions(knex);
-    62	 * // Output: false (SQLite needs 3.25.0+)
-    63	 *
-    64	 * @description
-    65	 * Used by:
-    66	 * - buildWindowedIncludeQuery to validate before using window functions
-    67	 * - rest-api-knex-plugin to determine query strategies
-    68	 *
-    69	 * Purpose:
-    70	 * - Prevents runtime errors by checking feature support
-    71	 * - Enables fallback strategies for older databases
-    72	 * - Provides clear error messages about version requirements
-    73	 *
-    74	 * Data flow:
-    75	 * 1. Identifies database client type from Knex config
-    76	 * 2. For version-dependent databases, queries version string
-    77	 * 3. Parses version and compares against known thresholds
-    78	 * 4. Returns boolean indicating support
-    79	 * 5. Falls back to false if version can't be determined
-    80	 *
-    81	 * Version requirements:
-    82	 * - PostgreSQL: 8.4+ (all modern versions)
-    83	 * - MySQL: 8.0+
-    84	 * - MariaDB: 10.2+
-    85	 * - SQLite: 3.25.0+
-    86	 * - SQL Server: 2005+ (all versions)
-    87	 * - Oracle: Supported (long-standing feature)
-    88	 */
-    89	export const supportsWindowFunctions = async (knex) => {
-    90	  try {
-    91	    const client = knex.client.config.client
-    92	
-    93	    let versionString
-    94	
-    95	    switch (client) {
-    96	      case 'pg':
-    97	      case 'postgresql':
-    98	        // PostgreSQL 8.4+ supports window functions (all modern versions)
-    99	        return true
-   100	
-   101	      case 'mysql':
-   102	      case 'mysql2':
-   103	        try {
-   104	          const row = await knex.first(knex.raw('VERSION() as version'))
-   105	          const mysqlVersion = parseVersion(row.version)
-   106	
-   107	          return mysqlVersion && mysqlVersion.major >= 8
-   108	        } catch (dbError) {
-   109	          console.warn(`[supportsWindowFunctions] Failed to get MySQL version: ${dbError.message}`)
-   110	          return false
-   111	        }
-   112	
-   113	      case 'sqlite3':
-   114	      case 'better-sqlite3':
-   115	        try {
-   116	          versionString = await knex.raw('SELECT sqlite_version() as version')
-   117	          const sqliteVersion = versionString[0].version
-   118	          // SQLite 3.25.0+ supports window functions
-   119	          const parsed = parseVersion(sqliteVersion)
-   120	          return parsed && (parsed.major > 3 || (parsed.major === 3 && parsed.minor >= 25))
-   121	        } catch (dbError) {
-   122	          console.warn(`[supportsWindowFunctions] Failed to get SQLite version: ${dbError.message}`)
-   123	          return false
-   124	        }
-   125	
-   126	      case 'mssql':
-   127	        // SQL Server 2005+ supports window functions
-   128	        return true
-   129	
-   130	      case 'oracledb':
-   131	        // Oracle has supported window functions for a long time
-   132	        return true
-   133	
-   134	      default:
-   135	        // For MariaDB, we need to check if it's actually MariaDB or MySQL
-   136	        if (client.includes('maria')) {
-   137	          try {
-   138	            versionString = await knex.raw('SELECT VERSION() as version')
-   139	            const version = versionString[0].version.toLowerCase()
-   140	            if (version.includes('mariadb')) {
-   141	              const mariaVersion = parseVersion(version)
-   142	              // MariaDB 10.2+ supports window functions
-   143	              return mariaVersion && (mariaVersion.major > 10 ||
-   144	                (mariaVersion.major === 10 && mariaVersion.minor >= 2))
-   145	            }
-   146	          } catch (dbError) {
-   147	            console.warn(`[supportsWindowFunctions] Failed to get MariaDB version: ${dbError.message}`)
-   148	            return false
-   149	          }
-   150	        }
-   151	        return false
-   152	    }
-   153	  } catch (error) {
-   154	    // Log error with context
-   155	    console.error('[supportsWindowFunctions] Unexpected error checking database capabilities:', {
-   156	      error: error.message,
-   157	      stack: error.stack,
-   158	      client: knex?.client?.config?.client || 'unknown'
-   159	    })
-   160	    // If we can't determine, assume no support for safety
-   161	    return false
-   162	  }
-   163	}
-   164	
-   165	/**
-   166	 * Gets database info for error messages and capability checks
-   167	 *
-   168	 * @param {Object} knex - Knex instance
-   169	 * @returns {Promise<Object>} Database info with client and version
-   170	 *
-   171	 * @example
-   172	 * // Input: MySQL connection
-   173	 * const info = await getDatabaseInfo(knex);
-   174	 * // Output: { client: 'MySQL', version: '8.0.33' }
-   175	 *
-   176	 * @example
-   177	 * // Input: PostgreSQL connection
-   178	 * const info = await getDatabaseInfo(knex);
-   179	 * // Output: {
-   180	 * //   client: 'PostgreSQL',
-   181	 * //   version: 'PostgreSQL 14.5 (Ubuntu 14.5-1.pgdg20.04+1)'
-   182	 * // }
-   183	 *
-   184	 * @example
-   185	 * // Input: Connection error case
-   186	 * const info = await getDatabaseInfo(knexWithError);
-   187	 * // Output: {
-   188	 * //   client: 'MySQL',
-   189	 * //   version: 'unknown',
-   190	 * //   error: 'Connection refused'
-   191	 * // }
-   192	 *
-   193	 * @description
-   194	 * Used by:
-   195	 * - Error messages to show which database/version lacks a feature
-   196	 * - Capability detection for feature flags
-   197	 * - Debugging connection issues
-   198	 *
-   199	 * Purpose:
-   200	 * - Provides human-readable database identification
-   201	 * - Helps users understand version requirements
-   202	 * - Enables detailed error messages
-   203	 * - Gracefully handles query failures
-   204	 *
-   205	 * Data flow:
-   206	 * 1. Identifies client type from Knex config
-   207	 * 2. Runs version query specific to each database
-   208	 * 3. Returns formatted info object
-   209	 * 4. Includes error details if version query fails
-   210	 * 5. Falls back to 'unknown' for unsupported databases
-   211	 */
-   212	export const getDatabaseInfo = async (knex) => {
-   213	  try {
-   214	    const client = knex.client.config.client
-   215	
-   216	    let versionString
-   217	    switch (client) {
-   218	      case 'mysql':
-   219	      case 'mysql2':
-   220	        try {
-   221	          const row = await knex.first(knex.raw('VERSION() as version'))
-   222	          return { client: 'MySQL', version: row.version }
-   223	        } catch (dbError) {
-   224	          console.warn(`[getDatabaseInfo] Failed to get MySQL version: ${dbError.message}`)
-   225	          return { client: 'MySQL', version: 'unknown', error: dbError.message }
-   226	        }
-   227	
-   228	      case 'sqlite3':
-   229	      case 'better-sqlite3':
-   230	        try {
-   231	          versionString = await knex.raw('SELECT sqlite_version() as version')
-   232	          return { client: 'SQLite', version: versionString[0].version }
-   233	        } catch (dbError) {
-   234	          console.warn(`[getDatabaseInfo] Failed to get SQLite version: ${dbError.message}`)
-   235	          return { client: 'SQLite', version: 'unknown', error: dbError.message }
-   236	        }
-   237	
-   238	      case 'pg':
-   239	      case 'postgresql':
-   240	        try {
-   241	          versionString = await knex.raw('SELECT version() as version')
-   242	          return { client: 'PostgreSQL', version: versionString.rows[0].version }
-   243	        } catch (dbError) {
-   244	          console.warn(`[getDatabaseInfo] Failed to get PostgreSQL version: ${dbError.message}`)
-   245	          return { client: 'PostgreSQL', version: 'unknown', error: dbError.message }
-   246	        }
-   247	
-   248	      default:
-   249	        return { client, version: 'unknown' }
-   250	    }
-   251	  } catch (error) {
-   252	    // Log unexpected errors
-   253	    console.error('[getDatabaseInfo] Unexpected error getting database info:', {
-   254	      error: error.message,
-   255	      stack: error.stack,
-   256	      client: knex?.client?.config?.client || 'unknown'
-   257	    })
-   258	
-   259	    return {
-   260	      client: knex?.client?.config?.client || 'unknown',
-   261	      version: 'unknown',
-   262	      error: error.message
-   263	    }
-   264	  }
-   265	}

package/audit/evidence/code/critical-pass1/json-rest-api__plugins__core__lib__querying-writing__database-value-normalizers.js.txt

@@ -1,369 +0,0 @@
-     1	/**
-     2	 * Normalizes a date value to appropriate format based on field type
-     3	 *
-     4	 * @param {*} value - The date value from the database
-     5	 * @param {string} type - The field type ('date', 'dateTime', or 'time')
-     6	 * @returns {Date|string|null} Date object for date/dateTime, string for time, or null
-     7	 *
-     8	 * @example
-     9	 * // Input: Already a Date object
-    10	 * normalizeDateValue(new Date('2024-01-15T10:30:00Z'), 'dateTime');
-    11	 * // Output: Date object (unchanged)
-    12	 *
-    13	 * @example
-    14	 * // Input: MySQL datetime string without timezone
-    15	 * normalizeDateValue('2024-01-15 10:30:00', 'dateTime');
-    16	 * // Output: Date object parsed as UTC (2024-01-15T10:30:00Z)
-    17	 *
-    18	 * @example
-    19	 * // Input: Date-only string
-    20	 * normalizeDateValue('2024-01-15', 'date');
-    21	 * // Output: Date object at UTC midnight (2024-01-15T00:00:00Z)
-    22	 *
-    23	 * @example
-    24	 * // Input: Time field (always returns string)
-    25	 * normalizeDateValue('14:30:45', 'time');
-    26	 * // Output: "14:30:45" (string)
-    27	 *
-    28	 * @example
-    29	 * // Input: Date object for time field
-    30	 * normalizeDateValue(new Date('2024-01-15T14:30:45Z'), 'time');
-    31	 * // Output: "14:30:45" (extracts time portion)
-    32	 *
-    33	 * @description
-    34	 * Used by:
-    35	 * - normalizeAttributes to process individual field values
-    36	 * - Applied to all date/time fields fetched from database
-    37	 *
-    38	 * Purpose:
-    39	 * - Handles database-specific date formats (especially MySQL)
-    40	 * - Prevents timezone shifts for date-only fields
-    41	 * - Ensures consistent Date objects across databases
-    42	 * - Keeps time fields as HH:MM:SS strings
-    43	 *
-    44	 * Data flow:
-    45	 * 1. Checks for null/undefined (returns null)
-    46	 * 2. For time fields: ensures HH:MM:SS string format
-    47	 * 3. For date/dateTime: converts to Date objects
-    48	 * 4. Handles MySQL datetime format (no T separator)
-    49	 * 5. Forces UTC interpretation to prevent timezone issues
-    50	 */
-    51	function normalizeDateValue (value, type) {
-    52	  // Handle null/undefined
-    53	  if (value === null || value === undefined) {
-    54	    return null
-    55	  }
-    56	
-    57	  // Handle time type specially - always return as string
-    58	  if (type === 'time') {
-    59	    // If it's already a properly formatted time string, return as-is
-    60	    if (typeof value === 'string' && /^\d{2}:\d{2}:\d{2}/.test(value)) {
-    61	      return value
-    62	    }
-    63	    // If we got a Date object for a time field, extract the time portion
-    64	    if (value instanceof Date) {
-    65	      return value.toISOString().slice(11, 19) // Extract HH:MM:SS
-    66	    }
-    67	    // Try to parse and extract time
-    68	    if (typeof value === 'string' || typeof value === 'number') {
-    69	      const d = new Date(value)
-    70	      if (!isNaN(d.getTime())) {
-    71	        return d.toISOString().slice(11, 19)
-    72	      }
-    73	    }
-    74	    return null
-    75	  }
-    76	
-    77	  // For date and dateTime: Already a Date object? Return as-is
-    78	  if (value instanceof Date) {
-    79	    return value
-    80	  }
-    81	
-    82	  // Handle string values
-    83	  if (typeof value === 'string') {
-    84	    // Detect MySQL datetime format: 'YYYY-MM-DD HH:MM:SS'
-    85	    // These have no T separator and no timezone indicator
-    86	    const isMySQLDateTime = type === 'dateTime' &&
-    87	                           /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}/.test(value) &&
-    88	                           !value.includes('T') &&
-    89	                           !value.includes('Z') &&
-    90	                           !value.includes('+') &&
-    91	                           !value.includes('-', 10) // Don't match date separators
-    92	
-    93	    if (isMySQLDateTime) {
-    94	      // Convert to ISO format and force UTC interpretation
-    95	      // '2024-01-15 10:30:00' becomes '2024-01-15T10:30:00Z'
-    96	      return new Date(value.replace(' ', 'T') + 'Z')
-    97	    }
-    98	
-    99	    // For date-only fields, ensure parsing at UTC midnight
-   100	    // This prevents timezone shifts when parsing dates
-   101	    if (type === 'date' && /^\d{4}-\d{2}-\d{2}$/.test(value)) {
-   102	      return new Date(value + 'T00:00:00Z')
-   103	    }
-   104	  }
-   105	
-   106	  // Handle numeric values (Unix timestamps)
-   107	  if (typeof value === 'number') {
-   108	    return new Date(value)
-   109	  }
-   110	
-   111	  // Try to parse any other format
-   112	  const dateObj = new Date(value)
-   113	
-   114	  // Check if date is valid
-   115	  if (isNaN(dateObj.getTime())) {
-   116	    console.warn(`Invalid date value for field type '${type}': ${value}`)
-   117	    return null // Return null for invalid dates
-   118	  }
-   119	
-   120	  return dateObj
-   121	}
-   122	
-   123	/**
-   124	 * Normalizes database values in an attributes object
-   125	 *
-   126	 * @param {Object} attributes - The attributes object to normalize
-   127	 * @param {Object} schemaStructure - The schema structure defining field types
-   128	 * @returns {Object} The normalized attributes object
-   129	 *
-   130	 * @example
-   131	 * // Input: Raw database values
-   132	 * const attributes = {
-   133	 *   id: 1,
-   134	 *   is_active: 1,              // Boolean as 0/1
-   135	 *   created_at: '2024-01-15 10:30:00',  // MySQL datetime
-   136	 *   birth_date: '1990-05-20',           // Date string
-   137	 *   shift_time: '09:00:00'              // Time string
-   138	 * };
-   139	 *
-   140	 * const schema = {
-   141	 *   is_active: { type: 'boolean' },
-   142	 *   created_at: { type: 'dateTime' },
-   143	 *   birth_date: { type: 'date' },
-   144	 *   shift_time: { type: 'time' }
-   145	 * };
-   146	 *
-   147	 * const normalized = normalizeAttributes(attributes, schema);
-   148	 *
-   149	 * // Output: Properly typed values
-   150	 * // {
-   151	 * //   id: 1,
-   152	 * //   is_active: true,                    // 1 → true
-   153	 * //   created_at: Date('2024-01-15T10:30:00Z'),  // Date object
-   154	 * //   birth_date: Date('1990-05-20T00:00:00Z'),  // Date at midnight UTC
-   155	 * //   shift_time: '09:00:00'                     // String unchanged
-   156	 * // }
-   157	 *
-   158	 * @example
-   159	 * // Input: Boolean edge cases
-   160	 * const attributes = {
-   161	 *   flag1: 0,      // Number 0
-   162	 *   flag2: '1',    // String '1'
-   163	 *   flag3: true,   // Already boolean
-   164	 *   flag4: null    // Null value
-   165	 * };
-   166	 *
-   167	 * const normalized = normalizeAttributes(attributes, {
-   168	 *   flag1: { type: 'boolean' },
-   169	 *   flag2: { type: 'boolean' },
-   170	 *   flag3: { type: 'boolean' },
-   171	 *   flag4: { type: 'boolean' }
-   172	 * });
-   173	 *
-   174	 * // Output:
-   175	 * // {
-   176	 * //   flag1: false,  // 0 → false
-   177	 * //   flag2: true,   // '1' → true
-   178	 * //   flag3: true,   // unchanged
-   179	 * //   flag4: null    // null preserved
-   180	 * // }
-   181	 *
-   182	 * @description
-   183	 * Used by:
-   184	 * - normalizeRecordAttributes for each record's attributes
-   185	 * - Applied after fetching data from database
-   186	 *
-   187	 * Purpose:
-   188	 * - Handles databases without native boolean support (SQLite, older MySQL)
-   189	 * - Normalizes date formats from different databases
-   190	 * - Ensures consistent data types in API responses
-   191	 * - Preserves null values appropriately
-   192	 *
-   193	 * Data flow:
-   194	 * 1. Creates copy of attributes to avoid mutation
-   195	 * 2. Iterates through each field with schema definition
-   196	 * 3. Normalizes booleans: 1/0 or '1'/'0' to true/false
-   197	 * 4. Normalizes dates using normalizeDateValue
-   198	 * 5. Returns new object with normalized values
-   199	 */
-   200	export function normalizeAttributes (attributes, schemaStructure) {
-   201	  if (!attributes || !schemaStructure) {
-   202	    return attributes
-   203	  }
-   204	
-   205	  const normalized = { ...attributes }
-   206	
-   207	  // Iterate through each attribute
-   208	  for (const [fieldName, value] of Object.entries(attributes)) {
-   209	    const fieldDef = schemaStructure[fieldName]
-   210	
-   211	    // Skip if no field definition found
-   212	    if (!fieldDef) continue
-   213	
-   214	    // Normalize boolean values
-   215	    if (fieldDef.type === 'boolean') {
-   216	      if (value === 1 || value === '1') {
-   217	        normalized[fieldName] = true
-   218	      } else if (value === 0 || value === '0') {
-   219	        normalized[fieldName] = false
-   220	      }
-   221	      // null/undefined remain as-is
-   222	    }
-   223	
-   224	    // Normalize date/dateTime/time values
-   225	    if (fieldDef.type === 'date' || fieldDef.type === 'dateTime' || fieldDef.type === 'time') {
-   226	      normalized[fieldName] = normalizeDateValue(value, fieldDef.type)
-   227	    }
-   228	  }
-   229	
-   230	  return normalized
-   231	}
-   232	
-   233	/**
-   234	 * Normalizes all records in a JSON:API response
-   235	 *
-   236	 * @param {Object} record - The JSON:API response object
-   237	 * @param {Object} scopes - All available scopes for schema lookup
-   238	 * @returns {Object} The response with normalized values
-   239	 *
-   240	 * @example
-   241	 * // Input: JSON:API response with various data types
-   242	 * const response = {
-   243	 *   data: {
-   244	 *     type: 'articles',
-   245	 *     id: '1',
-   246	 *     attributes: {
-   247	 *       title: 'My Article',
-   248	 *       is_published: 1,                    // Boolean as number
-   249	 *       published_at: '2024-01-15 10:00:00' // MySQL datetime
-   250	 *     }
-   251	 *   },
-   252	 *   included: [{
-   253	 *     type: 'users',
-   254	 *     id: '10',
-   255	 *     attributes: {
-   256	 *       name: 'John',
-   257	 *       is_admin: 0,         // Boolean as number
-   258	 *       last_login: '2024-01-14 15:30:00'
-   259	 *     }
-   260	 *   }]
-   261	 * };
-   262	 *
-   263	 * const normalized = normalizeRecordAttributes(response, scopes);
-   264	 *
-   265	 * // Output: All booleans and dates normalized
-   266	 * // {
-   267	 * //   data: {
-   268	 * //     type: 'articles',
-   269	 * //     id: '1',
-   270	 * //     attributes: {
-   271	 * //       title: 'My Article',
-   272	 * //       is_published: true,                        // 1 → true
-   273	 * //       published_at: Date('2024-01-15T10:00:00Z') // Date object
-   274	 * //     }
-   275	 * //   },
-   276	 * //   included: [{
-   277	 * //     type: 'users',
-   278	 * //     id: '10',
-   279	 * //     attributes: {
-   280	 * //       name: 'John',
-   281	 * //       is_admin: false,                          // 0 → false
-   282	 * //       last_login: Date('2024-01-14T15:30:00Z')  // Date object
-   283	 * //     }
-   284	 * //   }]
-   285	 * // }
-   286	 *
-   287	 * @example
-   288	 * // Input: Collection response (array of records)
-   289	 * const response = {
-   290	 *   data: [
-   291	 *     {
-   292	 *       type: 'comments',
-   293	 *       id: '1',
-   294	 *       attributes: { approved: 1, created_at: '2024-01-01 09:00:00' }
-   295	 *     },
-   296	 *     {
-   297	 *       type: 'comments',
-   298	 *       id: '2',
-   299	 *       attributes: { approved: 0, created_at: '2024-01-02 10:00:00' }
-   300	 *     }
-   301	 *   ]
-   302	 * };
-   303	 *
-   304	 * // Each record in the array is normalized
-   305	 *
-   306	 * @description
-   307	 * Used by:
-   308	 * - rest-api-knex-plugin after fetching data, before sending response
-   309	 * - Applied to both GET (single) and QUERY (collection) responses
-   310	 *
-   311	 * Purpose:
-   312	 * - Ensures consistent data types in API responses
-   313	 * - Handles both primary data and included resources
-   314	 * - Works with single records and collections
-   315	 * - Uses schema definitions to determine field types
-   316	 *
-   317	 * Data flow:
-   318	 * 1. Checks if data is array (collection) or object (single)
-   319	 * 2. For each record, looks up its schema by type
-   320	 * 3. Calls normalizeAttributes with schema structure
-   321	 * 4. Processes included array the same way
-   322	 * 5. Returns complete response with normalized values
-   323	 */
-   324	export function normalizeRecordAttributes (record, scopes) {
-   325	  if (!record || !scopes) {
-   326	    return record
-   327	  }
-   328	
-   329	  // Normalize main data records
-   330	  if (record.data) {
-   331	    if (Array.isArray(record.data)) {
-   332	      // Handle array of records (query result)
-   333	      for (const entry of record.data) {
-   334	        const scope = scopes[entry.type]
-   335	        if (scope?.vars?.schemaInfo?.schemaStructure && entry.attributes) {
-   336	          entry.attributes = normalizeAttributes(
-   337	            entry.attributes,
-   338	            scope.vars.schemaInfo.schemaStructure
-   339	          )
-   340	        }
-   341	      }
-   342	    } else {
-   343	      // Handle single record (get result)
-   344	      const entry = record.data
-   345	      const scope = scopes[entry.type]
-   346	      if (scope?.vars?.schemaInfo?.schemaStructure && entry.attributes) {
-   347	        entry.attributes = normalizeAttributes(
-   348	          entry.attributes,
-   349	          scope.vars.schemaInfo.schemaStructure
-   350	        )
-   351	      }
-   352	    }
-   353	  }
-   354	
-   355	  // Normalize included records
-   356	  if (record.included && Array.isArray(record.included)) {
-   357	    for (const entry of record.included) {
-   358	      const scope = scopes[entry.type]
-   359	      if (scope?.vars?.schemaInfo?.schemaStructure && entry.attributes) {
-   360	        entry.attributes = normalizeAttributes(
-   361	          entry.attributes,
-   362	          scope.vars.schemaInfo.schemaStructure
-   363	        )
-   364	      }
-   365	    }
-   366	  }
-   367	
-   368	  return record
-   369	}