@codeyam/codeyam-cli 0.1.0-bleeding-edge.8afd3ee

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

@@ -0,0 +1,476 @@
+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/schemaHelpers.ts

@@ -0,0 +1,18 @@
+import { ColumnDefinitionBuilder, sql } from 'kysely';
+
+// turns
+//   { foo: schemaField<string>() }
+// into
+//   { foo: null as unknown as string }
+// for our database & table definitions
+export const schemaField = <T>() => null as unknown as T;
+
+export function defaultNow(shouldBeNotNull: boolean = false) {
+  return (col: ColumnDefinitionBuilder) => {
+    col = col.defaultTo(sql`CURRENT_TIMESTAMP`);
+    if (shouldBeNotNull) {
+      col = col.notNull();
+    }
+    return col;
+  };
+}

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

@@ -0,0 +1,46 @@
+import {
+  KyselyPlugin,
+  OperationNodeTransformer,
+  PluginTransformQueryArgs,
+  PluginTransformResultArgs,
+  PrimitiveValueListNode,
+  QueryResult,
+  RootOperationNode,
+  UnknownRow,
+  ValueNode,
+} from 'kysely';
+
+export class SqliteBooleanPlugin implements KyselyPlugin {
+  readonly #transformer = new SqliteBooleanTransformer();
+
+  transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
+    return this.#transformer.transformNode(args.node);
+  }
+
+  transformResult(
+    args: PluginTransformResultArgs,
+  ): Promise<QueryResult<UnknownRow>> {
+    return Promise.resolve(args.result);
+  }
+}
+
+class SqliteBooleanTransformer extends OperationNodeTransformer {
+  transformValue(node: ValueNode): ValueNode {
+    return {
+      ...super.transformValue(node),
+      value:
+        typeof node.value === 'boolean' ? (node.value ? 1 : 0) : node.value,
+    };
+  }
+
+  transformPrimitiveValueList(
+    node: PrimitiveValueListNode,
+  ): PrimitiveValueListNode {
+    return {
+      ...node,
+      values: node.values.map((value) =>
+        typeof value === 'boolean' ? (value ? 1 : 0) : value,
+      ),
+    };
+  }
+}

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

@@ -0,0 +1,105 @@
+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>;

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

@@ -0,0 +1,26 @@
+/**
+ * Client-safe type-only exports for database table relations.
+ * This file contains ONLY types and does not import Kysely table definitions,
+ * preventing pg/dotenv/better-sqlite3 from being pulled into client bundles.
+ */
+
+// Re-export only the TYPE definitions, not the runtime values
+export type {
+  DbAnalysisBranch,
+  DbAnalysis,
+  DbBackgroundJob,
+  DbBranch,
+  DbCommit,
+  DbCommitAuthor,
+  DbCommitBranch,
+  DbEntityBranch,
+  DbEntity,
+  DbFile,
+  DbProject,
+  DbScenarioComment,
+  DbScenario,
+  DbGithubUser,
+  DbUser,
+  DbUserScenario,
+  DbStatement,
+} from './tableRelations';