@famgia/omnify-cli 0.0.143 → 0.0.145

package/dist/index.cjs

@@ -141,7 +141,8 @@ async function resolveConfig(userConfig, configPath) {
     plugins,
     verbose: userConfig.verbose ?? false,
     lockFilePath: userConfig.lockFilePath ?? ".omnify.lock",
-    ...userConfig.locale && { locale: userConfig.locale }
+    ...userConfig.locale && { locale: userConfig.locale },
+    ...userConfig.additionalSchemaPaths && { additionalSchemaPaths: userConfig.additionalSchemaPaths }
   };
   return result;
 }
@@ -744,6 +745,7 @@ function registerInitCommand(program) {
 }
 
 // src/commands/validate.ts
+var import_node_fs4 = require("fs");
 var import_node_path4 = require("path");
 var import_omnify_core3 = require("@famgia/omnify-core");
 async function runValidate(options) {
@@ -758,14 +760,38 @@ async function runValidate(options) {
   const schemaPath = (0, import_node_path4.resolve)(rootDir, config.schemasDir);
   logger.step(`Loading schemas from ${schemaPath}`);
   logger.timing("Schema load start");
-  const schemas = await (0, import_omnify_core3.loadSchemas)(schemaPath);
-  const schemaCount = Object.keys(schemas).length;
+  let schemas = await (0, import_omnify_core3.loadSchemas)(schemaPath);
+  logger.debug(`Found ${Object.keys(schemas).length} schema(s) in main directory`);
+  const additionalPaths = config.additionalSchemaPaths ?? [];
+  let hasPackageSchemas = false;
+  if (additionalPaths.length > 0) {
+    logger.step(`Loading schemas from ${additionalPaths.length} additional path(s)`);
+    for (const entry of additionalPaths) {
+      const absolutePath = (0, import_node_path4.resolve)(rootDir, entry.path);
+      logger.debug(`  Checking: ${entry.path} \u2192 ${absolutePath}`);
+      if ((0, import_node_fs4.existsSync)(absolutePath)) {
+        const packageSchemas = await (0, import_omnify_core3.loadSchemas)(absolutePath, { skipPartialResolution: true });
+        const count = Object.keys(packageSchemas).filter((k) => !k.startsWith("__partial__")).length;
+        const partialCount = Object.keys(packageSchemas).filter((k) => k.startsWith("__partial__")).length;
+        const nsInfo = entry.namespace ? ` [${entry.namespace}]` : "";
+        logger.info(`  \u2022 ${entry.path}${nsInfo}: ${count} schema(s)${partialCount > 0 ? ` + ${partialCount} partial(s)` : ""}`);
+        schemas = { ...packageSchemas, ...schemas };
+        hasPackageSchemas = true;
+      } else {
+        logger.warn(`  \u2022 ${entry.path}: directory not found (skipped)`);
+      }
+    }
+  }
+  if (hasPackageSchemas) {
+    schemas = (0, import_omnify_core3.mergePartialSchemas)(schemas);
+  }
   logger.timing("Schemas loaded");
+  const schemaCount = Object.keys(schemas).length;
   if (schemaCount === 0) {
     logger.warn("No schema files found");
     return;
   }
-  logger.debug(`Found ${schemaCount} schema(s)`);
+  logger.debug(`Total: ${schemaCount} schema(s)`);
   logger.step("Validating schemas...");
   logger.timing("Validation start");
   const result = (0, import_omnify_core3.validateSchemas)(schemas);
@@ -801,6 +827,7 @@ function registerValidateCommand(program) {
 }
 
 // src/commands/diff.ts
+var import_node_fs5 = require("fs");
 var import_node_path5 = require("path");
 var import_omnify_core4 = require("@famgia/omnify-core");
 
@@ -838,13 +865,37 @@ async function runDiff(options) {
   requireDevUrl(config);
   const schemaPath = (0, import_node_path5.resolve)(rootDir, config.schemasDir);
   logger.step(`Loading schemas from ${schemaPath}`);
-  const schemas = await (0, import_omnify_core4.loadSchemas)(schemaPath);
+  let schemas = await (0, import_omnify_core4.loadSchemas)(schemaPath);
+  logger.debug(`Found ${Object.keys(schemas).length} schema(s) in main directory`);
+  const additionalPaths = config.additionalSchemaPaths ?? [];
+  let hasPackageSchemas = false;
+  if (additionalPaths.length > 0) {
+    logger.step(`Loading schemas from ${additionalPaths.length} additional path(s)`);
+    for (const entry of additionalPaths) {
+      const absolutePath = (0, import_node_path5.resolve)(rootDir, entry.path);
+      logger.debug(`  Checking: ${entry.path} \u2192 ${absolutePath}`);
+      if ((0, import_node_fs5.existsSync)(absolutePath)) {
+        const packageSchemas = await (0, import_omnify_core4.loadSchemas)(absolutePath, { skipPartialResolution: true });
+        const count = Object.keys(packageSchemas).filter((k) => !k.startsWith("__partial__")).length;
+        const partialCount = Object.keys(packageSchemas).filter((k) => k.startsWith("__partial__")).length;
+        const nsInfo = entry.namespace ? ` [${entry.namespace}]` : "";
+        logger.info(`  \u2022 ${entry.path}${nsInfo}: ${count} schema(s)${partialCount > 0 ? ` + ${partialCount} partial(s)` : ""}`);
+        schemas = { ...packageSchemas, ...schemas };
+        hasPackageSchemas = true;
+      } else {
+        logger.warn(`  \u2022 ${entry.path}: directory not found (skipped)`);
+      }
+    }
+  }
+  if (hasPackageSchemas) {
+    schemas = (0, import_omnify_core4.mergePartialSchemas)(schemas);
+  }
   const schemaCount = Object.keys(schemas).length;
   if (schemaCount === 0) {
     logger.warn("No schema files found");
     return;
   }
-  logger.debug(`Found ${schemaCount} schema(s)`);
+  logger.debug(`Total: ${schemaCount} schema(s)`);
   logger.step("Validating schemas...");
   const validationResult = (0, import_omnify_core4.validateSchemas)(schemas);
   if (!validationResult.valid) {
@@ -902,7 +953,7 @@ function registerDiffCommand(program) {
 }
 
 // src/commands/generate.ts
-var import_node_fs5 = require("fs");
+var import_node_fs7 = require("fs");
 var import_node_path7 = require("path");
 var import_omnify_core5 = require("@famgia/omnify-core");
 var import_omnify_atlas2 = require("@famgia/omnify-atlas");
@@ -910,7 +961,7 @@ var import_omnify_laravel = require("@famgia/omnify-laravel");
 var import_omnify_typescript = require("@famgia/omnify-typescript");
 
 // src/guides/index.ts
-var import_node_fs4 = require("fs");
+var import_node_fs6 = require("fs");
 var import_node_path6 = require("path");
 var import_node_url = require("url");
 var CLAUDE_MD = `# Omnify Project
@@ -975,19 +1026,19 @@ function copyOmnifyGuides(rootDir) {
   for (const pkgPath of omnifyPkgPaths) {
     if (pkgPath.includes("*")) {
       const parentDir = (0, import_node_path6.dirname)((0, import_node_path6.dirname)(pkgPath));
-      if ((0, import_node_fs4.existsSync)(parentDir)) {
-        const entries = (0, import_node_fs4.readdirSync)(parentDir);
+      if ((0, import_node_fs6.existsSync)(parentDir)) {
+        const entries = (0, import_node_fs6.readdirSync)(parentDir);
         for (const entry of entries) {
           if (entry.startsWith("@famgia+omnify@")) {
             const testPath = (0, import_node_path6.join)(parentDir, entry, "node_modules", "@famgia", "omnify", "stubs", "ai-guides", "omnify");
-            if ((0, import_node_fs4.existsSync)(testPath)) {
+            if ((0, import_node_fs6.existsSync)(testPath)) {
               stubsDir = testPath;
               break;
             }
           }
         }
       }
-    } else if ((0, import_node_fs4.existsSync)(pkgPath)) {
+    } else if ((0, import_node_fs6.existsSync)(pkgPath)) {
       stubsDir = pkgPath;
       break;
     }
@@ -996,7 +1047,7 @@ function copyOmnifyGuides(rootDir) {
     try {
       const omnifyPath = (0, import_node_path6.dirname)(require.resolve("@famgia/omnify/package.json", { paths: [rootDir] }));
       const testPath = (0, import_node_path6.join)(omnifyPath, "stubs", "ai-guides", "omnify");
-      if ((0, import_node_fs4.existsSync)(testPath)) {
+      if ((0, import_node_fs6.existsSync)(testPath)) {
         stubsDir = testPath;
       }
     } catch {
@@ -1006,13 +1057,13 @@ function copyOmnifyGuides(rootDir) {
     return 0;
   }
   const destDir = (0, import_node_path6.resolve)(rootDir, ".claude", "omnify", "guides", "omnify");
-  (0, import_node_fs4.mkdirSync)(destDir, { recursive: true });
-  const files = (0, import_node_fs4.readdirSync)(stubsDir).filter((f) => f.endsWith(".stub"));
+  (0, import_node_fs6.mkdirSync)(destDir, { recursive: true });
+  const files = (0, import_node_fs6.readdirSync)(stubsDir).filter((f) => f.endsWith(".stub"));
   for (const file of files) {
     const srcPath = (0, import_node_path6.join)(stubsDir, file);
     const destPath = (0, import_node_path6.join)(destDir, file.replace(".stub", ""));
-    const content = (0, import_node_fs4.readFileSync)(srcPath, "utf8");
-    (0, import_node_fs4.writeFileSync)(destPath, content);
+    const content = (0, import_node_fs6.readFileSync)(srcPath, "utf8");
+    (0, import_node_fs6.writeFileSync)(destPath, content);
     filesWritten++;
   }
   return filesWritten;
@@ -1020,8 +1071,8 @@ function copyOmnifyGuides(rootDir) {
 function generateAIGuides(rootDir, _plugins) {
   let filesWritten = 0;
   const claudeMdPath = (0, import_node_path6.resolve)(rootDir, "CLAUDE.md");
-  if (!(0, import_node_fs4.existsSync)(claudeMdPath)) {
-    (0, import_node_fs4.writeFileSync)(claudeMdPath, CLAUDE_MD);
+  if (!(0, import_node_fs6.existsSync)(claudeMdPath)) {
+    (0, import_node_fs6.writeFileSync)(claudeMdPath, CLAUDE_MD);
     filesWritten++;
   }
   filesWritten += copyOmnifyGuides(rootDir);
@@ -1029,37 +1080,16 @@ function generateAIGuides(rootDir, _plugins) {
 }
 
 // src/commands/generate.ts
-async function loadRegisteredSchemaPaths(rootDir) {
-  const schemaPathsFile = (0, import_node_path7.resolve)(rootDir, "storage/omnify/schema-paths.json");
-  logger.debug(`Checking for registered schema paths at: ${schemaPathsFile}`);
-  if (!(0, import_node_fs5.existsSync)(schemaPathsFile)) {
-    logger.debug("No registered schema paths file found");
-    return [];
-  }
-  try {
-    const content = (0, import_node_fs5.readFileSync)(schemaPathsFile, "utf-8");
-    const data = JSON.parse(content);
-    if (!data.paths || data.paths.length === 0) {
-      logger.debug("No paths defined in schema-paths.json");
-      return [];
-    }
-    logger.debug(`Found ${data.paths.length} registered schema path(s) in schema-paths.json`);
-    return data.paths;
-  } catch (error) {
-    logger.warn(`Could not read schema-paths.json: ${error.message}`);
-    return [];
-  }
-}
 function hasPluginGenerators(plugins) {
   return plugins.some((p) => p.generators && p.generators.length > 0);
 }
 function getExistingMigrationTables(migrationsDir) {
   const existingTables = /* @__PURE__ */ new Set();
-  if (!(0, import_node_fs5.existsSync)(migrationsDir)) {
+  if (!(0, import_node_fs7.existsSync)(migrationsDir)) {
     return existingTables;
   }
   try {
-    const files = (0, import_node_fs5.readdirSync)(migrationsDir);
+    const files = (0, import_node_fs7.readdirSync)(migrationsDir);
     const createMigrationPattern = /^\d{4}_\d{2}_\d{2}_\d{6}_create_(.+)_table\.php$/;
     for (const file of files) {
       const match = file.match(createMigrationPattern);
@@ -1250,15 +1280,15 @@ function writeGeneratorOutputs(outputs, rootDir) {
   for (const output of outputs) {
     const filePath = (0, import_node_path7.resolve)(rootDir, output.path);
     const dir = (0, import_node_path7.dirname)(filePath);
-    if (!(0, import_node_fs5.existsSync)(dir)) {
-      (0, import_node_fs5.mkdirSync)(dir, { recursive: true });
+    if (!(0, import_node_fs7.existsSync)(dir)) {
+      (0, import_node_fs7.mkdirSync)(dir, { recursive: true });
       logger.debug(`Created directory: ${dir}`);
     }
-    if (output.skipIfExists && (0, import_node_fs5.existsSync)(filePath)) {
+    if (output.skipIfExists && (0, import_node_fs7.existsSync)(filePath)) {
       logger.debug(`Skipped (exists): ${output.path}`);
       continue;
     }
-    (0, import_node_fs5.writeFileSync)(filePath, output.content);
+    (0, import_node_fs7.writeFileSync)(filePath, output.content);
     logger.debug(`Created: ${output.path}`);
     if (output.type === "migration") counts.migrations++;
     else if (output.type === "type") counts.types++;
@@ -1315,8 +1345,8 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
   if (!options.typesOnly && config.output.laravel) {
     logger.step("Generating Laravel migrations...");
     const migrationsDir = (0, import_node_path7.resolve)(rootDir, config.output.laravel.migrationsPath);
-    if (!(0, import_node_fs5.existsSync)(migrationsDir)) {
-      (0, import_node_fs5.mkdirSync)(migrationsDir, { recursive: true });
+    if (!(0, import_node_fs7.existsSync)(migrationsDir)) {
+      (0, import_node_fs7.mkdirSync)(migrationsDir, { recursive: true });
       logger.debug(`Created directory: ${migrationsDir}`);
     }
     const addedSchemaNames = new Set(
@@ -1338,7 +1368,7 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
           continue;
         }
         const filePath = (0, import_node_path7.resolve)(migrationsDir, migration.fileName);
-        (0, import_node_fs5.writeFileSync)(filePath, migration.content);
+        (0, import_node_fs7.writeFileSync)(filePath, migration.content);
         logger.debug(`Created: ${migration.fileName}`);
         migrationsGenerated++;
       }
@@ -1347,7 +1377,7 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
       const alterMigrations = (0, import_omnify_laravel.generateMigrationsFromChanges)(alterChanges);
       for (const migration of alterMigrations) {
         const filePath = (0, import_node_path7.resolve)(migrationsDir, migration.fileName);
-        (0, import_node_fs5.writeFileSync)(filePath, migration.content);
+        (0, import_node_fs7.writeFileSync)(filePath, migration.content);
         logger.debug(`Created: ${migration.fileName}`);
         migrationsGenerated++;
       }
@@ -1360,11 +1390,11 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
     const baseModelsPath = config.output.laravel.baseModelsPath ?? `${modelsPath}/OmnifyBase`;
     const modelsDir = (0, import_node_path7.resolve)(rootDir, modelsPath);
     const baseModelsDir = (0, import_node_path7.resolve)(rootDir, baseModelsPath);
-    if (!(0, import_node_fs5.existsSync)(modelsDir)) {
-      (0, import_node_fs5.mkdirSync)(modelsDir, { recursive: true });
+    if (!(0, import_node_fs7.existsSync)(modelsDir)) {
+      (0, import_node_fs7.mkdirSync)(modelsDir, { recursive: true });
     }
-    if (!(0, import_node_fs5.existsSync)(baseModelsDir)) {
-      (0, import_node_fs5.mkdirSync)(baseModelsDir, { recursive: true });
+    if (!(0, import_node_fs7.existsSync)(baseModelsDir)) {
+      (0, import_node_fs7.mkdirSync)(baseModelsDir, { recursive: true });
     }
     const providersPath = config.output.laravel.providersPath ?? "app/Providers";
     const models = (0, import_omnify_laravel.generateModels)(schemas, {
@@ -1376,14 +1406,14 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
     for (const model of models) {
       const filePath = (0, import_node_path7.resolve)(rootDir, (0, import_omnify_laravel.getModelPath)(model));
       const fileDir = (0, import_node_path7.dirname)(filePath);
-      if (!(0, import_node_fs5.existsSync)(fileDir)) {
-        (0, import_node_fs5.mkdirSync)(fileDir, { recursive: true });
+      if (!(0, import_node_fs7.existsSync)(fileDir)) {
+        (0, import_node_fs7.mkdirSync)(fileDir, { recursive: true });
       }
-      if (!model.overwrite && (0, import_node_fs5.existsSync)(filePath)) {
+      if (!model.overwrite && (0, import_node_fs7.existsSync)(filePath)) {
         logger.debug(`Skipped (exists): ${(0, import_omnify_laravel.getModelPath)(model)}`);
         continue;
       }
-      (0, import_node_fs5.writeFileSync)(filePath, model.content);
+      (0, import_node_fs7.writeFileSync)(filePath, model.content);
       logger.debug(`Created: ${(0, import_omnify_laravel.getModelPath)(model)}`);
       modelsGenerated++;
     }
@@ -1393,8 +1423,8 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
     logger.step("Generating Laravel factories...");
     const factoriesPath = config.output.laravel.factoriesPath;
     const factoriesDir = (0, import_node_path7.resolve)(rootDir, factoriesPath);
-    if (!(0, import_node_fs5.existsSync)(factoriesDir)) {
-      (0, import_node_fs5.mkdirSync)(factoriesDir, { recursive: true });
+    if (!(0, import_node_fs7.existsSync)(factoriesDir)) {
+      (0, import_node_fs7.mkdirSync)(factoriesDir, { recursive: true });
     }
     const factories = (0, import_omnify_laravel.generateFactories)(schemas, {
       factoryPath: factoriesPath
@@ -1402,14 +1432,14 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
     for (const factory of factories) {
       const filePath = (0, import_node_path7.resolve)(rootDir, (0, import_omnify_laravel.getFactoryPath)(factory));
       const fileDir = (0, import_node_path7.dirname)(filePath);
-      if (!(0, import_node_fs5.existsSync)(fileDir)) {
-        (0, import_node_fs5.mkdirSync)(fileDir, { recursive: true });
+      if (!(0, import_node_fs7.existsSync)(fileDir)) {
+        (0, import_node_fs7.mkdirSync)(fileDir, { recursive: true });
       }
-      if (!factory.overwrite && (0, import_node_fs5.existsSync)(filePath)) {
+      if (!factory.overwrite && (0, import_node_fs7.existsSync)(filePath)) {
         logger.debug(`Skipped (exists): ${(0, import_omnify_laravel.getFactoryPath)(factory)}`);
         continue;
       }
-      (0, import_node_fs5.writeFileSync)(filePath, factory.content);
+      (0, import_node_fs7.writeFileSync)(filePath, factory.content);
       logger.debug(`Created: ${(0, import_omnify_laravel.getFactoryPath)(factory)}`);
       factoriesGenerated++;
     }
@@ -1422,12 +1452,12 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
     const schemasDir = (0, import_node_path7.resolve)(basePath, tsConfig.schemasDir ?? "schemas");
     const enumDir = (0, import_node_path7.resolve)(basePath, tsConfig.enumDir ?? "enum");
     const enumImportPrefix = (0, import_node_path7.relative)(schemasDir, enumDir).replace(/\\/g, "/");
-    if (!(0, import_node_fs5.existsSync)(schemasDir)) {
-      (0, import_node_fs5.mkdirSync)(schemasDir, { recursive: true });
+    if (!(0, import_node_fs7.existsSync)(schemasDir)) {
+      (0, import_node_fs7.mkdirSync)(schemasDir, { recursive: true });
       logger.debug(`Created directory: ${schemasDir}`);
     }
-    if (!(0, import_node_fs5.existsSync)(enumDir)) {
-      (0, import_node_fs5.mkdirSync)(enumDir, { recursive: true });
+    if (!(0, import_node_fs7.existsSync)(enumDir)) {
+      (0, import_node_fs7.mkdirSync)(enumDir, { recursive: true });
       logger.debug(`Created directory: ${enumDir}`);
     }
     const isMultiLocale = config.locale && config.locale.locales && config.locale.locales.length > 1;
@@ -1444,14 +1474,14 @@ function runDirectGeneration(schemas, config, rootDir, options, changes) {
       const outputDir = file.category === "enum" ? enumDir : schemasDir;
       const filePath = (0, import_node_path7.resolve)(outputDir, file.filePath);
       const fileDir = (0, import_node_path7.dirname)(filePath);
-      if (!(0, import_node_fs5.existsSync)(fileDir)) {
-        (0, import_node_fs5.mkdirSync)(fileDir, { recursive: true });
+      if (!(0, import_node_fs7.existsSync)(fileDir)) {
+        (0, import_node_fs7.mkdirSync)(fileDir, { recursive: true });
       }
-      if (!file.overwrite && (0, import_node_fs5.existsSync)(filePath)) {
+      if (!file.overwrite && (0, import_node_fs7.existsSync)(filePath)) {
         logger.debug(`Skipped (exists): ${file.filePath}`);
         continue;
       }
-      (0, import_node_fs5.writeFileSync)(filePath, file.content);
+      (0, import_node_fs7.writeFileSync)(filePath, file.content);
       logger.debug(`Created: ${file.filePath}`);
       typesGenerated++;
     }
@@ -1484,18 +1514,19 @@ async function runGenerate(options) {
   logger.step(`Loading schemas from ${schemaPath}`);
   let schemas = await (0, import_omnify_core5.loadSchemas)(schemaPath);
   logger.debug(`Found ${Object.keys(schemas).length} schema(s) in main directory`);
-  const additionalPaths = await loadRegisteredSchemaPaths(rootDir);
+  const additionalPaths = config.additionalSchemaPaths ?? [];
   let hasPackageSchemas = false;
   if (additionalPaths.length > 0) {
-    logger.step(`Loading schemas from ${additionalPaths.length} registered path(s)`);
+    logger.step(`Loading schemas from ${additionalPaths.length} additional path(s)`);
     for (const entry of additionalPaths) {
       const absolutePath = (0, import_node_path7.resolve)(rootDir, entry.path);
       logger.debug(`  Checking: ${entry.path} \u2192 ${absolutePath}`);
-      if ((0, import_node_fs5.existsSync)(absolutePath)) {
+      if ((0, import_node_fs7.existsSync)(absolutePath)) {
         const packageSchemas = await (0, import_omnify_core5.loadSchemas)(absolutePath, { skipPartialResolution: true });
         const count = Object.keys(packageSchemas).filter((k) => !k.startsWith("__partial__")).length;
         const partialCount = Object.keys(packageSchemas).filter((k) => k.startsWith("__partial__")).length;
-        logger.info(`  \u2022 ${entry.path}: ${count} schema(s)${partialCount > 0 ? ` + ${partialCount} partial(s)` : ""}`);
+        const nsInfo = entry.namespace ? ` [${entry.namespace}]` : "";
+        logger.info(`  \u2022 ${entry.path}${nsInfo}: ${count} schema(s)${partialCount > 0 ? ` + ${partialCount} partial(s)` : ""}`);
         schemas = { ...packageSchemas, ...schemas };
         hasPackageSchemas = true;
       } else {
@@ -1704,12 +1735,12 @@ async function runGenerate(options) {
       const schemasDir2 = (0, import_node_path7.resolve)(basePath2, tsConfig2.schemasDir ?? "schemas");
       const enumDir2 = (0, import_node_path7.resolve)(basePath2, tsConfig2.enumDir ?? "enum");
       const enumImportPrefix2 = (0, import_node_path7.relative)(schemasDir2, enumDir2).replace(/\\/g, "/");
-      if (!(0, import_node_fs5.existsSync)(schemasDir2)) {
-        (0, import_node_fs5.mkdirSync)(schemasDir2, { recursive: true });
+      if (!(0, import_node_fs7.existsSync)(schemasDir2)) {
+        (0, import_node_fs7.mkdirSync)(schemasDir2, { recursive: true });
         logger.debug(`Created directory: ${schemasDir2}`);
       }
-      if (!(0, import_node_fs5.existsSync)(enumDir2)) {
-        (0, import_node_fs5.mkdirSync)(enumDir2, { recursive: true });
+      if (!(0, import_node_fs7.existsSync)(enumDir2)) {
+        (0, import_node_fs7.mkdirSync)(enumDir2, { recursive: true });
         logger.debug(`Created directory: ${enumDir2}`);
       }
       const isMultiLocale = config.locale && config.locale.locales && config.locale.locales.length > 1;
@@ -1726,14 +1757,14 @@ async function runGenerate(options) {
         const outputDir2 = file.category === "enum" ? enumDir2 : schemasDir2;
         const filePath = (0, import_node_path7.resolve)(outputDir2, file.filePath);
         const fileDir = (0, import_node_path7.dirname)(filePath);
-        if (!(0, import_node_fs5.existsSync)(fileDir)) {
-          (0, import_node_fs5.mkdirSync)(fileDir, { recursive: true });
+        if (!(0, import_node_fs7.existsSync)(fileDir)) {
+          (0, import_node_fs7.mkdirSync)(fileDir, { recursive: true });
         }
-        if (!file.overwrite && (0, import_node_fs5.existsSync)(filePath)) {
+        if (!file.overwrite && (0, import_node_fs7.existsSync)(filePath)) {
           logger.debug(`Skipped (exists): ${file.filePath}`);
           continue;
         }
-        (0, import_node_fs5.writeFileSync)(filePath, file.content);
+        (0, import_node_fs7.writeFileSync)(filePath, file.content);
         logger.debug(`Created: ${file.filePath}`);
         typesGenerated++;
       }