@an5/orm 1.0.7 → 1.0.9

package/dist/an5Orm.js

@@ -1,205 +1,224 @@
 "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");
+exports.an5Orm = exports.An5ORM = exports.ViewClient = exports.TableClient = void 0;
+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.toLowerCase(), 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;
 }
-async function execQuery(queryText, params) {
+const execQuery = Object.assign(async (queryText, params) => {
     const a = await getAdapter();
     return a.exec(queryText, params);
+}, {
+    executeRaw: async (queryText, params) => {
+        const a = await getAdapter();
+        return a._executeRaw(queryText, params);
+    },
+    transaction: async (fn, options) => {
+        const a = await getAdapter();
+        return a.$transaction(async (tx) => fn(executorFromAdapterLike(tx)), options);
+    },
+    beginTransaction: async () => {
+        const a = await getAdapter();
+        if (typeof a.$begin !== "function") {
+            throw new Error("Interactive transactions require an adapter with $begin support");
+        }
+        const tx = await a.$begin();
+        return {
+            executor: executorFromAdapterLike(tx),
+            commit: () => tx.$commit(),
+            rollback: () => tx.$rollback(),
+        };
+    },
+});
+function normalizeAffectedCount(result) {
+    if (typeof result === "number")
+        return result;
+    if (!result)
+        return 0;
+    if (Array.isArray(result.rowsAffected))
+        return Number(result.rowsAffected[0] ?? 0);
+    if (typeof result.rowsAffected === "number")
+        return result.rowsAffected;
+    if (typeof result.count === "number")
+        return result.count;
+    if (Array.isArray(result) && result.length === 1)
+        return normalizeAffectedCount(result[0]);
+    return 0;
 }
-function parseWhere(modelName, where, params, prefix = "") {
-    if (!where)
-        return "";
-    const conditions = [];
-    const cleanWhere = {};
+const FILTER_OPERATOR_KEYS = new Set(["in", "notIn", "contains", "startsWith", "endsWith", "not", "gte", "lte", "gt", "lt"]);
+function executorFromAdapterLike(adapterLike) {
+    return Object.assign(async (queryText, params) => {
+        return adapterLike.exec(queryText, params);
+    }, {
+        executeRaw: async (queryText, params) => {
+            if (typeof adapterLike._executeRaw === "function") {
+                return adapterLike._executeRaw(queryText, params);
+            }
+            if (typeof adapterLike.executeRaw === "function") {
+                return adapterLike.executeRaw(queryText, params);
+            }
+            return normalizeAffectedCount(await adapterLike.exec(queryText, params));
+        },
+    });
+}
+function flattenSimpleEqualityWhere(where) {
+    if (!where || typeof where !== "object" || where instanceof Date || Array.isArray(where)) {
+        return null;
+    }
+    const flat = {};
     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);
+        if (value === null || value === undefined || Array.isArray(value))
+            return null;
+        if (value instanceof Date || typeof value !== "object") {
+            flat[key] = value;
+            continue;
         }
-        else {
-            cleanWhere[key] = value;
+        if (!key.includes("_"))
+            return null;
+        for (const [innerKey, innerValue] of Object.entries(value)) {
+            if (FILTER_OPERATOR_KEYS.has(innerKey))
+                return null;
+            if (innerValue === null || innerValue === undefined || (typeof innerValue === "object" && !(innerValue instanceof Date))) {
+                return null;
+            }
+            flat[innerKey] = innerValue;
         }
     }
-    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 ")})`);
+    return Object.keys(flat).length > 0 ? flat : null;
+}
+function asArray(value) {
+    if (value === undefined)
+        return [];
+    return Array.isArray(value) ? value : [value];
+}
+function hasOwn(obj, key) {
+    return !!obj && Object.prototype.hasOwnProperty.call(obj, key);
+}
+function appendUpdateSet(sets, params, key, val) {
+    const col = (0, sql_utils_1.quoteIdentifier)(key);
+    const safeKey = (0, sql_utils_1.sanitizeParamName)(key);
+    if (val && typeof val === "object" && !(val instanceof Date)) {
+        const ops = [
+            ['increment', '+'],
+            ['decrement', '-'],
+            ['multiply', '*'],
+            ['divide', '/'],
+        ];
+        for (const [opKey, symbol] of ops) {
+            if (val[opKey] !== undefined) {
+                const paramName = `${safeKey}_${opKey.slice(0, 3)}`;
+                sets.push(`${col} = ${col} ${symbol} @${paramName}`);
+                params[paramName] = val[opKey];
+                return;
             }
         }
-        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 ")})`);
-            }
+        if (val.set !== undefined) {
+            const paramName = `${safeKey}_set`;
+            sets.push(`${col} = @${paramName}`);
+            params[paramName] = val.set;
+            return;
         }
-        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";
-                    }
+    }
+    sets.push(`${col} = @${safeKey}`);
+    params[safeKey] = val;
+}
+function normalizeByFields(by) {
+    if (typeof by === "string")
+        return [by];
+    return Array.isArray(by) ? by.filter((field) => typeof field === "string" && field.length > 0) : [];
+}
+function selectedAggregateFields(fields) {
+    if (!fields || typeof fields !== "object")
+        return [];
+    return Object.keys(fields).filter((key) => fields[key]);
+}
+function aggregateExpression(kind, field) {
+    const upper = kind.toUpperCase();
+    if (upper === "COUNT" && field === "_all")
+        return "COUNT(*)";
+    return `${upper}(${(0, sql_utils_1.quoteIdentifier)(field)})`;
+}
+function addHavingPredicate(conditions, params, expr, paramBase, filter) {
+    if (filter && typeof filter === "object" && !(filter instanceof Date)) {
+        for (const [op, value] of Object.entries(filter)) {
+            const p = (0, sql_utils_1.sanitizeParamName)(`having_${paramBase}_${op}`);
+            if (op === "equals") {
+                conditions.push(`${expr} = @${p}`);
+                params[p] = value;
+            }
+            else if (op === "gt" || op === "gte" || op === "lt" || op === "lte") {
+                const symbol = op === "gt" ? ">" : op === "gte" ? ">=" : op === "lt" ? "<" : "<=";
+                conditions.push(`${expr} ${symbol} @${p}`);
+                params[p] = value;
+            }
+            else if (op === "not") {
+                if (value && typeof value === "object" && !(value instanceof Date)) {
+                    const nested = [];
+                    addHavingPredicate(nested, params, expr, `${paramBase}_not`, value);
+                    if (nested.length > 0)
+                        conditions.push(`NOT (${nested.join(" AND ")})`);
                 }
-                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 {
+                    conditions.push(`${expr} <> @${p}`);
+                    params[p] = value;
                 }
             }
-            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 ((op === "in" || op === "notIn") && Array.isArray(value)) {
+                if (value.length === 0) {
+                    conditions.push(op === "in" ? "1 = 0" : "1 = 1");
                 }
                 else {
-                    if (value === null) {
-                        conditions.push(`${key} IS NULL`);
-                    }
-                    else {
-                        conditions.push(`${key} = @${paramName}`);
-                        params[paramName] = value;
-                    }
+                    const placeholders = value.map((item, idx) => {
+                        const itemParam = (0, sql_utils_1.sanitizeParamName)(`${p}_${idx}`);
+                        params[itemParam] = item;
+                        return `@${itemParam}`;
+                    });
+                    conditions.push(`${expr} ${op === "in" ? "IN" : "NOT IN"} (${placeholders.join(", ")})`);
                 }
             }
         }
+        return;
     }
-    return conditions.join(" AND ");
+    const p = (0, sql_utils_1.sanitizeParamName)(`having_${paramBase}`);
+    conditions.push(`${expr} = @${p}`);
+    params[p] = filter;
 }
