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

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

@@ -0,0 +1,18 @@
+import type { IOrderBy, IDialect } from "../IRuntime";
+type IWhere = {
+    [k: string]: any;
+};
+type IArgs = {
+    [k: string]: any;
+};
+export declare function stringifyWhere(input: {
+    where: IWhere;
+    table: string;
+    dialect: IDialect;
+    args: IArgs;
+    orderBy?: IOrderBy | undefined;
+    rowWithMatchingCursor?: any;
+}): string;
+export declare function getEscapeId(dialect: IDialect): any;
+export declare function getEscape(dialect: IDialect): any;
+export {};

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

@@ -0,0 +1,257 @@
+"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.stringifyWhere = stringifyWhere;
+exports.getEscapeId = getEscapeId;
+exports.getEscape = getEscape;
+const _ = __importStar(require("lodash/fp"));
+const MySqlString = __importStar(require("sqlstring"));
+// @ts-expect-error
+const SqliteString = __importStar(require("sqlstring-sqlite"));
+const pgFormat = __importStar(require("pg-format"));
+function stringifyWhere(input) {
+    const { where, table, dialect, args, orderBy, rowWithMatchingCursor } = input;
+    const escapeId = getEscapeId(dialect);
+    const escape = getEscape(dialect);
+    let result = _stringifyWhere(where, table, escapeId, escape, "");
+    const paginationWhere = stringifyPaginationWhere({
+        table,
+        args,
+        orderBy,
+        escapeId,
+        escape,
+        rowWithMatchingCursor
+    });
+    if (paginationWhere) {
+        result =
+            result.length === 0 ? paginationWhere : result + " AND " + paginationWhere;
+    }
+    return result;
+}
+function _stringifyWhere(where, table, escapeId, escape, result) {
+    if (Object.prototype.hasOwnProperty.call(where, "$and")) {
+        if (Object.keys(where).length !== 1) {
+            throw new Error("Must have 1 key: " + JSON.stringify(where, null, 2));
+        }
+        const _xs = where.$and.filter((x) => x != null);
+        if (_xs.length === 0) {
+            return result;
+        }
+        const xs = _xs
+            .map((x) => _stringifyWhere(x, table, escapeId, escape, result))
+            .filter(Boolean);
+        if (xs.length === 0) {
+            return result;
+        }
+        return `(${xs.join(" AND ")})`;
+    }
+    if (Object.prototype.hasOwnProperty.call(where, "$or")) {
+        if (Object.keys(where).length !== 1) {
+            throw new Error("Must have 1 key: " + JSON.stringify(where, null, 2));
+        }
+        const _xs = where.$or.filter((x) => x != null);
+        if (_xs.length === 0) {
+            return result;
+        }
+        const xs = _xs
+            .map((x) => _stringifyWhere(x, table, escapeId, escape, result))
+            .filter(Boolean);
+        if (xs.length === 0) {
+            return result;
+        }
+        return `(${xs.join(" OR ")})`;
+    }
+    function printValue(v) {
+        if (v === true) {
+            v = 1;
+        }
+        if (v === false) {
+            v = 0;
+        }
+        return escape(v);
+    }
+    return Object.keys(where)
+        .map((k) => {
+        let v = where[k];
+        if (v === void 0) {
+            return null;
+        }
+        // Can't do this, since we need this function to be sync
+        // if (relationMap[k] !== null) {
+        //   const relationData = await getRelationData(k, v, relationMap);
+        //   k = relationData.k;
+        //   v = relationData.v;
+        // }
+        if (v === null) {
+            return `${table}.${escapeId(k)} IS NULL`;
+        }
+        if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+            return `${table}.${escapeId(k)} = ${printValue(v)}`;
+        }
+        if (_.isPlainObject(v)) {
+            const keys = Object.keys(v);
+            if (keys.length !== 1) {
+                throw new Error("Must have 1 key: " + JSON.stringify(v, null, 2));
+            }
+            const operator = keys[0];
+            const operand = v[operator];
+            if (operator === "$neq") {
+                return `${table}.${escapeId(k)} ${getOperatorNeq(operand)} ${printValue(operand)}`;
+            }
+            if (operator === "$gt") {
+                return `${table}.${escapeId(k)} > ${printValue(operand)}`;
+            }
+            if (operator === "$gte") {
+                return `${table}.${escapeId(k)} >= ${printValue(operand)}`;
+            }
+            if (operator === "$lt") {
+                return `${table}.${escapeId(k)} < ${printValue(operand)}`;
+            }
+            if (operator === "$lte") {
+                return `${table}.${escapeId(k)} <= ${printValue(operand)}`;
+            }
+            if (operator === "$like") {
+                return `${table}.${escapeId(k)} LIKE ${printValue(operand)}`;
+            }
+            if (operator === "$nlike") {
+                return `${table}.${escapeId(k)} NOT LIKE ${printValue(operand)}`;
+            }
+            if (operator === "$in") {
+                if (operand.length === 0) {
+                    // Edit: no longer relevant, since the MSSQL dialect was
+                    // removed, but keep the same for stability.
+                    // Would do "FALSE" instead, as it's more readable, but it
+                    // causes a RequestError in MSSQL.
+                    return "(1=0)";
+                }
+                return `${table}.${escapeId(k)} IN (${operand
+                    .map((x) => printValue(x))
+                    .join(",")})`;
+            }
+            if (operator === "$nin") {
+                if (operand.length === 0) {
+                    // Edit: no longer relevant, since the MSSQL dialect was
+                    // removed, but keep the same for stability.
+                    // Would do "TRUE" instead, as it's more readable, but it
+                    // causes a RequestError in MSSQL.
+                    return "(1=1)";
+                }
+                return `${table}.${escapeId(k)} NOT IN (${operand
+                    .map((x) => printValue(x))
+                    .join(",")})`;
+            }
+            if (operator === "$btwn") {
+                if (operand.length !== 2) {
+                    throw new Error("Expected length of 2, got: " + operand.length);
+                }
+                return `${table}.${escapeId(k)} BETWEEN ${printValue(operand[0])} AND ${printValue(operand[1])}`;
+            }
+            if (operator === "$nbtwn") {
+                if (operand.length !== 2) {
+                    throw new Error("Expected length of 2, got: " + operand.length);
+                }
+                return `${table}.${escapeId(k)} NOT BETWEEN ${printValue(operand[0])} AND ${printValue(operand[1])}`;
+            }
+            throw new Error("Invalid operator: " + operator);
+        }
+        throw new Error("Invalid value: " + v);
+    })
+        .filter((x) => x != null)
+        .join(" AND ");
+}
+const valuesThatUseIsOrIsNot = new Set([null]);
+function getOperatorNeq(value) {
+    return valuesThatUseIsOrIsNot.has(value) ? "IS NOT" : "!=";
+}
+// async function getRelationData(k: string, v: any, relationMap: IRelationMap) {
+//   // TODO
+//   return { k, v };
+// }
+function stringifyPaginationWhere(input) {
+    const { table, args, orderBy, escapeId, escape, rowWithMatchingCursor } = input;
+    if (args?.$paginate?.after == null && args?.$paginate?.before == null) {
+        return "";
+    }
+    if (rowWithMatchingCursor == null) {
+        return "";
+    }
+    // orderBy should never be null because of getOrderBy, but add a check.
+    if (orderBy == null) {
+        throw new Error("orderBy cannot be null when paginating");
+    }
+    function getCompOp(dir) {
+        return dir === "asc" ? ">" : "<";
+    }
+    function printValue(v) {
+        if (v === true) {
+            v = 1;
+        }
+        if (v === false) {
+            v = 0;
+        }
+        return escape(v);
+    }
+    // https://gist.github.com/pcattori/2bb645d587e45c9fdbcabf5cef7a7106
+    const cond = orderBy
+        .map(({ column, direction }, i) => {
+        let a = orderBy.slice(0, i).map(({ column: col2 }) => {
+            const field = `${table}.${escapeId(col2)}`;
+            const op = "=";
+            const v = printValue(rowWithMatchingCursor[col2]);
+            return `${field} ${op} ${v}`;
+        });
+        const field = `${table}.${escapeId(column)}`;
+        const op = getCompOp(direction);
+        const v = printValue(rowWithMatchingCursor[column]);
+        a.push(`${field} ${op} ${v}`);
+        return "(" + a.join(" AND ") + ")";
+    })
+        .join(" OR ");
+    return "(" + cond + ")";
+}
+function getEscapeId(dialect) {
+    if (dialect === "mysql") {
+        return MySqlString.escapeId.bind(MySqlString);
+    }
+    if (dialect === "sqlite") {
+        return SqliteString.escapeId.bind(SqliteString);
+    }
+    if (dialect === "postgresql") {
+        return (id) => pgFormat.ident(id);
+    }
+    throw new Error("Unsupported dialect: " + dialect);
+}
+function getEscape(dialect) {
+    if (dialect === "mysql") {
+        return MySqlString.escape.bind(MySqlString);
+    }
+    if (dialect === "sqlite") {
+        return SqliteString.escape.bind(SqliteString);
+    }
+    if (dialect === "postgresql") {
+        return (value) => pgFormat.literal(value);
+    }
+    throw new Error("Unsupported dialect: " + dialect);
+}

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

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

