@technicity/data-service-generator 0.8.4 → 0.10.0-next.0

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.traverseFieldArgs = exports.SDKNotFoundError = exports.generate = void 0;
+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 error_1 = require("./runtime/lib/error");
+Object.defineProperty(exports, "SDKNotFoundError", { enumerable: true, get: function () { return error_1.SDKNotFoundError; } });
+Object.defineProperty(exports, "SDKBadWhereError", { enumerable: true, get: function () { return error_1.SDKBadWhereError; } });
 var traverseFieldArgs_1 = require("./traverseFieldArgs");
 Object.defineProperty(exports, "traverseFieldArgs", { enumerable: true, get: function () { return traverseFieldArgs_1.traverseFieldArgs; } });

package/dist/runtime/Cache.d.ts

@@ -0,0 +1,18 @@
+import { RedisClientType } from 'redis';
+import { TResolveParams } from './IRuntime';
+declare class Cache {
+    protected logs?: boolean | undefined;
+    client: RedisClientType;
+    waiting?: Set<() => void> | undefined;
+    constructor(url: string, logs?: boolean | undefined);
+    log(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>;
+}
+export default Cache;

package/dist/runtime/Cache.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = require("crypto");
+const redis_1 = require("redis");
+const utility_1 = require("./lib/utility");
+class Cache {
+    constructor(url, logs) {
+        this.logs = logs;
+        this.waiting = new Set();
+        this.client = (0, redis_1.createClient)({ url: `redis://${url}` });
+        this.client.connect();
+        this.client.on("connect", () => {
+            if (this.waiting)
+                this.waiting.forEach(x => x());
+            this.waiting = undefined;
+        });
+    }
+    log(message) {
+        if (this.logs)
+            console.log(message);
+    }
+    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.log(`Cache 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}`);
+            return JSON.parse(data);
+        }
+        else {
+            this.log(`Cache 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}`)
+            ];
+        });
+    }
+}
+exports.default = Cache;

package/dist/runtime/Runtime.d.ts

@@ -0,0 +1,23 @@
+import Cache from './Cache';
+import { IArtifacts, IRuntime, TMiddleware, TResolveParams } from './IRuntime';
+import { MiddlewareHandler } from './lib/resolve';
+declare abstract class Runtime implements IRuntime {
+    protected abstract $dialect: "mysql" | "mssql";
+    protected $clientCache?: Cache;
+    protected $middlewareHandler: MiddlewareHandler<TMiddleware>;
+    constructor(otherOpts: {
+        redisHost?: string;
+    }, clientOpts?: {
+        [k: string]: any;
+    });
+    protected abstract formatQuery(q: string, values: any[]): string;
+    protected abstract beginTransaction(): Promise<any>;
+    protected abstract dbCall(q: string): Promise<any>;
+    abstract $shutdown(): Promise<void>;
+    $queryRaw(sql: string, values?: any[]): Promise<any>;
+    resolve(input: TResolveParams): Promise<any>;
+    $use(middleware: TMiddleware): Promise<void>;
+    $prepareWhere(artifacts: IArtifacts, table: string, data: any): Promise<{}>;
+    $whereNeedsProcessing(where: any): boolean;
+}
+export default Runtime;

package/dist/runtime/Runtime.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Cache_1 = require("./Cache");
+const prepareWhere_1 = require("./lib/prepareWhere");
+const resolve_1 = require("./lib/resolve");
+class Runtime {
+    constructor(otherOpts, clientOpts) {
+        this.$middlewareHandler = new resolve_1.MiddlewareHandler();
+        const debugCache = clientOpts?.debug?.includes("Cache");
+        if (otherOpts.redisHost)
+            this.$clientCache = new Cache_1.default(otherOpts.redisHost, debugCache);
+    }
+    async $queryRaw(sql, values) {
+        return this.dbCall(this.formatQuery(sql, values ?? []));
+    }
+    async resolve(input) {
+        return (0, resolve_1.resolve)(input, this.dbCall.bind(this), this.formatQuery.bind(this), this.beginTransaction.bind(this), this.$dialect, this.$middlewareHandler, input.context ?? {}, this.$clientCache);
+    }
+    async $use(middleware) {
+        this.$middlewareHandler.register(middleware);
+    }
+    async $prepareWhere(artifacts, table, data) {
+        return (0, prepareWhere_1.prepareWhere)(artifacts, table, data, this.dbCall.bind(this), this.formatQuery.bind(this));
+    }
+    $whereNeedsProcessing(where) {
+        return JSON.stringify(where).includes("Uuid");
+    }
+}
+exports.default = Runtime;

