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

package/dist/src/index.d.ts

@@ -0,0 +1,4 @@
+export { generate } from "./generation/generate";
+export { SDKNotFoundError } from "./runtime/lib/SDKNotFoundError";
+export { SDKBadWhereError } from "./runtime/lib/SDKBadWhereError";
+export { traverseFieldArgs } from "./traverseFieldArgs";

package/dist/src/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traverseFieldArgs = exports.SDKBadWhereError = exports.SDKNotFoundError = exports.generate = void 0;
+var generate_1 = require("./generation/generate");
+Object.defineProperty(exports, "generate", { enumerable: true, get: function () { return generate_1.generate; } });
+var SDKNotFoundError_1 = require("./runtime/lib/SDKNotFoundError");
+Object.defineProperty(exports, "SDKNotFoundError", { enumerable: true, get: function () { return SDKNotFoundError_1.SDKNotFoundError; } });
+var SDKBadWhereError_1 = require("./runtime/lib/SDKBadWhereError");
+Object.defineProperty(exports, "SDKBadWhereError", { enumerable: true, get: function () { return SDKBadWhereError_1.SDKBadWhereError; } });
+var traverseFieldArgs_1 = require("./traverseFieldArgs");
+Object.defineProperty(exports, "traverseFieldArgs", { enumerable: true, get: function () { return traverseFieldArgs_1.traverseFieldArgs; } });

package/dist/src/lib/CustomError.d.ts

@@ -0,0 +1,3 @@
+export declare class CustomError extends Error {
+    constructor(message: string);
+}

package/dist/src/lib/CustomError.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomError = void 0;
+class CustomError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+    }
+}
+exports.CustomError = CustomError;

package/dist/src/lib/capitalizeFirstLetter.d.ts

@@ -0,0 +1 @@
+export declare function capitalizeFirstLetter(str: string): string;

package/dist/src/lib/capitalizeFirstLetter.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capitalizeFirstLetter = capitalizeFirstLetter;
+function capitalizeFirstLetter(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}

package/dist/src/lib/getDuplicates.d.ts

@@ -0,0 +1 @@
+export declare function getDuplicates<T extends any>(arr: Array<T>): any[];

package/dist/src/lib/getDuplicates.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDuplicates = getDuplicates;
+function getDuplicates(arr) {
+    return arr.reduce((agg, col) => {
+        agg.filter[col] = agg.filter[col] ? agg.dup.push(col) : 2;
+        return agg;
+    }, { filter: {}, dup: [] }).dup;
+}

package/dist/src/lib/isNotNullOrUndefined.d.ts

@@ -0,0 +1 @@
+export declare function isNotNullOrUndefined<T extends Object>(input: null | undefined | T): input is T;

package/dist/src/lib/isNotNullOrUndefined.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNotNullOrUndefined = isNotNullOrUndefined;
+// https://github.com/Microsoft/TypeScript/issues/16069
+function isNotNullOrUndefined(input) {
+    return input != null;
+}

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

@@ -0,0 +1,28 @@
+import Redis, { Cluster } from "ioredis";
+import { TResolveParams } from "./IRuntime";
+import Stats from "./Stats";
+export type RedisConfig = {
+    host: string;
+    port: number;
+    tls?: boolean;
+    db?: number;
+    socketTimeout?: number;
+    clusterMode?: boolean;
+};
+declare class Cache {
+    client: Redis | Cluster;
+    waiting?: Set<() => void> | undefined;
+    stats?: Stats;
+    constructor(redisConfig: RedisConfig, debug?: string[]);
+    debug(message: string): void;
+    pending(): Promise<void>;
+    from(input: TResolveParams): Promise<{
+        request: string;
+        cached: any;
+    }>;
+    insert(key: string, payload: any): Promise<void>;
+    read(key: string): Promise<any>;
+    purge(...uuids: string[]): Promise<void>;
+    shutdown(): Promise<void>;
+}
+export default Cache;

package/dist/src/runtime/Cache.js