package/dist/src/runtime/lib/stringifyWhere.test.js

@@ -0,0 +1,245 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const strict_1 = __importDefault(require("node:assert/strict"));
+const stringifyWhere_1 = require("./stringifyWhere");
+(0, globals_1.describe)("stringifyWhere", () => {
+    const table = "Usr";
+    const dialect = "mysql";
+    const args = {};
+    (0, globals_1.test)("should work", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { userId: 2, text: "foo" },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "Usr.`userId` = 2 AND Usr.`text` = 'foo'");
+    });
+    (0, globals_1.test)("should handle empty object", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({ where: {}, table, dialect, args });
+        strict_1.default.deepEqual(result, "");
+    });
+    (0, globals_1.test)("should handle $and", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { $and: [{ valid: true }, { text: "foo" }] },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "(Usr.`valid` = 1 AND Usr.`text` = 'foo')");
+    });
+    (0, globals_1.test)("should handle $or", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { $or: [{ valid: true }, { text: "foo" }] },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "(Usr.`valid` = 1 OR Usr.`text` = 'foo')");
+    });
+    (0, globals_1.test)("should handle null", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { userId: null },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "Usr.`userId` IS NULL");
+    });
+    (0, globals_1.test)("should handle $neq", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { userId: { $neq: 2 }, text: "foo" },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "Usr.`userId` != 2 AND Usr.`text` = 'foo'");
+    });
+    (0, globals_1.test)("should handle $neq null", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { userId: { $neq: null }, text: "foo" },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "Usr.`userId` IS NOT NULL AND Usr.`text` = 'foo'");
+    });
+    (0, globals_1.test)("should handle $gt", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { userId: { $gt: 2 }, text: "foo" },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "Usr.`userId` > 2 AND Usr.`text` = 'foo'");
+    });
+    (0, globals_1.test)("should handle $gte", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { userId: { $gte: 2 }, text: "foo" },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "Usr.`userId` >= 2 AND Usr.`text` = 'foo'");
+    });
+    (0, globals_1.test)("should handle $lt", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { userId: { $lt: 2 }, text: "foo" },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "Usr.`userId` < 2 AND Usr.`text` = 'foo'");
+    });
+    (0, globals_1.test)("should handle $lte", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { userId: { $lte: 2 }, text: "foo" },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "Usr.`userId` <= 2 AND Usr.`text` = 'foo'");
+    });
+    (0, globals_1.test)("should handle $like", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { text: { $like: "%foo%" } },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "Usr.`text` LIKE '%foo%'");
+    });
+    (0, globals_1.test)("should handle $nlike", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { text: { $nlike: "%foo%" } },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "Usr.`text` NOT LIKE '%foo%'");
+    });
+    (0, globals_1.test)("should handle $in", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { userId: { $in: [1, 2] }, text: "foo" },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "Usr.`userId` IN (1,2) AND Usr.`text` = 'foo'");
+    });
+    (0, globals_1.test)("should handle empty $in", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { userId: { $in: [] }, text: "foo" },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "(1=0) AND Usr.`text` = 'foo'");
+    });
+    (0, globals_1.test)("should handle $nin", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { userId: { $nin: [1, 2] }, text: "foo" },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "Usr.`userId` NOT IN (1,2) AND Usr.`text` = 'foo'");
+    });
+    (0, globals_1.test)("should handle empty $nin", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { userId: { $nin: [] }, text: "foo" },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "(1=1) AND Usr.`text` = 'foo'");
+    });
+    (0, globals_1.test)("should handle $btwn", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { userId: { $btwn: [1, 20] }, text: "foo" },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "Usr.`userId` BETWEEN 1 AND 20 AND Usr.`text` = 'foo'");
+    });
+    (0, globals_1.test)("should handle $nbtwn", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { userId: { $nbtwn: [1, 20] }, text: "foo" },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "Usr.`userId` NOT BETWEEN 1 AND 20 AND Usr.`text` = 'foo'");
+    });
+    (0, globals_1.test)("should handle nested $and and $or", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: {
+                $and: [
+                    { userId: { $gt: 2 } },
+                    { $or: [{ text: { $like: "foo" } }, { text: { $like: "bar" } }] },
+                    { $and: [{ lala: "lala" }, { oioi: "oioi" }] }
+                ]
+            },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "(Usr.`userId` > 2 AND (Usr.`text` LIKE 'foo' OR Usr.`text` LIKE 'bar') AND (Usr.`lala` = 'lala' AND Usr.`oioi` = 'oioi'))");
+    });
+    (0, globals_1.test)("should throw on invalid operator", () => {
+        strict_1.default.throws(() => (0, stringifyWhere_1.stringifyWhere)({
+            where: { foo: { $foo: 3 } },
+            table,
+            dialect,
+            args
+        }), (error) => {
+            (0, strict_1.default)(error instanceof Error);
+            (0, strict_1.default)(error.message.startsWith("Invalid operator:"));
+            return true;
+        });
+    });
+    (0, globals_1.test)("should throw on more than 1 key for $and", () => {
+        strict_1.default.throws(() => (0, stringifyWhere_1.stringifyWhere)({
+            where: { $and: [{ foo: "bar" }, { bar: "baz" }], foo: "bar" },
+            table,
+            dialect,
+            args
+        }), (error) => {
+            (0, strict_1.default)(error instanceof Error);
+            (0, strict_1.default)(error.message.startsWith("Must have 1 key:"));
+            return true;
+        });
+    });
+    (0, globals_1.test)("ignores undefined values", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { $or: [{ foo: "bar" }, { bar: null }, { baz: undefined }] },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "(Usr.`foo` = 'bar' OR Usr.`bar` IS NULL)");
+    });
+    (0, globals_1.test)("handles empty $and", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { $and: [] },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "");
+    });
+    (0, globals_1.test)("handles empty $or", () => {
+        const result = (0, stringifyWhere_1.stringifyWhere)({
+            where: { $or: [] },
+            table,
+            dialect,
+            args
+        });
+        strict_1.default.deepEqual(result, "");
+    });
+});

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

