@technicity/data-service-generator 0.12.0-next.0 → 0.12.1

package/dist/getFakeData.d.ts

@@ -0,0 +1,12 @@
+import { type IArtifacts } from "./runtime/IRuntime";
+export declare function getFakeData(input: {
+    model: string;
+    select?: unknown[];
+    isList: boolean;
+    artifacts: IArtifacts;
+    operation: string | null;
+}): {
+    [k: string]: unknown;
+} | {
+    [k: string]: unknown;
+}[];

package/dist/getFakeData.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFakeData = void 0;
+function getFakeData(input) {
+    const { model, select, isList, artifacts, operation } = input;
+    const tableMeta = artifacts[model];
+    if (tableMeta === void 0) {
+        throw new Error(`Model ${model} not found.`);
+    }
+    const { fields } = tableMeta;
+    let data = {};
+    if (select == null) {
+        data = fields.reduce((acc, x) => {
+            if (x.kind === "scalar") {
+                acc[x.name] = getValue(x.type);
+                return acc;
+            }
+            else if (x.kind === "enum") {
+                acc[x.name] = x.values[0];
+                return acc;
+            }
+            return acc;
+        }, data);
+    }
+    else {
+        for (let x of select) {
+            if (!(typeof x === "string" || (typeof x === "object" && x != null))) {
+                throw new Error(`Invalid select: ${x}`);
+            }
+            const name = typeof x === "string" ? x : x.name;
+            const fieldName = x.as ?? name;
+            const field = fields.find((x) => x.name === name);
+            if (field == null) {
+                throw new Error(`Field not found: ${name}`);
+            }
+            if (field.kind === "scalar") {
+                data[fieldName] = getValue(field.type);
+            }
+            else if (field.kind === "enum") {
+                data[fieldName] = field.values[0];
+            }
+            else if (field.kind === "object") {
+                if (!(typeof x === "object" && x != null)) {
+                    throw new Error(`Invalid select: ${x}`);
+                }
+                data[fieldName] = getFakeData({
+                    model: field.type,
+                    select: x.fields,
+                    artifacts,
+                    isList: field.isList,
+                    // Only relevant at top-level
+                    operation: null
+                });
+            }
+            else {
+                throw new Error(`Unhandled kind: ${field?.kind}`);
+            }
+        }
+    }
+    let out = isList ? [data] : data;
+    if (typeof operation === "string" && operation.endsWith("Paginated")) {
+        out = {
+            paginationInfo: {
+                hasPreviousPage: false,
+                hasNextPage: false,
+                startCursor: "STUB",
+                endCursor: "STUB",
+                totalCount: 1
+            },
+            results: out
+        };
+    }
+    return out;
+}
+exports.getFakeData = getFakeData;
+function getValue(type) {
+    if (type === "boolean") {
+        return true;
+    }
+    if (type === "number") {
+        return 54.9434;
+    }
+    if (type === "integer") {
+        return 4;
+    }
+    if (type === "string") {
+        return "foo";
+    }
+    throw new Error(`Unhandled type: ${type}`);
+}

package/dist/getIsList.d.ts

@@ -0,0 +1 @@
+export declare function getIsList(operation: string): boolean;

package/dist/getIsList.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIsList = void 0;
+function getIsList(operation) {
+    return operation.endsWith("Paginated") || operation.endsWith("Many");
+}
+exports.getIsList = getIsList;

package/dist/index.d.ts

@@ -2,3 +2,5 @@ export { generate } from "./generation/generate";
 export { SDKNotFoundError } from "./runtime/lib/SDKNotFoundError";
 export { SDKBadWhereError } from "./runtime/lib/SDKBadWhereError";
 export { traverseFieldArgs } from "./traverseFieldArgs";