-function buildOrderBy(orderBy) {
-    if (!orderBy)
+function buildHavingSql(having, params) {
+    if (!having || typeof having !== "object")
         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}`);
-            }
+    const conditions = [];
+    const aggregateKeys = {
+        _count: "COUNT",
+        _sum: "SUM",
+        _avg: "AVG",
+        _min: "MIN",
+        _max: "MAX",
+    };
+    for (const [key, sqlFn] of Object.entries(aggregateKeys)) {
+        const fields = having[key];
+        if (!fields || typeof fields !== "object")
+            continue;
+        for (const [field, filter] of Object.entries(fields)) {
+            addHavingPredicate(conditions, params, aggregateExpression(sqlFn, field), `${key}_${field}`, filter);
         }
     }
-    return orderClauses.length > 0 ? ` ORDER BY ` + orderClauses.join(", ") : "";
+    return conditions.length > 0 ? conditions.join(" AND ") : "";
 }
 function projectFields(row, select) {
     if (!row || !select)
@@ -215,11 +234,57 @@ function projectFields(row, select) {
     }
     return projected;
 }
+function collectRelationSelections(modelName, select, metadata) {
+    if (!select || typeof select !== "object")
+        return undefined;
+    const modelRelations = metadata.relationMap[modelName] || {};
+    const relationSelections = {};
+    for (const [key, value] of Object.entries(select)) {
+        if (!value)
+            continue;
+        if (key === "_count" || modelRelations[key]) {
+            relationSelections[key] = value;
+        }
+    }
+    return Object.keys(relationSelections).length > 0 ? relationSelections : undefined;
+}
+function mergeIncludes(primary, secondary) {
+    if (!primary)
+        return secondary;
+    if (!secondary)
+        return primary;
+    return { ...secondary, ...primary };
+}
+function relationOrderClause(orderBy, fallbackKey) {
+    const sql = (0, sql_utils_1.buildOrderBy)(orderBy);
+    return sql ? sql.replace(/^\s*ORDER\s+BY\s+/i, "") : `${(0, sql_utils_1.quoteIdentifier)(fallbackKey)} ASC`;
+}
+function requiredRelationKeys(modelName, include, metadata) {
+    if (!include || typeof include !== "object")
+        return [];
+    const modelRelations = metadata.relationMap[modelName] || {};
+    const keys = new Set();
+    for (const [key, value] of Object.entries(include)) {
+        if (!value)
+            continue;
+        const relation = modelRelations[key];
+        if (!relation) {
+            if (key === "_count") {
+                for (const rel of Object.values(modelRelations)) {
+                    keys.add(rel.localKey);
+                }
+            }
+            continue;
+        }
+        keys.add(relation.relationType === "one" ? relation.foreignKey : relation.localKey);
+    }
+    return Array.from(keys);
+}
 // 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)) {
@@ -227,22 +292,24 @@ async function resolveIncludes(modelName, rows, include, executor) {
             continue;
         const relation = modelRelations[key];
         if (!relation) {
-            if (key === "_count" && value && typeof value === "object") {
-                const countFields = Object.keys(value.select || {});
+            if (key === "_count" && value) {
+                const countFields = value === true
+                    ? Object.keys(modelRelations)
+                    : Object.keys(value.select || {}).filter((field) => value.select[field]);
                 for (const countField of countFields) {
                     const rel = modelRelations[countField];
                     if (rel) {
-                        const relTable = an5Metadata_1.modelToTable[rel.modelName];
+                        const relTable = (0, sql_utils_1.quoteTableIdentifier)(metadata.modelToTable[rel.modelName] || 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 
+              SELECT ${(0, sql_utils_1.quoteIdentifier)(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}
+              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 +325,7 @@ async function resolveIncludes(modelName, rows, include, executor) {
             }
             continue;
         }
-        const relTable = an5Metadata_1.modelToTable[relation.modelName];
+        const relTable = (0, sql_utils_1.quoteTableIdentifier)(metadata.modelToTable[relation.modelName] || 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;
@@ -269,43 +336,77 @@ async function resolveIncludes(modelName, rows, include, executor) {
         }
         const uniqueKeys = Array.from(new Set(keys));
         let relCols = "*";
+        const nestedInclude = value && typeof value === "object"
+            ? mergeIncludes(value.include, collectRelationSelections(relation.modelName, value.select, metadata))
+            : undefined;
         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}]`);