@@ -0,0 +1,5 @@
+/**
+ * Eagerly resolve and map input values then concatinate.
+ */
+export declare function mapAsync<T, R>(source: T[] | Promise<T[]>, mapFunction: (item: T) => R | R[] | Promise<R>[] | Promise<R | R[]>): Promise<R[]>;
+export declare function flatten<T>(array: (T | T[])[]): T[];

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapAsync = mapAsync;
+exports.flatten = flatten;
+/**
+ * Eagerly resolve and map input values then concatinate.
+ */
+async function mapAsync(source, mapFunction) {
+    const output = (await source).map(mapFunction);
+    return Promise.all(flatten(output)).then(flatten);
+}
+function flatten(array) {
+    return [].concat(...array);
+}

package/dist/src/traverseFieldArgs.d.ts

@@ -0,0 +1,2 @@
+import { IArgs, TSelect } from "./runtime/IRuntime";
+export declare function traverseFieldArgs(fields: TSelect, cb: (args: IArgs | undefined) => IArgs): void;

package/dist/src/traverseFieldArgs.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traverseFieldArgs = traverseFieldArgs;
+function traverseFieldArgs(fields, cb) {
+    const values = Object.values(fields);
+    for (let x of values) {
+        if (typeof x !== "object") {
+            continue;
+        }
+        const fields = x.$fields;
+        if (fields == null) {
+            continue;
+        }
+        cb(x);
+        traverseFieldArgs(fields, cb);
+    }
+}

