@technicity/data-service-generator 0.14.1 → 0.14.3

package/dist/generation/generate.js

@@ -1,18 +1,44 @@
 "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.generate = void 0;
-const path = require("path");
-const fs = require("fs");
-const os = require("os");
-const child_process = require("child_process");
-const prettier = require("prettier");
-const changeCase = require("change-case");
-const fse = require("fs-extra");
-const _ = require("lodash/fp");
-const uuid_1 = require("uuid");
-const mssql = require("mssql");
+const path = __importStar(require("node:path"));
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const child_process = __importStar(require("node:child_process"));
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const prettier = __importStar(require("prettier"));
+const changeCase = __importStar(require("change-case"));
+const fse = __importStar(require("fs-extra"));
+const _ = __importStar(require("lodash/fp"));
+const mssql = __importStar(require("mssql"));
 // @ts-ignore
-const TSqlString = require("tsqlstring");
+const TSqlString = __importStar(require("tsqlstring"));
 const json_schema_to_typescript_1 = require("json-schema-to-typescript");
 const getDuplicates_1 = require("../lib/getDuplicates");
 const isNotNullOrUndefined_1 = require("../lib/isNotNullOrUndefined");
@@ -25,8 +51,9 @@ const MySQL_1 = require("../runtime/lib/MySQL");
 let query = undefined;
 let dialect = "mysql";
 const json2TsOpts = {
-    bannerComment: "",
+    bannerComment: ""
 };
+const keyFields = "$fields";
 async function generate(input) {
     if (input.tables != null && input.excludeTables != null) {
         throw new Error("Must specify either `tables` or `excludeTables`, not both");
@@ -57,22 +84,26 @@ async function generate(input) {
         getPatchOneData(x, specialCaseUuidColumn, includeMappedFields),
         getPatchListData(x),
         getDeleteOneData(x),
-        getDeleteListData(x),
+        getDeleteListData(x)
     ]));
-    const artifactsSource = await getArtifactsSource(tables, includeMappedFields, specialCaseUuidColumn);
-    const sdkSource = await getSDKSource(data, specialCaseUuidColumn, supplementClientOpts);
+    const artifacts = await getArtifacts(tables, includeMappedFields, specialCaseUuidColumn);
+    const artifactsSource = getArtifactsSource(artifacts);
+    const sdkSource = await getSDKSource(data, specialCaseUuidColumn, supplementClientOpts, artifacts);
     const sdkFilename = "index.ts";
+    const sourceIRuntimeFilePath = fs.existsSync(path.join(__dirname, "../runtime", "IRuntime.ts"))
+        ? path.join(__dirname, "../runtime", "IRuntime.ts")
+        : path.join(__dirname, "../runtime", "IRuntime.js");
+    const IRuntimeFilename = path.basename(sourceIRuntimeFilePath);
     const artifactsFilename = "artifacts.ts";
-    const IRuntimeFilename = "IRuntime.d.ts";
     const tsConfigJSON = {
         compilerOptions: {
             module: "commonjs",
             moduleResolution: "node",
             target: "es2020",
             declaration: true,
-            outDir: "./sdk-ts",
+            outDir: "./sdk-ts"
         },
-        include: [sdkFilename, artifactsFilename, IRuntimeFilename],
+        include: [sdkFilename, artifactsFilename, IRuntimeFilename]
     };
     const packageJSON = {
         name: "temp",
@@ -81,14 +112,15 @@ async function generate(input) {
         dependencies: require("../../package.json").dependencies,
         devDependencies: {
             "@types/node": require("../../package.json").devDependencies["@types/node"],
-            typescript: require("../../package.json").devDependencies.typescript,
-        },
+            typescript: require("../../package.json").devDependencies.typescript
+        }
     };
-    const tmpDirPath = path.join(os.tmpdir(), `dsg-${(0, uuid_1.v4)()}`);
+    const tmpDirPath = path.join(os.tmpdir(), 
+    // _ because - in filename is not supported by mysql2sqlite
+    `dsg_${node_crypto_1.default.randomUUID()}`.replace(/-/g, "_"));
     fse.mkdirpSync(tmpDirPath);
     fs.writeFileSync(path.join(tmpDirPath, sdkFilename), sdkSource);
     fs.writeFileSync(path.join(tmpDirPath, artifactsFilename), artifactsSource);
-    const sourceIRuntimeFilePath = path.join(__dirname, "../runtime", IRuntimeFilename);
     fse.copyFileSync(sourceIRuntimeFilePath, path.join(tmpDirPath, IRuntimeFilename));
     const typesDirPath = path.join(tmpDirPath, "types");
     fse.mkdirpSync(typesDirPath);
@@ -128,7 +160,40 @@ async function generate(input) {
         .join("\n"));
     // TODO: workaround for IRuntime.d.ts not being included
     // copyFileSync hangs for some reason, so use writeFileSync + readFileSync instead
-    fs.writeFileSync(path.join(tmpBuildOutputPath, IRuntimeFilename), fs.readFileSync(sourceIRuntimeFilePath));
+    fs.writeFileSync(path.join(tmpBuildOutputPath, "IRuntime.d.ts"), fs.existsSync(path.join(__dirname, "../runtime", "IRuntime.d.ts"))
+        ? fs.readFileSync(path.join(__dirname, "../runtime", "IRuntime.d.ts"))
+        : fs.readFileSync(sourceIRuntimeFilePath));
+    if (dialect === "mysql" && input.outputSqliteSchema) {
+        // Since mysql2sqlite outputs a malformed string if a column
+        // has the name `enum`, temporarily change the name to something else,
+        // then change it back.
+        const enumMarker = "`" + node_crypto_1.default.randomUUID() + "`";
+        const schemaMySql = Object.values(artifacts)
+            .reduce((acc, x) => {
+            let d = x.dump?.schema;
+            if (!d) {
+                return acc;
+            }
+            d = d.replace(/`enum`/g, enumMarker);
+            d += ";";
+            acc.push(d);
+            return acc;
+        }, [])
+            .join("\n\n");
+        const mysql2SqliteSrc = getMysql2sqliteSrc();
+        const mysql2SqlitePath = path.join(tmpDirPath, "mysql2sqlite");
+        fs.writeFileSync(mysql2SqlitePath, mysql2SqliteSrc);
+        fs.chmodSync(mysql2SqlitePath, 0o755);
+        const tmpMySqlSchemaFilename = "tmp.sql";
+        const tmpMySqlSchemaPath = path.join(tmpDirPath, tmpMySqlSchemaFilename);
+        fs.writeFileSync(tmpMySqlSchemaPath, schemaMySql);
+        let schemaSqlite = child_process
+            .execFileSync(mysql2SqlitePath, [tmpMySqlSchemaFilename], { cwd: tmpDirPath })
+            .toString();
+        schemaSqlite = schemaSqlite.replace(new RegExp(enumMarker, "g"), "`enum`");
+        const src = prettier.format(`module.exports = { schema: \`${schemaSqlite.replace(/`/g, "\\`")}\` }`, { parser: "babel" });
+        fs.writeFileSync(path.join(tmpBuildOutputPath, "artifacts.sqlite.js"), src);
+    }
     if (!fs.existsSync(outdir)) {
         fse.mkdirpSync(outdir);
     }
@@ -145,17 +210,17 @@ function init(input) {
             password,
             host,
             port,
-            database,
+            database
         });
         query = mysql.query.bind(mysql);
     }
-    if (dialect === "mssql" || dialect === "ksql") {
+    if (dialect === "mssql") {
         const pool = new mssql.ConnectionPool({
             server: server ?? "localhost",
             user,
             password,
             port,
-            database,
+            database
         });
         const poolConnect = pool.connect();
         async function runMSSQLQuery(...input) {
@@ -170,7 +235,7 @@ function init(input) {
 }
 // It's a bit awkward to put __whereNeedsProcessing, __prepareWhere on the class,
 // but it allows us to share the same database pool, clientOpts, etc.
-async function getSDKSource(input, specialCaseUuidColumn, supplementClientOpts) {
+async function getSDKSource(input, specialCaseUuidColumn, supplementClientOpts, artifacts) {
     function getTypeImports() {
         let set = new Set();
         for (let d of input) {
@@ -179,7 +244,7 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementClientOpts)
                 "typeReturnBaseName",
                 "typeWhereName",
                 "typeOrderByName",
-                "typeDataName",
+                "typeDataName"
             ]) {
                 const str = d[k];
                 if (str) {
@@ -204,10 +269,13 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementClientOpts)
       clientOpts: { [k: string]: any; },
       otherOpts?: { [k: string]: any; }
      }) {
-      opts.otherOpts = opts.otherOpts ?? {}
+      let otherOpts = opts.otherOpts ?? {};
+      if (opts.clientOpts.filename === ":memory:") {
+        otherOpts = { ...otherOpts, createTablesString: require("./artifacts.sqlite").schema }
+      }
       this.runtime = new opts.runtime(opts.clientOpts, ${supplementClientOpts === true
-        ? "{ supplementClientOpts: true, ...opts.otherOpts }"
-        : "opts.otherOpts"}, artifacts);
+        ? "{ supplementClientOpts: true, ...otherOpts }"
+        : "otherOpts"}, artifacts);
     }
 
     $use(middleware: TMiddleware) {
@@ -233,159 +301,362 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementClientOpts)
       return this.runtime.$shutdown();
     }
 