package/dist/runtime/RuntimeKSQL.d.ts

@@ -1,5 +1,5 @@
+import { KSQL } from '../ksql';
 import type { IRuntime, TMiddleware, TResolveParams, IArtifacts, TDbCall } from "./IRuntime";
-import { KSQL } from "../ksql";
 declare type TGetTableName = (table: string) => string;
 export declare class RuntimeKSQL implements IRuntime {
     #private;

package/dist/runtime/RuntimeKSQL.js

@@ -13,15 +13,17 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _RuntimeKSQL_ksql, _RuntimeKSQL_middlewareHandler, _RuntimeKSQL_dbCall, _RuntimeKSQL_formatQuery, _RuntimeKSQL_getBaseTableName, _RuntimeKSQL_getMaterializedViewName, _RuntimeKSQL_doNotUseMaterializedViews;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RuntimeKSQL = void 0;
-const SqlString = require("sqlstring");
 const async_hooks_1 = require("async_hooks");
-const _ = require("lodash");
 const graphql_relay_1 = require("graphql-relay");
-const shared_1 = require("./lib/shared");
+const _ = require("lodash");
+const SqlString = require("sqlstring");
 const ksql_1 = require("../ksql");
-const SDKNotFoundError_1 = require("./lib/SDKNotFoundError");
-const stringifyWhere_1 = require("./lib/stringifyWhere");
 const cursor_1 = require("./lib/cursor");
+const error_1 = require("./lib/error");
+const getWhere_1 = require("./lib/getWhere");
+const prepareWhere_1 = require("./lib/prepareWhere");
+const resolve_1 = require("./lib/resolve");
+const shared_1 = require("./lib/shared");
 const escapeId = SqlString.escapeId.bind(SqlString);
 class RuntimeKSQL {
     constructor(clientOpts, otherOpts, artifacts) {
@@ -33,7 +35,7 @@ class RuntimeKSQL {
         _RuntimeKSQL_getMaterializedViewName.set(this, void 0);
         _RuntimeKSQL_doNotUseMaterializedViews.set(this, void 0);
         __classPrivateFieldSet(this, _RuntimeKSQL_ksql, new ksql_1.KSQL(clientOpts ?? {}), "f");
-        __classPrivateFieldSet(this, _RuntimeKSQL_middlewareHandler, new shared_1.MiddlewareHandler(), "f");
+        __classPrivateFieldSet(this, _RuntimeKSQL_middlewareHandler, new resolve_1.MiddlewareHandler(), "f");
         __classPrivateFieldSet(this, _RuntimeKSQL_dbCall, typeof otherOpts._dbCall === "function"
             ? (q) => otherOpts._dbCall(q).then(mapResult)
             : (q) => __classPrivateFieldGet(this, _RuntimeKSQL_ksql, "f").streamQuery(q).then(mapResult), "f");
@@ -52,10 +54,10 @@ class RuntimeKSQL {
         __classPrivateFieldGet(this, _RuntimeKSQL_middlewareHandler, "f").register(middleware);
     }
     $whereNeedsProcessing(where) {
-        return (0, shared_1.whereNeedsProcessing)(where);
+        return JSON.stringify(where).includes("Uuid");
     }
     async $prepareWhere(artifacts, table, data) {
-        return (0, shared_1._prepareWhere)(artifacts, table, data, __classPrivateFieldGet(this, _RuntimeKSQL_dbCall, "f").bind(this), __classPrivateFieldGet(this, _RuntimeKSQL_formatQuery, "f").bind(this));
+        return (0, prepareWhere_1.prepareWhere)(artifacts, table, data, __classPrivateFieldGet(this, _RuntimeKSQL_dbCall, "f").bind(this), __classPrivateFieldGet(this, _RuntimeKSQL_formatQuery, "f").bind(this));
     }
     async $shutdown() {
         // Nothing to do here, I think
@@ -116,7 +118,7 @@ async function getData(input, dbCall, formatQuery, getBaseTableName, getMaterial
         action === "deleteMany";
     const data = await _getData(input, grabMany, dbCall, formatQuery, getBaseTableName, getMaterializedViewName, doNotUseMaterializedViews);
     if (data == null && !grabMany) {
-        throw new SDKNotFoundError_1.SDKNotFoundError();
+        throw new error_1.SDKNotFoundError();
     }
     const scalarFields = input.artifacts[input.resource].scalarFields;
     if (action === "findManyPaginated" && data?.results != null) {
@@ -156,7 +158,7 @@ async function _getData(input, grabMany, dbCall, formatQuery, getBaseTableName,
             argsMapped = _.cloneDeep(argsMapped);
             argsMapped.$where = argsMapped.$where[table];
         }
-        const whereResult = (0, stringifyWhere_1.stringifyWhere)({
+        const whereResult = (0, getWhere_1.stringifyWhere)({
             where: argsMapped.$where,
             table: escapeId(getTableName(table)),
             dialect: "mysql",
@@ -320,7 +322,7 @@ async function resolveDependentFields(table, parentData, mappedFields, relationF
                 ],
             };
             const key = relationField.relations[1].foreignKey;
-            const s = formatQuery(`SELECT ?? FROM ?? WHERE ${(0, stringifyWhere_1.stringifyWhere)({
+            const s = formatQuery(`SELECT ?? FROM ?? WHERE ${(0, getWhere_1.stringifyWhere)({
                 where: whereJunction,
                 table: escapeId(getBaseTableName(relationField.junctionTable)),
                 dialect: "mysql",

package/dist/runtime/RuntimeMSSQL.d.ts

@@ -1,19 +1,23 @@
-import * as mssql from "mssql";
-import type { IRuntime, TMiddleware, TResolveParams, IArtifacts, ISupplementClientOpts } from "./IRuntime";
-import { typeCastMSSQL } from "./lib/typeCastMSSQL";
-export declare class RuntimeMSSQL implements IRuntime {
-    #private;
+import * as mssql from 'mssql';
+import { IArtifacts, ISupplementClientOpts } from './IRuntime';
+import { typeCastMSSQL } from './lib/typeCastMSSQL';
+import Runtime from './Runtime';
+export declare class RuntimeMSSQL extends Runtime {
+    readonly $dialect = "mssql";
+    private $pool;
+    private $poolConnect;
+    private $typeCast?;
     constructor(clientOpts: mssql.config, otherOpts: {
         supplementClientOpts?: ISupplementClientOpts;
         typeCast?: Parameters<typeof typeCastMSSQL>[0];
-    }, 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<{}>;
+        redisHost?: string;
+    }, artifacts?: IArtifacts);
     $shutdown(): Promise<void>;
-    private dbCall;
-    private formatQuery;
-    private beginTransaction;
+    protected dbCall(q: string): Promise<any>;
+    protected formatQuery(q: string, values: any[]): any;
+    private mapResult;
+    protected beginTransaction(): Promise<{
+        commit: () => Promise<void>;
+        dbCall: (q: string) => Promise<any>;
+    }>;
 }

package/dist/runtime/RuntimeMSSQL.js

@@ -1,58 +1,63 @@
 "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 _RuntimeMSSQL_dialect, _RuntimeMSSQL_mssqlClient, _RuntimeMSSQL_middlewareHandler;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RuntimeMSSQL = void 0;
-const shared_1 = require("./lib/shared");
-const MSSQL_1 = require("./lib/MSSQL");
+const mssql = require("mssql");
+// @ts-ignore
+const TSqlString = require("tsqlstring");
 const typeCastMSSQL_1 = require("./lib/typeCastMSSQL");
-class RuntimeMSSQL {
+const Runtime_1 = require("./Runtime");
+class RuntimeMSSQL extends Runtime_1.default {
     constructor(clientOpts, otherOpts, artifacts) {
-        _RuntimeMSSQL_dialect.set(this, "mssql");
-        _RuntimeMSSQL_mssqlClient.set(this, void 0);
-        _RuntimeMSSQL_middlewareHandler.set(this, void 0);
-        __classPrivateFieldSet(this, _RuntimeMSSQL_mssqlClient, new MSSQL_1.MSSQL(clientOpts, otherOpts?.supplementClientOpts
+        super(otherOpts, clientOpts);
+        this.$dialect = "mssql";
+        this.$pool = new mssql.ConnectionPool(clientOpts);
+        this.$poolConnect = this.$pool.connect();
+        this.$typeCast = otherOpts?.supplementClientOpts
             ? (0, typeCastMSSQL_1.typeCastMSSQL)(otherOpts?.typeCast)
-            : undefined), "f");
-        __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 ?? {});
-    }
-    async $queryRaw(sql, values) {
-        return this.dbCall(this.formatQuery(sql, values ?? []));
-    }
-    async $use(middleware) {
-        __classPrivateFieldGet(this, _RuntimeMSSQL_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));
+            : undefined;
     }
     async $shutdown() {
-        await __classPrivateFieldGet(this, _RuntimeMSSQL_mssqlClient, "f").closePool();
+        await this.$pool.close();
     }
     async dbCall(q) {
-        return __classPrivateFieldGet(this, _RuntimeMSSQL_mssqlClient, "f").dbCall(q);
+        await this.$poolConnect;
+        const request = this.$pool.request();
+        const result = await request.query(q);
+        return this.mapResult(result);
     }
     formatQuery(q, values) {
-        return __classPrivateFieldGet(this, _RuntimeMSSQL_mssqlClient, "f").formatQuery(q, values);
-    }
-    beginTransaction() {
-        return __classPrivateFieldGet(this, _RuntimeMSSQL_mssqlClient, "f").beginTransaction();
+        return TSqlString.format(q, values);
+    }
+    mapResult(result) {
+        // TODO: see https://github.com/tediousjs/node-mssql/pull/1171
+        const meta = result.recordset?.columns;
+        if (meta != null && typeof this.$typeCast === "function") {
+            return this.$typeCast(result, meta);
+        }
+        return result.recordset;
+    }
+    async beginTransaction() {
+        const transaction = new mssql.Transaction(this.$pool);
+        const mapResult = this.mapResult.bind(this);
+        let rolledBack = false;
+        transaction.on("rollback", (aborted) => {
+            // emited with aborted === true
+            rolledBack = true;
+        });
+        async function handleError(err) {
+            if (!rolledBack) {
+                await transaction.rollback();
+            }
+            throw err;
+        }
+        await transaction.begin();
+        return {
+            commit: () => transaction.commit().catch(handleError),
+            dbCall: (q) => new mssql.Request(transaction)
+                .query(q)
+                .then(mapResult)
+                .catch(handleError),
+        };
     }
 }
 exports.RuntimeMSSQL = RuntimeMSSQL;
-_RuntimeMSSQL_dialect = new WeakMap(), _RuntimeMSSQL_mssqlClient = new WeakMap(), _RuntimeMSSQL_middlewareHandler = new WeakMap();

package/dist/runtime/RuntimeMySQL.d.ts

@@ -1,18 +1,17 @@
-import type { IRuntime, TMiddleware, TResolveParams, IArtifacts, ISupplementClientOpts } from "./IRuntime";
-export declare class RuntimeMySQL implements IRuntime {
-    #private;
+import { IArtifacts, ISupplementClientOpts } from './IRuntime';
+import Runtime from './Runtime';
+export declare class RuntimeMySQL extends Runtime {
+    readonly $dialect = "mysql";
+    protected $pool: any;
     constructor(clientOpts: {
         [k: string]: any;
     }, otherOpts: {
         supplementClientOpts?: ISupplementClientOpts;
-    }, 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<{}>;
+        redisHost?: string;
+    }, artifacts?: IArtifacts);
     $shutdown(): Promise<void>;
-    private dbCall;
-    private formatQuery;
-    private beginTransaction;
+    dbCall(q: string, args?: any[]): any;
+    protected formatQuery(q: string, values: any[]): string;
+    protected beginTransaction(): any;
+    protected getConnection(): Promise<any>;
 }

package/dist/runtime/RuntimeMySQL.js

@@ -1,95 +1,62 @@
 "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 _RuntimeMySQL_dialect, _RuntimeMySQL_mysqlClient, _RuntimeMySQL_middlewareHandler;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RuntimeMySQL = void 0;
 const SqlString = require("sqlstring");
-const MySQL_1 = require("./lib/MySQL");
-const shared_1 = require("./lib/shared");
-class RuntimeMySQL {
+const Runtime_1 = require("./Runtime");
+const mysql = require("mysql");
+const P = require("bluebird");
+P.promisifyAll(require("mysql/lib/Connection").prototype);
+P.promisifyAll(require("mysql/lib/Pool").prototype);
+class RuntimeMySQL extends Runtime_1.default {
     constructor(clientOpts, otherOpts, artifacts) {
-        _RuntimeMySQL_dialect.set(this, "mysql");
-        _RuntimeMySQL_mysqlClient.set(this, void 0);
-        _RuntimeMySQL_middlewareHandler.set(this, void 0);
-        __classPrivateFieldSet(this, _RuntimeMySQL_middlewareHandler, new shared_1.MiddlewareHandler(), "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"
-                    // ) {
-                    //   return new Date(field.string()).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, this.dbCall.bind(this), this.formatQuery.bind(this), this.beginTransaction.bind(this), __classPrivateFieldGet(this, _RuntimeMySQL_dialect, "f"), __classPrivateFieldGet(this, _RuntimeMySQL_middlewareHandler, "f"), input.context ?? {});
-    }
-    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));
+        super(otherOpts, clientOpts);
+        this.$dialect = "mysql";
+        if (otherOpts.supplementClientOpts)
+            clientOpts.supportBigNumbers = true;
+        clientOpts.typeCast = (field, next) => {
+            if (field.type == "TINY" && field.length == 1)
+                return field.string() == "1";
+            // if(otherOpts.supplementClientOpts){
+            //   if (field.type === "DATE")
+            //     return field.string();
+            //
+            //   if (["TIMESTAMP", "DATETIME"].includes(field.type))
+            //     return new Date(field.string()).toISOString();
+            // }
+            if (field.type === "VAR_STRING" || field.type === "STRING")
+                return field.string();
+            return next();
+        };
+        // this.$client = new MySQL(clientOpts);
+        this.$pool = mysql.createPool(clientOpts);
     }
     async $shutdown() {
-        await __classPrivateFieldGet(this, _RuntimeMySQL_mysqlClient, "f").endPool();
+        await this.$pool.endAsync();
     }
-    dbCall(q) {
-        return __classPrivateFieldGet(this, _RuntimeMySQL_mysqlClient, "f").query(q);
+    dbCall(q, args) {
+        return P.using(this.getConnection(), (connection) => connection.queryAsync(q, args));
     }
     formatQuery(q, values) {
         return SqlString.format(q, values);
     }
     beginTransaction() {
-        return __classPrivateFieldGet(this, _RuntimeMySQL_mysqlClient, "f").beginTransaction();
+        return P.using(this.getConnection(), async (connection) => {
+            async function handleError(err) {
+                await connection.rollbackAsync();
+                throw err;
+            }
+            await connection.beginTransactionAsync();
+            return {
+                commit: () => connection.commitAsync().catch(handleError),
+                dbCall: (q) => connection.queryAsync(q).catch(handleError),
+            };
+        });
+    }
+    // http://bluebirdjs.com/docs/api/disposer.html
+    async getConnection() {
+        return this.$pool
+            .getConnectionAsync()
+            .disposer((connection) => connection.release());
     }
 }
 exports.RuntimeMySQL = RuntimeMySQL;
-_RuntimeMySQL_dialect = new WeakMap(), _RuntimeMySQL_mysqlClient = new WeakMap(), _RuntimeMySQL_middlewareHandler = new WeakMap();

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

@@ -0,0 +1,12 @@
+import { IDialect, TBeginTransaction, TContext, TDbCall, TFormatQuery, TResolveParams } from '../IRuntime';
+export declare function create(input: TResolveParams, dbCall: TDbCall, formatQuery: TFormatQuery, beginTransaction: TBeginTransaction, dialect: IDialect, context: TContext): Promise<any>;
+declare type TRunCreateTreeSQL = (table: string, referencedKey: string | null, referencedKeyValue: number | string | null, columns: string[][], values: any[][], dbCall: TDbCall, formatQuery: TFormatQuery) => Promise<any[]>;
+export declare function runCreateTree(tree: TCreateTree, referencedKeyValue: number | string | null, runCreateTreeSQL: TRunCreateTreeSQL, dbCall: TDbCall, formatQuery: TFormatQuery, dialect: IDialect): Promise<any[]>;
+declare type TCreateTree = {
+    table: string;
+    referencedKey: string | null;
+    columns: string[][];
+    values: any[][];
+    children: TCreateTree[][];
+};
+export {};