package/dist/src/traverseFieldArgs.test.d.ts

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

package/dist/src/traverseFieldArgs.test.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const strict_1 = __importDefault(require("node:assert/strict"));
+const _1 = require(".");
+const addWhereValidTrue_1 = require("../test/addWhereValidTrue");
+(0, globals_1.describe)("traverseFieldArgs", () => {
+    (0, globals_1.test)("should work", () => {
+        const fields = {
+            id: true,
+            uuid: true,
+            business: { $fields: { id: true, uuid: true, name: true } },
+            sessionList: {
+                $fields: {
+                    id: true,
+                    archived: true,
+                    fooList: { $fields: { id: true, uuid: true } }
+                },
+                $where: { archived: false },
+                $orderBy: { id: "desc" }
+            },
+            usrList: {
+                $fields: { firstName: true, lastName: true, password: true },
+                $where: { valid: false, archived: false },
+                $orderBy: { id: "desc" }
+            }
+        };
+        (0, _1.traverseFieldArgs)(fields, addWhereValidTrue_1.addWhereValidTrue);
+        strict_1.default.deepEqual(fields, {
+            id: true,
+            uuid: true,
+            business: {
+                $fields: { id: true, uuid: true, name: true },
+                $where: { valid: true }
+            },
+            sessionList: {
+                $fields: {
+                    id: true,
+                    archived: true,
+                    fooList: { $fields: { id: true, uuid: true }, $where: { valid: true } }
+                },
+                $where: { valid: true, archived: false },
+                $orderBy: { id: "desc" }
+            },
+            usrList: {
+                $fields: { firstName: true, lastName: true, password: true },
+                // Should not be overwritten
+                $where: { valid: false, archived: false },
+                $orderBy: { id: "desc" }
+            }
+        });
+    });
+});

