@an5/orm 1.0.7 → 1.0.8

package/dist/pull.js

@@ -1,339 +0,0 @@
-"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 = process.cwd();
-let config = {};
-try {
-    let configPath = path_1.default.join(rootDir, "an5Orm.config.js");
-    if (!fs_1.default.existsSync(configPath)) {
-        configPath = path_1.default.join(rootDir, "an5Orm.config.cjs");
-    }
-    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

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

package/dist/push.js

@@ -1,281 +0,0 @@
-"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 adapters_1 = require("@an5/adapters");
-const rootDir = process.cwd();
-let config = {};
-try {
-    let configPath = path_1.default.join(rootDir, "an5Orm.config.js");
-    if (!fs_1.default.existsSync(configPath)) {
-        configPath = path_1.default.join(rootDir, "an5Orm.config.cjs");
-    }
-    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 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();
-}
-function parseTableName(raw) {
-    const cleaned = raw.replace(/[\[\]"]/g, "");
-    const parts = cleaned.split(".").filter(Boolean);
-    if (parts.length >= 2) {
-        return { schema: parts[parts.length - 2], name: parts[parts.length - 1] };
-    }
-    return { name: cleaned };
-}
-function tableSqlName(raw) {
-    const table = parseTableName(raw);
-    return table.schema ? `[${table.schema}].[${table.name}]` : `[${table.name}]`;
-}
-function tableObjectName(raw) {
-    const table = parseTableName(raw);
-    return table.schema ? `${table.schema}.${table.name}` : table.name;
-}
-function safeIdentifierName(raw) {
-    return raw.replace(/[^A-Za-z0-9_]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
-}
-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) {
-        const sqlTableName = tableSqlName(model.tableName);
-        const objectName = tableObjectName(model.tableName);
-        console.log(`Processing table ${sqlTableName}...`);
-        // Check if table exists
-        const tableExists = await (await getDb()).$queryRawUnsafe(`SELECT name FROM sys.tables WHERE object_id = OBJECT_ID('${objectName}')`);
-        if (tableExists.length === 0) {
-            console.log(`Creating table ${sqlTableName}...`);
-            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_${safeIdentifierName(model.tableName)}_compound_${idx}`;
-                    const fieldsStr = fields.map(f => `[${f}]`).join(", ");
-                    colDefs.push(`CONSTRAINT [${constraintName}] UNIQUE (${fieldsStr})`);
-                });
-            }
-            const createSql = `CREATE TABLE ${sqlTableName} (\n  ${colDefs.join(",\n  ")}\n)`;
-            await (await getDb()).$executeRawUnsafe(createSql);
-            console.log(`✅ Table ${sqlTableName} 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_${safeIdentifierName(model.tableName)}_${fields.join("_")}`;
-                    const fieldsStr = fields.map((f) => `[${f}]`).join(", ");
-                    console.log(`Creating index [${indexName}] on table ${sqlTableName}...`);
-                    await (await getDb()).$executeRawUnsafe(`CREATE INDEX [${indexName}] ON ${sqlTableName} (${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('${objectName}') AND name = '${field.name}'`);
-                if (colExists.length === 0) {
-                    console.log(`Adding column [${field.name}] to table ${sqlTableName}...`);
-                    let alterSql = `ALTER TABLE ${sqlTableName} 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_${safeIdentifierName(model.tableName)}_compound_${idx}`;
-                    const constraintExists = await (await getDb()).$queryRawUnsafe(`SELECT name FROM sys.objects WHERE type = 'UQ' AND parent_object_id = OBJECT_ID('${objectName}') AND name = '${constraintName}'`);
-                    if (constraintExists.length === 0) {
-                        console.log(`Adding compound unique constraint [${constraintName}] to table ${sqlTableName}...`);
-                        const fieldsStr = fields.map((f) => `[${f}]`).join(", ");
-                        await (await getDb()).$executeRawUnsafe(`ALTER TABLE ${sqlTableName} 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_${safeIdentifierName(model.tableName)}_${fields.join("_")}`;
-                    const indexExists = await (await getDb()).$queryRawUnsafe(`SELECT name FROM sys.indexes WHERE object_id = OBJECT_ID('${objectName}') AND name = '${indexName}'`);
-                    if (indexExists.length === 0) {
-                        console.log(`Creating index [${indexName}] on table ${sqlTableName}...`);
-                        const fieldsStr = fields.map((f) => `[${f}]`).join(", ");
-                        await (await getDb()).$executeRawUnsafe(`CREATE INDEX [${indexName}] ON ${sqlTableName} (${fieldsStr})`);
-                    }
-                }
-            }
-        }
-    }
-    console.log("✅ Database push completed.");
-    process.exit(0);
-}
-push().catch((err) => {
-    console.error("❌ Push failed:", err);
-    process.exit(1);
-});

package/dist/seed.d.ts

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