@snowtop/ent 0.1.0-alpha1 → 0.1.0-alpha100

package/testutils/db/{test_db.js → temp_db.js}

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[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];
@@ -22,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSchemaTable = exports.setupSqlite = exports.assoc_edge_table = exports.assoc_edge_config_table = exports.TempDB = exports.enumType = exports.table = exports.boolList = exports.dateList = exports.timetzList = exports.timeList = exports.timestamptzList = exports.timestampList = exports.uuidList = exports.integerList = exports.textList = exports.jsonb = exports.json = exports.float = exports.integer = exports.bool = exports.date = exports.timetz = exports.time = exports.timestamptz = exports.timestamp = exports.enumCol = exports.text = exports.uuid = exports.uniqueIndex = exports.foreignKey = exports.primaryKey = void 0;
+exports.getColumnFromField = exports.getSchemaTable = exports.doSQLiteTestFromSchemas = exports.setupPostgres = exports.setupSqlite = exports.assoc_edge_table = exports.assoc_edge_config_table = exports.TempDB = exports.enumType = exports.table = exports.boolList = exports.dateList = exports.timetzList = exports.timeList = exports.timestamptzList = exports.timestampList = exports.uuidList = exports.integerList = exports.textList = exports.jsonb = exports.json = exports.float = exports.integer = exports.bool = exports.date = exports.timetz = exports.time = exports.timestamptz = exports.timestamp = exports.enumCol = exports.text = exports.uuid = exports.index = exports.check = exports.foreignKey = exports.primaryKey = void 0;
 const pg_1 = require("pg");
 const db_1 = __importStar(require("../../core/db"));
 // this should only be used in tests so we expect to be able to import without shenanigans
@@ -32,6 +36,7 @@ const fs = __importStar(require("fs"));
 const schema_1 = require("../../schema");
 const snake_case_1 = require("snake-case");
 const builder_1 = require("../builder");