@@ -0,0 +1,142 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = require("crypto");
+const ioredis_1 = __importDefault(require("ioredis"));
+const loglevel_1 = __importDefault(require("loglevel"));
+const utility_1 = require("./lib/utility");
+const Stats_1 = __importDefault(require("./Stats"));
+class Cache {
+    constructor(redisConfig, debug) {
+        this.waiting = new Set();
+        if (debug?.includes("Cache")) {
+            loglevel_1.default.setLevel("DEBUG");
+        }
+        const { host, port } = redisConfig;
+        const tls = redisConfig.tls ? true : false;
+        const clusterMode = redisConfig.clusterMode ? true : false;
+        const db = redisConfig.db == null ? 0 : redisConfig.db;
+        const socketTimeout = redisConfig.socketTimeout == null ? 50000 : redisConfig.socketTimeout;
+        let client = undefined;
+        if (clusterMode) {
+            client = new ioredis_1.default.Cluster([
+                {
+                    host,
+                    port
+                }
+            ], {
+                dnsLookup: (address, callback) => callback(null, address),
+                redisOptions: {
+                    tls: tls ? {} : undefined,
+                    lazyConnect: true,
+                    commandTimeout: socketTimeout
+                }
+            });
+        }
+        else {
+            client = new ioredis_1.default({
+                host,
+                port,
+                db,
+                lazyConnect: true,
+                tls: tls ? {} : undefined
+            });
+        }
+        this.client = client;
+        // call connect() if not already connected or in the process of connecting
+        if (client.status !== "connect" &&
+            client.status !== "connecting" &&
+            client.status !== "reconnecting") {
+            client.connect();
+        }
+        else {
+            loglevel_1.default.info("DB SDK client status is currently: " + client.status);
+        }
+        client.on("connect", () => {
+            loglevel_1.default.info(`DB SDK connected to redis server at ${host}:${port}`);
+            if (this.waiting)
+                this.waiting.forEach((x) => x());
+            this.waiting = undefined;
+        });
+        client.on("error", (err) => {
+            loglevel_1.default.error("ERROR: redis client");
+            loglevel_1.default.error(err);
+        });
+        if (debug?.includes("Stats"))
+            this.stats = new Stats_1.default(client);
+    }
+    debug(message) {
+        loglevel_1.default.debug(`\n-- CACHE: ${message}\n`);
+    }
+    async pending() {
+        if (this.waiting)
+            return new Promise((res) => this.waiting.add(res));
+    }
+    async from(input) {
+        let { action, args, fields, resource } = input;
+        const request = JSON.stringify({
+            action,
+            resource,
+            args,
+            fields
+        });
+        const key = (0, crypto_1.createHash)("sha256").update(request).digest("hex");
+        const cached = await this.read(key);
+        return {
+            request: key,
+            cached
+        };
+    }
+    async insert(key, payload) {
+        const redis = this.client;
+        const json = JSON.stringify(payload);
+        const regex = /"uuid":"(.+?)"/g;
+        const pending = [];
+        for (let result; (result = regex.exec(json));) {
+            const uuid = result[1];
+            if (!uuid)
+                continue;
+            pending.push(redis.sadd(`deps:${uuid}`, [key]), redis.sadd(`cached:${key}`, [uuid]));
+        }
+        if (!pending.length)
+            return;
+        this.debug(`insert: ${key.substring(0, 6)}`);
+        await Promise.all([redis.set(`cache:${key}`, json), ...pending]);
+    }
+    async read(key) {
+        await this.pending();
+        const data = await this.client.get(`cache:${key}`);
+        const shorthand = key.substring(0, 6);
+        if (data) {
+            this.debug(`hit: ${shorthand}`);
+            return JSON.parse(data);
+        }
+        else {
+            this.debug(`miss: ${shorthand}`);
+            return undefined;
+        }
+    }
+    async purge(...uuids) {
+        const redis = this.client;
+        await (0, utility_1.mapAsync)(uuids, (uuid) => {
+            const getDependancies = redis.smembers(`deps:${uuid}`);
+            return [
+                (0, utility_1.mapAsync)(getDependancies, (key) => {
+                    const getDependants = redis.smembers(`cached:${key}`);
+                    return [
+                        (0, utility_1.mapAsync)(getDependants, (uuid) => redis.srem(`deps:${uuid}`, [key])),
+                        redis.del(`cache:${key}`),
+                        redis.del(`cached:${key}`)
+                    ];
+                }),
+                redis.del(`deps:${uuid}`)
+            ];
+        });
+    }
+    async shutdown() {
+        await this.client.disconnect();
+    }
+}
+exports.default = Cache;

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

