@codeyam/codeyam-cli 0.1.0-staging.28f73cf → 0.1.0-staging.596f0eb

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

@@ -398,6 +398,7 @@ export default function mergeInDependentDataStructure({
                   const postfix = joinParenthesesAndArrays(
                     schemaPathParts.slice(matchedUpToIndex),
                   );
+
                   entry.equivalentPostfixes[postfix] = entry
                     .equivalentPostfixes[postfix]
                     ? bestValueFromOptions([
@@ -673,6 +674,7 @@ export default function mergeInDependentDataStructure({
           equivalentRoot.schemaRootPath,
           relevantPostfix,
         ]);
+
         schema[newSchemaPath] = postfixValue;
       }
 
@@ -680,6 +682,77 @@ export default function mergeInDependentDataStructure({
     }
   }
 
+  // Propagate equivalency-derived attributes to generic function call variants.
+  // When attributes are traced via equivalencies (e.g., fileComparisons from buildDataMap.signature[2]),
+  // they get written to non-generic paths (returnValue.data.x or funcName().functionCallReturnValue.data.x).
+  // If the ORIGINAL input schema has generic variants (funcName<T>().functionCallReturnValue.data),
+  // we need to copy the attributes to those paths too.
+  for (const filePath in mergedDataStructure.dependencySchemas) {
+    for (const depName in mergedDataStructure.dependencySchemas[filePath]) {
+      const depSchema =
+        mergedDataStructure.dependencySchemas[filePath][depName];
+      const returnValueSchema = depSchema.returnValueSchema;
+
+      // Look at the ORIGINAL input dependencySchemas for generic variants,
+      // since the merged schema may have lost them during equivalency processing
+      const originalSchema = dependencySchemas?.[filePath]?.[depName];
+      const schemaToSearchForGenericVariants =
+        originalSchema?.returnValueSchema || returnValueSchema;
+
+      // Find all unique generic variants of this function
+      // e.g., useFetcher<BranchEntityDiffResult>() from useFetcher<BranchEntityDiffResult>().functionCallReturnValue.data
+      const genericVariants = new Set<string>();
+      const genericRegex = new RegExp(
+        `^${depName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}<[^>]+>\\(\\)`,
+      );
+
+      for (const path in schemaToSearchForGenericVariants) {
+        const match = path.match(genericRegex);
+        if (match) {
+          genericVariants.add(match[0]);
+        }
+      }
+
+      if (genericVariants.size === 0) continue;
+
+      // For each returnValue. path or non-generic function call path,
+      // create corresponding paths for each generic variant
+      const pathsToAdd: [string, string][] = [];
+
+      for (const path in returnValueSchema) {
+        const value = returnValueSchema[path];
+
+        // Handle returnValue. paths
+        if (path.startsWith('returnValue.')) {
+          const suffix = path.slice('returnValue.'.length);
+          for (const genericVariant of genericVariants) {
+            const genericPath = `${genericVariant}.functionCallReturnValue.${suffix}`;
+            if (!(genericPath in returnValueSchema)) {
+              pathsToAdd.push([genericPath, value]);
+            }
+          }
+        }
+        // Handle non-generic function call paths like depName().functionCallReturnValue.x
+        else if (path.startsWith(`${depName}().functionCallReturnValue.`)) {
+          const suffix = path.slice(
+            `${depName}().functionCallReturnValue.`.length,
+          );
+          for (const genericVariant of genericVariants) {
+            const genericPath = `${genericVariant}.functionCallReturnValue.${suffix}`;
+            if (!(genericPath in returnValueSchema)) {
+              pathsToAdd.push([genericPath, value]);
+            }
+          }
+        }
+      }
+
+      // Add the new generic variant paths
+      for (const [path, value] of pathsToAdd) {
+        returnValueSchema[path] = value;
+      }
+    }
+  }
+
   // For mocked dependencies: copy paths from dependencySchemas (usage info) and normalize
   // returnValue. paths that were created by equivalency processing.
   // This ensures all paths use the consistent functionName().functionCallReturnValue. format.
@@ -695,33 +768,38 @@ export default function mergeInDependentDataStructure({
       name: dependency.name,
     });
 
-    // First, normalize any returnValue. paths that were written by equivalency processing
-    // to the standard functionName().functionCallReturnValue. format.
-    // Also delete returnValue[] artifact paths that don't represent actual array structure.
+    // First, normalize any returnValue paths that were written by equivalency processing
+    // to the standard functionName().functionCallReturnValue format.
+    // This includes both returnValue. (dot) and returnValue[ (array) paths.
     const pathsToNormalize: [string, string][] = [];
-    const pathsToDelete: string[] = [];
     for (const path in depSchema.returnValueSchema) {
-      if (path === 'returnValue' || path.startsWith('returnValue.')) {
+      if (
+        path === 'returnValue' ||
+        path.startsWith('returnValue.') ||
+        path.startsWith('returnValue[')
+      ) {
         pathsToNormalize.push([path, depSchema.returnValueSchema[path]]);
-      } else if (path.match(/^returnValue\[\d*\]/)) {
-        // Delete returnValue[] and returnValue[n] paths - these are artifacts from
-        // equivalency processing and don't represent the actual structure of mocked dependencies.
-        // The correct structure comes from srcSchema (dependencySchemas).
-        pathsToDelete.push(path);
       }
     }
-    for (const path of pathsToDelete) {
-      delete depSchema.returnValueSchema[path];
-    }
     for (const [path, value] of pathsToNormalize) {
       delete depSchema.returnValueSchema[path];
-      const normalizedPath =
-        path === 'returnValue'
-          ? `${dependency.name}().functionCallReturnValue`
-          : path.replace(
-              /^returnValue\./,
-              `${dependency.name}().functionCallReturnValue.`,
-            );
+      let normalizedPath: string;
+      if (path === 'returnValue') {
+        normalizedPath = `${dependency.name}().functionCallReturnValue`;
+      } else if (path.startsWith('returnValue.')) {
+        normalizedPath = path.replace(
+          /^returnValue\./,
+          `${dependency.name}().functionCallReturnValue.`,
+        );
+      } else {
+        // path.startsWith('returnValue[')
+        // e.g., returnValue[] -> getOptions().functionCallReturnValue[]
+        // e.g., returnValue[].label -> getOptions().functionCallReturnValue[].label
+        normalizedPath = path.replace(
+          /^returnValue/,
+          `${dependency.name}().functionCallReturnValue`,
+        );
+      }
       depSchema.returnValueSchema[normalizedPath] = value;
     }
 
@@ -773,6 +851,37 @@ export default function mergeInDependentDataStructure({
           depSchema.returnValueSchema[path] = value;
         }
       }
+
+      // Copy object-typed paths for chained API access patterns (like trpc.customer.getCustomersByOrg)
+      // These intermediate paths are needed for constructMockCode to build the nested mock structure.
+      // Example: for trpc.customer.getCustomersByOrg.useQuery().functionCallReturnValue.data,
+      // we need 'trpc', 'trpc.customer', 'trpc.customer.getCustomersByOrg' all typed as 'object'.
+      // Skip paths starting with 'returnValue' - they were already handled above
+      //
+      // EXCEPTION: For function-style dependencies like getSupabase(), skip intermediate object
+      // paths like 'getSupabase().auth' that are just property access after a function call.
+      // These aren't needed because constructMockCode can infer the structure from the actual
+      // function call paths like 'getSupabase().auth.getUser()'. We only need object paths
+      // for object-style dependencies like 'supabase.auth' where the dependency itself is an object.
+      if (value === 'object' && !path.startsWith('returnValue')) {
+        // Check if this is a function-style dependency (path starts with name() or name<T>())
+        const isFunctionStyleDependency =
+          path.startsWith(`${dependency.name}()`) ||
+          path.match(new RegExp(`^${dependency.name}<[^>]+>\\(\\)`));
+
+        // For function-style dependencies, skip intermediate object paths
+        // Only keep object paths that are within functionCallReturnValue
+        if (
+          isFunctionStyleDependency &&
+          !path.includes('.functionCallReturnValue')
+        ) {
+          continue;
+        }
+
+        if (!(path in depSchema.returnValueSchema)) {
+          depSchema.returnValueSchema[path] = value;
+        }
+      }
     }
 
     cleanSchema(depSchema.returnValueSchema);
@@ -853,6 +962,40 @@ export default function mergeInDependentDataStructure({
     }
   }
 
+  // Ensure ALL dependencies from the input dependencySchemas are preserved.
+  // Some dependencies (like .d.ts type declaration files) may not have:
+  // - Equivalencies with the root scope
+  // - A dependent analysis (they're just type declarations)
+  // - Be marked as mocked
+  // Without this, their schemas would be lost entirely.
+  //
+  // IMPORTANT: Only add schemas for dependencies that weren't already processed.
+  // If a dependency has an existing schema (even an empty one), it means the
+  // existing processing (mocked dependencies, equivalencies, dependentAnalyses)
+  // has already handled it and may have intentionally filtered out certain paths.
+  for (const filePath in dependencySchemas) {
+    for (const name in dependencySchemas[filePath]) {
+      const srcSchema = dependencySchemas[filePath][name];
+      if (!srcSchema) continue;
+
+      // Check if this dependency was already processed by any other mechanism
+      const existingSchema =
+        mergedDataStructure.dependencySchemas[filePath]?.[name];
+
+      // Only add if no existing schema at all - this means the dependency
+      // wasn't processed through equivalencies, mocked dependencies, or dependentAnalyses
+      if (!existingSchema) {
+        const depSchema = findOrCreateDependentSchemas({ filePath, name });
+        for (const path in srcSchema.returnValueSchema) {
+          depSchema.returnValueSchema[path] = srcSchema.returnValueSchema[path];
+        }
+        for (const path in srcSchema.signatureSchema) {
+          depSchema.signatureSchema[path] = srcSchema.signatureSchema[path];
+        }
+      }
+    }
+  }
+
   // writeFile(
   //   'mergeInDependentDataStructure-debug-result.json',
   //   // rootScopeName,

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

@@ -176,9 +176,19 @@ export default function mergeValidatedDataStructures({
       }
     }
 
-    for (const mockName in dependentAnalysis?.metadata?.scenariosDataStructure
-      ?.dataForMocks ?? {}) {
+    const dependencyDataForMocks =
+      dependentAnalysis?.metadata?.scenariosDataStructure?.dataForMocks ?? {};
+    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;
+      }
     }
   }
 

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

@@ -3,7 +3,7 @@ import { ProjectAnalyzer } from '../ProjectAnalyzer';
 import getImportedExports from './getImportedExports';
 import { getFrameworkForFile, isFrameworkRoute } from '~codeyam/utils';
 import findOrCreateEntity from './analyze/findOrCreateEntity';
-import { generateSha, loadEntities, upsertEntities } from '~codeyam/supabase';
+import { generateSha, loadEntities, upsertEntities } from '~codeyam/database';
 import { AnalysisContext } from '../analysisContext';
 import analyzeFrameworkRoute from './analyzeFrameworkRoute';
 

package/analyzer-template/packages/aws/dist/src/lib/s3/getPresignedUrl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getPresignedUrl.d.ts","sourceRoot":"","sources":["../../../../src/lib/s3/getPresignedUrl.ts"],"names":[],"mappings":"AAOA,UAAU,yBAAyB;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,UAAU,2BAA2B;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAKD;;;GAGG;AACH,wBAAsB,qBAAqB,CAAC,EAC1C,UAAU,EACV,GAAG,EACH,WAAgC,EAChC,gBAAwC,GACzC,EAAE,yBAAyB,GAAG,OAAO,CAAC,MAAM,CAAC,CAU7C;AAED;;;GAGG;AACH,wBAAsB,uBAAuB,CAAC,EAC5C,UAAU,EACV,GAAG,EACH,gBAA0C,GAC3C,EAAE,2BAA2B,GAAG,OAAO,CAAC,MAAM,CAAC,CAS/C"}
+{"version":3,"file":"getPresignedUrl.d.ts","sourceRoot":"","sources":["../../../../src/lib/s3/getPresignedUrl.ts"],"names":[],"mappings":"AAOA,UAAU,yBAAyB;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,UAAU,2BAA2B;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAKD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,EACpC,UAAU,EACV,GAAG,EACH,WAAgC,EAChC,gBAAwC,GACzC,EAAE,yBAAyB,GAAG,OAAO,CAAC,MAAM,CAAC,CAU7C;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,EACtC,UAAU,EACV,GAAG,EACH,gBAA0C,GAC3C,EAAE,2BAA2B,GAAG,OAAO,CAAC,MAAM,CAAC,CAS/C"}

package/analyzer-template/packages/aws/dist/src/lib/s3/getPresignedUrl.js

@@ -6,7 +6,7 @@ const DEFAULT_DOWNLOAD_EXPIRY = 24 * 60 * 60; // 24 hours
  * Generate a presigned URL for uploading a file to S3.
  * The client can PUT directly to this URL without AWS credentials.
  */
-export async function getPresignedUploadUrl({ bucketName, key, contentType = 'application/gzip', expiresInSeconds = DEFAULT_UPLOAD_EXPIRY, }) {
+export function getPresignedUploadUrl({ bucketName, key, contentType = 'application/gzip', expiresInSeconds = DEFAULT_UPLOAD_EXPIRY, }) {
     const s3Client = new S3Client({});
     const command = new PutObjectCommand({
         Bucket: bucketName,
@@ -19,7 +19,7 @@ export async function getPresignedUploadUrl({ bucketName, key, contentType = 'ap
  * Generate a presigned URL for downloading a file from S3.
  * Anyone with this URL can GET the file without AWS credentials.
  */
-export async function getPresignedDownloadUrl({ bucketName, key, expiresInSeconds = DEFAULT_DOWNLOAD_EXPIRY, }) {
+export function getPresignedDownloadUrl({ bucketName, key, expiresInSeconds = DEFAULT_DOWNLOAD_EXPIRY, }) {
     const s3Client = new S3Client({});
     const command = new GetObjectCommand({
         Bucket: bucketName,

package/analyzer-template/packages/aws/dist/src/lib/s3/getPresignedUrl.js.map

@@ -1 +1 @@
-{"version":3,"file":"getPresignedUrl.js","sourceRoot":"","sources":["../../../../src/lib/s3/getPresignedUrl.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAe7D,MAAM,qBAAqB,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,UAAU;AACrD,MAAM,uBAAuB,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,WAAW;AAEzD;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CAAC,EAC1C,UAAU,EACV,GAAG,EACH,WAAW,GAAG,kBAAkB,EAChC,gBAAgB,GAAG,qBAAqB,GACd;IAC1B,MAAM,QAAQ,GAAG,IAAI,QAAQ,CAAC,EAAE,CAAC,CAAC;IAElC,MAAM,OAAO,GAAG,IAAI,gBAAgB,CAAC;QACnC,MAAM,EAAE,UAAU;QAClB,GAAG,EAAE,GAAG;QACR,WAAW,EAAE,WAAW;KACzB,CAAC,CAAC;IAEH,OAAO,YAAY,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,SAAS,EAAE,gBAAgB,EAAE,CAAC,CAAC;AAC1E,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAAC,EAC5C,UAAU,EACV,GAAG,EACH,gBAAgB,GAAG,uBAAuB,GACd;IAC5B,MAAM,QAAQ,GAAG,IAAI,QAAQ,CAAC,EAAE,CAAC,CAAC;IAElC,MAAM,OAAO,GAAG,IAAI,gBAAgB,CAAC;QACnC,MAAM,EAAE,UAAU;QAClB,GAAG,EAAE,GAAG;KACT,CAAC,CAAC;IAEH,OAAO,YAAY,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,SAAS,EAAE,gBAAgB,EAAE,CAAC,CAAC;AAC1E,CAAC"}
+{"version":3,"file":"getPresignedUrl.js","sourceRoot":"","sources":["../../../../src/lib/s3/getPresignedUrl.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAe7D,MAAM,qBAAqB,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,UAAU;AACrD,MAAM,uBAAuB,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,WAAW;AAEzD;;;GAGG;AACH,MAAM,UAAU,qBAAqB,CAAC,EACpC,UAAU,EACV,GAAG,EACH,WAAW,GAAG,kBAAkB,EAChC,gBAAgB,GAAG,qBAAqB,GACd;IAC1B,MAAM,QAAQ,GAAG,IAAI,QAAQ,CAAC,EAAE,CAAC,CAAC;IAElC,MAAM,OAAO,GAAG,IAAI,gBAAgB,CAAC;QACnC,MAAM,EAAE,UAAU;QAClB,GAAG,EAAE,GAAG;QACR,WAAW,EAAE,WAAW;KACzB,CAAC,CAAC;IAEH,OAAO,YAAY,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,SAAS,EAAE,gBAAgB,EAAE,CAAC,CAAC;AAC1E,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,uBAAuB,CAAC,EACtC,UAAU,EACV,GAAG,EACH,gBAAgB,GAAG,uBAAuB,GACd;IAC5B,MAAM,QAAQ,GAAG,IAAI,QAAQ,CAAC,EAAE,CAAC,CAAC;IAElC,MAAM,OAAO,GAAG,IAAI,gBAAgB,CAAC;QACnC,MAAM,EAAE,UAAU;QAClB,GAAG,EAAE,GAAG;KACT,CAAC,CAAC;IAEH,OAAO,YAAY,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,SAAS,EAAE,gBAAgB,EAAE,CAAC,CAAC;AAC1E,CAAC"}

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

@@ -13,11 +13,11 @@
   "dependencies": {
     "@aws-sdk/client-codebuild": "^3.948.0",
     "@aws-sdk/client-cloudwatch-logs": "^3.940.0",
-    "@aws-sdk/client-dynamodb": "^3.899.0",
+    "@aws-sdk/client-dynamodb": "^3.956.0",
     "@aws-sdk/client-ecr": "^3.948.0",
-    "@aws-sdk/client-ecs": "^3.937.0",
+    "@aws-sdk/client-ecs": "^3.956.0",
     "@aws-sdk/client-s3": "^3.940.0",
-    "@aws-sdk/client-sqs": "^3.940.0",
+    "@aws-sdk/client-sqs": "^3.956.0",
     "@aws-sdk/lib-storage": "^3.940.0",
     "@aws-sdk/s3-request-presigner": "^3.940.0",
     "@aws-sdk/util-dynamodb": "^3.902.0"

package/analyzer-template/packages/aws/src/lib/s3/getPresignedUrl.ts

@@ -25,7 +25,7 @@ const DEFAULT_DOWNLOAD_EXPIRY = 24 * 60 * 60; // 24 hours
  * Generate a presigned URL for uploading a file to S3.
  * The client can PUT directly to this URL without AWS credentials.
  */
-export async function getPresignedUploadUrl({
+export function getPresignedUploadUrl({
   bucketName,
   key,
   contentType = 'application/gzip',
@@ -46,7 +46,7 @@ export async function getPresignedUploadUrl({
  * Generate a presigned URL for downloading a file from S3.
  * Anyone with this URL can GET the file without AWS credentials.
  */
-export async function getPresignedDownloadUrl({
+export function getPresignedDownloadUrl({
   bucketName,
   key,
   expiresInSeconds = DEFAULT_DOWNLOAD_EXPIRY,

package/analyzer-template/packages/database/client.ts

@@ -0,0 +1,35 @@
+/**
+ * This index file re-exports modules which are safe to use in a browser
+ * environment with our current set of polyfills. Two considerations:
+ * - It must compile: it can't rely on node modules we don't polyfill
+ * - It must use Supabase for its REST capabilities. None of the db.ts
+ *   infrastructure must be invoked in this file or any of its imports.
+ *
+ *   Kysely itself is fine.
+ */
+
+export { getSupabase, getAdminSupabase } from './src/lib/supabase';
+
+export type { SupabaseClient } from '@supabase/supabase-js';
+export { default as upsertFiles_Client } from './src/lib/client/upsertFiles_Client';
+export { default as loadAnalyses_Client } from './src/lib/client/loadAnalysesInClient';
+export { default as loadBranches_Client } from './src/lib/client/loadBranches_Client';
+export { default as loadAnalysis_Client } from './src/lib/client/loadAnalysis_Client';
+
+export { default as listenForCommits_Client } from './src/lib/client/listenForCommits_Client';
+
+export { default as dbToAnalysis } from './src/lib/dbToAnalysis';
+export { default as dbToBranch } from './src/lib/dbToBranch';
+export { default as dbToCommit } from './src/lib/dbToCommit';
+export { default as dbToEntity } from './src/lib/dbToEntity';
+export { default as dbToFile } from './src/lib/dbToFile';
+export { default as dbToProject } from './src/lib/dbToProject';
+export { default as dbToScenario } from './src/lib/dbToScenario';
+export { default as dbToUserScenario } from './src/lib/dbToUserScenario';
+export { default as dbToScenarioComment } from './src/lib/dbToScenarioComment';
+
+// NOTE: generateSha is NOT exported here because it uses Node's crypto module
+// which is server-only. Import from '~codeyam/database' (server) instead.
+
+// Export ONLY types from tableRelations (no runtime code that imports Kysely)
+export type * from './src/lib/kysely/tableRelationsTypes';

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

@@ -0,0 +1,31 @@
+{
+  "name": "@codeyam/supabase",
+  "version": "1.0.0",
+  "description": "",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "test": "jest --watchAll --verbose"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@supabase/supabase-js": "2.88.0",
+    "better-sqlite3": "^12.4.1",
+    "fetch-retry": "^6.0.0",
+    "kysely": "^0.28.5",
+    "pg": "^8.16.3"
+  },
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/jest": "^30.0.0",
+    "@types/pg": "^8.15.5",
+    "@types/ws": "^8.18.1"
+  }
+}

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

@@ -0,0 +1,162 @@
+import { Database, getDatabase, getJsonHelper } from './kysely/db';
+import dbToCommit from './dbToCommit';
+import {
+  DbAnalysis,
+  DbBranch,
+  DbCommit,
+  DbScenario,
+} from './kysely/tableRelations';
+import { awsLog } from '~codeyam/utils';
+import { ExpressionBuilder } from 'kysely';
+import { ScenariosTableColumns } from './kysely/tables/scenariosTable';
+
+interface LoadCommitArgs {
+  id?: string;
+  projectId?: string;
+  sha?: string;
+  branchId?: string;
+}
+
+async function loadBranchForCommit(branchId: string): Promise<DbBranch | null> {
+  const db = getDatabase();
+
+  try {
+    return (
+      (await db
+        .selectFrom('branches')
+        .selectAll()
+        .where('id', '=', branchId)
+        .executeTakeFirst()) || null
+    );
+  } catch (error) {
+    awsLog('CodeYam Error: Loading branch for commit', error, { branchId });
+    return null;
+  }
+}
+
+async function loadAnalysesForCommit(commitId: string): Promise<DbAnalysis[]> {
+  const db = getDatabase();
+
+  const { jsonArrayFrom } = getJsonHelper();
+
+  try {
+    const analyses = await db
+      .selectFrom('analyses')
+      .selectAll('analyses')
+      .select((eb: ExpressionBuilder<any, any>) =>
+        jsonArrayFrom(
+          eb
+            .selectFrom('scenarios')
+            .select(ScenariosTableColumns)
+            .whereRef('scenarios.analysis_id', '=', 'analyses.id')
+            .$castTo<DbScenario>(),
+        ).as('scenarios'),
+      )
+      .where('commit_id', '=', commitId)
+      .execute();
+
+    return analyses;
+  } catch (error) {
+    awsLog('CodeYam Error: Loading analyses for commit', error, { commitId });
+    return [];
+  }
+}
+
+export default async function loadCommit({
+  id,
+  projectId,
+  sha,
+  branchId,
+}: LoadCommitArgs) {
+  const db = getDatabase();
+
+  try {
+    let query = db
+      .selectFrom('commits')
+      .selectAll('commits')
+      .select((eb: ExpressionBuilder<any, any>) =>
+        getCommitAuthorsAsJson(eb).as('author'),
+      );
+
+    if (id) {
+      query = query.where('id', '=', id);
+    }
+
+    if (sha) {
+      query = query.where('sha', '=', sha);
+    }
+
+    if (projectId) {
+      query = query.where('project_id', '=', projectId);
+    }
+
+    if (branchId) {
+      query = query.where('branch_id', '=', branchId);
+    }
+
+    query = query.orderBy('committed_at', 'desc').limit(1);
+
+    const commit = await query.executeTakeFirst();
+
+    if (!commit) {
+      awsLog('CodeYam Error: Commit not found', null, {
+        id,
+        projectId,
+        sha,
+        branchId,
+      });
+      return null;
+    }
+
+    // Load branch and mergedBranch separately
+    const [branch, mergedBranch, analyses] = await Promise.all([
+      commit.branch_id
+        ? loadBranchForCommit(commit.branch_id)
+        : Promise.resolve(null),
+      commit.merged_branch_id
+        ? loadBranchForCommit(commit.merged_branch_id)
+        : Promise.resolve(null),
+      loadAnalysesForCommit(commit.id),
+    ]);
+
+    // Construct the full DbCommit object
+    const dbCommit: DbCommit = {
+      ...commit,
+      branch: branch || undefined,
+      mergedBranch: mergedBranch || undefined,
+      analyses,
+    };
+
+    return dbToCommit(dbCommit);
+  } catch (error) {
+    awsLog('CodeYam Error: Database error loading commit', error, {
+      id,
+      projectId,
+      sha,
+      branchId,
+    });
+    return null;
+  }
+}
+
+// Export for reuse in other loaders
+export function getCommitAuthorsAsJson(
+  eb: ExpressionBuilder<Database, 'commits'>,
+) {
+  const { jsonObjectFrom } = getJsonHelper();
+
+  return jsonObjectFrom(
+    eb
+      .selectFrom('github_users')
+      .select([
+        'username',
+        'preferred_username as preferredUsername',
+        'avatar_url as avatarUrl',
+      ])
+      .where(
+        'github_users.username',
+        '=',
+        eb.ref('commits.author_github_username'),
+      ),
+  );
+}

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

@@ -0,0 +1,94 @@
+import { Entity } from '~codeyam/types';
+import dbToEntity from './dbToEntity';
+import { getDatabase } from './kysely/db';
+
+export interface LoadEntitiesArgs {
+  projectId?: string;
+  branchId?: string;
+  fileIds?: string[];
+  filePaths?: string[];
+  names?: string[];
+  shas?: string[];
+}
+
+export default async function loadEntities({
+  projectId,
+  branchId,
+  fileIds,
+  filePaths,
+  names,
+  shas,
+}: LoadEntitiesArgs): Promise<Entity[] | null> {
+  if (
+    (fileIds && fileIds.length == 0) ||
+    (filePaths && filePaths.length == 0) ||
+    (names && names.length == 0) ||
+    (shas && shas.length == 0)
+  ) {
+    return [];
+  }
+
+  if (shas && shas.length > 50) {
+    const allEntities: Entity[] = [];
+    for (let i = 0; i < shas.length; i += 50) {
+      const chunk = shas.slice(i, i + 50);
+      const chunkEntities = await loadEntities({
+        projectId,
+        branchId,
+        fileIds,
+        filePaths,
+        names,
+        shas: chunk,
+      });
+
+      if (chunkEntities) {
+        allEntities.push(...chunkEntities);
+      }
+    }
+    return allEntities;
+  }
+
+  const db = getDatabase();
+
+  try {
+    const query = db
+      .selectFrom('entities')
+      .selectAll('entities')
+      .$if(!!branchId, (qb) =>
+        qb
+          .innerJoin(
+            'entity_branches',
+            'entity_branches.entity_sha',
+            'entities.sha',
+          )
+          .where('entity_branches.branch_id', '=', branchId),
+      )
+      .$if(!!projectId, (qb) => qb.where('entities.project_id', '=', projectId))
+      .$if(!!shas, (qb) => qb.where('entities.sha', 'in', shas))
+      .$if(!!filePaths, (qb) => qb.where('entities.file_path', 'in', filePaths))
+      .$if(!!names, (qb) => qb.where('entities.name', 'in', names))
+      .$if(!!fileIds, (qb) => qb.where('entities.file_id', 'in', fileIds));
+
+    const entities = await query.execute();
+
+    if (!entities || entities.length === 0) {
+      console.log('Load Entities: No entities found', {
+        projectId,
+        fileIds,
+        filePaths,
+        shas,
+      });
+      return null;
+    }
+
+    return entities.map(dbToEntity);
+  } catch (error) {
+    console.log('Load Entities: Error occurred', error, {
+      projectId,
+      fileIds,
+      filePaths,
+      shas,
+    });
+    return null;
+  }
+}