@codeyam/codeyam-cli 0.1.0-staging.1669d45 → 0.1.0-staging.323686

package/analyzer-template/packages/ai/src/lib/dataStructure/equivalencyManagers/frameworks/MuiManager.ts

@@ -39,6 +39,203 @@ export class MuiManager implements EquivalencyManager {
 
     // Also check if this scope is inside a DataGrid callback and propagate row property accesses
     this.propagateFromChildScope(scopeNode, scopeDataStructure);
+
+    // NOTE: processGridApiContext, processCreateTheme, and processGridSelector
+    // are now called from finalize() instead of here.
+    // This is because external function calls are only added AFTER postProcess()
+    // runs (in trackFunctionCalls), so getExternalFunctionCallInfo() would return
+    // undefined during postProcess(). See Issue 23.
+  }
+
+  /**
+   * Handle useGridApiContext() calls by adding the expected apiRef structure to the schema.
+   *
+   * useGridApiContext() returns an apiRef that has internal state used by useGridSelector.
+   * When useGridSelector(apiRef, selector) is called, it accesses apiRef.current.state
+   * to extract data like filterModel, sortModel, etc.
+   *
+   * We add the state structure directly to the external function call's schema
+   * to ensure mocks include the necessary paths.
+   */
+  private processGridApiContext(
+    _scopeNode: ScopeNode,
+    scopeDataStructure: ScopeDataStructure,
+  ) {
+    // Find the external function call for useGridApiContext
+    const gridApiContextCall =
+      scopeDataStructure.getExternalFunctionCallInfo('useGridApiContext');
+
+    if (!gridApiContextCall) {
+      return;
+    }
+
+    // Add the state structure that useGridSelector needs to the external function call's schema
+    // useGridSelector reads from apiRef.current.state internally
+    // gridFilterModelSelector reads state.filter.filterModel
+    const basePath = 'useGridApiContext().functionCallReturnValue.current';
+    const statePaths: Record<string, string> = {
+      [`${basePath}.state`]: 'object',
+      [`${basePath}.state.filter`]: 'object',
+      [`${basePath}.state.filter.filterModel`]: 'object',
+      [`${basePath}.state.filter.filterModel.items`]: 'array',
+      // Also add common state paths that might be needed by other selectors
+      [`${basePath}.state.sorting`]: 'object',
+      [`${basePath}.state.sorting.sortModel`]: 'array',
+      [`${basePath}.state.pagination`]: 'object',
+      [`${basePath}.state.pagination.paginationModel`]: 'object',
+      [`${basePath}.state.pagination.paginationModel.page`]: 'number',
+      [`${basePath}.state.pagination.paginationModel.pageSize`]: 'number',
+      [`${basePath}.state.rows`]: 'object',
+      [`${basePath}.state.rows.dataRowIds`]: 'array',
+      [`${basePath}.state.columns`]: 'object',
+      [`${basePath}.state.columns.all`]: 'array',
+    };
+
+    // Add each path to the external function call's schema if it doesn't exist
+    for (const [path, type] of Object.entries(statePaths)) {
+      if (!gridApiContextCall.schema[path]) {
+        gridApiContextCall.schema[path] = type;
+      }
+    }
+  }
+
+  /**
+   * Handle createTheme() calls by adding required MUI theme properties to the schema.
+   *
+   * MUI's ThemeProvider and related components check for specific properties:
+   * - `'$$material' in theme` - validates it's a MUI theme object
+   * - `'colorSchemes' in theme` - checks for color scheme support (MUI v6+)
+   *
+   * Without these properties, ThemeProvider throws:
+   * "TypeError: Cannot use 'in' operator to search for '$$material' in object"
+   * "TypeError: Cannot use 'in' operator to search for 'colorSchemes' in true"
+   *
+   * We add these properties to the createTheme return value schema
+   * to ensure mocks include the necessary properties.
+   */
+  private processCreateTheme(
+    _scopeNode: ScopeNode,
+    scopeDataStructure: ScopeDataStructure,
+  ) {
+    // Find the external function call for createTheme
+    const createThemeCall =
+      scopeDataStructure.getExternalFunctionCallInfo('createTheme');
+
+    if (!createThemeCall) {
+      return;
+    }
+
+    // Use the actual call signature to construct the path
+    // createTheme can be called with various arguments:
+    // - createTheme()
+    // - createTheme(options)
+    // - createTheme(getTheme(false), { components: {} })
+    const callSignature = createThemeCall.callSignature;
+    const basePath = `${callSignature}.functionCallReturnValue`;
+
+    // Add required MUI theme properties
+    const themeProperties: Record<string, string> = {
+      [`${basePath}.$$material`]: 'boolean',
+      [`${basePath}.colorSchemes`]: 'object',
+    };
+
+    for (const [path, type] of Object.entries(themeProperties)) {
+      if (!createThemeCall.schema[path]) {
+        createThemeCall.schema[path] = type;
+      }
+    }
+  }
+
+  /**
+   * Handle useGridSelector(apiRef, selector) calls by adding return value schema.
+   *
+   * useGridSelector is a MUI X Data Grid hook that extracts data from the grid's
+   * internal state using a selector function. It's unique because:
+   * 1. It takes arguments (apiRef and selector), so it's not automatically mocked
+   * 2. But its return value depends on which selector is used
+   * 3. The selector reads from apiRef.current.state
+   *
+   * Common selectors and their return types:
+   * - gridFilterModelSelector -> { items: GridFilterItem[] }
+   * - gridSortModelSelector -> GridSortItem[]
+   * - gridPaginationModelSelector -> { page: number, pageSize: number }
+   * - gridRowCountSelector -> number
+   *
+   * We detect which selector is used from the call signature and add the
+   * appropriate return value schema.
+   */
+  private processGridSelector(
+    _scopeNode: ScopeNode,
+    scopeDataStructure: ScopeDataStructure,
+  ) {
+    // Find external function calls for useGridSelector
+    const gridSelectorCall =
+      scopeDataStructure.getExternalFunctionCallInfo('useGridSelector');
+
+    if (!gridSelectorCall) {
+      return;
+    }
+
+    const callSignature = gridSelectorCall.callSignature;
+    const basePath = `${callSignature}.functionCallReturnValue`;
+
+    // Determine which selector is being used and add appropriate schema
+    if (callSignature.includes('gridFilterModelSelector')) {
+      // gridFilterModelSelector returns { items: GridFilterItem[] }
+      const filterPaths: Record<string, string> = {
+        [basePath]: 'object',
+        [`${basePath}.items`]: 'array',
+        [`${basePath}.items[]`]: 'object',
+        [`${basePath}.items[].field`]: 'string',
+        [`${basePath}.items[].operator`]: 'string',
+        [`${basePath}.items[].value`]: 'array',
+        [`${basePath}.items[].value[]`]: 'string',
+      };
+
+      for (const [path, type] of Object.entries(filterPaths)) {
+        if (!gridSelectorCall.schema[path]) {
+          gridSelectorCall.schema[path] = type;
+        }
+      }
+    } else if (callSignature.includes('gridSortModelSelector')) {
+      // gridSortModelSelector returns GridSortItem[]
+      const sortPaths: Record<string, string> = {
+        [basePath]: 'array',
+        [`${basePath}[]`]: 'object',
+        [`${basePath}[].field`]: 'string',
+        [`${basePath}[].sort`]: 'string',
+      };
+
+      for (const [path, type] of Object.entries(sortPaths)) {
+        if (!gridSelectorCall.schema[path]) {
+          gridSelectorCall.schema[path] = type;
+        }
+      }
+    } else if (callSignature.includes('gridPaginationModelSelector')) {
+      // gridPaginationModelSelector returns { page: number, pageSize: number }
+      const paginationPaths: Record<string, string> = {
+        [basePath]: 'object',
+        [`${basePath}.page`]: 'number',
+        [`${basePath}.pageSize`]: 'number',
+      };
+
+      for (const [path, type] of Object.entries(paginationPaths)) {
+        if (!gridSelectorCall.schema[path]) {
+          gridSelectorCall.schema[path] = type;
+        }
+      }
+    } else if (callSignature.includes('gridRowCountSelector')) {
+      // gridRowCountSelector returns number
+      if (!gridSelectorCall.schema[basePath]) {
+        gridSelectorCall.schema[basePath] = 'number';
+      }
+    } else {
+      // Unknown selector - add generic object return type
+      // This ensures the hook is at least mocked with some structure
+      if (!gridSelectorCall.schema[basePath]) {
+        gridSelectorCall.schema[basePath] = 'object';
+      }
+    }
   }
 
   private processDataGridCallbacks(
@@ -662,6 +859,14 @@ export class MuiManager implements EquivalencyManager {
   }
 
   finalize(_scopeNode: ScopeNode, scopeDataStructure: ScopeDataStructure) {
+    // Process external function call schemas ONCE (not per-scope) since they
+    // are global. These were moved from postProcess() because external function
+    // calls are only available AFTER postProcess() runs (in trackFunctionCalls).
+    // See Issue 23.
+    this.processGridApiContext(_scopeNode, scopeDataStructure);
+    this.processCreateTheme(_scopeNode, scopeDataStructure);
+    this.processGridSelector(_scopeNode, scopeDataStructure);
+
     // Iterate through all scopes (finalize is only called on root)
     for (const [scopeName, scopeNode] of Object.entries(
       scopeDataStructure.scopeNodes,

package/analyzer-template/packages/ai/src/lib/dataStructure/equivalencyManagers/frameworks/ReactFrameworkManager.ts

@@ -239,10 +239,18 @@ export class ReactFrameworkManager implements EquivalencyManager {
             });
           }
 
+          // Get the initial value path (what signature[0] is equivalent to)
+          const initialValuePath = equivalentValues[0].schemaPath;
+          const initialValueScopeName = equivalentValues[0].scopeNodeName;
+
+          // Note: Callback scope tracing (for useState(() => { return prop; }))
+          // is handled in getEquivalentSignatureVariables() where the full
+          // equivalency database is available for deep tracing.
+
           scopeDataStructure.addEquivalency(
             relevantUseStateInfo.value,
-            equivalentValues[0].schemaPath,
-            scopeNode.name,
+            initialValuePath,
+            initialValueScopeName,
             scopeNode,
             'useState value equivalency',
           );

package/analyzer-template/packages/ai/src/lib/dataStructure/helpers/cleanKnownObjectFunctions.ts

@@ -35,6 +35,29 @@ const getParts = (path: string): string[] => {
   return parts;
 };
 
+/**
+ * Clear the module-level cache.
+ * Call this between entity analyses to prevent unbounded memory growth.
+ */
+export function clearCleanKnownObjectFunctionsCache(): {
+  count: number;
+  estimatedBytes: number;
+} {
+  let totalBytes = 0;
+  for (const [key, value] of partsCache) {
+    // Key is a string, value is string[] - estimate UTF-16 encoding (2 bytes per char)
+    totalBytes += key.length * 2;
+    for (const part of value) {
+      totalBytes += part.length * 2;
+    }
+    // Add overhead for array and Map entry (~50 bytes per entry)
+    totalBytes += 50;
+  }
+  const count = partsCache.size;
+  partsCache.clear();
+  return { count, estimatedBytes: totalBytes };
+}
+
 /** pre-compute the prototype-method sets once per module load */
 const protoMethodSets: Record<PrimitiveKind, Set<string>> = {
   array: new Set(

package/analyzer-template/packages/ai/src/lib/dataStructure/helpers/cleanNonObjectFunctions.ts

@@ -119,6 +119,17 @@ const stringMethodsSet = new Set([
 ]);
 export const allMethodsSet = new Set([...arrayMethodsSet, ...stringMethodsSet]);
 
+// Methods that exist in both stringMethodsSet and arrayMethodsSet.
+// When ONLY these methods are called on an object, we can't determine if it's a string or array.
+// Don't infer 'string' type from these alone - leave as 'unknown' for other type resolution.
+const stringArrayAmbiguousMethodsSet = new Set([
+  'includes', // exists in both String.includes() and Array.includes()
+  'indexOf', // exists in both String.indexOf() and Array.indexOf()
+  'lastIndexOf', // exists in both String.lastIndexOf() and Array.lastIndexOf()
+  'concat', // exists in both String.concat() and Array.concat()
+  'slice', // exists in both String.slice() and Array.slice()
+]);
+
 const signatureKeyWord = 'signature';
 const returnValueKeyWord = 'functionCallReturnValue';
 
@@ -140,6 +151,29 @@ function cachedSplit(str: string): string[] {
   return parts;
 }
 
+/**
+ * Clear the module-level cache.
+ * Call this between entity analyses to prevent unbounded memory growth.
+ */
+export function clearCleanNonObjectFunctionsCache(): {
+  count: number;
+  estimatedBytes: number;
+} {
+  let totalBytes = 0;
+  for (const [key, value] of splitCache) {
+    // Key is a string, value is string[] - estimate UTF-16 encoding (2 bytes per char)
+    totalBytes += key.length * 2;
+    for (const part of value) {
+      totalBytes += part.length * 2;
+    }
+    // Add overhead for array and Map entry (~50 bytes per entry)
+    totalBytes += 50;
+  }
+  const count = splitCache.size;
+  splitCache.clear();
+  return { count, estimatedBytes: totalBytes };
+}
+
 // --- Prefix Index for O(1) lookup in subPathIsFromKnownObject ---
 // Maps parent prefix -> array of last parts (method names without parens)
 type PrefixIndex = Map<string, string[]>;
@@ -697,7 +731,14 @@ function handleFunctionMapping(
         allProperties.every((prop) => stringMethodsSet.has(getMethodName(prop)))
       ) {
         if (allProperties.every((prop) => isValidStringMethod(prop))) {
-          keyMapping[previousPath] = 'string';
+          // Don't infer string if ALL methods are ambiguous between string and array
+          // (like includes, indexOf, concat, slice - these exist on both types)
+          const hasOnlyStringArrayAmbiguousMethods = allProperties.every(
+            (prop) => stringArrayAmbiguousMethodsSet.has(getMethodName(prop)),
+          );
+          if (!hasOnlyStringArrayAmbiguousMethods) {
+            keyMapping[previousPath] = 'string';
+          }
         } else {
           return false;
         }
@@ -718,19 +759,36 @@ function handleFunctionMapping(
 
     // Don't add [] element for ambiguous methods without other array evidence
     // Also don't add [] if the path was already identified as a string type
+    // Also don't add [] if the method is ambiguous between string and array (like includes)
     const methodName = getMethodName(lastPart);
     const isAmbiguousMethod = ambiguousArrayMethodsSet.has(methodName);
+    const isStringArrayAmbiguous =
+      stringArrayAmbiguousMethodsSet.has(methodName);
     const isStringType = keyMapping[previousPath] === 'string';
     if (
       !isValidFunctionCall(previousPart) &&
       arrayMethodsSet.has(methodName) &&
       !keyMapping[previousPath + '[]'] &&
       !isAmbiguousMethod &&
+      !isStringArrayAmbiguous &&
       !isStringType
     ) {
       keyMapping[previousPath + '[]'] = 'unknown';
     }
 
+    // For primitive-returning methods (like includes, indexOf, some, every),
+    // also delete the .functionCallReturnValue children since the return value
+    // is just a primitive (boolean/number) and not useful data.
+    // For other methods (like filter, map), keep children for transformation.
+    const isPrimitiveReturning = primitiveReturningMethodsSet.has(methodName);
+    if (isPrimitiveReturning) {
+      for (const otherPath of Object.keys(keyMapping)) {
+        if (otherPath.startsWith(path + '.')) {
+          delete keyMapping[otherPath];
+        }
+      }
+    }
+
     delete keyMapping[path];
     return true;
   }
@@ -956,14 +1014,34 @@ function clearAttributes(
     }
   }
 
+  // Track paths that have primitive-returning method calls (like includes, some, every)
+  // These need cleanup even if we can't determine the base type
+  const pathsWithPrimitiveReturningMethods = new Set<string>();
+
   for (const key in functionCallsOnObjects) {
     const functionCalls = functionCallsOnObjects[key];
+
+    // Check if any method calls are primitive-returning
+    const hasPrimitiveReturningMethods = functionCalls.some((f) =>
+      primitiveReturningMethodsSet.has(getMethodName(f)),
+    );
+    if (hasPrimitiveReturningMethods) {
+      pathsWithPrimitiveReturningMethods.add(key);
+    }
+
     if (
       functionCalls.every(
         (f) => stringMethodsSet.has(getMethodName(f)) && isValidStringMethod(f),
       )
     ) {
-      mapping[key] = 'string';
+      // Don't infer string if ALL methods are ambiguous between string and array
+      // (like includes, indexOf, concat, slice - these exist on both types)
+      const hasOnlyStringArrayAmbiguousMethods = functionCalls.every((f) =>
+        stringArrayAmbiguousMethodsSet.has(getMethodName(f)),
+      );
+      if (!hasOnlyStringArrayAmbiguousMethods) {
+        mapping[key] = 'string';
+      }
     } else if (
       functionCalls.every(
         (f) => arrayMethodsSet.has(getMethodName(f)) && isValidArrayMethod(f),
@@ -1000,6 +1078,13 @@ function clearAttributes(
     }
   }
 
+  // Also add paths with primitive-returning method calls (like includes, some, every)
+  // to knownBasePaths so their method call paths get cleaned up, even if we couldn't
+  // determine the base type (e.g., when only ambiguous methods like includes are used)
+  for (const path of pathsWithPrimitiveReturningMethods) {
+    knownBasePaths.add(path);
+  }
+
   for (const key in mapping) {
     const keyParts = cachedSplit(key);
     for (const basePath of knownBasePaths) {

package/analyzer-template/packages/ai/src/lib/dataStructure/helpers/fillInSchemaGapsAndUnknowns.ts

@@ -486,6 +486,17 @@ const STRONG_ARRAY_METHODS = new Set([
   'with',
 ]);
 
+/**
+ * Check if a method call argument looks like a string literal.
+ * String literals start with ' or " (e.g., includes('foo'), indexOf("bar"))
+ */
+function hasStringLiteralArgument(methodCall: string): boolean {
+  const parenIndex = methodCall.indexOf('(');
+  if (parenIndex === -1) return false;
+  const arg = methodCall.slice(parenIndex + 1).trim();
+  return arg.startsWith("'") || arg.startsWith('"') || arg.startsWith('`');
+}
+
 function checkIfKnownType(
   key: string,
   functionAndAttributesKeysMapping: Record<string, string[]>,
@@ -496,6 +507,7 @@ function checkIfKnownType(
   let hasOnlyAmbiguousArrayMethods = true;
   let hasLengthAccess = false;
   let hasArrayStringAmbiguousMethod = false;
+  let hasIncludesOrIndexOfWithVariable = false;
 
   for (const functionOrAttributeName of functionAndAttributesKeysMapping[key] ??
     []) {
@@ -519,6 +531,17 @@ function checkIfKnownType(
       hasArrayStringAmbiguousMethod = true;
     }
 
+    // Check if .includes() or .indexOf() is called with a variable argument (not a string literal).
+    // Pattern: arr.includes(item) -> likely array (checking if item exists)
+    // Pattern: str.includes('substring') -> likely string (checking for substring)
+    if (
+      (methodName === 'includes' || methodName === 'indexOf') &&
+      functionOrAttributeName.includes('(') &&
+      !hasStringLiteralArgument(functionOrAttributeName)
+    ) {
+      hasIncludesOrIndexOfWithVariable = true;
+    }
+
     // Check if this is strong evidence of an array (unambiguous array methods)
     if (STRONG_ARRAY_METHODS.has(methodName)) {
       hasStrongArrayEvidence = true;
@@ -549,18 +572,20 @@ function checkIfKnownType(
     return 'array';
   }
 
-  // When we have BOTH .length AND an ambiguous method like .includes(),
-  // prefer array. This pattern (checking .length AND calling .includes)
-  // is very common with arrays (e.g., arr.length > 0 && arr.includes(x))
-  // but rare with strings (you'd typically just call str.includes(x))
-  if (isArray && hasLengthAccess && hasArrayStringAmbiguousMethod) {
+  // When .includes() or .indexOf() is called with a variable argument AND we have .length,
+  // prefer array. This pattern (arr.length > 0 && arr.includes(item)) is common for arrays.
+  // But str.includes('literal') is common for strings - that case is handled by hasStringLiteralArgument.
+  if (isArray && hasLengthAccess && hasIncludesOrIndexOfWithVariable) {
     return 'array';
   }
 
+  // When both array and string are possible, prefer string.
+  // Strings have .length, .slice(), .includes(), etc. just like arrays.
+  // We only infer 'array' if we have STRONG evidence (like .map, .filter, .reduce).
   if (isString) return 'string';
 
-  // Only infer array if we have strong evidence OR not only ambiguous methods
-  // This prevents router.push() from being incorrectly inferred as an array
+  // Only infer array if we have strong evidence (already handled above)
+  // or non-ambiguous array methods that don't exist on strings
   if (isArray && !hasOnlyAmbiguousArrayMethods) {
     return 'array';
   }

package/analyzer-template/packages/ai/src/lib/dataStructure/helpers/fixNullIdsBySchema.ts

@@ -0,0 +1,129 @@
+import { awsLog } from '~codeyam/utils';
+
+/**
+ * Fixes null values for ID fields when the schema indicates they should be non-null numbers.
+ *
+ * The LLM sometimes generates `null` for ID fields (e.g., `"id": null`) when the schema
+ * type is `"number"` or `"number | undefined"` (but NOT `"number | null"`). This causes
+ * runtime issues when code checks `if (!data?.id)` expecting a truthy value.
+ *
+ * This function traverses data and schema together:
+ * - If field name looks like an ID field AND value is null AND schema doesn't allow null,
+ *   replace with a valid default value (1 for numbers, generated UUID for strings)
+ *
+ * @param data The data object with potential null ID values
+ * @param schema The schema describing expected types
+ * @param path Current path in the data structure (for logging)
+ * @returns The data with null IDs fixed (mutates original)
+ */
+export default function fixNullIdsBySchema<T>(
+  data: T,
+  schema: unknown,
+  path: string = '',
+): T {
+  // Handle null/undefined data
+  if (data === null || data === undefined) {
+    return data;
+  }
+
+  // Only process objects
+  if (typeof data !== 'object') {
+    return data;
+  }
+
+  // Handle arrays
+  if (Array.isArray(data)) {
+    // For arrays, the schema should be an array with one element describing the item type
+    const itemSchema = Array.isArray(schema) ? schema[0] : undefined;
+    for (let i = 0; i < data.length; i++) {
+      data[i] = fixNullIdsBySchema(data[i], itemSchema, `${path}[${i}]`);
+    }
+    return data;
+  }
+
+  // Handle objects
+  const dataObj = data as Record<string, unknown>;
+  const schemaObj = schema as Record<string, unknown> | undefined;
+
+  for (const key of Object.keys(dataObj)) {
+    const value = dataObj[key];
+    const fieldSchema = schemaObj?.[key];
+    const fieldPath = path ? `${path}.${key}` : key;
+
+    if (value === null && isIdField(key)) {
+      // Check if schema indicates this should be a non-null number
+      const replacement = getIdReplacementValue(fieldSchema);
+      if (replacement !== null) {
+        dataObj[key] = replacement;
+        awsLog(
+          `CodeYam: Fixed null ID field "${fieldPath}": null -> ${replacement}`,
+        );
+      }
+    } else if (typeof value === 'object' && value !== null) {
+      // Recursively process nested objects/arrays
+      fixNullIdsBySchema(value, fieldSchema, fieldPath);
+    }
+  }
+
+  return data;
+}
+
+/**
+ * Pattern for field names that are likely ID fields.
+ * Matches: id, Id, ID, userId, user_id, quoteId, quote_id, etc.
+ */
+const ID_FIELD_PATTERNS = [
+  /^id$/i, // Exact match for "id", "Id", "ID"
+  /Id$/, // Ends with "Id" (camelCase): userId, quoteId
+  /_id$/i, // Ends with "_id" (snake_case): user_id, quote_id
+  /^.*_id$/i, // Contains "_id": some_object_id
+];
+
+/**
+ * Determines if a field name looks like an ID field.
+ */
+function isIdField(fieldName: string): boolean {
+  return ID_FIELD_PATTERNS.some((pattern) => pattern.test(fieldName));
+}
+
+/**
+ * Gets the replacement value for a null ID based on schema type.
+ * Returns null if the schema allows null values (no replacement needed).
+ *
+ * @param fieldSchema The schema type for the field
+ * @returns Replacement value (1 for numbers, generated string for strings) or null if no replacement
+ */
+function getIdReplacementValue(fieldSchema: unknown): number | string | null {
+  // If no schema for this field, be conservative - don't replace
+  if (fieldSchema === undefined || fieldSchema === null) {
+    return null;
+  }
+
+  // If schema is a string type definition
+  if (typeof fieldSchema === 'string') {
+    // If schema explicitly allows null, don't replace
+    if (fieldSchema.includes('null')) {
+      return null;
+    }
+
+    // If schema is a number type, return 1 as default
+    if (
+      fieldSchema === 'number' ||
+      fieldSchema.startsWith('number') ||
+      fieldSchema.includes('number')
+    ) {
+      return 1;
+    }
+
+    // If schema is a string type, return a generated ID
+    if (
+      fieldSchema === 'string' ||
+      fieldSchema.startsWith('string') ||
+      fieldSchema.includes('string')
+    ) {
+      return 'id-1';
+    }
+  }
+
+  return null;
+}