@dbcube/schema-builder 1.0.17 → 1.0.19

package/dist/index.cjs

@@ -31,6 +31,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   CubeValidator: () => CubeValidator,
+  DependencyResolver: () => DependencyResolver,
   Schema: () => Schema,
   UIUtils: () => UIUtils,
   default: () => index_default
@@ -38,9 +39,9 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/lib/Schema.ts
-var import_fs3 = __toESM(require("fs"));
+var import_fs4 = __toESM(require("fs"));
 var import_core = require("@dbcube/core");
-var import_path2 = __toESM(require("path"));
+var import_path3 = __toESM(require("path"));
 
 // src/lib/FileUtils.ts
 var fs = __toESM(require("fs"));
@@ -405,7 +406,7 @@ var CubeValidator = class {
             filePath,
             lineNumber
           });
-        } else if (!this.isOptionCompatibleWithType(option, columnType)) {
+        } else if (columnType !== "unknown" && !this.isOptionCompatibleWithType(option, columnType)) {
           errors.push({
             itemName: fileName,
             error: `Option '${option}' is not compatible with type '${columnType}'`,
@@ -424,6 +425,18 @@ var CubeValidator = class {
     if (/^\s*[a-zA-Z_][a-zA-Z0-9_]*\s*:\s*\{/.test(line)) {
       return;
     }
+    if (this.isInsideForeignKeyObject(content, lineNumber - 1)) {
+      const validForeignKeyProperties = ["table", "column"];
+      if (!validForeignKeyProperties.includes(propertyName)) {
+        errors.push({
+          itemName: fileName,
+          error: `Invalid foreign key property '${propertyName}'. Valid foreign key properties: ${validForeignKeyProperties.join(", ")}`,
+          filePath,
+          lineNumber
+        });
+      }
+      return;
+    }
     if (this.isInsideColumnsBlock(content, lineNumber - 1)) {
       if (!this.validProperties.includes(propertyName)) {
         errors.push({
@@ -592,6 +605,227 @@ var CubeValidator = class {
     }
     return columnsStartLine !== -1 && columnsEndLine !== -1 && lineIndex > columnsStartLine && lineIndex < columnsEndLine;
   }
+  isInsideForeignKeyObject(content, lineIndex) {
+    const lines = content.split("\n");
+    for (let i = lineIndex; i >= 0; i--) {
+      const line = lines[i];
+      if (/foreign\s*:\s*\{/.test(line)) {
+        let braceCount = 0;
+        for (let j = i; j <= lineIndex; j++) {
+          const currentLine = lines[j];
+          const openBraces = (currentLine.match(/\{/g) || []).length;
+          const closeBraces = (currentLine.match(/\}/g) || []).length;
+          braceCount += openBraces - closeBraces;
+          if (braceCount === 0 && j > i) {
+            return false;
+          }
+        }
+        return braceCount > 0;
+      }
+      if (line.trim() === "}" || line.includes("};")) {
+        break;
+      }
+    }
+    return false;
+  }
+};
+
+// src/lib/DependencyResolver.ts
+var import_fs3 = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
+var DependencyResolver = class {
+  /**
+   * Resolves table dependencies and creates execution order
+   */
+  static resolveDependencies(cubeFiles, cubeType = "table") {
+    const tableDependencies = this.extractDependencies(cubeFiles, cubeType);
+    const orderedTables = this.topologicalSort(tableDependencies);
+    const executionOrder = {
+      tables: cubeType === "table" ? orderedTables : [],
+      seeders: cubeType === "seeder" ? orderedTables : [],
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.saveExecutionOrder(executionOrder);
+    return executionOrder;
+  }
+  /**
+   * Extracts dependencies from cube files
+   */
+  static extractDependencies(cubeFiles, cubeType) {
+    const dependencies = [];
+    for (const file of cubeFiles) {
+      let filePath;
+      if (import_path2.default.isAbsolute(file)) {
+        filePath = file;
+      } else if (import_fs3.default.existsSync(file)) {
+        filePath = import_path2.default.resolve(file);
+      } else {
+        filePath = import_path2.default.join(process.cwd(), "dbcube", "cubes", file);
+      }
+      try {
+        const tableNameResult = FileUtils_default.extracTableNameFromCube(filePath);
+        const tableName = tableNameResult.status === 200 ? tableNameResult.message : import_path2.default.basename(file, `.${cubeType}.cube`);
+        const deps = this.extractForeignKeyReferences(filePath);
+        dependencies.push({
+          tableName,
+          filePath,
+          dependencies: deps
+        });
+      } catch (error) {
+        console.error(`Error processing ${filePath}:`, error);
+      }
+    }
+    return dependencies;
+  }
+  /**
+   * Extracts foreign key references from a cube file
+   */
+  static extractForeignKeyReferences(filePath) {
+    const dependencies = [];
+    try {
+      const content = import_fs3.default.readFileSync(filePath, "utf8");
+      const lines = content.split("\n");
+      let insideForeignKey = false;
+      let braceCount = 0;
+      for (const line of lines) {
+        if (/foreign\s*:\s*\{/.test(line)) {
+          insideForeignKey = true;
+          braceCount = 1;
+          const sameLineMatch = line.match(/table\s*:\s*["']([^"']+)["']/);
+          if (sameLineMatch) {
+            dependencies.push(sameLineMatch[1]);
+            insideForeignKey = false;
+            braceCount = 0;
+          }
+          continue;
+        }
+        if (insideForeignKey) {
+          braceCount += (line.match(/\{/g) || []).length;
+          braceCount -= (line.match(/\}/g) || []).length;
+          const tableMatch = line.match(/table\s*:\s*["']([^"']+)["']/);
+          if (tableMatch) {
+            dependencies.push(tableMatch[1]);
+          }
+          if (braceCount === 0) {
+            insideForeignKey = false;
+          }
+        }
+      }
+    } catch (error) {
+      console.error(`Error reading file ${filePath}:`, error);
+    }
+    return dependencies;
+  }
+  /**
+   * Performs topological sort to determine execution order
+   */
+  static topologicalSort(dependencies) {
+    const graph = /* @__PURE__ */ new Map();
+    const inDegree = /* @__PURE__ */ new Map();
+    const tableMap = /* @__PURE__ */ new Map();
+    for (const dep of dependencies) {
+      graph.set(dep.tableName, dep.dependencies);
+      inDegree.set(dep.tableName, 0);
+      tableMap.set(dep.tableName, dep);
+    }
+    for (const dep of dependencies) {
+      for (const dependency of dep.dependencies) {
+        if (inDegree.has(dependency)) {
+          inDegree.set(dep.tableName, (inDegree.get(dep.tableName) || 0) + 1);
+        }
+      }
+    }
+    const queue = [];
+    const result = [];
+    for (const [table, degree] of inDegree) {
+      if (degree === 0) {
+        queue.push(table);
+      }
+    }
+    while (queue.length > 0) {
+      const current = queue.shift();
+      result.push(current);
+      const currentDeps = graph.get(current) || [];
+      for (const neighbor of currentDeps) {
+        if (inDegree.has(neighbor)) {
+          const newDegree = (inDegree.get(neighbor) || 0) - 1;
+          inDegree.set(neighbor, newDegree);
+          if (newDegree === 0) {
+            queue.push(neighbor);
+          }
+        }
+      }
+    }
+    if (result.length !== dependencies.length) {
+      for (const dep of dependencies) {
+        if (!result.includes(dep.tableName)) {
+          result.push(dep.tableName);
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Saves the execution order to .dbcube/orderexecute.json
+   */
+  static saveExecutionOrder(order) {
+    try {
+      const projectRoot = process.cwd();
+      const dbcubeDir = import_path2.default.join(projectRoot, ".dbcube");
+      const orderFile = import_path2.default.join(dbcubeDir, "orderexecute.json");
+      if (!import_fs3.default.existsSync(dbcubeDir)) {
+        import_fs3.default.mkdirSync(dbcubeDir, { recursive: true });
+      }
+      import_fs3.default.writeFileSync(orderFile, JSON.stringify(order, null, 2), "utf8");
+    } catch (error) {
+      console.error("\u274C Failed to save execution order:", error);
+    }
+  }
+  /**
+   * Loads the execution order from .dbcube/orderexecute.json
+   */
+  static loadExecutionOrder() {
+    try {
+      const projectRoot = process.cwd();
+      const orderFile = import_path2.default.join(projectRoot, ".dbcube", "orderexecute.json");
+      if (!import_fs3.default.existsSync(orderFile)) {
+        return null;
+      }
+      const content = import_fs3.default.readFileSync(orderFile, "utf8");
+      return JSON.parse(content);
+    } catch (error) {
+      console.error("\u274C Failed to load execution order:", error);
+      return null;
+    }
+  }
+  /**
+   * Orders cube files based on saved execution order
+   */
+  static orderCubeFiles(cubeFiles, cubeType) {
+    const executionOrder = this.loadExecutionOrder();
+    if (!executionOrder) {
+      return cubeFiles;
+    }
+    const orderList = cubeType === "table" ? executionOrder.tables : executionOrder.seeders;
+    const orderedFiles = [];
+    const fileMap = /* @__PURE__ */ new Map();
+    for (const file of cubeFiles) {
+      const filePath = import_path2.default.isAbsolute(file) ? file : import_path2.default.join(process.cwd(), "dbcube", "cubes", file);
+      const tableNameResult = FileUtils_default.extracTableNameFromCube(filePath);
+      const tableName = tableNameResult.status === 200 ? tableNameResult.message : import_path2.default.basename(file, `.${cubeType}.cube`);
+      fileMap.set(tableName, file);
+    }
+    for (const tableName of orderList) {
+      if (fileMap.has(tableName)) {
+        orderedFiles.push(fileMap.get(tableName));
+        fileMap.delete(tableName);
+      }
+    }
+    for (const [, file] of fileMap) {
+      orderedFiles.push(file);
+    }
+    return orderedFiles;
+  }
 };
 
 // src/lib/Schema.ts
@@ -623,7 +857,7 @@ var Schema = class {
         return {
           isValid: false,
           error: {
-            itemName: import_path2.default.basename(filePath, import_path2.default.extname(filePath)),
+            itemName: import_path3.default.basename(filePath, import_path3.default.extname(filePath)),
             error: `Error reading database directive: ${dbResult.message}`,
             filePath,
             lineNumber: this.findDatabaseLineNumber(filePath)
@@ -632,7 +866,7 @@ var Schema = class {
       }
       const cubeDbName = dbResult.message;
       const configInstance = new import_core.Config();
-      const configFilePath = import_path2.default.resolve(process.cwd(), "dbcube.config.js");
+      const configFilePath = import_path3.default.resolve(process.cwd(), "dbcube.config.js");
       const configFn = require(configFilePath);
       if (typeof configFn === "function") {
         configFn(configInstance);
@@ -659,7 +893,7 @@ var Schema = class {
         return {
           isValid: false,
           error: {
-            itemName: import_path2.default.basename(filePath, import_path2.default.extname(filePath)),
+            itemName: import_path3.default.basename(filePath, import_path3.default.extname(filePath)),
             error: `Database configuration '${cubeDbName}' not found in dbcube.config.js. Available: ${availableText}`,
             filePath,
             lineNumber: this.findDatabaseLineNumber(filePath)
@@ -671,7 +905,7 @@ var Schema = class {
       return {
         isValid: false,
         error: {
-          itemName: import_path2.default.basename(filePath, import_path2.default.extname(filePath)),
+          itemName: import_path3.default.basename(filePath, import_path3.default.extname(filePath)),
           error: `Database configuration validation failed: ${error.message}`,
           filePath,
           lineNumber: this.findDatabaseLineNumber(filePath)
@@ -684,7 +918,7 @@ var Schema = class {
    */
   findDatabaseLineNumber(filePath) {
     try {
-      const content = import_fs3.default.readFileSync(filePath, "utf8");
+      const content = import_fs4.default.readFileSync(filePath, "utf8");
       const lines = content.split("\n");
       for (let i = 0; i < lines.length; i++) {
         if (lines[i].includes("@database")) {
@@ -696,9 +930,65 @@ var Schema = class {
       return 1;
     }
   }
+  /**
+   * Extracts foreign key dependencies from a cube file
+   */
+  extractForeignKeyDependencies(filePath) {
+    const dependencies = [];
+    try {
+      const content = import_fs4.default.readFileSync(filePath, "utf8");
+      const lines = content.split("\n");
+      let insideForeignKey = false;
+      let braceCount = 0;
+      for (const line of lines) {
+        if (/foreign\s*:\s*\{/.test(line)) {
+          insideForeignKey = true;
+          braceCount = 1;
+          const sameLineMatch = line.match(/table\s*:\s*["']([^"']+)["']/);
+          if (sameLineMatch) {
+            dependencies.push(sameLineMatch[1]);
+            insideForeignKey = false;
+            braceCount = 0;
+          }
+          continue;
+        }
+        if (insideForeignKey) {
+          braceCount += (line.match(/\{/g) || []).length;
+          braceCount -= (line.match(/\}/g) || []).length;
+          const tableMatch = line.match(/table\s*:\s*["']([^"']+)["']/);
+          if (tableMatch) {
+            dependencies.push(tableMatch[1]);
+          }
+          if (braceCount === 0) {
+            insideForeignKey = false;
+          }
+        }
+      }
+    } catch (error) {
+      console.error(`Error reading dependencies from ${filePath}:`, error);
+    }
+    return dependencies;
+  }
+  /**
+   * Finds the line number where a foreign key table reference is located
+   */
+  findForeignKeyLineNumber(filePath, tableName) {
+    try {
+      const content = import_fs4.default.readFileSync(filePath, "utf8");
+      const lines = content.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        if (lines[i].includes(`table: "${tableName}"`) || lines[i].includes(`table: '${tableName}'`)) {
+          return i + 1;
+        }
+      }
+      return 1;
+    } catch {
+      return 1;
+    }
+  }
   async createDatabase() {
     const startTime = Date.now();
-    const rootPath = import_path2.default.resolve(process.cwd());
+    const rootPath = import_path3.default.resolve(process.cwd());
     UIUtils.showOperationHeader(" CREATING DATABASE", this.name, "\u{1F5C4}\uFE0F");
     await UIUtils.showItemProgress("Preparando e instalando base de datos", 1, 1);
     try {
@@ -742,33 +1032,52 @@ var Schema = class {
   }
   async refreshTables() {
     const startTime = Date.now();
-    const cubesDir = import_path2.default.join(process.cwd(), "dbcube", "cubes");
-    if (!import_fs3.default.existsSync(cubesDir)) {
+    const cubesDir = import_path3.default.join(process.cwd(), "dbcube", "cubes");
+    if (!import_fs4.default.existsSync(cubesDir)) {
       throw new Error("\u274C The cubes folder does not exist");
     }
     const cubeFiles = FileUtils_default.getCubeFilesRecursively("dbcube", "table.cube");
     if (cubeFiles.length === 0) {
       throw new Error("\u274C There are no cubes to execute");
     }
+    DependencyResolver.resolveDependencies(cubeFiles, "table");
+    const orderedCubeFiles = DependencyResolver.orderCubeFiles(cubeFiles, "table");
     UIUtils.showOperationHeader("EXECUTING REFRESH TABLES", this.name, "\u{1F504}");
     let totalTablesProcessed = 0;
     let successCount = 0;
     let errorCount = 0;
     const processedTables = [];
     const errors = [];
-    for (let index = 0; index < cubeFiles.length; index++) {
-      const file = cubeFiles[index];
-      const filePath = import_path2.default.isAbsolute(file) ? file : import_path2.default.join(cubesDir, file);
-      const stats = import_fs3.default.statSync(filePath);
+    const failedTables = /* @__PURE__ */ new Set();
+    for (let index = 0; index < orderedCubeFiles.length; index++) {
+      const file = orderedCubeFiles[index];
+      const filePath = import_path3.default.isAbsolute(file) ? file : import_path3.default.join(cubesDir, file);
+      const stats = import_fs4.default.statSync(filePath);
       if (stats.isFile()) {
         const getTableName = FileUtils_default.extracTableNameFromCube(filePath);
-        const tableName = getTableName.status === 200 ? getTableName.message : import_path2.default.basename(file, ".table.cube");
-        await UIUtils.showItemProgress(tableName, index + 1, cubeFiles.length);
+        const tableName = getTableName.status === 200 ? getTableName.message : import_path3.default.basename(file, ".table.cube");
+        await UIUtils.showItemProgress(tableName, index + 1, orderedCubeFiles.length);
         try {
           const validation = this.validateDatabaseConfiguration(filePath);
           if (!validation.isValid && validation.error) {
             UIUtils.showItemError(tableName, validation.error.error);
             errors.push(validation.error);
+            failedTables.add(tableName);
+            errorCount++;
+            continue;
+          }
+          const dependencies = this.extractForeignKeyDependencies(filePath);
+          const missingDependencies = dependencies.filter((dep) => failedTables.has(dep));
+          if (missingDependencies.length > 0) {
+            const dependencyError = {
+              itemName: tableName,
+              error: `Cannot refresh table '${tableName}' because it depends on failed table(s): ${missingDependencies.join(", ")}`,
+              filePath,
+              lineNumber: this.findForeignKeyLineNumber(filePath, missingDependencies[0])
+            };
+            UIUtils.showItemError(tableName, dependencyError.error);
+            errors.push(dependencyError);
+            failedTables.add(tableName);
             errorCount++;
             continue;
           }
@@ -825,6 +1134,7 @@ var Schema = class {
           };
           UIUtils.showItemError(tableName, error.message);
           errors.push(processError);
+          failedTables.add(tableName);
           errorCount++;
         }
       }
@@ -844,33 +1154,52 @@ var Schema = class {
   }
   async freshTables() {
     const startTime = Date.now();
-    const cubesDir = import_path2.default.join(process.cwd(), "dbcube", "cubes");
-    if (!import_fs3.default.existsSync(cubesDir)) {
+    const cubesDir = import_path3.default.join(process.cwd(), "dbcube", "cubes");
+    if (!import_fs4.default.existsSync(cubesDir)) {
       throw new Error("\u274C The cubes folder does not exist");
     }
     const cubeFiles = FileUtils_default.getCubeFilesRecursively("dbcube", "table.cube");
     if (cubeFiles.length === 0) {
       throw new Error("\u274C There are no cubes to execute");
     }
+    DependencyResolver.resolveDependencies(cubeFiles, "table");
+    const orderedCubeFiles = DependencyResolver.orderCubeFiles(cubeFiles, "table");
     UIUtils.showOperationHeader("EXECUTING FRESH TABLES", this.name);
     let totalTablesProcessed = 0;
     let successCount = 0;
     let errorCount = 0;
     const processedTables = [];
     const errors = [];
-    for (let index = 0; index < cubeFiles.length; index++) {
-      const file = cubeFiles[index];
-      const filePath = import_path2.default.isAbsolute(file) ? file : import_path2.default.join(cubesDir, file);
-      const stats = import_fs3.default.statSync(filePath);
+    const failedTables = /* @__PURE__ */ new Set();
+    for (let index = 0; index < orderedCubeFiles.length; index++) {
+      const file = orderedCubeFiles[index];
+      const filePath = import_path3.default.isAbsolute(file) ? file : import_path3.default.join(cubesDir, file);
+      const stats = import_fs4.default.statSync(filePath);
       if (stats.isFile()) {
         const getTableName = FileUtils_default.extracTableNameFromCube(filePath);
-        const tableName = getTableName.status === 200 ? getTableName.message : import_path2.default.basename(file, ".table.cube");
-        await UIUtils.showItemProgress(tableName, index + 1, cubeFiles.length);
+        const tableName = getTableName.status === 200 ? getTableName.message : import_path3.default.basename(file, ".table.cube");
+        await UIUtils.showItemProgress(tableName, index + 1, orderedCubeFiles.length);
         try {
           const validation = this.validateDatabaseConfiguration(filePath);
           if (!validation.isValid && validation.error) {
             UIUtils.showItemError(tableName, validation.error.error);
             errors.push(validation.error);
+            failedTables.add(tableName);
+            errorCount++;
+            continue;
+          }
+          const dependencies = this.extractForeignKeyDependencies(filePath);
+          const missingDependencies = dependencies.filter((dep) => failedTables.has(dep));
+          if (missingDependencies.length > 0) {
+            const dependencyError = {
+              itemName: tableName,
+              error: `Cannot create table '${tableName}' because it depends on failed table(s): ${missingDependencies.join(", ")}`,
+              filePath,
+              lineNumber: this.findForeignKeyLineNumber(filePath, missingDependencies[0])
+            };
+            UIUtils.showItemError(tableName, dependencyError.error);
+            errors.push(dependencyError);
+            failedTables.add(tableName);
             errorCount++;
             continue;
           }
@@ -925,6 +1254,7 @@ var Schema = class {
           };
           UIUtils.showItemError(tableName, error.message);
           errors.push(processError);
+          failedTables.add(tableName);
           errorCount++;
         }
       }
@@ -944,28 +1274,29 @@ var Schema = class {
   }
   async executeSeeders() {
     const startTime = Date.now();
-    const cubesDir = import_path2.default.join(process.cwd(), "dbcube", "cubes");
-    if (!import_fs3.default.existsSync(cubesDir)) {
+    const cubesDir = import_path3.default.join(process.cwd(), "dbcube", "cubes");
+    if (!import_fs4.default.existsSync(cubesDir)) {
       throw new Error("\u274C The cubes folder does not exist");
     }
     const cubeFiles = FileUtils_default.getCubeFilesRecursively("dbcube", "seeder.cube");
     if (cubeFiles.length === 0) {
       throw new Error("\u274C There are no cubes to execute");
     }
+    const orderedCubeFiles = DependencyResolver.orderCubeFiles(cubeFiles, "seeder");
     UIUtils.showOperationHeader("EXECUTING SEEDERS", this.name, "\u{1F331}");
     let totalSeedersProcessed = 0;
     let successCount = 0;
     let errorCount = 0;
     const processedSeeders = [];
     const errors = [];
-    for (let index = 0; index < cubeFiles.length; index++) {
-      const file = cubeFiles[index];
-      const filePath = import_path2.default.isAbsolute(file) ? file : import_path2.default.join(cubesDir, file);
-      const stats = import_fs3.default.statSync(filePath);
+    for (let index = 0; index < orderedCubeFiles.length; index++) {
+      const file = orderedCubeFiles[index];
+      const filePath = import_path3.default.isAbsolute(file) ? file : import_path3.default.join(cubesDir, file);
+      const stats = import_fs4.default.statSync(filePath);
       if (stats.isFile()) {
         const getSeederName = FileUtils_default.extracTableNameFromCube(filePath);
-        const seederName = getSeederName.status === 200 ? getSeederName.message : import_path2.default.basename(file, ".seeder.cube");
-        await UIUtils.showItemProgress(seederName, index + 1, cubeFiles.length);
+        const seederName = getSeederName.status === 200 ? getSeederName.message : import_path3.default.basename(file, ".seeder.cube");
+        await UIUtils.showItemProgress(seederName, index + 1, orderedCubeFiles.length);
         try {
           const validation = this.validateDatabaseConfiguration(filePath);
           if (!validation.isValid && validation.error) {
@@ -1015,9 +1346,9 @@ var Schema = class {
   }
   async executeTriggers() {
     const startTime = Date.now();
-    const cubesDir = import_path2.default.join(process.cwd(), "dbcube", "cubes");
-    const triggersDirExit = import_path2.default.join(process.cwd(), "dbcube", "triggers");
-    if (!import_fs3.default.existsSync(cubesDir)) {
+    const cubesDir = import_path3.default.join(process.cwd(), "dbcube", "cubes");
+    const triggersDirExit = import_path3.default.join(process.cwd(), "dbcube", "triggers");
+    if (!import_fs4.default.existsSync(cubesDir)) {
       throw new Error("\u274C The cubes folder does not exist");
     }
     const cubeFiles = FileUtils_default.getCubeFilesRecursively("dbcube", "trigger.cube");
@@ -1032,11 +1363,11 @@ var Schema = class {
     const errors = [];
     for (let index = 0; index < cubeFiles.length; index++) {
       const file = cubeFiles[index];
-      const filePath = import_path2.default.isAbsolute(file) ? file : import_path2.default.join(cubesDir, file);
-      const stats = import_fs3.default.statSync(filePath);
+      const filePath = import_path3.default.isAbsolute(file) ? file : import_path3.default.join(cubesDir, file);
+      const stats = import_fs4.default.statSync(filePath);
       if (stats.isFile()) {
         const getTriggerName = FileUtils_default.extracTableNameFromCube(filePath);
-        const triggerName = getTriggerName.status === 200 ? getTriggerName.message : import_path2.default.basename(file, ".trigger.cube");
+        const triggerName = getTriggerName.status === 200 ? getTriggerName.message : import_path3.default.basename(file, ".trigger.cube");
         await UIUtils.showItemProgress(triggerName, index + 1, cubeFiles.length);
         try {
           const validation = this.validateDatabaseConfiguration(filePath);
@@ -1107,7 +1438,7 @@ ${import_chalk2.default.red("\u{1F6AB}")} ${import_chalk2.default.bold.red("ERRO
       const errorLocation = `${filePath}:${lineStr}:${columnStr}`;
       console.log(`${import_chalk2.default.cyan("[code]")} ${import_chalk2.default.yellow(errorLocation)}`);
       try {
-        const codeLines = import_fs3.default.readFileSync(filePath, "utf-8").split("\n");
+        const codeLines = import_fs4.default.readFileSync(filePath, "utf-8").split("\n");
         const start = Math.max(0, lineNum - 3);
         const end = Math.min(codeLines.length, lineNum + 2);
         for (let i = start; i < end; i++) {
@@ -1130,6 +1461,7 @@ var index_default = Schema;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CubeValidator,
+  DependencyResolver,
   Schema,
   UIUtils
 });