@l4yercak3/cli 1.2.21 → 1.3.1

package/src/detectors/model-detector.js

@@ -0,0 +1,318 @@
+/**
+ * Model/Type Scanner
+ * Detects data models and types across multiple sources:
+ * - Prisma schemas
+ * - TypeScript interfaces/types
+ * - Drizzle table definitions
+ * - Convex schemas
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * @typedef {Object} DetectedModel
+ * @property {string} name - Model name
+ * @property {string} source - Source identifier (e.g., 'prisma/schema.prisma')
+ * @property {string[]} fields - Field names
+ */
+
+/**
+ * Check if a path exists
+ * @param {string} filePath
+ * @returns {boolean}
+ */
+function exists(filePath) {
+  try {
+    return fs.existsSync(filePath);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Safely read a file
+ * @param {string} filePath
+ * @returns {string|null}
+ */
+function readFile(filePath) {
+  try {
+    return fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Find files matching a pattern in a directory (non-recursive)
+ * @param {string} dir
+ * @param {RegExp} pattern
+ * @returns {string[]}
+ */
+function findFiles(dir, pattern) {
+  if (!exists(dir)) return [];
+  try {
+    return fs.readdirSync(dir)
+      .filter(f => pattern.test(f))
+      .map(f => path.join(dir, f));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Parse Prisma schema file for model definitions
+ * @param {string} filePath - Path to schema.prisma
+ * @returns {DetectedModel[]}
+ */
+function parsePrismaSchema(filePath) {
+  const content = readFile(filePath);
+  if (!content) return [];
+
+  const models = [];
+  const modelRegex = /^model\s+(\w+)\s*\{([^}]+)\}/gm;
+  let match;
+
+  while ((match = modelRegex.exec(content)) !== null) {
+    const name = match[1];
+    const body = match[2];
+    const fields = [];
+
+    for (const line of body.split('\n')) {
+      const trimmed = line.trim();
+      // Skip empty lines, comments, and @@ annotations
+      if (!trimmed || trimmed.startsWith('//') || trimmed.startsWith('@@')) continue;
+      // Extract field name (first word on the line)
+      const fieldMatch = trimmed.match(/^(\w+)\s+/);
+      if (fieldMatch) {
+        fields.push(fieldMatch[1]);
+      }
+    }
+
+    models.push({
+      name,
+      source: 'prisma/schema.prisma',
+      fields,
+    });
+  }
+
+  return models;
+}
+
+/**
+ * Parse TypeScript files for interface and type definitions
+ * @param {string[]} dirs - Directories to scan
+ * @param {string} projectPath - Project root for relative paths
+ * @returns {DetectedModel[]}
+ */
+function parseTypeScriptTypes(dirs, projectPath) {
+  const models = [];
+  const filePattern = /\.(ts|tsx)$/;
+
+  for (const dir of dirs) {
+    const files = findFiles(dir, filePattern);
+
+    for (const filePath of files) {
+      const content = readFile(filePath);
+      if (!content) continue;
+
+      const relativePath = path.relative(projectPath, filePath);
+
+      // Match interface declarations
+      const interfaceRegex = /^(?:export\s+)?interface\s+(\w+)\s*(?:extends\s+[\w,\s<>]+)?\s*\{([^}]+)\}/gm;
+      let match;
+
+      while ((match = interfaceRegex.exec(content)) !== null) {
+        const name = match[1];
+        const body = match[2];
+        const fields = extractTsFields(body);
+        if (fields.length > 0) {
+          models.push({ name, source: relativePath, fields });
+        }
+      }
+
+      // Match type aliases with object shapes
+      const typeRegex = /^(?:export\s+)?type\s+(\w+)\s*=\s*\{([^}]+)\}/gm;
+      while ((match = typeRegex.exec(content)) !== null) {
+        const name = match[1];
+        const body = match[2];
+        const fields = extractTsFields(body);
+        if (fields.length > 0) {
+          models.push({ name, source: relativePath, fields });
+        }
+      }
+    }
+  }
+
+  return models;
+}
+
+/**
+ * Extract field names from a TypeScript object body
+ * @param {string} body
+ * @returns {string[]}
+ */
+function extractTsFields(body) {
+  const fields = [];
+  for (const line of body.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('//') || trimmed.startsWith('/*')) continue;
+    // Match: fieldName: type or fieldName?: type
+    const fieldMatch = trimmed.match(/^(\w+)\s*\??:/);
+    if (fieldMatch) {
+      fields.push(fieldMatch[1]);
+    }
+  }
+  return fields;
+}
+
+/**
+ * Parse Drizzle schema files for table definitions
+ * @param {string[]} dirs - Directories to scan
+ * @param {string} projectPath - Project root for relative paths
+ * @returns {DetectedModel[]}
+ */
+function parseDrizzleSchemas(dirs, projectPath) {
+  const models = [];
+  const filePattern = /schema.*\.(ts|js)$/;
+
+  for (const dir of dirs) {
+    const files = findFiles(dir, filePattern);
+
+    for (const filePath of files) {
+      const content = readFile(filePath);
+      if (!content) continue;
+
+      const relativePath = path.relative(projectPath, filePath);
+
+      // Match: export const tableName = pgTable('table_name', { ... })
+      const tableRegex = /export\s+const\s+(\w+)\s*=\s*(?:pgTable|mysqlTable|sqliteTable)\s*\(\s*['"](\w+)['"]\s*,\s*\{([^}]+)\}/g;
+      let match;
+
+      while ((match = tableRegex.exec(content)) !== null) {
+        // match[1] is the variable name (e.g., 'users'), match[2] is the SQL table name
+        const tableName = match[2];
+        const body = match[3];
+        const fields = [];
+
+        for (const line of body.split('\n')) {
+          const trimmed = line.trim();
+          if (!trimmed || trimmed.startsWith('//')) continue;
+          // Match: columnName: type(...)
+          const colMatch = trimmed.match(/^(\w+)\s*:/);
+          if (colMatch) {
+            fields.push(colMatch[1]);
+          }
+        }
+
+        // Use PascalCase version of table name as model name
+        const name = tableName
+          .split('_')
+          .map(w => w.charAt(0).toUpperCase() + w.slice(1))
+          .join('');
+
+        models.push({ name, source: relativePath, fields });
+      }
+    }
+  }
+
+  return models;
+}
+
+/**
+ * Parse Convex schema file
+ * @param {string} filePath - Path to convex/schema.ts
+ * @param {string} projectPath - Project root
+ * @returns {DetectedModel[]}
+ */
+function parseConvexSchema(filePath, projectPath) {
+  const content = readFile(filePath);
+  if (!content) return [];
+
+  const models = [];
+  const relativePath = path.relative(projectPath, filePath);
+
+  // Match: tableName: defineTable({ ... })
+  const tableRegex = /(\w+)\s*:\s*defineTable\s*\(\s*\{([^}]+)\}/g;
+  let match;
+
+  while ((match = tableRegex.exec(content)) !== null) {
+    const tableName = match[1];
+    const body = match[2];
+    const fields = [];
+
+    for (const line of body.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('//')) continue;
+      const fieldMatch = trimmed.match(/^(\w+)\s*:/);
+      if (fieldMatch) {
+        fields.push(fieldMatch[1]);
+      }
+    }
+
+    const name = tableName.charAt(0).toUpperCase() + tableName.slice(1);
+    models.push({ name, source: relativePath, fields });
+  }
+
+  return models;
+}
+
+/**
+ * Detect all models/types in a project
+ * @param {string} projectPath - Project root path
+ * @returns {{ hasModels: boolean, models: DetectedModel[] }}
+ */
+function detect(projectPath = process.cwd()) {
+  const allModels = [];
+
+  // 1. Prisma
+  const prismaPath = path.join(projectPath, 'prisma', 'schema.prisma');
+  if (exists(prismaPath)) {
+    allModels.push(...parsePrismaSchema(prismaPath));
+  }
+
+  // 2. TypeScript types/interfaces
+  const tsDirs = [
+    path.join(projectPath, 'types'),
+    path.join(projectPath, 'src', 'types'),
+    path.join(projectPath, 'models'),
+    path.join(projectPath, 'src', 'models'),
+  ].filter(d => exists(d));
+
+  if (tsDirs.length > 0) {
+    allModels.push(...parseTypeScriptTypes(tsDirs, projectPath));
+  }
+
+  // 3. Drizzle
+  const drizzleDirs = [
+    path.join(projectPath, 'drizzle'),
+    path.join(projectPath, 'src', 'db'),
+    path.join(projectPath, 'db'),
+  ].filter(d => exists(d));
+
+  if (drizzleDirs.length > 0) {
+    allModels.push(...parseDrizzleSchemas(drizzleDirs, projectPath));
+  }
+
+  // 4. Convex
+  const convexSchemaTs = path.join(projectPath, 'convex', 'schema.ts');
+  const convexSchemaJs = path.join(projectPath, 'convex', 'schema.js');
+  if (exists(convexSchemaTs)) {
+    allModels.push(...parseConvexSchema(convexSchemaTs, projectPath));
+  } else if (exists(convexSchemaJs)) {
+    allModels.push(...parseConvexSchema(convexSchemaJs, projectPath));
+  }
+
+  return {
+    hasModels: allModels.length > 0,
+    models: allModels,
+  };
+}
+
+module.exports = {
+  detect,
+  parsePrismaSchema,
+  parseTypeScriptTypes,
+  parseDrizzleSchemas,
+  parseConvexSchema,
+};