+                for (const requiredKey of [searchKey, ...requiredRelationKeys(relation.modelName, nestedInclude, metadata)]) {
+                    const quotedRequiredKey = (0, sql_utils_1.quoteIdentifier)(requiredKey);
+                    if (!selectedSubCols.includes(quotedRequiredKey)) {
+                        selectedSubCols.push(quotedRequiredKey);
+                    }
                 }
                 relCols = selectedSubCols.join(", ");
             }
         }
-        let sqlText = `SELECT ${relCols} FROM ${relTable} WITH (NOLOCK) WHERE ${searchKey} IN (${uniqueKeys.map((_, i) => `@k_${i}`).join(", ")})`;
+        const filters = [`${(0, sql_utils_1.quoteIdentifier)(searchKey)} IN (${uniqueKeys.map((_, i) => `@k_${i}`).join(", ")})`];
+        let sqlText = "";
         const subParams = {};
         uniqueKeys.forEach((k, i) => { subParams[`k_${i}`] = k; });
+        let subArgs = undefined;
         if (value && typeof value === "object") {
-            const subArgs = value;
-            if (subArgs.orderBy) {
-                sqlText += buildOrderBy(subArgs.orderBy);
+            subArgs = value;
+            const subWhereSql = (0, sql_utils_1.parseWhere)(relation.modelName, subArgs.where, subParams, `rel_${key}_`, {
+                relationMap: metadata.relationMap,
+                modelToTable: metadata.modelToTable,
+            });
+            if (subWhereSql) {
+                filters.push(subWhereSql);
             }
         }
-        const relatedRows = await executor(sqlText, subParams);
-        if (value && typeof value === "object" && value.select) {
-            relatedRows.forEach((r, idx) => {
-                relatedRows[idx] = projectFields(r, value.select);
-            });
+        const hasRelationPagination = isMany && subArgs && (subArgs.take !== undefined || subArgs.skip !== undefined);
+        if (hasRelationPagination) {
+            const rn = (0, sql_utils_1.quoteIdentifier)("__an5_rn");
+            const skip = (0, sql_utils_1.toNonNegativeInt)(subArgs.skip);
+            const take = subArgs.take !== undefined ? (0, sql_utils_1.toNonNegativeInt)(subArgs.take, 1) : undefined;
+            const whereSql = filters.join(" AND ");
+            sqlText = `SELECT * FROM (
+        SELECT ${relCols}, ROW_NUMBER() OVER (PARTITION BY ${(0, sql_utils_1.quoteIdentifier)(searchKey)} ORDER BY ${relationOrderClause(subArgs.orderBy, searchKey)}) AS ${rn}
+        FROM ${relTable} WITH (NOLOCK)
+        WHERE ${whereSql}
+      ) AS [an5_rel]
+      WHERE ${rn} > ${skip}`;
+            if (take !== undefined) {
+                sqlText += ` AND ${rn} <= ${skip + take}`;
+            }
+            sqlText += ` ORDER BY ${(0, sql_utils_1.quoteIdentifier)(searchKey)}, ${rn}`;
         }
-        if (value && typeof value === "object" && value.include) {
-            await resolveIncludes(relation.modelName, relatedRows, value.include, executor);
+        else {
+            sqlText = `SELECT ${relCols} FROM ${relTable} WITH (NOLOCK) WHERE ${filters.join(" AND ")}`;
+            if (subArgs?.orderBy) {
+                sqlText += (0, sql_utils_1.buildOrderBy)(subArgs.orderBy);
+            }
+        }
+        const relatedRows = await executor(sqlText, subParams);
+        relatedRows.forEach((r) => { delete r.__an5_rn; });
+        if (nestedInclude) {
+            await resolveIncludes(relation.modelName, relatedRows, nestedInclude, executor, metadata);
         }
+        const outputRows = value && typeof value === "object" && value.select
+            ? relatedRows.map((r) => projectFields(r, value.select))
+            : relatedRows;
         const groupMap = new Map();
-        relatedRows.forEach((r) => {
+        relatedRows.forEach((r, idx) => {
             const k = r[searchKey];
             if (!groupMap.has(k))
                 groupMap.set(k, []);
-            groupMap.get(k).push(r);
+            groupMap.get(k).push(outputRows[idx]);
         });
         rows.forEach(r => {
             const k = r[matchKey];
@@ -323,56 +424,69 @@ async function resolveIncludes(modelName, rows, include, executor) {
 class TableClient {
     constructor(modelName, tableName, executor, orm) {
         this.modelName = modelName;
-        this.tableName = tableName;
         this.executor = executor;
         this.orm = orm;
+        this.tableName = (0, sql_utils_1.quoteTableIdentifier)(tableName);
+    }
+    async executeRaw(queryText, params) {
+        if (this.executor.executeRaw) {
+            return this.executor.executeRaw(queryText, params);
+        }
+        return normalizeAffectedCount(await this.executor(queryText, params));
     }
     async findMany(args) {
         return this.orm._executeMiddleware({ model: this.modelName, action: 'findMany', args }, async (params) => {
             const { args: finalArgs } = params;
             const hasSkip = finalArgs?.skip !== undefined && finalArgs?.skip !== null;
+            const selectedRelations = collectRelationSelections(this.modelName, finalArgs?.select, this.orm.metadata);
+            const include = mergeIncludes(finalArgs?.include, selectedRelations);
             let cols = "*";
             if (finalArgs?.select) {
-                const modelRelations = an5Metadata_1.relationMap[this.modelName] || {};
-                const selectedCols = Object.keys(finalArgs.select)
-                    .filter(k => finalArgs.select[k] && !modelRelations[k])
-                    .map(k => `[${k}]`);
+                const modelRelations = this.orm.metadata.relationMap[this.modelName] || {};
+                const selectedColNames = Object.keys(finalArgs.select)
+                    .filter(k => finalArgs.select[k] && !modelRelations[k] && k !== "_count");
+                for (const key of requiredRelationKeys(this.modelName, include, this.orm.metadata)) {
+                    if (!selectedColNames.includes(key)) {
+                        selectedColNames.push(key);
+                    }
+                }
+                const selectedCols = selectedColNames.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);
+            if (include) {
+                await resolveIncludes(this.modelName, rows, include, this.executor, this.orm.metadata);
+            }
             if (finalArgs?.select) {
                 rows.forEach((r, idx) => {
                     rows[idx] = projectFields(r, finalArgs.select);
                 });
             }
-            if (finalArgs?.include) {
-                await resolveIncludes(this.modelName, rows, finalArgs.include, this.executor);
-            }
             return rows;
         });
     }
@@ -392,7 +506,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}`;
             }
@@ -400,8 +514,14 @@ class TableClient {
             return result[0]?.count || 0;
         });
     }
+    scopedRelationWhere(relation, parentId, where) {
+        const parentWhere = { [relation.foreignKey]: parentId };
+        if (!where || Object.keys(where).length === 0)
+            return parentWhere;
+        return { AND: [where, parentWhere] };
+    }
     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))
@@ -410,32 +530,72 @@ class TableClient {
             if (!relTableClient)
                 continue;
             const nestedOps = value;
+            if (relation.relationType !== "many")
+                continue;
+            if (hasOwn(nestedOps, "set")) {
+                await relTableClient.updateMany({
+                    where: { [relation.foreignKey]: parentId },
+                    data: { [relation.foreignKey]: null },
+                });
+                for (const item of asArray(nestedOps.set)) {
+                    await relTableClient.update({
+                        where: item,
+                        data: { [relation.foreignKey]: parentId }
+                    });
+                }
+            }
             // Handle deleteMany (an5Orm-style)
-            if (nestedOps.deleteMany) {
+            if (hasOwn(nestedOps, "deleteMany")) {
                 const deleteWhere = Array.isArray(nestedOps.deleteMany) ? { OR: nestedOps.deleteMany } : nestedOps.deleteMany;
                 // Scope deletion to parent
-                const scopedWhere = { ...deleteWhere, [relation.foreignKey]: parentId };
+                const scopedWhere = this.scopedRelationWhere(relation, parentId, deleteWhere);
                 await relTableClient.deleteMany({ where: scopedWhere });
             }
+            if (hasOwn(nestedOps, "delete")) {
+                const deleteWhere = Array.isArray(nestedOps.delete) ? { OR: nestedOps.delete } : nestedOps.delete;
+                await relTableClient.deleteMany({
+                    where: this.scopedRelationWhere(relation, parentId, deleteWhere),
+                });
+            }
+            if (hasOwn(nestedOps, "disconnect")) {
+                const disconnectWhere = Array.isArray(nestedOps.disconnect) ? { OR: nestedOps.disconnect } : nestedOps.disconnect;
+                await relTableClient.updateMany({
+                    where: this.scopedRelationWhere(relation, parentId, disconnectWhere),
+                    data: { [relation.foreignKey]: null },
+                });
+            }
+            if (hasOwn(nestedOps, "update")) {
+                for (const item of asArray(nestedOps.update)) {
+                    await relTableClient.update({
+                        where: this.scopedRelationWhere(relation, parentId, item.where),
+                        data: item.data,
+                    });
+                }
+            }
+            if (hasOwn(nestedOps, "upsert")) {
+                for (const item of asArray(nestedOps.upsert)) {
+                    await relTableClient.upsert({
+                        where: this.scopedRelationWhere(relation, parentId, item.where),
+                        create: { ...item.create, [relation.foreignKey]: parentId },
+                        update: item.update,
+                    });
+                }
+            }
             // Handle create
-            if (nestedOps.create) {
-                const createItems = Array.isArray(nestedOps.create) ? nestedOps.create : [nestedOps.create];
-                for (const item of createItems) {
+            if (hasOwn(nestedOps, "create")) {
+                for (const item of asArray(nestedOps.create)) {
                     // Inject parent ID
                     const itemData = { ...item, [relation.foreignKey]: parentId };
                     await relTableClient.create({ data: itemData });
                 }
             }
             // Handle connect
-            if (nestedOps.connect) {
-                const connectItems = Array.isArray(nestedOps.connect) ? nestedOps.connect : [nestedOps.connect];
-                for (const item of connectItems) {
-                    if (relation.relationType === "many") {
-                        await relTableClient.update({
-                            where: item,
-                            data: { [relation.foreignKey]: parentId }
-                        });
-                    }
+            if (hasOwn(nestedOps, "connect")) {
+                for (const item of asArray(nestedOps.connect)) {
+                    await relTableClient.update({
+                        where: item,
+                        data: { [relation.foreignKey]: parentId }
+                    });
                 }
             }
         }
@@ -447,35 +607,39 @@ 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)) {
                     const rel = modelRelations[key];
-                    if (rel && rel.relationType === "one" && value.connect) {
-                        const connectObj = value.connect;
-                        const targetId = connectObj.id || Object.values(connectObj)[0];
+                    const nestedValue = value && typeof value === "object" ? value : {};
+                    if (rel && rel.relationType === "one" && (nestedValue.connect || nestedValue.set)) {
+                        const connectObj = nestedValue.connect || nestedValue.set;
+                        const targetId = connectObj[rel.localKey] || connectObj.id || Object.values(connectObj)[0];
                         data[rel.foreignKey] = targetId;
                     }
                 }
                 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 +664,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 +689,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];
@@ -541,46 +705,35 @@ class TableClient {
             // Handle one-relation connect where we hold the FK
             for (const [key, value] of Object.entries(nestedData)) {
                 const rel = modelRelations[key];
-                if (rel && rel.relationType === "one" && value.connect) {
-                    const connectObj = value.connect;
-                    const targetId = connectObj.id || Object.values(connectObj)[0];
-                    data[rel.foreignKey] = targetId;
+                const nestedValue = value && typeof value === "object" ? value : {};
+                if (rel && rel.relationType === "one") {
+                    if (nestedValue.connect || nestedValue.set) {
+                        const connectObj = nestedValue.connect || nestedValue.set;
+                        const targetId = connectObj[rel.localKey] || connectObj.id || Object.values(connectObj)[0];
+                        data[rel.foreignKey] = targetId;
+                    }
+                    else if (hasOwn(nestedValue, "disconnect") || value === null) {
+                        data[rel.foreignKey] = null;
+                    }
                 }
             }
             const sets = [];
             const p = {};
             for (const key of Object.keys(data)) {
                 const val = data[key];
-                if (val && typeof val === "object" && !(val instanceof Date)) {
-                    if (val.increment !== undefined) {
-                        sets.push(`[${key}] = [${key}] + @${key}_inc`);
-                        p[`${key}_inc`] = val.increment;
-                        continue;
-                    }
-                    else if (val.decrement !== undefined) {
-                        sets.push(`[${key}] = [${key}] - @${key}_dec`);
-                        p[`${key}_dec`] = val.decrement;
-                        continue;
-                    }
-                    else if (val.set !== undefined) {
-                        sets.push(`[${key}] = @${key}_set`);
-                        p[`${key}_set`] = val.set;
-                        continue;
-                    }
-                }
-                sets.push(`[${key}] = @${key}`);
-                p[key] = val;
+                appendUpdateSet(sets, p, key, 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);
-            // Get parent ID for nested writes
             const existing = await this.findUnique({ where: finalArgs.where });
             if (!existing)
                 throw new Error("Record not found to update");
             const parentId = existing.id;
+            if (sets.length > 0) {
+                const sqlText = `UPDATE ${this.tableName} SET ${sets.join(", ")} WHERE ${whereSql}`;
+                await this.executor(sqlText, p);
+            }
             // Process nested writes
             await this.handleNestedWrites(nestedData, parentId);
             const updated = await this.findUnique({ where: finalArgs.where, include: finalArgs.include });
@@ -594,7 +747,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 +755,19 @@ 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;
-                if (val && typeof val === "object" && !(val instanceof Date)) {
-                    if (val.increment !== undefined) {
-                        sets.push(`[${key}] = [${key}] + @${key}_inc`);
-                        p[`${key}_inc`] = val.increment;
-                        continue;
-                    }
-                    else if (val.decrement !== undefined) {
-                        sets.push(`[${key}] = [${key}] - @${key}_dec`);
-                        p[`${key}_dec`] = val.decrement;
-                        continue;
-                    }
-                    else if (val.set !== undefined) {
-                        sets.push(`[${key}] = @${key}_set`);
-                        p[`${key}_set`] = val.set;
-                        continue;
-                    }
-                }
-                sets.push(`[${key}] = @${key}`);
-                p[key] = val;
+                appendUpdateSet(sets, p, key, val);
+            }
+            if (sets.length === 0) {
+                return { count: 0 };
             }
             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 this.executeRaw(sqlText, p);
+            return { count };
         });
     }
     async delete(args) {
@@ -644,7 +777,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 +787,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 this.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,12 +825,12 @@ 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;
             }
             catch (err) {
-                const msg = String(err.message || "").toLowerCase();
+                const msg = (String(err?.message || "") + " " + String(err?.originalError?.message || "")).toLowerCase();
                 // Handle specific float16 to float32 conversion error by retrying with float16
                 if (msg.includes("float16") && msg.includes("float32") && msg.includes("conversion") && !finalArgs.vectorElementType) {
                     logger_1.logger.info(`Detected float16 vector storage. Retrying vectorSearch with float16 element type.`);
@@ -707,8 +838,17 @@ class TableClient {
                 }
                 const isUnsupported = msg.includes("vector_distance") ||
                     msg.includes("type vector") ||
+                    msg.includes("type \"vector\"") ||
+                    msg.includes("data type vector") ||
+                    msg.includes("incorrect syntax") ||
+                    msg.includes("syntax near") ||
+                    msg.includes("not a recognized built-in function") ||
+                    msg.includes("not a defined system type") ||
                     msg.includes("limit of 1998") ||
-                    err?.number === 195;
+                    err?.number === 195 ||
+                    err?.number === 102 ||
+                    err?.number === 319 ||
+                    err?.originalError?.number === 319;
                 if (!isUnsupported) {
                     throw err;
                 }
@@ -716,8 +856,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 +894,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 +906,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 +917,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 this.executeRaw(sqlText, params);
+                return { count: rows.length };
             }
             catch (err) {
                 logger_1.logger.warn(`Bulk insert failed, falling back to sequential inserts: ${err.message}`);
@@ -846,26 +961,26 @@ class TableClient {
             const resultObj = {};
             if (finalArgs._sum) {
                 resultObj._sum = {};
-                for (const key of Object.keys(finalArgs._sum)) {
-                    selects.push(`SUM(${key}) as sum_${key}`);
+                for (const key of selectedAggregateFields(finalArgs._sum)) {
+                    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}`);
+                for (const key of selectedAggregateFields(finalArgs._avg)) {
+                    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}`);
+                for (const key of selectedAggregateFields(finalArgs._min)) {
+                    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}`);
+                for (const key of selectedAggregateFields(finalArgs._max)) {
+                    selects.push(aggSelect("MAX", key));
                 }
             }
             if (finalArgs._count) {
@@ -874,8 +989,8 @@ class TableClient {
                     selects.push(`COUNT(*) as count_all`);
                 }
                 else {
-                    for (const key of Object.keys(finalArgs._count)) {
-                        selects.push(`COUNT(${key}) as count_${key}`);
+                    for (const key of selectedAggregateFields(finalArgs._count)) {
+                        selects.push(aggSelect("COUNT", key));
                     }
                 }
             }
@@ -884,30 +999,30 @@ 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}`;
             }
             const rows = await this.executor(sqlText, p);
             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;
+                for (const key of selectedAggregateFields(finalArgs._sum)) {
+                    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;
+                for (const key of selectedAggregateFields(finalArgs._avg)) {
+                    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;
+                for (const key of selectedAggregateFields(finalArgs._min)) {
+                    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;
+                for (const key of selectedAggregateFields(finalArgs._max)) {
+                    resultObj._max[key] = row[aggAlias("max", key)] !== undefined ? row[aggAlias("max", key)] : null;
                 }
             }
             if (finalArgs._count) {
@@ -915,8 +1030,8 @@ class TableClient {
                     resultObj._count._all = row[`count_all`] || 0;
                 }
                 else {
-                    for (const key of Object.keys(finalArgs._count)) {
-                        resultObj._count[key] = row[`count_${key}`] || 0;
+                    for (const key of selectedAggregateFields(finalArgs._count)) {
+                        resultObj._count[key] = row[aggAlias("count", key)] || 0;
                     }
                 }
             }
@@ -926,48 +1041,66 @@ class TableClient {
     async groupBy(args) {
         return this.orm._executeMiddleware({ model: this.modelName, action: 'groupBy', args }, async (params) => {
             const { args: finalArgs } = params;
-            const byFields = finalArgs.by || [];
+            const byFields = normalizeByFields(finalArgs.by);
             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}`);
+                    for (const key of selectedAggregateFields(finalArgs._count)) {
+                        selects.push(aggSelect("COUNT", key));
                     }
                 }
             }
             if (finalArgs._sum) {
-                for (const key of Object.keys(finalArgs._sum)) {
-                    selects.push(`SUM(${key}) as sum_${key}`);
+                for (const key of selectedAggregateFields(finalArgs._sum)) {
+                    selects.push(aggSelect("SUM", key));
                 }
             }
             if (finalArgs._avg) {
-                for (const key of Object.keys(finalArgs._avg)) {
-                    selects.push(`AVG(${key}) as avg_${key}`);
+                for (const key of selectedAggregateFields(finalArgs._avg)) {
+                    selects.push(aggSelect("AVG", key));
                 }
             }
             if (finalArgs._min) {
-                for (const key of Object.keys(finalArgs._min)) {
-                    selects.push(`MIN(${key}) as min_${key}`);
+                for (const key of selectedAggregateFields(finalArgs._min)) {
+                    selects.push(aggSelect("MIN", key));
                 }
             }
             if (finalArgs._max) {
-                for (const key of Object.keys(finalArgs._max)) {
-                    selects.push(`MAX(${key}) as max_${key}`);
+                for (const key of selectedAggregateFields(finalArgs._max)) {
+                    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 havingSql = buildHavingSql(finalArgs?.having, p);
+            if (havingSql) {
+                sqlText += ` HAVING ${havingSql}`;
+            }
+            const hasSkip = finalArgs?.skip !== undefined && finalArgs?.skip !== null;
+            const hasTake = finalArgs?.take !== undefined && finalArgs?.take !== null;
+            if (finalArgs?.orderBy) {
+                sqlText += (0, sql_utils_1.buildOrderBy)(finalArgs.orderBy);
+            }
+            else if (hasSkip || hasTake) {
+                sqlText += ` ORDER BY ${byFields.map((f) => (0, sql_utils_1.quoteIdentifier)(f)).join(", ")}`;
+            }
+            if (hasSkip || hasTake) {
+                sqlText += ` OFFSET ${(0, sql_utils_1.toNonNegativeInt)(finalArgs.skip)} ROWS`;
+                if (hasTake) {
+                    sqlText += ` FETCH NEXT ${(0, sql_utils_1.toNonNegativeInt)(finalArgs.take, 1)} ROWS ONLY`;
+                }
+            }
             const rows = await this.executor(sqlText, p);
             return rows.map((row) => {
                 const item = {};
@@ -980,39 +1113,46 @@ class TableClient {
                         item._count._all = row[`count_all`] || 0;
                     }
                     else {
-                        for (const key of Object.keys(finalArgs._count)) {
-                            item._count[key] = row[`count_${key}`] || 0;
+                        for (const key of selectedAggregateFields(finalArgs._count)) {
+                            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;
+                    for (const key of selectedAggregateFields(finalArgs._sum)) {
+                        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;
+                    for (const key of selectedAggregateFields(finalArgs._avg)) {
+                        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;
+                    for (const key of selectedAggregateFields(finalArgs._min)) {
+                        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;
+                    for (const key of selectedAggregateFields(finalArgs._max)) {
+                        item._max[key] = row[aggAlias("max", key)] !== undefined ? row[aggAlias("max", key)] : null;
                     }
                 }
                 return item;
             });
         });
     }
+    async sequentialUpsert(finalArgs) {
+        const existing = await this.findUnique({ where: finalArgs.where });
+        if (existing) {
+            return this.update({ where: finalArgs.where, data: finalArgs.update, include: finalArgs.include });
+        }
+        return this.create({ data: finalArgs.create, include: finalArgs.include });
+    }
     async upsert(args) {
         return this.orm._executeMiddleware({ model: this.modelName, action: 'upsert', args }, async (params) => {
             const { args: finalArgs } = params;
@@ -1021,50 +1161,50 @@ 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 atomicWhere = flattenSimpleEqualityWhere(where);
+            if (!atomicWhere || Object.keys(cleanUpdate).length === 0) {
+                return this.sequentialUpsert(finalArgs);
+            }
             const p = {};
-            const whereSql = 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];
+            }
+            for (const [k, v] of Object.entries(atomicWhere)) {
+                p[`upw_${(0, sql_utils_1.sanitizeParamName)(k)}`] = v;
             }
             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(", ");
-            // 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.
-            const onClause = Object.keys(where).map(k => {
-                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 `target.[${k}] = @upw_${k}`;
-            }).join(" AND ");
+            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(", ");
+            const onClause = Object.keys(atomicWhere)
+                .map(k => `target.${(0, sql_utils_1.quoteIdentifier)(k)} = @upw_${(0, sql_utils_1.sanitizeParamName)(k)}`)
+                .join(" AND ");
             const sqlText = `
         MERGE INTO ${this.tableName} WITH (HOLDLOCK) AS target
         USING (SELECT ${sourceSelect}) AS source
@@ -1079,29 +1219,24 @@ class TableClient {
                 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;
             }
             catch (err) {
                 logger_1.logger.warn(`Atomic upsert failed, falling back to sequential: ${err.message}`);
-                const existing = await this.findUnique({ where: finalArgs.where });
-                if (existing) {
-                    return this.update({ where: finalArgs.where, data: finalArgs.update, include: finalArgs.include });
-                }
-                else {
-                    return this.create({ data: finalArgs.create, include: finalArgs.include });
-                }
+                return this.sequentialUpsert(finalArgs);
             }
         });
     }
 }
-function addNoLockToQuery(sql) {
+exports.TableClient = TableClient;
+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 +1265,128 @@ 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).
+class ViewClient {
+    constructor(viewName, rawTableName, executor, orm) {
+        this.viewName = viewName;
+        this.rawTableName = rawTableName;
+        this.executor = executor;
+        this.orm = orm;
+        this.tableClient = new TableClient(viewName, rawTableName, executor, orm);
+    }
+    async findMany(args) { return this.tableClient.findMany(args); }
+    async findFirst(args) { return this.tableClient.findFirst(args); }
+    async findUnique(args) { return this.tableClient.findUnique(args); }
+    async count(args) { return this.tableClient.count(args); }
+    async aggregate(args) { return this.tableClient.aggregate(args); }
+    async groupBy(args) { return this.tableClient.groupBy(args); }
+    async vectorSearch(args) { return this.tableClient.vectorSearch(args); }
+    async create() {
+        throw new errors_1.An5ClientKnownRequestError("Views are read-only and do not support create operations.", { code: "P2000", clientVersion: "1.0.8" });
+    }
+    async createMany() {
+        throw new errors_1.An5ClientKnownRequestError("Views are read-only and do not support createMany operations.", { code: "P2000", clientVersion: "1.0.8" });
+    }
+    async update() {
+        throw new errors_1.An5ClientKnownRequestError("Views are read-only and do not support update operations.", { code: "P2000", clientVersion: "1.0.8" });
+    }
+    async updateMany() {
+        throw new errors_1.An5ClientKnownRequestError("Views are read-only and do not support updateMany operations.", { code: "P2000", clientVersion: "1.0.8" });
+    }
+    async delete() {
+        throw new errors_1.An5ClientKnownRequestError("Views are read-only and do not support delete operations.", { code: "P2000", clientVersion: "1.0.8" });
+    }
+    async deleteMany() {
+        throw new errors_1.An5ClientKnownRequestError("Views are read-only and do not support deleteMany operations.", { code: "P2000", clientVersion: "1.0.8" });
+    }
+    async upsert() {
+        throw new errors_1.An5ClientKnownRequestError("Views are read-only and do not support upsert operations.", { code: "P2000", clientVersion: "1.0.8" });
+    }
+}
+exports.ViewClient = ViewClient;
+function buildProcCallSql(procName, params) {
+    const p = {};
+    const targetProc = (0, sql_utils_1.quoteTableIdentifier)(procName);
+    if (!params) {
+        return { sqlText: `EXEC ${targetProc};`, p };
+    }
+    if (Array.isArray(params)) {
+        const argList = params.map((val, idx) => {
+            const key = `p_${idx}`;
+            p[key] = val;
+            return `@${key}`;
+        }).join(", ");
+        return { sqlText: `EXEC ${targetProc} ${argList};`, p };
+    }
+    const argList = Object.entries(params).map(([key, val], idx) => {
+        const paramKey = (0, sql_utils_1.sanitizeParamName)(`p_${key}_${idx}`);
+        p[paramKey] = val;
+        return `@${(0, sql_utils_1.sanitizeParamName)(key)} = @${paramKey}`;
+    }).join(", ");
+    return { sqlText: `EXEC ${targetProc} ${argList};`, p };
+}
+function buildFunctionCallSql(fnName, params) {
+    const p = {};
+    const targetFn = (0, sql_utils_1.quoteTableIdentifier)(fnName);
+    if (!params) {
+        return { sqlText: `SELECT * FROM ${targetFn}();`, p };
+    }
+    if (Array.isArray(params)) {
+        const argList = params.map((val, idx) => {
+            const key = `p_${idx}`;
+            p[key] = val;
+            return `@${key}`;
+        }).join(", ");
+        return { sqlText: `SELECT * FROM ${targetFn}(${argList});`, p };
+    }
+    const argList = Object.entries(params).map(([key, val], idx) => {
+        const paramKey = (0, sql_utils_1.sanitizeParamName)(`p_${key}_${idx}`);
+        p[paramKey] = val;
+        return `@${paramKey}`;
+    }).join(", ");
+    return { sqlText: `SELECT * FROM ${targetFn}(${argList});`, p };
+}
+let autoMetadata = null;
+function loadAutoMetadata() {
+    if (autoMetadata)
+        return autoMetadata;
+    const candidates = [
+        "an5-client/typescript/an5Metadata",
+        "../an5Client/typescript/an5Metadata",
+        "./an5Metadata"
+    ];
+    for (const cand of candidates) {
+        try {
+            const m = require(cand);
+            if (m && m.modelToTable && Object.keys(m.modelToTable).length > 0) {
+                autoMetadata = {
+                    modelToTable: m.modelToTable || {},
+                    relationMap: m.relationMap || {},
+                    modelFields: m.modelFields || {},
+                };
+                return autoMetadata;
+            }
+        }
+        catch { }
+    }
+    autoMetadata = metadata_1.DEFAULT_METADATA;
+    return autoMetadata;
+}
 // Proxied AN5 ORM client class
 class An5ORM {
-    constructor(customExecutor) {
-        this.customExecutor = customExecutor;
+    constructor(customExecutor, metadata, inTransaction = false, transactionControl) {
+        this.inTransaction = inTransaction;
+        this.transactionControl = transactionControl;
         this.middlewares = [];
+        if (customExecutor && typeof customExecutor === "object" && typeof customExecutor.exec === "function") {
+            this.customExecutor = executorFromAdapterLike(customExecutor);
+        }
+        else if (typeof customExecutor === "function") {
+            this.customExecutor = customExecutor;
+        }
+        this.metadata = metadata ?? loadAutoMetadata();
         // Add default logging middleware
         this.$use(async (params, next) => {
             const start = Date.now();
@@ -1153,46 +1405,77 @@ class An5ORM {
             }
         });
         return new Proxy(this, {
-            get(target, prop) {
-                if (prop === "$use") {
-                    return target.$use.bind(target);
-                }
-                if (prop === "$transaction") {
-                    return target.$transaction.bind(target);
-                }
-                if (prop === "$connect") {
-                    return target.$connect.bind(target);
-                }
-                if (prop === "$disconnect") {
-                    return target.$disconnect.bind(target);
-                }
-                if (prop === "$queryRaw") {
-                    return target.$queryRaw.bind(target);
-                }
-                if (prop === "$queryRawUnsafe") {
-                    return target.$queryRawUnsafe.bind(target);
-                }
-                if (prop === "$executeRaw") {
-                    return target.$executeRaw.bind(target);
-                }
-                if (prop === "$executeRawUnsafe") {
-                    return target.$executeRawUnsafe.bind(target);
+            get(target, prop, receiver) {
+                if (typeof prop === "string" && prop in target && typeof target[prop] === "function") {
+                    return target[prop].bind(target);
                 }
                 if (!(prop in target) && typeof prop === "string" && !prop.startsWith("_")) {
-                    // Resolve modelName in camelCase and map to table name
-                    const tableName = an5Metadata_1.modelToTable[prop];
-                    if (tableName) {
-                        target[prop] = new TableClient(prop, tableName, target.customExecutor || execQuery, target // Pass ORM instance for middleware access
-                        );
+                    let modelName = prop;
+                    let tableName = target.metadata.modelToTable[prop];
+                    if (!tableName) {
+                        const lowerProp = prop.toLowerCase();
+                        for (const [mName, tName] of Object.entries(target.metadata.modelToTable)) {
+                            const lowerModel = mName.toLowerCase();
+                            const lowerTable = tName.toLowerCase();
+                            if (lowerModel === lowerProp ||
+                                lowerTable === lowerProp ||
+                                lowerModel + "s" === lowerProp ||
+                                lowerModel + "es" === lowerProp ||
+                                lowerTable + "s" === lowerProp ||
+                                lowerTable + "es" === lowerProp) {
+                                modelName = mName;
+                                tableName = tName;
+                                break;
+                            }
+                        }
                     }
+                    if (!tableName) {
+                        tableName = prop;
+                    }
+                    target[prop] = new TableClient(modelName, tableName, target.customExecutor || execQuery, receiver);
                 }
                 return target[prop];
             }
         });
     }
+    table(name) {
+        const rawTable = this.metadata.modelToTable[name] || name;
+        return new TableClient(name, rawTable, this.customExecutor || execQuery, this);
+    }
+    view(name) {
+        const rawTable = this.metadata.modelToTable[name] || name;
+        return new ViewClient(name, rawTable, this.customExecutor || execQuery, this);
+    }
+    $view(name) {
+        return this.view(name);
+    }
+    async $queryProc(procName, params) {
+        const executor = this.customExecutor || execQuery;
+        const { sqlText, p } = buildProcCallSql(procName, params);
+        return executor(sqlText, p);
+    }
+    async $executeProc(procName, params) {
+        const executor = this.customExecutor || execQuery;
+        const { sqlText, p } = buildProcCallSql(procName, params);
+        if (executor.executeRaw) {
+            return executor.executeRaw(sqlText, p);
+        }
+        return normalizeAffectedCount(await executor(sqlText, p));
+    }
+    async $queryFunction(fnName, params) {
+        const executor = this.customExecutor || execQuery;
+        const { sqlText, p } = buildFunctionCallSql(fnName, params);
+        return executor(sqlText, p);
+    }
     $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 +1526,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 +1538,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,9 +1569,11 @@ class An5ORM {
         else {
             throw new Error("Invalid query format for $executeRaw");
         }
-        queryText = addNoLockToQuery(queryText);
-        const result = (await executor(queryText, params));
-        return result.rowsAffected?.[0] || 0;
+        queryText = addNoLockToQuery(queryText, this.metadata);
+        if (executor.executeRaw) {
+            return executor.executeRaw(queryText, params);
+        }
+        return normalizeAffectedCount(await executor(queryText, params));
     }
     async $executeRawUnsafe(queryText, ...values) {
         const executor = this.customExecutor || execQuery;
@@ -1299,50 +1584,61 @@ class An5ORM {
                 params[paramName] = val;
             });
         }
-        const modifiedQueryText = addNoLockToQuery(queryText);
-        const result = (await executor(modifiedQueryText, params));
-        return result.rowsAffected?.[0] || 0;
+        const modifiedQueryText = addNoLockToQuery(queryText, this.metadata);
+        if (executor.executeRaw) {
+            return executor.executeRaw(modifiedQueryText, params);
+        }
+        return normalizeAffectedCount(await executor(modifiedQueryText, params));
     }
     async $transaction(fn, options) {
         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);
+        const executor = this.customExecutor || execQuery;
+        if (!executor.transaction) {
+            if (this.inTransaction) {
+                const txClient = new An5ORM(executor, this.metadata, true);
+                return fn(txClient);
             }
-            throw err;
+            throw new Error("Transactions require an executor with transaction support");
+        }
+        return executor.transaction(async (txExecutor) => {
+            const txClient = new An5ORM(txExecutor, this.metadata, true);
+            return fn(txClient);
+        }, options);
+    }
+    async $begin() {
+        if (this.inTransaction) {
+            throw new Error("Interactive transactions cannot be nested");
+        }
+        const executor = this.customExecutor || execQuery;
+        if (!executor.beginTransaction) {
+            throw new Error("Interactive transactions require an executor with beginTransaction support");
+        }
+        const tx = await executor.beginTransaction();
+        return new An5ORM(tx.executor, this.metadata, true, {
+            commit: tx.commit,
+            rollback: tx.rollback,
+        });
+    }
+    async $commit() {
+        if (!this.transactionControl) {
+            throw new Error("$commit can only be called on an interactive transaction client");
+        }
+        const control = this.transactionControl;
+        this.transactionControl = undefined;
+        await control.commit();
+    }
+    async $rollback() {
+        if (!this.transactionControl) {
+            throw new Error("$rollback can only be called on an interactive transaction client");
         }
+        const control = this.transactionControl;
+        this.transactionControl = undefined;
+        await control.rollback();
     }
 }
 exports.An5ORM = An5ORM;
 exports.an5Orm = new An5ORM();
 exports.default = exports.an5Orm;
-//# sourceMappingURL=an5Orm.js.map
+//# sourceMappingURL=an5Orm.js.map