@@ -0,0 +1,209 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+export interface IRuntime {
+    resolve(input: TResolveParams): Promise<any>;
+    $queryRaw(sql: string, values?: any[]): Promise<any>;
+    $use: (middleware: TMiddleware) => void;
+    $whereNeedsProcessing(where: any): boolean;
+    $prepareWhere(artifacts: IArtifacts, table: string, data: any): Promise<any>;
+    $shutdown(): Promise<void>;
+    $startTransaction(input?: {
+        isolationLevel?: "READ UNCOMMITTED" | "READ COMMITTED" | "REPEATABLE READ" | "SERIALIZABLE";
+    }): Promise<TBeginTransactionResult>;
+}
+export type TAction = "findUnique" | "findMany" | "findManyPaginated" | "create" | "update" | "updateMany" | "delete" | "deleteMany";
+export type TResolveParams = {
+    resource: string;
+    action: TAction;
+    args?: IArgs;
+    data?: any;
+    artifacts: IArtifacts;
+    fields?: TSelect;
+    context?: TContext;
+    skipCache?: boolean;
+    dbCall?: TDbCall;
+    eventTarget: EventTarget;
+    onHandler?: TOnHandler;
+    asyncLocalStorage?: AsyncLocalStorage<{
+        isInOnHandler?: boolean;
+        isTransaction?: boolean;
+    }>;
+    passBeforeValueToAfterCallback: boolean;
+    sdk?: unknown;
+};
+export type TOnHandler = (sdk: unknown, input: unknown, output: unknown, before: unknown, TContext: TContext) => Promise<void>;
+export declare class EventOnHandlerError<T> extends Event {
+    error: T;
+    resource: string;
+    action: TAction;
+    constructor(message: string, data: ConstructorParameters<typeof Event>[1] & {
+        error: T;
+        resource: string;
+        action: TAction;
+    });
+}
+export type TContext = {
+    [k: string]: any;
+};
+export type TMiddleware = (params: TResolveParams, next: (params: TResolveParams) => Promise<any>) => Promise<any>;
+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>;
+type TBeginTransactionResult = {
+    dbCall: (q: string) => Promise<any>;
+    commit: () => Promise<void>;
+    rollback: () => Promise<void>;
+    queryRaw: (q: string, values: any[]) => Promise<any>;
+};
+export type ISupplementClientOpts = boolean;
+export type IOrderBy = {
+    column: string;
+    direction: any;
+}[];
+export type IArgs = {
+    [k: string]: any;
+};
+export type TSelect = {
+    [k: string]: boolean | {
+        $fields?: TSelect;
+    };
+};
+type IWhere = (table: string, args: IArgs) => string | undefined;
+type IASTChildColumn = {
+    type: "column";
+    name: string;
+    fieldName: string;
+    as: string;
+    fromOtherTable?: string;
+};
+type IASTChildComposite = {
+    type: "composite";
+    name: string[];
+    fieldName: string;
+    as: string;
+    fromOtherTable?: string;
+};
+type ISqlJoin = (t1: string, t2: string, args: IArgs) => string;
+type ISqlBatch = {
+    thisKey: IASTChildColumn;
+    parentKey: IASTChildColumn;
+};
+type IJunction = {
+    sqlTable: string;
+    as: string;
+    uniqueKey: string | string[];
+    where?: IWhere;
+    sqlBatch: {
+        thisKey: IASTChildColumn;
+        parentKey: IASTChildColumn;
+        sqlJoin: ISqlJoin;
+    };
+} | {
+    sqlTable: string;
+    as: string;
+    where?: IWhere;
+    sqlJoins: ISqlJoin[];
+};
+export type IGetSQLASTInput = {
+    table: string;
+    fieldName: string;
+    fields: TSelect;
+    args?: IArgs;
+    where?: IWhere;
+    sqlJoin?: ISqlJoin;
+    sqlBatch?: ISqlBatch;
+    junction?: IJunction;
+    grabMany: boolean;
+    getWhere: (table: string, args: any, dialect: IDialect, orderBy?: IOrderBy | undefined, rowWithMatchingCursor?: any) => string | null;
+    orderBy?: IOrderBy;
+    rowWithMatchingCursor?: any;
+    artifacts: IArtifacts;
+    dialect: IDialect;
+    firstChild?: IASTChildColumn | IASTChildComposite;
+    escapeId: (x: string) => string;
+};
+export type IRelation = {
+    table: string;
+    foreignKey: string;
+    referencedTable: string;
+    referencedKey: string;
+    nullable: boolean;
+};
+type IOneToManyOrManyToOne = "one-to-many__many-to-one";
+type IManyToMany = "many-to-many";
+type IRelationKind = "one-to-many" | "many-to-one";
+export type IRelationOneToManyOrManyToOne = {
+    type: IOneToManyOrManyToOne;
+    kind: IRelationKind;
+    grabMany: boolean;
+    table: string;
+    name: string;
+    relation: IRelation;
+    nullable: boolean;
+};
+export type IRelationManyToMany = {
+    type: IManyToMany;
+    grabMany: boolean;
+    table: string;
+    junctionTable: string;
+    name: string;
+    relations: IRelation[];
+};
+export type IRelationField = IRelationOneToManyOrManyToOne | IRelationManyToMany;
+export type IMappedField = {
+    name: string;
+    as: string;
+    type: string;
+    nullable: boolean;
+    table: string;
+    foreignKey: string;
+    referencedTable: string;
+    referencedKey: string;
+};
+export type IArtifacts = {
+    [k: string]: {
+        table: string;
+        primaryKey: string;
+        scalarFields: string[];
+        relationFields: {
+            [k: string]: IRelationField;
+        };
+        mappedFields: {
+            [k: string]: IMappedField;
+        } | null;
+        uniqueFields: {
+            name: string;
+            type: string;
+            nullable: boolean;
+        }[];
+        dateTimeFields: {
+            [k: string]: boolean;
+        };
+        dateTimeFieldsCount: number;
+        fields: TField[];
+        dump: {
+            schema: string;
+        } | null;
+    };
+};
+export type TFieldType = "string" | "boolean" | "number" | "integer";
+export type TField = {
+    kind: "scalar";
+    type: TFieldType;
+    name: string;
+    nullable: boolean;
+    hasDefaultValue: boolean;
+    mapped?: true;
+} | {
+    kind: "enum";
+    values: unknown[];
+    name: string;
+    nullable: boolean;
+} | {
+    kind: "object";
+    type: string;
+    name: string;
+    isList: boolean;
+    nullable: boolean;
+};
+export {};

