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

package/dist/generation/generate.js

@@ -30,24 +30,27 @@ 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");
-// json-schema-to-typescript inlines everything. We don't want that,
-// so use `tsType`, and add imports manually.
-// https://github.com/bcherny/json-schema-to-typescript#custom-schema-properties
-// https://github.com/bcherny/json-schema-to-typescript/issues/258
-// Meh
-let query = undefined;
-let dialect = "mysql";
+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: ""
 };
@@ -62,159 +65,176 @@ async function generate(input) {
     const specialCaseUuidColumn = input.specialCaseUuidColumn ?? true;
     const includeMappedFields = input.includeMappedFields ?? true;
     const supplementClientOpts = input.supplementClientOpts ?? true;
-    dialect = input.dialect;
-    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 ctx = {
+        runId: node_crypto_1.default.randomUUID(),
+        dialect: input.dialect,
+        query: undefined
     };
-    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);
+    return ctxStorage.run(ctx, async () => {
+        init(input);
+        let tables = await getTableNames();
+        if (tables.length === 0) {
+            throw new Error("No tables found");
         }
-        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 (input.tables != null) {
+            tables = tables.filter((x) => input.tables?.includes(x));
         }
-        if (x.kind === "postOne") {
-            fs.writeFileSync(path.join(typesDirPath, x.typeDataName + ".ts"), x.typeData);
+        if (input.excludeTables != null) {
+            tables = tables.filter((x) => !input.excludeTables?.includes(x));
         }
-        if (x.kind === "patchOne") {
-            fs.writeFileSync(path.join(typesDirPath, x.typeDataName + ".ts"), x.typeData);
+        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 (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) {
+        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;
-            }
-            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);
+            }, [])
+                .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 (dialect === "mysql") {
-        let mysql = new MySQL_1.MySQL({
+    if (ctx.dialect === "mysql") {
+        const mysql = new MySQL_1.MySQL({
             user,
             password,
             host,
             port,
             database
         });
-        query = mysql.query.bind(mysql);
+        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,
@@ -1068,7 +1088,7 @@ async function getMappedFields(table) {
             name: "uuid",
             // Replace `Id` with `Uuid`
             as: x.foreignKey.slice(0, -2) + "Uuid",
-            type: getBaseJSONType(uuidColumn.Type)
+            type: getBaseJSONType(uuidColumn.Type, getCtx().dialect)
         });
     }
     return out;
@@ -1489,7 +1509,7 @@ async function getArtifacts(tables, includeMappedFields, specialCaseUuidColumn)
             }
             return {
                 kind: "scalar",
-                type: getBaseJSONType(t.Type),
+                type: getBaseJSONType(t.Type, getCtx().dialect),
                 name: t.Field,
                 nullable,
                 hasDefaultValue: !!t.Default
@@ -1534,7 +1554,7 @@ async function getArtifacts(tables, includeMappedFields, specialCaseUuidColumn)
     }, {});
     return artifacts;
 }
-const getRelationInfo = _.memoize(async function getRelationInfo(table) {
+const getRelationInfo = (0, memoize_1.default)(async function getRelationInfo(table) {
     const relationsManyToOne = await getRelationsManyToOne(table);
     const relationsOneToMany = await getRelationsOneToMany(table);
     let out = [];
@@ -1604,7 +1624,7 @@ const getRelationInfo = _.memoize(async function getRelationInfo(table) {
     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"), ""));
 }
@@ -1627,11 +1647,12 @@ async function getJunctionTables() {
 }
 // `from` relations
 // https://stackoverflow.com/a/54732547
-// Note: this function
-// isn't pure (because of `dialect`), but that's fine because its value
-// isn't expected to change.
-const getRelationsManyToOne = _.memoize(async function getRelationsManyToOne(table) {
-    const sql = `
+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,
@@ -1646,8 +1667,18 @@ const getRelationsManyToOne = _.memoize(async function getRelationsManyToOne(tab
     AND REFERENCED_TABLE_NAME IS NOT NULL
     AND (TABLE_NAME = ?);
   `;
-    const tableMeta = await getTableMeta(table);
-    const rs = await query(sql, [table]);
+        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,
@@ -1658,10 +1689,13 @@ const getRelationsManyToOne = _.memoize(async function getRelationsManyToOne(tab
         };
     })));
     return _.sortBy((x) => x.referencedTable, xs);
-});
+}, (table) => getCtx().runId + ":" + table);
 // `to` relations