+    async $startTransaction(input?: {
+      isolationLevel?:
+        | "READ UNCOMMITTED"
+        | "READ COMMITTED"
+        | "REPEATABLE READ"
+        | "SERIALIZABLE"
+    }) {
+      const { dbCall, commit, rollback } = await this.runtime.$startTransaction(input);
+      const runtime = this.runtime;
+      return {
+        $commit: commit,
+        $rollback: rollback,
+        ${(await Promise.all(input.flatMap(async (x) => {
+        if (x.kind === "getOne") {
+            const findOnes = await getFindOnes(x, specialCaseUuidColumn);
+            return getMethodSourceGetOne(x, findOnes, true);
+        }
+        if (x.kind === "getList") {
+            return getMethodSourceGetList(x, true);
+        }
+        if (x.kind === "getListPaginated") {
+            return getMethodSourceGetListPaginated(x, true);
+        }
+        if (x.kind === "postOne") {
+            return getMethodSourcePostOne(x, specialCaseUuidColumn, true);
+        }
+        if (x.kind === "patchOne") {
+            const findOnes = await getFindOnes(x, specialCaseUuidColumn);
+            return getMethodSourcePatchOne(x, findOnes, true);
+        }
+        if (x.kind === "patchList") {
+            return getMethodSourcePatchList(x, true);
+        }
+        if (x.kind === "deleteOne") {
+            const findOnes = await getFindOnes(x, specialCaseUuidColumn);
+            return getMethodSourceDeleteOne(x, findOnes, true);
+        }
+        if (x.kind === "deleteList") {
+            return getMethodSourceDeleteList(x, true);
+        }
+    }))).join(",\n")}
+      }
+    }
+
     ${(await Promise.all(input.flatMap(async (x) => {
-        let findOnes = [];
-        const primaryColumn = await getPrimaryColumn(x.table);
-        const uniqueColumns = await getUniqueColumns(x.table, specialCaseUuidColumn);
-        findOnes = findOnes
-            .concat([primaryColumn])
-            .concat(uniqueColumns)
-            .map((x) => ({
-            ...x,
-            type: x.type === "integer" ? "number" : x.type,
-        }));
         if (x.kind === "getOne") {
-            return `async ${x.methodName}(
-                param1: ${findOnes
-                .map((findOne) => `{ ${findOne.name}: ${findOne.type}${findOne.nullable ? " | null" : ""} }`)
-                .join(" | ")}, 
-                param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, skipCache?: boolean, context?: TContext }
-              ): Promise<${x.typeReturnBaseName}> {
-              return this.runtime.resolve(
-                {
-                  resource: "${x.table}",
-                  action: "findUnique",
-                  args: { $where: param1 },
-                  fields: param2?.fields,
-                  artifacts,
-                  context: param2?.context,
-                  skipCache: param2?.skipCache
-                }
-              );
-            }`;
+            const findOnes = await getFindOnes(x, specialCaseUuidColumn);
+            return getMethodSourceGetOne(x, findOnes, false);
         }
         if (x.kind === "getList") {
-            return `async ${x.methodName}(
-            param1: { $where?: ${x.typeWhereName}, $orderBy?: ${x.typeOrderByName}, $limit?: number }, 
-            param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, skipCache?: boolean, context?: TContext }
-          ): Promise<Array<${x.typeReturnBaseName}>> {
-            return this.runtime.resolve(
-              {
-                resource: "${x.table}",
-                action: "findMany",
-                args: param1,
-                fields: param2?.fields,
-                artifacts,
-                context: param2?.context,
-                skipCache: param2?.skipCache
-              }
-            );
-          }`;
+            return getMethodSourceGetList(x, false);
         }
         if (x.kind === "getListPaginated") {
-            return `async ${x.methodName}(
-            param1: { $where?: ${x.typeWhereName}, $orderBy?: ${x.typeOrderByName}, $paginate: Paginate }, 
-            param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, skipCache?: boolean, context?: TContext }
-          ): Promise<ListPaginated<${x.typeReturnBaseName}>> {
-            return this.runtime.resolve(
-              {
-                resource: "${x.table}",
-                action: "findManyPaginated",
-                args: param1,
-                fields: param2?.fields,
-                artifacts,
-                context: param2?.context,
-                skipCache: param2?.skipCache
-              }
-            );
-          }`;
+            return getMethodSourceGetListPaginated(x, false);
         }
         if (x.kind === "postOne") {
-            return `async ${x.methodName}(
-            data: ${x.typeDataName}, 
-            param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, context?: TContext }
-          ): Promise<${x.typeReturnBaseName}> {
-          return this.runtime.resolve({
-            resource: "${x.table}",
-            action: "create",
-            data,
-            artifacts,
-            fields: param2?.fields,
-            context: {...param2?.context, specialCaseUuidColumn: ${JSON.stringify(specialCaseUuidColumn)}}
-          });
-        }`;
+            return getMethodSourcePostOne(x, specialCaseUuidColumn, false);
         }
         if (x.kind === "patchOne") {
-            return `async ${x.methodName}(
-              param1: ${findOnes
-                .map((findOne) => `{ ${findOne.name}: ${findOne.type}${findOne.nullable ? " | null" : ""} }`)
-                .join(" | ")}, 
-            data: ${x.typeDataName}, 
-            param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, context?: TContext }
-          ): Promise<${x.typeReturnBaseName}> {
-          return this.runtime.resolve({
-            resource: "${x.table}",
-            action: "update",
-            args: { $where: param1 },
-            data,
-            artifacts,
-            fields: param2?.fields,
-            context: param2?.context
-          });
-        }`;
+            const findOnes = await getFindOnes(x, specialCaseUuidColumn);
+            return getMethodSourcePatchOne(x, findOnes, false);
         }
         if (x.kind === "patchList") {
-            return `async ${x.methodName}(
-            param1: { $where?: ${x.typeWhereName} }, 
-            data: ${x.typeDataName}, 
-            param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, context?: TContext }
-          ): Promise<Array<${x.typeReturnBaseName}>> {
-          return this.runtime.resolve({
-            resource: "${x.table}",
-            action: "updateMany",
-            args: param1,
-            data,
-            artifacts,
-            fields: param2?.fields,
-            context: param2?.context
-          });
-        }`;
+            return getMethodSourcePatchList(x, false);
         }
         if (x.kind === "deleteOne") {
-            return `async ${x.methodName}(
-              param1: ${findOnes
-                .map((findOne) => `{ ${findOne.name}: ${findOne.type}${findOne.nullable ? " | null" : ""} }`)
-                .join(" | ")},
-            param2?: { correlationId?: string, context?: TContext }
-          ): Promise<void> {
-            await this.runtime.resolve({
-              resource: "${x.table}",
-              action: "delete",
-              args: { $where: param1 },
-              artifacts,
-              context: param2?.context
-            });
-          }`;
+            const findOnes = await getFindOnes(x, specialCaseUuidColumn);
+            return getMethodSourceDeleteOne(x, findOnes, false);
         }
         if (x.kind === "deleteList") {
-            return `async ${x.methodName}(
-            param1: { $where?: ${x.typeWhereName} },
-            param2?: { correlationId?: string, context?: TContext }
-          ): Promise<void> {
-            await this.runtime.resolve({
-              resource: "${x.table}",
-              action: "deleteMany",
-              args: param1,
-              artifacts,
-              context: param2?.context
-            });
-          }`;
+            return getMethodSourceDeleteList(x, false);
         }
     }))).join("\n\n")}
   }
