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

package/dist/src/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/src/runtime/RuntimeSQLite.d.ts

@@ -0,0 +1,42 @@
+import Database from "better-sqlite3";
+import type { IRuntime, TMiddleware, TResolveParams, IArtifacts, ISupplementClientOpts } from "./IRuntime";
+import { MiddlewareHandler } from "./lib/shared";
+type TClientOpts = {
+    filename: string;
+} & Parameters<typeof Database>[1];
+export declare class RuntimeSQLite implements IRuntime {
+    #private;
+    __middlewareHandler: MiddlewareHandler<TMiddleware>;
+    constructor(clientOpts: TClientOpts, otherOpts: {
+        createTablesString?: string;
+        seedString?: string;
+        supplementClientOpts?: ISupplementClientOpts;
+    }, artifacts: IArtifacts);
+    resolve(input: TResolveParams): Promise<any>;
+    $queryRaw(sql: string, values?: any[]): Promise<unknown[] | {
+        insertId: number | bigint;
+    }>;
+    $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<unknown[] | {
+            insertId: number | bigint;
+        }>;
+        queryRaw: (sql: string, values?: any[] | undefined) => Promise<unknown[] | {
+            insertId: number | bigint;
+        }>;
+    }>;
+    private dbCall;
+    private formatQuery;
+    private dbCallTransaction;
+    private queryRawTransaction;
+    private commit;
+    private rollback;
+}
+export {};

package/dist/src/runtime/RuntimeSQLite.js

@@ -0,0 +1,150 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    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 _RuntimeSQLite_dialect, _RuntimeSQLite_db;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeSQLite = void 0;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+// @ts-expect-error
+const SqliteString = __importStar(require("sqlstring-sqlite"));
+const shared_1 = require("./lib/shared");
+class RuntimeSQLite {
+    constructor(clientOpts, otherOpts, artifacts) {
+        _RuntimeSQLite_dialect.set(this, "sqlite");
+        _RuntimeSQLite_db.set(this, void 0);
+        const { filename, ...restOpts } = clientOpts;
+        this.__middlewareHandler = new shared_1.MiddlewareHandler();
+        __classPrivateFieldSet(this, _RuntimeSQLite_db, new better_sqlite3_1.default(filename, restOpts), "f");
+        if (clientOpts.filename === ":memory:") {
+            if (!otherOpts.createTablesString) {
+                throw new Error(`\`createTablesString\` must be supplied when filename is \`:memory:\`.`);
+            }
+            __classPrivateFieldGet(this, _RuntimeSQLite_db, "f").exec(otherOpts.createTablesString);
+            if (otherOpts.seedString) {
+                __classPrivateFieldGet(this, _RuntimeSQLite_db, "f").exec(otherOpts.seedString);
+            }
+        }
+    }
+    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, _RuntimeSQLite_dialect, "f"), this.__middlewareHandler, input.context ?? {});
+    }
+    async $queryRaw(sql, values) {
+        return this.dbCall(this.formatQuery(sql, values ?? []));
+    }
+    async $use(middleware) {
+        this.__middlewareHandler.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() {
+        __classPrivateFieldGet(this, _RuntimeSQLite_db, "f").close();
+    }
+    async $startTransaction(input) {
+        const isolationLevel = input?.isolationLevel;
+        if (isolationLevel != null) {
+            if (isolationLevel !== "READ UNCOMMITTED" &&
+                isolationLevel !== "READ COMMITTED" &&
+                isolationLevel !== "REPEATABLE READ" &&
+                isolationLevel !== "SERIALIZABLE") {
+                throw new Error(`Invalid isolationLevel: ${isolationLevel}`);
+            }
+        }
+        __classPrivateFieldGet(this, _RuntimeSQLite_db, "f").prepare("BEGIN TRANSACTION").run();
+        return {
+            commit: this.commit.bind(this),
+            rollback: this.rollback.bind(this),
+            dbCall: this.dbCallTransaction.bind(this),
+            queryRaw: this.queryRawTransaction.bind(this)
+        };
+    }
+    async dbCall(q) {
+        const statement = __classPrivateFieldGet(this, _RuntimeSQLite_db, "f").prepare(q);
+        if (q.startsWith("INSERT") || q.startsWith("UPDATE") || q.startsWith("DELETE")) {
+            const result = statement.run();
+            return { insertId: result.lastInsertRowid };
+        }
+        // TODO: use statement.raw instead of typeCastSqlite? That would stop
+        // working if we start joining instead of batching, though.
+        // https://github.com/WiseLibs/better-sqlite3/blob/master/docs/api.md#rawtogglestate---this
+        return statement.all();
+    }
+    formatQuery(q, values) {
+        return SqliteString.format(q, values);
+    }
+    async dbCallTransaction(...args) {
+        try {
+            return await this.dbCall(...args);
+        }
+        catch (err) {
+            __classPrivateFieldGet(this, _RuntimeSQLite_db, "f").prepare("ROLLBACK").run();
+            throw err;
+        }
+    }
+    async queryRawTransaction(...args) {
+        try {
+            return await this.$queryRaw(...args);
+        }
+        catch (err) {
+            __classPrivateFieldGet(this, _RuntimeSQLite_db, "f").prepare("ROLLBACK").run();
+            throw err;
+        }
+    }
+    async commit() {
+        try {
+            __classPrivateFieldGet(this, _RuntimeSQLite_db, "f").prepare("COMMIT").run();
+        }
+        catch (err) {
+            __classPrivateFieldGet(this, _RuntimeSQLite_db, "f").prepare("ROLLBACK").run();
+            throw err;
+        }
+    }
+    async rollback() {
+        try {
+            __classPrivateFieldGet(this, _RuntimeSQLite_db, "f").prepare("ROLLBACK").run();
+        }
+        catch (e) {
+            console.log(e);
+        }
+    }
+}
+exports.RuntimeSQLite = RuntimeSQLite;
+_RuntimeSQLite_dialect = new WeakMap(), _RuntimeSQLite_db = new WeakMap();

