@technicity/data-service-generator 0.22.2 → 0.23.0-next.0

package/dist/src/generation/generate.js

@@ -0,0 +1,2349 @@
+"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 = generate;
+const path = __importStar(require("node:path"));
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const node_async_hooks_1 = require("node:async_hooks");
+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 memoize_1 = __importDefault(require("lodash/memoize"));
+const json_schema_to_typescript_1 = require("json-schema-to-typescript");
+const getDuplicates_1 = require("../lib/getDuplicates");
+const isNotNullOrUndefined_1 = require("../lib/isNotNullOrUndefined");
+const pg_1 = require("pg");
+const MySQL_1 = require("../runtime/lib/MySQL");
+const capitalizeFirstLetter_1 = require("../lib/capitalizeFirstLetter");
+const ctxStorage = new node_async_hooks_1.AsyncLocalStorage();
+function getCtx() {
+    const c = ctxStorage.getStore();
+    if (!c)
+        throw new Error("generate() context missing");
+    return c;
+}
+const json2TsOpts = {
+    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");
+    }
+    if (input.dialect == null) {
+        throw new Error("Must specify `dialect`");
+    }
+    const specialCaseUuidColumn = input.specialCaseUuidColumn ?? true;
+    const includeMappedFields = input.includeMappedFields ?? true;
+    const supplementClientOpts = input.supplementClientOpts ?? true;
+    const ctx = {
+        runId: node_crypto_1.default.randomUUID(),
+        dialect: input.dialect,
+        query: undefined
+    };
+    return ctxStorage.run(ctx, async () => {
+        init(input);
+        let tables = await getTableNames();
+        if (tables.length === 0) {
+            throw new Error("No tables found");
+        }
+        if (input.tables != null) {
+            tables = tables.filter((x) => input.tables?.includes(x));
+        }
+        if (input.excludeTables != null) {
+            tables = tables.filter((x) => !input.excludeTables?.includes(x));
+        }
+        const data = await Promise.all(tables.flatMap((x) => [
+            getGetOneData(x, includeMappedFields),
+            getGetListData(x),
+            getGetListPaginatedData(x),
+            getPostOneData(x, specialCaseUuidColumn, includeMappedFields),
+            getPatchOneData(x, specialCaseUuidColumn, includeMappedFields),
+            getPatchListData(x),
+            getDeleteOneData(x),
+            getDeleteListData(x)
+        ]));
+        const artifacts = await getArtifacts(tables, includeMappedFields, specialCaseUuidColumn);
+        const artifactsSource = getArtifactsSource(artifacts);
+        const sdkSource = await getSDKSource(data, specialCaseUuidColumn, supplementClientOpts, artifacts, input.outputSqliteSchema);
+        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 tsConfigJSON = {
+            compilerOptions: {
+                module: "commonjs",
+                moduleResolution: "node",
+                target: "es2020",
+                declaration: true,
+                outDir: "./sdk-ts"
+            },
+            include: [sdkFilename, artifactsFilename, IRuntimeFilename]
+        };
+        const packageJSON = {
+            name: "temp",
+            version: "1.0.0",
+            // Deps need to be included so that they're inlined by ncc
+            dependencies: require("../../package.json").dependencies,
+            devDependencies: {
+                "@types/node": require("../../package.json").devDependencies["@types/node"],
+                typescript: require("../../package.json").devDependencies.typescript
+            },
+            // Not `resolutions` because npm used for install
+            overrides: {
+                // Fix for: `Cannot find type definition file for 'glob'`
+                glob: ">9.0.0"
+            }
+        };
+        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);
+        fse.copyFileSync(sourceIRuntimeFilePath, path.join(tmpDirPath, IRuntimeFilename));
+        const typesDirPath = path.join(tmpDirPath, "types");
+        fse.mkdirpSync(typesDirPath);
+        fs.writeFileSync(path.join(typesDirPath, "_shared.ts"), getTypeShared());
+        for (let x of data) {
+            if (x.kind === "getOne") {
+                fs.writeFileSync(path.join(typesDirPath, x.typeFieldsName + ".ts"), x.typeFields);
+                fs.writeFileSync(path.join(typesDirPath, x.typeReturnBaseName + ".ts"), x.typeReturnBase);
+            }
+            if (x.kind === "getList") {
+                fs.writeFileSync(path.join(typesDirPath, x.typeWhereName + ".ts"), x.typeWhere);
+                fs.writeFileSync(path.join(typesDirPath, x.typeOrderByName + ".ts"), x.typeOrderBy);
+            }
+            if (x.kind === "postOne") {
+                fs.writeFileSync(path.join(typesDirPath, x.typeDataName + ".ts"), x.typeData);
+            }
+            if (x.kind === "patchOne") {
+                fs.writeFileSync(path.join(typesDirPath, x.typeDataName + ".ts"), x.typeData);
+            }
+        }
+        fs.writeFileSync(path.join(typesDirPath, "index.ts"), getTypeTypesIndex(data));
+        fs.writeFileSync(path.join(tmpDirPath, "package.json"), JSON.stringify(packageJSON, null, 2));
+        fs.writeFileSync(path.join(tmpDirPath, "tsconfig.json"), JSON.stringify(tsConfigJSON, null, 2));
+        fse.copySync(__dirname, path.join(tmpDirPath, "src"));
+        const tmpBuildOutputPath = path.join(tmpDirPath, "sdk-ts");
+        const outdir = path.resolve(input.outdir);
+        const sdkOutputPath = path.join(outdir, "sdk-ts");
+        const nccVersion = "^0.33.0";
+        child_process.execSync("npm i", { cwd: tmpDirPath, stdio: "inherit" });
+        child_process.execSync(`npm_config_yes=true npx -p @vercel/ncc@${nccVersion} ncc build ./${sdkFilename} -o ${tmpBuildOutputPath} -e ./artifacts`, { cwd: tmpDirPath, stdio: "inherit" });
+        // TODO: workaround for artifacts.js not being output by ncc
+        fs.writeFileSync(path.join(tmpBuildOutputPath, "artifacts.js"), artifactsSource
+            .replace("export const artifacts: IArtifacts = ", "module.exports.artifacts = ")
+            .split("\n")
+            // Remove import
+            .slice(2)
+            .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"), "utf-8")
+            : fs.readFileSync(sourceIRuntimeFilePath, "utf-8"));
+        if (getCtx().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);
+        }
+        fse.emptyDirSync(sdkOutputPath);
+        fse.copySync(tmpBuildOutputPath, sdkOutputPath);
+        fse.removeSync(tmpDirPath);
+    });
+}
+function init(input) {
+    const ctx = getCtx();
+    const { database, user, password, host, port, server } = input;
+    if (ctx.dialect === "mysql") {
+        const mysql = new MySQL_1.MySQL({
+            user,
+            password,
+            host,
+            port,
+            database
+        });
+        ctx.query = mysql.query.bind(mysql);
+    }
+    if (ctx.dialect === "postgresql") {
+        const pool = new pg_1.Pool({
+            host: host ?? "localhost",
+            port: port ?? 5432,
+            user,
+            password,
+            database
+        });
+        ctx.query = (q, values) => pool.query(q, values ?? []).then((r) => r.rows);
+    }
+}
+// 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, artifacts, outputSqliteSchema) {
+    function getTypeImports() {
+        let set = new Set();
+        for (let d of input) {
+            for (let k of [
+                "typeFieldsName",
+                "typeReturnBaseName",
+                "typeWhereName",
+                "typeOrderByName",
+                "typeDataName"
+            ]) {
+                const str = d[k];
+                if (str) {
+                    set.add(str);
+                }
+            }
+        }
+        return `import type { ${["Paginate", "ListPaginated"]
+            .concat(Array.from(set).sort())
+            .join(",\n")} } from "./types";`;
+    }
+    const src = `import { AsyncLocalStorage } from "node:async_hooks";
+  import type { IRuntime, TMiddleware, TContext, TOnHandler, EventOnHandlerError } from "./IRuntime"
+  import { artifacts } from "./artifacts";
+
+  ${getTypeImports()}
+
+  const asyncLocalStorage = new AsyncLocalStorage<{ isInOnHandler: boolean }>();
+
+  export class SDK {
+    runtime: IRuntime;
+    onHandlerMap: Map<string, TOnHandler>;
+    eventTarget: EventTarget;
+    passBeforeValueToAfterCallback: boolean;
+  
+    constructor(opts: {
+      runtime: any;
+      clientOpts: { [k: string]: any; },
+      otherOpts?: { [k: string]: any; },
+      passBeforeValueToAfterCallback: boolean,
+     }) {
+      let otherOpts = opts.otherOpts ?? {};
+      if (opts.clientOpts.filename === ":memory:") {
+        ${outputSqliteSchema === true
+        ? `otherOpts = { ...otherOpts, createTablesString: require("./artifacts.sqlite").schema }`
+        : `throw new Error("SQLite artifacts not available. Please regenerate the SDK with \`outputSqliteSchema: true\`.")`}
+      }
+      this.runtime = new opts.runtime(opts.clientOpts, ${supplementClientOpts === true
+        ? "{ supplementClientOpts: true, ...otherOpts }"
+        : "otherOpts"}, artifacts);
+      this.onHandlerMap = new Map();
+      this.eventTarget = new EventTarget();
+      this.passBeforeValueToAfterCallback = opts.passBeforeValueToAfterCallback;
+    }
+
+    $use(middleware: TMiddleware) {
+      return this.runtime.$use(middleware);
+    }
+
+    $whereNeedsProcessing(where: any) {
+      return this.runtime.$whereNeedsProcessing(where);
+    }
+
+    async $prepareWhere(
+      table: string,
+      where: any
+    ) {
+      return this.runtime.$prepareWhere(artifacts, table, where);
+    }
+
+    async $queryRaw(sql: string, values?: any[]) {
+      return this.runtime.$queryRaw(sql, values);
+    }
+
+    async $shutdown() {
+      return this.runtime.$shutdown();
+    }
+
+    async $startTransaction(input?: {
+      isolationLevel?:
+        | "READ UNCOMMITTED"
+        | "READ COMMITTED"
+        | "REPEATABLE READ"
+        | "SERIALIZABLE"
+    }) {
+      const { dbCall, queryRaw, commit, rollback } = await this.runtime.$startTransaction(input);
+      const runtime = this.runtime;
+      const eventTarget = this.eventTarget;
+      const onHandlerMap = this.onHandlerMap;
+      const passBeforeValueToAfterCallback = this.passBeforeValueToAfterCallback;
+      return {
+        $queryRaw: queryRaw,
+        $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")}
+      }
+    }
+
+    onOnHandlerError(cb: (event: EventOnHandlerError<unknown>) => void) {
+      this.eventTarget.addEventListener("error", cb);
+    }
+
+    ${(await Promise.all(input.flatMap(async (x) => {
+        if (x.kind === "getOne") {
+            const findOnes = await getFindOnes(x, specialCaseUuidColumn);
+            return getMethodSourceGetOne(x, findOnes, false);
+        }
+        if (x.kind === "getList") {
+            return getMethodSourceGetList(x, false);
+        }
+        if (x.kind === "getListPaginated") {
+            return getMethodSourceGetListPaginated(x, false);
+        }
+        if (x.kind === "postOne") {
+            return getMethodSourcePostOne(x, specialCaseUuidColumn, false);
+        }
+        if (x.kind === "patchOne") {
+            const findOnes = await getFindOnes(x, specialCaseUuidColumn);
+            return getMethodSourcePatchOne(x, findOnes, false);
+        }
+        if (x.kind === "patchList") {
+            return getMethodSourcePatchList(x, false);
+        }
+        if (x.kind === "deleteOne") {
+            const findOnes = await getFindOnes(x, specialCaseUuidColumn);
+            return getMethodSourceDeleteOne(x, findOnes, false);
+        }
+        if (x.kind === "deleteList") {
+            return getMethodSourceDeleteList(x, false);
+        }
+    }))).join("\n\n")}
+
+    ${(await Promise.all(input.flatMap(async (x) => {
+        if (x.kind === "postOne") {
+            return getMethodSourceOnHandlerPostOne(x);
+        }
+        if (x.kind === "patchOne") {
+            const findOnes = await getFindOnes(x, specialCaseUuidColumn);
+            return getMethodSourceOnHandlerPatchOne(x, findOnes);
+        }
+        if (x.kind === "patchList") {
+            return getMethodSourceOnHandlerPatchList(x);
+        }
+        if (x.kind === "deleteOne") {
+            const findOnes = await getFindOnes(x, specialCaseUuidColumn);
+            return getMethodSourceOnHandlerDeleteOne(x, findOnes);
+        }
+        if (x.kind === "deleteList") {
+            return getMethodSourceOnHandlerDeleteList(x);
+        }
+    })))
+        .filter(Boolean)
+        .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,
+      eventTarget: ${isTransaction ? "eventTarget" : "this.eventTarget"},
+      ${isTransaction ? "dbCall," : ""}
+      passBeforeValueToAfterCallback: ${isTransaction
+        ? "passBeforeValueToAfterCallback"
+        : "this.passBeforeValueToAfterCallback"},
+    }
+  );
+}`;
+}
+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,
+        eventTarget: ${isTransaction ? "eventTarget" : "this.eventTarget"},
+        ${isTransaction ? "dbCall," : ""}
+        passBeforeValueToAfterCallback: ${isTransaction
+        ? "passBeforeValueToAfterCallback"
+        : "this.passBeforeValueToAfterCallback"},
+      }
+    );
+  }`;
+}
+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,
+        eventTarget: ${isTransaction ? "eventTarget" : "this.eventTarget"},
+        ${isTransaction ? "dbCall," : ""}
+        passBeforeValueToAfterCallback: ${isTransaction
+        ? "passBeforeValueToAfterCallback"
+        : "this.passBeforeValueToAfterCallback"},
+      }
+    );
+  }`;
+}
+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)}},
+    eventTarget: ${isTransaction ? "eventTarget" : "this.eventTarget"},
+    onHandler: ${isTransaction ? "onHandlerMap" : "this.onHandlerMap"}.get("${mapKindToAction(x.kind)}-${x.table}"),
+    asyncLocalStorage,
+    sdk: this,
+    ${isTransaction ? "dbCall," : ""}
+    passBeforeValueToAfterCallback: ${isTransaction
+        ? "passBeforeValueToAfterCallback"
+        : "this.passBeforeValueToAfterCallback"},
+  });
+}`;
+}
+function getMethodSourceOnHandlerPostOne(x) {
+    return `on${(0, capitalizeFirstLetter_1.capitalizeFirstLetter)(x.methodName)}(handler:
+    (sdk: InstanceType<typeof SDK>, input: { data: ${x.typeDataName} },
+    output: Partial<${getTypeReturnName(x.table)}>,
+    context: TContext,
+  ) => Promise<void>
+): void {
+  this.onHandlerMap.set("${mapKindToAction(x.kind)}-${x.table}", handler);
+}`;
+}
+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,
+  eventTarget: ${isTransaction ? "eventTarget" : "this.eventTarget"},
+  onHandler: ${isTransaction ? "onHandlerMap" : "this.onHandlerMap"}.get("${mapKindToAction(x.kind)}-${x.table}"),
+  asyncLocalStorage,
+  sdk: this,
+  ${isTransaction ? "dbCall," : ""}
+  passBeforeValueToAfterCallback: ${isTransaction
+        ? "passBeforeValueToAfterCallback"
+        : "this.passBeforeValueToAfterCallback"},
+});
+}`;
+}
+function getMethodSourceOnHandlerPatchOne(x, findOnes) {
+    return `on${(0, capitalizeFirstLetter_1.capitalizeFirstLetter)(x.methodName)}(handler:
+    (sdk: InstanceType<typeof SDK>, input: { $where: ${findOnes
+        .map((findOne) => `{ ${findOne.name}: ${findOne.type}${findOne.nullable ? " | null" : ""} }`)
+        .join(" | ")}, data: ${x.typeDataName} },
+    output: Partial<${getTypeReturnName(x.table)}>,
+    before: ${getTypeReturnName(x.table)} | null,
+    context: TContext,
+  ) => Promise<void>
+): void {
+  this.onHandlerMap.set("${mapKindToAction(x.kind)}-${x.table}", handler);
+}`;
+}
+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,
+    eventTarget: ${isTransaction ? "eventTarget" : "this.eventTarget"},
+    onHandler: ${isTransaction ? "onHandlerMap" : "this.onHandlerMap"}.get("${mapKindToAction(x.kind)}-${x.table}"),
+    asyncLocalStorage,
+    sdk: this,
+    ${isTransaction ? "dbCall," : ""}
+    passBeforeValueToAfterCallback: ${isTransaction
+        ? "passBeforeValueToAfterCallback"
+        : "this.passBeforeValueToAfterCallback"},
+  });
+}`;
+}
+function getMethodSourceOnHandlerPatchList(x) {
+    return `on${(0, capitalizeFirstLetter_1.capitalizeFirstLetter)(x.methodName)}(handler:
+    (sdk: InstanceType<typeof SDK>, input: { $where?: ${x.typeWhereName}, $orderBy?: ${x.typeOrderByName}, data: ${x.typeDataName} },
+    output: Partial<${getTypeReturnName(x.table)}>[],
+    before: ${getTypeReturnName(x.table)}[] | null,
+    context: TContext,
+  ) => Promise<void>
+): void {
+  this.onHandlerMap.set("${mapKindToAction(x.kind)}-${x.table}", handler);
+}`;
+}
+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,
+    eventTarget: ${isTransaction ? "eventTarget" : "this.eventTarget"},
+    onHandler: ${isTransaction ? "onHandlerMap" : "this.onHandlerMap"}.get("${mapKindToAction(x.kind)}-${x.table}"),
+    asyncLocalStorage,
+    sdk: this,
+    ${isTransaction ? "dbCall," : ""}
+    passBeforeValueToAfterCallback: ${isTransaction
+        ? "passBeforeValueToAfterCallback"
+        : "this.passBeforeValueToAfterCallback"},
+  });
+}`;
+}
+function getMethodSourceOnHandlerDeleteOne(x, findOnes) {
+    return `on${(0, capitalizeFirstLetter_1.capitalizeFirstLetter)(x.methodName)}(handler:
+    (sdk: InstanceType<typeof SDK>, input: { $where: ${findOnes
+        .map((findOne) => `{ ${findOne.name}: ${findOne.type}${findOne.nullable ? " | null" : ""} }`)
+        .join(" | ")}, },
+    output: void,
+    context: TContext,
+  ) => Promise<void>
+): void {
+  this.onHandlerMap.set("${mapKindToAction(x.kind)}-${x.table}", handler);
+}`;
+}
+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,
+      eventTarget: ${isTransaction ? "eventTarget" : "this.eventTarget"},
+      onHandler: ${isTransaction ? "onHandlerMap" : "this.onHandlerMap"}.get("${mapKindToAction(x.kind)}-${x.table}"),
+      asyncLocalStorage,
+      sdk: this,
+      ${isTransaction ? "dbCall," : ""}
+      passBeforeValueToAfterCallback: ${isTransaction
+        ? "passBeforeValueToAfterCallback"
+        : "this.passBeforeValueToAfterCallback"},
+    });
+  }`;
+}
+function getMethodSourceOnHandlerDeleteList(x) {
+    return `on${(0, capitalizeFirstLetter_1.capitalizeFirstLetter)(x.methodName)}(handler:
+    (sdk: InstanceType<typeof SDK>, input: { $where?: ${x.typeWhereName} },
+    output: void,
+    before: ${getTypeReturnName(x.table)}[] | null,
+    context: TContext,
+  ) => Promise<void>
+): void {
+  this.onHandlerMap.set("${mapKindToAction(x.kind)}-${x.table}", handler);
+}`;
+}
+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);
+}
+function getTypeFieldsName(table) {
+    return "Fields" + changeCase.pascalCase(table);
+}
+function getTypeWhereName(table) {
+    return "Where" + changeCase.pascalCase(table);
+}
+function getTypeOrderByName(table) {
+    return "OrderBy" + changeCase.pascalCase(table);
+}
+function getTypeDataPostName(table) {
+    return "DataPost" + changeCase.pascalCase(table);
+}
+async function getGetOneData(table, includeMappedFields) {
+    const typeFieldsName = getTypeFieldsName(table);
+    const typeReturnBaseName = getTypeReturnBaseName(table);
+    return {
+        kind: "getOne",
+        table,
+        methodName: "get" + changeCase.pascalCase(table),
+        typeFields: await getTypeFields(table, typeFieldsName, includeMappedFields),
+        typeFieldsName,
+        typeReturnBase: await getTypeReturnBase(table, typeReturnBaseName, includeMappedFields),
+        typeReturnBaseName
+    };
+}
+async function getGetListData(table) {
+    const typeFieldsName = getTypeFieldsName(table);
+    const typeReturnBaseName = getTypeReturnBaseName(table);
+    const typeWhereName = getTypeWhereName(table);
+    const typeWhere = await getTypeWhere(table, typeWhereName);
+    const typeOrderByName = getTypeOrderByName(table);
+    const typeOrderBy = await getTypeOrderBy(table, typeOrderByName);
+    return {
+        kind: "getList",
+        table,
+        methodName: "get" + changeCase.pascalCase(table) + "List",
+        typeFieldsName,
+        typeReturnBaseName,
+        typeWhere,
+        typeWhereName,
+        typeOrderBy,
+        typeOrderByName
+    };
+}
+async function getGetListPaginatedData(table) {
+    const typeFieldsName = getTypeFieldsName(table);
+    const typeReturnBaseName = getTypeReturnBaseName(table);
+    const typeWhereName = getTypeWhereName(table);
+    const typeOrderByName = getTypeOrderByName(table);
+    return {
+        kind: "getListPaginated",
+        table,
+        methodName: "get" + changeCase.pascalCase(table) + "ListPaginated",
+        typeFieldsName,
+        typeReturnBaseName,
+        typeWhereName,
+        typeOrderByName
+    };
+}
+async function getPostOneData(table, specialCaseUuidColumn, includeMappedFields) {
+    const typeFieldsName = getTypeFieldsName(table);
+    const typeReturnBaseName = getTypeReturnBaseName(table);
+    const typeDataName = getTypeDataPostName(table);
+    return {
+        kind: "postOne",
+        table,
+        methodName: "post" + changeCase.pascalCase(table),
+        typeFieldsName,
+        typeReturnBaseName,
+        typeData: await getTypeDataPost(table, typeDataName, specialCaseUuidColumn, includeMappedFields),
+        typeDataName
+    };
+}
+async function getPatchOneData(table, specialCaseUuidColumn, includeMappedFields) {
+    const typeFieldsName = getTypeFieldsName(table);
+    const typeReturnBaseName = getTypeReturnBaseName(table);
+    const typeDataName = "DataPatch" + changeCase.pascalCase(table);
+    return {
+        kind: "patchOne",
+        table,
+        methodName: "patch" + changeCase.pascalCase(table),
+        typeFieldsName,
+        typeReturnBaseName,
+        typeData: await getTypeDataPatch(table, typeDataName, specialCaseUuidColumn, includeMappedFields),
+        typeDataName
+    };
+}
+async function getPatchListData(table) {
+    const typeFieldsName = getTypeFieldsName(table);
+    const typeReturnBaseName = getTypeReturnBaseName(table);
+    const typeWhereName = getTypeWhereName(table);
+    const typeDataName = "DataPatch" + changeCase.pascalCase(table);
+    const typeOrderByName = getTypeOrderByName(table);
+    return {
+        kind: "patchList",
+        table,
+        methodName: "patch" + changeCase.pascalCase(table) + "List",
+        typeFieldsName,
+        typeReturnBaseName,
+        typeWhereName,
+        typeDataName,
+        typeOrderByName
+    };
+}
+function getDeleteOneData(table) {
+    return {
+        kind: "deleteOne",
+        table,
+        methodName: "delete" + changeCase.pascalCase(table)
+    };
+}
+function getDeleteListData(table) {
+    const typeWhereName = getTypeWhereName(table);
+    return {
+        kind: "deleteList",
+        table,
+        methodName: "delete" + changeCase.pascalCase(table) + "List",
+        typeWhereName
+    };
+}
+async function getTypeWhere(table, name) {
+    const jsonSchemaWhere = await getJSONSchemaWhere(table);
+    return (0, json_schema_to_typescript_1.compile)(jsonSchemaWhere, name, json2TsOpts);
+}
+async function getTypeDataPost(table, name, specialCaseUuidColumn, includeMappedFields) {
+    const primaryColumn = await getPrimaryColumn(table);
+    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
+    }), {});
+    const hasDefault = tableMeta.reduce((acc, m) => ({
+        ...acc,
+        [m.Field]: m.Default == null ? false : true
+    }), {});
+    let properties = getJSONSchemaObjProperties(tableMeta);
+    let notRequiredList = [];
+    const oneToManyRelations = (await getRelationInfo(table)).filter((x) => x.type === "one-to-many__many-to-one" && x.kind === "one-to-many");
+    const mappedFields = includeMappedFields ? await getMappedFields(table) : [];
+    let mappedFieldsMap = new Map();
+    if (includeMappedFields) {
+        properties = {
+            ...properties,
+            ...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) {
+            mappedFieldsMap.set(r.table, await getMappedFields(r.table));
+        }
+    }
+    const uuidColumn = await getUuidColumn(table);
+    const jsonSchema = {
+        type: "object",
+        properties: {
+            ...properties,
+            ...oneToManyRelations.reduce((acc, v) => {
+                let tsType = getTypeDataPostName(v.table);
+                const mappedFields = mappedFieldsMap.get(v.table);
+                if (includeMappedFields && mappedFields != null && mappedFields.length > 0) {
+                    tsType = `Omit<${tsType}, ${mappedFields
+                        .map((x) => JSON.stringify(x.as))
+                        .join(" | ")}>`;
+                }
+                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)
+            .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))
+    };
+    let type = await (0, json_schema_to_typescript_1.compile)(jsonSchema, name, json2TsOpts);
+    const imports = _.uniq(oneToManyRelations
+        .filter((r) => r.table !== table)
+        .map((x) => getTypeDataPostName(x.table)))
+        .map((x) => `import type { ${x} } from "./${x}";`)
+        .join("\n");
+    if (imports) {
+        type = imports + "\n\n" + type;
+    }
+    return type;
+}
+async function getTypeDataPatch(table, name, specialCaseUuidColumn, includeMappedFields) {
+    const primaryColumn = await getPrimaryColumn(table);
+    let tableMeta = (await getTableMeta(table)).filter((x) => x.Field !== primaryColumn.name);
+    if (specialCaseUuidColumn) {
+        const uuidColumn = await getUuidColumn(table);
+        if (uuidColumn != null) {
+            tableMeta = tableMeta.filter((x) => x.Field !== uuidColumn.name);
+        }
+    }
+    let properties = getJSONSchemaObjProperties(tableMeta);
+    let mustImportTUpdateOperationsString = false;
+    let mustImportTUpdateOperationsNumber = false;
+    for (let key in properties) {
+        const type = unwrapJSONType(properties[key].type);
+        if (type === "string") {
+            properties[key] = {
+                oneOf: [properties[key], { tsType: "TUpdateOperationsString" }]
+            };
+            mustImportTUpdateOperationsString = true;
+        }
+        else if (type === "number" || type === "integer") {
+            properties[key] = {
+                oneOf: [properties[key], { tsType: "TUpdateOperationsNumber" }]
+            };
+            mustImportTUpdateOperationsNumber = true;
+        }
+    }
+    if (includeMappedFields) {
+        const mappedFields = await getMappedFields(table);
+        properties = {
+            ...properties,
+            ...mappedFields.reduce((acc, v) => {
+                acc[v.as] = { type: getJSONTypes(v.type, v.nullable) };
+                return acc;
+            }, {})
+        };
+    }
+    const jsonSchema = {
+        type: "object",
+        properties,
+        additionalProperties: false,
+        required: []
+    };
+    let type = await (0, json_schema_to_typescript_1.compile)(jsonSchema, name, json2TsOpts);
+    if (mustImportTUpdateOperationsString || mustImportTUpdateOperationsNumber) {
+        const imports = [];
+        if (mustImportTUpdateOperationsString) {
+            imports.push("TUpdateOperationsString");
+        }
+        if (mustImportTUpdateOperationsNumber) {
+            imports.push("TUpdateOperationsNumber");
+        }
+        const importsStr = imports
+            .map((x) => `import type { ${x} } from "./_shared";`)
+            .join("\n");
+        type = importsStr + "\n\n" + type;
+    }
+    return type;
+}
+function unwrapJSONType(type) {
+    if (Array.isArray(type)) {
+        // Gets first non-null type
+        return type.filter((x) => x !== "null")[0];
+    }
+    return type;
+}
+async function getMappedFields(table) {
+    const relationsManyToOne = await getRelationsManyToOne(table).then((xs) => xs.filter((x) => x.foreignKey.endsWith("Id")));
+    let out = [];
+    for (let x of relationsManyToOne) {
+        const tableMeta = await getTableMeta(x.referencedTable);
+        const uuidColumn = tableMeta.find((x) => x.Field === "uuid");
+        const idColumn = tableMeta.find((x) => x.Field === "id");
+        if (uuidColumn == null) {
+            throw new Error("No `uuid` column found for table " + x.referencedTable);
+        }
+        if (idColumn == null) {
+            throw new Error("No `id` column found for table " + x.referencedTable);
+        }
+        out.push({
+            ...x,
+            name: "uuid",
+            // Replace `Id` with `Uuid`
+            as: x.foreignKey.slice(0, -2) + "Uuid",
+            type: getBaseJSONType(uuidColumn.Type, getCtx().dialect)
+        });
+    }
+    return out;
+}
+async function getJSONSchemaWhere(table) {
+    const whereSchemaName = `_Where${changeCase.pascalCase(table)}`;
+    const defWhere = {
+        oneOf: [
+            {
+                type: "object",
+                properties: Object.entries(getJSONSchemaObjProperties(await getTableMeta(table))).reduce((acc, [k, v]) => ({
+                    ...acc,
+                    [k]: {
+                        oneOf: [
+                            v,
+                            {
+                                type: "object",
+                                properties: { $eq: v },
+                                additionalProperties: false
+                            },
+                            {
+                                type: "object",
+                                properties: { $neq: v },
+                                additionalProperties: false
+                            },
+                            {
+                                type: "object",
+                                properties: { $gt: v },
+                                additionalProperties: false
+                            },
+                            {
+                                type: "object",
+                                properties: { $gte: v },
+                                additionalProperties: false
+                            },
+                            {
+                                type: "object",
+                                properties: { $lt: v },
+                                additionalProperties: false
+                            },
+                            {
+                                type: "object",
+                                properties: { $lte: v },
+                                additionalProperties: false
+                            },
+                            {
+                                type: "object",
+                                properties: { $like: { type: "string", minLength: 1 } },
+                                additionalProperties: false
+                            },
+                            {
+                                type: "object",
+                                properties: { $nlike: { type: "string", minLength: 1 } },
+                                additionalProperties: false
+                            },
+                            {
+                                type: "object",
+                                properties: { $in: { type: "array", items: v } },
+                                additionalProperties: false
+                            },
+                            {
+                                type: "object",
+                                properties: { $nin: { type: "array", items: v } },
+                                additionalProperties: false
+                            },
+                            {
+                                type: "object",
+                                properties: {
+                                    $btwn: {
+                                        type: "array",
+                                        items: v,
+                                        minItems: 2,
+                                        maxItems: 2,
+                                        uniqueItems: true
+                                    }
+                                },
+                                additionalProperties: false
+                            },
+                            {
+                                type: "object",
+                                properties: {
+                                    $nbtwn: {
+                                        type: "array",
+                                        items: v,
+                                        minItems: 2,
+                                        maxItems: 2,
+                                        uniqueItems: true
+                                    }
+                                },
+                                additionalProperties: false
+                            }
+                        ]
+                    }
+                }), {}),
+                additionalProperties: false
+            },
+            {
+                type: "object",
+                properties: {
+                    $and: {
+                        type: "array",
+                        items: {
+                            $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
+            },
+            {
+                type: "object",
+                properties: {
+                    $or: {
+                        type: "array",
+                        items: {
+                            $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
+            }
+        ]
+    };
+    return {
+        definitions: { [whereSchemaName]: defWhere },
+        anyOf: [
+            { $ref: `#/definitions/${whereSchemaName}` },
+            ...["$and", "$or"].map((x) => ({
+                type: "object",
+                properties: {
+                    [x]: {
+                        type: "array",
+                        items: { $ref: `#/definitions/${whereSchemaName}` },
+                        // While it makes sense conceptually for $and/$or to have
+                        // at least 2 items, in practice, they could be
+                        // generated dynamically and could end up having
+                        // less than 2 items, so don't enforce minItems.
+                        // minItems: 2,
+                        additionalProperties: false
+                    }
+                },
+                additionalProperties: false
+            }))
+        ]
+    };
+}
+async function getTypeOrderBy(table, name) {
+    return (0, json_schema_to_typescript_1.compile)((await getJSONSchemaOrderBy(table, name)), name, json2TsOpts);
+}
+async function getJSONSchemaOrderBy(table, name) {
+    const fieldNames = await getTableMeta(table).then((xs) => xs.map((x) => x.Field));
+    const def = {
+        oneOf: fieldNames.map((k) => ({
+            type: "object",
+            properties: { [k]: { enum: ["asc", "desc"] } },
+            required: [k],
+            additionalProperties: false
+        }))
+    };
+    const defName = `_${name}`;
+    const _schema = { $ref: `#/definitions/${defName}` };
+    return {
+        definitions: { [defName]: def },
+        oneOf: [_schema, { type: "array", items: _schema }]
+    };
+}
+function getTypeTypesIndex(data) {
+    function getExport(name) {
+        return `export type { ${name} } from "./${name}";`;
+    }
+    let set = new Set();
+    for (let d of data) {
+        for (let k of [
+            "typeFieldsName",
+            "typeReturnBaseName",
+            "typeWhereName",
+            "typeOrderByName",
+            "typeDataName"
+        ]) {
+            const str = d[k];
+            if (str) {
+                set.add(str);
+            }
+        }
+    }
+    let src = `export type { ${[
+        "Paginate",
+        "ListPaginated",
+        "TUpdateOperationsString",
+        "TUpdateOperationsNumber"
+    ].join(",")} } from "./_shared";\n\n`;
+    let arr = Array.from(set).sort();
+    for (let x of arr) {
+        src += getExport(x);
+    }
+    return prettier.format(src, { parser: "typescript" });
+}
+function getTypeShared() {
+    const src = `export type Paginate = {
+    first: number;
+    after?: string;
+    before?: string;
+} | {
+    last: number;
+    after?: string;
+    before?: string;
+} | {
+  limit: number;
+  offset?: number;
+}
+
+export type ListPaginated<T> = {
+  paginationInfo: {
+    hasPreviousPage?: boolean,
+    hasNextPage?: boolean,
+    startCursor?: string,
+    endCursor?: string,
+    totalCount: number,
+  },
+  results: Array<T>,
+}
+
+export type TUpdateOperationsString = {$prepend: string} | {$append: string}
+
+export type TUpdateOperationsNumber = {$increment: number} | {$decrement: number}
+`;
+    return prettier.format(src, { parser: "typescript" });
+}
+async function getTypeFields(table, name, includeMappedFields) {
+    const scalarKeys = Object.keys(getJSONSchemaObjProperties(await getTableMeta(table)));
+    const relations = await getRelationInfo(table);
+    const mappedFields = includeMappedFields ? await getMappedFields(table) : [];
+    const keyWhere = "$where";
+    const keyOrderBy = "$orderBy";
+    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)
+                        }
+                    },
+                    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 whereImports = _.uniq(relations.flatMap((x) => x.type === "many-to-many"
+        ? [getTypeWhereName(x.table), getTypeWhereName(x.junctionTable)]
+        : getTypeWhereName(x.table)));
+    const orderByImports = _.uniq(relations
+        // $orderBy only makes sense for a list
+        .filter((x) => x.grabMany)
+        .map((x) => getTypeOrderByName(x.table)));
+    const imports = _.uniq(fieldImports.concat(whereImports).concat(orderByImports))
+        .map((x) => `import type { ${x} } from "./${x}";`)
+        .join("\n");
+    type = imports + "\n\n" + type;
+    return type;
+}
+async function getTypeReturnBase(table, name, includeMappedFields) {
+    const tableMeta = await getTableMeta(table);
+    const scalarProperties = getJSONSchemaObjProperties(tableMeta);
+    const relations = await getRelationInfo(table);
+    const mappedFields = includeMappedFields ? await getMappedFields(table) : [];
+    const jsonSchemaReturn = {
+        type: "object",
+        properties: {
+            ...scalarProperties,
+            ...mappedFields.reduce((acc, x) => {
+                acc[x.as] = { type: getJSONTypes(x.type, x.nullable) };
+                return acc;
+            }, {}),
+            ...relations.reduce((acc, x) => {
+                const key = x.name;
+                const typeName = getTypeReturnBaseName(x.table);
+                const tsType = x.type === "one-to-many__many-to-one"
+                    ? getMaybeNullableTsType(typeName, x.nullable)
+                    : typeName;
+                if (x.grabMany) {
+                    acc[key] = { type: "array", items: { tsType } };
+                }
+                else {
+                    acc[key] = { tsType };
+                }
+                return acc;
+            }, {})
+        },
+        // Because of aliases
+        additionalProperties: true
+    };
+    let type = await (0, json_schema_to_typescript_1.compile)(jsonSchemaReturn, name, json2TsOpts);
+    const imports = _.uniq(relations.map((x) => getTypeReturnBaseName(x.table)))
+        .filter((x) => x !== name)
+        .map((x) => `import type { ${x} } from "./${x}";`)
+        .join("\n");
+    type = imports + "\n\n" + type;
+    return type;
+}
+function getMaybeNullableTsType(type, nullable) {
+    if (nullable) {
+        return `${type} | null`;
+    }
+    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) {
+    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 scalarFields = tableMeta.map((x) => x.Field);
+        const relationInfo = await getRelationInfo(table);
+        const relationFields = relationInfo.reduce((acc, x) => {
+            if (x.type === "one-to-many__many-to-one") {
+                acc[x.name] = {
+                    name: x.name,
+                    type: x.type,
+                    kind: x.kind,
+                    table: x.table,
+                    grabMany: x.grabMany,
+                    nullable: x.nullable,
+                    relation: x.relation
+                };
+            }
+            else {
+                acc[x.name] = {
+                    name: x.name,
+                    type: x.type,
+                    table: x.table,
+                    junctionTable: x.junctionTable,
+                    grabMany: x.grabMany,
+                    relations: x.relations
+                };
+            }
+            return acc;
+        }, {});
+        const _mappedFields = includeMappedFields ? await getMappedFields(table) : [];
+        const mappedFields = _mappedFields.length === 0
+            ? null
+            : _mappedFields.reduce((acc, v) => {
+                acc[v.as] = v;
+                return acc;
+            }, {});
+        const dateTimeFields = Object.entries(getJSONSchemaObjProperties(tableMeta)).reduce((acc, x) => {
+            const k = x[0];
+            const v = x[1];
+            if (v.format != null && ["date-time"].includes(v.format)) {
+                acc[k] = true;
+            }
+            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, getCtx().dialect),
+                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,
+            scalarFields,
+            relationFields,
+            mappedFields,
+            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 getRelationInfo = (0, memoize_1.default)(async function getRelationInfo(table) {
+    const relationsManyToOne = await getRelationsManyToOne(table);
+    const relationsOneToMany = await getRelationsOneToMany(table);
+    let out = [];
+    out = out.concat(relationsManyToOne.reduce((acc, x) => {
+        if (!x.foreignKey.endsWith("Id")) {
+            return acc;
+        }
+        const name = getRelationManyToOneFieldName(x);
+        acc.push({
+            type: "one-to-many__many-to-one",
+            kind: "many-to-one",
+            grabMany: false,
+            table: x.referencedTable,
+            name,
+            relation: x,
+            nullable: x.nullable
+        });
+        return acc;
+    }, []));
+    const relationsOneToManyDuplicates = (0, getDuplicates_1.getDuplicates)(relationsOneToMany.map((x) => x.referencedTable));
+    out = out.concat(relationsOneToMany.reduce((acc, x) => {
+        if (!x.referencedKey.endsWith("Id")) {
+            return acc;
+        }
+        let name = changeCase.camelCase(x.referencedTable) + "List";
+        if (relationsOneToManyDuplicates.includes(x.referencedTable)) {
+            // Examples:
+            // `User` would end up with:
+            // * `Invite` + `fromUserId` = `inviteFromUserList`
+            // * `Invite` + `toUserId` = `inviteToUserList`
+            name =
+                changeCase.camelCase(x.referencedTable) +
+                    changeCase.pascalCase(x.referencedKey.replace(new RegExp(x.foreignKey + "$", "i"), "")) +
+                    "List";
+        }
+        acc.push({
+            type: "one-to-many__many-to-one",
+            kind: "one-to-many",
+            grabMany: true,
+            table: x.referencedTable,
+            name,
+            relation: x,
+            nullable: x.nullable
+        });
+        return acc;
+    }, []));
+    const relationsManyToMany = (await getJunctionTables()).reduce((acc, x) => {
+        const dataForParentTable = x.relations.find((r) => r.referencedTable === table);
+        if (dataForParentTable == null) {
+            return acc;
+        }
+        const dataForChildTable = x.relations.find((r) => r.referencedTable !== dataForParentTable.referencedTable);
+        if (dataForChildTable == null) {
+            throw new Error("Null dataForChildTable for table: " + table);
+        }
+        acc.push({
+            type: "many-to-many",
+            table: dataForChildTable.referencedTable,
+            junctionTable: x.table,
+            name: changeCase.camelCase(dataForChildTable.referencedTable) + "List",
+            // Ensure parent comes before child
+            relations: [dataForParentTable, dataForChildTable],
+            grabMany: true
+        });
+        return acc;
+    }, []);
+    out = out.concat(relationsManyToMany);
+    out = _.sortBy((x) => x.table, out);
+    return out;
+}, (table) => getCtx().runId + ":" + table);
+function getRelationManyToOneFieldName(x) {
+    return changeCase.camelCase(x.foreignKey.replace(new RegExp(x.referencedKey + "$", "i"), ""));
+}
+// TODO: not sure if this logic is correct
+async function getJunctionTables() {
+    const tables = await getTableNames();
+    return (await Promise.all(tables.map(async (table) => {
+        const relations = await getRelationsManyToOne(table);
+        if (relations.length === 2 &&
+            relations[0].referencedTable !== relations[1].referencedTable &&
+            // e.g. junction of Foo, Bar must be FooBar or BarFoo
+            [
+                relations[0].referencedTable + relations[1].referencedTable,
+                relations[1].referencedTable + relations[0].referencedTable
+            ].includes(table)) {
+            return { table, relations };
+        }
+        return null;
+    }))).filter(isNotNullOrUndefined_1.isNotNullOrUndefined);
+}
+// `from` relations
+// https://stackoverflow.com/a/54732547
+const getRelationsManyToOne = (0, memoize_1.default)(async function getRelationsManyToOne(table) {
+    const { dialect, query } = getCtx();
+    const tableMeta = await getTableMeta(table);
+    let rs;
+    if (dialect === "mysql") {
+        const sql = `
+  SELECT
+    TABLE_SCHEMA as db,
+    TABLE_NAME as t1,
+    COLUMN_NAME as t1Field,
+    REFERENCED_TABLE_SCHEMA as db2,
+    REFERENCED_TABLE_NAME as t2,
+    REFERENCED_COLUMN_NAME as t2Field
+  FROM
+    INFORMATION_SCHEMA.KEY_COLUMN_USAGE
+  WHERE
+    TABLE_SCHEMA = SCHEMA()
+    AND REFERENCED_TABLE_NAME IS NOT NULL
+    AND (TABLE_NAME = ?);
+  `;
+        rs = await query(sql, [table]);
+    }
+    else if (dialect === "postgresql") {
+        rs = await query(`SELECT kcu.column_name AS "t1Field", ccu.table_name AS t2, ccu.column_name AS "t2Field"
+       FROM information_schema.key_column_usage kcu
+       JOIN information_schema.referential_constraints rc ON kcu.constraint_name = rc.constraint_name AND kcu.table_schema = rc.constraint_schema
+       JOIN information_schema.constraint_column_usage ccu ON rc.unique_constraint_name = ccu.constraint_name AND rc.unique_constraint_schema = ccu.table_schema
+       WHERE kcu.table_schema = 'public' AND kcu.table_name = $1`, [table]);
+    }
+    else {
+        throw new Error("Unsupported dialect: " + dialect);
+    }
+    const xs = await Promise.all(_.uniqWith(_.isEqual, rs.map(async (v) => {
+        return {
+            table: table,
+            foreignKey: v.t1Field,
+            referencedTable: v.t2,
+            referencedKey: v.t2Field,
+            nullable: tableMeta.find((m) => m.Field === v.t1Field)?.Null === "YES"
+        };
+    })));
+    return _.sortBy((x) => x.referencedTable, xs);
+}, (table) => getCtx().runId + ":" + table);
+// `to` relations
+const getRelationsOneToMany = (0, memoize_1.default)(async function getRelationsOneToMany(table) {
+    const { dialect, query } = getCtx();
+    let rs;
+    if (dialect === "mysql") {
+        const sql = `
+  SELECT
+    TABLE_SCHEMA as db,
+    TABLE_NAME as t1,
+    COLUMN_NAME as t1Field,
+    REFERENCED_TABLE_SCHEMA as db2,
+    REFERENCED_TABLE_NAME as t2,
+    REFERENCED_COLUMN_NAME as t2Field
+  FROM
+    INFORMATION_SCHEMA.KEY_COLUMN_USAGE
+  WHERE
+    TABLE_SCHEMA = SCHEMA()
+    AND REFERENCED_TABLE_NAME IS NOT NULL
+    AND (REFERENCED_TABLE_NAME = ?);
+  `;
+        rs = await query(sql, [table]);
+    }
+    else if (dialect === "postgresql") {
+        rs = await query(`SELECT kcu.table_name AS t1, kcu.column_name AS "t1Field", ccu.column_name AS "t2Field"
+       FROM information_schema.key_column_usage kcu
+       JOIN information_schema.referential_constraints rc ON kcu.constraint_name = rc.constraint_name AND kcu.table_schema = rc.constraint_schema
+       JOIN information_schema.constraint_column_usage ccu ON rc.unique_constraint_name = ccu.constraint_name AND rc.unique_constraint_schema = ccu.table_schema
+       WHERE kcu.table_schema = 'public' AND ccu.table_name = $1`, [table]);
+    }
+    else {
+        throw new Error("Unsupported dialect: " + dialect);
+    }
+    const xs = await Promise.all(_.uniqWith(_.isEqual, rs.map(async (v) => {
+        return {
+            table: table,
+            foreignKey: v.t2Field,
+            referencedTable: v.t1,
+            referencedKey: v.t1Field,
+            nullable: false
+        };
+    })));
+    return _.sortBy((x) => x.referencedKey, _.sortBy((x) => x.referencedTable, xs));
+}, (table) => getCtx().runId + ":" + table);
+async function getPrimaryColumn(table) {
+    const tableMeta = await getTableMeta(table);
+    const columns = tableMeta.filter((x) => x.Key === "PRI");
+    if (columns.length !== 1) {
+        throw new Error("Expected to find 1 primary key for table: " + table);
+    }
+    const column = columns[0];
+    return {
+        name: column.Field,
+        type: getBaseJSONType(column.Type, getCtx().dialect),
+        nullable: column.Null === "YES"
+    };
+}
+async function getUniqueColumns(table, specialCaseUuidColumn) {
+    const tableMeta = await getTableMeta(table);
+    return tableMeta
+        .filter((x) => x.Key === "UNI" ||
+        // Because with the _Base pattern, Key isn't UNI for some reason
+        (specialCaseUuidColumn && x.Field === "uuid"))
+        .map((x) => ({
+        name: x.Field,
+        type: getBaseJSONType(x.Type, getCtx().dialect),
+        nullable: x.Null === "YES"
+    }));
+}
+async function getUuidColumn(table) {
+    const tableMeta = await getTableMeta(table);
+    const column = tableMeta.find((x) => x.Field === "uuid");
+    if (column == null) {
+        return undefined;
+    }
+    return {
+        name: column.Field,
+        type: column.Type,
+        nullable: column.Null === "YES"
+    };
+}
+const getPgEnumDefinition = (0, memoize_1.default)(async function getPgEnumDefinition(udtName) {
+    const { dialect, query } = getCtx();
+    if (dialect !== "postgresql")
+        return null;
+    const rows = await query(`SELECT e.enumlabel FROM pg_enum e
+     JOIN pg_type t ON e.enumtypid = t.oid
+     JOIN pg_catalog.pg_namespace n ON t.typnamespace = n.oid
+     WHERE t.typname = $1 AND n.nspname = 'public'
+     ORDER BY e.enumsortorder`, [udtName]);
+    if (rows.length === 0)
+        return null;
+    const labels = rows.map((r) => String(r.enumlabel).replace(/'/g, "''"));
+    return "enum('" + labels.join("', '") + "')";
+}, (udtName) => getCtx().runId + ":" + udtName);
+const getTableMeta = (0, memoize_1.default)(async function getTableMeta(table) {
+    const { dialect, query } = getCtx();
+    if (dialect === "mysql") {
+        return query("DESCRIBE ??", [table]).then((xs) => _.sortBy((x) => x.Field, xs));
+    }
+    if (dialect === "postgresql") {
+        const columns = await query(`SELECT column_name AS "Field", data_type, udt_name, character_maximum_length AS char_max, is_nullable, column_default AS "Default"
+       FROM information_schema.columns
+       WHERE table_schema = 'public' AND table_name = $1
+       ORDER BY ordinal_position`, [table]);
+        const keyInfo = await query(`SELECT a.attname AS col, 'PRI' AS key_type
+       FROM pg_index i
+       JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey) AND NOT a.attisdropped AND a.attnum > 0
+       JOIN pg_class c ON c.oid = i.indrelid
+       JOIN pg_namespace n ON n.oid = c.relnamespace
+       WHERE n.nspname = 'public' AND c.relname = $1 AND i.indisprimary
+       UNION ALL
+       SELECT kcu.column_name AS col, 'UNI' AS key_type
+       FROM information_schema.table_constraints tc
+       JOIN information_schema.key_column_usage kcu ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema
+       WHERE tc.table_schema = 'public' AND tc.table_name = $1 AND tc.constraint_type = 'UNIQUE'
+       UNION ALL
+       SELECT kcu.column_name AS col, 'MUL' AS key_type
+       FROM information_schema.table_constraints tc
+       JOIN information_schema.key_column_usage kcu ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema
+       WHERE tc.table_schema = 'public' AND tc.table_name = $1 AND tc.constraint_type = 'FOREIGN KEY'`, [table]);
+        const keyMap = new Map();
+        for (const k of keyInfo) {
+            if (!keyMap.has(k.col) || k.key_type === "PRI")
+                keyMap.set(k.col, k.key_type);
+        }
+        const udtNames = [
+            ...new Set(columns
+                .filter((c) => c.data_type === "USER-DEFINED" && c.udt_name != null)
+                .map((c) => c.udt_name))
+        ];
+        const enumDefs = await Promise.all(udtNames.map((udt) => getPgEnumDefinition(udt)));
+        const enumMap = new Map(udtNames.map((udt, i) => [udt, enumDefs[i] ?? "varchar(255)"]));
+        return columns.map((c) => {
+            let type;
+            if (c.data_type === "USER-DEFINED" && c.udt_name != null) {
+                type = enumMap.get(c.udt_name) ?? "character varying(255)";
+            }
+            else {
+                type = c.data_type;
+                if ((c.data_type === "character varying" || c.data_type === "character") &&
+                    c.char_max != null) {
+                    type += "(" + c.char_max + ")";
+                }
+            }
+            return {
+                Field: c.Field,
+                Type: type,
+                Null: c.is_nullable === "YES" ? "YES" : "NO",
+                Key: keyMap.get(c.Field) ?? "",
+                Default: c.Default ?? ""
+            };
+        });
+    }
+    throw new Error("Unsupported dialect: " + dialect);
+}, (table) => getCtx().runId + ":" + table);
+async function getShowCreateTable(table) {
+    const { dialect, query } = getCtx();
+    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, ""));
+    }
+    if (dialect === "postgresql") {
+        const [tableMeta, relations] = await Promise.all([
+            getTableMeta(table),
+            getRelationsManyToOne(table)
+        ]);
+        const refByFk = new Map(relations.map((r) => [r.foreignKey, r]));
+        const columnDefs = tableMeta.map((c) => {
+            let def = `"${c.Field.replace(/"/g, '""')}" ${c.Type} ${c.Null === "YES" ? "NULL" : "NOT NULL"}`;
+            if (c.Default != null && c.Default !== "") {
+                def += ` DEFAULT ${c.Default}`;
+            }
+            if (c.Key === "PRI")
+                def += " PRIMARY KEY";
+            if (c.Key === "UNI")
+                def += " UNIQUE";
+            const ref = refByFk.get(c.Field);
+            if (ref != null) {
+                def += ` REFERENCES "${ref.referencedTable.replace(/"/g, '""')}" ("${ref.referencedKey.replace(/"/g, '""')}")`;
+            }
+            return def;
+        });
+        return `CREATE TABLE "${table.replace(/"/g, '""')}" (\n  ${columnDefs.join(",\n  ")}\n)`;
+    }
+    return Promise.resolve(null);
+}
+function getJSONSchemaObjProperties(tableMeta) {
+    return tableMeta.reduce((acc, m) => {
+        const baseType = getBaseJSONType(m.Type, getCtx().dialect);
+        const format = getPropertyFormat(m.Type);
+        const nullable = m.Null === "YES";
+        const isEnum = m.Type.startsWith("enum");
+        const _enum = isEnum
+            ? getPropertyEnum(m.Type)
+            : undefined;
+        if (_enum && nullable) {
+            _enum.push(null);
+        }
+        acc[m.Field] = {
+            type: getJSONTypes(baseType, nullable)
+            // maxLength:
+            //   baseType === "string" && format == null && isEnum == null
+            //     ? getPropertyMaxLength(m.Type)
+            //     : undefined,
+        };
+        if (_enum !== void 0) {
+            acc[m.Field].enum = _enum;
+        }
+        if (format !== void 0) {
+            acc[m.Field].format = format;
+        }
+        return acc;
+    }, {});
+}
+function getJSONTypes(baseType, nullable) {
+    if (nullable) {
+        if (Array.isArray(baseType)) {
+            return baseType.concat("null");
+        }
+        return [baseType, "null"];
+    }
+    return baseType;
+}
+// https://github.com/mysqljs/mysql#type-casting
+function getBaseJSONType(sqlType, dialect) {
+    if (dialect === "postgresql") {
+        if (sqlType === "boolean" || sqlType === "bool")
+            return "boolean";
+        if (["smallint", "int2", "integer", "int4", "bigint", "int8"].includes(sqlType)) {
+            return "integer";
+        }
+        if (["real", "float4", "double precision", "float8"].includes(sqlType) ||
+            sqlType.startsWith("numeric") ||
+            sqlType.startsWith("decimal")) {
+            return "number";
+        }
+        if (["text", "uuid", "json", "jsonb"].includes(sqlType) ||
+            sqlType === "date" ||
+            sqlType === "time" ||
+            sqlType.startsWith("timestamp") ||
+            sqlType.startsWith("character varying") ||
+            sqlType.startsWith("character") ||
+            sqlType.startsWith("enum")) {
+            return "string";
+        }
+        throw new Error("Unable to map to JSON type: " + sqlType);
+    }
+    if (
+    // TODO?
+    sqlType === "tinyint(1)" ||
+        sqlType === "boolean" ||
+        sqlType === "bool" ||
+        sqlType === "bit") {
+        return "boolean";
+    }
+    // TODO?
+    if (sqlType === "timestamp" ||
+        sqlType === "datetime" ||
+        sqlType === "datetime2" ||
+        sqlType === "date") {
+        return "string";
+    }
+    if (sqlType.startsWith("char") ||
+        sqlType.startsWith("varchar") ||
+        sqlType.startsWith("tinytext") ||
+        sqlType.startsWith("mediumtext") ||
+        sqlType.startsWith("longtext") ||
+        sqlType.startsWith("text") ||
+        sqlType.startsWith("enum") ||
+        sqlType.startsWith("set") ||
+        sqlType.startsWith("time") ||
+        sqlType.startsWith("geometry") ||
+        // TODO?
+        // https://github.com/mysqljs/mysql#buffer
+        sqlType.startsWith("tinyblob") ||
+        sqlType.startsWith("mediumblob") ||
+        sqlType.startsWith("longblob") ||
+        sqlType.startsWith("blob") ||
+        sqlType.startsWith("binary") ||
+        sqlType.startsWith("varbinary") ||
+        sqlType === "uniqueidentifier"
+    // sqlType.startsWith("bit")
+    ) {
+        return "string";
+    }
+    if (sqlType.startsWith("tinyint") ||
+        sqlType.startsWith("smallint") ||
+        sqlType.startsWith("mediumint") ||
+        sqlType.startsWith("int") ||
+        sqlType.startsWith("year")) {
+        return "integer";
+    }
+    if (sqlType.startsWith("bigint")) {
+        // TODO: will be string if `bigNumberStrings` is used
+        // https://github.com/mysqljs/mysql#connection-options
+        return "integer";
+    }
+    if (sqlType.startsWith("float") || sqlType.startsWith("double")) {
+        return "number";
+    }
+    if (sqlType.startsWith("decimal")) {
+        // TODO: will be string if `bigNumberStrings` is used
+        // https://github.com/mysqljs/mysql#connection-options
+        return "number";
+    }
+    if (sqlType === "json" || sqlType === "nvarchar") {
+        // TODO
+        return "string";
+        // return ["array", "object"];
+    }
+    throw new Error("Unable to map to JSON type: " + sqlType);
+}
+// function getPropertyMaxLength(sqlType: string) {
+//   const a = sqlType.includes("(");
+//   if (a) {
+//     const tmp = sqlType.split("(");
+//     const b = tmp[tmp.length - 1];
+//     return parseInt(b.slice(0, b.length - 1));
+//   }
+//   return undefined;
+// }
+function getPropertyEnum(sqlType) {
+    const a = sqlType.split("enum(").filter(Boolean)[0];
+    const b = a.slice(0, a.length - 1);
+    const c = b
+        .split(",")
+        .map((x) => x.trim())
+        .map((x) => x.replace(/['"]/g, ""));
+    return c;
+}
+function getPropertyFormat(sqlType) {
+    if (sqlType === "datetime" ||
+        sqlType === "datetime2" ||
+        sqlType === "timestamp" ||
+        sqlType.startsWith("timestamp")) {
+        // TODO: not sure this is correct for `timestamp`
+        return "date-time";
+    }
+    if (sqlType === "date") {
+        // https://json-schema.org/understanding-json-schema/reference/string.html#built-in-formats
+        // https://github.com/epoberezkin/ajv#formats
+        // `date` isn't a built-in format, but it's supported by `Ajv`.
+        return "date";
+    }
+    if (sqlType === "time") {
+        // https://json-schema.org/understanding-json-schema/reference/string.html#built-in-formats
+        // https://github.com/epoberezkin/ajv#formats
+        // `time` isn't a built-in format, but it's supported by `Ajv`.
+        return "time";
+    }
+    return undefined;
+}
+async function getTableNames() {
+    const { dialect, query } = getCtx();
+    if (dialect === "mysql") {
+        return query("SHOW TABLES").then((xs) => xs.flatMap((x) => Object.values(x)).sort());
+    }
+    if (dialect === "postgresql") {
+        return query(`SELECT table_name FROM information_schema.tables
+       WHERE table_schema = 'public' AND table_type = 'BASE TABLE'
+       ORDER BY table_name`).then((rows) => rows.map((r) => r.table_name));
+    }
+    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\\".")
+  }
+}
+`;
+}