@goboost/scanner-typescript 1.2.1

package/src/index.ts

@@ -0,0 +1,284 @@
+/**
+ * Scanner entrypoint — orchestrates all extractors and outputs normalized IR JSON.
+ *
+ * Produces DUAL IR per the goBoost Decoupled Universal Extractor architecture:
+ *   - goboost.api.json (API IR v2.0.0) — controllers, DTOs, guards
+ *   - goboost.db.json  (DB IR v1.0.0)  — tables, columns, relations, enums (from Prisma)
+ *
+ * Constitution v1.2.0 compliance:
+ *   - Principle V:   Prisma as single source of truth for DB schema
+ *   - Principle VIII: The Framework Rosetta Stone — JSII-compliant IR
+ */
+import { Project } from 'ts-morph';
+import { extractControllers } from './controller-extractor';
+import { extractDTOs, collectReferencedDTOs, markSharedDTOs } from './dto-extractor';
+import { extractPrismaSchema, DBRoot } from './prisma-schema-extractor';
+import { extractGuards } from './guard-extractor';
+import { detectUnsupported, canGenerate } from './unsupported-detector';
+
+const API_IR_VERSION = '2.0.0';
+
+interface ScanOptions {
+  projectPath: string;
+  tsConfigPath?: string;
+  prismaSchemaPath?: string;
+}
+
+/** API IR root (goboost.api.json v2.0.0) — matches internal/ir/api_types.go */
+interface APIRoot {
+  version: string;
+  sourceFramework: string;
+  projectRoot: string;
+  scannedAt: string;
+  controllers: any[];
+  dtos: Record<string, any>;
+  guards: Record<string, any>;
+  meta?: { generatorVersion?: string; scanDuration?: string };
+}
+
+interface ScanResult {
+  apiIR: APIRoot;
+  dbIR: DBRoot;
+}
+
+export async function scan(options: ScanOptions): Promise<ScanResult> {
+  const { projectPath, tsConfigPath } = options;
+  const startTime = Date.now();
+
+  // Initialize ts-morph project for API extraction
+  const project = new Project({
+    tsConfigFilePath: tsConfigPath || `${projectPath}/tsconfig.json`,
+    skipAddingFilesFromTsConfig: false,
+  });
+
+  // ---- API IR extraction ----
+
+  // Extract controllers
+  const controllers = extractControllers(project);
+
+  // Detect circular service dependencies
+  const circularDeps = detectCircularDependencies(project, controllers);
+  if (circularDeps.length > 0) {
+    console.error('Warning: Circular service dependencies detected:');
+    for (const dep of circularDeps) {
+      console.error(`  - ${dep}`);
+    }
+  }
+
+  // Collect and extract DTOs
+  const referencedDTOs = collectReferencedDTOs(controllers);
+  const dtos = extractDTOs(project, referencedDTOs);
+  markSharedDTOs(dtos, controllers);
+
+  // Extract guards
+  const guards = extractGuards(project);
+
+  // Detect unsupported features per route
+  for (const controller of controllers) {
+    const controllerUnsupported: string[] = [];
+
+    const controllerCyclicDeps = circularDeps.filter(d => d.startsWith(controller.name));
+    for (const dep of controllerCyclicDeps) {
+      if (!controllerUnsupported.includes('circular-dependency')) {
+        controllerUnsupported.push('circular-dependency');
+      }
+    }
+
+    for (const route of controller.routes) {
+      const unsupported = detectUnsupported(project, {
+        handlerName: route.handlerName,
+        unsupportedFeatures: [],
+      });
+      route.unsupportedFeatures = unsupported;
+      route.canGenerate = canGenerate(unsupported);
+
+      for (const feature of unsupported) {
+        if (!controllerUnsupported.includes(feature)) {
+          controllerUnsupported.push(feature);
+        }
+      }
+    }
+
+    controller.unsupportedFeatures = controllerUnsupported;
+  }
+
+  const scanDuration = `${Date.now() - startTime}ms`;
+
+  // Build API IR
+  const apiIR: APIRoot = {
+    version: API_IR_VERSION,
+    sourceFramework: 'nestjs',
+    projectRoot: projectPath,
+    scannedAt: new Date().toISOString(),
+    controllers,
+    dtos,
+    guards,
+    meta: {
+      generatorVersion: '1.1.0',
+      scanDuration,
+    },
+  };
+
+  // Normalize API IR for determinism
+  normalizeAPIIR(apiIR);
+
+  // ---- DB IR extraction (Prisma DMMF) ----
+
+  const dbIR = await extractPrismaSchema({
+    projectPath,
+    schemaPath: options.prismaSchemaPath,
+  });
+
+  return { apiIR, dbIR };
+}
+
+/**
+ * Detect circular dependencies between services in controllers
+ */
+function detectCircularDependencies(project: Project, controllers: any[]): string[] {
+  const circularDeps: string[] = [];
+  const visited = new Set<string>();
+  const dependencyGraph = new Map<string, Set<string>>();
+
+  for (const controller of controllers) {
+    if (controller.dependencies && controller.dependencies.length > 0) {
+      const deps = new Set<string>();
+      for (const dep of controller.dependencies) {
+        const serviceName = extractServiceName(dep);
+        if (serviceName) {
+          deps.add(serviceName);
+        }
+      }
+      dependencyGraph.set(controller.name, deps);
+    }
+  }
+
+  function dfs(node: string, path: string[]): boolean {
+    if (visited.has(node)) {
+      const cycleStart = path.indexOf(node);
+      if (cycleStart !== -1) {
+        const cycle = [...path.slice(cycleStart), node].join(' -> ');
+        circularDeps.push(`${node}: ${cycle}`);
+      }
+      return true;
+    }
+
+    visited.add(node);
+    path.push(node);
+
+    const deps = dependencyGraph.get(node);
+    if (deps) {
+      for (const dep of deps) {
+        if (path.includes(dep) || dfs(dep, [...path])) {
+          // Continue to find all cycles
+        }
+      }
+    }
+
+    path.pop();
+    return false;
+  }
+
+  for (const controller of controllers) {
+    visited.clear();
+    dfs(controller.name, []);
+  }
+
+  return circularDeps;
+}
+
+function extractServiceName(typeText: string): string | null {
+  const match = typeText.match(/(\w+Service)/);
+  return match ? match[1] : null;
+}
+
+/**
+ * Normalize API IR for deterministic output
+ */
+function normalizeAPIIR(ir: APIRoot): void {
+  for (const controller of ir.controllers) {
+    controller.routes.sort((a: any, b: any) => {
+      const methodCompare = a.httpMethod.localeCompare(b.httpMethod);
+      if (methodCompare !== 0) return methodCompare;
+      return a.path.localeCompare(b.path);
+    });
+  }
+
+  ir.dtos = sortObjectKeys(ir.dtos);
+  ir.guards = sortObjectKeys(ir.guards);
+}
+
+function sortObjectKeys<T>(obj: Record<string, T>): Record<string, T> {
+  const sorted: Record<string, T> = {};
+  const keys = Object.keys(obj).sort();
+  for (const key of keys) {
+    sorted[key] = obj[key];
+  }
+  return sorted;
+}
+
+/**
+ * CLI entrypoint — outputs dual IR JSON to stdout or files
+ */
+if (require.main === module) {
+  const args = process.argv.slice(2);
+
+  let projectPath = process.cwd();
+  let tsConfigPath: string | undefined;
+  let prismaSchemaPath: string | undefined;
+  let outputApiPath: string | undefined;
+  let outputDbPath: string | undefined;
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--project' || args[i] === '-p') {
+      projectPath = args[++i];
+    } else if (args[i] === '--tsconfig' || args[i] === '-t') {
+      tsConfigPath = args[++i];
+    } else if (args[i] === '--prisma-schema') {
+      prismaSchemaPath = args[++i];
+    } else if (args[i] === '--output-api') {
+      outputApiPath = args[++i];
+    } else if (args[i] === '--output-db') {
+      outputDbPath = args[++i];
+    } else if (!args[i].startsWith('-') && i === 0) {
+      projectPath = args[i];
+    }
+  }
+
+  scan({ projectPath, tsConfigPath, prismaSchemaPath })
+    .then(({ apiIR, dbIR }) => {
+      const apiJson = JSON.stringify(apiIR, null, 2);
+      const dbJson = JSON.stringify(dbIR, null, 2);
+
+      if (outputApiPath) {
+        const fs = require('fs');
+        const path = require('path');
+        fs.mkdirSync(path.dirname(outputApiPath), { recursive: true });
+        fs.writeFileSync(outputApiPath, apiJson, 'utf-8');
+        console.error(`API IR written to: ${outputApiPath}`);
+      }
+
+      if (outputDbPath) {
+        const fs = require('fs');
+        const path = require('path');
+        fs.mkdirSync(path.dirname(outputDbPath), { recursive: true });
+        fs.writeFileSync(outputDbPath, dbJson, 'utf-8');
+        console.error(`DB IR written to: ${outputDbPath}`);
+      }
+
+      // If no output paths specified, write both to stdout as a combined object
+      if (!outputApiPath && !outputDbPath) {
+        console.log(JSON.stringify({ api: apiIR, db: dbIR }, null, 2));
+      }
+    })
+    .catch((err) => {
+      console.error(JSON.stringify({
+        error: true,
+        message: err.message,
+        stack: err.stack,
+      }));
+      process.exit(1);
+    });
+}
+
+export { scan as scanProject };

