@ismaelsoilet/synapsejs 1.1.0

package/src/compiler/schema-drift.ts

@@ -0,0 +1,184 @@
+/**
+ * SynapseJS - Schema Drift Detector
+ *
+ * Compares live database catalog (SQLite or PostgreSQL) against the declared
+ * AST sliceSchema DDL contracts across the project.
+ *
+ * Pinpoints:
+ * - Missing tables (declared in slice, not yet migrated)
+ * - Missing columns (declared in slice, missing in DB)
+ * - Orphan tables (exist in DB, not declared by any slice)
+ */
+
+import type { DatabaseClient } from '../core/database-client';
+import { getDatabase } from '../core/database-factory';
+import { PostgresDatabaseClient } from '../core/postgres-client';
+import { type DatabaseCatalog, generateDatabaseSchemaCatalog } from './db-schema-generator';
+
+export interface MissingTableInfo {
+  table: string;
+  sourceSlice?: string;
+}
+
+export interface MissingColumnInfo {
+  table: string;
+  column: string;
+  expectedType: string;
+}
+
+export interface SchemaDriftReport {
+  status: 'PASS' | 'DRIFT_DETECTED';
+  totalDeclaredTables: number;
+  totalLiveTables: number;
+  drift: {
+    missingTables: MissingTableInfo[];
+    missingColumns: MissingColumnInfo[];
+    orphanTables: string[];
+  };
+}
+
+const IGNORED_TABLE_PATTERNS = [/^sqlite_/i, /^_synapse_/i, /^pg_/i, /^sql_/i];
+
+function isIgnoredTable(name: string): boolean {
+  return IGNORED_TABLE_PATTERNS.some((pat) => pat.test(name));
+}
+
+interface LiveColumn {
+  name: string;
+  type: string;
+}
+
+interface LiveTableSchema {
+  name: string;
+  columns: Map<string, LiveColumn>;
+}
+
+async function inspectLiveDatabase(db: DatabaseClient): Promise<Map<string, LiveTableSchema>> {
+  const isPostgres = db instanceof PostgresDatabaseClient;
+  const liveSchema = new Map<string, LiveTableSchema>();
+
+  if (isPostgres) {
+    const tables = await db.query<{ table_name: string }>(`
+      SELECT table_name 
+      FROM information_schema.tables 
+      WHERE table_schema = 'public' 
+        AND table_type = 'BASE TABLE'
+    `);
+
+    for (const t of tables) {
+      const tName = t.table_name.toLowerCase();
+      if (isIgnoredTable(tName)) continue;
+      liveSchema.set(tName, { name: tName, columns: new Map() });
+    }
+
+    const columns = await db.query<{ table_name: string; column_name: string; data_type: string }>(`
+      SELECT table_name, column_name, data_type 
+      FROM information_schema.columns 
+      WHERE table_schema = 'public'
+    `);
+
+    for (const col of columns) {
+      const tName = col.table_name.toLowerCase();
+      const colName = col.column_name.toLowerCase();
+      const tbl = liveSchema.get(tName);
+      if (tbl) {
+        tbl.columns.set(colName, {
+          name: col.column_name,
+          type: col.data_type
+        });
+      }
+    }
+  } else {
+    // SQLite
+    const tables = await db.query<{ name: string }>(`
+      SELECT name 
+      FROM sqlite_master 
+      WHERE type = 'table'
+    `);
+
+    for (const t of tables) {
+      const tName = t.name.toLowerCase();
+      if (isIgnoredTable(tName)) continue;
+
+      const colMap = new Map<string, LiveColumn>();
+      const colInfo = await db.query<{ name: string; type: string }>(`
+        PRAGMA table_info("${t.name}");
+      `);
+
+      for (const c of colInfo) {
+        colMap.set(c.name.toLowerCase(), {
+          name: c.name,
+          type: c.type
+        });
+      }
+
+      liveSchema.set(tName, { name: t.name, columns: colMap });
+    }
+  }
+
+  return liveSchema;
+}
+
+/**
+ * Checks for schema drift between AST slice schemas and a live database.
+ */
+export async function checkSchemaDrift(
+  rootDir: string = process.cwd(),
+  customDb?: DatabaseClient
+): Promise<SchemaDriftReport> {
+  const db = customDb || getDatabase();
+  const catalog: DatabaseCatalog = generateDatabaseSchemaCatalog(rootDir);
+  const liveTables = await inspectLiveDatabase(db);
+
+  const missingTables: MissingTableInfo[] = [];
+  const missingColumns: MissingColumnInfo[] = [];
+  const orphanTables: string[] = [];
+
+  const declaredTableNames = new Set<string>();
+
+  for (const table of catalog.tables) {
+    const tName = table.name.toLowerCase();
+    declaredTableNames.add(tName);
+
+    const liveTable = liveTables.get(tName);
+    if (!liveTable) {
+      missingTables.push({
+        table: table.name,
+        sourceSlice: table.sourceSlice
+      });
+      continue;
+    }
+
+    // Check columns
+    for (const col of table.columns) {
+      const colName = col.name.toLowerCase();
+      if (!liveTable.columns.has(colName)) {
+        missingColumns.push({
+          table: table.name,
+          column: col.name,
+          expectedType: col.sqlType
+        });
+      }
+    }
+  }
+
+  // Check for orphan tables
+  for (const [liveName, tbl] of liveTables.entries()) {
+    if (!declaredTableNames.has(liveName)) {
+      orphanTables.push(tbl.name);
+    }
+  }
+
+  const hasDrift = missingTables.length > 0 || missingColumns.length > 0 || orphanTables.length > 0;
+
+  return {
+    status: hasDrift ? 'DRIFT_DETECTED' : 'PASS',
+    totalDeclaredTables: catalog.totalTables,
+    totalLiveTables: liveTables.size,
+    drift: {
+      missingTables,
+      missingColumns,
+      orphanTables
+    }
+  };
+}

