@codeyam/codeyam-cli 0.1.0-staging.d0ad4ae → 0.1.0-staging.d3e886e

package/analyzer-template/packages/analyze/src/lib/files/scenarios/mergeValidatedDataStructures.ts

@@ -2,6 +2,49 @@ import { splitOutsideParenthesesAndArrays } from '~codeyam/ai';
 import { JsonTypeDefinition, ReadonlyAnalysisMap } from '~codeyam/types';
 import { awsLog } from '~codeyam/utils';
 
+/**
+ * Deep merge for JsonTypeDefinition schemas.
+ * Only recursively merges when BOTH sides are plain objects (not arrays, not primitives).
+ * This is different from the general deepMerge which is designed for data values -
+ * here we're merging type schemas where leaf values are strings like "boolean" or "function".
+ *
+ * When types are incompatible (e.g., array vs object), prefer keeping the base value
+ * since it was set first from the root entity's validatedVariables.
+ */
+function deepMergeSchemas(
+  base: JsonTypeDefinition,
+  override: JsonTypeDefinition,
+): JsonTypeDefinition {
+  // If override is null/undefined, return base
+  if (override === null || override === undefined) return base;
+  // If base is null/undefined, return override
+  if (base === null || base === undefined) return override;
+
+  // Only recursively merge if BOTH are plain objects (not arrays, not primitives)
+  const baseIsPlainObject =
+    typeof base === 'object' && !Array.isArray(base) && base !== null;
+  const overrideIsPlainObject =
+    typeof override === 'object' &&
+    !Array.isArray(override) &&
+    override !== null;
+
+  if (baseIsPlainObject && overrideIsPlainObject) {
+    const result: JsonTypeDefinition = { ...base };
+    for (const key in override) {
+      result[key] = deepMergeSchemas(
+        base[key] as JsonTypeDefinition,
+        override[key] as JsonTypeDefinition,
+      );
+    }
+    return result;
+  }
+
+  // For incompatible types (array vs object, string vs object, etc.), keep base
+  // This ensures the root entity's structure is preserved when a dependency
+  // has a different view of the same mock
+  return base;
+}
+
 export function mergeInStructure(
   name: string | number,
   key: string | number,
@@ -155,10 +198,10 @@ export default function mergeValidatedDataStructures({
       }
       activeValidatedParts = validatedVariables[usedName] as JsonTypeDefinition;
     }
-    dataForMocks = {
-      ...dataForMocks,
-      ...validatedData,
-    };
+    // Use deep merge instead of shallow spread to preserve previously merged
+    // dependency data. This fixes Issue #15 where multiple dependencies with
+    // the same top-level key (e.g., trpc) would overwrite each other.
+    dataForMocks = deepMergeSchemas(dataForMocks, validatedData);
   };
 
   for (const dependency of relevantDependencies) {
@@ -181,13 +224,15 @@ export default function mergeValidatedDataStructures({
     for (const mockName in dependencyDataForMocks) {
       addMockDataForEntity(mockName);
 
-      // If addMockDataForEntity didn't find matching entries in validatedVariables,
-      // copy the dependency's value directly. This handles cases like usePathname()
-      // which returns a simple "string" type but isn't in the root's validatedVariables.
-      if (dataForMocks[mockName] === undefined) {
-        dataForMocks[mockName] = dependencyDataForMocks[
-          mockName
-        ] as JsonTypeDefinition;
+      // Always deep merge the dependency's value to preserve nested structures.
+      // This handles cases like usePathname() which returns a simple "string" type,
+      // AND cases like trpc where both root and dependency have nested data that
+      // needs to be combined (e.g., trpc.quote from root + trpc.fastener.getAttributeValues
+      // from dependency).
+      if (dependencyDataForMocks[mockName] !== undefined) {
+        dataForMocks = deepMergeSchemas(dataForMocks, {
+          [mockName]: dependencyDataForMocks[mockName],
+        } as JsonTypeDefinition);
       }
     }
   }

package/analyzer-template/packages/analyze/src/lib/files/scenarios/propagateArrayItemSchemas.ts

@@ -0,0 +1,474 @@
+import { splitOutsideParenthesesAndArrays } from '~codeyam/ai';
+import { DataStructure } from '~codeyam/types';
+
+// Safety limits to prevent combinatorial explosion
+const MAX_SCHEMA_PATHS = 15000; // Don't propagate if schema already has this many paths
+const MAX_PATHS_TO_ADD = 5000; // Stop adding paths after this many new paths
+const MAX_ARRAY_NESTING_DEPTH = 3; // Don't propagate paths with more than this many [] levels
+
+/**
+ * Count the number of array levels in a path.
+ * e.g., "entities[].analyses[].scenarios[]" has 3 levels
+ */
+function countArrayLevels(path: string): number {
+  return (path.match(/\[\]/g) || []).length;
+}
+
+/**
+ * Check if appending suffix to prefix would create a recursive path.
+ * A path is recursive if it contains the same array name twice.
+ * e.g., "entities[].analyses[].scenarios[].analyses[]" has "analyses" twice.
+ */
+function wouldCreateRecursivePath(prefix: string, suffix: string): boolean {
+  // Extract array names from prefix (names that appear before [])
+  const prefixArrayNames = new Set<string>();
+  const prefixMatches = prefix.matchAll(/\.?([a-zA-Z_][a-zA-Z0-9_]*)\[\]/g);
+  for (const match of prefixMatches) {
+    prefixArrayNames.add(match[1].toLowerCase());
+  }
+
+  // Check if any array name in suffix already exists in prefix
+  const suffixMatches = suffix.matchAll(/\.?([a-zA-Z_][a-zA-Z0-9_]*)\[\]/g);
+  for (const match of suffixMatches) {
+    if (prefixArrayNames.has(match[1].toLowerCase())) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Propagates array item schemas between arrays that likely have the same type.
+ *
+ * When the Rust analyzer traces property accesses, it may trace item properties for
+ * one array but not another, even though they have the same TypeScript type. This
+ * happens when:
+ * - One array is accessed directly in code (e.g., `entities.forEach(e => e.name)`)
+ * - Another array is only used as a fallback in an OR expression
+ *   (e.g., `const displayEntities = currentlyExecuting?.entities || currentEntities`)
+ *
+ * In this case, `entities` gets `entities[]`, `entities[].name`, etc. traced,
+ * but `currentEntities` only gets `currentEntities: "array"` with no item schema.
+ *
+ * This function finds arrays without item schemas and copies item schemas from
+ * other arrays that appear to have the same type based on naming conventions.
+ *
+ * Heuristics for matching arrays:
+ * 1. Same suffix (e.g., `currentEntities` matches `entities`, `queueJobs[].entities` matches `entities`)
+ * 2. One name is a plural/singular form of the other
+ */
+export default function propagateArrayItemSchemas(
+  dependencySchemas: DataStructure['dependencySchemas'],
+): void {
+  if (!dependencySchemas) {
+    console.log('[PROPAGATE] No dependencySchemas provided');
+    return;
+  }
+
+  // Log what we're working with
+  const packages = Object.keys(dependencySchemas);
+  console.log('[PROPAGATE] Processing packages:', packages);
+
+  // PHASE 1: Run per-entity propagation (original behavior)
+  // This propagates array item schemas within each entity's own schema.
+  console.log('[PROPAGATE] === PHASE 1: Per-entity propagation ===');
+  for (const filePath in dependencySchemas) {
+    for (const entityName in dependencySchemas[filePath]) {
+      const schema = dependencySchemas[filePath][entityName]?.returnValueSchema;
+      if (!schema) {
+        continue;
+      }
+      const beforeCount = Object.keys(schema).length;
+
+      propagateArrayItemSchemasInSchema(schema);
+
+      const afterCount = Object.keys(schema).length;
+
+      if (beforeCount !== afterCount) {
+        console.log(
+          `[PROPAGATE] PHASE1 ${filePath}/${entityName}: ${beforeCount} -> ${afterCount} paths`,
+        );
+      }
+    }
+  }
+
+  // PHASE 2: Cross-entity propagation within the same package
+  // When we have call-specific entities like `useLoaderData<typeof loader>()`,
+  // they may be missing array item paths that exist in the base entity `useLoaderData`.
+  // Copy array item paths from base entities to call-specific entities.
+  console.log('[PROPAGATE] === PHASE 2: Cross-entity propagation ===');
+  for (const filePath in dependencySchemas) {
+    const entities = dependencySchemas[filePath];
+    const entityNames = Object.keys(entities);
+
+    for (const entityName of entityNames) {
+      // Check if this is a call-specific entity (ends with function call syntax)
+      if (!entityName.includes('(')) {
+        continue;
+      }
+
+      // Find the base entity name (e.g., "useLoaderData<typeof loader>()" -> "useLoaderData")
+      const baseEntityName = entityName.split(/[(<]/)[0];
+
+      if (!baseEntityName || !entities[baseEntityName]) {
+        console.log(
+          `[PROPAGATE] PHASE2: No base entity '${baseEntityName}' for '${entityName}'`,
+        );
+        continue;
+      }
+
+      const callSpecificSchema = entities[entityName]?.returnValueSchema;
+      const baseSchema = entities[baseEntityName]?.returnValueSchema;
+
+      if (!callSpecificSchema || !baseSchema) {
+        continue;
+      }
+
+      console.log(
+        `[PROPAGATE] PHASE2: Copying from '${baseEntityName}' (${Object.keys(baseSchema).length} paths) to '${entityName}' (${Object.keys(callSpecificSchema).length} paths)`,
+      );
+
+      // Check what paths exist in base but not in call-specific
+      const baseHasEntitiesFilePath = Object.keys(baseSchema).some((p) =>
+        p.includes('currentlyExecuting.entities[].filePath'),
+      );
+      const callSpecificHasEntitiesFilePath = Object.keys(
+        callSpecificSchema,
+      ).some((p) => p.includes('currentlyExecuting.entities[].filePath'));
+
+      console.log(
+        `[PROPAGATE] PHASE2: base has currentlyExecuting.entities[].filePath: ${baseHasEntitiesFilePath}`,
+      );
+      console.log(
+        `[PROPAGATE] PHASE2: callSpecific has currentlyExecuting.entities[].filePath: ${callSpecificHasEntitiesFilePath}`,
+      );
+
+      // Copy any array item paths from base schema to call-specific schema
+      // that are missing in the call-specific schema
+      let copiedCount = 0;
+      const copiedPaths: string[] = [];
+      for (const path in baseSchema) {
+        // Only copy paths that include array element notation
+        if (!path.includes('[]')) continue;
+        // Only copy if not already present
+        if (callSpecificSchema[path]) continue;
+
+        callSpecificSchema[path] = baseSchema[path];
+        copiedCount++;
+
+        // Track specific paths we care about
+        if (path.includes('currentlyExecuting.entities[]')) {
+          copiedPaths.push(path);
+        }
+      }
+
+      console.log(`[PROPAGATE] PHASE2: Copied ${copiedCount} paths`);
+      if (copiedPaths.length > 0) {
+        console.log(
+          '[PROPAGATE] PHASE2: Copied currentlyExecuting.entities paths:',
+          copiedPaths,
+        );
+      }
+
+      // Verify after copy
+      const afterHasEntitiesFilePath = Object.keys(callSpecificSchema).some(
+        (p) => p.includes('currentlyExecuting.entities[].filePath'),
+      );
+      console.log(
+        `[PROPAGATE] PHASE2: AFTER copy, callSpecific has currentlyExecuting.entities[].filePath: ${afterHasEntitiesFilePath}`,
+      );
+    }
+  }
+
+  console.log('[PROPAGATE] === DONE ===');
+}
+
+/**
+ * Helper to extract the "base name" from an array path for matching purposes.
+ * e.g., "currentEntities" -> "entities"
+ * e.g., "validCurrentEntities" -> "entities"
+ * e.g., "queueJobs[].entities" -> "entities"
+ * e.g., "entities" -> "entities"
+ */
+function extractArrayBaseName(path: string): string {
+  // Get the last segment of the path (after the last dot, if any)
+  const parts = splitOutsideParenthesesAndArrays(path);
+  const lastPart = parts[parts.length - 1] || path;
+
+  // Remove trailing [] if present
+  const name = lastPart.replace(/\[\]$/, '');
+
+  // Common prefixes that can be stripped for matching
+  const prefixes = [
+    'current',
+    'valid',
+    'filtered',
+    'all',
+    'new',
+    'old',
+    'display',
+    'active',
+    'selected',
+    'loaded',
+    'fetched',
+  ];
+
+  // Keep stripping prefixes until no more match
+  let baseName = name;
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const prefix of prefixes) {
+      if (
+        baseName.toLowerCase().startsWith(prefix) &&
+        baseName.length > prefix.length
+      ) {
+        // Remove prefix and lowercase the first char
+        baseName = baseName.slice(prefix.length);
+        baseName = baseName.charAt(0).toLowerCase() + baseName.slice(1);
+        changed = true;
+        break;
+      }
+    }
+  }
+
+  return baseName.toLowerCase();
+}
+
+/**
+ * Check if two array names likely refer to the same type.
+ */
+function arrayNamesMatch(name1: string, name2: string): boolean {
+  const base1 = extractArrayBaseName(name1);
+  const base2 = extractArrayBaseName(name2);
+
+  if (base1 === base2) return true;
+
+  // Check singular/plural relationships
+  if (base1 + 's' === base2 || base2 + 's' === base1) return true;
+  if (base1 + 'es' === base2 || base2 + 'es' === base1) return true;
+
+  // Handle "ies" plural (e.g., entity -> entities)
+  if (base1.endsWith('ies') && base1.slice(0, -3) + 'y' === base2) return true;
+  if (base2.endsWith('ies') && base2.slice(0, -3) + 'y' === base1) return true;
+
+  return false;
+}
+
+/**
+ * Count the number of item properties an array has in the schema.
+ */
+function countArrayItemProperties(
+  schema: Record<string, string>,
+  arrayPath: string,
+): number {
+  const elementPrefix = arrayPath + '[]';
+  let count = 0;
+  for (const path in schema) {
+    if (path.startsWith(elementPrefix)) {
+      count++;
+    }
+  }
+  return count;
+}
+
+function propagateArrayItemSchemasInSchema(
+  schema: Record<string, string>,
+): void {
+  // Safety check: Don't propagate if schema is already very large
+  const initialPathCount = Object.keys(schema).length;
+  if (initialPathCount > MAX_SCHEMA_PATHS) {
+    console.log(
+      `[PROPAGATE] SKIPPING: Schema already has ${initialPathCount} paths (limit: ${MAX_SCHEMA_PATHS})`,
+    );
+    return;
+  }
+
+  let totalPathsAdded = 0;
+
+  // Find all array paths and categorize them
+  const arraysWithItemSchema: string[] = [];
+  const arraysWithoutItemSchema: string[] = [];
+
+  for (const path in schema) {
+    const type = schema[path];
+
+    // Check if this is an array type (including "array | undefined", etc.)
+    if (!type.startsWith('array')) continue;
+
+    // Check if this is an array element path (ends with [])
+    if (path.endsWith('[]')) continue;
+
+    // This is an array declaration, not an element. Check if it has item schema.
+    const elementPath = path + '[]';
+    if (schema[elementPath]) {
+      arraysWithItemSchema.push(path);
+    } else {
+      arraysWithoutItemSchema.push(path);
+    }
+  }
+
+  // For each array without item schema, try to find a matching array with schema
+  for (const emptyArrayPath of arraysWithoutItemSchema) {
+    let bestMatch: string | null = null;
+    let bestMatchScore = 0;
+
+    for (const richArrayPath of arraysWithItemSchema) {
+      if (!arrayNamesMatch(emptyArrayPath, richArrayPath)) continue;
+
+      // Score the match - prefer shorter paths (less nested) as they're more likely primary
+      // and prefer paths that are more similar in structure
+      const emptyDepth = emptyArrayPath.split('.').length;
+      const richDepth = richArrayPath.split('.').length;
+      const depthDiff = Math.abs(emptyDepth - richDepth);
+      const score = 100 - depthDiff * 10 - richDepth;
+
+      if (score > bestMatchScore) {
+        bestMatchScore = score;
+        bestMatch = richArrayPath;
+      }
+    }
+
+    if (bestMatch) {
+      // Safety check: Stop if we've added too many paths
+      if (totalPathsAdded >= MAX_PATHS_TO_ADD) {
+        console.log(
+          `[PROPAGATE] STOPPING FIRST PASS: Already added ${totalPathsAdded} paths (limit: ${MAX_PATHS_TO_ADD})`,
+        );
+        break;
+      }
+
+      // Copy item schema from the rich array to the empty array
+      const richElementPrefix = bestMatch + '[]';
+      const emptyElementPrefix = emptyArrayPath + '[]';
+
+      // Find all paths that start with the rich array's element path
+      const pathsToCheck = Object.keys(schema);
+
+      for (const path of pathsToCheck) {
+        if (path.startsWith(richElementPrefix)) {
+          const suffix = path.slice(richElementPrefix.length);
+          const newPath = emptyElementPrefix + suffix;
+
+          // Skip if this would create a recursive path (suffix contains array names that are already in the prefix)
+          if (wouldCreateRecursivePath(emptyElementPrefix, suffix)) {
+            continue;
+          }
+
+          // Skip if the new path would have too many array levels
+          if (countArrayLevels(newPath) > MAX_ARRAY_NESTING_DEPTH) {
+            continue;
+          }
+
+          // Safety check: Stop if we've added too many paths
+          if (totalPathsAdded >= MAX_PATHS_TO_ADD) {
+            break;
+          }
+
+          // Only add if the path doesn't already exist
+          if (!schema[newPath]) {
+            schema[newPath] = schema[path];
+            totalPathsAdded++;
+          }
+        }
+      }
+    }
+  }
+
+  // SECOND PASS: For arrays that have PARTIAL item schemas (some but not all properties),
+  // propagate missing properties from matching arrays with more complete schemas.
+  // This handles the case where e.g. currentlyExecuting.entities has sha traced
+  // but is missing filePath, name, etc. that entities[] has.
+
+  // Safety check: Skip second pass if we've already hit the limit
+  if (totalPathsAdded >= MAX_PATHS_TO_ADD) {
+    console.log(
+      `[PROPAGATE] SKIPPING SECOND PASS: Already added ${totalPathsAdded} paths`,
+    );
+    return;
+  }
+
+  for (const partialArrayPath of arraysWithItemSchema) {
+    // Safety check: Stop if we've added too many paths
+    if (totalPathsAdded >= MAX_PATHS_TO_ADD) {
+      console.log(
+        `[PROPAGATE] STOPPING SECOND PASS: Already added ${totalPathsAdded} paths (limit: ${MAX_PATHS_TO_ADD})`,
+      );
+      break;
+    }
+
+    const partialCount = countArrayItemProperties(schema, partialArrayPath);
+
+    // Find the best matching array with MORE properties
+    let bestMatch: string | null = null;
+    let bestMatchScore = 0;
+    let bestMatchCount = partialCount;
+
+    for (const richArrayPath of arraysWithItemSchema) {
+      if (richArrayPath === partialArrayPath) continue;
+      if (!arrayNamesMatch(partialArrayPath, richArrayPath)) continue;
+
+      const richCount = countArrayItemProperties(schema, richArrayPath);
+
+      // Only consider arrays with MORE properties
+      if (richCount <= partialCount) continue;
+
+      // Score the match - prefer arrays with more properties and shallower depth
+      const partialDepth = partialArrayPath.split('.').length;
+      const richDepth = richArrayPath.split('.').length;
+      const depthDiff = Math.abs(partialDepth - richDepth);
+      const score = richCount * 10 - depthDiff * 5 - richDepth;
+
+      if (score > bestMatchScore || richCount > bestMatchCount) {
+        bestMatchScore = score;
+        bestMatch = richArrayPath;
+        bestMatchCount = richCount;
+      }
+    }
+
+    if (bestMatch) {
+      // Copy MISSING item properties from the rich array to the partial array
+      const richElementPrefix = bestMatch + '[]';
+      const partialElementPrefix = partialArrayPath + '[]';
+
+      const pathsToCheck = Object.keys(schema);
+
+      for (const path of pathsToCheck) {
+        if (path.startsWith(richElementPrefix)) {
+          const suffix = path.slice(richElementPrefix.length);
+          const newPath = partialElementPrefix + suffix;
+
+          // Skip if this would create a recursive path
+          if (wouldCreateRecursivePath(partialElementPrefix, suffix)) {
+            continue;
+          }
+
+          // Skip if the new path would have too many array levels
+          if (countArrayLevels(newPath) > MAX_ARRAY_NESTING_DEPTH) {
+            continue;
+          }
+
+          // Safety check: Stop if we've added too many paths
+          if (totalPathsAdded >= MAX_PATHS_TO_ADD) {
+            break;
+          }
+
+          // Only add if the path doesn't already exist (don't overwrite)
+          if (!schema[newPath]) {
+            schema[newPath] = schema[path];
+            totalPathsAdded++;
+          }
+        }
+      }
+    }
+  }
+
+  // Log final stats
+  if (totalPathsAdded > 0) {
+    const finalPathCount = Object.keys(schema).length;
+    console.log(
+      `[PROPAGATE] Added ${totalPathsAdded} paths (${initialPathCount} -> ${finalPathCount})`,
+    );
+  }
+}

package/analyzer-template/packages/analyze/src/lib/files/setImportedExports.ts

@@ -1,5 +1,6 @@
 import { Commit, Entity, File } from '~codeyam/types';
 import { ProjectAnalyzer } from '../ProjectAnalyzer';
+import { getFileByPathSafe } from '../utils/getFileByPath';
 import getImportedExports from './getImportedExports';
 import { getFrameworkForFile, isFrameworkRoute } from '~codeyam/utils';
 import findOrCreateEntity from './analyze/findOrCreateEntity';
@@ -149,7 +150,7 @@ export default async function setImportedExports({
             // Use fileStore for O(1) lookup when available, fallback to O(n) find
             const relevantFile =
               fileStore?.getByPath(resolvedFilePath) ??
-              project.files.find((f) => f.path === resolvedFilePath);
+              getFileByPathSafe(projectAnalyzer, resolvedFilePath);
 
             if (relevantFile) {
               const relevantFileAnalyzer =

package/analyzer-template/packages/analyze/src/lib/index.ts

@@ -4,3 +4,4 @@ export { type FunctionDependenciesMap } from './asts/sourceFiles/getPseudoFile';
 export * as asts from './asts/index';
 export * as projects from './projects/index';
 export * as types from './types';
+export { transformationTracer } from './files/scenarios/TransformationTracer';

package/analyzer-template/packages/analyze/src/lib/utils/getFileByPath.ts

@@ -0,0 +1,19 @@
+import { File } from '~codeyam/types';
+import { ProjectAnalyzer } from '../ProjectAnalyzer';
+
+export function getFileByPathSafe(
+  projectAnalyzer: ProjectAnalyzer,
+  filePath: string,
+): File | undefined {
+  const maybeGetFileByPath = (projectAnalyzer as any).getFileByPath;
+  if (typeof maybeGetFileByPath === 'function') {
+    return maybeGetFileByPath.call(projectAnalyzer, filePath);
+  }
+
+  const projectFiles = (projectAnalyzer as any).project?.files;
+  if (Array.isArray(projectFiles)) {
+    return projectFiles.find((file: File) => file.path === filePath);
+  }
+
+  return undefined;
+}

package/analyzer-template/packages/aws/package.json

@@ -12,14 +12,14 @@
   "license": "ISC",
   "dependencies": {
     "@aws-sdk/client-codebuild": "^3.948.0",
-    "@aws-sdk/client-cloudwatch-logs": "^3.966.0",
+    "@aws-sdk/client-cloudwatch-logs": "^3.980.0",
     "@aws-sdk/client-dynamodb": "^3.956.0",
     "@aws-sdk/client-ecr": "^3.948.0",
     "@aws-sdk/client-ecs": "^3.956.0",
     "@aws-sdk/client-s3": "^3.940.0",
     "@aws-sdk/client-sqs": "^3.956.0",
-    "@aws-sdk/lib-storage": "^3.940.0",
+    "@aws-sdk/lib-storage": "^3.975.0",
     "@aws-sdk/s3-request-presigner": "^3.940.0",
-    "@aws-sdk/util-dynamodb": "^3.902.0"
+    "@aws-sdk/util-dynamodb": "^3.971.0"
   }
 }

package/analyzer-template/packages/database/package.json

@@ -15,7 +15,7 @@
     "@supabase/supabase-js": "2.88.0",
     "better-sqlite3": "^12.4.1",
     "fetch-retry": "^6.0.0",
-    "kysely": "^0.28.5",
+    "kysely": "^0.28.11",
     "pg": "^8.16.3"
   },
   "jest": {

package/analyzer-template/packages/database/src/lib/analysisBranchToDb.ts

@@ -1,6 +1,6 @@
 import { AnalysisBranch } from '~codeyam/types';
 import { DbAnalysisBranch } from './kysely/tableRelations';
-import { randomUUID } from 'crypto';
+const randomUUID = () => crypto.randomUUID();
 import { AnalysisBranchesTable } from './kysely/tables/analysisBranchesTable';
 import { type Insertable } from 'kysely';
 

package/analyzer-template/packages/database/src/lib/analysisToDb.ts

@@ -1,7 +1,7 @@
 import { Analysis } from '~codeyam/types';
 import { type Insertable } from 'kysely';
 import { AnalysesTable } from './kysely/tables/analysesTable';
-import { randomUUID } from 'crypto';
+const randomUUID = () => crypto.randomUUID();
 
 export default function analysisToDb(
   analysis: Analysis,

package/analyzer-template/packages/database/src/lib/branchToDb.ts

@@ -1,7 +1,7 @@
 import { Branch } from '~codeyam/types';
 import { type Insertable } from 'kysely';
 import { BranchesTable } from './kysely/tables/branchesTable';
-import { randomUUID } from 'crypto';
+const randomUUID = () => crypto.randomUUID();
 
 export default function branchToDb(branch: Branch): Insertable<BranchesTable> {
   const { id, projectId, activeAt, contentChangedAt, metadata, ...remaining } =

package/analyzer-template/packages/database/src/lib/commitBranchToDb.ts

@@ -1,6 +1,6 @@
 import { CommitBranch } from '~codeyam/types';
 import { type Insertable } from 'kysely';
-import { randomUUID } from 'crypto';
+const randomUUID = () => crypto.randomUUID();
 import { CommitBranchesTable } from './kysely/tables/commitBranchesTable';
 
 export default function commitBranchToDb(

package/analyzer-template/packages/database/src/lib/commitToDb.ts

@@ -1,7 +1,7 @@
 import { Commit } from '~codeyam/types';
 import { CommitsTable } from './kysely/tables/commitsTable';
 import { type Insertable } from 'kysely';
-import { randomUUID } from 'crypto';
+const randomUUID = () => crypto.randomUUID();
 
 export default function commitToDb(
   commit: Commit,