@codeyam/codeyam-cli 0.1.0-staging.da5baf5 → 0.1.0-staging.dd216e0

package/analyzer-template/packages/supabase/src/lib/kysely/db.ts

@@ -1,476 +0,0 @@
-import SQLiteDatabase from 'better-sqlite3';
-import { Pool, PoolClient } from 'pg';
-import * as fs from 'fs';
-import * as path from 'path';
-import {
-  Kysely,
-  LogEvent,
-  ParseJSONResultsPlugin,
-  PostgresDialect,
-  sql,
-  SqliteDialect,
-} from 'kysely';
-
-import * as sqliteHelper from 'kysely/helpers/sqlite';
-import * as pgHelper from 'kysely/helpers/postgres';
-
-import { SqliteBooleanPlugin } from './sqliteBooleanPlugin';
-
-import { createProjectsTable, ProjectsTable } from './tables/projectsTable';
-import { AnalysesTable, createAnalysesTable } from './tables/analysesTable';
-import {
-  AnalysisBranchesTable,
-  createAnalysisBranchesTable,
-} from './tables/analysisBranchesTable';
-import {
-  BackgroundJobsTable,
-  createBackgroundJobsTable,
-} from './tables/backgroundJobsTable';
-import { BranchesTable, createBranchesTable } from './tables/branchesTable';
-import {
-  CommitBranchesTable,
-  createCommitBranchesTable,
-} from './tables/commitBranchesTable';
-import { CommitsTable, createCommitsTable } from './tables/commitsTable';
-import { createEntitiesTable, EntitiesTable } from './tables/entitiesTable';
-import {
-  createEntityBranchesTable,
-  EntityBranchesTable,
-} from './tables/entityBranchesTable';
-import {
-  createEntityStatementsTable,
-  EntityStatementsTable,
-} from './tables/entityStatementsTable';
-import { createFilesTable, FilesTable } from './tables/filesTable';
-import {
-  createGithubPayloadsTable,
-  GithubPayloadsTable,
-} from './tables/githubPayloadsTable';
-import {
-  createGithubUsersTable,
-  GithubUsersTable,
-} from './tables/githubUsersTable';
-import {
-  createScenarioCommentsTable,
-  ScenarioCommentsTable,
-} from './tables/scenarioCommentsTable';
-import { createScenariosTable, ScenariosTable } from './tables/scenariosTable';
-import {
-  createStatementsTable,
-  StatementsTable,
-} from './tables/statementsTable';
-import { createTeamsTable, TeamsTable } from './tables/teamsTable';
-import {
-  createUserScenariosTable,
-  UserScenariosTable,
-} from './tables/userScenariosTable';
-import { createUserTeamsTable, UserTeamsTable } from './tables/userTeamsTable';
-import { createUsersTable, UsersTable } from './tables/usersTable';
-
-import { schemaField } from './schemaHelpers';
-
-// import { loadEnv } from '~codeyam/utils/server';
-
-// loadEnv(); // Commented out - causing Vite SSR issues, and it's just a placeholder anyway
-
-const ENABLE_QUERY_LOGGING = !!getEnvVar('ENABLE_QUERY_LOGGING');
-const ENABLE_QUERY_ERROR_LOGGING = !!getEnvVar('ENABLE_QUERY_ERROR_LOGGING');
-
-// PostgreSQL testing mode:
-// - uses a dedicated 'codeyam_tests' schema
-//   - run scripts/create-local-psql-test-schema.sh to set that up
-// - requires jest to be invoked with --runInBand, to avoid tests clobbering
-//   each other's data – it's a single shared database
-const USE_LOCAL_POSTGRESQL_FOR_TESTING =
-  getEnvVar('USE_LOCAL_POSTGRESQL_FOR_TESTING') === 'true';
-
-const CODEYAM_TESTS_SCHEMA_NAME = 'codeyam_tests';
-
-// define the Kysely database as an object instance so we can enumerate
-// our tables in runtime, while still creating the Database type for Kysely
-// using type inference flow (below).
-const databaseSchema = {
-  projects: schemaField<ProjectsTable>(),
-  analyses: schemaField<AnalysesTable>(),
-  analysis_branches: schemaField<AnalysisBranchesTable>(),
-  background_jobs: schemaField<BackgroundJobsTable>(),
-  branches: schemaField<BranchesTable>(),
-  commit_branches: schemaField<CommitBranchesTable>(),
-  commits: schemaField<CommitsTable>(),
-  entities: schemaField<EntitiesTable>(),
-  entity_branches: schemaField<EntityBranchesTable>(),
-  entity_statements: schemaField<EntityStatementsTable>(),
-  files: schemaField<FilesTable>(),
-  github_payloads: schemaField<GithubPayloadsTable>(),
-  github_users: schemaField<GithubUsersTable>(),
-  scenario_comments: schemaField<ScenarioCommentsTable>(),
-  scenarios: schemaField<ScenariosTable>(),
-  statements: schemaField<StatementsTable>(),
-  teams: schemaField<TeamsTable>(),
-  user_scenarios: schemaField<UserScenariosTable>(),
-  user_teams: schemaField<UserTeamsTable>(),
-  users: schemaField<UsersTable>(),
-} as const;
-
-// This is the core Database type used by Kysely everywhere
-export type Database = {
-  [K in keyof typeof databaseSchema]: (typeof databaseSchema)[K];
-};
-
-// Get columns at runtime
-export const databaseTableNames = Object.keys(
-  databaseSchema,
-) as (keyof Database)[];
-
-let db: Kysely<Database> | undefined;
-
-export function getDatabase(): Kysely<Database> {
-  if (!db) {
-    const dbType = determineDatabaseType();
-
-    if (dbType === 'sqlite') {
-      db = getSqliteDatabase();
-    } else if (dbType === 'postgresql') {
-      db = getPostgreDatabase();
-    } else {
-      throw new Error(`Unknown database type: ${dbType}`);
-    }
-  }
-  return db;
-}
-
-/**
- * Sets the SQLite database path and resets the database singleton.
- * Useful for testing/benchmarking scenarios where you need to switch databases.
- */
-export async function setSqlitePath(path: string): Promise<void> {
-  if (db) {
-    await db.destroy();
-    db = undefined;
-  }
-  process.env.SQLITE_PATH = path;
-}
-
-/**
- * Closes the current database connection and resets the singleton.
- * Useful for cleanup in testing/benchmarking scenarios.
- */
-export async function closeDatabase(): Promise<void> {
-  if (db) {
-    await db.destroy();
-    db = undefined;
-  }
-}
-
-let warnedAboutTestDb = false;
-
-export function getSqliteDatabase(sqlitePath?: string) {
-  if (!sqlitePath) {
-    sqlitePath = getEnvVar('SQLITE_PATH');
-  }
-  if (sqlitePath === ':memory:' || sqlitePath === 'memory') {
-    throw new Error(
-      'In-memory SQLite not supported in getDatabase(). Use getDatabaseForTesting() instead.',
-    );
-  }
-
-  const dbFileExistsBeforeOpen = fs.existsSync(sqlitePath);
-
-  // Ensure the parent directory exists and has proper permissions
-  // This prevents SQLITE_READONLY_DBMOVED errors when creating new databases
-  const dbDir = path.dirname(sqlitePath);
-
-  if (!fs.existsSync(dbDir)) {
-    fs.mkdirSync(dbDir, { recursive: true, mode: 0o755 });
-  } else {
-    // Ensure directory is writable (needed for SQLite journal files)
-    try {
-      fs.chmodSync(dbDir, 0o755);
-    } catch (error) {
-      console.warn(
-        `Warning: Could not set permissions on database directory: ${(error as Error).message}`,
-      );
-    }
-  }
-
-  // Explicitly open database in readwrite mode to prevent "attempt to write a readonly database" errors
-  // This can happen when copying databases between directories or when file permissions are ambiguous
-  const sqlite = new SQLiteDatabase(sqlitePath, {
-    readonly: false,
-    fileMustExist: false,
-  });
-  sqlite.pragma('journal_mode = WAL');
-  sqlite.pragma('synchronous = FULL');
-
-  // Verify the database has the expected schema
-  // If fileMustExist=false and the file didn't exist or was corrupted, SQLite creates a new empty database
-  if (!process.env.CLAUDE_CODE_MODE) {
-    try {
-      const tableCheck = sqlite
-        .prepare(
-          "SELECT COUNT(*) as count FROM sqlite_master WHERE type='table' AND name='projects'",
-        )
-        .get() as { count: number };
-
-      if (dbFileExistsBeforeOpen && tableCheck.count === 0) {
-        console.error(
-          'CodeYam DB ERROR: Database file existed but projects table is missing!',
-        );
-        console.error(
-          'This likely means SQLite created a new empty database instead of opening the existing one.',
-        );
-        console.error(
-          'Possible causes: corruption, WAL file issues, or file locking problems.',
-        );
-      }
-    } catch (error) {
-      console.error(
-        'CodeYam DB ERROR: Failed to verify database schema:',
-        error,
-      );
-    }
-  }
-  return new Kysely<Database>({
-    dialect: new SqliteDialect({ database: sqlite }),
-    plugins: [new ParseJSONResultsPlugin(), new SqliteBooleanPlugin()],
-    log: onQueryLogEvent,
-  });
-}
-
-export function getPostgreDatabase() {
-  const connectionString = getPostgresConnectionString();
-  console.log(`CodeYam: Using PostgreSQL database at: ${connectionString}`);
-  const pool = new Pool({ connectionString });
-  pool.on('error', (err: Error, _client: PoolClient) => {
-    console.error('CodeYam: Unexpected error on idle PostgreSQL client', err);
-  });
-  return new Kysely<Database>({
-    dialect: new PostgresDialect({ pool }),
-    log: onQueryLogEvent,
-  });
-}
-// Async database creation for testing only
-export async function getDatabaseForTesting(
-  dbPath = ':memory:',
-): Promise<Kysely<Database>> {
-  if (USE_LOCAL_POSTGRESQL_FOR_TESTING) {
-    if (!warnedAboutTestDb) {
-      console.log(
-        `ℹ️  Using PostgreSQL for tests (schema: ${CODEYAM_TESTS_SCHEMA_NAME})`,
-      );
-      warnedAboutTestDb = true;
-    }
-
-    const connectionString = getPostgresConnectionString();
-    validateLocalhostOnly(connectionString);
-
-    const pool = new Pool({
-      connectionString,
-      max: 1, // Single connection for tests
-      // Set search_path to use test schema
-      options: `-c search_path=${CODEYAM_TESTS_SCHEMA_NAME}`,
-    });
-    pool.on('error', (err: Error, _client: PoolClient) => {
-      console.error(
-        'CodeYam: Unexpected error on idle PostgreSQL client in test pool',
-        err,
-      );
-    });
-    const kyselyDb = new Kysely<Database>({
-      dialect: new PostgresDialect({ pool }),
-      plugins: [new ParseJSONResultsPlugin()], // No SQLite boolean plugin for PostgreSQL
-      log: onQueryLogEvent,
-    });
-
-    await clearPostgreSQLData(kyselyDb);
-    return kyselyDb;
-  } else {
-    // Standard SQLite testing path
-    const sqlite = new SQLiteDatabase(dbPath);
-    sqlite.pragma('journal_mode = WAL');
-    sqlite.pragma('synchronous = FULL');
-    const kyselyDb = new Kysely<Database>({
-      dialect: new SqliteDialect({ database: sqlite }),
-      plugins: [new ParseJSONResultsPlugin(), new SqliteBooleanPlugin()],
-      log: onQueryLogEvent,
-    });
-
-    await createSqliteSchema(kyselyDb);
-    return kyselyDb;
-  }
-}
-
-let jsonHelper: ReturnType<typeof createJsonHelper> | null = null;
-
-export function getJsonHelper() {
-  if (!jsonHelper) {
-    jsonHelper = createJsonHelper(determineDatabaseType());
-  }
-  return jsonHelper;
-}
-
-export function getJsonHelperForTesting() {
-  return createJsonHelper(
-    USE_LOCAL_POSTGRESQL_FOR_TESTING ? 'postgresql' : 'sqlite',
-  );
-}
-
-function onQueryLogEvent(event: LogEvent) {
-  if (event.level === 'error') {
-    if (ENABLE_QUERY_ERROR_LOGGING) {
-      console.error('Query failed : ', {
-        durationMs: event.queryDurationMillis,
-        error: event.error,
-        sql: event.query.sql,
-        params: event.query.parameters,
-      });
-    }
-  } else if (ENABLE_QUERY_LOGGING) {
-    // `'query'`
-    console.log('Query executed : ', {
-      durationMs: event.queryDurationMillis,
-      sql: event.query.sql,
-      params: event.query.parameters,
-    });
-  }
-}
-
-function createJsonHelper(dbType: 'postgresql' | 'sqlite') {
-  if (dbType === 'sqlite') {
-    return sqliteHelper;
-  } else if (dbType === 'postgresql') {
-    return pgHelper;
-  } else {
-    throw new Error(`Unknown database type: ${dbType}`);
-  }
-}
-
-function determineDatabaseType(): 'postgresql' | 'sqlite' {
-  const sqlitePath = getEnvVar('SQLITE_PATH');
-  if (sqlitePath) {
-    return 'sqlite';
-  }
-
-  // Check for PostgreSQL connection strings
-  const postgresUrl = getEnvVar('POSTGRESQL_URL');
-  if (postgresUrl) {
-    return 'postgresql';
-  }
-
-  throw new Error(
-    'No database configuration found. Set SQLITE_PATH for SQLite or POSTGRESQL_URL for PostgreSQL',
-  );
-}
-
-export async function createSqliteSchema(db: Kysely<Database>): Promise<void> {
-  // Create all tables needed for testing
-  // TODO: If this takes non-trivial time, we can maybe do it concurrently?
-  await createProjectsTable(db);
-  await createAnalysesTable(db);
-  await createAnalysisBranchesTable(db);
-  await createBackgroundJobsTable(db);
-  await createBranchesTable(db);
-  await createCommitBranchesTable(db);
-  await createCommitsTable(db);
-  await createEntitiesTable(db);
-  await createEntityBranchesTable(db);
-  await createEntityStatementsTable(db);
-  await createFilesTable(db);
-  await createGithubPayloadsTable(db);
-  await createGithubUsersTable(db);
-  await createScenarioCommentsTable(db);
-  await createScenariosTable(db);
-  await createStatementsTable(db);
-  await createTeamsTable(db);
-  await createUserScenariosTable(db);
-  await createUserTeamsTable(db);
-  await createUsersTable(db);
-}
-
-let warnedAboutClear = false;
-
-// Clears all data from the test schema (codeyam_tests) tables
-// Tables must already exist (created by scripts/create-local-psql-test-schema.sh)
-async function clearPostgreSQLData(db: Kysely<Database>): Promise<void> {
-  if (!warnedAboutClear) {
-    console.log(`🗑️  Clearing test schema (${CODEYAM_TESTS_SCHEMA_NAME})...`);
-  }
-
-  // Delete in reverse dependency order (child tables first)
-  // Using the dynamically generated table names from schema
-  const tablesToClear = [...databaseTableNames].reverse();
-
-  // For testing, we can use TRUNCATE for better performance and to reset sequences
-  // But fallback to DELETE if TRUNCATE fails due to foreign key constraints
-  for (const tableName of tablesToClear) {
-    try {
-      // Try TRUNCATE first for better performance
-      await sql`TRUNCATE TABLE ${sql.ref(tableName)} CASCADE`.execute(db);
-    } catch (error) {
-      console.warn(
-        `TRUNCATE failed for ${tableName}, falling back to DELETE:`,
-        error,
-      );
-      try {
-        // Fallback to DELETE FROM if TRUNCATE fails
-        await db.deleteFrom(tableName as any).execute();
-      } catch (deleteError) {
-        console.error(`Failed to clear table ${tableName}:`, deleteError);
-        // Continue with other tables - don't fail the entire test setup
-      }
-    }
-  }
-
-  if (!warnedAboutClear) {
-    console.log('✅ Test schema cleared.');
-    warnedAboutClear = true;
-  }
-}
-
-// Safety check to ensure we're only wiping localhost databases
-function validateLocalhostOnly(connectionString: string): void {
-  try {
-    const url = new URL(connectionString.replace('postgresql://', 'http://'));
-    const allowedHosts = ['localhost', '127.0.0.1', '::1'];
-
-    if (!allowedHosts.some((host) => url.hostname.includes(host))) {
-      throw new Error(
-        `🚨 SAFETY ERROR: PostgreSQL testing is only allowed on localhost!\n` +
-          `Current host: ${url.hostname}\n` +
-          `Set USE_LOCAL_POSTGRESQL_FOR_TESTING=false to disable PostgreSQL testing.\n` +
-          `If you need to test against a remote database, please review the safety implications.`,
-      );
-    }
-
-    // console.warn(`🔒 Validated localhost connection: ${url.hostname}`);
-  } catch (error) {
-    if (error instanceof Error && error.message.includes('SAFETY ERROR')) {
-      throw error; // Re-throw our safety errors
-    }
-
-    // If URL parsing fails, be extra cautious and block
-    throw new Error(
-      `🚨 SAFETY ERROR: Could not validate connection string format.\n` +
-        `For safety, PostgreSQL testing is blocked.\n` +
-        `Connection string: ${connectionString}\n` +
-        `Error: ${error}`,
-    );
-  }
-}
-
-function getPostgresConnectionString(): string {
-  // Check for direct PostgreSQL connection strings first
-  const postgresUrl = getEnvVar('POSTGRESQL_URL');
-  if (!postgresUrl) {
-    throw new Error(
-      'No PostgreSQL connection string found. Set POSTGRESQL_URL environment variable.',
-    );
-  }
-  return postgresUrl;
-}
-
-function getEnvVar(key: string): string | undefined {
-  return typeof window !== 'undefined'
-    ? (window as any).env?.[key]
-    : process.env[key];
-}

