@an5/orm 1.0.0

package/dist/cleanup.d.ts

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

package/dist/cleanup.js

@@ -0,0 +1,117 @@
+"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 an5_adapters_1 = require("an5-adapters");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+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 cleanup.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;
+}
+async function cleanup() {
+    console.log("🧹 Starting database cleanup...");
+    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!");
+            process.exit(1);
+        }
+    }
+    const lines = schemaText.split("\n");
+    const validTables = new Set();
+    for (let line of lines) {
+        line = line.trim();
+        if (line.startsWith("model ")) {
+            const modelName = line.split(" ")[1].replace("{", "").trim();
+            // Default table name is model name + 's' (lowercase)
+            validTables.add(modelName.toLowerCase() + "s");
+        }
+        if (line.startsWith("@@map")) {
+            const mapMatch = line.match(/@@map\("(.+)"\)/);
+            if (mapMatch) {
+                // The last model's default name should be replaced by the map name
+                // Since we add the default name first, we need to be careful.
+                // Actually, let's just add the map name.
+                validTables.add(mapMatch[1]);
+            }
+        }
+    }
+    // Also include the capitalization variations from an5Metadata if we can, 
+    // but schema.an5 is the source of truth.
+    console.log("Valid tables from schema:", Array.from(validTables));
+    const dbTables = await (await getDb()).$queryRawUnsafe(`
+    SELECT name FROM sys.tables WHERE is_ms_shipped = 0
+  `);
+    const tablesToDrop = dbTables
+        .map(t => t.name)
+        .filter(name => !validTables.has(name) && !validTables.has(name.toLowerCase()));
+    if (tablesToDrop.length === 0) {
+        console.log("✅ No extra tables found. Database is clean.");
+        process.exit(0);
+    }
+    console.log("Tables to be DROPPED:", tablesToDrop);
+    for (const table of tablesToDrop) {
+        console.log(`Dropping table [${table}]...`);
+        try {
+            // We need to handle foreign key constraints. 
+            // For a thorough cleanup, we might need to drop constraints first.
+            // But for now, we'll try a simple DROP TABLE.
+            await (await getDb()).$executeRawUnsafe(`DROP TABLE [${table}]`);
+            console.log(`✅ Dropped [${table}]`);
+        }
+        catch (err) {
+            console.error(`❌ Failed to drop [${table}]: ${err.message}`);
+            if (err.message.includes("FOREIGN KEY constraint")) {
+                console.log(`Attempting to find and drop constraints for [${table}]...`);
+                const constraints = await (await getDb()).$queryRawUnsafe(`
+            SELECT fk.name AS constraint_name, OBJECT_NAME(fk.parent_object_id) AS table_name
+            FROM sys.foreign_keys AS fk
+            WHERE OBJECT_NAME(fk.referenced_object_id) = @p_0 OR OBJECT_NAME(fk.parent_object_id) = @p_0
+          `, table);
+                for (const c of constraints) {
+                    console.log(`Dropping constraint [${c.constraint_name}] on [${c.table_name}]...`);
+                    await (await getDb()).$executeRawUnsafe(`ALTER TABLE [${c.table_name}] DROP CONSTRAINT [${c.constraint_name}]`);
+                }
+                // Try dropping again
+                await (await getDb()).$executeRawUnsafe(`DROP TABLE [${table}]`);
+                console.log(`✅ Dropped [${table}] after removing constraints.`);
+            }
+        }
+    }
+    console.log("✅ Cleanup completed.");
+    process.exit(0);
+}
+cleanup().catch(err => {
+    console.error("❌ Cleanup failed:", err);
+    process.exit(1);
+});
+//# sourceMappingURL=cleanup.js.map

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { An5ORM, an5Orm, default } from "./an5Orm";
+export type { Middleware, MiddlewareParams } from "./an5Orm";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.an5Orm = exports.An5ORM = void 0;
+var an5Orm_1 = require("./an5Orm");
+Object.defineProperty(exports, "An5ORM", { enumerable: true, get: function () { return an5Orm_1.An5ORM; } });
+Object.defineProperty(exports, "an5Orm", { enumerable: true, get: function () { return an5Orm_1.an5Orm; } });
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(an5Orm_1).default; } });
+//# sourceMappingURL=index.js.map

package/dist/migrate.d.ts

@@ -0,0 +1,11 @@
+/**
+ * an5Orm Migration Tool
+ * Compares schema files with database and generates migration SQL.
+ *
+ * Usage:
+ *   npx tsx migrate.ts diff       # Show differences
+ *   npx tsx migrate.ts generate   # Generate migration file
+ *   npx tsx migrate.ts status     # Show migration status
+ */
+import 'dotenv/config';
+//# sourceMappingURL=migrate.d.ts.map