+
+  ${await Promise.all(Object.entries(artifacts).map(async ([table, tableArtifacts]) => {
+        const jsonSchema = {
+            type: "object",
+            properties: tableArtifacts.fields.reduce((acc, x) => {
+                if (x.kind === "object") {
+                    return acc;
+                }
+                if (x.kind === "scalar" && x.mapped) {
+                    return acc;
+                }
+                acc[x.name] =
+                    x.kind === "enum"
+                        ? { enum: x.values }
+                        : { type: getJSONTypes(x.type, x.nullable) };
+                return acc;
+            }, {}),
+            required: tableArtifacts.fields
+                .filter((x) => x.kind === "scalar" || x.kind === "enum")
+                .map((x) => x.name),
+            additionalProperties: false
+        };
+        return (0, json_schema_to_typescript_1.compile)(jsonSchema, getTypeReturnName(table), json2TsOpts);
+    })).then((xs) => xs.join(";\n\n"))}
+
+  ${Object.entries(artifacts)
+        .map(([table, tableArtifacts]) => {
+        // https://pkerschbaum.com/blog/how-prisma-adapts-result-types-based-on-the-actual-arguments-given
+        // https://github.com/pkerschbaum/how-prisma-adapts-result-types-based-on-the-actual-arguments-given_example/blob/main/prisma/lib/prisma-client/index.d.ts
+        return `export type ${getTypeGetPayloadName(table)}<S extends { ${keyFields}?: ${getTypeFieldsName(table)} } | boolean, U = keyof S> = S extends true ? ${getTypeReturnName(table)} : S extends { ${keyFields}?: ${getTypeFieldsName(table)}, [k: string]: any } ?  "${keyFields}" extends U ? S["${keyFields}"] extends undefined ? ${getTypeReturnName(table)} : { [P in TrueKeys<S["${keyFields}"]>]: ${tableArtifacts.fields
+            .reduce((acc, x) => {
+            if (x.kind !== "object") {
+                return acc;
+            }
+            let str = `P extends "${x.name}" ? ${getTypeGetPayloadName(x.type)}<S["${keyFields}"][P]>`;
+            if (x.isList) {
+                str += "[]";
+            }
+            if (x.nullable) {
+                str += " | null";
+            }
+            str += " : ";
+            acc.push(str);
+            return acc;
+        }, [])
+            .join("")} ${tableArtifacts.fields
+            .reduce((acc, x) => {
+            if (x.kind === "scalar" && x.mapped) {
+                let type = x.type;
+                if (x.nullable) {
+                    type += " | null";
+                }
+                const str = `P extends "${x.name}" ? ${type} : `;
+                acc.push(str);
+            }
+            return acc;
+        }, [])
+            .join("")} P extends keyof ${getTypeReturnName(table)} ? ${getTypeReturnName(table)}[P] : never } : ${getTypeReturnName(table)} : ${getTypeReturnName(table)}`;
+    })
+        .join(";\n\n")}
+
+  // Utils
+
+  type Pick2<T, K extends keyof T> = { [P in K]: T[P]; };
+  
+  type RequiredKeys<T> = {
+    [K in keyof T]-?: {} extends Pick2<T, K> ? never : K;
+  }[keyof T];
+  
+  type TruthyKeys<T> = {
+    [key in keyof T]: T[key] extends false | undefined | null ? never : key;
+  }[keyof T];
+  
+  type TrueKeys<T> = TruthyKeys<Pick2<T, RequiredKeys<T>>>;
+  
+  type SelectSubset<T, U> = {
+    [key in keyof T]: key extends keyof U ? T[key] : never;
+  }
+
+  type HasSelect = { ${keyFields}: any; };
+
+  type CheckSelect<T, S, U> =  T extends HasSelect ? U : S;
   `;
     return prettier.format(src, { parser: "typescript" });
 }
+async function getFindOnes(x, specialCaseUuidColumn) {
+    let findOnes = [];
+    const primaryColumn = await getPrimaryColumn(x.table);
+    const uniqueColumns = await getUniqueColumns(x.table, specialCaseUuidColumn);
+    findOnes = findOnes
+        .concat([primaryColumn])
+        .concat(uniqueColumns)
+        .map((x) => ({
+        ...x,
+        type: x.type === "integer" ? "number" : x.type
+    }));
+    return findOnes;
+}
+function getMethodSourceGetOne(x, findOnes, isTransaction) {
+    const param2 = `{ ${keyFields}?: ${x.typeFieldsName}, correlationId?: string, skipCache?: boolean, context?: TContext }`;
+    return `async ${x.methodName}<T extends ${param2}>(
+    param1: ${findOnes
+        .map((findOne) => `{ ${findOne.name}: ${findOne.type}${findOne.nullable ? " | null" : ""} }`)
+        .join(" | ")}, 
+    param2?: SelectSubset<T, ${param2}>
+  ): Promise<CheckSelect<T, ${getTypeReturnName(x.table)}, ${getTypeGetPayloadName(x.table)}<T>>> {
+  return ${isTransaction ? "runtime" : "this.runtime"}.resolve(
+    {
+      resource: "${x.table}",
+      action: "${mapKindToAction(x.kind)}",
+      args: { $where: param1 },
+      fields: param2?.$fields as any,
+      artifacts,
+      context: param2?.context,
+      skipCache: param2?.skipCache,
+      ${isTransaction ? "dbCall" : ""}
+    }
+  );
+}`;
+}
+function getMethodSourceGetList(x, isTransaction) {
+    const param2 = `{ ${keyFields}?: ${x.typeFieldsName}, correlationId?: string, skipCache?: boolean, context?: TContext }`;
+    return `async ${x.methodName}<T extends ${param2}>(
+    param1: { $where?: ${x.typeWhereName}, $orderBy?: ${x.typeOrderByName}, $limit?: number },
+    param2?: SelectSubset<T, ${param2}>
+  ): Promise<Array<CheckSelect<T, ${getTypeReturnName(x.table)}, ${getTypeGetPayloadName(x.table)}<T>>>> {
+    return ${isTransaction ? "runtime" : "this.runtime"}.resolve(
+      {
+        resource: "${x.table}",
+        action: "${mapKindToAction(x.kind)}",
+        args: param1,
+        fields: param2?.$fields as any,
+        artifacts,
+        context: param2?.context,
+        skipCache: param2?.skipCache,
+        ${isTransaction ? "dbCall" : ""}
+      }
+    );
+  }`;
+}
+function getMethodSourceGetListPaginated(x, isTransaction) {
+    const param2 = `{ ${keyFields}?: ${x.typeFieldsName}, correlationId?: string, skipCache?: boolean, context?: TContext }`;
+    return `async ${x.methodName}<T extends ${param2}>(
+    param1: { $where?: ${x.typeWhereName}, $orderBy?: ${x.typeOrderByName}, $paginate: Paginate },
+    param2?: SelectSubset<T, ${param2}>
+  ): Promise<ListPaginated<CheckSelect<T, ${getTypeReturnName(x.table)}, ${getTypeGetPayloadName(x.table)}<T>>>> {
+    return ${isTransaction ? "runtime" : "this.runtime"}.resolve(
+      {
+        resource: "${x.table}",
+        action: "${mapKindToAction(x.kind)}",
+        args: param1,
+        fields: param2?.$fields as any,
+        artifacts,
+        context: param2?.context,
+        skipCache: param2?.skipCache,
+        ${isTransaction ? "dbCall" : ""}
+      }
+    );
+  }`;
+}
+function getMethodSourcePostOne(x, specialCaseUuidColumn, isTransaction) {
+    const param2 = `{ ${keyFields}?: ${x.typeFieldsName}, correlationId?: string, context?: TContext }`;
+    return `async ${x.methodName}<T extends ${param2}>(
+    data: ${x.typeDataName},
+    param2?: SelectSubset<T, ${param2}>
+  ): Promise<CheckSelect<T, ${getTypeReturnName(x.table)}, ${getTypeGetPayloadName(x.table)}<T>>> {
+  return ${isTransaction ? "runtime" : "this.runtime"}.resolve({
+    resource: "${x.table}",
+    action: "${mapKindToAction(x.kind)}",
+    data,
+    artifacts,
+    fields: param2?.$fields as any,
+    context: {...param2?.context, specialCaseUuidColumn: ${JSON.stringify(specialCaseUuidColumn)}},
+    ${isTransaction ? "dbCall" : ""}
+  });
+}`;
+}
+function getMethodSourcePatchOne(x, findOnes, isTransaction) {
+    const param2 = `{ ${keyFields}?: ${x.typeFieldsName}, correlationId?: string, context?: TContext }`;
+    return `async ${x.methodName}<T extends ${param2}>(
+    param1: ${findOnes
+        .map((findOne) => `{ ${findOne.name}: ${findOne.type}${findOne.nullable ? " | null" : ""} }`)
+        .join(" | ")},
+  data: ${x.typeDataName},
+  param2?: SelectSubset<T, ${param2}>
+): Promise<CheckSelect<T, ${getTypeReturnName(x.table)}, ${getTypeGetPayloadName(x.table)}<T>>> {
+return ${isTransaction ? "runtime" : "this.runtime"}.resolve({
+  resource: "${x.table}",
+  action: "${mapKindToAction(x.kind)}",
+  args: { $where: param1 },
+  data,
+  artifacts,
+  fields: param2?.$fields as any,
+  context: param2?.context,
+  ${isTransaction ? "dbCall" : ""}
+});
+}`;
+}
+function getMethodSourcePatchList(x, isTransaction) {
+    const param2 = `{ ${keyFields}?: ${x.typeFieldsName}, correlationId?: string, context?: TContext }`;
+    return `async ${x.methodName}<T extends ${param2}>(
+    param1: { $where?: ${x.typeWhereName}, $orderBy?: ${x.typeOrderByName} },
+    data: ${x.typeDataName},
+    param2?: SelectSubset<T, ${param2}>
+  ): Promise<Array<CheckSelect<T, ${getTypeReturnName(x.table)}, ${getTypeGetPayloadName(x.table)}<T>>>> {
+  return ${isTransaction ? "runtime" : "this.runtime"}.resolve({
+    resource: "${x.table}",
+    action: "${mapKindToAction(x.kind)}",
+    args: param1,
+    data,
+    artifacts,
+    fields: param2?.$fields as any,
+    context: param2?.context,
+    ${isTransaction ? "dbCall" : ""}
+  });
+}`;
+}
+function getMethodSourceDeleteOne(x, findOnes, isTransaction) {
+    return `async ${x.methodName}(
+    param1: ${findOnes
+        .map((findOne) => `{ ${findOne.name}: ${findOne.type}${findOne.nullable ? " | null" : ""} }`)
+        .join(" | ")},
+  param2?: { correlationId?: string, context?: TContext }
+): Promise<void> {
+  await ${isTransaction ? "runtime" : "this.runtime"}.resolve({
+    resource: "${x.table}",
+    action: "${mapKindToAction(x.kind)}",
+    args: { $where: param1 },
+    artifacts,
+    context: param2?.context,
+    ${isTransaction ? "dbCall" : ""}
+  });
+}`;
+}
+function getMethodSourceDeleteList(x, isTransaction) {
+    return `async ${x.methodName}(
+    param1: { $where?: ${x.typeWhereName} },
+    param2?: { correlationId?: string, context?: TContext }
+  ): Promise<void> {
+    await ${isTransaction ? "runtime" : "this.runtime"}.resolve({
+      resource: "${x.table}",
+      action: "${mapKindToAction(x.kind)}",
+      args: param1,
+      artifacts,
+      context: param2?.context,
+      ${isTransaction ? "dbCall" : ""}
+    });
+  }`;
+}
+function mapKindToAction(kind) {
+    if (kind === "getOne") {
+        return "findUnique";
+    }
+    if (kind === "getList") {
+        return "findMany";
+    }
+    if (kind === "getListPaginated") {
+        return "findManyPaginated";
+    }
+    if (kind === "postOne") {
+        return "create";
+    }
+    if (kind === "patchOne") {
+        return "update";
+    }
+    if (kind === "patchList") {
+        return "updateMany";
+    }
+    if (kind === "deleteOne") {
+        return "delete";
+    }
+    if (kind === "deleteList") {
+        return "deleteMany";
+    }
+    throw new Error(`Unhandled kind: ${kind}`);
+}
+function getTypeGetPayloadName(table) {
+    return "GetPayload" + changeCase.pascalCase(table);
+}
+function getTypeReturnName(table) {
+    return changeCase.pascalCase(table);
+}
 function getTypeReturnBaseName(table) {
     return "ReturnBase" + changeCase.pascalCase(table);
 }
@@ -411,7 +682,7 @@ async function getGetOneData(table, includeMappedFields) {
         typeFields: await getTypeFields(table, typeFieldsName, includeMappedFields),
         typeFieldsName,
         typeReturnBase: await getTypeReturnBase(table, typeReturnBaseName, includeMappedFields),
-        typeReturnBaseName,
+        typeReturnBaseName
     };
 }
 async function getGetListData(table) {
@@ -430,7 +701,7 @@ async function getGetListData(table) {
         typeWhere,
         typeWhereName,
         typeOrderBy,
-        typeOrderByName,
+        typeOrderByName
     };
 }
 async function getGetListPaginatedData(table) {
@@ -445,7 +716,7 @@ async function getGetListPaginatedData(table) {
         typeFieldsName,
         typeReturnBaseName,
         typeWhereName,
-        typeOrderByName,
+        typeOrderByName
     };
 }
 async function getPostOneData(table, specialCaseUuidColumn, includeMappedFields) {
@@ -459,7 +730,7 @@ async function getPostOneData(table, specialCaseUuidColumn, includeMappedFields)
         typeFieldsName,
         typeReturnBaseName,
         typeData: await getTypeDataPost(table, typeDataName, specialCaseUuidColumn, includeMappedFields),
-        typeDataName,
+        typeDataName
     };
 }
 async function getPatchOneData(table, specialCaseUuidColumn, includeMappedFields) {
@@ -473,7 +744,7 @@ async function getPatchOneData(table, specialCaseUuidColumn, includeMappedFields
         typeFieldsName,
         typeReturnBaseName,
         typeData: await getTypeDataPatch(table, typeDataName, specialCaseUuidColumn, includeMappedFields),
-        typeDataName,
+        typeDataName
     };
 }
 async function getPatchListData(table) {
@@ -481,6 +752,7 @@ async function getPatchListData(table) {
     const typeReturnBaseName = getTypeReturnBaseName(table);
     const typeWhereName = getTypeWhereName(table);
     const typeDataName = "DataPatch" + changeCase.pascalCase(table);
+    const typeOrderByName = getTypeOrderByName(table);
     return {
         kind: "patchList",
         table,
@@ -489,13 +761,14 @@ async function getPatchListData(table) {
         typeReturnBaseName,
         typeWhereName,
         typeDataName,
+        typeOrderByName
     };
 }
 function getDeleteOneData(table) {
     return {
         kind: "deleteOne",
         table,
-        methodName: "delete" + changeCase.pascalCase(table),
+        methodName: "delete" + changeCase.pascalCase(table)
     };
 }
 function getDeleteListData(table) {
@@ -504,7 +777,7 @@ function getDeleteListData(table) {
         kind: "deleteList",
         table,
         methodName: "delete" + changeCase.pascalCase(table) + "List",
-        typeWhereName,
+        typeWhereName
     };
 }
 async function getTypeWhere(table, name) {
@@ -516,11 +789,11 @@ async function getTypeDataPost(table, name, specialCaseUuidColumn, includeMapped
     const tableMeta = (await getTableMeta(table)).filter((x) => x.Field !== primaryColumn.name);
     const nullable = tableMeta.reduce((acc, m) => ({
         ...acc,
-        [m.Field]: m.Null === "YES" ? true : false,
+        [m.Field]: m.Null === "YES" ? true : false
     }), {});
     const hasDefault = tableMeta.reduce((acc, m) => ({
         ...acc,
-        [m.Field]: m.Default == null ? false : true,
+        [m.Field]: m.Default == null ? false : true
     }), {});
     let properties = getJSONSchemaObjProperties(tableMeta);
     let notRequiredList = [];
@@ -533,7 +806,7 @@ async function getTypeDataPost(table, name, specialCaseUuidColumn, includeMapped
             ...mappedFields.reduce((acc, v) => {
                 acc[v.as] = { type: getJSONTypes(v.type, v.nullable) };
                 return acc;
-            }, {}),
+            }, {})
         };
         notRequiredList = mappedFields.flatMap((x) => [x.as, x.foreignKey]);
         for (let r of oneToManyRelations) {
@@ -548,9 +821,7 @@ async function getTypeDataPost(table, name, specialCaseUuidColumn, includeMapped
             ...oneToManyRelations.reduce((acc, v) => {
                 let tsType = getTypeDataPostName(v.table);
                 const mappedFields = mappedFieldsMap.get(v.table);
-                if (includeMappedFields &&
-                    mappedFields != null &&
-                    mappedFields.length > 0) {
+                if (includeMappedFields && mappedFields != null && mappedFields.length > 0) {
                     tsType = `Omit<${tsType}, ${mappedFields
                         .map((x) => JSON.stringify(x.as))
                         .join(" | ")}>`;
@@ -558,21 +829,19 @@ async function getTypeDataPost(table, name, specialCaseUuidColumn, includeMapped
                 tsType = `{$create: ${tsType}[]}`;
                 acc[v.name] = { tsType };
                 return acc;
-            }, {}),
+            }, {})
         },
         additionalProperties: false,
         required: Object.keys(properties)
             .filter(
         // `uuid` should not be required
-        (x) => !specialCaseUuidColumn || uuidColumn == null
-            ? true
-            : x !== uuidColumn.name)
+        (x) => !specialCaseUuidColumn || uuidColumn == null ? true : x !== uuidColumn.name)
             .filter(
         // Required if column is non-nullable and has no default.
         (x) => !nullable[x] && !hasDefault[x])
             // Instead of doing a union with all possible permutations of UUID and IDs,
             // for simplicity, just make both not required for now.
-            .filter((x) => !notRequiredList.includes(x)),
+            .filter((x) => !notRequiredList.includes(x))
     };
     let type = await (0, json_schema_to_typescript_1.compile)(jsonSchema, name, json2TsOpts);
     const imports = _.uniq(oneToManyRelations
@@ -601,13 +870,13 @@ async function getTypeDataPatch(table, name, specialCaseUuidColumn, includeMappe
         const type = unwrapJSONType(properties[key].type);
         if (type === "string") {
             properties[key] = {
-                oneOf: [properties[key], { tsType: "TUpdateOperationsString" }],
+                oneOf: [properties[key], { tsType: "TUpdateOperationsString" }]
             };
             mustImportTUpdateOperationsString = true;
         }
         else if (type === "number" || type === "integer") {
             properties[key] = {
-                oneOf: [properties[key], { tsType: "TUpdateOperationsNumber" }],
+                oneOf: [properties[key], { tsType: "TUpdateOperationsNumber" }]
             };
             mustImportTUpdateOperationsNumber = true;
         }
@@ -619,14 +888,14 @@ async function getTypeDataPatch(table, name, specialCaseUuidColumn, includeMappe
             ...mappedFields.reduce((acc, v) => {
                 acc[v.as] = { type: getJSONTypes(v.type, v.nullable) };
                 return acc;
-            }, {}),
+            }, {})
         };
     }
     const jsonSchema = {
         type: "object",
         properties,
         additionalProperties: false,
-        required: [],
+        required: []
     };
     let type = await (0, json_schema_to_typescript_1.compile)(jsonSchema, name, json2TsOpts);
     if (mustImportTUpdateOperationsString || mustImportTUpdateOperationsNumber) {
@@ -669,7 +938,7 @@ async function getMappedFields(table) {
             name: "uuid",
             // Replace `Id` with `Uuid`
             as: x.foreignKey.slice(0, -2) + "Uuid",
-            type: getBaseJSONType(uuidColumn.Type),
+            type: getBaseJSONType(uuidColumn.Type)
         });
     }
     return out;
@@ -688,52 +957,52 @@ async function getJSONSchemaWhere(table) {
                             {
                                 type: "object",
                                 properties: { $eq: v },
-                                additionalProperties: false,
+                                additionalProperties: false
                             },
                             {
                                 type: "object",
                                 properties: { $neq: v },
-                                additionalProperties: false,
+                                additionalProperties: false
                             },
                             {
                                 type: "object",
                                 properties: { $gt: v },
-                                additionalProperties: false,
+                                additionalProperties: false
                             },
                             {
                                 type: "object",
                                 properties: { $gte: v },
-                                additionalProperties: false,
+                                additionalProperties: false
                             },
                             {
                                 type: "object",
                                 properties: { $lt: v },
-                                additionalProperties: false,
+                                additionalProperties: false
                             },
                             {
                                 type: "object",
                                 properties: { $lte: v },
-                                additionalProperties: false,
+                                additionalProperties: false
                             },
                             {
                                 type: "object",
                                 properties: { $like: { type: "string", minLength: 1 } },
-                                additionalProperties: false,
+                                additionalProperties: false
                             },
                             {
                                 type: "object",
                                 properties: { $nlike: { type: "string", minLength: 1 } },
-                                additionalProperties: false,
+                                additionalProperties: false
                             },
                             {
                                 type: "object",
                                 properties: { $in: { type: "array", items: v } },
-                                additionalProperties: false,
+                                additionalProperties: false
                             },
                             {
                                 type: "object",
                                 properties: { $nin: { type: "array", items: v } },
-                                additionalProperties: false,
+                                additionalProperties: false
                             },
                             {
                                 type: "object",
@@ -743,10 +1012,10 @@ async function getJSONSchemaWhere(table) {
                                         items: v,
                                         minItems: 2,
                                         maxItems: 2,
-                                        uniqueItems: true,
-                                    },
+                                        uniqueItems: true
+                                    }
                                 },
-                                additionalProperties: false,
+                                additionalProperties: false
                             },
                             {
                                 type: "object",
@@ -756,15 +1025,15 @@ async function getJSONSchemaWhere(table) {
                                         items: v,
                                         minItems: 2,
                                         maxItems: 2,
-                                        uniqueItems: true,
-                                    },
+                                        uniqueItems: true
+                                    }
                                 },
-                                additionalProperties: false,
-                            },
-                        ],
-                    },
+                                additionalProperties: false
+                            }
+                        ]
+                    }
                 }), {}),
-                additionalProperties: false,
+                additionalProperties: false
             },
             {
                 type: "object",
@@ -772,17 +1041,17 @@ async function getJSONSchemaWhere(table) {
                     $and: {
                         type: "array",
                         items: {
-                            $ref: `#/definitions/${whereSchemaName}`,
+                            $ref: `#/definitions/${whereSchemaName}`
                         },
                         // While it makes sense conceptually for $and to have
                         // at least 2 items, in practice, $and could be
                         // generated dynamically and could end up having
                         // less than 2 items, so don't enforce minItems.
                         // minItems: 2,
