@famgia/omnify-cli 0.0.164 → 0.0.166

package/dist/cli.js

@@ -146,6 +146,9 @@ import { resolve } from "path";
 function hasViteOmnifyAlias(content) {
   return content.includes("'@omnify'") || content.includes('"@omnify"') || content.includes("@omnify:") || content.includes("'@omnify/");
 }
+function hasViteOmnifyBaseAlias(content) {
+  return content.includes("'@omnify-base'") || content.includes('"@omnify-base"') || content.includes("@omnify-base/");
+}
 function hasTsconfigOmnifyPath(content) {
   return content.includes('"@omnify/*"') || content.includes("'@omnify/*'") || content.includes('"@omnify/"');
 }
@@ -317,6 +320,80 @@ function configureOmnifyAlias(rootDir, omnifyPath = "omnify", silent = false) {
   }
   return result;
 }
+function addPluginEnumAlias(rootDir) {
+  const configPaths = [
+    resolve(rootDir, "vite.config.ts"),
+    resolve(rootDir, "vite.config.js"),
+    resolve(rootDir, "vite.config.mts"),
+    resolve(rootDir, "vite.config.mjs")
+  ];
+  const configPath2 = configPaths.find((p) => existsSync(p));
+  if (!configPath2) {
+    return { updated: false };
+  }
+  try {
+    let content = readFileSync(configPath2, "utf-8");
+    if (hasViteOmnifyBaseAlias(content)) {
+      return { updated: false };
+    }
+    const lines = content.split("\n");
+    let insertIndex = -1;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if ((line.includes("'@omnify'") || line.includes('"@omnify"')) && line.includes(":")) {
+        for (let j = i; j < lines.length; j++) {
+          if (lines[j].includes("),") || lines[j].trim().endsWith(",") && lines[j].includes(")")) {
+            insertIndex = j + 1;
+            break;
+          }
+        }
+        break;
+      }
+    }
+    if (insertIndex > 0) {
+      const indent = "      ";
+      const aliasLine = `${indent}'@omnify-base': path.resolve(__dirname, 'node_modules/@omnify-base'),`;
+      lines.splice(insertIndex, 0, aliasLine);
+      content = lines.join("\n");
+      writeFileSync(configPath2, content);
+      return { updated: true };
+    }
+    return { updated: false, error: "Could not find @omnify alias to add @omnify-base after" };
+  } catch (error) {
+    return {
+      updated: false,
+      error: `Failed to add plugin enum alias: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+function addPluginEnumTsconfigPath(rootDir) {
+  const configPath2 = resolve(rootDir, "tsconfig.json");
+  if (!existsSync(configPath2)) {
+    return { updated: false };
+  }
+  try {
+    const content = readFileSync(configPath2, "utf-8");
+    if (content.includes("@omnify-base")) {
+      return { updated: false };
+    }
+    const jsonContent = content.replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, "");
+    const config = JSON.parse(jsonContent);
+    if (!config.compilerOptions) {
+      config.compilerOptions = {};
+    }
+    if (!config.compilerOptions.paths) {
+      config.compilerOptions.paths = {};
+    }
+    config.compilerOptions.paths["@omnify-base/*"] = ["./node_modules/@omnify-base/*"];
+    writeFileSync(configPath2, JSON.stringify(config, null, 2));
+    return { updated: true };
+  } catch (error) {
+    return {
+      updated: false,
+      error: `Failed to add plugin enum tsconfig path: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
 
 // src/commands/init.ts
 var EXAMPLE_SCHEMA = `# Example User schema
@@ -1062,7 +1139,7 @@ import {
   generateFactories,
   getFactoryPath
 } from "@famgia/omnify-laravel";
-import { generateTypeScript, copyStubs, generateAIGuides as generateTypescriptAIGuides, shouldGenerateAIGuides as shouldGenerateTypescriptAIGuides } from "@famgia/omnify-typescript";
+import { generateTypeScript, generateAIGuides as generateTypescriptAIGuides, shouldGenerateAIGuides as shouldGenerateTypescriptAIGuides } from "@famgia/omnify-typescript";
 
 // src/guides/index.ts
 import { existsSync as existsSync7, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync3 } from "fs";
@@ -1175,10 +1252,8 @@ function copyOmnifyGuides(rootDir) {
 function generateAIGuides(rootDir, _plugins) {
   let filesWritten = 0;
   const claudeMdPath = resolve7(rootDir, "CLAUDE.md");
-  if (!existsSync7(claudeMdPath)) {
-    writeFileSync3(claudeMdPath, CLAUDE_MD);
-    filesWritten++;
-  }
+  writeFileSync3(claudeMdPath, CLAUDE_MD);
+  filesWritten++;
   filesWritten += copyOmnifyGuides(rootDir);
   return filesWritten;
 }
@@ -1555,6 +1630,9 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
     const basePath = resolve8(rootDir, tsConfig.path);
     const schemasDir = resolve8(basePath, tsConfig.schemasDir ?? "schemas");
     const enumDir = resolve8(basePath, tsConfig.enumDir ?? "enum");
+    const omnifyBaseDir = resolve8(rootDir, "node_modules/@omnify-base");
+    const pluginEnumDir = resolve8(omnifyBaseDir, "enum");
+    const baseSchemasDir = resolve8(omnifyBaseDir, "schemas");
     const enumImportPrefix = relative(schemasDir, enumDir).replace(/\\/g, "/");
     if (!existsSync8(schemasDir)) {
       mkdirSync3(schemasDir, { recursive: true });
@@ -1564,6 +1642,26 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
       mkdirSync3(enumDir, { recursive: true });
       logger.debug(`Created directory: ${enumDir}`);
     }
+    if (!existsSync8(pluginEnumDir)) {
+      mkdirSync3(pluginEnumDir, { recursive: true });
+      logger.debug(`Created directory: ${pluginEnumDir}`);
+    }
+    if (!existsSync8(baseSchemasDir)) {
+      mkdirSync3(baseSchemasDir, { recursive: true });
+      logger.debug(`Created directory: ${baseSchemasDir}`);
+    }
+    const omnifyPkgJson = resolve8(omnifyBaseDir, "package.json");
+    if (!existsSync8(omnifyPkgJson)) {
+      writeFileSync4(omnifyPkgJson, JSON.stringify({
+        name: "@omnify-base",
+        version: "0.0.0",
+        private: true,
+        exports: {
+          "./enum/*": "./enum/*.js",
+          "./schemas/*": "./schemas/*.js"
+        }
+      }, null, 2));
+    }
     const isMultiLocale = config.locale && config.locale.locales && config.locale.locales.length > 1;
     const typeFiles = generateTypeScript(schemas, {
       customTypes: customTypesMap,
@@ -1572,11 +1670,26 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
       multiLocale: isMultiLocale,
       generateRules: tsConfig.generateRules ?? true,
       validationTemplates: tsConfig.validationTemplates,
-      enumImportPrefix
+      enumImportPrefix,
+      pluginEnumImportPrefix: "@omnify-base/enum",
+      baseImportPrefix: "@omnify-base/schemas",
+      schemaEnumImportPrefix: "@omnify/enum"
+      // Absolute path for node_modules base files
     });
     for (const file of typeFiles) {
-      const outputDir = file.category === "enum" ? enumDir : schemasDir;
-      const filePath = resolve8(outputDir, file.filePath);
+      let outputDir;
+      let outputFilePath = file.filePath;
+      if (file.category === "plugin-enum") {
+        outputDir = pluginEnumDir;
+      } else if (file.category === "base") {
+        outputDir = baseSchemasDir;
+        outputFilePath = file.filePath.replace(/^base\//, "");
+      } else if (file.category === "enum") {
+        outputDir = enumDir;
+      } else {
+        outputDir = schemasDir;
+      }
+      const filePath = resolve8(outputDir, outputFilePath);
       const fileDir = dirname6(filePath);
       if (!existsSync8(fileDir)) {
         mkdirSync3(fileDir, { recursive: true });
@@ -1590,13 +1703,6 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
       typesGenerated++;
     }
     logger.success(`Generated ${typesGenerated} TypeScript file(s)`);
-    const stubsResult = copyStubs({
-      targetDir: basePath,
-      skipIfExists: true
-    });
-    if (stubsResult.copied.length > 0) {
-      logger.success(`Generated ${stubsResult.copied.length} React stub(s)`);
-    }
     const aliasResult = configureOmnifyAlias(rootDir, tsConfig.path, true);
     if (aliasResult.viteUpdated) {
       logger.success("Auto-configured @omnify alias in vite.config");
@@ -1604,6 +1710,14 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
     if (aliasResult.tsconfigUpdated) {
       logger.success("Auto-configured @omnify/* path in tsconfig.json");
     }
+    const pluginAliasResult = addPluginEnumAlias(rootDir);
+    if (pluginAliasResult.updated) {
+      logger.success("Auto-configured @omnify-base alias in vite.config");
+    }
+    const pluginPathResult = addPluginEnumTsconfigPath(rootDir);
+    if (pluginPathResult.updated) {
+      logger.success("Auto-configured @omnify-base/* path in tsconfig.json");
+    }
   }
   return { migrations: migrationsGenerated, types: typesGenerated, models: modelsGenerated, factories: factoriesGenerated };
 }
@@ -1775,11 +1889,48 @@ async function runGenerate(options) {
         return;
       }
     }
-    if (migrationValidation.missingFiles.length > 0) {
+    if (migrationValidation.missingFiles.length > 0 && config.output.laravel) {
       const toRegenerate = getMigrationsToRegenerate(existingLock, migrationValidation.missingFiles);
       if (toRegenerate.length > 0) {
-        logger.info(`Will regenerate ${toRegenerate.length} missing migration(s) with original timestamps.`);
-        logger.warn("Auto-regeneration not yet implemented. Please restore from git or reset migrations.");
+        const createMigrations = toRegenerate.filter((m) => m.type === "create");
+        const alterMigrations = toRegenerate.filter((m) => m.type === "alter" || m.type === "drop");
+        if (createMigrations.length > 0) {
+          logger.info(`Regenerating ${createMigrations.length} missing CREATE migration(s) with original timestamps...`);
+          const migrationsDir2 = resolve8(rootDir, config.output.laravel.migrationsPath);
+          const customTypesMap2 = /* @__PURE__ */ new Map();
+          for (const plugin of config.plugins) {
+            if (plugin.types) {
+              for (const [typeName, typeDef] of Object.entries(plugin.types)) {
+                customTypesMap2.set(typeName, typeDef);
+              }
+            }
+          }
+          for (const migData of createMigrations) {
+            const migrationSchemas = Object.fromEntries(
+              Object.entries(schemas).filter(([name]) => migData.schemas.includes(name))
+            );
+            if (Object.keys(migrationSchemas).length === 0) {
+              logger.warn(`  Cannot regenerate ${migData.fileName}: schema not found`);
+              continue;
+            }
+            const regenerated = generateMigrations(migrationSchemas, {
+              timestamp: migData.timestamp,
+              customTypes: customTypesMap2
+            });
+            for (const mig of regenerated) {
+              const filePath = resolve8(migrationsDir2, migData.fileName);
+              writeFileSync4(filePath, mig.content);
+              logger.success(`  Regenerated: ${migData.fileName}`);
+            }
+          }
+        }
+        if (alterMigrations.length > 0) {
+          logger.warn(`Cannot regenerate ${alterMigrations.length} ALTER/DROP migration(s) - original change data not available.`);
+          logger.warn("  Please restore these files from git or reset migrations with: npx omnify reset");
+          for (const m of alterMigrations) {
+            logger.warn(`    - ${m.fileName}`);
+          }
+        }
       }
     }
   }
@@ -1849,6 +2000,9 @@ async function runGenerate(options) {
       const basePath2 = resolve8(rootDir, tsConfig2.path);
       const schemasDir2 = resolve8(basePath2, tsConfig2.schemasDir ?? "schemas");
       const enumDir2 = resolve8(basePath2, tsConfig2.enumDir ?? "enum");
+      const omnifyBaseDir2 = resolve8(rootDir, "node_modules/@omnify-base");
+      const pluginEnumDir2 = resolve8(omnifyBaseDir2, "enum");
+      const baseSchemasDir2 = resolve8(omnifyBaseDir2, "schemas");
       const enumImportPrefix2 = relative(schemasDir2, enumDir2).replace(/\\/g, "/");
       if (!existsSync8(schemasDir2)) {
         mkdirSync3(schemasDir2, { recursive: true });
@@ -1858,6 +2012,26 @@ async function runGenerate(options) {
         mkdirSync3(enumDir2, { recursive: true });
         logger.debug(`Created directory: ${enumDir2}`);
       }
+      if (!existsSync8(pluginEnumDir2)) {
+        mkdirSync3(pluginEnumDir2, { recursive: true });
+        logger.debug(`Created directory: ${pluginEnumDir2}`);
+      }
+      if (!existsSync8(baseSchemasDir2)) {
+        mkdirSync3(baseSchemasDir2, { recursive: true });
+        logger.debug(`Created directory: ${baseSchemasDir2}`);
+      }
+      const omnifyPkgJson2 = resolve8(omnifyBaseDir2, "package.json");
+      if (!existsSync8(omnifyPkgJson2)) {
+        writeFileSync4(omnifyPkgJson2, JSON.stringify({
+          name: "@omnify-base",
+          version: "0.0.0",
+          private: true,
+          exports: {
+            "./enum/*": "./enum/*.js",
+            "./schemas/*": "./schemas/*.js"
+          }
+        }, null, 2));
+      }
       const isMultiLocale = config.locale && config.locale.locales && config.locale.locales.length > 1;
       const typeFiles = generateTypeScript(schemas, {
         customTypes: customTypesMap,
@@ -1866,11 +2040,26 @@ async function runGenerate(options) {
         multiLocale: isMultiLocale,
         generateRules: tsConfig2.generateRules ?? true,
         validationTemplates: tsConfig2.validationTemplates,
-        enumImportPrefix: enumImportPrefix2
+        enumImportPrefix: enumImportPrefix2,
+        pluginEnumImportPrefix: "@omnify-base/enum",
+        baseImportPrefix: "@omnify-base/schemas",
+        schemaEnumImportPrefix: "@omnify/enum"
+        // Absolute path for node_modules base files
       });
       for (const file of typeFiles) {
-        const outputDir2 = file.category === "enum" ? enumDir2 : schemasDir2;
-        const filePath = resolve8(outputDir2, file.filePath);
+        let outputDir2;
+        let outputFilePath2 = file.filePath;
+        if (file.category === "plugin-enum") {
+          outputDir2 = pluginEnumDir2;
+        } else if (file.category === "base") {
+          outputDir2 = baseSchemasDir2;
+          outputFilePath2 = file.filePath.replace(/^base\//, "");
+        } else if (file.category === "enum") {
+          outputDir2 = enumDir2;
+        } else {
+          outputDir2 = schemasDir2;
+        }
+        const filePath = resolve8(outputDir2, outputFilePath2);
         const fileDir = dirname6(filePath);
         if (!existsSync8(fileDir)) {
           mkdirSync3(fileDir, { recursive: true });
@@ -1884,13 +2073,6 @@ async function runGenerate(options) {
         typesGenerated++;
       }
       logger.success(`Generated ${typesGenerated} TypeScript file(s)`);
-      const stubsResult2 = copyStubs({
-        targetDir: basePath2,
-        skipIfExists: true
-      });
-      if (stubsResult2.copied.length > 0) {
-        logger.success(`Generated ${stubsResult2.copied.length} React stub(s)`);
-      }
       const aliasResult = configureOmnifyAlias(rootDir, tsConfig2.path, true);
       if (aliasResult.viteUpdated) {
         logger.success("Auto-configured @omnify alias in vite.config");
@@ -1898,6 +2080,14 @@ async function runGenerate(options) {
       if (aliasResult.tsconfigUpdated) {
         logger.success("Auto-configured @omnify/* path in tsconfig.json");
       }
+      const pluginAliasResult = addPluginEnumAlias(rootDir);
+      if (pluginAliasResult.updated) {
+        logger.success("Auto-configured @omnify-base alias in vite.config");
+      }
+      const pluginPathResult = addPluginEnumTsconfigPath(rootDir);
+      if (pluginPathResult.updated) {
+        logger.success("Auto-configured @omnify-base/* path in tsconfig.json");
+      }
       if (shouldGenerateTypescriptAIGuides(rootDir)) {
         const tsAIResult = generateTypescriptAIGuides(rootDir, {
           typescriptPath: tsConfig2.path