+export { getFakeData } from "./getFakeData";
+export { getIsList } from "./getIsList";

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.traverseFieldArgs = exports.SDKBadWhereError = exports.SDKNotFoundError = exports.generate = void 0;
+exports.getIsList = exports.getFakeData = 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");
@@ -9,3 +9,7 @@ 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; } });
+var getFakeData_1 = require("./getFakeData");
+Object.defineProperty(exports, "getFakeData", { enumerable: true, get: function () { return getFakeData_1.getFakeData; } });
+var getIsList_1 = require("./getIsList");
+Object.defineProperty(exports, "getIsList", { enumerable: true, get: function () { return getIsList_1.getIsList; } });

package/dist/runtime/Cache.d.ts

@@ -1,11 +1,20 @@
-import { RedisClientType } from 'redis';
-import { TResolveParams } from './IRuntime';
+import Redis, { Cluster } from "ioredis";
+import { TResolveParams } from "./IRuntime";
+import Stats from "./Stats";
+export declare type RedisConfig = {
+    host: string;
+    port: number;
+    tls?: boolean;
+    db?: number;
+    socketTimeout?: number;
+    clusterMode?: boolean;
+};
 declare class Cache {
-    protected logs?: boolean | undefined;
-    client: RedisClientType;
+    client: Redis | Cluster;
     waiting?: Set<() => void> | undefined;
-    constructor(url: string, logs?: boolean | undefined);
-    log(message: string): void;
+    stats?: Stats;
+    constructor(redisConfig: RedisConfig, debug?: string[]);
+    debug(message: string): void;
     pending(): Promise<void>;
     from(input: TResolveParams): Promise<{
         request: string;
@@ -14,5 +23,6 @@ declare class Cache {
     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/runtime/Cache.js

@@ -1,36 +1,85 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const crypto_1 = require("crypto");
-const redis_1 = require("redis");
+const ioredis_1 = require("ioredis");
+const loglevel_1 = require("loglevel");
 const utility_1 = require("./lib/utility");
+const Stats_1 = require("./Stats");
 class Cache {
-    constructor(url, logs) {
-        this.logs = logs;
+    constructor(redisConfig, debug) {
         this.waiting = new Set();
-        this.client = (0, redis_1.createClient)({ url: `redis://${url}` });
-        this.client.connect();
-        this.client.on("connect", () => {
+        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.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);
     }
-    log(message) {
-        if (this.logs)
-            console.log(message);
+    debug(message) {
+        loglevel_1.default.debug(`\n-- CACHE: ${message}\n`);
     }
     async pending() {
         if (this.waiting)
-            return new Promise(res => this.waiting.add(res));
+            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
+            action,
+            resource,
+            args,
+            fields
         });
-        const key = (0, crypto_1.createHash)('sha256')
-            .update(request)
-            .digest('hex');
+        const key = (0, crypto_1.createHash)("sha256").update(request).digest("hex");
         const cached = await this.read(key);
         return {
             request: key,
@@ -42,42 +91,39 @@ class Cache {
         const json = JSON.stringify(payload);
         const regex = /"uuid":"(.+?)"/g;
         const pending = [];
-        for (let result; result = regex.exec(json);) {
+        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]));
+            pending.push(redis.sadd(`deps:${uuid}`, [key]), redis.sadd(`cached:${key}`, [uuid]));
         }
         if (!pending.length)
             return;
-        this.log(`Cache insert: ${key.substring(0, 6)}`);
-        await Promise.all([
-            redis.set(`cache:${key}`, json),
-            ...pending
-        ]);
+        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.log(`Cache hit: ${shorthand}`);
+            this.debug(`hit: ${shorthand}`);
             return JSON.parse(data);
         }
         else {
-            this.log(`Cache miss: ${shorthand}`);
+            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}`);
+        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}`);
+                (0, utility_1.mapAsync)(getDependancies, (key) => {
+                    const getDependants = redis.smembers(`cached:${key}`);
                     return [
-                        (0, utility_1.mapAsync)(getDependants, uuid => (redis.sRem(`deps:${uuid}`, [key]))),
+                        (0, utility_1.mapAsync)(getDependants, (uuid) => redis.srem(`deps:${uuid}`, [key])),
                         redis.del(`cache:${key}`),
                         redis.del(`cached:${key}`)
                     ];
@@ -86,5 +132,8 @@ class Cache {
             ];
         });
     }
+    async shutdown() {
+        await this.client.disconnect();
+    }
 }
 exports.default = Cache;

package/dist/runtime/IRuntime.d.ts

@@ -5,16 +5,22 @@ export interface IRuntime {
     $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 declare type TAction = "findUnique" | "findMany" | "findManyPaginated" | "create" | "update" | "updateMany" | "delete" | "deleteMany";
 export declare type TResolveParams = {
     resource: string;
-    action: "findUnique" | "findMany" | "findManyPaginated" | "create" | "update" | "updateMany" | "delete" | "deleteMany";
+    action: TAction;
     args?: IArgs | undefined;
     data?: any;
     artifacts: IArtifacts;
     fields?: IField[] | undefined;
     context?: TContext | undefined;
     skipCache?: boolean;
+    dbCall?: TDbCall;
+    nullability?: unknown;
 };
 export declare type TContext = {
     [k: string]: any;
@@ -23,10 +29,12 @@ export declare type TMiddleware = (params: TResolveParams, next: (params: TResol
 export declare type IDialect = "mysql" | "mssql" | "ksql";
 export declare type TDbCall = (q: string) => Promise<any>;
 export declare type TFormatQuery = (q: string, values: any[]) => string;
-export declare type TBeginTransaction = () => Promise<{
+export declare type TBeginTransaction = () => Promise<TBeginTransactionResult>;
+declare type TBeginTransactionResult = {
     dbCall: (q: string) => Promise<any>;
     commit: () => Promise<void>;
-}>;
+    rollback: () => Promise<void>;
+};
 export declare type ISupplementClientOpts = boolean;
 export declare type IOrderBy = {
     column: string;
@@ -153,6 +161,25 @@ export declare type IArtifacts = {
             [k: string]: boolean;
         };
         dateTimeFieldsCount: number;
+        fields: TField[];
     };
 };
+export declare type TFieldType = "string" | "boolean" | "number" | "integer";
+export declare type TField = {
+    kind: "scalar";
+    type: TFieldType;
+    name: string;
+    nullable: boolean;
+    hasDefaultValue: boolean;
+} | {
+    kind: "enum";
+    values: unknown[];
+    name: string;
+    nullable: boolean;
+} | {
+    kind: "object";
+    type: string;
+    name: string;
+    isList: boolean;
+};
 export {};

package/dist/runtime/RuntimeKSQL.d.ts

@@ -15,5 +15,12 @@ export declare class RuntimeKSQL implements IRuntime {
     $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<{
+        dbCall: (q: string) => Promise<string>;
+        commit: () => Promise<void>;
+        rollback: () => Promise<void>;
+    }>;
 }
 export {};

package/dist/runtime/RuntimeKSQL.js

@@ -60,6 +60,14 @@ class RuntimeKSQL {
     async $shutdown() {
         // Nothing to do here, I think
     }
+    async $startTransaction(input) {
+        throw new Error("Not implemented.");
+        return {
+            dbCall: async (q) => "",
+            commit: async () => { },
+            rollback: async () => { }
+        };
+    }
 }
 exports.RuntimeKSQL = RuntimeKSQL;
 _RuntimeKSQL_ksql = new WeakMap(), _RuntimeKSQL_middlewareHandler = new WeakMap(), _RuntimeKSQL_dbCall = new WeakMap(), _RuntimeKSQL_formatQuery = new WeakMap(), _RuntimeKSQL_getBaseTableName = new WeakMap(), _RuntimeKSQL_getMaterializedViewName = new WeakMap(), _RuntimeKSQL_doNotUseMaterializedViews = new WeakMap();
@@ -151,8 +159,7 @@ async function _getData(input, grabMany, dbCall, formatQuery, getBaseTableName,
     let where = undefined;
     if (args?.$where != null) {
         let argsMapped = args;
-        if (typeof argsMapped.$where === "object" &&
-            argsMapped.$where[table] != null) {
+        if (typeof argsMapped.$where === "object" && argsMapped.$where[table] != null) {
             argsMapped = _.cloneDeep(argsMapped);
             argsMapped.$where = argsMapped.$where[table];
         }
@@ -160,7 +167,7 @@ async function _getData(input, grabMany, dbCall, formatQuery, getBaseTableName,
             where: argsMapped.$where,
             table: escapeId(getTableName(table)),
             dialect: "mysql",
-            args: argsMapped,
+            args: argsMapped
         });
         if (whereResult) {
             where = whereResult;
@@ -288,10 +295,10 @@ async function resolveDependentFields(table, parentData, mappedFields, relationF
             mappedField.name,
             getBaseTableName(mappedField.referencedTable),
             mappedField.referencedKey,
-            parentData?.[mappedField.foreignKey],
+            parentData?.[mappedField.foreignKey]
         ]);
         return dbCall(s).then((xs) => ({
-            [x]: xs?.[0]?.[mappedField.name] ?? null,
+            [x]: xs?.[0]?.[mappedField.name] ?? null
         }));
     }))
         .concat(relationFields.map((x) => {
@@ -316,8 +323,8 @@ async function resolveDependentFields(table, parentData, mappedFields, relationF
             whereJunction = {
                 $and: [
                     { [relationField.relations[0].foreignKey]: junctionKeyValue },
-                    whereJunction,
-                ],
+                    whereJunction
+                ]
             };
             const key = relationField.relations[1].foreignKey;
             const s = formatQuery(`SELECT ?? FROM ?? WHERE ${(0, stringifyWhere_1.stringifyWhere)({
@@ -325,20 +332,20 @@ async function resolveDependentFields(table, parentData, mappedFields, relationF
                 table: escapeId(getBaseTableName(relationField.junctionTable)),
                 dialect: "mysql",
                 // Since we're paginating, empty is fine
-                args: {},
+                args: {}
             })};`, [key, getBaseTableName(relationField.junctionTable)]);
             return dbCall(s)
                 .then((xs) => xs.map((x) => x?.[key]))
                 .then((keys) => {
                 const whereDest = {
-                    [relationField.relations[1].referencedKey]: { $in: keys },
+                    [relationField.relations[1].referencedKey]: { $in: keys }
                 };
                 const argsMapped = x.args == null ? {} : _.cloneDeep(x.args);
                 if (typeof argsMapped?.$where === "object" &&
                     argsMapped.$where != null &&
                     argsMapped.$where[relationField.table] != null) {
                     argsMapped.$where = {
-                        $and: [whereDest, argsMapped.$where[relationField.table]],
+                        $and: [whereDest, argsMapped.$where[relationField.table]]
                     };
                 }
                 else if (argsMapped.$where != null) {
@@ -352,7 +359,7 @@ async function resolveDependentFields(table, parentData, mappedFields, relationF
                     args: argsMapped,
                     fields: x.fields,
                     artifacts,
-                    action: relationField.grabMany ? "findMany" : "findUnique",
+                    action: relationField.grabMany ? "findMany" : "findUnique"
                 }, relationField.grabMany, dbCall, formatQuery, getBaseTableName, getMaterializedViewName, doNotUseMaterializedViews).then((xx) => ({ [x.as ?? x.name]: xx }));
             });
         }
@@ -375,7 +382,7 @@ async function resolveDependentFields(table, parentData, mappedFields, relationF
                 args: argsMapped,
                 fields: x.fields,
                 artifacts,
-                action: relationField.grabMany ? "findMany" : "findUnique",
+                action: relationField.grabMany ? "findMany" : "findUnique"
             }, relationField.grabMany, dbCall, formatQuery, getBaseTableName, getMaterializedViewName, doNotUseMaterializedViews).then((xx) => ({ [x.as ?? x.name]: xx }));
         }
         throw new Error(`Invalid relationField.type`);
@@ -396,7 +403,7 @@ function paginate(data, args, primaryKey, action) {
             data = data.slice(offset, offset + limit);
             return {
                 results: data,
-                paginationInfo: { totalCount },
+                paginationInfo: { totalCount }
             };
         }
         if (typeof args?.$paginate?.first === "number" ||
@@ -427,8 +434,8 @@ function paginate(data, args, primaryKey, action) {
                     ...connection.pageInfo,
                     startCursor,
                     endCursor,
-                    totalCount,
-                },
+                    totalCount
+                }
             };
         }
     }