-                        additionalProperties: false,
-                    },
+                        additionalProperties: false
+                    }
                 },
-                additionalProperties: false,
+                additionalProperties: false
             },
             {
                 type: "object",
@@ -790,19 +1059,19 @@ async function getJSONSchemaWhere(table) {
                     $or: {
                         type: "array",
                         items: {
-                            $ref: `#/definitions/${whereSchemaName}`,
+                            $ref: `#/definitions/${whereSchemaName}`
                         },
                         // While it makes sense conceptually for $and to have
                         // at least 2 items, in practice, $and could be
                         // generated dynamically and could end up having
                         // less than 2 items, so don't enforce minItems.
                         // minItems: 2,
-                        additionalProperties: false,
-                    },
+                        additionalProperties: false
+                    }
                 },
-                additionalProperties: false,
-            },
-        ],
+                additionalProperties: false
+            }
+        ]
     };
     return {
         definitions: { [whereSchemaName]: defWhere },
@@ -819,12 +1088,12 @@ async function getJSONSchemaWhere(table) {
                         // generated dynamically and could end up having
                         // less than 2 items, so don't enforce minItems.
                         // minItems: 2,
-                        additionalProperties: false,
-                    },
+                        additionalProperties: false
+                    }
                 },
-                additionalProperties: false,
-            })),
-        ],
+                additionalProperties: false
+            }))
+        ]
     };
 }
 async function getTypeOrderBy(table, name) {
@@ -837,14 +1106,14 @@ async function getJSONSchemaOrderBy(table, name) {
             type: "object",
             properties: { [k]: { enum: ["asc", "desc"] } },
             required: [k],
-            additionalProperties: false,
-        })),
+            additionalProperties: false
+        }))
     };
     const defName = `_${name}`;
     const _schema = { $ref: `#/definitions/${defName}` };
     return {
         definitions: { [defName]: def },
-        oneOf: [_schema, { type: "array", items: _schema }],
+        oneOf: [_schema, { type: "array", items: _schema }]
     };
 }
 function getTypeTypesIndex(data) {
@@ -858,7 +1127,7 @@ function getTypeTypesIndex(data) {
             "typeReturnBaseName",
             "typeWhereName",
             "typeOrderByName",
-            "typeDataName",
+            "typeDataName"
         ]) {
             const str = d[k];
             if (str) {
@@ -870,7 +1139,7 @@ function getTypeTypesIndex(data) {
         "Paginate",
         "ListPaginated",
         "TUpdateOperationsString",
-        "TUpdateOperationsNumber",
+        "TUpdateOperationsNumber"
     ].join(",")} } from "./_shared";\n\n`;
     let arr = Array.from(set).sort();
     for (let x of arr) {
@@ -896,8 +1165,8 @@ export type ListPaginated<T> = {
   paginationInfo: {
     hasPreviousPage?: boolean,
     hasNextPage?: boolean,
-    startCursor?: string | number,
-    endCursor?: string | number,
+    startCursor?: string,
+    endCursor?: string,
     totalCount: number,
   },
   results: Array<T>,
@@ -915,58 +1184,49 @@ async function getTypeFields(table, name, includeMappedFields) {
     const mappedFields = includeMappedFields ? await getMappedFields(table) : [];
     const keyWhere = "$where";
     const keyOrderBy = "$orderBy";
-    const jsonSchemaFields = {
-        type: "array",
-        items: {
-            anyOf: [
-                {
-                    enum: scalarKeys.concat(mappedFields.map((x) => x.as)),
-                },
-                ...relations.map((x) => {
-                    const argsProperties = x.type === "many-to-many"
-                        ? {
-                            [keyWhere]: {
-                                type: "object",
-                                properties: {
-                                    [x.table]: { tsType: getTypeWhereName(x.table) },
-                                    [x.junctionTable]: {
-                                        tsType: getTypeWhereName(x.junctionTable),
-                                    },
-                                },
-                                additionalProperties: false,
-                            },
+    let properties = {};
+    for (let x of scalarKeys) {
+        properties[x] = { type: "boolean" };
+    }
+    for (let x of mappedFields) {
+        properties[x.as] = { type: "boolean" };
+    }
+    for (let x of relations) {
+        const argsProperties = x.type === "many-to-many"
+            ? {
+                [keyWhere]: {
+                    type: "object",
+                    properties: {
+                        [x.table]: { tsType: getTypeWhereName(x.table) },
+                        [x.junctionTable]: {
+                            tsType: getTypeWhereName(x.junctionTable)
                         }
-                        : { [keyWhere]: { tsType: getTypeWhereName(x.table) } };
-                    // $orderBy only makes sense for a list
-                    if (x.grabMany) {
-                        argsProperties[keyOrderBy] = {
-                            tsType: getTypeOrderByName(x.table),
-                        };
-                    }
-                    return {
-                        type: "object",
-                        properties: {
-                            name: { enum: [x.name] },
-                            as: { type: "string" },
-                            fields: { tsType: getTypeFieldsName(x.table) },
-                            args: {
-                                type: "object",
-                                properties: argsProperties,
-                                additionalProperties: false,
-                            },
-                            transform: { tsType: `(x: any) => any` },
-                        },
-                        additionalProperties: false,
-                        required: ["name", "fields"],
-                    };
-                }),
-            ],
-        },
+                    },
+                    additionalProperties: false
+                }
+            }
+            : { [keyWhere]: { tsType: getTypeWhereName(x.table) } };
+        // $orderBy only makes sense for a list
+        if (x.grabMany) {
+            argsProperties[keyOrderBy] = {
+                tsType: getTypeOrderByName(x.table)
+            };
+        }
+        argsProperties[keyFields] = { tsType: getTypeFieldsName(x.table) };
+        const jsonSchemaArgs = {
+            type: "object",
+            properties: argsProperties,
+            additionalProperties: false
+        };
+        properties[x.name] = { enum: [{ type: "boolean" }, jsonSchemaArgs] };
+    }
+    const jsonSchemaFields = {
+        type: "object",
+        additionalProperties: false,
+        properties
     };
     let type = await (0, json_schema_to_typescript_1.compile)(jsonSchemaFields, name, json2TsOpts);
-    const fieldImports = _.uniq(relations
-        .filter((x) => x.table !== table)
-        .map((x) => getTypeFieldsName(x.table)));
+    const fieldImports = _.uniq(relations.filter((x) => x.table !== table).map((x) => getTypeFieldsName(x.table)));
     const whereImports = _.uniq(relations.flatMap((x) => x.type === "many-to-many"
         ? [getTypeWhereName(x.table), getTypeWhereName(x.junctionTable)]
         : getTypeWhereName(x.table)));
@@ -1006,10 +1266,10 @@ async function getTypeReturnBase(table, name, includeMappedFields) {
                     acc[key] = { tsType };
                 }
                 return acc;
-            }, {}),
+            }, {})
         },
         // Because of aliases
-        additionalProperties: true,
+        additionalProperties: true
     };
     let type = await (0, json_schema_to_typescript_1.compile)(jsonSchemaReturn, name, json2TsOpts);
     const imports = _.uniq(relations.map((x) => getTypeReturnBaseName(x.table)))
@@ -1025,10 +1285,21 @@ function getMaybeNullableTsType(type, nullable) {
     }
     return type;
 }
-async function getArtifactsSource(tables, includeMappedFields, specialCaseUuidColumn) {
+function getArtifactsSource(artifacts) {
+    const src = `
+  import type {IArtifacts} from "./IRuntime";
+
+  export const artifacts: IArtifacts = ${JSON.stringify(artifacts)};
+  `;
+    return prettier.format(src, { parser: "typescript" });
+}
+async function getArtifacts(tables, includeMappedFields, specialCaseUuidColumn) {
     const tableMetaList = await Promise.all(tables.map(async (table) => {
-        const tableMeta = await getTableMeta(table);
-        const primaryKey = await getPrimaryColumn(table).then((x) => x.name);
+        const [tableMeta, primaryKey, dumpSchema] = await Promise.all([
+            getTableMeta(table),
+            getPrimaryColumn(table).then((x) => x.name),
+            getShowCreateTable(table)
+        ]);
         const scalarFields = tableMeta.map((x) => x.Field);
         const relationInfo = await getRelationInfo(table);
         const relationFields = relationInfo.reduce((acc, x) => {
@@ -1040,7 +1311,7 @@ async function getArtifactsSource(tables, includeMappedFields, specialCaseUuidCo
                     table: x.table,
                     grabMany: x.grabMany,
                     nullable: x.nullable,
-                    relation: x.relation,
+                    relation: x.relation
                 };
             }
             else {
@@ -1050,14 +1321,12 @@ async function getArtifactsSource(tables, includeMappedFields, specialCaseUuidCo
                     table: x.table,
                     junctionTable: x.junctionTable,
                     grabMany: x.grabMany,
-                    relations: x.relations,
+                    relations: x.relations
                 };
             }
             return acc;
         }, {});
-        const _mappedFields = includeMappedFields
-            ? await getMappedFields(table)
-            : [];
+        const _mappedFields = includeMappedFields ? await getMappedFields(table) : [];
         const mappedFields = _mappedFields.length === 0
             ? null
             : _mappedFields.reduce((acc, v) => {
@@ -1073,6 +1342,49 @@ async function getArtifactsSource(tables, includeMappedFields, specialCaseUuidCo
             return acc;
         }, {});
         const uniqueFields = await getUniqueColumns(table, specialCaseUuidColumn);
+        let fields = tableMeta.map((t) => {
+            const nullable = t.Null === "YES";
+            const isEnum = t.Type.startsWith("enum");
+            if (isEnum) {
+                const values = getPropertyEnum(t.Type);
+                if (values && nullable) {
+                    values.push(null);
+                }
+                return {
+                    kind: "enum",
+                    values,
+                    name: t.Field,
+                    nullable
+                };
+            }
+            return {
+                kind: "scalar",
+                type: getBaseJSONType(t.Type),
+                name: t.Field,
+                nullable,
+                hasDefaultValue: !!t.Default
+            };
+        });
+        for (let x of _mappedFields) {
+            fields.push({
+                kind: "scalar",
+                type: x.type,
+                name: x.as,
+                nullable: x.nullable,
+                // TODO
+                hasDefaultValue: false,
+                mapped: true
+            });
+        }
+        for (let x of relationInfo) {
+            fields.push({
+                kind: "object",
+                type: x.table,
+                name: x.name,
+                isList: x.grabMany,
+                nullable: x.type === "one-to-many__many-to-one" ? x.nullable : false
+            });
+        }
         return {
             table,
             primaryKey,
@@ -1082,18 +1394,15 @@ async function getArtifactsSource(tables, includeMappedFields, specialCaseUuidCo
             uniqueFields,
             dateTimeFields,
             dateTimeFieldsCount: Object.keys(dateTimeFields).length,
+            fields,
+            dump: dumpSchema == null ? null : { schema: dumpSchema }
         };
     }));
     const artifacts = tableMetaList.reduce((acc, x) => {
         acc[x.table] = x;
         return acc;
     }, {});
-    const src = `
-  import type {IArtifacts} from "./IRuntime";
-
-  export const artifacts: IArtifacts = ${JSON.stringify(artifacts)};
-  `;
-    return prettier.format(src, { parser: "typescript" });
+    return artifacts;
 }
 const getRelationInfo = _.memoize(async function getRelationInfo(table) {
     const relationsManyToOne = await getRelationsManyToOne(table);
@@ -1108,7 +1417,7 @@ const getRelationInfo = _.memoize(async function getRelationInfo(table) {
             table: x.referencedTable,
             name,
             relation: x,
-            nullable: x.nullable,
+            nullable: x.nullable
         };
     }));
     const relationsOneToManyDuplicates = (0, getDuplicates_1.getDuplicates)(relationsOneToMany.map((x) => x.referencedTable));
@@ -1131,7 +1440,7 @@ const getRelationInfo = _.memoize(async function getRelationInfo(table) {
             table: x.referencedTable,
             name,
             relation: x,
-            nullable: x.nullable,
+            nullable: x.nullable
         };
     }));
     const relationsManyToMany = (await getJunctionTables()).reduce((acc, x) => {
@@ -1150,7 +1459,7 @@ const getRelationInfo = _.memoize(async function getRelationInfo(table) {
             name: changeCase.camelCase(dataForChildTable.referencedTable) + "List",
             // Ensure parent comes before child
             relations: [dataForParentTable, dataForChildTable],
-            grabMany: true,
+            grabMany: true
         });
         return acc;
     }, []);
@@ -1171,7 +1480,7 @@ async function getJunctionTables() {
             // e.g. junction of Foo, Bar must be FooBar or BarFoo
             [
                 relations[0].referencedTable + relations[1].referencedTable,
-                relations[1].referencedTable + relations[0].referencedTable,
+                relations[1].referencedTable + relations[0].referencedTable
             ].includes(table)) {
             return { table, relations };
         }
@@ -1227,7 +1536,7 @@ const getRelationsManyToOne = _.memoize(async function getRelationsManyToOne(tab
             foreignKey: v.t1Field,
             referencedTable: v.t2,
             referencedKey: v.t2Field,
-            nullable: tableMeta.find((m) => m.Field === v.t1Field)?.Null === "YES",
+            nullable: tableMeta.find((m) => m.Field === v.t1Field)?.Null === "YES"
         };
     })));
     return _.sortBy((x) => x.referencedTable, xs);
@@ -1276,7 +1585,7 @@ const getRelationsOneToMany = _.memoize(async function getRelationsOneToMany(tab
             referencedTable: v.t1,
             referencedKey: v.t1Field,
             // TODO? I think this is right, since it's one-to-many, so a list
-            nullable: false,
+            nullable: false
         };
     })));
     return _.sortBy((x) => x.referencedKey, _.sortBy((x) => x.referencedTable, xs));
@@ -1291,7 +1600,7 @@ async function getPrimaryColumn(table) {
     return {
         name: column.Field,
         type: getBaseJSONType(column.Type),
-        nullable: column.Null === "YES",
+        nullable: column.Null === "YES"
     };
 }
 async function getUniqueColumns(table, specialCaseUuidColumn) {
@@ -1303,7 +1612,7 @@ async function getUniqueColumns(table, specialCaseUuidColumn) {
         .map((x) => ({
         name: x.Field,
         type: getBaseJSONType(x.Type),
-        nullable: x.Null === "YES",
+        nullable: x.Null === "YES"
     }));
 }
 async function getUuidColumn(table) {
@@ -1315,14 +1624,14 @@ async function getUuidColumn(table) {
     return {
         name: column.Field,
         type: column.Type,
-        nullable: column.Null === "YES",
+        nullable: column.Null === "YES"
     };
 }
 const getTableMeta = _.memoize(async function getTableMeta(table) {
     if (dialect === "mysql") {
         return query("DESCRIBE ??", [table]).then((xs) => _.sortBy((x) => x.Field, xs));
     }
-    if (dialect === "mssql" || dialect === "ksql") {
+    if (dialect === "mssql") {
         const primaryColumn = await query(`SELECT columns.name as COLUMN_NAME
           FROM sys.tables tables
           JOIN sys.columns columns