-const getRelationsOneToMany = _.memoize(async function getRelationsOneToMany(table) {
-    const sql = `
+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,
@@ -1676,19 +1710,29 @@ const getRelationsOneToMany = _.memoize(async function getRelationsOneToMany(tab
     AND REFERENCED_TABLE_NAME IS NOT NULL
     AND (REFERENCED_TABLE_NAME = ?);
   `;
-    const rs = await query(sql, [table]);
+        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,
-            // TODO? I think this is right, since it's one-to-many, so a list
             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");
@@ -1698,7 +1742,7 @@ async function getPrimaryColumn(table) {
     const column = columns[0];
     return {
         name: column.Field,
-        type: getBaseJSONType(column.Type),
+        type: getBaseJSONType(column.Type, getCtx().dialect),
         nullable: column.Null === "YES"
     };
 }
@@ -1710,7 +1754,7 @@ async function getUniqueColumns(table, specialCaseUuidColumn) {
         (specialCaseUuidColumn && x.Field === "uuid"))
         .map((x) => ({
         name: x.Field,
-        type: getBaseJSONType(x.Type),
+        type: getBaseJSONType(x.Type, getCtx().dialect),
         nullable: x.Null === "YES"
     }));
 }
@@ -1726,23 +1770,116 @@ async function getUuidColumn(table) {
         nullable: column.Null === "YES"
     };
 }
-const getTableMeta = _.memoize(async function getTableMeta(table) {
+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);
-});
-function getShowCreateTable(table) {
+}, (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);
+        const baseType = getBaseJSONType(m.Type, getCtx().dialect);
         const format = getPropertyFormat(m.Type);
         const nullable = m.Null === "YES";
         const isEnum = m.Type.startsWith("enum");
@@ -1778,7 +1915,29 @@ function getJSONTypes(baseType, nullable) {
     return baseType;
 }
 // https://github.com/mysqljs/mysql#type-casting