package/analyzer-template/packages/supabase/src/lib/kysely/tableRelations.ts

@@ -1,105 +0,0 @@
-import { type Selectable } from 'kysely';
-import { UserScenariosTable } from './tables/userScenariosTable';
-import { AnalysesTable } from './tables/analysesTable';
-import { AnalysisBranchesTable } from './tables/analysisBranchesTable';
-import { BackgroundJobsTable } from './tables/backgroundJobsTable';
-import { BranchesTable } from './tables/branchesTable';
-import { CommitsTable } from './tables/commitsTable';
-import { CommitBranchesTable } from './tables/commitBranchesTable';
-import { EntitiesTable } from './tables/entitiesTable';
-import { EntityBranchesTable } from './tables/entityBranchesTable';
-import { FilesTable } from './tables/filesTable';
-import { ProjectsTable } from './tables/projectsTable';
-import { ScenariosTable } from './tables/scenariosTable';
-import { ScenarioCommentsTable } from './tables/scenarioCommentsTable';
-import { UsersTable } from './tables/usersTable';
-import { GithubUsersTable } from './tables/githubUsersTable';
-import { StatementsTable } from './tables/statementsTable';
-
-/**
- * A module for the 'select' perspective on our database tables, but with
- * relations (e.g. from joins) mixed in.
- */
-
-export type DbAnalysisBranch = Selectable<AnalysisBranchesTable> & {
-  analysis?: DbAnalysis;
-  branch?: DbBranch;
-  entity?: DbEntity;
-};
-
-export type DbAnalysis = Selectable<AnalysesTable> & {
-  entity?: DbEntity;
-  file?: DbFile;
-  commit?: DbCommit;
-  project?: DbProject;
-  scenarios?: DbScenario[];
-  analysis_branches?: DbAnalysisBranch[];
-};
-
-export type DbBackgroundJob = Selectable<BackgroundJobsTable>;
-
-export type DbBranch = Selectable<BranchesTable> & {
-  commits?: DbCommit[];
-  analysis_branches?: DbAnalysisBranch[];
-};
-
-export type DbCommit = Selectable<CommitsTable> & {
-  author?: DbCommitAuthor;
-  branch?: DbBranch;
-  background_jobs?: DbBackgroundJob[];
-  mergedBranch?: DbBranch;
-  analyses?: DbAnalysis[];
-  entities?: DbEntity[];
-  commit_branches?: DbCommitBranch[];
-};
-
-// virtual schema for joined author data (see loadCommit.ts)
-export type DbCommitAuthor = {
-  username: string;
-  avatarUrl: string;
-  preferredUsername?: string;
-};
-
-export type DbCommitBranch = Selectable<CommitBranchesTable> & {
-  commit?: DbCommit;
-  branch?: DbBranch;
-};
-
-export type DbEntityBranch = Selectable<EntityBranchesTable> & {
-  entity?: DbEntity;
-};
-
-export type DbEntity = Selectable<EntitiesTable> & {
-  analyses?: DbAnalysis[];
-  commit?: DbCommit;
-  entity_branches?: DbEntityBranch[];
-};
-
-export type DbFile = Selectable<FilesTable>;
-
-export type DbProject = Selectable<ProjectsTable> & {
-  branches?: Selectable<BranchesTable>[];
-  files?: Selectable<FilesTable>[];
-};
-
-export type DbScenarioComment = Selectable<ScenarioCommentsTable> & {
-  user?: DbUser;
-};
-
-export type DbScenario = Selectable<ScenariosTable> & {
-  analysis?: DbAnalysis;
-  user_scenarios?: DbUserScenario[];
-  scenario_comments?: DbScenarioComment[];
-};
-
-export type DbGithubUser = Selectable<GithubUsersTable>;
-
-export type DbUser = Selectable<UsersTable> & {
-  github_user?: DbGithubUser;
-};
-
-export type DbUserScenario = Selectable<UserScenariosTable> & {
-  user?: DbUser;
-};
-
-export type DbStatement = Selectable<StatementsTable>;