@codeyam/codeyam-cli 0.1.0-staging.bbe4da9 → 0.1.0-staging.e38f7bd

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

@@ -31,12 +31,6 @@ export default function generateDataStructure({
     awsLog('CodeYam: Generating data structure for', {
       filePath: entity.filePath,
       entityName: entity.name,
-      // dependentAnalyses: Object.keys(dependentAnalyses).flatMap((path) =>
-      //   Object.keys(dependentAnalyses[path]).flatMap((entityName) => ({
-      //     path,
-      //     entityName,
-      //   })),
-      // ),
     });
 
     const allImportedExports = [
@@ -51,6 +45,58 @@ export default function generateDataStructure({
           ),
       ),
     ];
+
+    // For implicit dependencies (like root.tsx layouts), include their mocked nodeModuleImports
+    // This ensures layout file dependencies (like useLoaderData in root.tsx) are included in dataForMocks
+    // when simulating routes that are wrapped by those layout files
+    for (const importedExport of entity.metadata.importedExports ?? []) {
+      if (
+        !('isImplicitDependency' in importedExport) ||
+        !importedExport.isImplicitDependency
+      ) {
+        continue;
+      }
+
+      // Look up the implicit dependency's analysis
+      const implicitDepAnalysis =
+        dependentAnalyses[importedExport.filePath]?.[importedExport.name];
+
+      // Access nodeModuleImports from the entity attached to the analysis
+      const nodeModuleImports =
+        implicitDepAnalysis?.entity?.metadata?.nodeModuleImports;
+      if (!nodeModuleImports) {
+        continue;
+      }
+
+      // Add the implicit dependency's mocked nodeModuleImports to allImportedExports
+      for (const moduleName of Object.keys(nodeModuleImports)) {
+        const moduleImports = nodeModuleImports[moduleName] || [];
+        for (const imported of moduleImports) {
+          if (!imported.isMocked) continue;
+
+          // Only add if not already present (avoid duplicates)
+          const alreadyExists = allImportedExports.some(
+            (existing) =>
+              existing.filePath === moduleName &&
+              existing.name === imported.name,
+          );
+
+          if (!alreadyExists) {
+            allImportedExports.push({
+              filePath: moduleName,
+              name: imported.name,
+              isDefault: imported.isDefault,
+              isMocked: imported.isMocked,
+              calls: imported.calls ? [...imported.calls] : undefined,
+              callVariableNames: imported.callVariableNames
+                ? [...imported.callVariableNames]
+                : undefined,
+            });
+          }
+        }
+      }
+    }
+
     const nonMockedDependentAnalyses: ReadonlyAnalysisMap =
       allImportedExports.reduce((acc, importedExport) => {
         if (importedExport.isMocked) return acc;
@@ -63,6 +109,55 @@ export default function generateDataStructure({
         const relevantDependencyAnalysis =
           dependentAnalyses[lookupPath]?.[importedExport.name];
 
+        // DEBUG: Track buildBranchFileMap and fileComparisons
+        if (
+          importedExport.name === 'buildBranchFileMap' ||
+          entity.name === 'GitView'
+        ) {
+          console.log('🔍 DEBUG generateDataStructure:', {
+            entityName: entity.name,
+            importedExportName: importedExport.name,
+            lookupPath,
+            hasAnalysis: !!relevantDependencyAnalysis,
+            signatureSchema:
+              relevantDependencyAnalysis?.metadata?.mergedDataStructure
+                ?.signatureSchema,
+            dependencySchemas: relevantDependencyAnalysis?.metadata
+              ?.mergedDataStructure?.dependencySchemas
+              ? Object.keys(
+                  relevantDependencyAnalysis.metadata.mergedDataStructure
+                    .dependencySchemas,
+                )
+              : null,
+          });
+          if (
+            relevantDependencyAnalysis?.metadata?.mergedDataStructure
+              ?.signatureSchema
+          ) {
+            const sig =
+              relevantDependencyAnalysis.metadata.mergedDataStructure
+                .signatureSchema;
+            console.log(
+              '🔍 DEBUG buildBranchFileMap signature keys:',
+              Object.keys(sig),
+            );
+            // Look for fileComparisons in the signature
+            for (const key of Object.keys(sig)) {
+              if (
+                key.includes('fileComparisons') ||
+                key.includes('entityDiff')
+              ) {
+                console.log(
+                  '🔍 DEBUG Found relevant key:',
+                  key,
+                  '=',
+                  JSON.stringify(sig[key], null, 2),
+                );
+              }
+            }
+          }
+        }
+
         if (!relevantDependencyAnalysis) {
           // console.info(
           //   'CodeYam Warn: No relevant dependency analysis found for importedExport',
@@ -129,6 +224,7 @@ export default function generateDataStructure({
     // );
 
     const { isolatedDataStructure } = entity.metadata;
+
     const mergedDataStructure = mergeInDependentDataStructure({
       importedExports: allImportedExports,
       dependentAnalyses: nonMockedDependentAnalyses,
@@ -143,6 +239,39 @@ export default function generateDataStructure({
       dependencySchemas: isolatedDataStructure?.dependencySchemas || {},
     });
 
+    // DEBUG: Check merged result for GitView
+    if (entity.name === 'GitView') {
+      console.log(
+        '🔍 DEBUG GitView mergedDataStructure dependency schemas:',
+        Object.keys(mergedDataStructure.dependencySchemas || {}),
+      );
+      for (const filePath of Object.keys(
+        mergedDataStructure.dependencySchemas || {},
+      )) {
+        for (const depName of Object.keys(
+          mergedDataStructure.dependencySchemas[filePath] || {},
+        )) {
+          const depSchema =
+            mergedDataStructure.dependencySchemas[filePath][depName];
+          console.log(
+            `🔍 DEBUG Merged dep ${filePath}/${depName} signature keys:`,
+            Object.keys(depSchema.signatureSchema || {}),
+          );
+          // Look for fileComparisons
+          for (const key of Object.keys(depSchema.signatureSchema || {})) {
+            if (key.includes('fileComparisons') || key.includes('entityDiff')) {
+              console.log(
+                '🔍 DEBUG MERGED Found relevant key:',
+                key,
+                '=',
+                JSON.stringify(depSchema.signatureSchema[key], null, 2),
+              );
+            }
+          }
+        }
+      }
+    }
+
     mergedDataStructure.environmentVariables =
       isolatedDataStructure.environmentVariables || [];
 
@@ -202,6 +331,28 @@ export default function generateDataStructure({
       mergedDataStructure.dependencySchemas,
     );
 
+    // DEBUG: Check dataForMocks for GitView
+    if (entity.name === 'GitView') {
+      console.log(
+        '🔍 DEBUG GitView dataForMocks keys:',
+        Object.keys(dataForMocks),
+      );
+      for (const key of Object.keys(dataForMocks)) {
+        if (
+          key.includes('buildBranchFileMap') ||
+          key.includes('fileComparisons') ||
+          key.includes('entityDiff')
+        ) {
+          console.log(
+            '🔍 DEBUG dataForMocks relevant key:',
+            key,
+            '=',
+            JSON.stringify(dataForMocks[key], null, 2),
+          );
+        }
+      }
+    }
+
     // console.info(
     //   'CODEYAM DEBUG: dataForMocks',
     //   JSON.stringify(
@@ -215,6 +366,24 @@ export default function generateDataStructure({
     //   ),
     // );
 
+    // Log union types in signatureSchema before processing
+    const unionTypeEntries = Object.entries(
+      mergedDataStructure.signatureSchema,
+    ).filter(
+      ([_, value]) =>
+        typeof value === 'string' &&
+        value.includes("'") &&
+        value.includes(' | '),
+    );
+    if (unionTypeEntries.length > 0) {
+      console.log(
+        `[UNION-TYPE] generateDataStructure for ${entity.name}: Found union types in signatureSchema:`,
+      );
+      unionTypeEntries.forEach(([key, value]) => {
+        console.log(`[UNION-TYPE]   "${key}": ${value}`);
+      });
+    }
+
     const finalizedArgumentsSchema = fillInDirectSchemaGapsAndUnknowns({
       schema: { ...mergedDataStructure.signatureSchema },
     });

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

@@ -74,6 +74,7 @@ export default async function generateKeyAttributes({
       () =>
         generateEntityKeyAttributes({
           entity,
+          mergedDataStructure: analysis.metadata.mergedDataStructure,
           model,
         }),
       `Generating entity key attributes`,
@@ -82,6 +83,7 @@ export default async function generateKeyAttributes({
 
     const relevantDependentKeyAttributes = gatherRelevantDependentKeyAttributes(
       entity,
+      analysis.metadata.mergedDataStructure,
       dependentAnalyses,
     );
 
@@ -92,6 +94,10 @@ export default async function generateKeyAttributes({
         // Spread to convert readonly arrays to mutable arrays (with fallback for undefined)
         validValueOptions: [...(ka.validValueOptions ?? [])],
         errorValueOptions: [...(ka.errorValueOptions ?? [])],
+        // Convert readonly dependencies array to mutable if present
+        ...(ka.dependencies && {
+          dependencies: ka.dependencies.map((dep) => ({ ...dep })),
+        }),
       })),
     ].filter(
       (ka, index, self) =>

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

@@ -61,20 +61,24 @@ export function gatherDataForMocks(
     for (const importedExport of allImportedExports) {
       const localDataForMocks =
         activeAnalysis.metadata?.scenariosDataStructure?.dataForMocks ?? {};
-      const relevantKey = Object.keys(localDataForMocks).find((key) =>
-        key.startsWith(importedExport.name),
+      // Find relevant keys - handle both old format (starts with name)
+      // and new variable-qualified format ("varName <- functionName")
+      const relevantKeys = Object.keys(localDataForMocks).filter(
+        (key) =>
+          key.startsWith(importedExport.name) ||
+          key.endsWith(` <- ${importedExport.name}`),
       );
 
       // console.info('CODEYAM DEBUG: Processing import', {
       //   importedExportName: importedExport.name,
       //   importedExportFilePath: importedExport.filePath,
-      //   relevantKey,
+      //   relevantKeys,
       //   hasLocalDataForMocks: Object.keys(localDataForMocks).length > 0,
       //   localDataForMocksKeys: Object.keys(localDataForMocks),
       // });
 
       // First, if we have local data for this mock, add it
-      if (relevantKey) {
+      for (const relevantKey of relevantKeys) {
         const localDataForMock = localDataForMocks[relevantKey];
 
         // console.info('CODEYAM DEBUG: Found relevantKey', {

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.
@@ -853,6 +926,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/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/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/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'),
+      ),
+  );
+}