@an5/orm 1.0.7 → 1.0.8

package/dist/an5Orm.js

@@ -1,19 +1,22 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.an5Orm = exports.An5ORM = void 0;
-const mssql_1 = __importDefault(require("mssql"));
-const an5_adapters_1 = require("@an5/adapters");
+const adapters_1 = require("@an5/adapters");
 const crypto_1 = require("crypto");
-const logger_1 = require("@an5/lib/logger");
-const typescript_1 = require("an5-client/typescript");
-const an5Metadata_1 = require("an5-client/typescript/an5Metadata");
+const logger_1 = require("./logger");
+const errors_1 = require("./errors");
+const metadata_1 = require("./metadata");
+const sql_utils_1 = require("./sql-utils");
+function aggSelect(fn, key) {
+    return `${fn}(${(0, sql_utils_1.quoteIdentifier)(key)}) as ${aggAlias(fn, key)}`;
+}
+function aggAlias(fn, key) {
+    return (0, sql_utils_1.sanitizeParamName)(`${fn}_${key}`);
+}
 let adapter = null;
 async function getAdapter() {
     if (!adapter) {
-        adapter = new an5_adapters_1.An5Adapter({ connectionString: process.env.DATABASE_URL });
+        adapter = new adapters_1.An5Adapter({ connectionString: process.env.DATABASE_URL });
         await adapter.$connect();
     }
     return adapter;
@@ -22,185 +25,6 @@ async function execQuery(queryText, params) {
     const a = await getAdapter();
     return a.exec(queryText, params);
 }
-function parseWhere(modelName, where, params, prefix = "") {
-    if (!where)
-        return "";
-    const conditions = [];
-    const cleanWhere = {};
-    for (const [key, value] of Object.entries(where)) {
-        if (key.includes("_") &&
-            value &&
-            typeof value === "object" &&
-            !(value instanceof Date) &&
-            !value.in &&
-            !value.contains &&
-            !value.not &&
-            !value.gte &&
-            !value.lte &&
-            !value.gt &&
-            !value.lt) {
-            Object.assign(cleanWhere, value);
-        }
-        else {
-            cleanWhere[key] = value;
-        }
-    }
-    for (const [key, value] of Object.entries(cleanWhere)) {
-        if (key === "OR" && Array.isArray(value)) {
-            const orConditions = value.map((subWhere, idx) => parseWhere(modelName, subWhere, params, `${prefix}or_${idx}_`));
-            const filtered = orConditions.filter(Boolean);
-            if (filtered.length > 0) {
-                conditions.push(`(${filtered.join(" OR ")})`);
-            }
-        }
-        else if (key === "AND" && Array.isArray(value)) {
-            const andConditions = value.map((subWhere, idx) => parseWhere(modelName, subWhere, params, `${prefix}and_${idx}_`));
-            const filtered = andConditions.filter(Boolean);
-            if (filtered.length > 0) {
-                conditions.push(`(${filtered.join(" AND ")})`);
-            }
-        }
-        else {
-            const modelRelations = an5Metadata_1.relationMap[modelName];
-            const relation = modelRelations?.[key];
-            if (relation) {
-                // Relation subquery
-                const relationTable = an5Metadata_1.modelToTable[relation.modelName];
-                const subParams = {};
-                let subWhere = value;
-                let op = "some"; // default
-                if (value && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date)) {
-                    if (value.some) {
-                        subWhere = value.some;
-                        op = "some";
-                    }
-                    else if (value.none) {
-                        subWhere = value.none;
-                        op = "none";
-                    }
-                    else if (value.every) {
-                        subWhere = value.every;
-                        op = "every";
-                    }
-                }
-                const subWhereSql = parseWhere(relation.modelName, subWhere, subParams, `${prefix}${key}_`);
-                Object.assign(params, subParams);
-                if (subWhereSql) {
-                    if (relation.relationType === "one") {
-                        if (op === "none") {
-                            conditions.push(`${relation.foreignKey} NOT IN (SELECT ${relation.localKey} FROM ${relationTable} WITH (NOLOCK) WHERE ${subWhereSql})`);
-                        }
-                        else {
-                            conditions.push(`${relation.foreignKey} IN (SELECT ${relation.localKey} FROM ${relationTable} WITH (NOLOCK) WHERE ${subWhereSql})`);
-                        }
-                    }
-                    else {
-                        if (op === "none") {
-                            conditions.push(`${relation.localKey} NOT IN (SELECT ${relation.foreignKey} FROM ${relationTable} WITH (NOLOCK) WHERE ${subWhereSql})`);
-                        }
-                        else {
-                            conditions.push(`${relation.localKey} IN (SELECT ${relation.foreignKey} FROM ${relationTable} WITH (NOLOCK) WHERE ${subWhereSql})`);
-                        }
-                    }
-                }
-            }
-            else {
-                const paramName = `${prefix}${key}`;
-                if (value && typeof value === "object" && !(value instanceof Date)) {
-                    const ops = Object.entries(value);
-                    for (const [op, opVal] of ops) {
-                        if (op === "in" && Array.isArray(opVal)) {
-                            if (opVal.length === 0) {
-                                conditions.push("1 = 0");
-                            }
-                            else {
-                                const inParams = [];
-                                opVal.forEach((item, idx) => {
-                                    const inParamName = `${paramName}_in_${idx}`;
-                                    inParams.push(`@${inParamName}`);
-                                    params[inParamName] = item;
-                                });
-                                conditions.push(`${key} IN (${inParams.join(", ")})`);
-                            }
-                        }
-                        else if (op === "notIn" && Array.isArray(opVal)) {
-                            if (opVal.length === 0) {
-                                // NOT IN empty list is always true, but let's be safe
-                                conditions.push("1 = 1");
-                            }
-                            else {
-                                const inParams = [];
-                                opVal.forEach((item, idx) => {
-                                    const inParamName = `${paramName}_notin_${idx}`;
-                                    inParams.push(`@${inParamName}`);
-                                    params[inParamName] = item;
-                                });
-                                conditions.push(`${key} NOT IN (${inParams.join(", ")})`);
-                            }
-                        }
-                        else if (op === "contains") {
-                            conditions.push(`${key} LIKE @${paramName}_contains`);
-                            params[`${paramName}_contains`] = `%${opVal}%`;
-                        }
-                        else if (op === "startsWith") {
-                            conditions.push(`${key} LIKE @${paramName}_startsWith`);
-                            params[`${paramName}_startsWith`] = `${opVal}%`;
-                        }
-                        else if (op === "endsWith") {
-                            conditions.push(`${key} LIKE @${paramName}_endsWith`);
-                            params[`${paramName}_endsWith`] = `%${opVal}`;
-                        }
-                        else if (op === "not") {
-                            conditions.push(`${key} <> @${paramName}_not`);
-                            params[`${paramName}_not`] = opVal;
-                        }
-                        else if (op === "gte") {
-                            conditions.push(`${key} >= @${paramName}_gte`);
-                            params[`${paramName}_gte`] = opVal;
-                        }
-                        else if (op === "lte") {
-                            conditions.push(`${key} <= @${paramName}_lte`);
-                            params[`${paramName}_lte`] = opVal;
-                        }
-                        else if (op === "gt") {
-                            conditions.push(`${key} > @${paramName}_gt`);
-                            params[`${paramName}_gt`] = opVal;
-                        }
-                        else if (op === "lt") {
-                            conditions.push(`${key} < @${paramName}_lt`);
-                            params[`${paramName}_lt`] = opVal;
-                        }
-                    }
-                }
-                else {
-                    if (value === null) {
-                        conditions.push(`${key} IS NULL`);
-                    }
-                    else {
-                        conditions.push(`${key} = @${paramName}`);
-                        params[paramName] = value;
-                    }
-                }
-            }
-        }
-    }
-    return conditions.join(" AND ");
-}
-function buildOrderBy(orderBy) {
-    if (!orderBy)
-        return "";
-    const orderClauses = [];
-    const orderByArr = Array.isArray(orderBy) ? orderBy : [orderBy];
-    for (const orderObj of orderByArr) {
-        if (orderObj && typeof orderObj === "object") {
-            for (const [k, dir] of Object.entries(orderObj)) {
-                const dirStr = typeof dir === "string" ? dir.toUpperCase() : "ASC";
-                orderClauses.push(`${k} ${dirStr}`);
-            }
-        }
-    }
-    return orderClauses.length > 0 ? ` ORDER BY ` + orderClauses.join(", ") : "";
-}
 function projectFields(row, select) {
     if (!row || !select)
         return row;
@@ -216,10 +40,10 @@ function projectFields(row, select) {
     return projected;
 }
 // Helper to batch-query and resolve relationships
-async function resolveIncludes(modelName, rows, include, executor) {
+async function resolveIncludes(modelName, rows, include, executor, metadata) {
     if (!rows || rows.length === 0 || !include)
         return;
-    const modelRelations = an5Metadata_1.relationMap[modelName];
+    const modelRelations = metadata.relationMap[modelName];
     if (!modelRelations)
         return;
     for (const [key, value] of Object.entries(include)) {
@@ -232,17 +56,17 @@ async function resolveIncludes(modelName, rows, include, executor) {
                 for (const countField of countFields) {
                     const rel = modelRelations[countField];
                     if (rel) {
-                        const relTable = an5Metadata_1.modelToTable[rel.modelName];
+                        const relTable = metadata.modelToTable[rel.modelName];
                         const localKeys = rows.map(r => r[rel.localKey]).filter(Boolean);
                         if (localKeys.length === 0) {
                             rows.forEach(r => { r._count = { ...r._count, [countField]: 0 }; });
                             continue;
                         }
-                        const sqlText = `
-              SELECT ${rel.foreignKey} as parentId, COUNT(*) as count 
-              FROM ${relTable} WITH (NOLOCK)
-              WHERE ${rel.foreignKey} IN (${localKeys.map((_, i) => `@lk_${i}`).join(", ")})
-              GROUP BY ${rel.foreignKey}
+                        const sqlText = `
+              SELECT ${(0, sql_utils_1.quoteIdentifier)(rel.foreignKey)} as parentId, COUNT(*) as count 
+              FROM ${relTable} WITH (NOLOCK)
+              WHERE ${(0, sql_utils_1.quoteIdentifier)(rel.foreignKey)} IN (${localKeys.map((_, i) => `@lk_${i}`).join(", ")})
+              GROUP BY ${(0, sql_utils_1.quoteIdentifier)(rel.foreignKey)}
             `;
                         const countParams = {};
                         localKeys.forEach((lk, i) => { countParams[`lk_${i}`] = lk; });
@@ -258,7 +82,7 @@ async function resolveIncludes(modelName, rows, include, executor) {
             }
             continue;
         }
-        const relTable = an5Metadata_1.modelToTable[relation.modelName];
+        const relTable = metadata.modelToTable[relation.modelName];
         const isMany = relation.relationType === "many";
         const matchKey = relation.relationType === "one" ? relation.foreignKey : relation.localKey;
         const searchKey = relation.relationType === "one" ? relation.localKey : relation.foreignKey;
@@ -271,24 +95,25 @@ async function resolveIncludes(modelName, rows, include, executor) {
         let relCols = "*";
         if (value && typeof value === "object" && value.select) {
             const subSelect = value.select;
-            const subRelations = an5Metadata_1.relationMap[relation.modelName] || {};
+            const subRelations = metadata.relationMap[relation.modelName] || {};
             const selectedSubCols = Object.keys(subSelect)
                 .filter(k => subSelect[k] && !subRelations[k])
-                .map(k => `[${k}]`);
+                .map(k => (0, sql_utils_1.quoteIdentifier)(k));
             if (selectedSubCols.length > 0) {
-                if (!selectedSubCols.includes(`[${searchKey}]`)) {
-                    selectedSubCols.push(`[${searchKey}]`);
+                const quotedSearchKey = (0, sql_utils_1.quoteIdentifier)(searchKey);
+                if (!selectedSubCols.includes(quotedSearchKey)) {
+                    selectedSubCols.push(quotedSearchKey);
                 }
                 relCols = selectedSubCols.join(", ");
             }
         }
-        let sqlText = `SELECT ${relCols} FROM ${relTable} WITH (NOLOCK) WHERE ${searchKey} IN (${uniqueKeys.map((_, i) => `@k_${i}`).join(", ")})`;
+        let sqlText = `SELECT ${relCols} FROM ${relTable} WITH (NOLOCK) WHERE ${(0, sql_utils_1.quoteIdentifier)(searchKey)} IN (${uniqueKeys.map((_, i) => `@k_${i}`).join(", ")})`;
         const subParams = {};
         uniqueKeys.forEach((k, i) => { subParams[`k_${i}`] = k; });
         if (value && typeof value === "object") {
             const subArgs = value;
             if (subArgs.orderBy) {
-                sqlText += buildOrderBy(subArgs.orderBy);
+                sqlText += (0, sql_utils_1.buildOrderBy)(subArgs.orderBy);
             }
         }
         const relatedRows = await executor(sqlText, subParams);
@@ -298,7 +123,7 @@ async function resolveIncludes(modelName, rows, include, executor) {
             });
         }
         if (value && typeof value === "object" && value.include) {
-            await resolveIncludes(relation.modelName, relatedRows, value.include, executor);
+            await resolveIncludes(relation.modelName, relatedRows, value.include, executor, metadata);
         }
         const groupMap = new Map();
         relatedRows.forEach((r) => {
@@ -333,35 +158,35 @@ class TableClient {
             const hasSkip = finalArgs?.skip !== undefined && finalArgs?.skip !== null;
             let cols = "*";
             if (finalArgs?.select) {
-                const modelRelations = an5Metadata_1.relationMap[this.modelName] || {};
+                const modelRelations = this.orm.metadata.relationMap[this.modelName] || {};
                 const selectedCols = Object.keys(finalArgs.select)
                     .filter(k => finalArgs.select[k] && !modelRelations[k])
-                    .map(k => `[${k}]`);
+                    .map(k => (0, sql_utils_1.quoteIdentifier)(k));
                 if (selectedCols.length > 0) {
                     cols = selectedCols.join(", ");
                 }
             }
             let sqlText = "SELECT";
             if (finalArgs?.take && !hasSkip) {
-                sqlText += ` TOP (${finalArgs.take})`;
+                sqlText += ` TOP (${(0, sql_utils_1.toNonNegativeInt)(finalArgs.take, 1)})`;
             }
             sqlText += ` ${cols} FROM ${this.tableName} WITH (NOLOCK)`;
             const p = {};
-            const whereSql = parseWhere(this.modelName, finalArgs?.where, p);
+            const whereSql = this.orm.parseWhere(this.modelName, finalArgs?.where, p);
             if (whereSql) {
                 sqlText += ` WHERE ${whereSql}`;
             }
             if (finalArgs?.orderBy) {
-                sqlText += buildOrderBy(finalArgs.orderBy);
+                sqlText += (0, sql_utils_1.buildOrderBy)(finalArgs.orderBy);
             }
             else if (hasSkip) {
                 // OFFSET requires an ORDER BY clause in SQL Server
                 sqlText += " ORDER BY (SELECT NULL)";
             }
             if (hasSkip) {
-                sqlText += ` OFFSET ${finalArgs.skip} ROWS`;
+                sqlText += ` OFFSET ${(0, sql_utils_1.toNonNegativeInt)(finalArgs.skip)} ROWS`;
                 if (finalArgs?.take) {
-                    sqlText += ` FETCH NEXT ${finalArgs.take} ROWS ONLY`;
+                    sqlText += ` FETCH NEXT ${(0, sql_utils_1.toNonNegativeInt)(finalArgs.take, 1)} ROWS ONLY`;
                 }
             }
             const rows = await this.executor(sqlText, p);
@@ -371,7 +196,7 @@ class TableClient {
                 });
             }
             if (finalArgs?.include) {
-                await resolveIncludes(this.modelName, rows, finalArgs.include, this.executor);
+                await resolveIncludes(this.modelName, rows, finalArgs.include, this.executor, this.orm.metadata);
             }
             return rows;
         });
@@ -392,7 +217,7 @@ class TableClient {
             const { args: finalArgs } = params;
             let sqlText = `SELECT COUNT(*) as count FROM ${this.tableName} WITH (NOLOCK)`;
             const p = {};
-            const whereSql = parseWhere(this.modelName, finalArgs?.where, p);
+            const whereSql = this.orm.parseWhere(this.modelName, finalArgs?.where, p);
             if (whereSql) {
                 sqlText += ` WHERE ${whereSql}`;
             }
@@ -401,7 +226,7 @@ class TableClient {
         });
     }
     async handleNestedWrites(data, parentId) {
-        const modelRelations = an5Metadata_1.relationMap[this.modelName] || {};
+        const modelRelations = this.orm.metadata.relationMap[this.modelName] || {};
         for (const [key, value] of Object.entries(data)) {
             const relation = modelRelations[key];
             if (!relation || !value || typeof value !== "object" || (value instanceof Date))
@@ -447,20 +272,20 @@ class TableClient {
                 const data = { ...finalArgs.data };
                 // Extract nested writes
                 const nestedData = {};
-                const modelRelations = an5Metadata_1.relationMap[this.modelName] || {};
+                const modelRelations = this.orm.metadata.relationMap[this.modelName] || {};
                 for (const key of Object.keys(data)) {
                     if (modelRelations[key]) {
                         nestedData[key] = data[key];
                         delete data[key];
                     }
                 }
-                if (!data.id && an5Metadata_1.modelFields[this.modelName]?.id?.ts === "string") {
+                if (!data.id && this.orm.metadata.modelFields[this.modelName]?.id?.ts === "string") {
                     data.id = (0, crypto_1.randomUUID)();
                 }
                 const now = new Date();
-                if (!data.createdAt && an5Metadata_1.modelFields[this.modelName]?.createdAt)
+                if (!data.createdAt && this.orm.metadata.modelFields[this.modelName]?.createdAt)
                     data.createdAt = now;
-                if (!data.updatedAt && an5Metadata_1.modelFields[this.modelName]?.updatedAt)
+                if (!data.updatedAt && this.orm.metadata.modelFields[this.modelName]?.updatedAt)
                     data.updatedAt = now;
                 // Handle one-relation connect where we hold the FK
                 for (const [key, value] of Object.entries(nestedData)) {
@@ -472,10 +297,13 @@ class TableClient {
                     }
                 }
                 const keys = Object.keys(data);
-                const columns = keys.map(k => `[${k}]`).join(", ");
-                const placeholders = keys.map(k => `@${k}`).join(", ");
+                const columns = keys.map(k => (0, sql_utils_1.quoteIdentifier)(k)).join(", ");
+                const safeKeys = keys.map(k => (0, sql_utils_1.sanitizeParamName)(k));
+                const placeholders = safeKeys.map(k => `@${k}`).join(", ");
+                const safeData = {};
+                keys.forEach((k, i) => { safeData[safeKeys[i]] = data[k]; });
                 const sqlText = `INSERT INTO ${this.tableName} (${columns}) OUTPUT inserted.* VALUES (${placeholders})`;
-                const rows = await this.executor(sqlText, data);
+                const rows = await this.executor(sqlText, safeData);
                 const createdRow = rows[0];
                 if (!createdRow) {
                     throw new Error("Failed to insert record and retrieve output");
@@ -500,19 +328,19 @@ class TableClient {
                     msg.includes('unique') ||
                     errNumber === 2627 ||
                     errNumber === 2601) {
-                    throw new typescript_1.An5.An5ClientKnownRequestError("Unique constraint failed", {
+                    throw new errors_1.An5ClientKnownRequestError("Unique constraint failed", {
                         code: "P2002",
                         clientVersion: "mock",
                     });
                 }
                 if (msg.includes('foreign key') || errNumber === 547) {
-                    throw new typescript_1.An5.An5ClientKnownRequestError("Foreign key constraint failed", {
+                    throw new errors_1.An5ClientKnownRequestError("Foreign key constraint failed", {
                         code: "P2003",
                         clientVersion: "mock",
                     });
                 }
                 if (msg.includes('not found') || errNumber === 404) {
-                    throw new typescript_1.An5.An5ClientKnownRequestError("Record not found", {
+                    throw new errors_1.An5ClientKnownRequestError("Record not found", {
                         code: "P2025",
                         clientVersion: "mock",
                     });
@@ -525,12 +353,12 @@ class TableClient {
         return this.orm._executeMiddleware({ model: this.modelName, action: 'update', args }, async (params) => {
             const { args: finalArgs } = params;
             const data = { ...finalArgs.data };
-            if (an5Metadata_1.modelFields[this.modelName]?.updatedAt) {
+            if (this.orm.metadata.modelFields[this.modelName]?.updatedAt) {
                 data.updatedAt = new Date();
             }
             // Extract nested writes
             const nestedData = {};
-            const modelRelations = an5Metadata_1.relationMap[this.modelName] || {};
+            const modelRelations = this.orm.metadata.relationMap[this.modelName] || {};
             for (const key of Object.keys(data)) {
                 if (modelRelations[key]) {
                     nestedData[key] = data[key];
@@ -551,28 +379,30 @@ class TableClient {
             const p = {};
             for (const key of Object.keys(data)) {
                 const val = data[key];
+                const col = (0, sql_utils_1.quoteIdentifier)(key);
+                const safeKey = (0, sql_utils_1.sanitizeParamName)(key);
                 if (val && typeof val === "object" && !(val instanceof Date)) {
                     if (val.increment !== undefined) {
-                        sets.push(`[${key}] = [${key}] + @${key}_inc`);
-                        p[`${key}_inc`] = val.increment;
+                        sets.push(`${col} = ${col} + @${safeKey}_inc`);
+                        p[`${safeKey}_inc`] = val.increment;
                         continue;
                     }
                     else if (val.decrement !== undefined) {
-                        sets.push(`[${key}] = [${key}] - @${key}_dec`);
-                        p[`${key}_dec`] = val.decrement;
+                        sets.push(`${col} = ${col} - @${safeKey}_dec`);
+                        p[`${safeKey}_dec`] = val.decrement;
                         continue;
                     }
                     else if (val.set !== undefined) {
-                        sets.push(`[${key}] = @${key}_set`);
-                        p[`${key}_set`] = val.set;
+                        sets.push(`${col} = @${safeKey}_set`);
+                        p[`${safeKey}_set`] = val.set;
                         continue;
                     }
                 }
-                sets.push(`[${key}] = @${key}`);
-                p[key] = val;
+                sets.push(`${col} = @${safeKey}`);
+                p[safeKey] = val;
             }
             const whereParams = {};
-            const whereSql = parseWhere(this.modelName, finalArgs.where, whereParams, "w_");
+            const whereSql = this.orm.parseWhere(this.modelName, finalArgs.where, whereParams, "w_");
             Object.assign(p, whereParams);
             const sqlText = `UPDATE ${this.tableName} SET ${sets.join(", ")} WHERE ${whereSql}`;
             await this.executor(sqlText, p);
@@ -594,7 +424,7 @@ class TableClient {
         return this.orm._executeMiddleware({ model: this.modelName, action: 'updateMany', args }, async (params) => {
             const { args: finalArgs } = params;
             const data = { ...finalArgs.data };
-            if (an5Metadata_1.modelFields[this.modelName]?.updatedAt) {
+            if (this.orm.metadata.modelFields[this.modelName]?.updatedAt) {
                 data.updatedAt = new Date();
             }
             delete data.id;
@@ -602,39 +432,36 @@ class TableClient {
             const p = {};
             for (const key of Object.keys(data)) {
                 const val = data[key];
-                if (an5Metadata_1.relationMap[this.modelName]?.[key])
+                if (this.orm.metadata.relationMap[this.modelName]?.[key])
                     continue;
+                const col = (0, sql_utils_1.quoteIdentifier)(key);
+                const safeKey = (0, sql_utils_1.sanitizeParamName)(key);
                 if (val && typeof val === "object" && !(val instanceof Date)) {
                     if (val.increment !== undefined) {
-                        sets.push(`[${key}] = [${key}] + @${key}_inc`);
-                        p[`${key}_inc`] = val.increment;
+                        sets.push(`${col} = ${col} + @${safeKey}_inc`);
+                        p[`${safeKey}_inc`] = val.increment;
                         continue;
                     }
                     else if (val.decrement !== undefined) {
-                        sets.push(`[${key}] = [${key}] - @${key}_dec`);
-                        p[`${key}_dec`] = val.decrement;
+                        sets.push(`${col} = ${col} - @${safeKey}_dec`);
+                        p[`${safeKey}_dec`] = val.decrement;
                         continue;
                     }
                     else if (val.set !== undefined) {
-                        sets.push(`[${key}] = @${key}_set`);
-                        p[`${key}_set`] = val.set;
+                        sets.push(`${col} = @${safeKey}_set`);
+                        p[`${safeKey}_set`] = val.set;
                         continue;
                     }
                 }
-                sets.push(`[${key}] = @${key}`);
-                p[key] = val;
+                sets.push(`${col} = @${safeKey}`);
+                p[safeKey] = val;
             }
             const whereParams = {};
-            const whereSql = parseWhere(this.modelName, finalArgs.where, whereParams, "w_");
+            const whereSql = this.orm.parseWhere(this.modelName, finalArgs.where, whereParams, "w_");
             Object.assign(p, whereParams);
             const sqlText = `UPDATE ${this.tableName} SET ${sets.join(", ")} ${whereSql ? `WHERE ${whereSql}` : ""}`;
-            const pool = await (await getAdapter()).getPool();
-            const request = new mssql_1.default.Request(pool);
-            for (const [key, value] of Object.entries(p)) {
-                request.input(key, value);
-            }
-            const result = await request.query(sqlText);
-            return { count: result.rowsAffected?.[0] || 0 };
+            const count = await (await getAdapter())._executeRaw(sqlText, p);
+            return { count };
         });
     }
     async delete(args) {
@@ -644,7 +471,7 @@ class TableClient {
             if (!existing)
                 throw new Error("Record not found to delete");
             const p = {};
-            const whereSql = parseWhere(this.modelName, finalArgs.where, p);
+            const whereSql = this.orm.parseWhere(this.modelName, finalArgs.where, p);
             const sqlText = `DELETE FROM ${this.tableName} WHERE ${whereSql}`;
             await this.executor(sqlText, p);
             return existing;
@@ -654,39 +481,37 @@ class TableClient {
         return this.orm._executeMiddleware({ model: this.modelName, action: 'deleteMany', args }, async (params) => {
             const { args: finalArgs } = params;
             const p = {};
-            const whereSql = parseWhere(this.modelName, finalArgs?.where, p);
+            const whereSql = this.orm.parseWhere(this.modelName, finalArgs?.where, p);
             const sqlText = `DELETE FROM ${this.tableName} ${whereSql ? `WHERE ${whereSql}` : ""}`;
-            const pool = await (await getAdapter()).getPool();
-            const request = new mssql_1.default.Request(pool);
-            for (const [key, value] of Object.entries(p)) {
-                request.input(key, value);
-            }
-            const result = await request.query(sqlText);
-            return { count: result.rowsAffected?.[0] || 0 };
+            const count = await (await getAdapter())._executeRaw(sqlText, p);
+            return { count };
         });
     }
     async vectorSearch(args) {
         return this.orm._executeMiddleware({ model: this.modelName, action: 'vectorSearch', args }, async (params) => {
             const { args: finalArgs } = params;
             const field = finalArgs.vectorField || "embedding";
-            const metric = finalArgs.distanceMetric || "cosine";
-            const elementType = finalArgs.vectorElementType || "float32";
-            const take = finalArgs.take || 10;
-            const dim = finalArgs.vector.length;
+            const METRICS = ["cosine", "euclidean", "dot"];
+            const ELEMENT_TYPES = ["float32", "float16", "uint8"];
+            const metric = METRICS.includes(finalArgs.distanceMetric) ? finalArgs.distanceMetric : "cosine";
+            const elementType = ELEMENT_TYPES.includes(finalArgs.vectorElementType) ? finalArgs.vectorElementType : "float32";
+            const take = (0, sql_utils_1.toNonNegativeInt)(finalArgs.take, 10);
+            const dim = Number(finalArgs.vector?.length) || 0;
             const vectorJson = JSON.stringify(finalArgs.vector);
+            const col = (0, sql_utils_1.quoteIdentifier)(field);
             try {
                 if (dim > 1998) {
                     throw new Error("Vector dimension exceeds SQL Server limit of 1998");
                 }
                 let sqlText = `SELECT TOP (${take}) *, `;
-                sqlText += `VECTOR_DISTANCE('${metric}', CAST([${field}] AS VECTOR(${dim}, ${elementType})), CAST(@query_vector AS VECTOR(${dim}, ${elementType}))) AS distance `;
+                sqlText += `VECTOR_DISTANCE('${metric}', CAST(${col} AS VECTOR(${dim}, ${elementType})), CAST(@query_vector AS VECTOR(${dim}, ${elementType}))) AS distance `;
                 sqlText += `FROM ${this.tableName} WITH (NOLOCK) `;
                 const p = {
                     query_vector: vectorJson
                 };
                 const whereClauses = [];
-                whereClauses.push(`[${field}] IS NOT NULL`);
-                const whereSql = parseWhere(this.modelName, finalArgs.where, p, "v_");
+                whereClauses.push(`${col} IS NOT NULL`);
+                const whereSql = this.orm.parseWhere(this.modelName, finalArgs.where, p, "v_");
                 if (whereSql) {
                     whereClauses.push(whereSql);
                 }
@@ -694,7 +519,7 @@ class TableClient {
                 sqlText += `ORDER BY distance ASC`;
                 const rows = await this.executor(sqlText, p);
                 if (finalArgs.include) {
-                    await resolveIncludes(this.modelName, rows, finalArgs.include, this.executor);
+                    await resolveIncludes(this.modelName, rows, finalArgs.include, this.executor, this.orm.metadata);
                 }
                 return rows;
             }
@@ -716,8 +541,8 @@ class TableClient {
                 let fallbackSql = `SELECT * FROM ${this.tableName} WITH (NOLOCK) `;
                 const fallbackParams = {};
                 const fallbackWhereClauses = [];
-                fallbackWhereClauses.push(`[${field}] IS NOT NULL`);
-                const fallbackWhereSql = parseWhere(this.modelName, finalArgs.where, fallbackParams, "vf_");
+                fallbackWhereClauses.push(`${col} IS NOT NULL`);
+                const fallbackWhereSql = this.orm.parseWhere(this.modelName, finalArgs.where, fallbackParams, "vf_");
                 if (fallbackWhereSql) {
                     fallbackWhereClauses.push(fallbackWhereSql);
                 }
@@ -754,7 +579,7 @@ class TableClient {
                     .sort((a, b) => a.distance - b.distance)
                     .slice(0, take);
                 if (finalArgs.include && results.length > 0) {
-                    await resolveIncludes(this.modelName, results, finalArgs.include, this.executor);
+                    await resolveIncludes(this.modelName, results, finalArgs.include, this.executor, this.orm.metadata);
                 }
                 return results;
             }
@@ -766,42 +591,10 @@ class TableClient {
             if (!finalArgs.data || finalArgs.data.length === 0)
                 return { count: 0 };
             try {
-                const pool = await (await getAdapter()).getPool();
-                const table = new mssql_1.default.Table(this.tableName);
-                const fields = an5Metadata_1.modelFields[this.modelName] || {};
+                const fields = this.orm.metadata.modelFields[this.modelName] || {};
                 const fieldNames = Object.keys(fields);
-                for (const col of fieldNames) {
-                    const fieldDef = fields[col];
-                    const rawType = fieldDef?.ts || 'string';
-                    const sqlType = fieldDef?.sql || 'NVARCHAR(MAX)';
-                    const isNullable = rawType.endsWith('?');
-                    const tsType = isNullable ? rawType.slice(0, -1) : rawType;
-                    // Map SQL Server type to mssql package type
-                    const sqlBase = sqlType.toUpperCase().split('(')[0];
-                    if (sqlBase === 'INT' || sqlBase === 'SMALLINT' || sqlBase === 'TINYINT') {
-                        table.columns.add(col, mssql_1.default.Int, { nullable: isNullable });
-                    }
-                    else if (sqlBase === 'BIGINT') {
-                        table.columns.add(col, mssql_1.default.BigInt, { nullable: isNullable });
-                    }
-                    else if (sqlBase === 'FLOAT' || sqlBase === 'REAL' || sqlBase === 'DECIMAL' || sqlBase === 'NUMERIC' || sqlBase === 'MONEY' || sqlBase === 'SMALLMONEY') {
-                        table.columns.add(col, mssql_1.default.Float, { nullable: isNullable });
-                    }
-                    else if (sqlBase === 'BIT') {
-                        table.columns.add(col, mssql_1.default.Bit, { nullable: isNullable });
-                    }
-                    else if (sqlBase === 'DATETIME' || sqlBase === 'DATETIME2' || sqlBase === 'SMALLDATETIME' || sqlBase === 'DATE' || sqlBase === 'TIME') {
-                        table.columns.add(col, mssql_1.default.DateTime, { nullable: isNullable });
-                    }
-                    else if (sqlBase === 'UNIQUEIDENTIFIER') {
-                        table.columns.add(col, mssql_1.default.UniqueIdentifier, { nullable: isNullable });
-                    }
-                    else {
-                        table.columns.add(col, mssql_1.default.NVarChar(mssql_1.default.MAX), { nullable: isNullable });
-                    }
-                }
                 const now = new Date();
-                for (const item of finalArgs.data) {
+                const rows = finalArgs.data.map((item) => {
                     const rowData = { ...item };
                     if (!rowData.id && fields.id?.ts === "string")
                         rowData.id = (0, crypto_1.randomUUID)();
@@ -809,17 +602,24 @@ class TableClient {
                         rowData.createdAt = now;
                     if (!rowData.updatedAt && fields.updatedAt)
                         rowData.updatedAt = now;
-                    const rowValues = fieldNames.map(col => {
-                        const v = rowData[col];
-                        if (v === undefined)
-                            return null;
-                        return v;
+                    return rowData;
+                });
+                const cols = fieldNames.filter(col => rows.some((r) => r[col] !== undefined));
+                if (cols.length === 0)
+                    throw new Error("No insertable columns");
+                const params = {};
+                const rowPlaceholders = [];
+                rows.forEach((row, rowIdx) => {
+                    const vals = cols.map(col => {
+                        const p = (0, sql_utils_1.sanitizeParamName)(`r${rowIdx}_${col}`);
+                        params[p] = row[col] ?? null;
+                        return `@${p}`;
                     });
-                    table.rows.add(...rowValues);
-                }
-                const request = new mssql_1.default.Request(pool);
-                await request.bulk(table);
-                return { count: finalArgs.data.length };
+                    rowPlaceholders.push(`(${vals.join(", ")})`);
+                });
+                const sqlText = `INSERT INTO ${this.tableName} (${cols.map(sql_utils_1.quoteIdentifier).join(", ")}) VALUES ${rowPlaceholders.join(", ")}`;
+                await (await getAdapter())._executeRaw(sqlText, params);
+                return { count: rows.length };
             }
             catch (err) {
                 logger_1.logger.warn(`Bulk insert failed, falling back to sequential inserts: ${err.message}`);
@@ -847,25 +647,25 @@ class TableClient {
             if (finalArgs._sum) {
                 resultObj._sum = {};
                 for (const key of Object.keys(finalArgs._sum)) {
-                    selects.push(`SUM(${key}) as sum_${key}`);
+                    selects.push(aggSelect("SUM", key));
                 }
             }
             if (finalArgs._avg) {
                 resultObj._avg = {};
                 for (const key of Object.keys(finalArgs._avg)) {
-                    selects.push(`AVG(${key}) as avg_${key}`);
+                    selects.push(aggSelect("AVG", key));
                 }
             }
             if (finalArgs._min) {
                 resultObj._min = {};
                 for (const key of Object.keys(finalArgs._min)) {
-                    selects.push(`MIN(${key}) as min_${key}`);
+                    selects.push(aggSelect("MIN", key));
                 }
             }
             if (finalArgs._max) {
                 resultObj._max = {};
                 for (const key of Object.keys(finalArgs._max)) {
-                    selects.push(`MAX(${key}) as max_${key}`);
+                    selects.push(aggSelect("MAX", key));
                 }
             }
             if (finalArgs._count) {
@@ -875,7 +675,7 @@ class TableClient {
                 }
                 else {
                     for (const key of Object.keys(finalArgs._count)) {
-                        selects.push(`COUNT(${key}) as count_${key}`);
+                        selects.push(aggSelect("COUNT", key));
                     }
                 }
             }
@@ -884,7 +684,7 @@ class TableClient {
             }
             let sqlText = `SELECT ${selects.join(", ")} FROM ${this.tableName} WITH (NOLOCK)`;
             const p = {};
-            const whereSql = parseWhere(this.modelName, finalArgs?.where, p);
+            const whereSql = this.orm.parseWhere(this.modelName, finalArgs?.where, p);
             if (whereSql) {
                 sqlText += ` WHERE ${whereSql}`;
             }
@@ -892,22 +692,22 @@ class TableClient {
             const row = rows[0] || {};
             if (finalArgs._sum) {
                 for (const key of Object.keys(finalArgs._sum)) {
-                    resultObj._sum[key] = row[`sum_${key}`] !== undefined ? row[`sum_${key}`] : null;
+                    resultObj._sum[key] = row[aggAlias("sum", key)] !== undefined ? row[aggAlias("sum", key)] : null;
                 }
             }
             if (finalArgs._avg) {
                 for (const key of Object.keys(finalArgs._avg)) {
-                    resultObj._avg[key] = row[`avg_${key}`] !== undefined ? row[`avg_${key}`] : null;
+                    resultObj._avg[key] = row[aggAlias("avg", key)] !== undefined ? row[aggAlias("avg", key)] : null;
                 }
             }
             if (finalArgs._min) {
                 for (const key of Object.keys(finalArgs._min)) {
-                    resultObj._min[key] = row[`min_${key}`] !== undefined ? row[`min_${key}`] : null;
+                    resultObj._min[key] = row[aggAlias("min", key)] !== undefined ? row[aggAlias("min", key)] : null;
                 }
             }
             if (finalArgs._max) {
                 for (const key of Object.keys(finalArgs._max)) {
-                    resultObj._max[key] = row[`max_${key}`] !== undefined ? row[`max_${key}`] : null;
+                    resultObj._max[key] = row[aggAlias("max", key)] !== undefined ? row[aggAlias("max", key)] : null;
                 }
             }
             if (finalArgs._count) {
@@ -916,7 +716,7 @@ class TableClient {
                 }
                 else {
                     for (const key of Object.keys(finalArgs._count)) {
-                        resultObj._count[key] = row[`count_${key}`] || 0;
+                        resultObj._count[key] = row[aggAlias("count", key)] || 0;
                     }
                 }
             }
@@ -930,44 +730,44 @@ class TableClient {
             if (byFields.length === 0) {
                 throw new Error("groupBy requires 'by' fields");
             }
-            const selects = [...byFields];
+            const selects = byFields.map((f) => (0, sql_utils_1.quoteIdentifier)(f));
             if (finalArgs._count) {
                 if (finalArgs._count === true || finalArgs._count._all) {
                     selects.push(`COUNT(*) as count_all`);
                 }
                 else {
                     for (const key of Object.keys(finalArgs._count)) {
-                        selects.push(`COUNT(${key}) as count_${key}`);
+                        selects.push(aggSelect("COUNT", key));
                     }
                 }
             }
             if (finalArgs._sum) {
                 for (const key of Object.keys(finalArgs._sum)) {
-                    selects.push(`SUM(${key}) as sum_${key}`);
+                    selects.push(aggSelect("SUM", key));
                 }
             }
             if (finalArgs._avg) {
                 for (const key of Object.keys(finalArgs._avg)) {
-                    selects.push(`AVG(${key}) as avg_${key}`);
+                    selects.push(aggSelect("AVG", key));
                 }
             }
             if (finalArgs._min) {
                 for (const key of Object.keys(finalArgs._min)) {
-                    selects.push(`MIN(${key}) as min_${key}`);
+                    selects.push(aggSelect("MIN", key));
                 }
             }
             if (finalArgs._max) {
                 for (const key of Object.keys(finalArgs._max)) {
-                    selects.push(`MAX(${key}) as max_${key}`);
+                    selects.push(aggSelect("MAX", key));
                 }
             }
             let sqlText = `SELECT ${selects.join(", ")} FROM ${this.tableName} WITH (NOLOCK)`;
             const p = {};
-            const whereSql = parseWhere(this.modelName, finalArgs?.where, p);
+            const whereSql = this.orm.parseWhere(this.modelName, finalArgs?.where, p);
             if (whereSql) {
                 sqlText += ` WHERE ${whereSql}`;
             }
-            sqlText += ` GROUP BY ${byFields.join(", ")}`;
+            sqlText += ` GROUP BY ${byFields.map((f) => (0, sql_utils_1.quoteIdentifier)(f)).join(", ")}`;
             const rows = await this.executor(sqlText, p);
             return rows.map((row) => {
                 const item = {};
@@ -981,32 +781,32 @@ class TableClient {
                     }
                     else {
                         for (const key of Object.keys(finalArgs._count)) {
-                            item._count[key] = row[`count_${key}`] || 0;
+                            item._count[key] = row[aggAlias("count", key)] || 0;
                         }
                     }
                 }
                 if (finalArgs._sum) {
                     item._sum = {};
                     for (const key of Object.keys(finalArgs._sum)) {
-                        item._sum[key] = row[`sum_${key}`] !== undefined ? row[`sum_${key}`] : null;
+                        item._sum[key] = row[aggAlias("sum", key)] !== undefined ? row[aggAlias("sum", key)] : null;
                     }
                 }
                 if (finalArgs._avg) {
                     item._avg = {};
                     for (const key of Object.keys(finalArgs._avg)) {
-                        item._avg[key] = row[`avg_${key}`] !== undefined ? row[`avg_${key}`] : null;
+                        item._avg[key] = row[aggAlias("avg", key)] !== undefined ? row[aggAlias("avg", key)] : null;
                     }
                 }
                 if (finalArgs._min) {
                     item._min = {};
                     for (const key of Object.keys(finalArgs._min)) {
-                        item._min[key] = row[`min_${key}`] !== undefined ? row[`min_${key}`] : null;
+                        item._min[key] = row[aggAlias("min", key)] !== undefined ? row[aggAlias("min", key)] : null;
                     }
                 }
                 if (finalArgs._max) {
                     item._max = {};
                     for (const key of Object.keys(finalArgs._max)) {
-                        item._max[key] = row[`max_${key}`] !== undefined ? row[`max_${key}`] : null;
+                        item._max[key] = row[aggAlias("max", key)] !== undefined ? row[aggAlias("max", key)] : null;
                     }
                 }
                 return item;
@@ -1021,39 +821,41 @@ class TableClient {
             const cleanCreate = { ...createData };
             const cleanUpdate = { ...updateData };
             for (const key of Object.keys(cleanCreate)) {
-                if (an5Metadata_1.relationMap[this.modelName]?.[key])
+                if (this.orm.metadata.relationMap[this.modelName]?.[key])
                     delete cleanCreate[key];
             }
             for (const key of Object.keys(cleanUpdate)) {
-                if (an5Metadata_1.relationMap[this.modelName]?.[key])
+                if (this.orm.metadata.relationMap[this.modelName]?.[key])
                     delete cleanUpdate[key];
             }
-            if (!cleanCreate.id && an5Metadata_1.modelFields[this.modelName]?.id?.ts === "string") {
+            if (!cleanCreate.id && this.orm.metadata.modelFields[this.modelName]?.id?.ts === "string") {
                 cleanCreate.id = (0, crypto_1.randomUUID)();
             }
             const now = new Date();
-            if (!cleanCreate.createdAt && an5Metadata_1.modelFields[this.modelName]?.createdAt)
+            if (!cleanCreate.createdAt && this.orm.metadata.modelFields[this.modelName]?.createdAt)
                 cleanCreate.createdAt = now;
-            if (!cleanCreate.updatedAt && an5Metadata_1.modelFields[this.modelName]?.updatedAt)
+            if (!cleanCreate.updatedAt && this.orm.metadata.modelFields[this.modelName]?.updatedAt)
                 cleanCreate.updatedAt = now;
-            if (!cleanUpdate.updatedAt && an5Metadata_1.modelFields[this.modelName]?.updatedAt)
+            if (!cleanUpdate.updatedAt && this.orm.metadata.modelFields[this.modelName]?.updatedAt)
                 cleanUpdate.updatedAt = now;
             const p = {};
-            const whereSql = parseWhere(this.modelName, where, p, "upw_");
+            const whereSql = this.orm.parseWhere(this.modelName, where, p, "upw_");
             const allKeys = Array.from(new Set([...Object.keys(cleanCreate), ...Object.keys(cleanUpdate)]));
+            const cParam = (k) => `c_${(0, sql_utils_1.sanitizeParamName)(k)}`;
+            const uParam = (k) => `u_${(0, sql_utils_1.sanitizeParamName)(k)}`;
             for (const k of allKeys) {
                 if (cleanCreate[k] !== undefined)
-                    p[`c_${k}`] = cleanCreate[k];
+                    p[cParam(k)] = cleanCreate[k];
                 if (cleanUpdate[k] !== undefined)
-                    p[`u_${k}`] = cleanUpdate[k];
+                    p[uParam(k)] = cleanUpdate[k];
             }
             const sourceSelect = allKeys.map(k => {
-                const val = cleanCreate[k] !== undefined ? `@c_${k}` : (cleanUpdate[k] !== undefined ? `@u_${k}` : "NULL");
-                return `${val} as [${k}]`;
+                const val = cleanCreate[k] !== undefined ? `@${cParam(k)}` : (cleanUpdate[k] !== undefined ? `@${uParam(k)}` : "NULL");
+                return `${val} as ${(0, sql_utils_1.quoteIdentifier)(k)}`;
             }).join(", ");
-            const updateSets = Object.keys(cleanUpdate).map(k => `target.[${k}] = source.[${k}]`).join(", ");
-            const insertCols = Object.keys(cleanCreate).map(k => `[${k}]`).join(", ");
-            const insertVals = Object.keys(cleanCreate).map(k => `source.[${k}]`).join(", ");
+            const updateSets = Object.keys(cleanUpdate).map(k => `target.${(0, sql_utils_1.quoteIdentifier)(k)} = source.${(0, sql_utils_1.quoteIdentifier)(k)}`).join(", ");
+            const insertCols = Object.keys(cleanCreate).map(k => (0, sql_utils_1.quoteIdentifier)(k)).join(", ");
+            const insertVals = Object.keys(cleanCreate).map(k => `source.${(0, sql_utils_1.quoteIdentifier)(k)}`).join(", ");
             // Note: This MERGE assumes the 'where' translates to a simple ON clause.
             // For complex 'where', parseWhere might return something not easily usable in ON.
             // We'll try to extract simple equality for ON if possible, or fallback to sequential.
@@ -1061,25 +863,25 @@ class TableClient {
                 if (typeof where[k] === 'object' && where[k] !== null && !(where[k] instanceof Date)) {
                     // Flatten unique object if needed
                     const inner = where[k];
-                    return Object.keys(inner).map(ik => `target.[${ik}] = @upw_${k}_${ik}`).join(" AND ");
+                    return Object.keys(inner).map(ik => `target.${(0, sql_utils_1.quoteIdentifier)(ik)} = @${(0, sql_utils_1.sanitizeParamName)(`upw_${k}_${ik}`)}`).join(" AND ");
                 }
-                return `target.[${k}] = @upw_${k}`;
+                return `target.${(0, sql_utils_1.quoteIdentifier)(k)} = @${(0, sql_utils_1.sanitizeParamName)(`upw_${k}`)}`;
             }).join(" AND ");
-            const sqlText = `
-        MERGE INTO ${this.tableName} WITH (HOLDLOCK) AS target
-        USING (SELECT ${sourceSelect}) AS source
-        ON (${onClause})
-        WHEN MATCHED THEN
-          UPDATE SET ${updateSets}
-        WHEN NOT MATCHED THEN
-          INSERT (${insertCols}) VALUES (${insertVals})
-        OUTPUT inserted.*;
+            const sqlText = `
+        MERGE INTO ${this.tableName} WITH (HOLDLOCK) AS target
+        USING (SELECT ${sourceSelect}) AS source
+        ON (${onClause})
+        WHEN MATCHED THEN
+          UPDATE SET ${updateSets}
+        WHEN NOT MATCHED THEN
+          INSERT (${insertCols}) VALUES (${insertVals})
+        OUTPUT inserted.*;
       `;
             try {
                 const rows = await this.executor(sqlText, p);
                 const result = rows[0];
                 if (include && result) {
-                    await resolveIncludes(this.modelName, [result], include, this.executor);
+                    await resolveIncludes(this.modelName, [result], include, this.executor, this.orm.metadata);
                 }
                 return result;
             }
@@ -1096,12 +898,12 @@ class TableClient {
         });
     }
 }
-function addNoLockToQuery(sql) {
+function addNoLockToQuery(sql, metadata) {
     // If it's not a SELECT query, don't modify it
     if (!/^\s*SELECT/i.test(sql)) {
         return sql;
     }
-    const tableNames = Object.values(an5Metadata_1.modelToTable);
+    const tableNames = Object.values(metadata.modelToTable);
     let modifiedSql = sql;
     for (const table of tableNames) {
         const escapedTable = table.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
@@ -1130,11 +932,32 @@ function addNoLockToQuery(sql) {
     }
     return modifiedSql;
 }
+// Lazy-load generated schema metadata from the ORM's own generated copy so
+// `new An5ORM()` resolves schema models out of the box without the core ever
+// importing from the generated client package (client is generated FROM the ORM).
+let autoMetadata = null;
+function loadAutoMetadata() {
+    if (autoMetadata)
+        return autoMetadata;
+    try {
+        const m = require("./an5Metadata");
+        autoMetadata = {
+            modelToTable: m.modelToTable || {},
+            relationMap: m.relationMap || {},
+            modelFields: m.modelFields || {},
+        };
+    }
+    catch {
+        autoMetadata = metadata_1.DEFAULT_METADATA;
+    }
+    return autoMetadata;
+}
 // Proxied AN5 ORM client class
 class An5ORM {
-    constructor(customExecutor) {
+    constructor(customExecutor, metadata) {
         this.customExecutor = customExecutor;
         this.middlewares = [];
+        this.metadata = metadata ?? loadAutoMetadata();
         // Add default logging middleware
         this.$use(async (params, next) => {
             const start = Date.now();
@@ -1180,7 +1003,7 @@ class An5ORM {
                 }
                 if (!(prop in target) && typeof prop === "string" && !prop.startsWith("_")) {
                     // Resolve modelName in camelCase and map to table name
-                    const tableName = an5Metadata_1.modelToTable[prop];
+                    const tableName = target.metadata.modelToTable[prop];
                     if (tableName) {
                         target[prop] = new TableClient(prop, tableName, target.customExecutor || execQuery, target // Pass ORM instance for middleware access
                         );
@@ -1193,6 +1016,12 @@ class An5ORM {
     $use(middleware) {
         this.middlewares.push(middleware);
     }
+    parseWhere(modelName, where, params, prefix = "") {
+        return (0, sql_utils_1.parseWhere)(modelName, where, params, prefix, {
+            relationMap: this.metadata.relationMap,
+            modelToTable: this.metadata.modelToTable,
+        });
+    }
     async _executeMiddleware(params, finalAction) {
         let index = -1;
         const dispatch = async (i, currentParams) => {
@@ -1243,7 +1072,7 @@ class An5ORM {
         else {
             throw new Error("Invalid query format for $queryRaw");
         }
-        queryText = addNoLockToQuery(queryText);
+        queryText = addNoLockToQuery(queryText, this.metadata);
         return executor(queryText, params);
     }
     async $queryRawUnsafe(queryText, ...values) {
@@ -1255,7 +1084,7 @@ class An5ORM {
                 params[paramName] = val;
             });
         }
-        const modifiedQueryText = addNoLockToQuery(queryText);
+        const modifiedQueryText = addNoLockToQuery(queryText, this.metadata);
         const result = await executor(modifiedQueryText, params);
         return result;
     }
@@ -1286,7 +1115,7 @@ class An5ORM {
         else {
             throw new Error("Invalid query format for $executeRaw");
         }
-        queryText = addNoLockToQuery(queryText);
+        queryText = addNoLockToQuery(queryText, this.metadata);
         const result = (await executor(queryText, params));
         return result.rowsAffected?.[0] || 0;
     }
@@ -1299,7 +1128,7 @@ class An5ORM {
                 params[paramName] = val;
             });
         }
-        const modifiedQueryText = addNoLockToQuery(queryText);
+        const modifiedQueryText = addNoLockToQuery(queryText, this.metadata);
         const result = (await executor(modifiedQueryText, params));
         return result.rowsAffected?.[0] || 0;
     }
@@ -1307,42 +1136,18 @@ class An5ORM {
         if (Array.isArray(fn)) {
             return Promise.all(fn);
         }
-        const pool = await getDbPool();
-        const transaction = new mssql_1.default.Transaction(pool);
-        await transaction.begin();
-        logger_1.logger.info("Database Transaction Initiated");
-        const txExecutor = async (queryText, params) => {
-            const request = new mssql_1.default.Request(transaction);
-            if (params) {
-                for (const [key, value] of Object.entries(params)) {
-                    request.input(key, value);
-                }
-            }
-            const result = await request.query(queryText);
-            const recordset = (result.recordset || []);
-            recordset.rowsAffected = result.rowsAffected;
-            return recordset;
-        };
-        const txClient = new An5ORM(txExecutor);
-        try {
-            const result = await fn(txClient);
-            await transaction.commit();
-            logger_1.logger.info("Database Transaction Committed Successfully");
-            return result;
-        }
-        catch (err) {
-            try {
-                await transaction.rollback();
-                logger_1.logger.warn("Database Transaction Rolled Back");
-            }
-            catch (rollbackErr) {
-                logger_1.logger.error("Failed to rollback database transaction", rollbackErr);
-            }
-            throw err;
-        }
+        const a = await getAdapter();
+        return a.$transaction(async (tx) => {
+            const txExecutor = async (queryText, params) => {
+                const rows = await tx.exec(queryText, params);
+                return rows;
+            };
+            const txClient = new An5ORM(txExecutor, this.metadata);
+            return fn(txClient);
+        }, options);
     }
 }
 exports.An5ORM = An5ORM;
 exports.an5Orm = new An5ORM();
 exports.default = exports.an5Orm;
-//# sourceMappingURL=an5Orm.js.map
+//# sourceMappingURL=an5Orm.js.map