package/dist/src/runtime/Stats.d.ts

@@ -0,0 +1,8 @@
+import Redis, { Cluster } from "ioredis";
+declare class Stats {
+    client: Redis | Cluster;
+    constructor(client: Redis | Cluster);
+    updateStats: (ms: number, category: string) => Promise<void>;
+}
+export declare function timer(): <T extends timer.Callback>(callback: T, ...args: timer.Params<T>) => void;
+export default Stats;

package/dist/src/runtime/Stats.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timer = timer;
+const perf_hooks_1 = require("perf_hooks");
+class Stats {
+    constructor(client) {
+        this.client = client;
+        this.updateStats = async (ms, category) => {
+            const redis = this.client;
+            const requests = Number(await redis.get(`stats:${category}_requests`)) || 0;
+            const average = Number(await redis.get(`stats:${category}_avg`)) || 0;
+            const max = Number(await redis.get(`stats:${category}_max`)) || 0;
+            const min = Number(await redis.get(`stats:${category}_min`)) || Infinity;
+            const newTotalRequests = requests + 1;
+            const newAverage = (average * requests + ms) / newTotalRequests;
+            await redis.set(`stats:${category}_requests`, newTotalRequests);
+            await redis.set(`stats:${category}_avg`, newAverage);
+            if (ms > max)
+                await redis.set(`stats:${category}_max`, ms);
+            if (ms < min)
+                await redis.set(`stats:${category}_min`, ms);
+        };
+    }
+}
+function timer() {
+    const start = perf_hooks_1.performance.now();
+    return (callback, ...args) => {
+        callback(perf_hooks_1.performance.now() - start, ...args);
+    };
+}
+exports.default = Stats;

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

@@ -0,0 +1,13 @@
+import * as mysql from "mysql2/promise";
+export declare class MySQL {
+    pool: mysql.Pool;
+    constructor(opts: Parameters<typeof mysql.createPool>[0]);
+    query(...args: any[]): Promise<mysql.OkPacket | mysql.ResultSetHeader | mysql.ResultSetHeader[] | mysql.RowDataPacket[] | mysql.RowDataPacket[][] | mysql.OkPacket[] | [mysql.RowDataPacket[], mysql.ResultSetHeader]>;
+    beginTransaction(isolationLevel?: "READ UNCOMMITTED" | "READ COMMITTED" | "REPEATABLE READ" | "SERIALIZABLE"): Promise<{
+        commit: () => Promise<void>;
+        rollback: () => Promise<void>;
+        dbCall: (q: string) => Promise<mysql.OkPacket | mysql.ResultSetHeader | mysql.ResultSetHeader[] | mysql.RowDataPacket[] | mysql.RowDataPacket[][] | mysql.OkPacket[] | [mysql.RowDataPacket[], mysql.ResultSetHeader]>;
+        queryRaw: (q: string, values: any[]) => Promise<mysql.OkPacket | mysql.ResultSetHeader | mysql.ResultSetHeader[] | mysql.RowDataPacket[] | mysql.RowDataPacket[][] | mysql.OkPacket[] | [mysql.RowDataPacket[], mysql.ResultSetHeader]>;
+    }>;
+    endPool(): Promise<void>;
+}

package/dist/src/runtime/lib/MySQL.js