+const test_edge_global_schema_1 = require("../test_edge_global_schema");
 function primaryKey(name, cols) {
     return {
         name: name,
@@ -50,15 +55,35 @@ function foreignKey(name, cols, fkey) {
     };
 }
 exports.foreignKey = foreignKey;
-function uniqueIndex(name) {
+function check(name, condition) {
     return {
-        name: "",
+        name,
         generate() {
-            return `UNIQUE (${name})`;
+            return `CONSTRAINT ${name} CHECK(${condition})`;
         },
     };
 }
-exports.uniqueIndex = uniqueIndex;
+exports.check = check;
+function isPostCreateIndex(s) {
+    return (s.postCreate !== undefined &&
+        s.postCreate());
+}
+function index(tableName, cols, opts) {
+    const name = `${tableName}_${cols.join("_")}_idx`;
+    return {
+        name,
+        generate() {
+            if (opts?.unique && db_1.Dialect.SQLite === db_1.default.getDialect()) {
+                return `UNIQUE (${cols.join(",")})`;
+            }
+            return `CREATE ${opts?.unique ? "UNIQUE " : ""}INDEX ${name} ON ${tableName} USING ${opts?.type || "btree"} (${cols.join(",")});`;
+        },
+        postCreate() {
+            return db_1.Dialect.Postgres === db_1.default.getDialect() && !!opts?.unique;
+        },
+    };
+}
+exports.index = index;
 function uuid(name, opts) {
     return {
         name,
@@ -248,9 +273,24 @@ exports.boolList = boolList;
 function table(name, ...items) {
     let cols = [];
     let constraints = [];
+    let indexes = [];
     for (const item of items) {
         if (item.datatype !== undefined) {
             const col = item;
+            if (col.index) {
+                let opts = {
+                    type: "btree",
+                };
+                if (col.index === true) {
+                    opts = {
+                        type: "btree",
+                    };
+                }
+                else {
+                    opts = col.index;
+                }
+                indexes.push(index(name, [col.name], opts));
+            }
             // add it as a constraint
             if (col.foreignKey) {
                 constraints.push(foreignKey(`${name}_${col.name}_fkey`, [col.name], {
@@ -261,7 +301,12 @@ function table(name, ...items) {
             cols.push(item);
         }
         else if (item.generate !== undefined) {
-            constraints.push(item);
+            if (isPostCreateIndex(item) && item.postCreate()) {
+                indexes.push(item);
+            }
+            else {
+                constraints.push(item);
+            }
         }
     }
     return {
@@ -278,7 +323,12 @@ function table(name, ...items) {
                     parts.push("PRIMARY KEY");
                 }
                 if (col.default !== undefined) {
-                    parts.push(`DEFAULT ${col.default}`);
+                    if (db_1.Dialect.SQLite === db_1.default.getDialect()) {
+                        parts.push(`DEFAULT "${col.default}"`);
+                    }
+                    else {
+                        parts.push(`DEFAULT ${col.default}`);
+                    }
                 }
                 if (col.unique) {
                     parts.push("UNIQUE");
@@ -288,6 +338,9 @@ function table(name, ...items) {
             constraints.forEach((constraint) => schemaStr.push(constraint.generate()));
             return `CREATE TABLE IF NOT EXISTS ${name} (\n ${schemaStr})`;
         },
+        postCreate() {
+            return indexes.map((index) => index.generate());
+        },
         drop() {
             return `DROP TABLE IF EXISTS ${name}`;
         },
@@ -311,32 +364,21 @@ function randomDB() {
     // always ensure it starts with an alpha character
     return "abcdefghijklmnopqrstuvwxyz"[Math.floor(Math.random() * 26)] + str;
 }
-function isDialect(dialect) {
-    return !Array.isArray(dialect);
-}
 class TempDB {
     constructor(dialect, tables) {
         this.tables = new Map();
-        let tbles = [];
-        if (isDialect(dialect)) {
-            this.dialect = dialect;
-            if (tables) {
-                tbles = tables;
-            }
-        }
-        else {
-            this.dialect = db_1.Dialect.Postgres;
-            tbles = dialect;
-        }
-        tbles.forEach((table) => this.tables.set(table.name, table));
+        this.dialect = dialect;
+        this.setTables = tables;
     }
     getDialect() {
         return this.dialect;
     }
-    getTables() {
+    // NB: this won't be set until after beforeAll() is called since it depends on
+    // dialect being correctly set
+    __getTables() {
         return this.tables;
     }
-    async beforeAll() {
+    async beforeAll(setupConnString = true) {
         if (this.dialect === db_1.Dialect.Postgres) {
             const user = process.env.POSTGRES_USER || "";
             const password = process.env.POSTGRES_PASSWORD || "";
@@ -348,11 +390,22 @@ class TempDB {
             await this.client.connect();
             this.db = randomDB();
             await this.client.query(`CREATE DATABASE ${this.db}`);
-            if (user && password) {
-                process.env.DB_CONNECTION_STRING = `postgres://${user}:${password}@localhost:5432/${this.db}`;
+            if (setupConnString) {
+                delete process.env.DB_CONNECTION_STRING;
+                let connStr = "";
+                if (user && password) {
+                    connStr = `postgres://${user}:${password}@localhost:5432/${this.db}`;
+                }
+                else {
+                    connStr = `postgres://localhost/${this.db}?`;
+                }
+                db_1.default.initDB({
+                    connectionString: connStr,
+                });
             }
             else {
-                process.env.DB_CONNECTION_STRING = `postgres://localhost/${this.db}?`;
+                // will probably be setup via loadConfig
+                delete process.env.DB_CONNECTION_STRING;
             }
             this.dbClient = new pg_1.Client({
                 host: "localhost",
@@ -369,12 +422,35 @@ class TempDB {
             const filePath = process.env.DB_CONNECTION_STRING.substr(10);
             this.sqlite = (0, better_sqlite3_1.default)(filePath);
         }
-        for (const [_, table] of this.tables) {
-            if (this.dialect == db_1.Dialect.Postgres) {
-                await this.dbClient.query(table.create());
+        if (this.setTables) {
+            let tables = [];
+            if (typeof this.setTables === "function") {
+                tables = this.setTables();
             }
             else {
-                this.sqlite.exec(table.create());
+                tables = this.setTables;
+            }
+            tables.forEach((table) => this.tables.set(table.name, table));
+        }
+        for (const [_, table] of this.tables) {
+            await this.createImpl(table);
+        }
+    }
+    async createImpl(table) {
+        if (this.dialect == db_1.Dialect.Postgres) {
+            await this.dbClient.query(table.create());
+            if (table.postCreate) {
+                for (const q of table.postCreate()) {
+                    await this.dbClient.query(q);
+                }
+            }
+        }
+        else {
+            this.sqlite.exec(table.create());
+            if (table.postCreate) {
+                for (const q of table.postCreate()) {
+                    this.sqlite.exec(q);
+                }
             }
         }
     }
@@ -397,6 +473,9 @@ class TempDB {
         await this.client.query(`DROP DATABASE ${this.db}`);
         await this.client.end();
     }
+    getDB() {
+        return this.db;
+    }
     async dropAll() {
         for (const [t, _] of this.tables) {
             await this.drop(t);
@@ -422,12 +501,7 @@ class TempDB {
             if (this.tables.has(table.name)) {
                 throw new Error(`table with name ${table.name} already exists`);
             }
-            if (this.dialect === db_1.Dialect.Postgres) {
-                await this.dbClient.query(table.create());
-            }
-            else {
-                this.sqlite.exec(table.create());
-            }
+            await this.createImpl(table);
             this.tables.set(table.name, table);
         }
     }
@@ -439,18 +513,26 @@ function assoc_edge_config_table() {
     text("edge_type", { primaryKey: true }), text("edge_name"), bool("symmetric_edge", { default: "FALSE" }), text("inverse_edge_type", { nullable: true }), text("edge_table"), timestamptz("created_at"), timestamptz("updated_at"));
 }
 exports.assoc_edge_config_table = assoc_edge_config_table;
-function assoc_edge_table(name) {
-    return table(name, uuid("id1"), text("id1_type"), 
+// if global flag is true, add any column from testEdgeGlobalSchema
+// up to caller to set/clear that as needed
+function assoc_edge_table(name, global) {
+    const t = table(name, uuid("id1"), text("id1_type"), 
     // same as in assoc_edge_config_table
     text("edge_type"), uuid("id2"), text("id2_type"), timestamptz("time"), text("data", { nullable: true }), primaryKey(`${name}_pkey`, ["id1", "id2", "edge_type"]));
+    if (global) {
+        for (const k in test_edge_global_schema_1.testEdgeGlobalSchema.extraEdgeFields) {
+            const col = getColumnFromField(k, test_edge_global_schema_1.testEdgeGlobalSchema.extraEdgeFields[k], db_1.Dialect.Postgres);
+            t.columns.push(col);
+        }
+    }
+    return t;
 }
 exports.assoc_edge_table = assoc_edge_table;
 function setupSqlite(connString, tables, opts) {
-    let tdb;
+    let tdb = new TempDB(db_1.Dialect.SQLite, tables);
     beforeAll(async () => {
         process.env.DB_CONNECTION_STRING = connString;
         (0, config_1.loadConfig)();
-        tdb = new TempDB(db_1.Dialect.SQLite, tables());
         await tdb.beforeAll();
         const conn = db_1.default.getInstance().getConnection();
         expect(conn.db.memory).toBe(false);
@@ -458,7 +540,7 @@ function setupSqlite(connString, tables, opts) {
     if (!opts?.disableDeleteAfterEachTest) {
         afterEach(async () => {
             const client = await db_1.default.getInstance().getNewClient();
-            for (const [key, _] of tdb.getTables()) {
+            for (const [key, _] of tdb.__getTables()) {
                 const query = `delete from ${key}`;
                 if (isSyncClient(client))
                     if (client.execSync) {
@@ -473,16 +555,77 @@ function setupSqlite(connString, tables, opts) {
     afterAll(async () => {
         await tdb.afterAll();
         fs.rmSync(tdb.getSqliteClient().name);
+        delete process.env.DB_CONNECTION_STRING;
     });
+    return tdb;
 }
 exports.setupSqlite = setupSqlite;
+function setupPostgres(tables, opts) {
+    let tdb;
+    beforeAll(async () => {
+        tdb = new TempDB(db_1.Dialect.Postgres, tables());
+        await tdb.beforeAll();
+    });
+    // TODO need to fix this implementation...
+    if (!opts?.disableDeleteAfterEachTest) {
+        afterEach(async () => {
+            const client = await db_1.default.getInstance().getNewClient();
+            for (const [key, _] of tdb.__getTables()) {
+                const query = `delete from ${key}`;
+                await client.exec(query);
+            }
+            client.release();
+        });
+    }
+    afterAll(async () => {
+        await tdb.afterAll();
+    });
+}
+exports.setupPostgres = setupPostgres;
+async function doSQLiteTestFromSchemas(schemas, doTest, db) {
+    const connString = `sqlite:///${db || randomDB()}.db`;
+    const tables = schemas.map((schema) => getSchemaTable(schema, db_1.Dialect.SQLite));
+    let tdb = new TempDB(db_1.Dialect.SQLite, tables);
+    process.env.DB_CONNECTION_STRING = connString;
+    (0, config_1.loadConfig)();
+    await tdb.beforeAll();
+    await doTest();
+    await tdb.afterAll();
+    delete process.env.DB_CONNECTION_STRING;
+    return tdb;
+}
+exports.doSQLiteTestFromSchemas = doSQLiteTestFromSchemas;
 function getSchemaTable(schema, dialect) {
     const fields = (0, schema_1.getFields)(schema);
-    const columns = [];
+    const items = [];
     for (const [fieldName, field] of fields) {
-        columns.push(getColumnFromField(fieldName, field, dialect));
+        items.push(getColumnFromField(fieldName, field, dialect));
+    }
+    if (schema.constraints) {
+        for (const constraint of schema.constraints) {
+            switch (constraint.type) {
+                case schema_1.ConstraintType.PrimaryKey:
+                    items.push(primaryKey(constraint.name, constraint.columns));
+                    break;
+                case schema_1.ConstraintType.ForeignKey:
+                    if (!constraint.fkey) {
+                        throw new Error(`need 'fkey' field for foreign key constraint`);
+                    }
+                    items.push(foreignKey(constraint.name, constraint.columns, {
+                        table: constraint.fkey.tableName,
+                        cols: constraint.fkey.columns,
+                    }));
+                    break;
+                case schema_1.ConstraintType.Check:
+                    if (!constraint.condition) {
+                        throw new Error(`need 'condition' field for check constraint`);
+                    }
+                    items.push(check(constraint.name, constraint.condition));
+                    break;
+            }
+        }
     }
-    return table((0, builder_1.getTableName)(schema), ...columns);
+    return table((0, builder_1.getTableName)(schema), ...items);
 }
 exports.getSchemaTable = getSchemaTable;
 function getColumnForDbType(t, dialect) {
@@ -540,6 +683,7 @@ function getColumnFromField(fieldName, f, dialect) {
             return getColumn(fieldName, f, fn);
     }
 }
+exports.getColumnFromField = getColumnFromField;
 function getColumn(fieldName, f, col) {
     return col(storageKey(fieldName, f), buildOpts(f));
 }

package/testutils/db/value.d.ts

@@ -0,0 +1,7 @@
+import { Field, Schema } from "../../schema";
+export declare function randomEmail(domain?: string): string;
+interface Info {
+    schema: Schema;
+}
+export declare function getDefaultValue(f: Field, col: string, infos?: Map<string, Info>): any;
+export {};

package/testutils/db/value.js

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultValue = exports.randomEmail = void 0;
+const uuid_1 = require("uuid");
+const schema_1 = require("../../schema");
+const schema_2 = require("../../schema");
+function random() {
+    return Math.random().toString(16).substring(2);
+}
+function randomEmail(domain) {
+    domain = domain || "email.com";
+    return `test+${random()}@${domain}`;
+}
+exports.randomEmail = randomEmail;
+function randomPhoneNumber() {
+    return `+1${Math.random().toString(10).substring(2, 11)}`;
+}
+function coinFlip() {
+    return Math.floor(Math.random() * 10) >= 5;
+}
+function specialType(typ, col) {
+    let list = m.get(typ.dbType);
+    if (list?.length) {
+        for (const l of list) {
+            let regex = [];
+            if (Array.isArray(l.regex)) {
+                regex = l.regex;
+            }
+            else {
+                regex = [l.regex];
+            }
+            for (const r of regex) {
+                if (r.test(col)) {
+                    return l.newValue();
+                }
+            }
+        }
+    }
+    return undefined;
+}
+function getDefaultValue(f, col, infos) {
+    if (f.defaultValueOnCreate) {
+        // @ts-ignore
+        return f.defaultValueOnCreate();
+    }
+    // half the time, return null for nullable
+    if (f.nullable && coinFlip()) {
+        return null;
+    }
+    const specialVal = specialType(f.type, col);
+    if (specialVal !== undefined) {
+        return specialVal;
+    }
+    return getValueForType(f.type, f, infos);
+}
+exports.getDefaultValue = getDefaultValue;
+function getValueForType(typ, f, infos) {
+    switch (typ.dbType) {
+        case schema_1.DBType.UUID:
+            return (0, uuid_1.v4)();
+        case schema_1.DBType.Boolean:
+            return coinFlip();
+        case schema_1.DBType.Date:
+            return (0, schema_2.DateType)().format(new Date());
+        case schema_1.DBType.Time:
+            return (0, schema_2.TimeType)().format(new Date());
+        case schema_1.DBType.Timetz:
+            return (0, schema_2.TimetzType)().format(new Date());
+        case schema_1.DBType.Timestamp:
+            return (0, schema_2.TimestampType)().format(new Date());
+        case schema_1.DBType.Timestamptz:
+            return (0, schema_2.TimestamptzType)().format(new Date());
+        case schema_1.DBType.String:
+            return random();
+        case schema_1.DBType.Int:
+            return Math.floor(Math.random() * 100000000);
+        case schema_1.DBType.Float:
+            return Math.random() * 100000000;
+        case schema_1.DBType.Enum:
+        case schema_1.DBType.StringEnum:
+            if (typ.values) {
+                const idx = Math.floor(Math.random() * typ.values.length);
+                return typ.values[idx];
+            }
+            if (typ.enumMap) {
+                const vals = Object.values(typ.enumMap);
+                const idx = Math.floor(Math.random() * vals.length);
+                return vals[idx];
+            }
+            if (f.foreignKey) {
+                const schema = f.foreignKey.schema;
+                const col = f.foreignKey.column;
+                if (!infos) {
+                    throw new Error(`infos required for enum with foreignKey`);
+                }
+                const info = infos.get(schema);
+                if (!info) {
+                    throw new Error(`couldn't load data for schema ${schema}`);
+                }
+                if (!info.schema.dbRows) {
+                    throw new Error(`no dbRows for schema ${schema}`);
+                }
+                const idx = Math.floor(Math.random() * info.schema.dbRows.length);
+                return info.schema.dbRows[idx][col];
+            }
+            throw new Error("TODO: enum without values not currently supported");
+        case schema_1.DBType.IntEnum:
+            const vals = Object.values(typ.intEnumMap);
+            const idx = Math.floor(Math.random() * vals.length);
+            return vals[idx];
+        case schema_1.DBType.BigInt:
+            return BigInt(Math.floor(Math.random() * 100000000));
+        case schema_1.DBType.JSONB:
+            // type as list
+            if (typ.listElemType?.dbType === schema_1.DBType.JSONB) {
+                const values = [];
+                for (let i = 0; i < 10; i++) {
+                    values.push(getValueForType(typ.listElemType, f, infos));
+                }
+                if (!f.format) {
+                    throw new Error("invalid format");
+                }
+                return f.format(values);
+            }
+            return (0, schema_2.JSONBType)().format({});
+        case schema_1.DBType.JSON:
+            return (0, schema_2.JSONType)().format({});
+        case schema_1.DBType.List:
+            // just do 10
+            const values = [];
+            for (let i = 0; i < 10; i++) {
+                values.push(getValueForType(f.type.listElemType, f.__getElemField(), infos));
+            }
+            if (!f.format) {
+                throw new Error("invalid format");
+            }
+            return f.format(values);
+        default:
+            throw new Error(`unsupported type ${typ.dbType}`);
+    }
+}
+const emailType = {
+    dbType: schema_1.DBType.String,
+    newValue: () => {
+        return (0, schema_2.StringType)().format(randomEmail().toLowerCase());
+    },
+    regex: /^email(_address)|_email$/,
+};
+const phoneType = {
+    dbType: schema_1.DBType.String,
+    newValue: () => {
+        return randomPhoneNumber();
+    },
+    regex: /^phone(_number)?|_phone$|_phone_number$/,
+};
+const passwordType = {
+    dbType: schema_1.DBType.String,
+    newValue: () => {
+        // we don't use password type because when we're generating so many rows, it's too slow...
+        return random();
+    },
+    regex: /^password/,
+};
+const firstNames = [
+    "Daenerys",
+    "Jon",
+    "Arya",
+    "Sansa",
+    "Eddard",
+    "Khal",
+    "Robb",
+    "Joffrey",
+    "Ramsay",
+    "Cersei",
+    "Bolton",
+    "Oberyn",
+    "Jojen",
+    "Petyr",
+    "Brienne",
+    "Ygritte",
+    "Missandei",
+    "Shae",
+    "Sandor",
+    "Theon",
+    "Catelyn",
+    "Gilly",
+    "Samwell",
+    "Jaime",
+    "Stannis",
+    "Tyene",
+    "Obara",
+    "Nymeria",
+    "Elia",
+    "Ellaria",
+    "Myrcella",
+    "Hodor",
+    "Osha",
+    "Meera",
+    "Davos",
+    "Gendry",
+];
+const lastNames = [
+    "Stark",
+    "Targaryen",
+    "Lannister",
+    "Drogo",
+    "Baratheon",
+    "Reed",
+    "Martell",
+    "Tyrell",
+    "Clegane",
+    "Baelish",
+    "Greyjoy",
+    "Tarly",
+    "Sand",
+    "Snow",
+    "Bolton",
+    "Frey",
+    "Tarth",
+    "Payne",
+    "Seaworth",
+];
+const firstNameType = {
+    dbType: schema_1.DBType.String,
+    newValue: () => {
+        let idx = Math.floor(firstNames.length * Math.random());
+        return firstNames[idx];
+    },
+    regex: /^first_?(name)?/,
+};
+const lastNameType = {
+    dbType: schema_1.DBType.String,
+    newValue: () => {
+        let idx = Math.floor(lastNames.length * Math.random());
+        return lastNames[idx];
+    },
+    regex: /^last_?(name)?/,
+};
+let types = [
+    phoneType,
+    emailType,
+    passwordType,
+    firstNameType,
+    lastNameType,
+];
+let m = new Map();
+for (const type of types) {
+    let list = m.get(type.dbType) || [];
+    list.push(type);
+    m.set(type.dbType, list);
+}

package/testutils/db_mock.d.ts

@@ -18,7 +18,8 @@ export declare enum queryType {
     UPDATE = 2,
     BEGIN = 3,
     COMMIT = 4,
-    ROLLBACK = 5
+    ROLLBACK = 5,
+    DELETE = 6
 }
 export interface queryStructure {
     tableName?: string;
@@ -32,11 +33,14 @@ interface internalQueryStructure extends queryStructure {
     suffix?: string;
     setClause?: string;
 }
+/**
+ * @deprecated
+ */
 export declare class QueryRecorder {
     private static queries;
     private static ids;
     private static data;
-    private static getQueryStructure;
+    static getQueryStructure(query: any): internalQueryStructure | null;
     private static recordQuery;
     static newID(): ID;
     static getCurrentIDs(): ID[];
@@ -46,8 +50,16 @@ export declare class QueryRecorder {
     static clear(): void;
     static clearQueries(): void;
     static getCurrentQueries(): queryOptions[];
-    static validateQueryStructuresFromLogs(ml: MockLogs, expected: queryStructure[], skipSelect?: boolean): void;
-    private static validateQuryStructuresImpl;
+    /**
+     * @deprecated will keep this since it's just using ml.logs
+     * which we still want around (I think) but we should eventually
+     * probably stop using this
+     */
+    static validateQueryStructuresFromLogs(ml: MockLogs, expected: queryStructure[], opts?: {
+        skipSelect?: boolean;
+        flagBeginCommit?: boolean;
+    }): void;
+    private static validateQueryStructuresImpl;
     static mockPool(pool: typeof Pool): void;
 }
 export {};