package/dist/src/runtime/IRuntime.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventOnHandlerError = void 0;
+class EventOnHandlerError extends Event {
+    constructor(message, data) {
+        super(message, data);
+        this.error = data.error;
+        this.resource = data.resource;
+        this.action = data.action;
+    }
+}
+exports.EventOnHandlerError = EventOnHandlerError;

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

@@ -0,0 +1,26 @@
+import { RedisConfig } from "./Cache";
+import type { IRuntime, TMiddleware, TResolveParams, IArtifacts, ISupplementClientOpts } from "./IRuntime";
+import { MySQL } from "./lib/MySQL";
+export declare class RuntimeMySQL implements IRuntime {
+    #private;
+    constructor(clientOpts: ConstructorParameters<typeof MySQL>[0], otherOpts: {
+        supplementClientOpts?: ISupplementClientOpts;
+        redis?: RedisConfig;
+    }, artifacts: IArtifacts);
+    resolve(input: TResolveParams): Promise<any>;
+    $queryRaw(sql: string, values?: any[]): Promise<import("mysql2").OkPacket | import("mysql2").ResultSetHeader | import("mysql2").ResultSetHeader[] | import("mysql2").RowDataPacket[] | import("mysql2").RowDataPacket[][] | import("mysql2").OkPacket[] | [import("mysql2").RowDataPacket[], import("mysql2").ResultSetHeader]>;
+    $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<import("mysql2").OkPacket | import("mysql2").ResultSetHeader | import("mysql2").ResultSetHeader[] | import("mysql2").RowDataPacket[] | import("mysql2").RowDataPacket[][] | import("mysql2").OkPacket[] | [import("mysql2").RowDataPacket[], import("mysql2").ResultSetHeader]>;
+        queryRaw: (q: string, values: any[]) => Promise<import("mysql2").OkPacket | import("mysql2").ResultSetHeader | import("mysql2").ResultSetHeader[] | import("mysql2").RowDataPacket[] | import("mysql2").RowDataPacket[][] | import("mysql2").OkPacket[] | [import("mysql2").RowDataPacket[], import("mysql2").ResultSetHeader]>;
+    }>;
+    private dbCall;
+    private formatQuery;
+}

