@technicity/data-service-generator 0.13.26 → 0.14.1

package/dist/generation/generate.js

@@ -1,50 +1,22 @@
 "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 = __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"));
+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");
 // @ts-ignore
-const TSqlString = __importStar(require("tsqlstring"));
+const TSqlString = 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");
 const MySQL_1 = require("../runtime/lib/MySQL");
-const node_util_1 = require("node:util");
-const spawn = (0, node_util_1.promisify)(child_process.spawn);
 // json-schema-to-typescript inlines everything. We don't want that,
 // so use `tsType`, and add imports manually.
 // https://github.com/bcherny/json-schema-to-typescript#custom-schema-properties
@@ -53,7 +25,7 @@ const spawn = (0, node_util_1.promisify)(child_process.spawn);
 let query = undefined;
 let dialect = "mysql";
 const json2TsOpts = {
-    bannerComment: ""
+    bannerComment: "",
 };
 async function generate(input) {
     if (input.tables != null && input.excludeTables != null) {
@@ -85,26 +57,22 @@ async function generate(input) {
         getPatchOneData(x, specialCaseUuidColumn, includeMappedFields),
         getPatchListData(x),
         getDeleteOneData(x),
-        getDeleteListData(x)
+        getDeleteListData(x),
     ]));
-    const artifacts = await getArtifacts(tables, includeMappedFields, specialCaseUuidColumn);
-    const artifactsSource = getArtifactsSource(artifacts);
+    const artifactsSource = await getArtifactsSource(tables, includeMappedFields, specialCaseUuidColumn);
     const sdkSource = await getSDKSource(data, specialCaseUuidColumn, supplementClientOpts);
     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",
@@ -113,15 +81,14 @@ 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(), 
-    // _ because - in filename is not supported by mysql2sqlite
-    `dsg_${node_crypto_1.default.randomUUID()}`.replace(/-/g, "_"));
+    const tmpDirPath = path.join(os.tmpdir(), `dsg-${(0, uuid_1.v4)()}`);
     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);
@@ -161,40 +128,7 @@ 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, "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);
-    }
+    fs.writeFileSync(path.join(tmpBuildOutputPath, IRuntimeFilename), fs.readFileSync(sourceIRuntimeFilePath));
     if (!fs.existsSync(outdir)) {
         fse.mkdirpSync(outdir);
     }
@@ -211,7 +145,7 @@ function init(input) {
             password,
             host,
             port,
-            database
+            database,
         });
         query = mysql.query.bind(mysql);
     }
@@ -221,7 +155,7 @@ function init(input) {
             user,
             password,
             port,
-            database
+            database,
         });
         const poolConnect = pool.connect();
         async function runMSSQLQuery(...input) {
@@ -245,7 +179,7 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementClientOpts)
                 "typeReturnBaseName",
                 "typeWhereName",
                 "typeOrderByName",
-                "typeDataName"
+                "typeDataName",
             ]) {
                 const str = d[k];
                 if (str) {
@@ -270,13 +204,10 @@ async function getSDKSource(input, specialCaseUuidColumn, supplementClientOpts)
       clientOpts: { [k: string]: any; },
       otherOpts?: { [k: string]: any; }
      }) {
-      let otherOpts = opts.otherOpts ?? {};
-      if (opts.clientOpts.filename === ":memory:") {
-        otherOpts = { ...otherOpts, createTablesString: require("./artifacts.sqlite").schema }
-      }
+      opts.otherOpts = opts.otherOpts ?? {}
       this.runtime = new opts.runtime(opts.clientOpts, ${supplementClientOpts === true
-        ? "{ supplementClientOpts: true, ...otherOpts }"
-        : "otherOpts"}, artifacts);
+        ? "{ supplementClientOpts: true, ...opts.otherOpts }"
+        : "opts.otherOpts"}, artifacts);
     }
 
     $use(middleware: TMiddleware) {
@@ -302,269 +233,159 @@ 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") {
-            const findOnes = await getFindOnes(x, specialCaseUuidColumn);
-            return getMethodSourceGetOne(x, findOnes, false);
+            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
+                }
+              );
+            }`;
         }
         if (x.kind === "getList") {
-            return getMethodSourceGetList(x, false);
+            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
+              }
+            );
+          }`;
         }
         if (x.kind === "getListPaginated") {
-            return getMethodSourceGetListPaginated(x, false);
+            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
+              }
+            );
+          }`;
         }
         if (x.kind === "postOne") {
-            return getMethodSourcePostOne(x, specialCaseUuidColumn, false);
+            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)}}
+          });
+        }`;
         }
         if (x.kind === "patchOne") {
-            const findOnes = await getFindOnes(x, specialCaseUuidColumn);
-            return getMethodSourcePatchOne(x, findOnes, false);
+            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
+          });
+        }`;
         }
         if (x.kind === "patchList") {
-            return getMethodSourcePatchList(x, false);
+            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
+          });
+        }`;
         }
         if (x.kind === "deleteOne") {
-            const findOnes = await getFindOnes(x, specialCaseUuidColumn);
-            return getMethodSourceDeleteOne(x, findOnes, false);
+            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
+            });
+          }`;
         }
         if (x.kind === "deleteList") {
-            return getMethodSourceDeleteList(x, false);
+            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
+            });
+          }`;
         }
     }))).join("\n\n")}
   }
