@technicity/data-service-generator 0.2.8 → 0.4.1

package/dist/{runtime.js → runtime/__shared.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._prepareWhere = exports.whereNeedsProcessing = exports.init = exports.deleteList = exports.del = exports.patchList = exports.patch = exports.post = exports.resolve = exports.SDKNotFoundError = void 0;
+exports._prepareWhere = exports.whereNeedsProcessing = exports.deleteList = exports.del = exports.patchList = exports.patch = exports.post = exports.resolve = void 0;
 // @ts-ignore
 // import * as queryAST from "join-monster/dist/query-ast-to-sql-ast";
 // @ts-ignore
@@ -9,27 +9,22 @@ exports._prepareWhere = exports.whereNeedsProcessing = exports.init = exports.de
 const batch_planner_1 = require("join-monster/dist/batch-planner");
 // @ts-ignore
 const util_1 = require("join-monster/dist/util");
-const SqlString = require("sqlstring");
-// @ts-ignore
-const TSqlString = require("tsqlstring");
 const _ = require("lodash/fp");
-const getSqlAst_1 = require("./getSqlAst");
-const mysql_1 = require("./mysql");
-const mssql = require("mssql");
-const getWhere_1 = require("./getWhere");
-const getDateTimeStringMySQL_1 = require("./getDateTimeStringMySQL");
-const cursor_1 = require("./cursor");
-const runTransforms_1 = require("./runTransforms");
-const addNullFallbacks_1 = require("./addNullFallbacks");
-const SDKNotFoundError_1 = require("./SDKNotFoundError");
-Object.defineProperty(exports, "SDKNotFoundError", { enumerable: true, get: function () { return SDKNotFoundError_1.SDKNotFoundError; } });
-const driverOpts_1 = require("./driverOpts");
-async function resolve(input, options) {
+const getSqlAst_1 = require("../getSqlAst");
+const getWhere_1 = require("../getWhere");
+const getDateTimeStringMySQL_1 = require("../getDateTimeStringMySQL");
+const cursor_1 = require("../cursor");
+const runTransforms_1 = require("../runTransforms");
+const addNullFallbacks_1 = require("../addNullFallbacks");
+const SDKNotFoundError_1 = require("../SDKNotFoundError");
+const stringifyWhere_1 = require("../stringifyWhere");
+const getOrderBy_1 = require("../getOrderBy");
+async function resolve(input, dbCall, formatQuery, options) {
     const context = {};
-    const dbCall = getDbCall(options.dialect);
-    const formatQuery = getFormatQuery(options.dialect);
+    const kind = input.kind;
+    const primaryKey = input.artifacts[input.table].primaryKey;
     let rowWithCursorId = undefined;
-    if (input.kind === "listPaginated") {
+    if (kind === "listPaginated") {
         if (input.args?.$paginate == null) {
             throw new Error("$paginate required but not supplied");
         }
@@ -38,21 +33,22 @@ async function resolve(input, options) {
             const cursor = input.args.$paginate.after != null
                 ? input.args.$paginate.after
                 : input.args.$paginate.before;
-            rowWithCursorId = await dbCall(formatQuery("SELECT * FROM ?? WHERE id = ?", [
+            rowWithCursorId = await dbCall(formatQuery("SELECT * FROM ?? WHERE ?? = ?", [
                 input.table,
+                primaryKey,
                 cursor_1.decodeCursor(cursor),
             ])).then((xs) => xs[0]);
         }
     }
     // we need to read the query AST and build a new "SQL AST" from which the SQL and
     // const sqlAST = queryAST.queryASTToSqlAST(resolveInfo, options, context);
-    const kind = input.kind;
-    delete input.kind;
     const fields = input.fields ?? getScalarFields(input.table, input.artifacts);
+    const orderByListPaginatedRootResult = kind === "listPaginated" ? getOrderBy_1.getOrderBy(input.args, primaryKey) : undefined;
     const sqlAST = getSqlAst_1.getSqlAst({
         ...input,
         fields,
         getWhere: getWhere_1.getWhere,
+        orderBy: orderByListPaginatedRootResult?.orderBy,
         rowWithCursorId,
         dialect: options.dialect,
     });
@@ -117,9 +113,9 @@ async function resolve(input, options) {
         //   return true;
         // });
         if (kind === "listPaginated") {
-            data = await wrapListPaginated(data, input.args, (xs) => {
+            data = await wrapListPaginated(data, input.args, orderByListPaginatedRootResult.flip, (xs) => {
                 postProcess(xs, fields, shouldRemoveExtraKeys);
-            }, sql, dbCall, options.dialect, input.artifacts[input.table].primaryKey);
+            }, sqlAST, dbCall, input.artifacts[input.table].primaryKey, context, options);
         }
         return data;
     }
@@ -132,8 +128,7 @@ exports.resolve = resolve;
 // Not recursive at the moment; only supported at the root.
 // TODO - remove if support for pagination for mysql dialect
 // is added (I doubt it)
-async function wrapListPaginated(data, args, cb, sql, dbCall, dialect, primaryKey) {
-    const flip = typeof args.$paginate.first === "number" ? false : true;
+async function wrapListPaginated(data, args, flip, cb, sqlAST, dbCall, primaryKey, context, options) {
     const limit = flip ? args.$paginate.last : args.$paginate.first;
     const hasMoreResults = data.length === limit + 1;
     if (hasMoreResults) {
@@ -145,37 +140,26 @@ async function wrapListPaginated(data, args, cb, sql, dbCall, dialect, primaryKe
     }
     const hasPreviousPage = flip ? hasMoreResults : false;
     const hasNextPage = flip ? false : hasMoreResults;
-    const startId = data?.[0]?.[primaryKey];
-    const endId = data?.[data.length - 1]?.[primaryKey];
-    const startCursor = startId == null ? null : cursor_1.encodeCursor(startId);
-    const endCursor = endId == null ? null : cursor_1.encodeCursor(endId);
-    const countField = "COUNT(*)";
-    let countSql = "";
-    let totalCount = null;
-    if (dialect === "mysql") {
-        // Replace field selection with COUNT(*)
-        // Remove LIMIT
-        let tmp = sql.split("FROM ");
-        tmp.shift();
-        let tmp2 = tmp.join("").split(" LIMIT ");
-        tmp2.pop();
-        countSql = "SELECT " + countField + " FROM " + tmp2.join("");
-        totalCount = await dbCall(countSql).then((xs) => xs[0][countField]);
-    }
-    else {
-        // Replace field selection with COUNT(*)
-        // Remove TOP N
-        // Remove ORDER BY to avoid the error:
-        // Column "X" is invalid in the ORDER BY clause because it is not contained in either an aggregate function or the GROUP BY clause.
-        let tmp = sql.split("FROM ");
-        tmp.shift();
-        let tmp2 = tmp.join("").split("ORDER BY ");
-        tmp2.pop();
-        countSql = "SELECT " + countField + " FROM " + tmp2.join("");
-        totalCount = await dbCall(countSql).then((xs) => 
-        // Intentionally "" instead of countField
-        xs[0][""]);
-    }
+    const startKey = data?.[0]?.[primaryKey];
+    const endKey = data?.[data.length - 1]?.[primaryKey];
+    const startCursor = startKey == null ? null : cursor_1.encodeCursor(startKey);
+    const endCursor = endKey == null ? null : cursor_1.encodeCursor(endKey);
+    // Replace field selection with `COUNT(*)`
+    const fieldNameTotalCount = "totalCount";
+    const sqlASTTotalCount = { ...sqlAST };
+    sqlASTTotalCount.children = [
+        {
+            type: "expression",
+            sqlExpr: () => "COUNT(*)",
+            fieldName: fieldNameTotalCount,
+            as: fieldNameTotalCount,
+        },
+    ];
+    // Remove ORDER BY to avoid the error:
+    // Column "X" is invalid in the ORDER BY clause because it is not contained in either an aggregate function or the GROUP BY clause.
+    delete sqlASTTotalCount.orderBy;
+    const { sql: sqlTotalCount } = await util_1.compileSqlAST(sqlASTTotalCount, context, options);
+    const totalCount = await dbCall(sqlTotalCount).then((xs) => xs[0][fieldNameTotalCount]);
     cb(data);
     return {
         paginationInfo: {
@@ -189,128 +173,198 @@ async function wrapListPaginated(data, args, cb, sql, dbCall, dialect, primaryKe
     };
 }
 async function post(input) {
-    const dbCall = getDbCall(input.dialect);
-    const formatQuery = getFormatQuery(input.dialect);
-    // Shallow clone, as we're going to mutate later
-    const data = { ...input.data };
-    const tableArtifacts = input.artifacts[input.table];
-    if (hasMappedFields(input.artifacts, input.table, data)) {
-        await mapMappedFields(tableArtifacts, data, dbCall, formatQuery);
-    }
-    if (input.dialect === "mysql" && tableArtifacts.dateTimeFieldsCount > 0) {
-        for (let k in tableArtifacts.dateTimeFields) {
-            if (data[k] != null) {
-                data[k] = getDateTimeStringMySQL_1.getDateTimeStringMySQL(data[k]);
+    async function _post() {
+        const { dbCall, formatQuery } = input;
+        // Shallow clone, as we're going to mutate later
+        const data = { ...input.data };
+        const tableArtifacts = input.artifacts[input.table];
+        if (hasMappedFields(input.artifacts, input.table, data)) {
+            await mapMappedFields(tableArtifacts, data, dbCall, formatQuery);
+        }
+        if (input.dialect === "mysql" && tableArtifacts.dateTimeFieldsCount > 0) {
+            for (let k in tableArtifacts.dateTimeFields) {
+                if (data[k] != null) {
+                    data[k] = getDateTimeStringMySQL_1.getDateTimeStringMySQL(data[k]);
+                }
             }
         }
-    }
-    // Delete keys with value of undefined
-    for (let k in data) {
-        if (data[k] === void 0) {
-            delete data[k];
+        // Delete keys with value of undefined
+        for (let k in data) {
+            if (data[k] === void 0) {
+                delete data[k];
+            }
+        }
+        if (input.dialect === "mysql") {
+            const inserted = await dbCall(formatQuery("INSERT INTO ?? SET ?", [input.table, data]));
+            return inserted.insertId;
+        }
+        else {
+            const columns = Object.keys(data);
+            const values = Object.values(data);
+            const inserted = await dbCall(formatQuery(`INSERT INTO ?? (${columns
+                .map(() => "??")
+                .join(",")}) VALUES (${values
+                .map(() => "?")
+                .join(",")}) SELECT SCOPE_IDENTITY() AS [SCOPE_IDENTITY]`, [input.table, ...columns, ...values]));
+            return inserted[0]["SCOPE_IDENTITY"];
         }
     }
-    if (input.dialect === "mysql") {
-        const inserted = await dbCall(formatQuery("INSERT INTO ?? SET ?", [input.table, data]));
-        return inserted.insertId;
-    }
-    else {
-        const columns = Object.keys(data);
-        const values = Object.values(data);
-        const inserted = await dbCall(formatQuery(`INSERT INTO ?? (${columns
-            .map(() => "??")
-            .join(",")}) VALUES (${values
-            .map(() => "?")
-            .join(",")}) SELECT SCOPE_IDENTITY() AS [SCOPE_IDENTITY]`, [input.table, ...columns, ...values]));
-        return inserted[0]["SCOPE_IDENTITY"];
-    }
+    const id = await _post();
+    return resolve({
+        table: input.table,
+        fieldName: input.fieldName,
+        args: { $where: { id } },
+        fields: input.fields,
+        grabMany: false,
+        artifacts: input.artifacts,
+    }, input.dbCall, input.formatQuery, { dialect: input.dialect });
 }
 exports.post = post;
 async function patch(input) {
-    const dbCall = getDbCall(input.dialect);
-    const formatQuery = getFormatQuery(input.dialect);
-    const _findOne = Object.entries(input.findOne)[0];
-    const findOne = { key: _findOne[0], value: _findOne[1] };
-    const current = await dbCall(formatQuery("SELECT * FROM ?? WHERE ?? = ?", [
-        input.table,
-        findOne.key,
-        findOne.value,
-    ])).then((xs) => xs[0]);
-    if (current == null) {
-        throw new SDKNotFoundError_1.SDKNotFoundError();
-    }
-    // Shallow clone, as we're going to mutate later
-    const data = { ...input.data };
-    const tableArtifacts = input.artifacts[input.table];
-    if (hasMappedFields(input.artifacts, input.table, data)) {
-        await mapMappedFields(tableArtifacts, data, dbCall, formatQuery);
-    }
-    if (input.dialect === "mysql" && tableArtifacts.dateTimeFieldsCount > 0) {
-        for (let k in tableArtifacts.dateTimeFields) {
-            if (data[k] != null) {
-                data[k] = getDateTimeStringMySQL_1.getDateTimeStringMySQL(data[k]);
+    async function _patch() {
+        const { dbCall, formatQuery } = input;
+        const tableArtifacts = input.artifacts[input.table];
+        const where = getWhere_1.getWhere(input.table, input.args, input.dialect);
+        if (where == null) {
+            throw new Error("Null where");
+        }
+        const current = await dbCall(formatQuery("SELECT * FROM ?? WHERE " + where, [input.table])).then((xs) => xs[0]);
+        if (current == null) {
+            throw new SDKNotFoundError_1.SDKNotFoundError();
+        }
+        // Shallow clone, as we're going to mutate later
+        const data = { ...input.data };
+        if (hasMappedFields(input.artifacts, input.table, data)) {
+            await mapMappedFields(tableArtifacts, data, dbCall, formatQuery);
+        }
+        if (input.dialect === "mysql" && tableArtifacts.dateTimeFieldsCount > 0) {
+            for (let k in tableArtifacts.dateTimeFields) {
+                if (data[k] != null) {
+                    data[k] = getDateTimeStringMySQL_1.getDateTimeStringMySQL(data[k]);
+                }
             }
         }
-    }
-    // Delete keys with value of undefined
-    for (let k in data) {
-        if (data[k] === void 0) {
-            delete data[k];
+        // Delete keys with value of undefined
+        for (let k in data) {
+            if (data[k] === void 0) {
+                delete data[k];
+            }
         }
-    }
-    // Nothing to update
-    if (Object.keys(data).length === 0) {
+        // Nothing to update
+        if (Object.keys(data).length === 0) {
+            return true;
+        }
+        await dbCall(getUpdateQuery(input.table, data, where, input.dialect, input.formatQuery));
         return true;
     }
-    await dbCall(formatQuery("UPDATE ?? SET ? WHERE ?? = ?", [
-        input.table,
-        data,
-        findOne.key,
-        findOne.value,
-    ]));
-    return true;
+    await _patch();
+    return resolve({
+        table: input.table,
+        fieldName: input.fieldName,
+        args: input.args,
+        fields: input.fields,
+        grabMany: false,
+        artifacts: input.artifacts,
+    }, input.dbCall, input.formatQuery, { dialect: input.dialect });
 }
 exports.patch = patch;
-async function patchList(input) {
-    const dbCall = getDbCall(input.dialect);
-    const formatQuery = getFormatQuery(input.dialect);
-    const tableArtifacts = input.artifacts[input.table];
-    const where = getWhere_1.getWhere(input.table, { $where: input.where }, tableArtifacts.primaryKey, input.dialect);
-    if (where == null) {
-        throw new Error("Null where");
-    }
-    // Shallow clone, as we're going to mutate later
-    const data = { ...input.data };
-    if (hasMappedFields(input.artifacts, input.table, data)) {
-        await mapMappedFields(tableArtifacts, data, dbCall, formatQuery);
-    }
-    if (input.dialect === "mysql" && tableArtifacts.dateTimeFieldsCount > 0) {
-        for (let k in tableArtifacts.dateTimeFields) {
-            if (data[k] != null) {
-                data[k] = getDateTimeStringMySQL_1.getDateTimeStringMySQL(data[k]);
+function getUpdateQuery(table, data, where, dialect, formatQuery) {
+    // Assumes `data` is not empty
+    const escapeId = stringifyWhere_1.getEscapeId(dialect);
+    const escape = stringifyWhere_1.getEscape(dialect);
+    let q = "UPDATE ?? ";
+    let values = [table];
+    let opsStrs = [];
+    let dataRegular = {};
+    for (let k in data) {
+        const v = data[k];
+        if (typeof v === "object" && v != null && Object.keys(v).length === 1) {
+            const _entries = Object.entries(v)?.[0];
+            const op = _entries?.[0];
+            const vv = _entries?.[1];
+            if (op === "$prepend") {
+                opsStrs.push(`${table}.${escapeId(k)} = CASE WHEN ${table}.${escapeId(k)} IS NULL THEN NULL ELSE CONCAT(${escape(vv)}, ${table}.${escapeId(k)}) END`);
+                continue;
+            }
+            if (op === "$append") {
+                opsStrs.push(`${table}.${escapeId(k)} = CASE WHEN ${table}.${escapeId(k)} IS NULL THEN NULL ELSE CONCAT(${table}.${escapeId(k)}, ${escape(vv)}) END`);
+                continue;
             }
+            if (op === "$increment") {
+                opsStrs.push(`${table}.${escapeId(k)} = ${table}.${escapeId(k)} + ${escape(vv)}`);
+                continue;
+            }
+            if (op === "$decrement") {
+                opsStrs.push(`${table}.${escapeId(k)} = ${table}.${escapeId(k)} - ${escape(vv)}`);
+                continue;
+            }
+            dataRegular[k] = v;
         }
+        dataRegular[k] = v;
     }
-    // Delete keys with value of undefined
-    for (let k in data) {
-        if (data[k] === void 0) {
-            delete data[k];
+    if (opsStrs.length > 0) {
+        q += `SET ${opsStrs.join(", ")}`;
+    }
+    if (Object.keys(dataRegular).length > 0) {
+        if (opsStrs.length > 0) {
+            q += ", ?";
         }
+        else {
+            q += "SET ?";
+        }
+        values.push(dataRegular);
     }
-    // Nothing to update
-    if (Object.keys(data).length === 0) {
-        return [];
+    q += ` WHERE ${where}`;
+    return formatQuery(q, values);
+}
+async function patchList(input) {
+    async function _patchList() {
+        const { dbCall, formatQuery } = input;
+        const tableArtifacts = input.artifacts[input.table];
+        const where = getWhere_1.getWhere(input.table, input.args, input.dialect);
+        if (where == null) {
+            throw new Error("Null where");
+        }
+        // Shallow clone, as we're going to mutate later
+        const data = { ...input.data };
+        if (hasMappedFields(input.artifacts, input.table, data)) {
+            await mapMappedFields(tableArtifacts, data, dbCall, formatQuery);
+        }
+        if (input.dialect === "mysql" && tableArtifacts.dateTimeFieldsCount > 0) {
+            for (let k in tableArtifacts.dateTimeFields) {
+                if (data[k] != null) {
+                    data[k] = getDateTimeStringMySQL_1.getDateTimeStringMySQL(data[k]);
+                }
+            }
+        }
+        // Delete keys with value of undefined
+        for (let k in data) {
+            if (data[k] === void 0) {
+                delete data[k];
+            }
+        }
+        // Nothing to update
+        if (Object.keys(data).length === 0) {
+            return [];
+        }
+        await dbCall(getUpdateQuery(input.table, data, where, input.dialect, input.formatQuery));
+        return true;
     }
-    const sql = "UPDATE ?? SET ? WHERE " + where;
-    const values = [input.table, data];
-    await dbCall(formatQuery(sql, values));
-    return true;
+    await _patchList();
+    return resolve({
+        table: input.table,
+        fieldName: input.fieldName,
+        args: input.args,
+        fields: input.fields,
+        artifacts: input.artifacts,
+        grabMany: true,
+        kind: "list",
+    }, input.dbCall, input.formatQuery, { dialect: input.dialect });
 }
 exports.patchList = patchList;
 async function del(input) {
-    const dbCall = getDbCall(input.dialect);
-    const formatQuery = getFormatQuery(input.dialect);
-    const _findOne = Object.entries(input.findOne)[0];
+    const { dbCall, formatQuery } = input;
+    const _findOne = Object.entries(input.args.$where)[0];
     const findOne = { key: _findOne[0], value: _findOne[1] };
     const current = await dbCall(formatQuery("SELECT * FROM ?? WHERE ?? = ?", [
         input.table,
@@ -329,10 +383,8 @@ async function del(input) {
 }
 exports.del = del;
 async function deleteList(input) {
-    const dbCall = getDbCall(input.dialect);
-    const formatQuery = getFormatQuery(input.dialect);
-    const tableArtifacts = input.artifacts[input.table];
-    const where = getWhere_1.getWhere(input.table, { $where: input.where }, tableArtifacts.primaryKey, input.dialect);
+    const { dbCall, formatQuery } = input;
+    const where = getWhere_1.getWhere(input.table, input.args, input.dialect);
     if (where == null) {
         throw new Error("Null where");
     }
@@ -342,73 +394,6 @@ async function deleteList(input) {
     return true;
 }
 exports.deleteList = deleteList;
-let pool;
-let poolConnect;
-let typeCastMSSQL;
-function init(dialect, opts) {
-    let { supplementDriverOpts, ...driverOpts } = opts;
-    if (dialect === "mysql") {
-        if (supplementDriverOpts) {
-            driverOpts = { ...driverOpts_1.driverOptsMySQL, ...driverOpts };
-        }
-        else {
-            driverOpts = {
-                typeCast: (field, next) => {
-                    if (field.type == "TINY" && field.length == 1) {
-                        return field.string() == "1";
-                    }
-                    if (field.type === "VAR_STRING" || field.type === "STRING") {
-                        return field.string();
-                    }
-                    return next();
-                },
-                ...driverOpts,
-            };
-        }
-        mysql_1.init(driverOpts);
-        return;
-    }
-    if (dialect === "mssql") {
-        // TODO: see https://github.com/tediousjs/node-mssql/pull/1171
-        if (supplementDriverOpts) {
-            typeCastMSSQL = driverOpts_1.driverOptsMSSQL.typeCast;
-        }
-        pool = new mssql.ConnectionPool(driverOpts);
-        poolConnect = pool.connect();
-        return;
-    }
-    throw new Error("Unsupported dialect: " + dialect);
-}
-exports.init = init;
-function getDbCall(dialect) {
-    if (dialect === "mysql") {
-        return mysql_1.query;
-    }
-    if (dialect === "mssql") {
-        return runMSSQLQuery;
-    }
-    throw new Error("Unsupported dialect: " + dialect);
-}
-async function runMSSQLQuery(query) {
-    await poolConnect;
-    const request = pool.request();
-    const result = await request.query(query);
-    // TODO: see https://github.com/tediousjs/node-mssql/pull/1171
-    const meta = result.recordset?.columns;
-    if (meta != null && typeof typeCastMSSQL === "function") {
-        return typeCastMSSQL(result, meta);
-    }
-    return result.recordset;
-}
-function getFormatQuery(dialect) {
-    if (dialect === "mysql") {
-        return SqlString.format.bind(SqlString);
-    }
-    if (dialect === "mssql") {
-        return TSqlString.format.bind(TSqlString);
-    }
-    throw new Error("Unsupported dialect: " + dialect);
-}
 function getScalarFields(table, artifacts) {
     return artifacts[table].scalarFields;
 }
@@ -524,9 +509,7 @@ function whereNeedsProcessing(where) {
     return JSON.stringify(where).includes("Uuid");
 }
 exports.whereNeedsProcessing = whereNeedsProcessing;
-async function _prepareWhere(artifacts, table, data, dialect) {
-    const dbCall = getDbCall(dialect);
-    const formatQuery = getFormatQuery(dialect);
+async function _prepareWhere(artifacts, table, data, dbCall, formatQuery) {
     const mappedFields = artifacts[table].mappedFields;
     let out = {};
     await traverseWhere(data, async (where, ptr, parentPtr, root) => {

package/dist/runtime/__typeCastMSSQL.d.ts

@@ -0,0 +1,3 @@
+declare type TValueCast = (value: any) => any;
+export declare function typeCastMSSQL(customTypeCast?: (meta: any, mssql: any) => TValueCast): (result: any, meta: any) => any;
+export {};

package/dist/runtime/__typeCastMSSQL.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typeCastMSSQL = void 0;
+const mssql = require("mssql");
+// TODO: see https://github.com/tediousjs/node-mssql/pull/1171
+function typeCastMSSQL(customTypeCast) {
+    return function (result, meta) {
+        let typeCasts = {};
+        for (let k in meta) {
+            const v = meta[k];
+            if (typeof customTypeCast === "function") {
+                const tc = customTypeCast(v, mssql);
+                if (tc) {
+                    typeCasts[v.name] = tc;
+                }
+            }
+            // ids
+            if (v.identity === true || v.type === mssql.BigInt) {
+                typeCasts[v.name] = (x) => (typeof x === "string" ? parseInt(x) : x);
+            }
+            // uuids
+            if (v.type === mssql.UniqueIdentifier) {
+                typeCasts[v.name] = (x) => typeof x === "string" ? x.toLocaleLowerCase() : x;
+            }
+        }
+        const data = result.recordset;
+        if (Object.keys(typeCasts).length === 0) {
+            return data;
+        }
+        return data.map((x) => {
+            for (let k of Object.keys(x)) {
+                if (typeCasts[k]) {
+                    x[k] = typeCasts[k](x[k]);
+                }
+            }
+            return x;
+        });
+    };
+}
+exports.typeCastMSSQL = typeCastMSSQL;

package/dist/stringifyWhere.d.ts

@@ -0,0 +1,18 @@
+import type { IOrderBy, IDialect } from "./types";
+declare type IWhere = {
+    [k: string]: any;
+};
+declare type IArgs = {
+    [k: string]: any;
+};
+export declare function stringifyWhere(input: {
+    where: IWhere;
+    table: string;
+    dialect: IDialect;
+    args: IArgs;
+    orderBy?: IOrderBy | undefined;
+    rowWithCursorId?: any;
+}): string;
+export declare function getEscapeId(dialect: IDialect): any;
+export declare function getEscape(dialect: IDialect): any;
+export {};