package/dist/src/runtime/RuntimeMySQL.js

@@ -0,0 +1,132 @@
+"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 _RuntimeMySQL_dialect, _RuntimeMySQL_mysqlClient, _RuntimeMySQL_clientCache, _RuntimeMySQL_middlewareHandler;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeMySQL = void 0;
+const SqlString = __importStar(require("sqlstring"));
+const Cache_1 = __importDefault(require("./Cache"));
+const MySQL_1 = require("./lib/MySQL");
+const shared_1 = require("./lib/shared");
+const loglevel_1 = __importDefault(require("loglevel"));
+loglevel_1.default.setDefaultLevel("INFO");
+class RuntimeMySQL {
+    constructor(clientOpts, otherOpts, artifacts) {
+        _RuntimeMySQL_dialect.set(this, "mysql");
+        _RuntimeMySQL_mysqlClient.set(this, void 0);
+        _RuntimeMySQL_clientCache.set(this, void 0);
+        _RuntimeMySQL_middlewareHandler.set(this, void 0);
+        __classPrivateFieldSet(this, _RuntimeMySQL_middlewareHandler, new shared_1.MiddlewareHandler(), "f");
+        if (otherOpts.redis)
+            __classPrivateFieldSet(this, _RuntimeMySQL_clientCache, new Cache_1.default(otherOpts.redis, clientOpts?.debug), "f");
+        if (otherOpts.supplementClientOpts) {
+            clientOpts = {
+                supportBigNumbers: true,
+                typeCast: (field, next) => {
+                    if (field.type == "TINY" && field.length == 1) {
+                        return field.string() == "1";
+                    }
+                    // if (field.type === "DATE") {
+                    //   return field.string();
+                    // }
+                    if (field.type === "TIMESTAMP" ||
+                        field.type === "DATE" ||
+                        field.type === "DATETIME") {
+                        const x = field.string();
+                        if (x == null) {
+                            return x;
+                        }
+                        return new Date(x).toISOString();
+                    }
+                    if (field.type === "VAR_STRING" || field.type === "STRING") {
+                        return field.string();
+                    }
+                    return next();
+                },
+                ...clientOpts
+            };
+        }
+        else {
+            clientOpts = {
+                typeCast: (field, next) => {
+                    if (field.type == "TINY" && field.length == 1) {
+                        return field.string() == "1";
+                    }
+                    if (field.type === "VAR_STRING" || field.type === "STRING") {
+                        return field.string();
+                    }
+                    return next();
+                },
+                ...clientOpts
+            };
+        }
+        __classPrivateFieldSet(this, _RuntimeMySQL_mysqlClient, new MySQL_1.MySQL(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, _RuntimeMySQL_dialect, "f"), __classPrivateFieldGet(this, _RuntimeMySQL_middlewareHandler, "f"), input.context ?? {}, __classPrivateFieldGet(this, _RuntimeMySQL_clientCache, "f"));
+    }
+    async $queryRaw(sql, values) {
+        return this.dbCall(this.formatQuery(sql, values ?? []));
+    }
+    async $use(middleware) {
+        __classPrivateFieldGet(this, _RuntimeMySQL_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, _RuntimeMySQL_clientCache, "f")) {
+            await __classPrivateFieldGet(this, _RuntimeMySQL_clientCache, "f").shutdown();
+        }
+        await __classPrivateFieldGet(this, _RuntimeMySQL_mysqlClient, "f").endPool();
+    }
+    async $startTransaction(input) {
+        return __classPrivateFieldGet(this, _RuntimeMySQL_mysqlClient, "f").beginTransaction(input?.isolationLevel);
+    }
+    dbCall(q) {
+        return __classPrivateFieldGet(this, _RuntimeMySQL_mysqlClient, "f").query(q);
+    }
+    formatQuery(q, values) {
+        return SqlString.format(q, values);
+    }
+}
+exports.RuntimeMySQL = RuntimeMySQL;
+_RuntimeMySQL_dialect = new WeakMap(), _RuntimeMySQL_mysqlClient = new WeakMap(), _RuntimeMySQL_clientCache = new WeakMap(), _RuntimeMySQL_middlewareHandler = new WeakMap();

package/dist/src/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;
+}