@@ -0,0 +1,116 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySQL = void 0;
+const mysql = __importStar(require("mysql2/promise"));
+class MySQL {
+    constructor(opts) {
+        this.pool = mysql.createPool({
+            ...opts,
+            // For backward compat with the previous mysql implementation https://github.com/mysqljs/mysql
+            // https://sidorares.github.io/node-mysql2/docs/documentation#known-incompatibilities-with-node-mysql
+            jsonStrings: true
+        });
+        if (opts.debug) {
+            this.pool.on("acquire", (connection) => {
+                console.log("Connection %d acquired", connection.threadId);
+            });
+            this.pool.on("connection", (connection) => {
+                console.log("Connection %d connected", connection.threadId);
+            });
+            this.pool.on("enqueue", () => {
+                console.log("Waiting for available connection slot");
+            });
+            this.pool.on("release", (connection) => {
+                console.log("Connection %d released", connection.threadId);
+            });
+        }
+    }
+    query(...args) {
+        return this.pool
+            .query(
+        // @ts-expect-error
+        ...args)
+            .then(([rows]) => rows);
+    }
+    async beginTransaction(isolationLevel) {
+        const connection = await this.pool.getConnection();
+        // https://dev.mysql.com/doc/refman/8.0/en/set-transaction.html#set-transaction-isolation-level
+        // Without any SESSION or GLOBAL keyword:
+        // The statement applies only to the next single transaction performed within the session.
+        if (isolationLevel != null) {
+            if (isolationLevel !== "READ UNCOMMITTED" &&
+                isolationLevel !== "READ COMMITTED" &&
+                isolationLevel !== "REPEATABLE READ" &&
+                isolationLevel !== "SERIALIZABLE") {
+                throw new Error(`Invalid isolationLevel: ${isolationLevel}`);
+            }
+            await connection.query(`SET TRANSACTION ISOLATION LEVEL ${isolationLevel};`);
+        }
+        await connection.beginTransaction();
+        return {
+            commit: () => connection
+                .commit()
+                .catch(async (err) => {
+                await connection.rollback();
+                throw err;
+            })
+                .finally(() => {
+                connection.release();
+            }),
+            rollback: () => connection.rollback().finally(() => {
+                connection.release();
+            }),
+            dbCall: (q) => connection
+                .query(q)
+                .then(([rows]) => rows)
+                .catch(async (err) => {
+                try {
+                    await connection.rollback();
+                }
+                finally {
+                    connection.release();
+                }
+                throw err;
+            }),
+            queryRaw: (q, values) => connection
+                .query(q, values)
+                .then(([rows]) => rows)
+                .catch(async (err) => {
+                try {
+                    await connection.rollback();
+                }
+                finally {
+                    connection.release();
+                }
+                throw err;
+            })
+        };
+    }
+    async endPool() {
+        await this.pool.end();
+    }
+}
+exports.MySQL = MySQL;

package/dist/src/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/src/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/src/runtime/lib/SDKBadWhereError.d.ts

@@ -0,0 +1,4 @@
+import { CustomError } from "../../lib/CustomError";
+export declare class SDKBadWhereError extends CustomError {
+    constructor(message?: string);
+}

package/dist/src/runtime/lib/SDKBadWhereError.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDKBadWhereError = void 0;
+const CustomError_1 = require("../../lib/CustomError");
+class SDKBadWhereError extends CustomError_1.CustomError {
+    constructor(message) {
+        super(message || "Invalid $where");
+    }
+}
+exports.SDKBadWhereError = SDKBadWhereError;

package/dist/src/runtime/lib/SDKNotFoundError.d.ts

@@ -0,0 +1,4 @@
+import { CustomError } from "../../lib/CustomError";
+export declare class SDKNotFoundError extends CustomError {
+    constructor();
+}

package/dist/src/runtime/lib/SDKNotFoundError.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDKNotFoundError = void 0;
+const CustomError_1 = require("../../lib/CustomError");
+class SDKNotFoundError extends CustomError_1.CustomError {
+    constructor() {
+        super("Not found");
+    }
+}
+exports.SDKNotFoundError = SDKNotFoundError;

package/dist/src/runtime/lib/addNullFallbacks.d.ts

@@ -0,0 +1 @@
+export declare function addNullFallbacks(sqlAST: any, data: any): void;

package/dist/src/runtime/lib/addNullFallbacks.js

@@ -0,0 +1,32 @@
+"use strict";
+// If a many-to-one relation's ID field is null, we want the
+// relation field to be null as well, not undefined.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addNullFallbacks = addNullFallbacks;
+function addNullFallbacks(sqlAST, data) {
+    if (data == null) {
+        return;
+    }
+    for (let child of sqlAST.children ?? []) {
+        if (child.type === "table") {
+            if (Array.isArray(data)) {
+                for (let d of data) {
+                    if (d[child.fieldName] == null) {
+                        d[child.fieldName] = null;
+                    }
+                    if (child.children.length > 0 && d[child.fieldName] != null) {
+                        addNullFallbacks(child, d[child.fieldName]);
+                    }
+                }
+            }
+            else {
+                if (data[child.fieldName] == null) {
+                    data[child.fieldName] = null;
+                }
+                if (child.children.length > 0 && data[child.fieldName] != null) {
+                    addNullFallbacks(child, data[child.fieldName]);
+                }
+            }
+        }
+    }
+}

package/dist/src/runtime/lib/addNullFallbacks.test.d.ts

@@ -0,0 +1 @@
+export {};