package/src/prisma-schema-extractor.ts

@@ -0,0 +1,345 @@
+/**
+ * Prisma Schema Extractor — parses schema.prisma via @prisma/internals getDMMF()
+ * and produces goboost.db.json (DB IR v1.0.0) matching internal/ir/db_types.go.
+ *
+ * Constitution v1.2.0 Principle V: Single Shared Database — schema migrations
+ * managed from Prisma as the single source of truth. Performance Boosters use Gorm models
+ * generated from the canonical schema.
+ */
+import { getDMMF } from '@prisma/internals';
+import * as fs from 'fs';
+import * as path from 'path';
+
+// ---- DB IR types (mirrors internal/ir/db_types.go) ----
+
+export interface DBRoot {
+  version: string;
+  source: string;
+  databaseType: string;
+  schemaName: string;
+  extractedAt: string;
+  tables: TableSpec[];
+  enums: EnumSpec[];
+}
+
+export interface TableSpec {
+  name: string;
+  schema: string;
+  columns: ColumnSpec[];
+  relations: RelationSpec[];
+}
+
+export interface ColumnSpec {
+  name: string;
+  goType: string;
+  dbType: string;
+  isPrimary: boolean;
+  isAutoIncrement: boolean;
+  isNullable: boolean;
+  isUnique: boolean;
+  defaultValue?: string;
+  gormTag?: string;
+}
+
+export interface RelationSpec {
+  name: string;
+  type: string;
+  fromTable: string;
+  toTable: string;
+  fromColumns?: string[];
+}
+
+export interface EnumSpec {
+  name: string;
+  values: string[];
+}
+
+// ---- Prisma type → Go type mapping ----
+
+const PRISMA_TO_GO_TYPE: Record<string, string> = {
+  'String':   'string',
+  'Int':      'int64',
+  'BigInt':   'int64',
+  'Float':    'float64',
+  'Decimal':  'float64',
+  'Boolean':  'bool',
+  'DateTime': 'time.Time',
+  'Json':     'datatypes.JSON',
+  'Bytes':    '[]byte',
+};
+
+const PRISMA_TO_DB_TYPE: Record<string, string> = {
+  'String':   'VARCHAR(255)',
+  'Int':      'INTEGER',
+  'BigInt':   'BIGINT',
+  'Float':    'DOUBLE PRECISION',
+  'Decimal':  'DECIMAL',
+  'Boolean':  'BOOLEAN',
+  'DateTime': 'TIMESTAMP',
+  'Json':     'JSONB',
+  'Bytes':    'BYTEA',
+};
+
+// ---- Relation type mapping ----
+
+function mapRelationType(kind: string, isList: boolean): string {
+  if (isList) {
+    return 'one-to-many';
+  }
+  // A non-list relation field on the side with the FK is many-to-one
+  return 'many-to-one';
+}
+
+// ---- Main extraction function ----
+
+export interface ExtractOptions {
+  projectPath: string;
+  schemaPath?: string;
+}
+
+/**
+ * Detect the database provider from the schema.prisma datasource block.
+ */
+function detectDatabaseType(schemaContent: string): string {
+  const providerMatch = schemaContent.match(
+    /datasource\s+\w+\s*\{[^}]*provider\s*=\s*"(\w+)"/s
+  );
+  if (providerMatch) {
+    const provider = providerMatch[1].toLowerCase();
+    switch (provider) {
+      case 'postgresql': return 'postgresql';
+      case 'mysql':      return 'mysql';
+      case 'sqlite':     return 'sqlite';
+      case 'sqlserver':  return 'sqlserver';
+      case 'mongodb':    return 'mongodb';
+      case 'cockroachdb': return 'cockroachdb';
+      default:           return provider;
+    }
+  }
+  return 'postgresql'; // Default per Constitution (Principle V)
+}
+
+/**
+ * Extract DB IR from a Prisma schema file using @prisma/internals getDMMF().
+ * Output format matches internal/ir/db_types.go (DBRoot).
+ */
+export async function extractPrismaSchema(options: ExtractOptions): Promise<DBRoot> {
+  const { projectPath } = options;
+
+  // 1. Locate schema.prisma
+  const schemaPath = options.schemaPath || findPrismaSchema(projectPath);
+  if (!schemaPath) {
+    // No schema.prisma found — return empty DB IR (per contract: source="none")
+    return {
+      version: '1.0.0',
+      source: 'none',
+      databaseType: 'postgresql',
+      schemaName: 'public',
+      extractedAt: new Date().toISOString(),
+      tables: [],
+      enums: [],
+    };
+  }
+
+  // 2. Read schema content
+  const schemaContent = fs.readFileSync(schemaPath, 'utf-8');
+  const databaseType = detectDatabaseType(schemaContent);
+
+  // 3. Parse via getDMMF (offline — no database connection required)
+  const dmmf = await getDMMF({ datamodel: schemaContent });
+
+  // 4. Map DMMF models → TableSpec[]
+  const tables: TableSpec[] = dmmf.datamodel.models.map((model) => {
+    const columns: ColumnSpec[] = [];
+    const relations: RelationSpec[] = [];
+
+    for (const field of model.fields) {
+      if (field.kind === 'scalar' || field.kind === 'enum') {
+        columns.push(mapFieldToColumn(field, model));
+      } else if (field.kind === 'object') {
+        relations.push(mapFieldToRelation(field, model));
+      }
+    }
+
+    return {
+      name: model.name,
+      schema: 'public',
+      columns,
+      relations: relations.length > 0 ? relations : [],
+    };
+  });
+
+  // 5. Map DMMF enums → EnumSpec[]
+  const enums: EnumSpec[] = dmmf.datamodel.enums.map((e) => ({
+    name: e.name,
+    values: e.values.map((v) => v.name),
+  }));
+
+  // 6. Sort for determinism
+  tables.sort((a, b) => a.name.localeCompare(b.name));
+  for (const table of tables) {
+    table.columns.sort((a, b) => {
+      // Primary keys first, then alphabetical
+      if (a.isPrimary !== b.isPrimary) return a.isPrimary ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+    table.relations.sort((a, b) => a.name.localeCompare(b.name));
+  }
+  enums.sort((a, b) => a.name.localeCompare(b.name));
+
+  return {
+    version: '1.0.0',
+    source: 'prisma',
+    databaseType,
+    schemaName: 'public',
+    extractedAt: new Date().toISOString(),
+    tables,
+    enums,
+  };
+}
+
+// ---- Field mappers ----
+
+function mapFieldToColumn(field: any, model: any): ColumnSpec {
+  const isPrimary = field.isId || false;
+  const isAutoIncrement = hasDefaultAutoincrement(field);
+  const goType = field.kind === 'enum'
+    ? 'string'
+    : (PRISMA_TO_GO_TYPE[field.type] || 'string');
+  const dbType = field.kind === 'enum'
+    ? `VARCHAR(255)`
+    : (PRISMA_TO_DB_TYPE[field.type] || 'VARCHAR(255)');
+
+  // Apply @db.* native type overrides if present
+  const nativeType = field.nativeType;
+  let resolvedDbType = dbType;
+  if (nativeType) {
+    resolvedDbType = formatNativeType(nativeType);
+  }
+
+  const col: ColumnSpec = {
+    name: field.name,
+    goType,
+    dbType: resolvedDbType,
+    isPrimary,
+    isAutoIncrement,
+    isNullable: !field.isRequired,
+    isUnique: field.isUnique || false,
+  };
+
+  // Default value
+  const defaultVal = extractDefaultValue(field);
+  if (defaultVal) {
+    col.defaultValue = defaultVal;
+  }
+
+  // Build GORM tag
+  const gormTag = buildGormTag(col, field);
+  if (gormTag) {
+    col.gormTag = gormTag;
+  }
+
+  return col;
+}
+
+function mapFieldToRelation(field: any, model: any): RelationSpec {
+  const isList = field.isList;
+  const relationType = mapRelationType(field.relationName || '', isList);
+
+  const rel: RelationSpec = {
+    name: field.name,
+    type: relationType,
+    fromTable: model.name,
+    toTable: field.type,
+  };
+
+  // Determine FK columns from the relation's fromFields
+  if (field.relationFromFields && field.relationFromFields.length > 0) {
+    rel.fromColumns = field.relationFromFields;
+  }
+
+  return rel;
+}
+
+// ---- Helpers ----
+
+function hasDefaultAutoincrement(field: any): boolean {
+  if (!field.default) return false;
+  if (typeof field.default === 'object' && field.default.name === 'autoincrement') {
+    return true;
+  }
+  return false;
+}
+
+function extractDefaultValue(field: any): string | undefined {
+  if (!field.default) return undefined;
+
+  if (typeof field.default === 'object') {
+    // Prisma function defaults: autoincrement(), now(), uuid(), cuid(), etc.
+    const name = field.default.name;
+    if (name === 'autoincrement') return undefined; // Handled by isAutoIncrement
+    if (name === 'now') return 'CURRENT_TIMESTAMP';
+    if (name === 'uuid') return 'gen_random_uuid()';
+    if (name === 'cuid') return 'gen_random_uuid()'; // Approximate
+    if (name === 'dbgenerated') {
+      const args = field.default.args;
+      return args && args.length > 0 ? String(args[0]) : undefined;
+    }
+    return name + '()';
+  }
+
+  // Scalar defaults
+  return String(field.default);
+}
+
+function formatNativeType(nativeType: any): string {
+  if (!nativeType) return 'VARCHAR(255)';
+  // nativeType is [typeName, args[]]
+  const [typeName, args] = nativeType;
+  if (args && args.length > 0) {
+    return `${typeName.toUpperCase()}(${args.join(', ')})`;
+  }
+  return typeName.toUpperCase();
+}
+
+function buildGormTag(col: ColumnSpec, field: any): string {
+  const parts: string[] = [];
+
+  parts.push(`column:${col.name}`);
+  parts.push(`type:${col.dbType}`);
+
+  if (col.isPrimary) {
+    parts.push('primaryKey');
+  }
+  if (col.isAutoIncrement) {
+    parts.push('autoIncrement');
+  }
+  if (!col.isNullable) {
+    parts.push('not null');
+  }
+  if (col.isUnique) {
+    parts.push('uniqueIndex');
+  }
+  if (col.defaultValue) {
+    parts.push(`default:${col.defaultValue}`);
+  }
+
+  return parts.join(';');
+}
+
+function findPrismaSchema(projectPath: string): string | null {
+  // Standard Prisma schema locations
+  const candidates = [
+    path.join(projectPath, 'prisma', 'schema.prisma'),
+    path.join(projectPath, 'schema.prisma'),
+    path.join(projectPath, 'prisma', 'schema'),
+  ];
+
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  return null;
+}