@codeyam/codeyam-cli 0.1.0-staging.ad31e3e → 0.1.0-staging.b8a55ba

package/analyzer-template/project/createEntitiesAndSortFiles.ts

@@ -11,9 +11,12 @@ import {
   updateCommitMetadata,
   upsertEntities,
   upsertEntityBranches,
-} from '~codeyam/supabase';
+} from '~codeyam/database';
 import { LazyFileStore } from './LazyFileStore';
 
+// Track files we've already warned about to avoid duplicate warnings
+const warnedMissingFiles = new Set<string>();
+
 export interface EntityWithImportCount extends Entity {
   importCount?: number;
   started?: string;
@@ -89,12 +92,17 @@ async function findAndGatherEntity({
         ? fileStore.getByPath(importedEntityFilePath)
         : project.files.find((f) => f.path === importedEntityFilePath);
       if (!entityFile) {
-        console.log(
-          'CodeYam Error: Entity file not found for create and sort entities',
-          importedEntityName,
-          importedEntityFilePath,
-        );
-        throw new Error('Entity file not found for create and sort entities');
+        // File not in project - likely a mocked dependency or external library
+        // Skip this import rather than throwing, similar to gatherEntityMap.ts
+        if (!warnedMissingFiles.has(importedEntityFilePath)) {
+          warnedMissingFiles.add(importedEntityFilePath);
+          console.log(
+            'CodeYam Warning: Skipping dependency in create and sort - file not in project.files:',
+            importedEntityName,
+            importedEntityFilePath,
+          );
+        }
+        continue;
       }
 
       const info = await findAndGatherEntity({

package/analyzer-template/project/getFilesWithEntitiesFromRepo.ts

@@ -3,7 +3,7 @@ import {
   saveFiles,
   generateSha,
   loadEntities,
-} from '~codeyam/supabase';
+} from '~codeyam/database';
 import { File, Project } from '~codeyam/types';
 import { ProjectAnalyzer } from '~codeyam/analyze';
 

package/analyzer-template/project/getScenarioUrl.ts

@@ -1,6 +1,17 @@
-import { Analysis, Project, ProjectFramework, Scenario, File } from '~codeyam/types';
+import {
+  Analysis,
+  Project,
+  ProjectFramework,
+  Scenario,
+  File,
+} from '~codeyam/types';
 import getScenarioPagePaths from './getScenarioPagePath';
-import { frameworkRouteFileNameToRoute, isFrameworkRoute, PROJECT_RELATIVE_PATH, getAppDirectoryForFile } from '~codeyam/utils';
+import {
+  frameworkRouteFileNameToRoute,
+  isFrameworkRoute,
+  PROJECT_RELATIVE_PATH,
+  getAppDirectoryForFile,
+} from '~codeyam/utils';
 
 export interface GetScenarioUrlArgs {
   project: Project;
@@ -10,6 +21,48 @@ export interface GetScenarioUrlArgs {
   framework: ProjectFramework;
 }
 
+/**
+ * Extract route params from scenario data for URL generation.
+ * Handles array values (for catch-all routes) by joining them.
+ *
+ * Scenario data can be stored in two locations:
+ * - scenario.data.argumentsData (primary)
+ * - scenario.metadata.data.argumentsData (fallback)
+ *
+ * @param scenario - The scenario containing mock data
+ * @returns A record of param names to string values, or undefined if no params
+ */
+function extractRouteParamsFromScenario(
+  scenario: Scenario,
+): Record<string, string | string[]> | undefined {
+  // Check both possible locations for argumentsData
+  const argumentsData =
+    scenario.data?.argumentsData ?? scenario.metadata?.data?.argumentsData;
+
+  if (!Array.isArray(argumentsData) || argumentsData.length === 0) {
+    return undefined;
+  }
+
+  const params = (argumentsData[0] as Record<string, unknown>)?.params;
+  if (!params || typeof params !== 'object') {
+    return undefined;
+  }
+
+  // Convert all values to strings or string arrays
+  const result: Record<string, string | string[]> = {};
+  for (const [key, value] of Object.entries(
+    params as Record<string, unknown>,
+  )) {
+    if (Array.isArray(value)) {
+      result[key] = value.map(String);
+    } else if (value !== null && value !== undefined) {
+      result[key] = String(value);
+    }
+  }
+
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+
 /**
  * Get the URL path for a scenario (the path that goes in the iframe src)
  * This is the same logic used in generateCodeYamPage.ts to determine the iframe src
@@ -40,7 +93,10 @@ export default function getScenarioUrl({
     case ProjectFramework.Next:
       // the routePath looks like: relative/path/app/123/static/c054b7ee-3961-4697-8354-886062a95a9d/default/page.tsx
       // the path should look like: static/123/c054b7ee-3961-4697-8354-886062a95a9d/default/0
-      const appDirectory = getAppDirectoryForFile(file.path, project.metadata?.webapps);
+      const appDirectory = getAppDirectoryForFile(
+        file.path,
+        project.metadata?.webapps,
+      );
       path = routePath
         .replace(PROJECT_RELATIVE_PATH + '/' + appDirectory + '/', '')
         .split('/')
@@ -50,7 +106,10 @@ export default function getScenarioUrl({
     case ProjectFramework.NextPages:
       // the routePath looks like: relative/path/app/123/static/c054b7ee-3961-4697-8354-886062a95a9d/default/page.tsx
       // the path should look like: static/123/c054b7ee-3961-4697-8354-886062a95a9d/default/0
-      const pagesDirectory = getAppDirectoryForFile(file.path, project.metadata?.webapps);
+      const pagesDirectory = getAppDirectoryForFile(
+        file.path,
+        project.metadata?.webapps,
+      );
       path = routePath
         .replace(PROJECT_RELATIVE_PATH + '/' + pagesDirectory + '/', '')
         .split('/')
@@ -62,7 +121,16 @@ export default function getScenarioUrl({
   }
 
   if (isFrameworkRoute(file, analysis.entity, framework)) {
-    path = frameworkRouteFileNameToRoute(project.slug, file, analysis, framework, scenario.name);
+    // Extract route params from scenario mock data for URL generation
+    const routeParams = extractRouteParamsFromScenario(scenario);
+    path = frameworkRouteFileNameToRoute(
+      project.slug,
+      file,
+      analysis,
+      framework,
+      scenario.name,
+      routeParams,
+    );
   }
 
   return `/${path}`;

package/analyzer-template/project/loadReadyToBeCaptured.ts

@@ -1,5 +1,9 @@
 import { AnalysisContext, discoverDirectDependencies } from '~codeyam/analyze';
-import { loadAnalysis, loadReadyToBeCapturedAnalyses } from '~codeyam/supabase';
+import {
+  loadAnalysis,
+  loadEntities,
+  loadReadyToBeCapturedAnalyses,
+} from '~codeyam/database';
 import { Analysis, Project } from '~codeyam/types';
 import { LazyFileStore } from './LazyFileStore';
 
@@ -11,6 +15,132 @@ interface LoadReadyToBeCapturedArgs {
   fileStore?: LazyFileStore;
 }
 
+/**
+ * Recursively gather all entities referenced in importedExports of entities already in context.
+ * This fills the gap where discoverDirectDependencies skips mocked/type/implicit imports,
+ * but writeScenarioComponents still needs those entities in the context.
+ */
+async function gatherAllReferencedEntities(
+  context: AnalysisContext,
+  project: Project,
+): Promise<void> {
+  const processedKeys = new Set<string>();
+  let iterationCount = 0;
+  const MAX_ITERATIONS = 20; // Safety limit to prevent infinite loops
+
+  const getAllEntities = () =>
+    Object.values(context.getMutableEntityMap()).flatMap(Object.values);
+
+  while (iterationCount < MAX_ITERATIONS) {
+    iterationCount++;
+
+    // Collect all (filePath, entityName) pairs from importedExports of entities in context
+    const missingEntities = new Map<
+      string,
+      { filePath: string; name: string }
+    >();
+
+    for (const entity of getAllEntities()) {
+      for (const ie of entity.metadata?.importedExports ?? []) {
+        const filePath = ie.resolvedFilePath ?? ie.filePath;
+        const entityName = ie.resolvedName ?? ie.name;
+        const key = `${filePath}:${entityName}`;
+
+        // Skip if already in context or already processed
+        if (context.getEntity(filePath, entityName) || processedKeys.has(key)) {
+          continue;
+        }
+
+        missingEntities.set(key, { filePath, name: entityName });
+      }
+    }
+
+    if (missingEntities.size === 0) {
+      break; // No more missing entities
+    }
+
+    console.log(
+      `CodeYam: Entity gathering iteration ${iterationCount}: Loading ${missingEntities.size} missing entities`,
+    );
+
+    // Mark all as processed before loading to prevent re-processing
+    for (const key of missingEntities.keys()) {
+      processedKeys.add(key);
+    }
+
+    // Group by file path for batch loading
+    const byFilePath = new Map<string, string[]>();
+    for (const { filePath, name } of missingEntities.values()) {
+      if (!byFilePath.has(filePath)) {
+        byFilePath.set(filePath, []);
+      }
+      byFilePath.get(filePath)!.push(name);
+    }
+
+    // Batch load entities by file path
+    const loadPromises = Array.from(byFilePath.entries()).map(
+      async ([filePath, names]) => {
+        const entities = await loadEntities({
+          projectId: project.id,
+          filePaths: [filePath],
+        });
+
+        if (!entities) return [];
+
+        // Filter to only the entities we need (loadEntities returns all for the file)
+        // Special handling: if we requested 'default' and got a default export entity,
+        // include it even though the name doesn't match (entities are stored by actual name, not 'default')
+        return entities.filter((e) => {
+          if (names.includes(e.name)) {
+            return true;
+          }
+          // If we requested 'default' and this is a default export, include it
+          if (
+            names.includes('default') &&
+            e.metadata &&
+            !e.metadata.notExported &&
+            !e.metadata.namedExport
+          ) {
+            return true;
+          }
+          return false;
+        });
+      },
+    );
+
+    const results = await Promise.all(loadPromises);
+    const loadedEntities = results.flat();
+
+    // Add loaded entities to context
+    for (const entity of loadedEntities) {
+      context.addEntity(entity);
+
+      // Also register under 'default' alias if it's a default export
+      if (
+        entity.metadata &&
+        !entity.metadata.notExported &&
+        !entity.metadata.namedExport
+      ) {
+        context.addEntity(entity, 'default');
+      }
+    }
+
+    console.log(
+      `CodeYam: Loaded ${loadedEntities.length} entities in iteration ${iterationCount}`,
+    );
+  }
+
+  if (iterationCount >= MAX_ITERATIONS) {
+    console.log(
+      `CodeYam Warning: Entity gathering reached max iterations (${MAX_ITERATIONS}), some entities may be missing`,
+    );
+  }
+
+  console.log(
+    `CodeYam: Entity gathering complete after ${iterationCount} iteration(s), context has ${getAllEntities().length} entities`,
+  );
+}
+
 /**
  * Load the minimal set of analyses required to successfully run scenario capture.
  * This includes the root analyses (with scenarios) plus all recursive mock dependencies.
@@ -145,7 +275,7 @@ export default async function loadReadyToBeCaptured({
     `CodeYam: Loaded ${allRequiredAnalyses.size} total analyses for scenario capture`,
   );
 
-  // Populate the provided analysis context
+  // Populate the provided analysis context with analyses and their direct entities
   for (const analysis of allRequiredAnalyses.values()) {
     // Add the entity if it exists
     if (analysis.entity) {
@@ -156,6 +286,12 @@ export default async function loadReadyToBeCaptured({
     context.addAnalysis(analysis, analysis.filePath, analysis.entityName);
   }
 
+  // Recursively gather ALL entities referenced in importedExports.
+  // This is necessary because discoverDirectDependencies only finds entities that need
+  // ANALYSES loaded (skipping mocked imports, type imports, etc.), but writeScenarioComponents
+  // needs ALL entities in the context for import path rewriting and recursion.
+  await gatherAllReferencedEntities(context, project);
+
   // Extract the root analyses with scenarios from allRequiredAnalyses (they were reloaded with mocks)
   const finalReadyToBeCaptured = readyToBeCapturedAnalyses.map(
     (originalAnalysis) => {

package/analyzer-template/project/orchestrateCapture/KyselyAnalysisLoader.ts

@@ -1,5 +1,5 @@
 import type { Commit, Project } from '~codeyam/types';
-import { getDatabase } from '~codeyam/supabase';
+import { getDatabase } from '~codeyam/database';
 import { sql } from 'kysely';
 import type { AnalysisLoader, ReadyAnalysisData } from './taskRunner';
 
@@ -46,21 +46,20 @@ export default class KyselyAnalysisLoader implements AnalysisLoader {
             'status',
           ])
           // Base condition: readyToBeCaptured = true
-          .where(
-            sql<string>` ${sql.ref('status')} -> 'readyToBeCaptured'`,
-            '=',
-            'true',
+          // Use json_extract for SQLite (returns 1 for boolean true)
+          .where((eb) =>
+            eb(
+              sql`json_extract(${sql.ref('status')}, '$.readyToBeCaptured')`,
+              '=',
+              sql`1`,
+            ),
           )
           // Project filter (always required)
           .where('project_id', '=', this.config.project.id);
 
         // Optional: branch commit SHA filter
         if (this.config.commit?.metadata?.baseline) {
-          query = query.where(
-            'branch_commit_sha',
-            '=',
-            this.config.commit.sha,
-          );
+          query = query.where('branch_commit_sha', '=', this.config.commit.sha);
         }
 
         // Optional: commit ID filter
@@ -98,11 +97,11 @@ export default class KyselyAnalysisLoader implements AnalysisLoader {
             return false;
           }
 
-          // Check: has incomplete scenarios
+          // Check: has scenarios needing capture
           // Include if:
           // - No scenarios field
           // - Empty scenarios array
-          // - At least one scenario without finishedAt or error
+          // - At least one scenario that needs capture (no finishedAt OR has error)
           const scenarios = status?.scenarios;
           if (!scenarios || !Array.isArray(scenarios)) {
             return true; // No scenarios field
@@ -111,12 +110,16 @@ export default class KyselyAnalysisLoader implements AnalysisLoader {
             return true; // Empty array
           }
 
-          // Check if at least one scenario is incomplete
-          const hasIncompleteScenario = scenarios.some(
+          // Check if at least one scenario needs capture
+          // A scenario needs capture if it has no finishedAt AND no error
+          // (i.e., it hasn't been attempted yet)
+          // Scenarios with finishedAt are complete (successful)
+          // Scenarios with error are complete (failed, not retried automatically)
+          const needsCapture = scenarios.some(
             (scenario: any) => !scenario.finishedAt && !scenario.error,
           );
 
-          return hasIncompleteScenario;
+          return needsCapture;
         });
 
         // Map to ReadyAnalysisData, excluding the status field

package/analyzer-template/project/orchestrateCapture/SequentialCaptureTaskRunner.ts

@@ -37,7 +37,10 @@ import {
 export interface SequentialCaptureTaskRunnerContext {
   absoluteProjectRootPath: string;
   absoluteTempPath?: string;
-  startArgs: StartArgs;
+  startArgs: Omit<
+    StartArgs,
+    'absoluteProjectRootPath' | 'absoluteTempPath' | 'noServer' | 'fast'
+  >;
   /** Universal mocks to apply to the capturer's project directory */
   universalMocks?: UniversalMock[];
   /** Environment variables to pass to the spawned processes */
@@ -72,8 +75,6 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
     config: TaskRunnerConfig,
     context: SequentialCaptureTaskRunnerContext,
   ): Promise<SequentialCaptureTaskRunner> {
-    console.log('CodeYam DEBUG: Creating SequentialCaptureTaskRunner...');
-
     // Validate that cwd and project path share parent directory
     // Use realpathSync to resolve symlinks (e.g., /tmp -> /private/tmp on macOS)
     const parentOfCodeyam = fs.realpathSync(path.dirname(process.cwd()));
@@ -90,56 +91,59 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
 
     // Derive paths
     const parentDir = parentOfCodeyam;
-    const capturerPath = path.normalize(path.join(parentDir, 'capturer-1'));
+
+    // In CAPTURE_ONLY mode, run directly from the main project folder (skip rsync)
+    // This preserves any manual edits made to generated files
+    const captureOnly = process.env.CAPTURE_ONLY === 'true';
+    const capturerPath = captureOnly
+      ? parentDir
+      : path.normalize(path.join(parentDir, 'capturer-1'));
 
     console.log(`CodeYam: Sequential runner using capturer at ${capturerPath}`);
 
-    // Create capturer base directory
-    if (!fs.existsSync(capturerPath)) {
+    if (captureOnly) {
       console.log(
-        `CodeYam DEBUG: Creating capturer directory at ${capturerPath}`,
+        'CodeYam: CAPTURE_ONLY mode - running from main project folder, skipping rsync',
       );
-      fs.mkdirSync(capturerPath, { recursive: true });
-    }
+    } else {
+      // Create capturer base directory
+      if (!fs.existsSync(capturerPath)) {
+        fs.mkdirSync(capturerPath, { recursive: true });
+      }
 
-    // Copy both codeyam/ and project/ into capturer-1/
-    // start.ts waits for repo checkout to complete before creating this runner
-    console.log('CodeYam: Copying codeyam/ and project/ to capturer-1/...');
-    await rsyncCopy({
-      sourcePath: parentDir,
-      destinationPath: capturerPath,
-      excludes: ['codeyam/log.txt', 'capturer-*'],
-      silent: false,
-    });
-    console.log('CodeYam DEBUG: Directory copy completed');
-
-    // Sanitize env files in capturer project (replaces real values with mock placeholders)
-    const capturerProjectPath = path.join(capturerPath, 'project');
-    console.log('CodeYam: Sanitizing env files in capturer project...');
-    console.log(`CodeYam DEBUG: capturerProjectPath = ${capturerProjectPath}`);
-    const sanitizeResult = sanitizeEnvFiles({
-      projectPath: capturerProjectPath,
-      log: (msg) => console.log(`CodeYam Sanitize: ${msg}`),
-    });
-    console.log(
-      `CodeYam DEBUG: Env files sanitized - created: ${sanitizeResult.createdFiles.length}, sanitized: ${sanitizeResult.sanitizedFiles.length}`,
-    );
-    if (sanitizeResult.sanitizedFiles.length > 0) {
-      console.log(
-        `CodeYam DEBUG: Sanitized files: ${sanitizeResult.sanitizedFiles.join(', ')}`,
-      );
-    }
+      // Copy both codeyam/ and project/ into capturer-1/
+      // start.ts waits for repo checkout to complete before creating this runner
+      console.log('CodeYam: Copying codeyam/ and project/ to capturer-1/...');
+      await rsyncCopy({
+        sourcePath: parentDir,
+        destinationPath: capturerPath,
+        excludes: ['codeyam/log.txt', 'capturer-*'],
+        silent: false,
+      });
 
-    // Apply universal mocks to capturer project
-    if (context.universalMocks && context.universalMocks.length > 0) {
-      console.log(
-        `CodeYam: Applying ${context.universalMocks.length} universal mock(s) to capturer project...`,
-      );
-      await applyUniversalMocks({
-        mocks: context.universalMocks,
+      // Sanitize env files in capturer project (replaces real values with mock placeholders)
+      const capturerProjectPath = path.join(capturerPath, 'project');
+      console.log('CodeYam: Sanitizing env files in capturer project...');
+      const sanitizeResult = sanitizeEnvFiles({
         projectPath: capturerProjectPath,
+        log: (msg) => console.log(`CodeYam Sanitize: ${msg}`),
       });
-      console.log('CodeYam DEBUG: Universal mocks applied');
+      if (sanitizeResult.sanitizedFiles.length > 0) {
+        console.log(
+          `CodeYam: Env files sanitized: ${sanitizeResult.sanitizedFiles.join(', ')}`,
+        );
+      }
+
+      // Apply universal mocks to capturer project
+      if (context.universalMocks && context.universalMocks.length > 0) {
+        console.log(
+          `CodeYam: Applying ${context.universalMocks.length} universal mock(s) to capturer project...`,
+        );
+        await applyUniversalMocks({
+          mocks: context.universalMocks,
+          projectPath: capturerProjectPath,
+        });
+      }
     }
 
     const runner = new SequentialCaptureTaskRunner(
@@ -150,12 +154,8 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
 
     // Start background processing loop
     // Each batch will spawn its own paired start+capture processes
-    console.log('CodeYam DEBUG: Starting processing loop...');
     runner.startProcessingLoop();
 
-    console.log(
-      'CodeYam DEBUG: SequentialCaptureTaskRunner created successfully',
-    );
     return runner;
   }
 
@@ -179,23 +179,18 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
   }
 
   private async runProcessingLoop(): Promise<void> {
-    console.log('CodeYam DEBUG: Processing loop started');
     while (!this.isCleanedUp) {
       if (this.queue.length === 0) {
         await new Promise((resolve) => setTimeout(resolve, 1000));
         continue;
       }
 
-      console.log(
-        `CodeYam DEBUG: Processing queue - ${this.queue.length} batches waiting`,
-      );
       this.isProcessing = true;
       const batch = this.queue.shift()!;
 
       try {
         await this.processBatch(batch);
 
-        console.log(`CodeYam DEBUG: Batch completed successfully`);
         // Notify callback of completion
         if (this.batchCompletedCallback) {
           this.batchCompletedCallback(batch);
@@ -210,7 +205,6 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
         this.isProcessing = false;
       }
     }
-    console.log('CodeYam DEBUG: Processing loop exited');
   }
 
   private async processBatch(analysisIds: string[]): Promise<void> {
@@ -265,6 +259,10 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
         READY_TO_BE_CAPTURED: 'true',
         PROJECT_SLUG: this.config.projectSlug,
         CODEYAM_LOG_PATH: capturerLogPath,
+        // Pass CAPTURE_ONLY through from parent process to skip file regeneration
+        ...(process.env.CAPTURE_ONLY && {
+          CAPTURE_ONLY: process.env.CAPTURE_ONLY,
+        }),
       },
       workingDir: capturerCodeyamPath,
       processName: 'project',
@@ -298,14 +296,38 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
       }, timeoutMs);
     });
 
+    // Track which process exits first and when
+    const batchStartTime = Date.now();
+    let startExitCode: number | null = null;
+    let captureExitCode: number | null = null;
+    let firstToExit: 'start' | 'capture' | 'timeout' | null = null;
+
+    const startPromiseWithLogging = startResult.promise.then((code) => {
+      startExitCode = code;
+      if (!firstToExit) {
+        firstToExit = 'start';
+      }
+      return code;
+    });
+
+    const capturePromiseWithLogging = captureResult.promise.then((code) => {
+      captureExitCode = code;
+      if (!firstToExit) {
+        firstToExit = 'capture';
+      }
+      return code;
+    });
+
     try {
-      // Race: whichever finishes first (capture exits when done, or timeout)
+      // Wait for EITHER process to complete (or timeout)
+      // If start.js exits, we should investigate why - it shouldn't exit before capture is done
       await Promise.race([
-        captureResult.promise,
-        startResult.promise,
+        capturePromiseWithLogging,
+        startPromiseWithLogging,
         timeoutPromise,
       ]);
-      console.log('CodeYam: Batch processing completed successfully');
+      const elapsed = ((Date.now() - batchStartTime) / 1000).toFixed(1);
+      console.log(`CodeYam: Batch processing completed after ${elapsed}s`);
     } finally {
       // Clean up timeout handle
       if (timeoutHandle) {
@@ -330,9 +352,6 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
   }
 
   enqueueWork(analysisIds: string[]): Promise<void> {
-    console.log(
-      `CodeYam DEBUG: Enqueueing batch of ${analysisIds.length} analyses`,
-    );
     this.queue.push(analysisIds);
     return Promise.resolve();
   }

package/analyzer-template/project/orchestrateCapture/SupabaseAnalysisLoader.ts

@@ -1,5 +1,5 @@
 import type { Commit, Project } from '~codeyam/types';
-import { getSupabase } from '~codeyam/supabase';
+import { getSupabase } from '~codeyam/database';
 import type { AnalysisLoader, ReadyAnalysisData } from './taskRunner';
 
 interface SupabaseAnalysisLoaderConfig {
@@ -48,7 +48,7 @@ export default class SupabaseAnalysisLoader implements AnalysisLoader {
     let pageOffset = 0;
 
     while (true) {
-      const query = getSupabase()
+      const { data, error } = await getSupabase()
         .rpc('get_ready_to_be_captured_analyses', args)
         .select(
           'id, commit_id, branch_commit_sha, status->processingForCaptureAt',
@@ -56,7 +56,7 @@ export default class SupabaseAnalysisLoader implements AnalysisLoader {
         .range(pageOffset, pageOffset + pageSize - 1)
         .returns<ReadyAnalysisData[]>();
 
-      const { data, error } = await query;
+      const rows = data as ReadyAnalysisData[] | null;
 
       if (error) {
         console.error(
@@ -67,13 +67,13 @@ export default class SupabaseAnalysisLoader implements AnalysisLoader {
         return null;
       }
 
-      if (!data || data.length === 0) {
+      if (!rows || rows.length === 0) {
         break;
       }
 
-      allData.push(...data);
+      allData.push(...rows);
 
-      if (data.length < pageSize) {
+      if (rows.length < pageSize) {
         break;
       }