@famgia/omnify-cli 0.0.13 → 0.0.16

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { existsSync as existsSync4 } from "fs";
-import { resolve as resolve6 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { resolve as resolve7 } from "path";
 import { Command } from "commander";
 import { OmnifyError as OmnifyError5 } from "@famgia/omnify-core";
 
@@ -455,7 +455,8 @@ async function resolveConfig(userConfig, configPath2) {
     },
     plugins,
     verbose: userConfig.verbose ?? false,
-    lockFilePath: userConfig.lockFilePath ?? ".omnify.lock"
+    lockFilePath: userConfig.lockFilePath ?? ".omnify.lock",
+    ...userConfig.locale && { locale: userConfig.locale }
   };
   return result;
 }
@@ -886,7 +887,7 @@ function writeGeneratorOutputs(outputs, rootDir) {
   }
   return counts;
 }
-async function runPluginGeneration(plugins, schemas, rootDir, verbose) {
+async function runPluginGeneration(plugins, schemas, rootDir, verbose, changes) {
   const pluginManager = new PluginManager({
     cwd: rootDir,
     verbose,
@@ -900,7 +901,7 @@ async function runPluginGeneration(plugins, schemas, rootDir, verbose) {
   for (const plugin of plugins) {
     await pluginManager.register(plugin);
   }
-  const result = await pluginManager.runGenerators(schemas);
+  const result = await pluginManager.runGenerators(schemas, changes);
   if (!result.success) {
     for (const error of result.errors) {
       logger.error(`Generator ${error.generatorName} failed: ${error.message}`);
@@ -955,13 +956,19 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
       mkdirSync2(typesDir, { recursive: true });
       logger.debug(`Created directory: ${typesDir}`);
     }
-    const typeFiles = generateTypeScript(schemas, {
-      singleFile: config.output.typescript.singleFile
-    });
+    const typeFiles = generateTypeScript(schemas);
     for (const file of typeFiles) {
-      const filePath = resolve5(typesDir, file.fileName);
+      const filePath = resolve5(typesDir, file.filePath);
+      const fileDir = dirname4(filePath);
+      if (!existsSync3(fileDir)) {
+        mkdirSync2(fileDir, { recursive: true });
+      }
+      if (!file.overwrite && existsSync3(filePath)) {
+        logger.debug(`Skipped (exists): ${file.filePath}`);
+        continue;
+      }
       writeFileSync2(filePath, file.content);
-      logger.debug(`Created: ${file.fileName}`);
+      logger.debug(`Created: ${file.filePath}`);
       typesGenerated++;
     }
     logger.success(`Generated ${typesGenerated} TypeScript file(s)`);
@@ -984,8 +991,18 @@ async function runGenerate(options) {
     return;
   }
   logger.debug(`Found ${schemaCount} schema(s)`);
+  const customTypeNames = [];
+  for (const plugin of config.plugins) {
+    if (plugin.types) {
+      for (const typeDef of plugin.types) {
+        customTypeNames.push(typeDef.name);
+      }
+    }
+  }
   logger.step("Validating schemas...");
-  const validationResult = validateSchemas3(schemas);
+  const validationResult = validateSchemas3(schemas, {
+    customTypes: customTypeNames
+  });
   if (!validationResult.valid) {
     logger.error("Schema validation failed. Fix errors before generating.");
     for (const error of validationResult.errors) {
@@ -1019,7 +1036,8 @@ async function runGenerate(options) {
       config.plugins,
       schemas,
       rootDir,
-      options.verbose ?? false
+      options.verbose ?? false,
+      comparison.changes
     );
     migrationsGenerated = counts.migrations;
     typesGenerated = counts.types;
@@ -1092,6 +1110,191 @@ function registerGenerateCommand(program2) {
   });
 }
 
+// src/commands/reset.ts
+import { existsSync as existsSync4, readdirSync, rmSync, statSync } from "fs";
+import { resolve as resolve6, dirname as dirname5, join } from "path";
+import { createInterface } from "readline";
+async function confirm2(message) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve8) => {
+    rl.question(`${message} (y/N) `, (answer) => {
+      rl.close();
+      resolve8(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+function countFiles(dir) {
+  if (!existsSync4(dir)) return 0;
+  let count = 0;
+  const entries = readdirSync(dir);
+  for (const entry of entries) {
+    const fullPath = join(dir, entry);
+    const stat = statSync(fullPath);
+    if (stat.isDirectory()) {
+      count += countFiles(fullPath);
+    } else {
+      count++;
+    }
+  }
+  return count;
+}
+function deleteDir(dir, verbose) {
+  if (!existsSync4(dir)) return 0;
+  const count = countFiles(dir);
+  rmSync(dir, { recursive: true, force: true });
+  if (verbose) {
+    logger.debug(`Deleted: ${dir}`);
+  }
+  return count;
+}
+function deleteFilesInDir(dir, pattern, verbose) {
+  if (!existsSync4(dir)) return 0;
+  let count = 0;
+  const entries = readdirSync(dir);
+  for (const entry of entries) {
+    const fullPath = join(dir, entry);
+    const stat = statSync(fullPath);
+    if (stat.isFile() && pattern.test(entry)) {
+      rmSync(fullPath);
+      if (verbose) {
+        logger.debug(`Deleted: ${fullPath}`);
+      }
+      count++;
+    }
+  }
+  return count;
+}
+async function runReset(options) {
+  logger.setVerbose(options.verbose ?? false);
+  logger.header("Reset Omnify Generated Files");
+  logger.debug("Loading configuration...");
+  const { config, configPath: configPath2 } = await loadConfig();
+  const rootDir = configPath2 ? dirname5(configPath2) : process.cwd();
+  const paths = [];
+  const omnifyBasePaths = [
+    "app/Models/OmnifyBase",
+    "backend/app/Models/OmnifyBase",
+    "src/Models/OmnifyBase"
+  ];
+  for (const relPath of omnifyBasePaths) {
+    const omnifyBasePath = resolve6(rootDir, relPath);
+    if (existsSync4(omnifyBasePath)) {
+      paths.push({ name: "OmnifyBase models", path: omnifyBasePath, type: "dir" });
+      break;
+    }
+  }
+  const migrationPaths = [
+    "database/migrations/omnify",
+    "backend/database/migrations/omnify"
+  ];
+  for (const relPath of migrationPaths) {
+    const migrationsPath = resolve6(rootDir, relPath);
+    if (existsSync4(migrationsPath)) {
+      paths.push({
+        name: "Omnify migrations",
+        path: migrationsPath,
+        type: "files",
+        pattern: /\.php$/
+      });
+      break;
+    }
+  }
+  const laravelConfig = config.output.laravel;
+  if (laravelConfig?.modelsPath) {
+    const modelsPath = resolve6(rootDir, laravelConfig.modelsPath);
+    const omnifyBasePath = join(modelsPath, "OmnifyBase");
+    if (existsSync4(omnifyBasePath) && !paths.some((p) => p.path === omnifyBasePath)) {
+      paths.push({ name: "OmnifyBase models", path: omnifyBasePath, type: "dir" });
+    }
+  }
+  if (laravelConfig?.migrationsPath) {
+    const migrationsPath = resolve6(rootDir, laravelConfig.migrationsPath);
+    if (existsSync4(migrationsPath) && !paths.some((p) => p.path === migrationsPath)) {
+      paths.push({
+        name: "Omnify migrations",
+        path: migrationsPath,
+        type: "files",
+        pattern: /\.php$/
+      });
+    }
+  }
+  const lockFilePath = resolve6(rootDir, config.lockFilePath);
+  if (existsSync4(lockFilePath)) {
+    paths.push({ name: "Lock file", path: lockFilePath, type: "file" });
+  }
+  const omnifyDir = resolve6(rootDir, ".omnify");
+  if (existsSync4(omnifyDir)) {
+    paths.push({ name: ".omnify directory", path: omnifyDir, type: "dir" });
+  }
+  if (paths.length === 0) {
+    logger.info("Nothing to clean. No generated files found.");
+    return;
+  }
+  logger.newline();
+  logger.warn("The following will be deleted:");
+  logger.newline();
+  for (const item of paths) {
+    if (item.type === "dir") {
+      const count = countFiles(item.path);
+      logger.info(`  \u2022 ${item.name}: ${item.path} (${count} files)`);
+    } else if (item.type === "files" && item.pattern) {
+      const count = readdirSync(item.path).filter((f) => item.pattern.test(f)).length;
+      logger.info(`  \u2022 ${item.name}: ${item.path} (${count} files)`);
+    } else {
+      logger.info(`  \u2022 ${item.name}: ${item.path}`);
+    }
+  }
+  logger.newline();
+  if (!options.yes) {
+    const confirmed = await confirm2("Are you sure you want to delete these files?");
+    if (!confirmed) {
+      logger.info("Reset cancelled.");
+      return;
+    }
+  }
+  logger.newline();
+  logger.step("Deleting files...");
+  let totalDeleted = 0;
+  for (const item of paths) {
+    if (item.type === "dir") {
+      const count = deleteDir(item.path, options.verbose ?? false);
+      totalDeleted += count;
+      logger.info(`  \u2713 Deleted ${item.name} (${count} files)`);
+    } else if (item.type === "files" && item.pattern) {
+      const count = deleteFilesInDir(item.path, item.pattern, options.verbose ?? false);
+      totalDeleted += count;
+      logger.info(`  \u2713 Deleted ${item.name} (${count} files)`);
+    } else {
+      rmSync(item.path, { force: true });
+      if (options.verbose) {
+        logger.debug(`Deleted: ${item.path}`);
+      }
+      totalDeleted++;
+      logger.info(`  \u2713 Deleted ${item.name}`);
+    }
+  }
+  logger.newline();
+  logger.success(`Reset complete! Deleted ${totalDeleted} file(s).`);
+  logger.newline();
+  logger.info("Run `omnify generate` to regenerate files.");
+}
+function registerResetCommand(program2) {
+  program2.command("reset").description("Delete all generated files (OmnifyBase, migrations, locks)").option("-v, --verbose", "Show detailed output").option("-y, --yes", "Skip confirmation prompt").action(async (options) => {
+    try {
+      await runReset(options);
+    } catch (error) {
+      if (error instanceof Error) {
+        logger.error(error.message);
+        process.exit(1);
+      }
+      process.exit(1);
+    }
+  });
+}
+
 // src/cli.ts
 var VERSION = "0.0.5";
 var program = new Command();
@@ -1100,6 +1303,7 @@ registerInitCommand(program);
 registerValidateCommand(program);
 registerDiffCommand(program);
 registerGenerateCommand(program);
+registerResetCommand(program);
 process.on("uncaughtException", (error) => {
   if (error instanceof OmnifyError5) {
     logger.formatError(error);
@@ -1123,8 +1327,8 @@ process.on("unhandledRejection", (reason) => {
 var args = process.argv.slice(2);
 var firstArg = args[0];
 var hasCommand = firstArg !== void 0 && !firstArg.startsWith("-");
-var configPath = resolve6(process.cwd(), "omnify.config.ts");
-var hasConfig = existsSync4(configPath);
+var configPath = resolve7(process.cwd(), "omnify.config.ts");
+var hasConfig = existsSync5(configPath);
 if (!hasCommand && !hasConfig) {
   runInit({}).catch((error) => {
     if (error instanceof Error) {