package/src/compiler/slice-discovery.ts

@@ -0,0 +1,154 @@
+/**
+ * SynapseJS - Slice Directory Resolution & Discovery
+ *
+ * Single source of truth for locating `src/slices`. Every consumer (CLI, MCP,
+ * runtime, migrations, scaffolder) resolves through here.
+ *
+ * Fails loudly with structured diagnostics instead of silently reporting
+ * success when no slices directory exists — the previous source of
+ * false-green reports to AI agents.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { Err, Ok, type Result } from '../core/machine-types';
+
+export const SLICE_EXTENSION = '.slice.tsx';
+
+export type SlicesDirErrorCode = 'NO_SLICES_DIR' | 'AMBIGUOUS_SLICES_DIR';
+
+export interface SlicesDirError {
+  code: SlicesDirErrorCode;
+  message: string;
+  candidates: string[];
+}
+
+export interface SlicesResolution {
+  projectRoot: string;
+  slicesDir: string;
+}
+
+/**
+ * Recursively collects every `*.slice.tsx` under `dir`.
+ * Returns an empty array when the directory does not exist.
+ */
+export function findSliceFiles(dir: string): string[] {
+  if (!fs.existsSync(dir)) {
+    return [];
+  }
+
+  const results: string[] = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...findSliceFiles(full));
+    } else if (entry.name.endsWith(SLICE_EXTENSION)) {
+      results.push(full);
+    }
+  }
+  return results;
+}
+
+function readWorkspaceGlobs(projectRoot: string): string[] {
+  const pkgPath = path.join(projectRoot, 'package.json');
+  if (!fs.existsSync(pkgPath)) {
+    return [];
+  }
+
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    if (Array.isArray(pkg.workspaces)) {
+      return pkg.workspaces;
+    }
+    if (pkg.workspaces && Array.isArray(pkg.workspaces.packages)) {
+      return pkg.workspaces.packages;
+    }
+  } catch {
+    return [];
+  }
+
+  return [];
+}
+
+function expandWorkspaceGlobs(projectRoot: string, globs: string[]): string[] {
+  const dirs: string[] = [];
+
+  for (const glob of globs) {
+    if (!glob.endsWith('/*')) {
+      dirs.push(path.resolve(projectRoot, glob));
+      continue;
+    }
+
+    const parent = path.resolve(projectRoot, glob.slice(0, -2));
+    if (!fs.existsSync(parent)) {
+      continue;
+    }
+
+    for (const entry of fs.readdirSync(parent, { withFileTypes: true })) {
+      if (entry.isDirectory() && !entry.name.startsWith('.')) {
+        dirs.push(path.join(parent, entry.name));
+      }
+    }
+  }
+
+  return dirs;
+}
+
+function hasSlices(dir: string): boolean {
+  return findSliceFiles(dir).length > 0;
+}
+
+/**
+ * Resolves the slices directory starting from `startDir`.
+ *
+ * Order:
+ * 1. `SYNAPSE_ROOT` (relative to `startDir`) overrides the starting point.
+ * 2. `<projectRoot>/src/slices` when it contains at least one slice.
+ * 3. Workspace members declared in `package.json#workspaces` — only when
+ *    exactly one of them owns a non-empty `src/slices`.
+ *
+ * Ambiguity and absence are both errors: a machine consumer must never be
+ * told "PASS" when nothing was discovered.
+ */
+export function resolveSlicesDir(startDir: string = process.cwd()): Result<SlicesResolution, SlicesDirError> {
+  const envRoot = process.env.SYNAPSE_ROOT;
+  const projectRoot = envRoot ? path.resolve(startDir, envRoot) : path.resolve(startDir);
+  const candidates: string[] = [];
+
+  const direct = path.join(projectRoot, 'src/slices');
+  candidates.push(direct);
+  if (hasSlices(direct)) {
+    return Ok({ projectRoot, slicesDir: direct });
+  }
+
+  const discovered: string[] = [];
+  for (const workspaceDir of expandWorkspaceGlobs(projectRoot, readWorkspaceGlobs(projectRoot))) {
+    const candidate = path.join(workspaceDir, 'src/slices');
+    candidates.push(candidate);
+    if (hasSlices(candidate)) {
+      discovered.push(candidate);
+    }
+  }
+
+  if (discovered.length === 1) {
+    return Ok({ projectRoot, slicesDir: discovered[0] });
+  }
+
+  if (discovered.length > 1) {
+    return Err({
+      code: 'AMBIGUOUS_SLICES_DIR',
+      message:
+        `Múltiplos diretórios de fatias encontrados a partir de '${projectRoot}'. ` +
+        `Defina SYNAPSE_ROOT ou execute o comando dentro do app alvo.`,
+      candidates: discovered
+    });
+  }
+
+  return Err({
+    code: 'NO_SLICES_DIR',
+    message:
+      `Nenhum diretório de fatias (src/slices contendo arquivos *${SLICE_EXTENSION}) ` +
+      `encontrado a partir de '${projectRoot}'.`,
+    candidates
+  });
+}