package/dist/test/addWhereValidTrue.d.ts

@@ -0,0 +1 @@
+export function addWhereValidTrue(args: any): any;

package/dist/test/addWhereValidTrue.js

@@ -0,0 +1,39 @@
+"use strict";
+function addWhereValidTrue(args) {
+    const key = "valid";
+    if (args == null) {
+        args = { $where: { [key]: true } };
+    }
+    else if (args.$where == null) {
+        args.$where = { [key]: true };
+    }
+    else {
+        // Only set if not explicitly set
+        if (!Object.prototype.hasOwnProperty.call(args.$where, key)) {
+            if (Array.isArray(args.$where)) {
+                for (let x of args.$where) {
+                    if (x.$and) {
+                        x.$and.push({ [key]: true });
+                    }
+                    else if (x.$or) {
+                        x.$or = x.$or.map((y) => ({ ...y, [key]: true }));
+                    }
+                    else {
+                        x.$where[key] = true;
+                    }
+                }
+            }
+            else if (args.$where.$and) {
+                args.$where.$and.push({ [key]: true });
+            }
+            else if (args.$where.$or) {
+                args.$where.$or = args.$where.$or.map((y) => ({ ...y, [key]: true }));
+            }
+            else {
+                args.$where[key] = true;
+            }
+        }
+    }
+    return args;
+}
+module.exports.addWhereValidTrue = addWhereValidTrue;

package/dist/test/globalSetup.d.ts

@@ -0,0 +1,13 @@
+import { StartedTestContainer } from "testcontainers";
+import { type SDK } from "./mysql80/__generated__/sdk-ts";
+export default function globalSetup(): Promise<void>;
+export type TTestItem = {
+    displayName: string;
+    dialect: string;
+    sdk: SDK;
+    SDK: typeof SDK;
+    sdkOpts: any;
+    sdkPath: string;
+    artifacts: any;
+    containers: StartedTestContainer[];
+};