package/dist/migrate.js

@@ -0,0 +1,298 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * an5Orm Migration Tool
+ * Compares schema files with database and generates migration SQL.
+ *
+ * Usage:
+ *   npx tsx migrate.ts diff       # Show differences
+ *   npx tsx migrate.ts generate   # Generate migration file
+ *   npx tsx migrate.ts status     # Show migration status
+ */
+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 { /* ignore */ }
+const schemaDir = path_1.default.resolve(rootDir, config.schemaDir || 'an5Schema');
+const migrationsDir = path_1.default.resolve(rootDir, 'migrations');
+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 ──────────────────────────────────────────────
+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',
+]);
+function parseSqlType(raw) {
+    const match = raw.match(/^(\w+)/);
+    return match ? match[1].toUpperCase() : raw.toUpperCase();
+}
+function parseSchema() {
+    const models = [];
+    if (!fs_1.default.existsSync(schemaDir))
+        return models;
+    const files = fs_1.default.readdirSync(schemaDir).filter(f => f.endsWith('.an5'));
+    let text = '';
+    for (const file of files) {
+        text += fs_1.default.readFileSync(path_1.default.join(schemaDir, file), 'utf8') + '\n';
+    }
+    const lines = text.split('\n');
+    let current = null;
+    for (let line of lines) {
+        line = line.trim();
+        if (!line || line.startsWith('//'))
+            continue;
+        const modelMatch = line.match(/^model\s+(\w+)\s*\{/);
+        if (modelMatch) {
+            current = {
+                name: modelMatch[1],
+                tableName: modelMatch[1].toLowerCase() + 's',
+                fields: [],
+                compoundUniques: [],
+                indexes: [],
+            };
+            models.push(current);
+            continue;
+        }
+        if (line === '}') {
+            current = null;
+            continue;
+        }
+        if (!current)
+            continue;
+        if (line.startsWith('@@map')) {
+            const m = line.match(/@@map\("(.+)"\)/);
+            if (m)
+                current.tableName = m[1];
+            continue;
+        }
+        if (line.startsWith('@@unique')) {
+            const m = line.match(/@@unique\(\[([\w,\s]+)\]\)/);
+            if (m)
+                current.compoundUniques.push(m[1].split(',').map(f => f.trim()));
+            continue;
+        }
+        if (line.startsWith('@@index')) {
+            const m = line.match(/@@index\(\[([\w,\s]+)\]\)/);
+            if (m)
+                current.indexes.push(m[1].split(',').map(f => f.trim()));
+            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;
+        current.fields.push({
+            name: fieldName,
+            sqlType: cleanType.toUpperCase(),
+            isOptional: fieldType.endsWith('?'),
+            isId: line.includes('@id'),
+            isUnique: line.includes('@unique'),
+            defaultValue: line.match(/@default\((.*)\)/)?.[1],
+        });
+    }
+    return models;
+}
+async function introspectTable(tableName) {
+    return (await getDb()).$queryRawUnsafe(`
+    SELECT
+      c.name AS columnName,
+      ty.name AS dataType,
+      c.is_nullable AS isNullable,
+      pk.is_primary_key AS isPrimaryKey,
+      c.is_identity AS isIdentity,
+      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);
+}
+async function getExistingTables() {
+    const rows = await (await getDb()).$queryRawUnsafe(`
+    SELECT name FROM sys.tables WHERE is_ms_shipped = 0 ORDER BY name
+  `);
+    return rows.map(r => r.name);
+}
+function generateDiff(schemaModels, dbTables) {
+    const ops = [];
+    const schemaTableNames = new Set(schemaModels.map(m => m.tableName));
+    // New tables
+    for (const model of schemaModels) {
+        if (!dbTables.includes(model.tableName)) {
+            const colDefs = model.fields.map(f => {
+                let def = `[${f.name}] ${f.sqlType}`;
+                if (f.isId)
+                    def += ' PRIMARY KEY';
+                if (f.defaultValue)
+                    def += ` ${mapDefault(f.defaultValue)}`;
+                if (!f.isOptional && !f.defaultValue && !f.isId)
+                    def += ' NOT NULL';
+                if (f.isUnique && !f.isId)
+                    def += ' UNIQUE';
+                return def;
+            });
+            const sql = `CREATE TABLE [${model.tableName}] (\n  ${colDefs.join(',\n  ')}\n)`;
+            ops.push({ type: 'CREATE_TABLE', table: model.tableName, sql });
+        }
+    }
+    // Dropped tables
+    for (const tableName of dbTables) {
+        if (!schemaTableNames.has(tableName)) {
+            ops.push({
+                type: 'DROP_COLUMN',
+                table: tableName,
+                details: `Table not in schema - consider dropping`,
+                sql: `-- DROP TABLE [${tableName}]`,
+            });
+        }
+    }
+    return ops;
+}
+function mapDefault(val) {
+    if (val === 'uuid()')
+        return 'DEFAULT NEWID()';
+    if (val === 'cuid()')
+        return 'DEFAULT NEWID()';
+    if (val === 'now()')
+        return 'DEFAULT CURRENT_TIMESTAMP';
+    if (val === 'autoincrement()')
+        return 'IDENTITY(1,1)';
+    if (val === 'true')
+        return 'DEFAULT 1';
+    if (val === 'false')
+        return 'DEFAULT 0';
+    if (/^".*"$/.test(val))
+        return `DEFAULT '${val.slice(1, -1)}'`;
+    return `DEFAULT ${val}`;
+}
+// ─── Commands ────────────────────────────────────────────────────────────────
+async function cmdDiff() {
+    console.log('\n🔍 Comparing schema with database...\n');
+    const schemaModels = parseSchema();
+    const dbTables = await getExistingTables();
+    console.log(`Schema: ${schemaModels.length} models`);
+    console.log(`Database: ${dbTables.length} tables\n`);
+    const ops = generateDiff(schemaModels, dbTables);
+    if (ops.length === 0) {
+        console.log('✅ Schema is in sync with database.');
+        return;
+    }
+    console.log(`Found ${ops.length} difference(s):\n`);
+    for (const op of ops) {
+        console.log(`  ${op.type}: ${op.table}`);
+        if (op.details)
+            console.log(`    ${op.details}`);
+        if (op.sql)
+            console.log(`    SQL: ${op.sql}`);
+    }
+}
+async function cmdGenerate() {
+    console.log('\n📝 Generating migration file...\n');
+    const schemaModels = parseSchema();
+    const dbTables = await getExistingTables();
+    const ops = generateDiff(schemaModels, dbTables);
+    if (ops.length === 0) {
+        console.log('No migrations needed.');
+        return;
+    }
+    if (!fs_1.default.existsSync(migrationsDir)) {
+        fs_1.default.mkdirSync(migrationsDir, { recursive: true });
+    }
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    const filename = `${timestamp}_migration.sql`;
+    const filepath = path_1.default.join(migrationsDir, filename);
+    const lines = [`-- Migration: ${timestamp}`, `-- Generated by an5Orm migrate`, ''];
+    for (const op of ops) {
+        lines.push(`-- ${op.type}: ${op.table}`);
+        if (op.sql)
+            lines.push(op.sql);
+        lines.push('');
+    }
+    fs_1.default.writeFileSync(filepath, lines.join('\n'));
+    console.log(`✅ Migration written to: ${filepath}`);
+}
+async function cmdStatus() {
+    console.log('\n📊 Migration Status\n');
+    const schemaModels = parseSchema();
+    const dbTables = await getExistingTables();
+    console.log('Schema Models:');
+    for (const model of schemaModels) {
+        const exists = dbTables.includes(model.tableName);
+        const icon = exists ? '✅' : '⚠️';
+        console.log(`  ${icon} ${model.name} → ${model.tableName} (${model.fields.length} fields)`);
+    }
+    console.log('\nDatabase Tables:');
+    for (const table of dbTables) {
+        const inSchema = schemaModels.some(m => m.tableName === table);
+        const icon = inSchema ? '✅' : '⚠️';
+        console.log(`  ${icon} ${table}`);
+    }
+    if (!fs_1.default.existsSync(migrationsDir)) {
+        fs_1.default.mkdirSync(migrationsDir, { recursive: true });
+    }
+    const migrations = fs_1.default.readdirSync(migrationsDir).filter(f => f.endsWith('.sql'));
+    console.log(`\nMigration files: ${migrations.length}`);
+}
+// ─── Main ────────────────────────────────────────────────────────────────────
+async function main() {
+    const command = process.argv[2] || 'diff';
+    switch (command) {
+        case 'diff':
+            await cmdDiff();
+            break;
+        case 'generate':
+            await cmdGenerate();
+            break;
+        case 'status':
+            await cmdStatus();
+            break;
+        default:
+            console.log('Usage: npx tsx migrate.ts [diff|generate|status]');
+            process.exit(1);
+    }
+    process.exit(0);
+}
+main().catch((err) => {
+    console.error('❌ Migration failed:', err);
+    process.exit(1);
+});
+//# sourceMappingURL=migrate.js.map

package/dist/pull.d.ts

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