@@ -1359,12 +1668,20 @@ const getTableMeta = _.memoize(async function getTableMeta(table) {
                         ? "UNI"
                         : "",
                 Null: x["IS_NULLABLE"],
-                Default: x["COLUMN_DEFAULT"],
+                Default: x["COLUMN_DEFAULT"]
             };
         })));
     }
     throw new Error("Unsupported dialect: " + dialect);
 });
+function getShowCreateTable(table) {
+    if (dialect === "mysql") {
+        return query("SHOW CREATE TABLE ??", [table]).then((xs) => xs[0]["Create Table"]
+            // https://github.com/bradzacher/mysqldump/blob/66839a57e572a07c046b0ba98753f30a7026cbd8/src/getSchemaDump.ts#L65
+            .replace(/AUTO_INCREMENT\s*=\s*\d+ /g, ""));
+    }
+    return Promise.resolve(null);
+}
 function getJSONSchemaObjProperties(tableMeta) {
     return tableMeta.reduce((acc, m) => {
         const baseType = getBaseJSONType(m.Type);
@@ -1378,7 +1695,7 @@ function getJSONSchemaObjProperties(tableMeta) {
             _enum.push(null);
         }
         acc[m.Field] = {
-            type: getJSONTypes(baseType, nullable),
+            type: getJSONTypes(baseType, nullable)
             // maxLength:
             //   baseType === "string" && format == null && isEnum == null
             //     ? getPropertyMaxLength(m.Type)
@@ -1488,9 +1805,7 @@ function getPropertyEnum(sqlType) {
     return c;
 }
 function getPropertyFormat(sqlType) {
-    if (sqlType === "datetime" ||
-        sqlType === "datetime2" ||
-        sqlType === "timestamp") {
+    if (sqlType === "datetime" || sqlType === "datetime2" || sqlType === "timestamp") {
         // TODO: not sure this is correct for `timestamp`
         return "date-time";
     }
@@ -1514,13 +1829,13 @@ const mssqlTableExcludes = new Set([
     "ddl_history",
     "index_columns",
     "lsn_time_mapping",
-    "systranschemas",
+    "systranschemas"
 ]);
 async function getTableNames() {
     if (dialect === "mysql") {
         return query("SHOW TABLES").then((xs) => xs.flatMap((x) => Object.values(x)).sort());
     }
-    if (dialect === "mssql" || dialect === "ksql") {
+    if (dialect === "mssql") {
         return query("SELECT * FROM INFORMATION_SCHEMA.TABLES").then((xs) => xs
             .map((x) => x["TABLE_NAME"])
             .filter((x) => !x.startsWith("dbo_") && !mssqlTableExcludes.has(x))
@@ -1528,3 +1843,295 @@ async function getTableNames() {
     }
     throw new Error("Unsupported dialect: " + dialect);
 }
+function getMysql2sqliteSrc() {
+    return `#!/usr/bin/awk -f
+
+# Authors: @esperlu, @artemyk, @gkuenning, @dumblob
+
+# FIXME detect empty input file and issue a warning
+
+function printerr( s ){ print s | "cat >&2" }
+
+BEGIN {
+  if( ARGC != 2 ){
+    printerr( \\
+      "USAGE:\\n"\\
+      "       mysql2sqlite dump_mysql.sql > dump_sqlite3.sql\\n" \\
+      "       OR\\n" \\
+      "       mysql2sqlite dump_mysql.sql | sqlite3 sqlite.db\\n" \\
+      "\\n" \\
+      "NOTES:\\n" \\
+      "       Dash in filename is not supported, because dash (-) means stdin." )
+    no_END = 1
+    exit 1
+  }
+
+  # Find INT_MAX supported by both this AWK (usually an ISO C signed int)
+  #   and SQlite.
+  # On non-8bit-based architectures, the additional bits are safely ignored.
+
+  # 8bit (lower precision should not exist)
+  s="127"
+  # "63" + 0 avoids potential parser misbehavior
+  if( (s + 0) "" == s ){ INT_MAX_HALF = "63" + 0 }
+  # 16bit
+  s="32767"
+  if( (s + 0) "" == s ){ INT_MAX_HALF = "16383" + 0 }
+  # 32bit
+  s="2147483647"
+  if( (s + 0) "" == s ){ INT_MAX_HALF = "1073741823" + 0 }
+  # 64bit (as INTEGER in SQlite3)
+  s="9223372036854775807"
+  if( (s + 0) "" == s ){ INT_MAX_HALF = "4611686018427387904" + 0 }
+#  # 128bit
+#  s="170141183460469231731687303715884105728"
+#  if( (s + 0) "" == s ){ INT_MAX_HALF = "85070591730234615865843651857942052864" + 0 }
+#  # 256bit
+#  s="57896044618658097711785492504343953926634992332820282019728792003956564819968"
+#  if( (s + 0) "" == s ){ INT_MAX_HALF = "28948022309329048855892746252171976963317496166410141009864396001978282409984" + 0 }
+#  # 512bit
+#  s="6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048"
+#  if( (s + 0) "" == s ){ INT_MAX_HALF = "3351951982485649274893506249551461531869841455148098344430890360930441007518386744200468574541725856922507964546621512713438470702986642486608412251521024" + 0 }
+#  # 1024bit
+#  s="89884656743115795386465259539451236680898848947115328636715040578866337902750481566354238661203768010560056939935696678829394884407208311246423715319737062188883946712432742638151109800623047059726541476042502884419075341171231440736956555270413618581675255342293149119973622969239858152417678164812112068608"
+#  if( (s + 0) "" == s ){ INT_MAX_HALF = "44942328371557897693232629769725618340449424473557664318357520289433168951375240783177119330601884005280028469967848339414697442203604155623211857659868531094441973356216371319075554900311523529863270738021251442209537670585615720368478277635206809290837627671146574559986811484619929076208839082406056034304" + 0 }
+#  # higher precision probably not needed
+
+  FS=",$"
+  print "PRAGMA synchronous = OFF;"
+  print "PRAGMA journal_mode = MEMORY;"
+  print "BEGIN TRANSACTION;"
+}
+
+# historically 3 spaces separate non-argument local variables
+function bit_to_int( str_bit,   powtwo, i, res, bit, overflow ){
+  powtwo = 1
+  overflow = 0
+  # 011101 = 1*2^0 + 0*2^1 + 1*2^2 ...
+  for( i = length( str_bit ); i > 0; --i ){
+    bit = substr( str_bit, i, 1 )
+    if( overflow || ( bit == 1 && res > INT_MAX_HALF ) ){
+      printerr( \\
+        NR ": WARN Bit field overflow, number truncated (LSBs saved, MSBs ignored)." )
+      break
+    }
+    res = res + bit * powtwo
+    # no warning here as it might be the last iteration
+    if( powtwo > INT_MAX_HALF ){ overflow = 1; continue }
+    powtwo = powtwo * 2
+  }
+  return res
+}
+
+# CREATE TRIGGER statements have funny commenting. Remember we are in trigger.
+/^\\/\\*.*(CREATE.*TRIGGER|create.*trigger)/ {
+  gsub( /^.*(TRIGGER|trigger)/, "CREATE TRIGGER" )
+  print
+  inTrigger = 1
+  next
+}
+# The end of CREATE TRIGGER has a stray comment terminator
+/(END|end) \\*\\/;;/ { gsub( /\\*\\//, "" ); print; inTrigger = 0; next }
+# The rest of triggers just get passed through
+inTrigger != 0 { print; next }
+
+# CREATE VIEW looks like a TABLE in comments
+/^\\/\\*.*(CREATE.*TABLE|create.*table)/ {
+  inView = 1
+  next
+}
+# end of CREATE VIEW
+/^(\\).*(ENGINE|engine).*\\*\\/;)/ {
+  inView = 0
+  next
+}
+# content of CREATE VIEW
+inView != 0 { next }
+
+# skip comments
+/^\\/\\*/ { next }
+
+# skip PARTITION statements
+/^ *[(]?(PARTITION|partition) +[^ ]+/ { next }
+
+# print all INSERT lines
+( /^ *\\(/ && /\\) *[,;] *$/ ) || /^(INSERT|insert|REPLACE|replace)/ {
+  prev = ""
+
+  # first replace \\\\ by \\_ that mysqldump never generates to deal with
+  # sequnces like \\\\n that should be translated into \\n, not \\<LF>.
+  # After we convert all escapes we replace \\_ by backslashes.
+  gsub( /\\\\\\\\/, "\\\\_" )
+
+  # single quotes are escaped by another single quote
+  gsub( /\\\\'/, "''" )
+  gsub( /\\\\n/, "\\n" )
+  gsub( /\\\\r/, "\\r" )
+  gsub( /\\\\"/, "\\"" )
+  gsub( /\\\\\\032/, "\\032" )  # substitute char
+
+  gsub( /\\\\_/, "\\\\" )
+
+  # sqlite3 is limited to 16 significant digits of precision
+  while( match( $0, /0x[0-9a-fA-F]{17}/ ) ){
+    hexIssue = 1
+    sub( /0x[0-9a-fA-F]+/, substr( $0, RSTART, RLENGTH-1 ), $0 )
+  }
+  if( hexIssue ){
+    printerr( \\
+      NR ": WARN Hex number trimmed (length longer than 16 chars)." )
+    hexIssue = 0
+  }
+  print
+  next
+}
+
+# CREATE DATABASE is not supported
+/^(CREATE DATABASE|create database)/ { next }
+
+# print the CREATE line as is and capture the table name
+/^(CREATE|create)/ {
+  if( $0 ~ /IF NOT EXISTS|if not exists/ || $0 ~ /TEMPORARY|temporary/ ){
+    caseIssue = 1
+    printerr( \\
+      NR ": WARN Potential case sensitivity issues with table/column naming\\n" \\
+      "          (see INFO at the end)." )
+  }
+  if( match( $0, /\`[^\`]+/ ) ){
+    tableName = substr( $0, RSTART+1, RLENGTH-1 )
+  }
+  aInc = 0
+  prev = ""
+  firstInTable = 1
+  print
+  next
+}
+
+# Replace \`FULLTEXT KEY\` (probably other \`XXXXX KEY\`)
+/^  (FULLTEXT KEY|fulltext key)/ { gsub( /[A-Za-z ]+(KEY|key)/, "  KEY" ) }
+
+# Get rid of field lengths in KEY lines
+/ (PRIMARY |primary )?(KEY|key)/ { gsub( /\\([0-9]+\\)/, "" ) }
+
+aInc == 1 && /PRIMARY KEY|primary key/ { next }
+
+# Replace COLLATE xxx_xxxx_xx statements with COLLATE BINARY
+/ (COLLATE|collate) [a-z0-9_]*/ { gsub( /(COLLATE|collate) [a-z0-9_]*/, "COLLATE BINARY" ) }
+
+# Print all fields definition lines except the \`KEY\` lines.
+/^  / && !/^(  (KEY|key)|\\);)/ {
+  if( match( $0, /[^"\`]AUTO_INCREMENT|auto_increment[^"\`]/) ){
+    aInc = 1
+    gsub( /AUTO_INCREMENT|auto_increment/, "PRIMARY KEY AUTOINCREMENT" )
+  }
+  gsub( /(UNIQUE KEY|unique key) (\`.*\`|".*") /, "UNIQUE " )
+  gsub( /(CHARACTER SET|character set) [^ ]+[ ,]/, "" )
+  # FIXME
+  #   CREATE TRIGGER [UpdateLastTime]
+  #   AFTER UPDATE
+  #   ON Package
+  #   FOR EACH ROW
+  #   BEGIN
+  #   UPDATE Package SET LastUpdate = CURRENT_TIMESTAMP WHERE ActionId = old.ActionId;
+  #   END
+  gsub( /(ON|on) (UPDATE|update) (CURRENT_TIMESTAMP|current_timestamp)(\\(\\))?/, "" )
+  gsub( /(DEFAULT|default) (CURRENT_TIMESTAMP|current_timestamp)(\\(\\))?/, "DEFAULT current_timestamp")
+  gsub( /(COLLATE|collate) [^ ]+ /, "" )
+  gsub( /(ENUM|enum)[^)]+\\)/, "text " )
+  gsub( /(SET|set)\\([^)]+\\)/, "text " )
+  gsub( /UNSIGNED|unsigned/, "" )
+  gsub( /_utf8mb3/, "" )
+  gsub( /\` [^ ]*(INT|int|BIT|bit)[^ ]*/, "\` integer" )
+  gsub( /" [^ ]*(INT|int|BIT|bit)[^ ]*/, "\\" integer" )
+  ere_bit_field = "[bB]'[10]+'"
+  if( match($0, ere_bit_field) ){
+    sub( ere_bit_field, bit_to_int( substr( $0, RSTART +2, RLENGTH -2 -1 ) ) )
+  }
+
+  # remove USING BTREE and other suffixes for USING, for example: "UNIQUE KEY
+  # \`hostname_domain\` (\`hostname\`,\`domain\`) USING BTREE,"
+  gsub( / USING [^, ]+/, "" )
+
+  # field comments are not supported
+  gsub( / (COMMENT|comment).+$/, "" )
+  # Get commas off end of line
+  gsub( /,.?$/, "" )
+  if( prev ){
+    if( firstInTable ){
+      print prev
+      firstInTable = 0
+    }
+    else {
+      print "," prev
+    }
+  }
+  else {
+    # FIXME check if this is correct in all cases
+    if( match( $1,
+        /(CONSTRAINT|constraint) ["].*["] (FOREIGN KEY|foreign key)/ ) ){
+      print ","
+    }
+  }
+  prev = $1
+}
+
+/ ENGINE| engine/ {
+  if( prev ){
+    if( firstInTable ){
+      print prev
+      firstInTable = 0
+    }
+    else {
+      print "," prev
+    }
+  }
+  prev=""
+  print ");"
+  next
+}
+# \`KEY\` lines are extracted from the \`CREATE\` block and stored in array for later print
+# in a separate \`CREATE KEY\` command. The index name is prefixed by the table name to
+# avoid a sqlite error for duplicate index name.
+/^(  (KEY|key)|\\);)/ {
+  if( prev ){
+    if( firstInTable ){
+      print prev
+      firstInTable = 0
+    }
+    else {
+      print "," prev
+    }
+  }
+  prev = ""
+  if( $0 == ");" ){
+    print
+  }
+  else {
+    if( match( $0, /\`[^\`]+/ ) ){
+      indexName = substr( $0, RSTART+1, RLENGTH-1 )
+    }
+    if( match( $0, /\\([^()]+/ ) ){
+      indexKey = substr( $0, RSTART+1, RLENGTH-1 )
+    }
+    # idx_ prefix to avoid name clashes (they really happen!)
+    key[tableName] = key[tableName] "CREATE INDEX \\"idx_" \\
+        tableName "_" indexName "\\" ON \\"" tableName "\\" (" indexKey ");\\n"
+  }
+}
+
+END {
+  if( no_END ){ exit 1}
+  # print all KEY creation lines.
+  for( table in key ){ printf key[table] }
+
+  print "END TRANSACTION;"
+
+  if( caseIssue ){
+    printerr( \\
+      "INFO Pure sqlite identifiers are case insensitive (even if quoted\\n" \\
+      "     or if ASCII) and doesnt cross-check TABLE and TEMPORARY TABLE\\n" \\
+      "     identifiers. Thus expect errors like \\"table T has no column named F\\".")
+  }
+}
+`;
+}