-
   `;
     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) {
-    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 ${isTransaction ? "runtime" : "this.runtime"}.resolve(
-    {
-      resource: "${x.table}",
-      action: "${mapKindToAction(x.kind)}",
-      args: { $where: param1 },
-      fields: param2?.fields,
-      artifacts,
-      context: param2?.context,
-      skipCache: param2?.skipCache,
-      ${isTransaction ? "dbCall" : ""}
-    }
-  );
-}`;
-}
-function getMethodSourceGetList(x, isTransaction) {
-    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 ${isTransaction ? "runtime" : "this.runtime"}.resolve(
-      {
-        resource: "${x.table}",
-        action: "${mapKindToAction(x.kind)}",
-        args: param1,
-        fields: param2?.fields,
-        artifacts,
-        context: param2?.context,
-        skipCache: param2?.skipCache,
-        ${isTransaction ? "dbCall" : ""}
-      }
-    );
-  }`;
-}
-function getMethodSourceGetListPaginated(x, isTransaction) {
-    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 ${isTransaction ? "runtime" : "this.runtime"}.resolve(
-      {
-        resource: "${x.table}",
-        action: "${mapKindToAction(x.kind)}",
-        args: param1,
-        fields: param2?.fields,
-        artifacts,
-        context: param2?.context,
-        skipCache: param2?.skipCache,
-        ${isTransaction ? "dbCall" : ""}
-      }
-    );
-  }`;
-}
-function getMethodSourcePostOne(x, specialCaseUuidColumn, isTransaction) {
-    return `async ${x.methodName}(
-    data: ${x.typeDataName},
-    param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, context?: TContext }
-  ): Promise<${x.typeReturnBaseName}> {
-  return ${isTransaction ? "runtime" : "this.runtime"}.resolve({
-    resource: "${x.table}",
-    action: "${mapKindToAction(x.kind)}",
-    data,
-    artifacts,
-    fields: param2?.fields,
-    context: {...param2?.context, specialCaseUuidColumn: ${JSON.stringify(specialCaseUuidColumn)}},
-    ${isTransaction ? "dbCall" : ""}
-  });
-}`;
-}
-function getMethodSourcePatchOne(x, findOnes, isTransaction) {
-    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 ${isTransaction ? "runtime" : "this.runtime"}.resolve({
-  resource: "${x.table}",
-  action: "${mapKindToAction(x.kind)}",
-  args: { $where: param1 },
-  data,
-  artifacts,
-  fields: param2?.fields,
-  context: param2?.context,
-  ${isTransaction ? "dbCall" : ""}
-});
-}`;
-}
-function getMethodSourcePatchList(x, isTransaction) {
-    return `async ${x.methodName}(
-    param1: { $where?: ${x.typeWhereName} },
-    data: ${x.typeDataName},
-    param2?: { fields?: ${x.typeFieldsName}, correlationId?: string, context?: TContext }
-  ): Promise<Array<${x.typeReturnBaseName}>> {
-  return ${isTransaction ? "runtime" : "this.runtime"}.resolve({
-    resource: "${x.table}",
-    action: "${mapKindToAction(x.kind)}",
-    args: param1,
-    data,
-    artifacts,
-    fields: param2?.fields,
-    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 getTypeReturnBaseName(table) {
     return "ReturnBase" + changeCase.pascalCase(table);
 }
@@ -590,7 +411,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) {
@@ -609,7 +430,7 @@ async function getGetListData(table) {
         typeWhere,
         typeWhereName,
         typeOrderBy,
-        typeOrderByName
+        typeOrderByName,
     };
 }
 async function getGetListPaginatedData(table) {
@@ -624,7 +445,7 @@ async function getGetListPaginatedData(table) {
         typeFieldsName,
         typeReturnBaseName,
         typeWhereName,
-        typeOrderByName
+        typeOrderByName,
     };
 }
 async function getPostOneData(table, specialCaseUuidColumn, includeMappedFields) {
@@ -638,7 +459,7 @@ async function getPostOneData(table, specialCaseUuidColumn, includeMappedFields)
         typeFieldsName,
         typeReturnBaseName,
         typeData: await getTypeDataPost(table, typeDataName, specialCaseUuidColumn, includeMappedFields),
-        typeDataName
+        typeDataName,
     };
 }
 async function getPatchOneData(table, specialCaseUuidColumn, includeMappedFields) {
@@ -652,7 +473,7 @@ async function getPatchOneData(table, specialCaseUuidColumn, includeMappedFields
         typeFieldsName,
         typeReturnBaseName,
         typeData: await getTypeDataPatch(table, typeDataName, specialCaseUuidColumn, includeMappedFields),
-        typeDataName
+        typeDataName,
     };
 }
 async function getPatchListData(table) {
@@ -667,14 +488,14 @@ async function getPatchListData(table) {
         typeFieldsName,
         typeReturnBaseName,
         typeWhereName,
-        typeDataName
+        typeDataName,
     };
 }
 function getDeleteOneData(table) {
     return {
         kind: "deleteOne",
         table,
-        methodName: "delete" + changeCase.pascalCase(table)
+        methodName: "delete" + changeCase.pascalCase(table),
     };
 }
 function getDeleteListData(table) {
@@ -683,7 +504,7 @@ function getDeleteListData(table) {
         kind: "deleteList",
         table,
         methodName: "delete" + changeCase.pascalCase(table) + "List",
-        typeWhereName
+        typeWhereName,
     };
 }
 async function getTypeWhere(table, name) {
@@ -695,11 +516,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 = [];
@@ -712,7 +533,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) {
@@ -727,7 +548,9 @@ 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(" | ")}>`;
@@ -735,19 +558,21 @@ 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
@@ -776,13 +601,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;
         }
@@ -794,14 +619,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) {
@@ -844,7 +669,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;
@@ -863,52 +688,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",
@@ -918,10 +743,10 @@ async function getJSONSchemaWhere(table) {
                                         items: v,
                                         minItems: 2,
                                         maxItems: 2,
-                                        uniqueItems: true
-                                    }
+                                        uniqueItems: true,
+                                    },
                                 },
-                                additionalProperties: false
+                                additionalProperties: false,
                             },
                             {
                                 type: "object",
@@ -931,15 +756,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",
@@ -947,17 +772,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",
@@ -965,19 +790,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 },
@@ -994,12 +819,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) {
@@ -1012,14 +837,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) {
@@ -1033,7 +858,7 @@ function getTypeTypesIndex(data) {
             "typeReturnBaseName",
             "typeWhereName",
             "typeOrderByName",
-            "typeDataName"
+            "typeDataName",
         ]) {
             const str = d[k];
             if (str) {
@@ -1045,7 +870,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) {
@@ -1095,7 +920,7 @@ async function getTypeFields(table, name, includeMappedFields) {
         items: {
             anyOf: [
                 {
-                    enum: scalarKeys.concat(mappedFields.map((x) => x.as))
+                    enum: scalarKeys.concat(mappedFields.map((x) => x.as)),
                 },
                 ...relations.map((x) => {
                     const argsProperties = x.type === "many-to-many"
@@ -1105,17 +930,17 @@ async function getTypeFields(table, name, includeMappedFields) {
                                 properties: {
                                     [x.table]: { tsType: getTypeWhereName(x.table) },
                                     [x.junctionTable]: {
-                                        tsType: getTypeWhereName(x.junctionTable)
-                                    }
+                                        tsType: getTypeWhereName(x.junctionTable),
+                                    },
                                 },
-                                additionalProperties: false
-                            }
+                                additionalProperties: false,
+                            },
                         }
                         : { [keyWhere]: { tsType: getTypeWhereName(x.table) } };
                     // $orderBy only makes sense for a list
                     if (x.grabMany) {
                         argsProperties[keyOrderBy] = {
-                            tsType: getTypeOrderByName(x.table)
+                            tsType: getTypeOrderByName(x.table),
                         };
                     }
                     return {
@@ -1127,19 +952,21 @@ async function getTypeFields(table, name, includeMappedFields) {
                             args: {
                                 type: "object",
                                 properties: argsProperties,
-                                additionalProperties: false
+                                additionalProperties: false,
                             },
-                            transform: { tsType: `(x: any) => any` }
+                            transform: { tsType: `(x: any) => any` },
                         },
                         additionalProperties: false,
-                        required: ["name", "fields"]
+                        required: ["name", "fields"],
                     };
-                })
-            ]
-        }
+                }),
+            ],
+        },
     };
     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)));
@@ -1179,10 +1006,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)))
@@ -1198,21 +1025,10 @@ function getMaybeNullableTsType(type, nullable) {
     }
     return type;
 }
-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) {
+async function getArtifactsSource(tables, includeMappedFields, specialCaseUuidColumn) {
     const tableMetaList = await Promise.all(tables.map(async (table) => {
-        const [tableMeta, primaryKey, dumpSchema] = await Promise.all([
-            getTableMeta(table),
-            getPrimaryColumn(table).then((x) => x.name),
-            getShowCreateTable(table)
-        ]);
+        const tableMeta = await getTableMeta(table);
+        const primaryKey = await getPrimaryColumn(table).then((x) => x.name);
         const scalarFields = tableMeta.map((x) => x.Field);
         const relationInfo = await getRelationInfo(table);
         const relationFields = relationInfo.reduce((acc, x) => {
@@ -1224,7 +1040,7 @@ async function getArtifacts(tables, includeMappedFields, specialCaseUuidColumn)
                     table: x.table,
                     grabMany: x.grabMany,
                     nullable: x.nullable,
-                    relation: x.relation
+                    relation: x.relation,
                 };
             }
             else {
@@ -1234,12 +1050,14 @@ async function getArtifacts(tables, includeMappedFields, specialCaseUuidColumn)
                     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) => {
@@ -1255,47 +1073,6 @@ async function getArtifacts(tables, includeMappedFields, specialCaseUuidColumn)
             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
-            });
-        }
-        for (let x of relationInfo) {
-            fields.push({
-                kind: "object",
-                type: x.table,
-                name: x.name,
-                isList: x.grabMany
-            });
-        }
         return {
             table,
             primaryKey,
@@ -1305,15 +1082,18 @@ async function getArtifacts(tables, includeMappedFields, specialCaseUuidColumn)
             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;
     }, {});
-    return artifacts;
+    const src = `
+  import type {IArtifacts} from "./IRuntime";
+
+  export const artifacts: IArtifacts = ${JSON.stringify(artifacts)};
+  `;
+    return prettier.format(src, { parser: "typescript" });
 }
 const getRelationInfo = _.memoize(async function getRelationInfo(table) {
     const relationsManyToOne = await getRelationsManyToOne(table);
@@ -1328,7 +1108,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));
@@ -1351,7 +1131,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) => {
@@ -1370,7 +1150,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;
     }, []);
@@ -1391,7 +1171,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 };
         }
@@ -1447,7 +1227,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);
@@ -1496,7 +1276,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));
@@ -1511,7 +1291,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) {
@@ -1523,7 +1303,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) {
@@ -1535,7 +1315,7 @@ 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) {
@@ -1579,20 +1359,12 @@ 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);
@@ -1606,7 +1378,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)
@@ -1716,7 +1488,9 @@ 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";
     }
@@ -1740,7 +1514,7 @@ const mssqlTableExcludes = new Set([
     "ddl_history",
     "index_columns",
     "lsn_time_mapping",
-    "systranschemas"
+    "systranschemas",
 ]);
 async function getTableNames() {
     if (dialect === "mysql") {
@@ -1754,295 +1528,3 @@ 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\\".")
-  }
-}
-`;
-}