@an5/orm 1.0.0

package/dist/pull.js

@@ -0,0 +1,336 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("dotenv/config");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const an5_adapters_1 = require("an5-adapters");
+const rootDir = path_1.default.join(__dirname, "../");
+let config = {};
+try {
+    const configPath = path_1.default.join(rootDir, "an5Orm.config.js");
+    if (fs_1.default.existsSync(configPath)) {
+        config = require(configPath);
+    }
+}
+catch (err) {
+    console.warn("⚠️ Could not load config file in pull.ts, using defaults.");
+}
+const schemaDir = path_1.default.resolve(rootDir, config.schemaDir || "an5Schema");
+let _adapter = null;
+async function getDb() {
+    if (!_adapter) {
+        _adapter = new an5_adapters_1.An5Adapter({ connectionString: process.env.DATABASE_URL });
+        await _adapter.$connect();
+    }
+    return _adapter;
+}
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+async function pull() {
+    console.log("🔍 Pulling schema from database...");
+    const tables = await (await getDb()).$queryRawUnsafe(`
+    SELECT s.name AS schemaName, t.name AS tableName
+    FROM sys.tables t
+    JOIN sys.schemas s ON t.schema_id = s.schema_id
+    WHERE t.is_ms_shipped = 0
+    ORDER BY t.name
+  `);
+    // Load existing schema files
+    const fileContents = {};
+    const modelToFileMap = {}; // modelName -> fileName
+    const tableToFileMap = {}; // tableName -> fileName
+    if (fs_1.default.existsSync(schemaDir)) {
+        const files = fs_1.default.readdirSync(schemaDir).filter(f => f.endsWith(".an5"));
+        for (const file of files) {
+            const fullPath = path_1.default.join(schemaDir, file);
+            const text = fs_1.default.readFileSync(fullPath, "utf8");
+            fileContents[file] = text;
+            // Extract model definitions and table mappings from existing file contents
+            const modelRegex = /model\s+(\w+)\s*\{([^}]*)\}/g;
+            let match;
+            while ((match = modelRegex.exec(text)) !== null) {
+                const modelName = match[1];
+                const block = match[2];
+                modelToFileMap[modelName] = file;
+                // Try to find @@map
+                const mapMatch = block.match(/@@map\("(.+)"\)/);
+                if (mapMatch) {
+                    const tableName = mapMatch[1];
+                    tableToFileMap[tableName] = file;
+                }
+                else {
+                    // Default pluralization mapping
+                    const defaultTableName = modelName.toLowerCase() + "s";
+                    tableToFileMap[defaultTableName] = file;
+                }
+            }
+        }
+    }
+    else {
+        fs_1.default.mkdirSync(schemaDir, { recursive: true });
+    }
+    // Ensure default core.an5 exists in fileContents
+    const defaultFile = "core.an5";
+    if (!fileContents[defaultFile]) {
+        fileContents[defaultFile] = "";
+    }
+    const existingModelNames = new Set(Object.keys(modelToFileMap));
+    const generatedModels = {};
+    for (const table of tables) {
+        const { tableName } = table;
+        console.log(`Introspecting table [${tableName}]...`);
+        // Get columns
+        const columns = await (await getDb()).$queryRawUnsafe(`
+      SELECT 
+          c.name AS columnName,
+          ty.name AS dataType,
+          c.max_length AS maxLength,
+          c.precision AS precision,
+          c.scale AS scale,
+          c.is_nullable AS isNullable,
+          c.is_identity AS isIdentity,
+          pk.is_primary_key AS isPrimaryKey,
+          d.definition AS defaultValue
+      FROM sys.columns c
+      JOIN sys.types ty ON c.user_type_id = ty.user_type_id
+      LEFT JOIN (
+          SELECT ic.object_id, ic.column_id, i.is_primary_key
+          FROM sys.index_columns ic
+          JOIN sys.indexes i ON ic.object_id = i.object_id AND ic.index_id = i.index_id
+          WHERE i.is_primary_key = 1
+      ) pk ON c.object_id = pk.object_id AND c.column_id = pk.column_id
+      LEFT JOIN sys.default_constraints d ON c.default_object_id = d.object_id
+      WHERE c.object_id = OBJECT_ID(@p_0)
+      ORDER BY c.column_id
+    `, tableName);
+        // Get indexes
+        const indexes = await (await getDb()).$queryRawUnsafe(`
+      SELECT 
+          i.name AS indexName,
+          i.is_unique AS isUnique,
+          i.is_primary_key AS isPrimaryKey,
+          c.name AS columnName,
+          ic.key_ordinal AS keyOrdinal
+      FROM sys.indexes i
+      JOIN sys.index_columns ic ON i.object_id = ic.object_id AND i.index_id = ic.index_id
+      JOIN sys.columns c ON ic.object_id = c.object_id AND ic.column_id = c.column_id
+      WHERE i.object_id = OBJECT_ID(@p_0) AND i.is_hypothetical = 0 AND i.name IS NOT NULL
+      ORDER BY i.name, ic.key_ordinal
+    `, tableName);
+        const indexGroups = {};
+        for (const idx of indexes) {
+            if (!indexGroups[idx.indexName]) {
+                indexGroups[idx.indexName] = {
+                    isUnique: idx.isUnique === 1 || idx.isUnique === true,
+                    isPrimaryKey: idx.isPrimaryKey === 1 || idx.isPrimaryKey === true,
+                    columns: []
+                };
+            }
+            indexGroups[idx.indexName].columns.push(idx.columnName);
+        }
+        const uniqueColumns = new Set();
+        const compoundUniques = [];
+        const modelIndexes = [];
+        for (const [name, info] of Object.entries(indexGroups)) {
+            if (info.isPrimaryKey)
+                continue;
+            if (info.isUnique) {
+                if (info.columns.length === 1) {
+                    uniqueColumns.add(info.columns[0]);
+                }
+                else {
+                    compoundUniques.push(info.columns);
+                }
+            }
+            else {
+                modelIndexes.push(info.columns);
+            }
+        }
+        let modelName = "";
+        for (const [mName, file] of Object.entries(modelToFileMap)) {
+            const text = fileContents[file];
+            const modelRegex = new RegExp(`model\\s+(${mName})\\s*\\{[^}]*\\}`, 'g');
+            let m;
+            while ((m = modelRegex.exec(text)) !== null) {
+                const block = m[0];
+                const mapMatch = block.match(/@@map\("(.+)"\)/);
+                if (mapMatch && mapMatch[1] === tableName) {
+                    modelName = mName;
+                    break;
+                }
+            }
+            if (modelName)
+                break;
+        }
+        if (!modelName) {
+            modelName = tableName.charAt(0).toUpperCase() + tableName.slice(1).replace(/s$/, "");
+        }
+        // Parse existing model fields from file for merging
+        const existingFields = {};
+        const targetFile = modelToFileMap[modelName] || defaultFile;
+        const fileContent = fileContents[targetFile];
+        if (fileContent) {
+            const modelRegex = new RegExp(`model\\s+${modelName}\\s*\\{([^}]*)\\}`, 'g');
+            const match = modelRegex.exec(fileContent);
+            if (match) {
+                const block = match[1];
+                const lines = block.split("\n");
+                for (let line of lines) {
+                    line = line.trim();
+                    if (!line || line.startsWith("@@") || line.startsWith("model ") || line === "}")
+                        continue;
+                    const parts = line.split(/\s+/);
+                    const name = parts[0];
+                    const type = parts[1];
+                    if (!name || !type)
+                        continue;
+                    const cleanType = type.replace("[]", "").replace("?", "");
+                    const isRelation = existingModelNames.has(cleanType) || type.endsWith("[]");
+                    existingFields[name.toLowerCase()] = {
+                        line,
+                        isRelation,
+                        name
+                    };
+                }
+            }
+        }
+        let modelStr = `model ${modelName} {\n`;
+        for (const col of columns) {
+            const { columnName, dataType, isNullable, isPrimaryKey, isIdentity, defaultValue } = col;
+            // Generate SQL Server type directly
+            let sqlType = dataType.toUpperCase();
+            const dt = dataType.toLowerCase();
+            // Add length/precision params
+            if (dt === "nvarchar" || dt === "varchar") {
+                sqlType = col.maxLength === -1 ? `${sqlType.toUpperCase()}(MAX)` : `${sqlType.toUpperCase()}(${col.maxLength / 2})`;
+            }
+            else if (dt === "char" || dt === "nchar") {
+                sqlType = `${sqlType.toUpperCase()}(${col.maxLength / 2})`;
+            }
+            else if (dt === "varbinary" || dt === "binary") {
+                sqlType = col.maxLength === -1 ? `${sqlType.toUpperCase()}(MAX)` : `${sqlType.toUpperCase()}(${col.maxLength})`;
+            }
+            else if (dt === "decimal" || dt === "numeric") {
+                sqlType = `${sqlType.toUpperCase()}(${col.precision}, ${col.scale})`;
+            }
+            const optional = isNullable ? "?" : "";
+            let attributes = "";
+            if (isPrimaryKey)
+                attributes += " @id";
+            if (isIdentity)
+                attributes += " @default(autoincrement())";
+            if (uniqueColumns.has(columnName) && !isPrimaryKey)
+                attributes += " @unique";
+            if (defaultValue) {
+                if (defaultValue.includes("newid()")) {
+                    attributes += " @default(uuid())";
+                }
+                else if (defaultValue.includes("getdate()") || defaultValue.includes("sysdatetime()")) {
+                    attributes += " @default(now())";
+                }
+                else {
+                    const cleaned = defaultValue.replace(/^\(+(.*?)\)+$/, '$1');
+                    if (dt === "bit") {
+                        if (cleaned === "1" || cleaned.toLowerCase() === "true")
+                            attributes += " @default(true)";
+                        else if (cleaned === "0" || cleaned.toLowerCase() === "false")
+                            attributes += " @default(false)";
+                    }
+                    else if (dt === "int" || dt === "float" || dt === "bigint" || dt === "decimal" || dt === "numeric") {
+                        if (!isNaN(Number(cleaned)))
+                            attributes += ` @default(${cleaned})`;
+                    }
+                    else if (dt === "nvarchar" || dt === "varchar") {
+                        if (cleaned.startsWith("'") && cleaned.endsWith("'")) {
+                            const val = cleaned.slice(1, -1).replace(/"/g, '\\"');
+                            attributes += ` @default("${val}")`;
+                        }
+                    }
+                }
+            }
+            let fieldLine = `${columnName} ${sqlType}${optional}${attributes}`;
+            // Merge decorators/attributes from existing schema
+            const existing = existingFields[columnName.toLowerCase()];
+            if (existing) {
+                const attributesMatch = existing.line.match(/(@default\(.*?\)|@updatedAt)/g);
+                if (attributesMatch) {
+                    for (const attr of attributesMatch) {
+                        if (!fieldLine.includes(attr)) {
+                            if (attr.startsWith("@default") && fieldLine.includes("@default")) {
+                                continue;
+                            }
+                            fieldLine += ` ${attr}`;
+                        }
+                    }
+                }
+            }
+            modelStr += `  ${fieldLine}\n`;
+        }
+        // Append preserved relations
+        for (const [lowerName, fieldInfo] of Object.entries(existingFields)) {
+            if (fieldInfo.isRelation) {
+                modelStr += `  ${fieldInfo.line}\n`;
+            }
+        }
+        const uniqueStrings = new Set();
+        for (const cols of compoundUniques) {
+            uniqueStrings.add(`@@unique([${cols.join(", ")}])`);
+        }
+        for (const key of uniqueStrings) {
+            modelStr += `  ${key}\n`;
+        }
+        const indexStrings = new Set();
+        for (const cols of modelIndexes) {
+            indexStrings.add(`@@index([${cols.join(", ")}])`);
+        }
+        for (const key of indexStrings) {
+            modelStr += `  ${key}\n`;
+        }
+        if (tableName !== modelName.toLowerCase() + "s") {
+            modelStr += `\n  @@map("${tableName}")\n`;
+        }
+        modelStr += "}";
+        generatedModels[modelName] = modelStr;
+    }
+    for (const [modelName, modelStr] of Object.entries(generatedModels)) {
+        const targetFile = modelToFileMap[modelName] || defaultFile;
+        const fileContent = fileContents[targetFile];
+        const modelRegex = new RegExp(`model\\s+${modelName}\\s*\\{[^}]*\\}`, 'g');
+        if (modelRegex.test(fileContent)) {
+            fileContents[targetFile] = fileContent.replace(modelRegex, modelStr);
+            console.log(`✏️ Updated model [${modelName}] in file [${targetFile}]`);
+        }
+        else {
+            fileContents[targetFile] = fileContent.trim() + "\n\n" + modelStr + "\n";
+            console.log(`➕ Added model [${modelName}] to file [${targetFile}]`);
+        }
+    }
+    for (const [file, content] of Object.entries(fileContents)) {
+        const fullPath = path_1.default.join(schemaDir, file);
+        fs_1.default.writeFileSync(fullPath, content.trim() + "\n");
+        console.log(`💾 Saved updates to [${fullPath}]`);
+    }
+    // Index schema into vector store for RAG
+    console.log("\n📚 Indexing schema into vector store for RAG...");
+    try {
+        const { indexSchema, indexQuerySamples } = require(path_1.default.join(rootDir, "an5Agent", "dist", "rag", "indexer.js"));
+        await indexSchema(schemaDir);
+        await indexQuerySamples();
+        console.log("✅ Schema indexed for RAG.");
+    }
+    catch (err) {
+        console.warn(`⚠️ RAG indexing skipped: ${err.message || err}`);
+        console.warn(`   Run 'npm --prefix an5Agent run rag:index' manually to build vector store.`);
+    }
+    console.log("✅ Database schema pulling completed successfully.");
+    process.exit(0);
+}
+pull().catch((err) => {
+    console.error("❌ Pull failed:", err);
+    process.exit(1);
+});
+//# sourceMappingURL=pull.js.map