-function getBaseJSONType(sqlType) {
+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)" ||
@@ -1863,7 +2022,10 @@ function getPropertyEnum(sqlType) {
     return c;
 }
 function getPropertyFormat(sqlType) {
-    if (sqlType === "datetime" || sqlType === "datetime2" || sqlType === "timestamp") {
+    if (sqlType === "datetime" ||
+        sqlType === "datetime2" ||
+        sqlType === "timestamp" ||
+        sqlType.startsWith("timestamp")) {
         // TODO: not sure this is correct for `timestamp`
         return "date-time";
     }
@@ -1882,9 +2044,15 @@ function getPropertyFormat(sqlType) {
     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() {

package/dist/runtime/IRuntime.d.ts

@@ -45,7 +45,7 @@ export type TContext = {
     [k: string]: any;
 };
 export type TMiddleware = (params: TResolveParams, next: (params: TResolveParams) => Promise<any>) => Promise<any>;
-export type IDialect = "mysql" | "sqlite";
+export type IDialect = "mysql" | "sqlite" | "postgresql";
 export type TDbCall = (q: string) => Promise<any>;
 export type TFormatQuery = (q: string, values: any[]) => string;
 export type TBeginTransaction = () => Promise<TBeginTransactionResult>;
@@ -120,6 +120,7 @@ export type IGetSQLASTInput = {
     artifacts: IArtifacts;
     dialect: IDialect;
     firstChild?: IASTChildColumn | IASTChildComposite;
+    escapeId: (x: string) => string;
 };
 export type IRelation = {
     table: string;

package/dist/runtime/RuntimePostgreSQL.d.ts

@@ -0,0 +1,30 @@
+import { RedisConfig } from "./Cache";
+import type { IRuntime, TMiddleware, TResolveParams, IArtifacts, ISupplementClientOpts } from "./IRuntime";
+import { PostgreSQL } from "./lib/PostgreSQL";
+export declare class RuntimePostgreSQL implements IRuntime {
+    #private;
+    constructor(clientOpts: ConstructorParameters<typeof PostgreSQL>[0], otherOpts: {
+        supplementClientOpts?: ISupplementClientOpts;
+        redis?: RedisConfig;
+    }, artifacts: IArtifacts);
+    resolve(input: TResolveParams): Promise<any>;
+    $queryRaw(sql: string, values?: any[]): Promise<any[]>;
+    $use(middleware: TMiddleware): Promise<void>;
+    $whereNeedsProcessing(where: any): boolean;
+    $prepareWhere(artifacts: IArtifacts, table: string, data: any): Promise<{}>;
+    $shutdown(): Promise<void>;
+    $startTransaction(input?: {
+        isolationLevel?: "READ UNCOMMITTED" | "READ COMMITTED" | "REPEATABLE READ" | "SERIALIZABLE";
+    }): Promise<{
+        commit: () => Promise<void>;
+        rollback: () => Promise<void>;
+        dbCall: (q: string) => Promise<any[]>;
+        queryRaw: (q: string, values: any[]) => Promise<any[]>;
+    }>;
+    private dbCall;
+    /**
+     * Converts MySQL-style ?? (identifier) and ? (value) placeholders to
+     * pg-format placeholders (%I and %L) and formats the query.
+     */
+    private formatQuery;
+}

package/dist/runtime/RuntimePostgreSQL.js

@@ -0,0 +1,73 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _RuntimePostgreSQL_dialect, _RuntimePostgreSQL_pgClient, _RuntimePostgreSQL_clientCache, _RuntimePostgreSQL_middlewareHandler;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimePostgreSQL = void 0;
+const pg_format_1 = __importDefault(require("pg-format"));
+const Cache_1 = __importDefault(require("./Cache"));
+const PostgreSQL_1 = require("./lib/PostgreSQL");
+const shared_1 = require("./lib/shared");
+class RuntimePostgreSQL {
+    constructor(clientOpts, otherOpts, artifacts) {
+        _RuntimePostgreSQL_dialect.set(this, "postgresql");
+        _RuntimePostgreSQL_pgClient.set(this, void 0);
+        _RuntimePostgreSQL_clientCache.set(this, void 0);
+        _RuntimePostgreSQL_middlewareHandler.set(this, void 0);
+        __classPrivateFieldSet(this, _RuntimePostgreSQL_middlewareHandler, new shared_1.MiddlewareHandler(), "f");
+        if (otherOpts.redis) {
+            __classPrivateFieldSet(this, _RuntimePostgreSQL_clientCache, new Cache_1.default(otherOpts.redis, clientOpts?.debug), "f");
+        }
+        __classPrivateFieldSet(this, _RuntimePostgreSQL_pgClient, new PostgreSQL_1.PostgreSQL(clientOpts), "f");
+    }
+    async resolve(input) {
+        return (0, shared_1.resolve)(input, input.dbCall ?? this.dbCall.bind(this), this.formatQuery.bind(this), this.$startTransaction.bind(this), __classPrivateFieldGet(this, _RuntimePostgreSQL_dialect, "f"), __classPrivateFieldGet(this, _RuntimePostgreSQL_middlewareHandler, "f"), input.context ?? {}, __classPrivateFieldGet(this, _RuntimePostgreSQL_clientCache, "f"));
+    }
+    async $queryRaw(sql, values) {
+        return this.dbCall(this.formatQuery(sql, values ?? []));
+    }
+    async $use(middleware) {
+        __classPrivateFieldGet(this, _RuntimePostgreSQL_middlewareHandler, "f").register(middleware);
+    }
+    $whereNeedsProcessing(where) {
+        return (0, shared_1.whereNeedsProcessing)(where);
+    }
+    async $prepareWhere(artifacts, table, data) {
+        return (0, shared_1._prepareWhere)(artifacts, table, data, this.dbCall.bind(this), this.formatQuery.bind(this));
+    }
+    async $shutdown() {
+        if (__classPrivateFieldGet(this, _RuntimePostgreSQL_clientCache, "f")) {
+            await __classPrivateFieldGet(this, _RuntimePostgreSQL_clientCache, "f").shutdown();
+        }
+        await __classPrivateFieldGet(this, _RuntimePostgreSQL_pgClient, "f").endPool();
+    }
+    async $startTransaction(input) {
+        return __classPrivateFieldGet(this, _RuntimePostgreSQL_pgClient, "f").beginTransaction(input?.isolationLevel);
+    }
+    dbCall(q) {
+        return __classPrivateFieldGet(this, _RuntimePostgreSQL_pgClient, "f").query(
+        // join-monster doesn't use formatQuery, so this is needed
+        q.replace(/`/g, '"'));
+    }
+    /**
+     * Converts MySQL-style ?? (identifier) and ? (value) placeholders to
+     * pg-format placeholders (%I and %L) and formats the query.
+     */
+    formatQuery(q, values) {
+        return pg_format_1.default.withArray(q.replace(/`/g, '"').replace(/\?\?/g, "%I").replace(/\?/g, "%L"), values);
+    }
+}
+exports.RuntimePostgreSQL = RuntimePostgreSQL;
+_RuntimePostgreSQL_dialect = new WeakMap(), _RuntimePostgreSQL_pgClient = new WeakMap(), _RuntimePostgreSQL_clientCache = new WeakMap(), _RuntimePostgreSQL_middlewareHandler = new WeakMap();

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

@@ -0,0 +1,14 @@
+import { Pool } from "pg";
+export type TPoolConfig = ConstructorParameters<typeof Pool>[0];
+export declare class PostgreSQL {
+    pool: Pool;
+    constructor(opts: TPoolConfig);
+    query(q: string): Promise<any[]>;
+    beginTransaction(isolationLevel?: "READ UNCOMMITTED" | "READ COMMITTED" | "REPEATABLE READ" | "SERIALIZABLE"): Promise<{
+        commit: () => Promise<void>;
+        rollback: () => Promise<void>;
+        dbCall: (q: string) => Promise<any[]>;
+        queryRaw: (q: string, values: any[]) => Promise<any[]>;
+    }>;
+    endPool(): Promise<void>;
+}

package/dist/runtime/lib/PostgreSQL.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgreSQL = void 0;
+const pg_1 = require("pg");
+// OID 20 = int8 (BIGINT/BIGSERIAL). Parse as number for consistency with MySQL.
+const BIGINT_OID = 20;
+pg_1.types.setTypeParser(BIGINT_OID, (val) => val === null ? null : parseInt(val, 10));
+// OID 114 = json, 3802 = jsonb. Return raw string for consistency with MySQL.
+pg_1.types.setTypeParser(114, (val) => val);
+pg_1.types.setTypeParser(3802, (val) => val);
+class PostgreSQL {
+    constructor(opts) {
+        this.pool = new pg_1.Pool(opts);
+        if (opts && opts.debug) {
+            this.pool.on("acquire", () => {
+                console.log("Connection acquired from pool");
+            });
+            this.pool.on("connect", () => {
+                console.log("Client connected to PostgreSQL");
+            });
+            this.pool.on("remove", () => {
+                console.log("Client removed from pool");
+            });
+        }
+    }
+    query(q) {
+        return this.pool.query(q).then((result) => result.rows);
+    }
+    async beginTransaction(isolationLevel) {
+        const client = await this.pool.connect();
+        let released = false;
+        const releaseOnce = () => {
+            if (!released) {
+                released = true;
+                client.release();
+            }
+        };
+        if (isolationLevel != null) {
+            if (isolationLevel !== "READ UNCOMMITTED" &&
+                isolationLevel !== "READ COMMITTED" &&
+                isolationLevel !== "REPEATABLE READ" &&
+                isolationLevel !== "SERIALIZABLE") {
+                releaseOnce();
+                throw new Error(`Invalid isolationLevel: ${isolationLevel}`);
+            }
+            // PostgreSQL: BEGIN ISOLATION LEVEL <level>
+            await client.query(`BEGIN ISOLATION LEVEL ${isolationLevel}`);
+        }
+        else {
+            await client.query("BEGIN");
+        }
+        return {
+            commit: () => {
+                if (released)
+                    return Promise.resolve();
+                return client
+                    .query("COMMIT")
+                    .then(() => undefined)
+                    .catch(async (err) => {
+                    try {
+                        await client.query("ROLLBACK");
+                    }
+                    catch {
+                        // Ignore
+                    }
+                    throw err;
+                })
+                    .finally(releaseOnce);
+            },
+            rollback: () => {
+                if (released)
+                    return Promise.resolve();
+                return client
+                    .query("ROLLBACK")
+                    .then(() => undefined)
+                    .finally(releaseOnce);
+            },
+            dbCall: (q) => client
+                .query(q)
+                .then((result) => result.rows)
+                .catch(async (err) => {
+                try {
+                    await client.query("ROLLBACK");
+                }
+                catch {
+                    // Ignore
+                }
+                releaseOnce();
+                throw err;
+            }),
+            queryRaw: (q, values) => client
+                .query(q, values)
+                .then((result) => result.rows)
+                .catch(async (err) => {
+                try {
+                    await client.query("ROLLBACK");
+                }
+                catch {
+                    // Ignore
+                }
+                releaseOnce();
+                throw err;
+            })
+        };
+    }
+    async endPool() {
+        await this.pool.end();
+    }
+}
+exports.PostgreSQL = PostgreSQL;

package/dist/runtime/lib/getSqlAst.js

@@ -34,7 +34,7 @@ const _ = __importStar(require("lodash/fp"));
 const getOrderBy_1 = require("./getOrderBy");
 const namespace = new alias_namespace_1.default(true);
 function getSqlAst(input) {
-    const { table, fieldName, fields, args, grabMany, sqlJoin, sqlBatch, junction, getWhere, artifacts, rowWithMatchingCursor, dialect } = input;
+    const { table, fieldName, fields, args, grabMany, sqlJoin, sqlBatch, junction, getWhere, artifacts, rowWithMatchingCursor, dialect, escapeId } = input;
     const tableArtifacts = artifacts[table];
     const primaryKey = tableArtifacts.primaryKey;
     const format = SqlString.format.bind(SqlString);
@@ -162,9 +162,9 @@ function getSqlAst(input) {
                             // TODO - where
                             // sqlJoins: [
                             //   (t: string, junctionTable: string, args: any) =>
-                            //     `${t}.${relationField.relations[0].referencedKey} = ${junctionTable}.${relationField.relations[0].foreignKey}`,
+                            //     `${t}.${escapeId(relationField.relations[0].referencedKey)} = ${junctionTable}.${escapeId(relationField.relations[0].foreignKey)}`,
                             //   (junctionTable: string, t: string, args: any) =>
-                            //     `${junctionTable}.${relationField.relations[1].foreignKey} = ${t}.${relationField.relations[1].referencedKey}`,
+                            //     `${junctionTable}.${escapeId(relationField.relations[1].foreignKey)} = ${t}.${escapeId(relationField.relations[1].referencedKey)}`,
                             // ],
                             // We have to use sqlBatch instead of sqlJoin because pagination is not
                             // supported with `mysql` dialect, and LIMITing the root list means
@@ -172,12 +172,13 @@ function getSqlAst(input) {
                             sqlBatch: {
                                 thisKey: columnToASTChild(relationField.relations[0].foreignKey, namespace, asJunction),
                                 parentKey: columnToASTChild(relationField.relations[0].referencedKey, namespace),
-                                sqlJoin: (junctionTable, t, args) => `${junctionTable}.${relationField.relations[1].foreignKey} = ${t}.${relationField.relations[1].referencedKey}`
+                                sqlJoin: (junctionTable, t, args) => `${junctionTable}.${escapeId(relationField.relations[1].foreignKey)} = ${t}.${escapeId(relationField.relations[1].referencedKey)}`
                             }
                         },
                         getWhere,
                         artifacts,
-                        dialect
+                        dialect,
+                        escapeId
                     });
                 }
                 return getSqlAst({
@@ -207,7 +208,8 @@ function getSqlAst(input) {
                     },
                     getWhere,
                     artifacts,
-                    dialect
+                    dialect,
+                    escapeId
                 });
             }
             else {

package/dist/runtime/lib/shared.js

@@ -230,6 +230,7 @@ async function getData(input, dbCall, formatQuery, dialect) {
         action === "findManyPaginated" ||
         action === "updateMany" ||
         action === "deleteMany";
+    const escapeId = (0, stringifyWhere_1.getEscapeId)(dialect);
     const sqlAST = (0, getSqlAst_1.getSqlAst)({
         ...input,
         table: input.resource,
@@ -239,9 +240,12 @@ async function getData(input, dbCall, formatQuery, dialect) {
         orderBy: orderByListPaginatedRootResult?.orderBy,
         rowWithMatchingCursor,
         dialect,
-        grabMany
+        grabMany,
+        escapeId
     });
-    const options = { dialect: dialect === "sqlite" ? "mysql" : dialect };
+    const options = {
+        dialect: dialect === "postgresql" ? "pg" : dialect === "sqlite" ? "mysql" : dialect
+    };
     let { sql, shapeDefinition } = await (0, util_1.compileSqlAST)(sqlAST, context, options);
     if (!sql) {
         // return {};
@@ -315,7 +319,8 @@ async function getData(input, dbCall, formatQuery, dialect) {
                 // We don't want the where clause to include cursor-related stuff
                 rowWithMatchingCursor: null,
                 dialect,
-                grabMany: true
+                grabMany: true,
+                escapeId
             });
             // Because orderBy doesn't matter for total count.
             // getOrderBy adds an element if paginating, so deleting args.$orderBy
@@ -464,6 +469,26 @@ const runCreateTreeMySQL = async (table, referencedKey, referencedKeyValue, colu
     }
     return Promise.all(allColumns.map((cs, i) => dbCall(formatQuery(`INSERT INTO ?? (??) VALUES (?)`, [table, cs, allValues[i]])).then((x) => x.insertId)));
 };
+const runCreateTreePostgreSQL = async (table, referencedKey, referencedKeyValue, columns, values, dbCall, formatQuery, artifacts) => {
+    if (artifacts == null) {
+        throw new Error("artifacts required for PostgreSQL runCreateTree");
+    }
+    const primaryKey = artifacts[table]?.primaryKey ?? "id";
+    let allColumns = columns;
+    if (typeof referencedKey === "string") {
+        allColumns = allColumns.slice().map((xs) => xs.concat(referencedKey));
+    }
+    let allValues = values;
+    if (referencedKeyValue != null) {
+        allValues = allValues.slice().map((xs) => xs.concat(referencedKeyValue));
+    }
+    return Promise.all(allColumns.map((cs, i) => dbCall(formatQuery(`INSERT INTO ?? (??) VALUES (?) RETURNING ??`, [
+        table,
+        cs,
+        allValues[i],
+        primaryKey
+    ])).then((rows) => rows[0]?.[primaryKey])));
+};
 async function create(input, dbCall, formatQuery, beginTransaction, dialect, context) {
     async function _create() {
         // Shallow clone, as we're going to mutate later
@@ -485,7 +510,8 @@ async function create(input, dbCall, formatQuery, beginTransaction, dialect, con
         });
         if (hasChildren) {
             const { dbCall: dbCallTransaction, commit } = await beginTransaction();
-            const id = await runCreateTree(getCreateTree([data], input.resource, null, context?.specialCaseUuidColumn, dialect, input.artifacts), null, runCreateTreeMySQL, dbCallTransaction, formatQuery, dialect).then((xs) => xs[0]);
+            const runCreateTreeSQL = dialect === "postgresql" ? runCreateTreePostgreSQL : runCreateTreeMySQL;
+            const id = await runCreateTree(getCreateTree([data], input.resource, null, context?.specialCaseUuidColumn, dialect, input.artifacts), null, runCreateTreeSQL, dbCallTransaction, formatQuery, dialect, input.artifacts).then((xs) => xs[0]);
             await commit();
             return id;
         }
@@ -493,6 +519,16 @@ async function create(input, dbCall, formatQuery, beginTransaction, dialect, con
             data = processCreateData(data, tableArtifacts, dialect, context?.specialCaseUuidColumn);
             const columns = Object.keys(data);
             const values = Object.values(data);
+            if (dialect === "postgresql") {
+                const primaryKey = tableArtifacts.primaryKey;
+                const inserted = await dbCall(formatQuery(`INSERT INTO ?? (??) VALUES (?) RETURNING ??`, [
+                    input.resource,
+                    columns,
+                    values,
+                    primaryKey
+                ]));
+                return inserted[0]?.[primaryKey];
+            }
             const inserted = await dbCall(formatQuery(`INSERT INTO ?? (??) VALUES (?)`, [
                 input.resource,
                 columns,
@@ -506,7 +542,8 @@ async function create(input, dbCall, formatQuery, beginTransaction, dialect, con
 }
 function processCreateData(data, tableArtifacts, dialect, specialCaseUuidColumn) {
     let out = { ...data };
-    if (dialect === "mysql" && tableArtifacts.dateTimeFieldsCount > 0) {
+    if ((dialect === "mysql" || dialect === "postgresql") &&
+        tableArtifacts.dateTimeFieldsCount > 0) {
         for (let k in tableArtifacts.dateTimeFields) {
             if (out[k] != null) {
                 out[k] = (0, getDateTimeStringMySQL_1.getDateTimeStringMySQL)(out[k]);
@@ -527,10 +564,10 @@ function processCreateData(data, tableArtifacts, dialect, specialCaseUuidColumn)
     }
     return out;
 }
-async function runCreateTree(tree, referencedKeyValue, runCreateTreeSQL, dbCall, formatQuery, dialect) {
-    const ids = await runCreateTreeSQL(tree.table, tree.referencedKey, referencedKeyValue, tree.columns, tree.values, dbCall, formatQuery);
+async function runCreateTree(tree, referencedKeyValue, runCreateTreeSQL, dbCall, formatQuery, dialect, artifacts) {
+    const ids = await runCreateTreeSQL(tree.table, tree.referencedKey, referencedKeyValue, tree.columns, tree.values, dbCall, formatQuery, artifacts);
     if (tree.children?.length > 0) {
-        await Promise.all(ids.flatMap((id, i) => tree.children[i].map((c) => runCreateTree(c, id, runCreateTreeSQL, dbCall, formatQuery, dialect))));
+        await Promise.all(ids.flatMap((id, i) => tree.children[i].map((c) => runCreateTree(c, id, runCreateTreeSQL, dbCall, formatQuery, dialect, artifacts))));
     }
     return ids;
 }
@@ -593,7 +630,8 @@ async function update(input, dbCall, formatQuery, dialect, cache) {
         if (hasMappedFields(input.artifacts, input.resource, data)) {
             await mapMappedFields(tableArtifacts, data, dbCall, formatQuery);
         }
-        if (dialect === "mysql" && tableArtifacts.dateTimeFieldsCount > 0) {
+        if ((dialect === "mysql" || dialect === "postgresql") &&
+            tableArtifacts.dateTimeFieldsCount > 0) {
             for (let k in tableArtifacts.dateTimeFields) {
                 if (data[k] != null) {
                     data[k] = (0, getDateTimeStringMySQL_1.getDateTimeStringMySQL)(data[k]);
@@ -670,9 +708,10 @@ function getUpdateQuery(table, data, where, dialect, formatQuery) {
     return formatQuery(q, values);
 }
 function stringifyConcat(operand1, operand2, dialect) {
-    if (dialect !== "sqlite") {
+    if (dialect === "mysql") {
         return `CONCAT(${operand1}, ${operand2})`;
     }
+    // sqlite and postgresql use || for string concatenation
     return `(${operand1} || ${operand2})`;
 }
 async function updateMany(input, dbCall, formatQuery, dialect, cache) {
@@ -698,7 +737,8 @@ async function updateMany(input, dbCall, formatQuery, dialect, cache) {
         if (hasMappedFields(input.artifacts, input.resource, data)) {
             await mapMappedFields(tableArtifacts, data, dbCall, formatQuery);
         }
-        if (dialect === "mysql" && tableArtifacts.dateTimeFieldsCount > 0) {
+        if ((dialect === "mysql" || dialect === "postgresql") &&
+            tableArtifacts.dateTimeFieldsCount > 0) {
             for (let k in tableArtifacts.dateTimeFields) {
                 if (data[k] != null) {
                     data[k] = (0, getDateTimeStringMySQL_1.getDateTimeStringMySQL)(data[k]);

package/dist/runtime/lib/stringifyWhere.js

@@ -30,6 +30,7 @@ const _ = __importStar(require("lodash/fp"));
 const MySqlString = __importStar(require("sqlstring"));
 // @ts-expect-error
 const SqliteString = __importStar(require("sqlstring-sqlite"));
+const pgFormat = __importStar(require("pg-format"));
 function stringifyWhere(input) {
     const { where, table, dialect, args, orderBy, rowWithMatchingCursor } = input;
     const escapeId = getEscapeId(dialect);
@@ -237,6 +238,9 @@ function getEscapeId(dialect) {
     if (dialect === "sqlite") {
         return SqliteString.escapeId.bind(SqliteString);
     }
+    if (dialect === "postgresql") {
+        return (id) => pgFormat.ident(id);
+    }
     throw new Error("Unsupported dialect: " + dialect);
 }
 function getEscape(dialect) {
@@ -246,5 +250,8 @@ function getEscape(dialect) {
     if (dialect === "sqlite") {
         return SqliteString.escape.bind(SqliteString);
     }
+    if (dialect === "postgresql") {
+        return (value) => pgFormat.literal(value);
+    }
     throw new Error("Unsupported dialect: " + dialect);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@technicity/data-service-generator",
-  "version": "0.22.2",
+  "version": "0.23.0-next.1",
   "main": "./dist/index.js",
   "files": [
     "dist"
@@ -25,6 +25,8 @@
     "lodash": "^4.17.23",
     "loglevel": "^1.8.1",
     "mysql2": "^3.10.1",
+    "pg": "^8.13.1",
+    "pg-format": "^1.0.4",
     "prettier": "^2.1.2",
     "sqlstring": "^2.3.2",
     "sqlstring-sqlite": "^0.1.1",
@@ -35,9 +37,11 @@
     "@swc/core": "^1.3.36",
     "@swc/jest": "^0.2.24",
     "@testcontainers/mysql": "^10.23.0",
+    "@testcontainers/postgresql": "^10.23.0",
     "@types/fs-extra": "9.0.13",
     "@types/lodash": "4.14.177",
     "@types/node": "^18.14.1",
+    "@types/pg": "^8.11.10",
     "@types/prettier": "^2.1.5",
     "@types/sqlstring": "^2.2.1",
     "@types/uuid": "^8.3.1",