@hed-hog/cli 0.0.12

package/dist/src/modules/hedhog/services/migration.service.js

@@ -0,0 +1,767 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrationService = void 0;
+const common_1 = require("@nestjs/common");
+const chalk = require("chalk");
+const path_1 = require("path");
+const sql_formatter_1 = require("sql-formatter");
+const database_service_1 = require("../../database/database.service");
+const developer_service_1 = require("../../developer/developer.service");
+const file_system_service_1 = require("./file-system.service");
+const table_service_1 = require("./table.service");
+let MigrationService = class MigrationService {
+    database;
+    developer;
+    fileSystem;
+    tableService;
+    indexWithClauseLocale = 0;
+    touchUpdatedAtCreated = false;
+    verbose = false;
+    constructor(database, developer, fileSystem, tableService) {
+        this.database = database;
+        this.developer = developer;
+        this.fileSystem = fileSystem;
+        this.tableService = tableService;
+    }
+    log(message) {
+        if (this.verbose) {
+            console.info('\n', message);
+        }
+    }
+    getDefaultValue(column) {
+        if (column.type.toUpperCase() === 'TIMESTAMPTZ' &&
+            column.default === 'now()') {
+            return 'now()';
+        }
+        else if (column.name === 'order' && column.type.toUpperCase() === 'INT') {
+            return '0';
+        }
+        else {
+            return `'${column.default}'`;
+        }
+    }
+    getWhereString(where) {
+        if (!where || typeof where !== 'object' || !where.where)
+            return '';
+        const conditions = [];
+        for (const [key, value] of Object.entries(where.where)) {
+            if (typeof value === 'object' && value !== null) {
+                if ('in' in value && Array.isArray(value.in)) {
+                    conditions.push(`"${key}" IN (${value.in.map((v) => `'${v}'`).join(', ')})`);
+                }
+                else if ('notIn' in value && Array.isArray(value.notIn)) {
+                    conditions.push(`"${key}" NOT IN (${value.notIn.map((v) => `'${v}'`).join(', ')})`);
+                }
+                else if ('contains' in value) {
+                    conditions.push(`"${key}" LIKE '%${value.contains}%'`);
+                }
+                else if ('notContains' in value) {
+                    conditions.push(`"${key}" NOT LIKE '%${value.notContains}%'`);
+                }
+                else if ('not' in value) {
+                    conditions.push(`"${key}" <> '${value.not}'`);
+                }
+                else if ('like' in value) {
+                    conditions.push(`"${key}" LIKE '${value.like}'`);
+                }
+                else if ('notLike' in value) {
+                    conditions.push(`"${key}" NOT LIKE '${value.notLike}'`);
+                }
+                else if ('gt' in value) {
+                    conditions.push(`"${key}" > '${value.gt}'`);
+                }
+                else if ('gte' in value) {
+                    conditions.push(`"${key}" >= '${value.gte}'`);
+                }
+                else if ('lt' in value) {
+                    conditions.push(`"${key}" < '${value.lt}'`);
+                }
+                else if ('lte' in value) {
+                    conditions.push(`"${key}" <= '${value.lte}'`);
+                }
+                else if ('equals' in value) {
+                    conditions.push(`"${key}" = '${value.equals}'`);
+                }
+                else if ('notEquals' in value) {
+                    conditions.push(`"${key}" <> '${value.notEquals}'`);
+                }
+                else if ('isNull' in value) {
+                    conditions.push(`"${key}" IS NULL`);
+                }
+                else if ('isNotNull' in value) {
+                    conditions.push(`"${key}" IS NOT NULL`);
+                }
+                else {
+                    console.warn(chalk.yellow(`Unknown condition for key "${key}": ${JSON.stringify(value)}`));
+                }
+            }
+            else {
+                conditions.push(`"${key}" = '${value}'`);
+            }
+        }
+        return conditions.length ? `WHERE ${conditions.join(' AND ')}` : '';
+    }
+    processEnums(tables, dbType, migrationContent) {
+        for (const table of tables) {
+            this.log(`Processing enums for table: ${table.name}`);
+            for (const column of table.columns) {
+                if (dbType === 'postgres' &&
+                    column.type === 'enum' &&
+                    (column.enum || column.values)) {
+                    this.log(`Creating enum for column: ${column.name}`);
+                    const enumName = `${table.name}_${column.name}_enum`;
+                    migrationContent.push(`-- CreateEnum`, `CREATE TYPE "${enumName}" AS ENUM (${((column.enum || column.values) ?? []).map((value) => `'${value}'`).join(', ')});`, ``);
+                    column.type = enumName;
+                }
+            }
+        }
+    }
+    async createTableMigrations(tables, dbType, migrationContent, createdTables, cwd) {
+        if (!this.touchUpdatedAtCreated && tables.length > 0) {
+            // Verifica se já existe uma migration com a função touch_updated_at
+            let hasTouchUpdatedAt = false;
+            try {
+                const migrationsDir = (0, path_1.resolve)(cwd, './apps/api/prisma/migrations');
+                if (await this.fileSystem.exists(migrationsDir)) {
+                    const migrationFolders = await this.fileSystem.listFiles(migrationsDir, (f) => true);
+                    for (const folder of migrationFolders) {
+                        const folderPath = (0, path_1.join)(migrationsDir, folder);
+                        if (await this.fileSystem.exists(folderPath)) {
+                            const files = await this.fileSystem.listFiles(folderPath, (f) => f.endsWith('.sql'));
+                            for (const file of files) {
+                                const filePath = (0, path_1.join)(folderPath, file);
+                                const content = await this.fileSystem.readFileContent(filePath);
+                                if (/CREATE\s+FUNCTION\s+touch_updated_at\b/i.test(content)) {
+                                    hasTouchUpdatedAt = true;
+                                    break;
+                                }
+                            }
+                        }
+                        if (hasTouchUpdatedAt)
+                            break;
+                    }
+                }
+            }
+            catch (error) {
+                console.error(chalk.red(`Error checking for touch_updated_at function in migrations: ${error.message}`));
+            }
+            // Só adiciona se não existir ainda
+            if (!hasTouchUpdatedAt) {
+                try {
+                    const templatePath = (0, path_1.resolve)(__dirname, '../../../templates/database/touch_updated_at.sql.ejs');
+                    if (await this.fileSystem.exists(templatePath)) {
+                        const templateContent = await this.fileSystem.readFileContent(templatePath);
+                        migrationContent.push(`-- Function to auto-update updated_at timestamp`, templateContent);
+                        this.touchUpdatedAtCreated = true;
+                    }
+                    else {
+                        console.warn(chalk.yellow(`Template not found: ${templatePath}. Skipping touch_updated_at function.`));
+                    }
+                }
+                catch (error) {
+                    console.error(chalk.red(`Error loading touch_updated_at.sql.ejs template: ${error.message}`));
+                }
+            }
+        }
+        for (const table of tables) {
+            this.log(`Creating migration for table: ${table.name}`);
+            const columns = table.columns;
+            if (dbType === 'postgres') {
+                createdTables.push(table.name);
+                migrationContent.push(`-- CreateTable`, `CREATE TABLE "${table.name}" (`);
+                const columnsContent = [];
+                for (const column of columns) {
+                    this.log(`Adding column: ${column.name} (${column.type})`);
+                    let columnDefinition = `"${column.name}" `;
+                    switch (column.type.toLowerCase()) {
+                        case 'pk':
+                            columnDefinition += 'SERIAL';
+                            break;
+                        case 'fk':
+                            columnDefinition += 'INTEGER';
+                            break;
+                        case 'int':
+                            columnDefinition += 'INTEGER';
+                            break;
+                        case 'slug':
+                            columnDefinition += `VARCHAR(${column.length || 255})`;
+                            break;
+                        case 'order':
+                            columnDefinition += 'INTEGER';
+                            break;
+                        case 'enum':
+                            columnDefinition += `"${column.type}"`;
+                            break;
+                        case 'datetime':
+                        case 'created_at':
+                        case 'updated_at':
+                            columnDefinition += 'TIMESTAMPTZ';
+                            break;
+                        case 'locale_varchar':
+                            columnDefinition += `VARCHAR(${column.length || 255})`;
+                            break;
+                        case 'locale_text':
+                            columnDefinition += 'TEXT';
+                            break;
+                        case 'char':
+                            columnDefinition += `CHAR(${column.length || 1})`;
+                            break;
+                        case 'bytes':
+                            columnDefinition += 'BYTEA';
+                            break;
+                        default:
+                            const validPostgresTypes = [
+                                'smallint',
+                                'integer',
+                                'bigint',
+                                'decimal',
+                                'numeric',
+                                'real',
+                                'double precision',
+                                'serial',
+                                'bigserial',
+                                'money',
+                                'varchar',
+                                'char',
+                                'text',
+                                'bytea',
+                                'timestamp',
+                                'timestamp(6)',
+                                'timestamptz',
+                                'timestamptz(6)',
+                                'date',
+                                'time',
+                                'boolean',
+                                'json',
+                                'jsonb',
+                                'uuid',
+                                'inet',
+                                'cidr',
+                                'macaddr',
+                                'point',
+                                'line',
+                                'lseg',
+                                'box',
+                                'path',
+                                'polygon',
+                                'circle',
+                                'interval',
+                                'tsvector',
+                                'tsquery',
+                                'xml',
+                                'enum',
+                            ];
+                            if (!validPostgresTypes.includes(column.type.toLowerCase()) &&
+                                !column.type.endsWith('_enum')) {
+                                console.error(chalk.red(`Invalid Postgres type for column "${column.name}": ${column.type}`));
+                                throw new Error(`Invalid Postgres type for column "${column.name}": ${column.type}`);
+                            }
+                            columnDefinition += column.type.toUpperCase();
+                    }
+                    columnDefinition += column.isNullable ? ' NULL' : ' NOT NULL';
+                    if (column.default !== undefined) {
+                        columnDefinition += ` DEFAULT ${this.getDefaultValue(column)}`;
+                    }
+                    columnsContent.push(columnDefinition);
+                }
+                // Add primary key constraint(s)
+                for (const column of columns) {
+                    if (column.isPrimaryKey || column.type === 'pk') {
+                        this.log(`Adding primary key: ${column.name}`);
+                        columnsContent.push(`CONSTRAINT "${table.name}_pkey" PRIMARY KEY ("${column.name}")`);
+                    }
+                }
+                migrationContent.push(columnsContent.join(',\n'), ');', '');
+                if (table.columns.find((col) => col.name === 'updated_at' || col.type === 'updated_at')) {
+                    try {
+                        const trgTemplatePath = (0, path_1.resolve)(__dirname, '../../../templates/database/trg_touch_updated_at.sql.ejs');
+                        if (await this.fileSystem.exists(trgTemplatePath)) {
+                            let trgTemplateContent = await this.fileSystem.readFileContent(trgTemplatePath);
+                            // Simple variable replacement for <%= tableName %>
+                            trgTemplateContent = trgTemplateContent.replace(/<%=\s*tableName\s*%>/g, table.name);
+                            migrationContent.push(`-- Trigger to auto-update updated_at for table ${table.name}`, trgTemplateContent);
+                        }
+                        else {
+                            console.warn(chalk.yellow(`Template not found: ${trgTemplatePath}. Skipping trg_touch_updated_at trigger for ${table.name}.`));
+                        }
+                    }
+                    catch (error) {
+                        console.error(chalk.red(`Error loading trg_touch_updated_at.sql.ejs template: ${error.message}`));
+                    }
+                }
+            }
+            else if (dbType === 'mysql') {
+                console.warn('TO DO: MySQL table creation');
+            }
+        }
+    }
+    addUniqueConstraints(tables, dbType, migrationContent) {
+        for (const table of tables) {
+            if (dbType === 'postgres') {
+                this.log(`Creating unique constraints for table: ${table.name}`);
+                const uniqueColumns = table.columns.filter((c) => c.isUnique);
+                if (uniqueColumns.length) {
+                    migrationContent.push(`CREATE UNIQUE INDEX "${table.name}_${uniqueColumns.map((c) => c.name).join('_')}_unique" ON "${table.name}" (${uniqueColumns.map((c) => `"${c.name}"`).join(', ')});`, ``);
+                }
+                for (const column of table.columns) {
+                    if (column.type === 'slug') {
+                        this.log(`Adding unique constraint for column: ${column.name}`);
+                        migrationContent.push(`CREATE UNIQUE INDEX "${table.name}_${column.name}_unique" ON "${table.name}" ("${column.name}");`, ``);
+                    }
+                }
+            }
+            else if (dbType === 'mysql') {
+                console.warn('TO DO: MySQL unique constraints');
+            }
+        }
+    }
+    addForeignKeys(tables, dbType, migrationContent) {
+        for (const table of tables) {
+            this.log(`Processing foreign keys for table: ${table.name}`);
+            if (dbType === 'postgres') {
+                const foreignKeys = [];
+                for (const column of table.columns) {
+                    if (column.type === 'fk' && column.references) {
+                        const { table: fkTable, column: fkColumn, onDelete, onUpdate, } = column.references;
+                        this.log(`Adding foreign key for column: ${column.name} referencing ${fkTable}.${fkColumn}`);
+                        foreignKeys.push(`ALTER TABLE "${table.name}" ADD CONSTRAINT "${fkTable}_${column.name}_fkey" FOREIGN KEY ("${column.name}") REFERENCES "${fkTable}" ("${fkColumn}") ON DELETE ${onDelete || 'NO ACTION'} ON UPDATE ${onUpdate || 'NO ACTION'};`, ``);
+                    }
+                }
+                if (foreignKeys.length > 0) {
+                    migrationContent.push(...foreignKeys);
+                }
+            }
+            else if (dbType === 'mysql') {
+                console.warn('TO DO: MySQL foreign keys');
+            }
+        }
+    }
+    getColumnList(row, table) {
+        return Object.keys(row)
+            .filter((col) => table.columns.some((c) => c.name === col))
+            .map((col) => `"${col}"`);
+    }
+    async getValuesList(row, table, tables) {
+        const values = Object.keys(row).filter((col) => table.columns.some((c) => c.name === col));
+        const resolvedValues = [];
+        for (const col of values) {
+            if (typeof row[col] === 'object') {
+                if (row[col]['where']) {
+                    const tableNameRelation = table.columns.find((c) => c.name === col && c.type === 'fk')?.references?.table;
+                    const tableRelation = tables.find((t) => t.name === tableNameRelation);
+                    const whereClause = this.getWhereString(row[col]);
+                    row[col] =
+                        `(SELECT "${tableRelation?.pk}" FROM "${tableRelation?.name}" ${whereClause})`;
+                }
+                else {
+                    row[col] = `'${JSON.stringify(row[col])}'`;
+                }
+            }
+            else {
+                const columnDef = table.columns.find((c) => c.name === col);
+                if (columnDef?.isNullable && row[col] === null) {
+                    row[col] = 'NULL';
+                }
+                else if (!columnDef?.isNullable &&
+                    (row[col] === undefined || row[col] === null || row[col] === '')) {
+                    row[col] =
+                        columnDef?.default !== undefined
+                            ? this.getDefaultValue(columnDef)
+                            : 'NULL';
+                }
+                else {
+                    row[col] = `\$\$${String(row[col]).replace(/'/g, "''")}\$\$`;
+                }
+            }
+            resolvedValues.push(row[col]);
+        }
+        return resolvedValues;
+    }
+    async getInfoFromRow(row, tables, table) {
+        const columnsList = this.getColumnList(row, table).join(', ');
+        const valuesList = await this.getValuesList(row, table, tables);
+        const valuesString = valuesList.join(', ');
+        const hasRelations = 'relations' in row;
+        const localeColumns = [];
+        const localeValues = [];
+        const localeCodes = [];
+        let hasValueLocale = false;
+        for (const colName in row) {
+            if (this.checkIsObjectLocale(row[colName])) {
+                localeColumns.push(colName);
+                localeValues.push(row[colName]);
+                for (const code of Object.keys(row[colName])) {
+                    if (!localeCodes.includes(code)) {
+                        localeCodes.push(code);
+                    }
+                }
+                hasValueLocale = true;
+            }
+        }
+        return {
+            columnsList,
+            valuesList,
+            valuesString,
+            hasRelations,
+            localeColumns,
+            localeValues,
+            localeCodes,
+            hasValueLocale,
+        };
+    }
+    async processRelationsRecursive(relationRow, relationTable, parentTableName, parentAsName, tables, name, cwd, deps, insertTables, relationIndex) {
+        const withClauses = [];
+        const relatedTableDef = tables.find((t) => t.name === relationTable);
+        const tableIntermediate = await this.tableService.getTableIntermediate(parentTableName, relationTable, cwd);
+        const relationColumns = [
+            ...this.getColumnList(relationRow, relatedTableDef),
+        ];
+        let relationQuery = '';
+        const relationQuerys = [];
+        if (tableIntermediate?.intermediateTable) {
+            const tb = await this.tableService.getTableFromYaml(relationTable, cwd);
+            const { localeColumns, localeValues, localeCodes } = await this.getInfoFromRow(relationRow, tables, tb);
+            const tbPk = tb.columns.find((c) => c.isPrimaryKey || c.type === 'pk')?.name ||
+                'id';
+            const fkForMain = tableIntermediate.table.columns.find((c) => c.type === 'fk' && c.references.table === parentTableName)?.name;
+            const fkForRelation = tableIntermediate.table.columns.find((c) => c.type === 'fk' && c.references.table === relationTable)?.name;
+            relationColumns.unshift(`"${fkForMain}"`);
+            relationColumns.unshift(`"${fkForRelation}"`);
+            const whereClause = this.getWhereString(relationRow);
+            deps.push(relationTable);
+            insertTables.push(tableIntermediate.name);
+            const asName = `insert__${tableIntermediate.name}__for_${parentTableName}__and__${relationTable}__${relationIndex.value++}`;
+            relationQuery = `${asName} AS (\n    INSERT INTO "${tableIntermediate.name}" (${relationColumns.join(', ')}) SELECT (SELECT "${tbPk}" FROM "${relationTable}" ${whereClause} LIMIT 1), id FROM ${parentAsName} RETURNING id\n)`;
+            relationQuerys.push(...(await this.addWithClausesLocales(tb, tables, localeCodes, localeColumns, localeValues, asName)));
+            withClauses.push(relationQuery, ...relationQuerys);
+            // Process nested relations recursively
+            if (relationRow.relations && typeof relationRow.relations === 'object') {
+                for (const [nestedRelationTable, nestedRelationRows] of Object.entries(relationRow.relations)) {
+                    if (Array.isArray(nestedRelationRows) &&
+                        nestedRelationRows.length > 0) {
+                        for (const nestedRelationRow of nestedRelationRows) {
+                            const nestedClauses = await this.processRelationsRecursive(nestedRelationRow, nestedRelationTable, relationTable, asName, tables, name, cwd, deps, insertTables, relationIndex);
+                            withClauses.push(...nestedClauses);
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            const fkForMain = tableIntermediate?.table.columns.find((c) => c.type === 'fk' && c.references.table === parentTableName)?.name;
+            relationColumns.unshift(`"${fkForMain}"`);
+            const relationValuesList = await this.getValuesList(relationRow, relatedTableDef, tables);
+            relationValuesList.unshift(`(SELECT id FROM ${parentAsName})`);
+            insertTables.push(relationTable);
+            const asName = `insert__${relationTable}__for__${parentTableName}__${relationIndex.value++}`;
+            relationQuery = `${asName} AS (\n    INSERT INTO "${relationTable}" (${relationColumns.join(', ')}) VALUES (${relationValuesList.join(', ')}) RETURNING id\n)`;
+            const tb = tables.find((t) => t.name === relationTable);
+            if (tb) {
+                const { localeColumns, localeValues, localeCodes } = await this.getInfoFromRow(relationRow, tables, tb);
+                relationQuerys.push(...(await this.addWithClausesLocales(tb, tables, localeCodes, localeColumns, localeValues, asName)));
+            }
+            withClauses.push(relationQuery, ...relationQuerys);
+            // Process nested relations recursively
+            if (relationRow.relations && typeof relationRow.relations === 'object') {
+                for (const [nestedRelationTable, nestedRelationRows] of Object.entries(relationRow.relations)) {
+                    if (Array.isArray(nestedRelationRows) &&
+                        nestedRelationRows.length > 0) {
+                        for (const nestedRelationRow of nestedRelationRows) {
+                            const nestedClauses = await this.processRelationsRecursive(nestedRelationRow, nestedRelationTable, relationTable, asName, tables, name, cwd, deps, insertTables, relationIndex);
+                            withClauses.push(...nestedClauses);
+                        }
+                    }
+                }
+            }
+        }
+        return withClauses;
+    }
+    async getInsertQueries(table, data, tables, name, cwd) {
+        const queries = [];
+        for (const row of data) {
+            const { columnsList, valuesList, valuesString, hasRelations, localeColumns, localeValues, localeCodes, hasValueLocale, } = await this.getInfoFromRow(row, tables, table);
+            // Extract dependencies from valuesList (queries that include sub-selects)
+            const deps = Array.from(new Set(valuesList
+                .filter((v) => /\bselect\b.*\bfrom\b/i.test(v))
+                .map((v) => {
+                const match = v.match(/\bselect\b.*\bfrom\s+([\w.]+)/i);
+                return match ? match[1] : v;
+            })));
+            const insertTables = [table.name];
+            const mainInsert = `INSERT INTO "${table.name}" (${columnsList}) VALUES (${valuesString})`;
+            let query = '';
+            const withClauses = [];
+            if (hasRelations || hasValueLocale) {
+                // Main insert with RETURNING clause
+                withClauses.push(`inserted AS (\n    ${mainInsert}\n    RETURNING id\n)`);
+                if (hasRelations) {
+                    // Process relation queries recursively
+                    const relationIndex = { value: 0 };
+                    const relations = row.relations || {};
+                    for (const [relationTable, relationRows] of Object.entries(relations)) {
+                        if (Array.isArray(relationRows) && relationRows.length > 0) {
+                            for (const relationRow of relationRows) {
+                                const relationClauses = await this.processRelationsRecursive(relationRow, relationTable, table.name, 'inserted', tables, name, cwd, deps, insertTables, relationIndex);
+                                withClauses.push(...relationClauses);
+                            }
+                        }
+                    }
+                }
+                ////////////////////////////////////////////////////////////////////
+                if (hasValueLocale) {
+                    withClauses.push(...(await this.addWithClausesLocales(table, tables, localeCodes, localeColumns, localeValues)));
+                }
+                query = `WITH ${withClauses.join(',\n')}\nSELECT * FROM inserted;`;
+            }
+            else {
+                query = mainInsert + ';';
+            }
+            queries.push({
+                query: query + '\n\n',
+                dependencies: Array.from(new Set(deps.filter((d) => insertTables.includes(d)))),
+                insertTables: Array.from(new Set(insertTables)),
+            });
+            this.log(`Prepared insert query for table: ${table.name}`);
+        }
+        return queries;
+    }
+    async addWithClausesLocales(table, tables, localeCodes, localeColumns, localeValues, insertedTableName = 'inserted') {
+        const tableLocale = tables.find((t) => t.name === `${table.name}_locale`);
+        const withClauses = [];
+        if (tableLocale) {
+            const fkColumnName = tableLocale?.columns.find((c) => c.type === 'fk' && c.references?.table === table.name)?.name;
+            const fkLocaleColumnName = tableLocale?.columns.find((c) => c.type === 'fk' && c.references?.table === 'locale')?.name;
+            for (const code of localeCodes) {
+                withClauses.push(`insert__${tableLocale.name}__${code}__${this.indexWithClauseLocale++} AS (\n
+                INSERT INTO "${table.name}_locale" (${fkLocaleColumnName}, ${fkColumnName}, ${localeColumns.map((c) => `"${c}"`).join(', ')})
+                VALUES (
+                  (SELECT "id" FROM "locale" WHERE "code" = '${code}'),
+                  (SELECT id FROM ${insertedTableName}),
+                  ${localeColumns.map((c) => `\$\$${localeValues[localeColumns.indexOf(c)][code].replaceAll("'", "''")}\$\$`).join(', ')})\n
+                RETURNING id\n
+              )`);
+            }
+        }
+        return withClauses;
+    }
+    checkIsObjectLocale(value) {
+        const validLocales = ['pt', 'en', 'es', 'it', 'jp'];
+        return (typeof value === 'object' &&
+            value !== null &&
+            !Array.isArray(value) &&
+            Object.keys(value).length > 0 &&
+            Object.keys(value).every((key) => typeof key === 'string' &&
+                /^[a-z]{2,3}$/.test(key) &&
+                validLocales.includes(key) &&
+                (typeof value[key] === 'string' || typeof value[key] === 'number')));
+    }
+    async getDataFromTable(table, name, cwd) {
+        const dataPath = (0, path_1.resolve)(cwd, `./libraries/${name}/hedhog/data`);
+        const fileNames = [`${table.name}.yaml`, `${table.name}.yml`];
+        let dataFilePath = null;
+        for (const fileName of fileNames) {
+            const fullPath = (0, path_1.join)(dataPath, fileName);
+            if (await this.fileSystem.exists(fullPath)) {
+                dataFilePath = fullPath;
+                break;
+            }
+        }
+        if (dataFilePath) {
+            this.log(`Loading initial data for table: ${table.name}`);
+            return await this.fileSystem.readYamlFile(dataFilePath);
+        }
+        return [];
+    }
+    async afterQueries(name, cwd, migrationContent) {
+        this.log(`Running after queries for ${name}...`);
+        const queriesPath = (0, path_1.resolve)(cwd, `./libraries/${name}/hedhog/query`);
+        try {
+            if (await this.fileSystem.exists(queriesPath)) {
+                const allFiles = await this.fileSystem.listFiles(queriesPath, () => true);
+                for (const file of allFiles) {
+                    if (file.endsWith('.sql')) {
+                        const sqlContent = await this.fileSystem.readFileContent((0, path_1.join)(queriesPath, file));
+                        migrationContent.push(`-- AfterQuery: ${file}`, sqlContent, '');
+                    }
+                    else {
+                        console.warn(chalk.yellow(`Arquivo ignorado no diretório de queries: ${file}`));
+                    }
+                }
+            }
+            else {
+                this.log(`No queries directory found at ${queriesPath}`);
+            }
+        }
+        catch (error) {
+            this.log(`Error processing after queries: ${error.message}`);
+            // Opcional: podrías relanzar el error si quieres que el flujo principal lo maneje
+            // throw error;
+        }
+    }
+    async insertInitialData(tables, name, cwd, migrationContent) {
+        const queries = [];
+        for (const table of tables) {
+            this.log(`Processing initial data for table: ${table.name}`);
+            const data = await this.getDataFromTable(table, name, cwd);
+            if (Array.isArray(data) && data.length > 0) {
+                // Sort rows so that rows with relation queries come last
+                const sortedData = [
+                    ...data.filter((row) => !Object.values(row).some((v) => typeof v === 'object' && v !== null && 'where' in v)),
+                    ...data.filter((row) => Object.values(row).some((v) => typeof v === 'object' && v !== null && 'where' in v)),
+                ];
+                queries.push(...(await this.getInsertQueries(table, sortedData, tables, name, cwd)));
+            }
+            else {
+                this.log(`Data for table ${table.name} is not an array. Skipping insertion.`);
+            }
+        }
+        if (queries.length) {
+            migrationContent.push(`-- InsertInitialData`);
+        }
+        // Order queries by dependencies
+        const orderedQueries = this.orderQueriesByDependencies(queries);
+        migrationContent.push(...orderedQueries.map((q) => q.query));
+    }
+    orderQueriesByDependencies(queries) {
+        const orderedQueries = [];
+        const remainingQueries = [...queries];
+        const insertedTables = new Set();
+        while (remainingQueries.length) {
+            const notReady = remainingQueries.filter((q) => !q.dependencies.every((dep) => insertedTables.has(dep)));
+            const ready = remainingQueries.filter((q) => q.dependencies.every((dep) => insertedTables.has(dep)));
+            let candidate;
+            if (notReady.length) {
+                notReady.sort((a, b) => {
+                    const diffDeps = a.dependencies.length - b.dependencies.length;
+                    if (diffDeps !== 0)
+                        return diffDeps;
+                    return (a.insertTables?.length || 0) - (b.insertTables?.length || 0);
+                });
+                candidate = notReady[0];
+            }
+            else if (ready.length) {
+                ready.sort((a, b) => {
+                    const diffDeps = a.dependencies.length - b.dependencies.length;
+                    if (diffDeps !== 0)
+                        return diffDeps;
+                    return (a.insertTables?.length || 0) - (b.insertTables?.length || 0);
+                });
+                candidate = ready[0];
+            }
+            if (candidate) {
+                orderedQueries.push(candidate);
+                candidate.insertTables?.forEach((table) => insertedTables.add(table));
+                const index = remainingQueries.indexOf(candidate);
+                if (index !== -1)
+                    remainingQueries.splice(index, 1);
+            }
+            else {
+                console.warn('Could not order all queries; remaining will be added at the end.');
+                orderedQueries.push(...remainingQueries);
+                break;
+            }
+        }
+        return orderedQueries;
+    }
+    toSnackCase(str) {
+        return str
+            .split(/[-_ ]/)
+            .map((word) => word.toLowerCase())
+            .join('_');
+    }
+    async createMigrations(name, cwd = process.cwd(), verbose = false) {
+        this.verbose = verbose;
+        const allTables = [];
+        const tables = await this.tableService.loadTablesFromYaml(name, cwd, verbose);
+        const tablesDep = await this.tableService.getTablesFromDependencies(name, cwd);
+        allTables.push(...tablesDep.filter((t) => !tables.find((tbl) => tbl.name === t.name)));
+        const uniqueTablesMap = new Map();
+        [...allTables, ...tables].forEach((table) => {
+            if (!uniqueTablesMap.has(table.name)) {
+                uniqueTablesMap.set(table.name, table);
+            }
+        });
+        allTables.length = 0;
+        allTables.push(...uniqueTablesMap.values());
+        if (!tables || tables.length === 0) {
+            this.log(`No tables found for ${name}. Skipping migration creation.`);
+            return;
+        }
+        this.log(`Creating migrations for ${name}...`);
+        const dbType = await this.database.getDatabaseType(cwd);
+        if (!dbType) {
+            throw new Error('Database type could not be determined');
+        }
+        const migrationContent = [];
+        const createdTables = [];
+        this.log(`Database type detected: ${dbType}`);
+        this.log(`Processing enums for ${name}...`);
+        this.processEnums(tables, dbType, migrationContent);
+        this.log(`Processed enums for ${name}!`);
+        this.log(`Creating tables for ${name}...`);
+        await this.createTableMigrations(tables, dbType, migrationContent, createdTables, cwd);
+        this.log(`Created tables for ${name}!`);
+        this.log(`Adding unique constraints for ${name}...`);
+        this.addUniqueConstraints(tables, dbType, migrationContent);
+        this.log(`Added unique constraints for ${name}!`);
+        this.log(`Adding foreign keys for ${name}...`);
+        this.addForeignKeys(tables, dbType, migrationContent);
+        this.log(`Added foreign keys for ${name}!`);
+        this.log(`Inserting initial data for ${name}...`);
+        await this.insertInitialData(!allTables.length && tables.length ? tables : allTables, name, cwd, migrationContent);
+        this.log(`Inserted initial data for ${name}!`);
+        this.log(`Running after querys for ${name}...`);
+        await this.afterQueries(name, cwd, migrationContent);
+        this.log(`Completed after querys for ${name}!`);
+        // Save migration file
+        const timestamp = new Date()
+            .toISOString()
+            .replace(/[-:.T]/g, '')
+            .slice(0, 14);
+        const migrationFileName = `${timestamp}_${this.toSnackCase(name)}`;
+        this.log(`Creating migration file: ${migrationFileName}`);
+        const migrationFilePath = (0, path_1.resolve)(cwd, `./apps/api/prisma/migrations/${migrationFileName}`);
+        this.log(`Creating migration directory at: ${migrationFilePath}`);
+        await this.fileSystem.createDirectory(migrationFilePath);
+        const contentSQL = migrationContent.join('\n') + '\n';
+        const formattedSQL = (0, sql_formatter_1.format)(contentSQL, {
+            language: 'postgresql',
+            newlineBeforeSemicolon: false,
+        });
+        await this.fileSystem.writeFileContent((0, path_1.resolve)(migrationFilePath, 'migration.sql'), formattedSQL);
+        // Update hedhog file
+        const hedhogFilePath = (0, path_1.join)(cwd, 'hedhog.json');
+        let hedhogFile = {};
+        if (await this.fileSystem.exists(hedhogFilePath)) {
+            hedhogFile = await this.fileSystem.readJsonFile(hedhogFilePath);
+        }
+        if (!hedhogFile.libraries) {
+            hedhogFile.libraries = {};
+        }
+        const hashLib = await this.developer.hashDirectory((0, path_1.resolve)(cwd, `./libraries/${name}`));
+        hedhogFile.libraries[name] = {
+            hash: hashLib,
+            migration: migrationFileName,
+        };
+        await this.fileSystem.writeJsonFile(hedhogFilePath, hedhogFile);
+        this.log(`Migration file ${migrationFileName} created successfully.`);
+    }
+};
+exports.MigrationService = MigrationService;
+exports.MigrationService = MigrationService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [database_service_1.DatabaseService,
+        developer_service_1.DeveloperService,
+        file_system_service_1.FileSystemService,
+        table_service_1.TableService])
+], MigrationService);
+//# sourceMappingURL=migration.service.js.map