package/dist/push.d.ts

@@ -0,0 +1,2 @@
+import "dotenv/config";
+//# sourceMappingURL=push.d.ts.map

package/dist/push.js

@@ -0,0 +1,258 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("dotenv/config");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const an5_adapters_1 = require("an5-adapters");
+const rootDir = path_1.default.join(__dirname, "../");
+let config = {};
+try {
+    const configPath = path_1.default.join(rootDir, "an5Orm.config.js");
+    if (fs_1.default.existsSync(configPath)) {
+        config = require(configPath);
+    }
+}
+catch (err) {
+    console.warn("⚠️ Could not load config file in push.ts, using defaults.");
+}
+const schemaDir = path_1.default.resolve(rootDir, config.schemaDir || "an5Schema");
+let _adapter = null;
+async function getDb() {
+    if (!_adapter) {
+        _adapter = new an5_adapters_1.An5Adapter({ connectionString: process.env.DATABASE_URL });
+        await _adapter.$connect();
+    }
+    return _adapter;
+}
+// Supported SQL Server types (base types without params)
+const AN5_TYPES = new Set([
+    "NVARCHAR", "VARCHAR", "CHAR", "NCHAR", "TEXT", "NTEXT", "XML",
+    "INT", "SMALLINT", "TINYINT", "BIGINT", "FLOAT", "REAL", "DECIMAL", "NUMERIC",
+    "MONEY", "SMALLMONEY", "BIT",
+    "DATETIME", "DATETIME2", "SMALLDATETIME", "DATE", "TIME", "DATETIMEOFFSET",
+    "VARBINARY", "BINARY", "IMAGE",
+    "UNIQUEIDENTIFIER", "SQL_VARIANT", "ROWVERSION",
+    "HIERARCHYID", "GEOGRAPHY", "GEOMETRY", "VECTOR",
+]);
+// Parse base type from "NVARCHAR(255)" → "NVARCHAR"
+function parseSqlType(raw) {
+    const match = raw.match(/^(\w+)/);
+    return match ? match[1].toUpperCase() : raw.toUpperCase();
+}
+async function push() {
+    let schemaText = "";
+    if (fs_1.default.existsSync(schemaDir)) {
+        const files = fs_1.default.readdirSync(schemaDir).filter(f => f.endsWith(".an5"));
+        for (const file of files) {
+            schemaText += fs_1.default.readFileSync(path_1.default.join(schemaDir, file), "utf8") + "\n";
+        }
+    }
+    else {
+        const schemaPath = path_1.default.join(__dirname, "schema.an5");
+        if (fs_1.default.existsSync(schemaPath)) {
+            schemaText = fs_1.default.readFileSync(schemaPath, "utf8");
+        }
+        else {
+            console.error(`No schema found in ${schemaDir} or schema.an5`);
+            process.exit(1);
+        }
+    }
+    const lines = schemaText.split("\n");
+    const models = [];
+    let currentModel = null;
+    for (let line of lines) {
+        line = line.trim();
+        if (!line || line.startsWith("//"))
+            continue;
+        const modelHeaderMatch = line.match(/^model\s+(\w+)\s*\{/);
+        if (modelHeaderMatch) {
+            currentModel = {
+                name: modelHeaderMatch[1],
+                tableName: modelHeaderMatch[1].toLowerCase() + "s",
+                fields: [],
+                compoundUniques: [],
+                indexes: [],
+            };
+            models.push(currentModel);
+            continue;
+        }
+        if (line === "}") {
+            currentModel = null;
+            continue;
+        }
+        if (currentModel) {
+            if (line.startsWith("@@map")) {
+                const mapMatch = line.match(/@@map\("(.+)"\)/);
+                if (mapMatch)
+                    currentModel.tableName = mapMatch[1];
+                continue;
+            }
+            if (line.startsWith("@@unique")) {
+                const uniqueMatch = line.match(/@@unique\(\[([\w,\s]+)\]\)/);
+                if (uniqueMatch) {
+                    const fields = uniqueMatch[1].split(",").map(f => f.trim());
+                    currentModel.compoundUniques.push(fields);
+                }
+                continue;
+            }
+            if (line.startsWith("@@index")) {
+                const indexMatch = line.match(/@@index\(\[([\w,\s]+)\]\)/);
+                if (indexMatch) {
+                    const fields = indexMatch[1].split(",").map(f => f.trim());
+                    currentModel.indexes.push(fields);
+                }
+                continue;
+            }
+            if (line.startsWith("@@"))
+                continue;
+            const parts = line.split(/\s+/);
+            const fieldName = parts[0];
+            const fieldType = parts[1];
+            if (!fieldName || !fieldType)
+                continue;
+            // Parse SQL Server type directly
+            const cleanType = fieldType.replace("[]", "").replace("?", "");
+            const sqlBase = parseSqlType(cleanType);
+            // Skip if not a known SQL Server type (might be a relation)
+            if (!AN5_TYPES.has(sqlBase)) {
+                continue;
+            }
+            const isOptional = fieldType.endsWith("?");
+            const isId = line.includes("@id");
+            const isUnique = line.includes("@unique");
+            // Use SQL Server type directly - no mapping needed
+            const sqlType = cleanType.toUpperCase();
+            let defaultValue = "";
+            const defaultMatch = line.match(/@default\((.*)\)/);
+            if (defaultMatch) {
+                const val = defaultMatch[1];
+                if (val === "uuid()")
+                    defaultValue = "DEFAULT NEWID()";
+                else if (val === "cuid()")
+                    defaultValue = "DEFAULT NEWID()";
+                else if (val === "now()")
+                    defaultValue = "DEFAULT CURRENT_TIMESTAMP";
+                else if (val === "autoincrement()")
+                    defaultValue = "IDENTITY(1,1)";
+                else if (val === "true")
+                    defaultValue = "DEFAULT 1";
+                else if (val === "false")
+                    defaultValue = "DEFAULT 0";
+                else if (/^".*"$/.test(val))
+                    defaultValue = `DEFAULT '${val.slice(1, -1)}'`;
+                else
+                    defaultValue = `DEFAULT ${val}`;
+            }
+            else if (line.includes("@updatedAt")) {
+                defaultValue = "DEFAULT CURRENT_TIMESTAMP";
+            }
+            currentModel.fields.push({
+                name: fieldName,
+                sqlType,
+                isOptional,
+                isId,
+                isUnique,
+                defaultValue,
+            });
+        }
+    }
+    console.log(`🚀 Pushing schema to database...`);
+    for (const model of models) {
+        console.log(`Processing table [${model.tableName}]...`);
+        // Check if table exists
+        const tableExists = await (await getDb()).$queryRawUnsafe(`SELECT name FROM sys.tables WHERE name = '${model.tableName}'`);
+        if (tableExists.length === 0) {
+            console.log(`Creating table [${model.tableName}]...`);
+            const colDefs = model.fields.map((f) => {
+                let def = `[${f.name}] ${f.sqlType}`;
+                if (f.isId)
+                    def += " PRIMARY KEY";
+                if (f.defaultValue)
+                    def += ` ${f.defaultValue}`;
+                if (!f.isOptional && !f.defaultValue && !f.isId)
+                    def += " NOT NULL";
+                if (f.isUnique && !f.isId)
+                    def += " UNIQUE";
+                return def;
+            });
+            // Add compound uniques as table constraints
+            if (model.compoundUniques && model.compoundUniques.length > 0) {
+                model.compoundUniques.forEach((fields, idx) => {
+                    const constraintName = `UQ_${model.tableName}_compound_${idx}`;
+                    const fieldsStr = fields.map(f => `[${f}]`).join(", ");
+                    colDefs.push(`CONSTRAINT [${constraintName}] UNIQUE (${fieldsStr})`);
+                });
+            }
+            const createSql = `CREATE TABLE [${model.tableName}] (\n  ${colDefs.join(",\n  ")}\n)`;
+            await (await getDb()).$executeRawUnsafe(createSql);
+            console.log(`✅ Table [${model.tableName}] created.`);
+            // Create indexes
+            if (model.indexes && model.indexes.length > 0) {
+                for (let idx = 0; idx < model.indexes.length; idx++) {
+                    const fields = model.indexes[idx];
+                    const indexName = `IX_${model.tableName}_${fields.join("_")}`;
+                    const fieldsStr = fields.map((f) => `[${f}]`).join(", ");
+                    console.log(`Creating index [${indexName}] on table [${model.tableName}]...`);
+                    await (await getDb()).$executeRawUnsafe(`CREATE INDEX [${indexName}] ON [${model.tableName}] (${fieldsStr})`);
+                }
+            }
+        }
+        else {
+            // 1. Check for missing columns
+            for (const field of model.fields) {
+                const colExists = await (await getDb()).$queryRawUnsafe(`SELECT name FROM sys.columns WHERE object_id = OBJECT_ID('${model.tableName}') AND name = '${field.name}'`);
+                if (colExists.length === 0) {
+                    console.log(`Adding column [${field.name}] to table [${model.tableName}]...`);
+                    let alterSql = `ALTER TABLE [${model.tableName}] ADD [${field.name}] ${field.sqlType}`;
+                    if (field.defaultValue)
+                        alterSql += ` ${field.defaultValue}`;
+                    if (field.isUnique && !field.isId)
+                        alterSql += " UNIQUE";
+                    if (!field.isOptional && !field.defaultValue) {
+                        if (!field.defaultValue)
+                            alterSql += " NULL";
+                        else
+                            alterSql += " NOT NULL";
+                    }
+                    await (await getDb()).$executeRawUnsafe(alterSql);
+                }
+            }
+            // 2. Check for missing compound uniques
+            if (model.compoundUniques && model.compoundUniques.length > 0) {
+                for (let idx = 0; idx < model.compoundUniques.length; idx++) {
+                    const fields = model.compoundUniques[idx];
+                    const constraintName = `UQ_${model.tableName}_compound_${idx}`;
+                    const constraintExists = await (await getDb()).$queryRawUnsafe(`SELECT name FROM sys.objects WHERE type = 'UQ' AND parent_object_id = OBJECT_ID('${model.tableName}') AND name = '${constraintName}'`);
+                    if (constraintExists.length === 0) {
+                        console.log(`Adding compound unique constraint [${constraintName}] to table [${model.tableName}]...`);
+                        const fieldsStr = fields.map((f) => `[${f}]`).join(", ");
+                        await (await getDb()).$executeRawUnsafe(`ALTER TABLE [${model.tableName}] ADD CONSTRAINT [${constraintName}] UNIQUE (${fieldsStr})`);
+                    }
+                }
+            }
+            // 3. Check for missing indexes
+            if (model.indexes && model.indexes.length > 0) {
+                for (let idx = 0; idx < model.indexes.length; idx++) {
+                    const fields = model.indexes[idx];
+                    const indexName = `IX_${model.tableName}_${fields.join("_")}`;
+                    const indexExists = await (await getDb()).$queryRawUnsafe(`SELECT name FROM sys.indexes WHERE object_id = OBJECT_ID('${model.tableName}') AND name = '${indexName}'`);
+                    if (indexExists.length === 0) {
+                        console.log(`Creating index [${indexName}] on table [${model.tableName}]...`);
+                        const fieldsStr = fields.map((f) => `[${f}]`).join(", ");
+                        await (await getDb()).$executeRawUnsafe(`CREATE INDEX [${indexName}] ON [${model.tableName}] (${fieldsStr})`);
+                    }
+                }
+            }
+        }
+    }
+    console.log("✅ Database push completed.");
+    process.exit(0);
+}
+push().catch((err) => {
+    console.error("❌ Push failed:", err);
+    process.exit(1);
+});
+//# sourceMappingURL=push.js.map

package/dist/scripts/release-cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env tsx
+export {};
+//# sourceMappingURL=release-cli.d.ts.map