@technicity/data-service-generator 0.14.0 → 0.14.1

package/dist/runtime/RuntimeMSSQL.d.ts

@@ -13,13 +13,7 @@ export declare class RuntimeMSSQL implements IRuntime {
     $whereNeedsProcessing(where: any): boolean;
     $prepareWhere(artifacts: IArtifacts, table: string, data: any): Promise<{}>;
     $shutdown(): Promise<void>;
-    $startTransaction(input?: {
-        isolationLevel?: "READ UNCOMMITTED" | "READ COMMITTED" | "REPEATABLE READ" | "SERIALIZABLE";
-    }): Promise<{
-        commit: () => Promise<void>;
-        rollback: () => Promise<void>;
-        dbCall: (q: string) => Promise<any>;
-    }>;
     private dbCall;
     private formatQuery;
+    private beginTransaction;
 }

package/dist/runtime/RuntimeMSSQL.js

@@ -27,7 +27,7 @@ class RuntimeMSSQL {
         __classPrivateFieldSet(this, _RuntimeMSSQL_middlewareHandler, new shared_1.MiddlewareHandler(), "f");
     }
     async resolve(input) {
-        return (0, shared_1.resolve)(input, input.dbCall ?? this.dbCall.bind(this), this.formatQuery.bind(this), this.$startTransaction.bind(this), __classPrivateFieldGet(this, _RuntimeMSSQL_dialect, "f"), __classPrivateFieldGet(this, _RuntimeMSSQL_middlewareHandler, "f"), input.context ?? {});
+        return (0, shared_1.resolve)(input, this.dbCall.bind(this), this.formatQuery.bind(this), this.beginTransaction.bind(this), __classPrivateFieldGet(this, _RuntimeMSSQL_dialect, "f"), __classPrivateFieldGet(this, _RuntimeMSSQL_middlewareHandler, "f"), input.context ?? {});
     }
     async $queryRaw(sql, values) {
         return this.dbCall(this.formatQuery(sql, values ?? []));
@@ -44,15 +44,15 @@ class RuntimeMSSQL {
     async $shutdown() {
         await __classPrivateFieldGet(this, _RuntimeMSSQL_mssqlClient, "f").closePool();
     }
-    async $startTransaction(input) {
-        return __classPrivateFieldGet(this, _RuntimeMSSQL_mssqlClient, "f").beginTransaction(input?.isolationLevel);
-    }
     async dbCall(q) {
         return __classPrivateFieldGet(this, _RuntimeMSSQL_mssqlClient, "f").dbCall(q);
     }
     formatQuery(q, values) {
         return __classPrivateFieldGet(this, _RuntimeMSSQL_mssqlClient, "f").formatQuery(q, values);
     }
+    beginTransaction() {
+        return __classPrivateFieldGet(this, _RuntimeMSSQL_mssqlClient, "f").beginTransaction();
+    }
 }
 exports.RuntimeMSSQL = RuntimeMSSQL;
 _RuntimeMSSQL_dialect = new WeakMap(), _RuntimeMSSQL_mssqlClient = new WeakMap(), _RuntimeMSSQL_middlewareHandler = new WeakMap();

package/dist/runtime/RuntimeMySQL.d.ts

@@ -14,9 +14,7 @@ export declare class RuntimeMySQL implements IRuntime {
     $whereNeedsProcessing(where: any): boolean;
     $prepareWhere(artifacts: IArtifacts, table: string, data: any): Promise<{}>;
     $shutdown(): Promise<void>;
-    $startTransaction(input?: {
-        isolationLevel?: "READ UNCOMMITTED" | "READ COMMITTED" | "REPEATABLE READ" | "SERIALIZABLE";
-    }): Promise<any>;
     private dbCall;
     private formatQuery;
+    private beginTransaction;
 }

package/dist/runtime/RuntimeMySQL.js

@@ -1,27 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
@@ -33,17 +10,14 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 var _RuntimeMySQL_dialect, _RuntimeMySQL_mysqlClient, _RuntimeMySQL_clientCache, _RuntimeMySQL_middlewareHandler;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RuntimeMySQL = void 0;
-const SqlString = __importStar(require("sqlstring"));
-const Cache_1 = __importDefault(require("./Cache"));
+const SqlString = require("sqlstring");
+const Cache_1 = require("./Cache");
 const MySQL_1 = require("./lib/MySQL");
 const shared_1 = require("./lib/shared");
-const loglevel_1 = __importDefault(require("loglevel"));
+const loglevel_1 = require("loglevel");
 loglevel_1.default.setDefaultLevel("INFO");
 class RuntimeMySQL {
     constructor(clientOpts, otherOpts, artifacts) {
@@ -96,7 +70,7 @@ class RuntimeMySQL {
         __classPrivateFieldSet(this, _RuntimeMySQL_mysqlClient, new MySQL_1.MySQL(clientOpts), "f");
     }
     async resolve(input) {
-        return (0, shared_1.resolve)(input, input.dbCall ?? this.dbCall.bind(this), this.formatQuery.bind(this), this.$startTransaction.bind(this), __classPrivateFieldGet(this, _RuntimeMySQL_dialect, "f"), __classPrivateFieldGet(this, _RuntimeMySQL_middlewareHandler, "f"), input.context ?? {}, __classPrivateFieldGet(this, _RuntimeMySQL_clientCache, "f"));
+        return (0, shared_1.resolve)(input, this.dbCall.bind(this), this.formatQuery.bind(this), this.beginTransaction.bind(this), __classPrivateFieldGet(this, _RuntimeMySQL_dialect, "f"), __classPrivateFieldGet(this, _RuntimeMySQL_middlewareHandler, "f"), input.context ?? {}, __classPrivateFieldGet(this, _RuntimeMySQL_clientCache, "f"));
     }
     async $queryRaw(sql, values) {
         return this.dbCall(this.formatQuery(sql, values ?? []));
@@ -116,15 +90,15 @@ class RuntimeMySQL {
         }
         await __classPrivateFieldGet(this, _RuntimeMySQL_mysqlClient, "f").endPool();
     }
-    async $startTransaction(input) {
-        return __classPrivateFieldGet(this, _RuntimeMySQL_mysqlClient, "f").beginTransaction(input?.isolationLevel);
-    }
     dbCall(q) {
         return __classPrivateFieldGet(this, _RuntimeMySQL_mysqlClient, "f").query(q);
     }
     formatQuery(q, values) {
         return SqlString.format(q, values);
     }
+    beginTransaction() {
+        return __classPrivateFieldGet(this, _RuntimeMySQL_mysqlClient, "f").beginTransaction();
+    }
 }
 exports.RuntimeMySQL = RuntimeMySQL;
 _RuntimeMySQL_dialect = new WeakMap(), _RuntimeMySQL_mysqlClient = new WeakMap(), _RuntimeMySQL_clientCache = new WeakMap(), _RuntimeMySQL_middlewareHandler = new WeakMap();

package/dist/runtime/lib/MSSQL.d.ts

@@ -5,9 +5,8 @@ export declare class MSSQL {
     dbCall(q: string): Promise<any>;
     private mapResult;
     formatQuery(q: string, values: any[]): any;
-    beginTransaction(isolationLevel?: "READ UNCOMMITTED" | "READ COMMITTED" | "REPEATABLE READ" | "SERIALIZABLE"): Promise<{
+    beginTransaction(): Promise<{
         commit: () => Promise<void>;
-        rollback: () => Promise<void>;
         dbCall: (q: string) => Promise<any>;
     }>;
     closePool(): Promise<void>;

package/dist/runtime/lib/MSSQL.js

@@ -1,27 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
@@ -36,9 +13,9 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _MSSQL_pool, _MSSQL_poolConnect, _MSSQL_typeCast;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MSSQL = void 0;
-const mssql = __importStar(require("mssql"));
+const mssql = require("mssql");
 // @ts-ignore
-const TSqlString = __importStar(require("tsqlstring"));
+const TSqlString = require("tsqlstring");
 class MSSQL {
     constructor(clientOpts, typeCast) {
         _MSSQL_pool.set(this, void 0);
@@ -65,7 +42,7 @@ class MSSQL {
     formatQuery(q, values) {
         return TSqlString.format(q, values);
     }
-    async beginTransaction(isolationLevel) {
+    async beginTransaction() {
         const transaction = new mssql.Transaction(__classPrivateFieldGet(this, _MSSQL_pool, "f"));
         let rolledBack = false;
         transaction.on("rollback", (aborted) => {
@@ -79,18 +56,13 @@ class MSSQL {
             throw err;
         }
         const mapResult = this.mapResult.bind(this);
-        let isolationLevelNumber;
-        if (isolationLevel) {
-            isolationLevelNumber = mssql.ISOLATION_LEVEL[isolationLevel.replace(" ", "_")];
-            if (isolationLevelNumber == null) {
-                throw new Error(`Invalid isolationLevel: ${isolationLevel}`);
-            }
-        }
-        await transaction.begin(isolationLevelNumber);
+        await transaction.begin();
         return {
             commit: () => transaction.commit().catch(handleError),
-            rollback: () => transaction.rollback(),
-            dbCall: (q) => new mssql.Request(transaction).query(q).then(mapResult).catch(handleError)
+            dbCall: (q) => new mssql.Request(transaction)
+                .query(q)
+                .then(mapResult)
+                .catch(handleError),
         };
     }
     async closePool() {

package/dist/runtime/lib/MySQL.d.ts

@@ -2,7 +2,7 @@ export declare class MySQL {
     pool: any;
     constructor(opts: any);
     query(...args: any[]): any;
-    beginTransaction(isolationLevel?: "READ UNCOMMITTED" | "READ COMMITTED" | "REPEATABLE READ" | "SERIALIZABLE"): Promise<any>;
+    beginTransaction(): Promise<any>;
     getConnection(): Promise<any>;
     endPool(): Promise<void>;
 }

package/dist/runtime/lib/MySQL.js

@@ -13,29 +13,16 @@ class MySQL {
     query(...args) {
         return P.using(this.getConnection(), (connection) => connection.queryAsync(...args));
     }
-    async beginTransaction(isolationLevel) {
+    async beginTransaction() {
         return P.using(this.getConnection(), async (connection) => {
             async function handleError(err) {
                 await connection.rollbackAsync();
                 throw err;
             }
-            // https://dev.mysql.com/doc/refman/8.0/en/set-transaction.html#set-transaction-isolation-level
-            // Without any SESSION or GLOBAL keyword:
-            // The statement applies only to the next single transaction performed within the session.
-            if (isolationLevel != null) {
-                if (isolationLevel !== "READ UNCOMMITTED" &&
-                    isolationLevel !== "READ COMMITTED" &&
-                    isolationLevel !== "REPEATABLE READ" &&
-                    isolationLevel !== "SERIALIZABLE") {
-                    throw new Error(`Invalid isolationLevel: ${isolationLevel}`);
-                }
-                await connection.queryAsync(`SET TRANSACTION ISOLATION LEVEL ${isolationLevel};`);
-            }
             await connection.beginTransactionAsync();
             return {
                 commit: () => connection.commitAsync().catch(handleError),
-                rollback: () => connection.rollbackAsync(),
-                dbCall: (q) => connection.queryAsync(q).catch(handleError)
+                dbCall: (q) => connection.queryAsync(q).catch(handleError),
             };
         });
     }

package/dist/runtime/lib/getSqlAst.js

@@ -1,47 +1,21 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSqlAst = void 0;
-const SqlString = __importStar(require("sqlstring"));
+const SqlString = require("sqlstring");
 // @ts-ignore
-const TSqlString = __importStar(require("tsqlstring"));
+const TSqlString = require("tsqlstring");
 // @ts-ignore
-const alias_namespace_1 = __importDefault(require("join-monster/dist/alias-namespace"));
-const _ = __importStar(require("lodash/fp"));
+const alias_namespace_1 = require("join-monster/dist/alias-namespace");
+const _ = require("lodash/fp");
 const getOrderBy_1 = require("./getOrderBy");
 const namespace = new alias_namespace_1.default(true);
 function getSqlAst(input) {
-    const { table, fieldName, fields, args, grabMany, sqlJoin, sqlBatch, junction, getWhere, artifacts, rowWithMatchingCursor, dialect } = input;
+    const { table, fieldName, fields, args, grabMany, sqlJoin, sqlBatch, junction, getWhere, artifacts, rowWithMatchingCursor, dialect, } = input;
     const tableArtifacts = artifacts[table];
     const primaryKey = tableArtifacts.primaryKey;
-    const format = dialect === "mssql"
-        ? TSqlString.format.bind(TSqlString)
-        : SqlString.format.bind(SqlString);
+    const format = dialect === "mysql"
+        ? SqlString.format.bind(SqlString)
+        : TSqlString.format.bind(TSqlString);
     const orderBy = input.orderBy ?? (0, getOrderBy_1.getOrderBy)(args, primaryKey)?.orderBy;
     let where = input.where;
     if (input.where == null) {
@@ -86,138 +60,127 @@ function getSqlAst(input) {
         args,
         where,
         orderBy,
-        children: children.concat(Object.entries(fields)
-            .filter(([_, v]) => v !== false)
-            .map(([k, v]) => {
-            const mappedField = tableArtifacts.mappedFields?.[k];
-            const relationField = tableArtifacts.relationFields?.[k];
-            if (mappedField != null) {
-                return {
-                    type: "expression",
-                    sqlExpr: (table) => {
-                        const referencedTableAlias = namespace.generate("table", mappedField.referencedTable);
-                        return format(`(SELECT ?? FROM ?? AS ?? WHERE ??.?? = ${table}.??)`, [
-                            mappedField.name,
-                            mappedField.referencedTable,
-                            referencedTableAlias,
-                            referencedTableAlias,
-                            mappedField.referencedKey,
-                            mappedField.foreignKey
-                        ]);
-                    },
-                    name: k,
-                    fieldName: k,
-                    as: namespace.generate("column", k)
-                };
-            }
-            else if (relationField != null) {
-                const fields = typeof v === "object"
-                    ? v.$fields ??
-                        tableArtifacts.scalarFields.reduce((acc, x) => {
-                            acc[x] = true;
-                            return acc;
-                        }, {})
-                    : tableArtifacts.scalarFields.reduce((acc, x) => {
-                        acc[x] = true;
-                        return acc;
-                    }, {});
-                const args = typeof v === "object" ? v : {};
-                if (relationField.type === "many-to-many") {
-                    const asJunction = namespace.generate("table", relationField.junctionTable);
-                    const uniqueKey = artifacts[relationField.junctionTable].primaryKey;
-                    return getSqlAst({
-                        table: relationField.table,
-                        fieldName: k,
-                        fields,
-                        args,
-                        grabMany: relationField.grabMany,
-                        firstChild: {
-                            ...keyToASTChild(uniqueKey, namespace, asJunction),
-                            // There's either a bug in join-monster, or join-monster doesn't expect a junction table to have a primary key.
-                            // Work around by ensuring a unique name, to avoid e.g. SELECT `UserRole`.`id` AS `b`, `Role`.`id` AS `b`
-                            // Notice the duplicate names in the select. This results in missing rows because the
-                            // shape definition passed into NestHydrationJS will only have 1 `id`.
-                            fieldName: String(Date.now()),
-                            as: String(Date.now())
+        children: children.concat(fields.map((x) => {
+            if (typeof x === "string") {
+                const mappedField = tableArtifacts.mappedFields?.[x];
+                if (mappedField != null) {
+                    return {
+                        type: "expression",
+                        sqlExpr: (table) => {
+                            const referencedTableAlias = namespace.generate("table", mappedField.referencedTable);
+                            return format(`(SELECT ?? FROM ?? AS ?? WHERE ??.?? = ${table}.??)`, [
+                                mappedField.name,
+                                mappedField.referencedTable,
+                                referencedTableAlias,
+                                referencedTableAlias,
+                                mappedField.referencedKey,
+                                mappedField.foreignKey,
+                            ]);
                         },
-                        junction: {
-                            sqlTable: relationField.junctionTable,
-                            as: asJunction,
-                            uniqueKey,
-                            where: (table, args) => {
-                                if (typeof args?.$where !== "object" ||
-                                    typeof args?.$where == null ||
-                                    args.$where[relationField.junctionTable] == null) {
-                                    return undefined;
-                                }
-                                const argsMapped = _.cloneDeep(args);
-                                argsMapped.$where =
-                                    argsMapped.$where[relationField.junctionTable];
-                                const whereResult = getWhere(
-                                // table is escaped already
-                                table, argsMapped, dialect, orderBy, rowWithMatchingCursor);
-                                if (whereResult == null) {
-                                    return undefined;
-                                }
-                                return whereResult;
-                            },
-                            // Because we used the where in sqlJoin
-                            // where: () => undefined,
-                            // TODO - where
-                            // sqlJoins: [
-                            //   (t: string, junctionTable: string, args: any) =>
-                            //     `${t}.${relationField.relations[0].referencedKey} = ${junctionTable}.${relationField.relations[0].foreignKey}`,
-                            //   (junctionTable: string, t: string, args: any) =>
-                            //     `${junctionTable}.${relationField.relations[1].foreignKey} = ${t}.${relationField.relations[1].referencedKey}`,
-                            // ],
-                            // We have to use sqlBatch instead of sqlJoin because pagination is not
-                            // supported with `mysql` dialect, and LIMITing the root list means
-                            // sub lists are limited, too.
-                            sqlBatch: {
-                                thisKey: columnToASTChild(relationField.relations[0].foreignKey, namespace, asJunction),
-                                parentKey: columnToASTChild(relationField.relations[0].referencedKey, namespace),
-                                sqlJoin: (junctionTable, t, args) => `${junctionTable}.${relationField.relations[1].foreignKey} = ${t}.${relationField.relations[1].referencedKey}`
-                            }
-                        },
-                        getWhere,
-                        artifacts,
-                        dialect
-                    });
+                        name: x,
+                        fieldName: x,
+                        as: namespace.generate("column", x),
+                    };
                 }
+                // TODO - validate in dev?
+                return columnToASTChild(x, namespace);
+            }
+            const relationField = tableArtifacts.relationFields?.[x.name];
+            if (relationField == null) {
+                throw new Error("Invalid field: " + table + "." + x.name);
+            }
+            if (relationField.type === "many-to-many") {
+                const asJunction = namespace.generate("table", relationField.junctionTable);
+                const uniqueKey = artifacts[relationField.junctionTable].primaryKey;
                 return getSqlAst({
                     table: relationField.table,
-                    fieldName: k,
-                    fields,
-                    args,
+                    fieldName: x.as ?? x.name,
+                    fields: x.fields,
+                    args: x.args,
                     grabMany: relationField.grabMany,
-                    // Because we used the where in sqlJoin
-                    // where: () => undefined,
-                    // sqlJoin: (t1: string, t2: string, args: any) => {
-                    //   let sql = `${t1}.?? = ${t2}.??`;
-                    //   let values = [relationField.relation.foreignKey, relationField.relation.referencedKey];
-                    //   if (args?.$where != null) {
-                    //     const whereResult = getWhere(t2, args);
-                    //     sql += " and " + whereResult.sql;
-                    //     values.push(whereResult.values);
-                    //   }
-                    //   return s.format(sql, values);
-                    // },
-                    // We have to use sqlBatch instead of sqlJoin because pagination is not
-                    // supported with `mysql` dialect, and LIMITing the root list means
-                    // sub lists are limited, too.
-                    sqlBatch: {
-                        thisKey: columnToASTChild(relationField.relation.referencedKey, namespace),
-                        parentKey: columnToASTChild(relationField.relation.foreignKey, namespace)
+                    firstChild: {
+                        ...keyToASTChild(uniqueKey, namespace, asJunction),
+                        // There's either a bug in join-monster, or join-monster doesn't expect a junction table to have a primary key.
+                        // Work around by ensuring a unique name, to avoid e.g. SELECT `UserRole`.`id` AS `b`, `Role`.`id` AS `b`
+                        // Notice the duplicate names in the select. This results in missing rows because the
+                        // shape definition passed into NestHydrationJS will only have 1 `id`.
+                        fieldName: String(Date.now()),
+                        as: String(Date.now()),
+                    },
+                    junction: {
+                        sqlTable: relationField.junctionTable,
+                        as: asJunction,
+                        uniqueKey,
+                        where: (table, args) => {
+                            if (typeof args?.$where !== "object" ||
+                                typeof args?.$where == null ||
+                                args.$where[relationField.junctionTable] == null) {
+                                return undefined;
+                            }
+                            const argsMapped = _.cloneDeep(args);
+                            argsMapped.$where =
+                                argsMapped.$where[relationField.junctionTable];
+                            const whereResult = getWhere(
+                            // table is escaped already
+                            table, argsMapped, dialect, orderBy, rowWithMatchingCursor);
+                            if (whereResult == null) {
+                                return undefined;
+                            }
+                            return whereResult;
+                        },
+                        // Because we used the where in sqlJoin
+                        // where: () => undefined,
+                        // TODO - where
+                        // sqlJoins: [
+                        //   (t: string, junctionTable: string, args: any) =>
+                        //     `${t}.${relationField.relations[0].referencedKey} = ${junctionTable}.${relationField.relations[0].foreignKey}`,
+                        //   (junctionTable: string, t: string, args: any) =>
+                        //     `${junctionTable}.${relationField.relations[1].foreignKey} = ${t}.${relationField.relations[1].referencedKey}`,
+                        // ],
+                        // We have to use sqlBatch instead of sqlJoin because pagination is not
+                        // supported with `mysql` dialect, and LIMITing the root list means
+                        // sub lists are limited, too.
+                        sqlBatch: {
+                            thisKey: columnToASTChild(relationField.relations[0].foreignKey, namespace, asJunction),
+                            parentKey: columnToASTChild(relationField.relations[0].referencedKey, namespace),
+                            sqlJoin: (junctionTable, t, args) => `${junctionTable}.${relationField.relations[1].foreignKey} = ${t}.${relationField.relations[1].referencedKey}`,
+                        },
                     },
                     getWhere,
                     artifacts,
-                    dialect
+                    dialect,
                 });
             }
-            else {
-                return columnToASTChild(k, namespace);
-            }
-        }))
+            return getSqlAst({
+                table: relationField.table,
+                fieldName: x.as ?? x.name,
+                fields: x.fields,
+                args: x.args,
+                grabMany: relationField.grabMany,
+                // Because we used the where in sqlJoin
+                // where: () => undefined,
+                // sqlJoin: (t1: string, t2: string, args: any) => {
+                //   let sql = `${t1}.?? = ${t2}.??`;
+                //   let values = [relationField.relation.foreignKey, relationField.relation.referencedKey];
+                //   if (args?.$where != null) {
+                //     const whereResult = getWhere(t2, args);
+                //     sql += " and " + whereResult.sql;
+                //     values.push(whereResult.values);
+                //   }
+                //   return s.format(sql, values);
+                // },
+                // We have to use sqlBatch instead of sqlJoin because pagination is not
+                // supported with `mysql` dialect, and LIMITing the root list means
+                // sub lists are limited, too.
+                sqlBatch: {
+                    thisKey: columnToASTChild(relationField.relation.referencedKey, namespace),
+                    parentKey: columnToASTChild(relationField.relation.foreignKey, namespace),
+                },
+                getWhere,
+                artifacts,
+                dialect,
+            });
+        })),
     };
 }
 exports.getSqlAst = getSqlAst;
@@ -229,7 +192,7 @@ function keyToASTChild(key, namespace, fromOtherTable) {
             name: key,
             fieldName: clumsyName,
             as: namespace.generate("column", clumsyName),
-            fromOtherTable
+            fromOtherTable,
         };
     }
     return columnToASTChild(key, namespace, fromOtherTable);
@@ -240,7 +203,7 @@ function columnToASTChild(columnName, namespace, fromOtherTable) {
         name: columnName,
         fieldName: columnName,
         as: namespace.generate("column", columnName),
-        fromOtherTable
+        fromOtherTable,
     };
 }
 function toClumsyName(keyArr) {

package/dist/runtime/lib/runTransforms.d.ts

@@ -0,0 +1,2 @@
+import type { IGetSQLASTInput } from "../IRuntime";
+export declare function runTransforms(data: any, fields: IGetSQLASTInput["fields"]): void;

package/dist/runtime/lib/runTransforms.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTransforms = void 0;
+function runTransforms(data, fields) {
+    if (data == null) {
+        return;
+    }
+    for (let x of fields) {
+        if (typeof x === "object") {
+            const k = x.as ?? x.name;
+            if (Array.isArray(data)) {
+                for (let d of data) {
+                    if (d != null) {
+                        runTransforms(d[k], x.fields);
+                    }
+                }
+            }
+            else {
+                runTransforms(data[k], x.fields);
+            }
+            if (typeof x.transform === "function") {
+                if (Array.isArray(data)) {
+                    for (let d of data) {
+                        if (d != null) {
+                            d[k] = x.transform(d[k]);
+                        }
+                    }
+                }
+                else {
+                    data[k] = x.transform(data[k]);
+                }
+            }
+        }
+    }
+}
+exports.runTransforms = runTransforms;

package/dist/runtime/lib/shared.d.ts

@@ -1,4 +1,5 @@
-import type { IGetSQLASTInput, IArtifacts, IDialect, TDbCall, TFormatQuery, TBeginTransaction, TContext, TMiddleware, TResolveParams } from "../IRuntime";
+import type { IGetSQLASTInput, IArtifacts, IDialect, TDbCall, TFormatQuery, TBeginTransaction, TContext } from "../IRuntime";
+import type { TMiddleware, TResolveParams } from "../IRuntime";
 import Cache from "../Cache";
 export declare function resolve(input: TResolveParams, dbCall: TDbCall, formatQuery: TFormatQuery, beginTransaction: TBeginTransaction, dialect: IDialect, middlewareHandler: MiddlewareHandler<TMiddleware>, context: TContext, cache?: Cache): Promise<any>;
 export declare class MiddlewareHandler<M extends Function> {