package/dist/runtime/RuntimeMSSQL.d.ts

@@ -13,7 +13,13 @@ export declare class RuntimeMSSQL implements IRuntime {
     $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>;
+    }>;
     private dbCall;
     private formatQuery;
-    private beginTransaction;
 }

package/dist/runtime/RuntimeMSSQL.js

@@ -27,7 +27,7 @@ class RuntimeMSSQL {
         __classPrivateFieldSet(this, _RuntimeMSSQL_middlewareHandler, new shared_1.MiddlewareHandler(), "f");
     }
     async resolve(input) {
-        return (0, shared_1.resolve)(input, this.dbCall.bind(this), this.formatQuery.bind(this), this.beginTransaction.bind(this), __classPrivateFieldGet(this, _RuntimeMSSQL_dialect, "f"), __classPrivateFieldGet(this, _RuntimeMSSQL_middlewareHandler, "f"), input.context ?? {});
+        return (0, shared_1.resolve)(input, input.dbCall ?? this.dbCall.bind(this), this.formatQuery.bind(this), this.$startTransaction.bind(this), __classPrivateFieldGet(this, _RuntimeMSSQL_dialect, "f"), __classPrivateFieldGet(this, _RuntimeMSSQL_middlewareHandler, "f"), input.context ?? {});
     }
     async $queryRaw(sql, values) {
         return this.dbCall(this.formatQuery(sql, values ?? []));
@@ -44,15 +44,15 @@ class RuntimeMSSQL {
     async $shutdown() {
         await __classPrivateFieldGet(this, _RuntimeMSSQL_mssqlClient, "f").closePool();
     }
+    async $startTransaction(input) {
+        return __classPrivateFieldGet(this, _RuntimeMSSQL_mssqlClient, "f").beginTransaction(input?.isolationLevel);
+    }
     async dbCall(q) {
         return __classPrivateFieldGet(this, _RuntimeMSSQL_mssqlClient, "f").dbCall(q);
     }
     formatQuery(q, values) {
         return __classPrivateFieldGet(this, _RuntimeMSSQL_mssqlClient, "f").formatQuery(q, values);
     }
-    beginTransaction() {
-        return __classPrivateFieldGet(this, _RuntimeMSSQL_mssqlClient, "f").beginTransaction();
-    }
 }
 exports.RuntimeMSSQL = RuntimeMSSQL;
 _RuntimeMSSQL_dialect = new WeakMap(), _RuntimeMSSQL_mssqlClient = new WeakMap(), _RuntimeMSSQL_middlewareHandler = new WeakMap();

package/dist/runtime/RuntimeMySQL.d.ts

@@ -1,3 +1,4 @@
+import { RedisConfig } from "./Cache";
 import type { IRuntime, TMiddleware, TResolveParams, IArtifacts, ISupplementClientOpts } from "./IRuntime";
 export declare class RuntimeMySQL implements IRuntime {
     #private;
@@ -5,7 +6,7 @@ export declare class RuntimeMySQL implements IRuntime {
         [k: string]: any;
     }, otherOpts: {
         supplementClientOpts?: ISupplementClientOpts;
-        redisHost?: string;
+        redis?: RedisConfig;
     }, artifacts: IArtifacts);
     resolve(input: TResolveParams): Promise<any>;
     $queryRaw(sql: string, values?: any[]): Promise<any>;
@@ -13,7 +14,9 @@ export declare class RuntimeMySQL implements IRuntime {
     $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<any>;
     private dbCall;
     private formatQuery;
-    private beginTransaction;
 }