@snowtop/ent 0.1.0-alpha16 → 0.1.0-alpha160-test2

package/core/query/custom_query.js

@@ -1,20 +1,104 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CustomEdgeQueryBase = void 0;
+const clause_1 = require("../clause");
 const ent_1 = require("../ent");
+const loaders_1 = require("../loaders");
 const query_1 = require("./query");
+function getClause(opts) {
+    let cls = opts.clause;
+    if (opts.disableTransformations) {
+        return cls;
+    }
+    let optClause = opts.loadEntOptions.loaderFactory?.options?.clause;
+    if (typeof optClause === "function") {
+        optClause = optClause();
+    }
+    if (!optClause) {
+        return cls;
+    }
+    return (0, clause_1.AndOptional)(cls, optClause);
+}
+function getRawCountLoader(viewer, opts) {
+    if (!viewer.context?.cache) {
+        return new loaders_1.RawCountLoader({
+            tableName: opts.loadEntOptions.tableName,
+            groupCol: opts.groupCol,
+            clause: getClause(opts),
+        });
+    }
+    const name = `custom_query_count_loader:${opts.name}`;
+    return viewer.context.cache.getLoader(name, () => new loaders_1.RawCountLoader({
+        tableName: opts.loadEntOptions.tableName,
+        groupCol: opts.groupCol,
+        clause: getClause(opts),
+    }));
+}
+function getQueryLoader(viewer, opts, options) {
+    const loader = opts.loadEntOptions.loaderFactory;
+    const name = `custom_query_loader:${opts.name}`;
+    return loaders_1.QueryLoaderFactory.createConfigurableLoader(name, {
+        tableName: opts.loadEntOptions.tableName,
+        fields: opts.loadEntOptions.fields,
+        groupCol: opts.groupCol,
+        clause: getClause(opts),
+        toPrime: [loader],
+    }, options, viewer.context);
+}
+function isDeprecatedOptions(options) {
+    return (options
+        .countLoaderFactory !== undefined);
+}
 class CustomEdgeQueryBase extends query_1.BaseEdgeQuery {
     constructor(viewer, options) {
-        super(viewer, options.sortColumn || "created_at");
+        let opts;
+        let defaultSort = "id";
+        let uniqueColIsSort = false;
+        let orderby;
+        let sortCol;
+        if (isDeprecatedOptions(options)) {
+            opts = options.options;
+        }
+        else {
+            opts = options.loadEntOptions;
+            if (options.primarySortColIsUnique) {
+                uniqueColIsSort = true;
+            }
+            if (options.orderby) {
+                orderby = options.orderby;
+                sortCol = options.orderby[0].column;
+            }
+        }
+        let uniqueCol = opts.loaderFactory.options?.key || "id";
+        if (!orderby) {
+            options.sortColumn = options.sortColumn || defaultSort;
+            sortCol = options.sortColumn;
+            orderby = [
+                {
+                    column: options.sortColumn,
+                    direction: "DESC",
+                },
+            ];
+        }
+        if (uniqueColIsSort) {
+            uniqueCol = sortCol || defaultSort;
+        }
+        super(viewer, {
+            cursorCol: uniqueCol,
+            orderby,
+        });
         this.viewer = viewer;
         this.options = options;
-        options.sortColumn = options.sortColumn || "created_at";
         if (typeof options.src === "object") {
             this.id = options.src.id;
         }
         else {
             this.id = options.src;
         }
+        this.opts = opts;
+    }
+    getTableName() {
+        return this.opts.tableName;
     }
     async idVisible() {
         const ids = await this.genIDInfosToFetch();
@@ -23,14 +107,24 @@ class CustomEdgeQueryBase extends query_1.BaseEdgeQuery {
         }
         return !ids[0].invalidated;
     }
+    getCountLoader() {
+        if (isDeprecatedOptions(this.options)) {
+            return this.options.countLoaderFactory.createLoader(this.viewer.context);
+        }
+        return getRawCountLoader(this.viewer, this.options);
+    }
+    getQueryLoader(options) {
+        if (isDeprecatedOptions(this.options)) {
+            return this.options.dataLoaderFactory.createConfigurableLoader(options, this.viewer.context);
+        }
+        return getQueryLoader(this.viewer, this.options, options);
+    }
     async queryRawCount() {
         const idVisible = await this.idVisible();
         if (!idVisible) {
             return 0;
         }
-        return await this.options.countLoaderFactory
-            .createLoader(this.viewer.context)
-            .load(this.id);
+        return this.getCountLoader().load(this.id);
     }
     async queryAllRawCount() {
         let count = 0;
@@ -44,16 +138,21 @@ class CustomEdgeQueryBase extends query_1.BaseEdgeQuery {
         addID(this.options.src);
     }
     async loadRawData(infos, options) {
-        const loader = this.options.dataLoaderFactory.createConfigurableLoader(options, this.viewer.context);
+        if (infos.length !== 1) {
+            throw new Error(`expected 1 info passed to loadRawData. ${infos.length} passed`);
+        }
         if (!options.orderby) {
-            options.orderby = `${this.options.sortColumn} DESC`;
+            options.orderby = [
+                {
+                    column: this.getSortCol(),
+                    direction: "DESC",
+                },
+            ];
         }
         if (!options.limit) {
-            options.limit = ent_1.DefaultLimit;
-        }
-        if (infos.length !== 1) {
-            throw new Error(`expected 1 info passed to loadRawData. ${infos.length} passed`);
+            options.limit = (0, ent_1.getDefaultLimit)();
         }
+        const loader = this.getQueryLoader(options);
         const info = infos[0];
         if (info.invalidated) {
             this.edges.set(this.id, []);
@@ -66,8 +165,7 @@ class CustomEdgeQueryBase extends query_1.BaseEdgeQuery {
         return edge.id;
     }
     async loadEntsFromEdges(id, rows) {
-        const ents = await (0, ent_1.applyPrivacyPolicyForRows)(this.viewer, rows, this.options.options);
-        return Array.from(ents.values());
+        return (0, ent_1.applyPrivacyPolicyForRows)(this.viewer, rows, this.opts);
     }
 }
 exports.CustomEdgeQueryBase = CustomEdgeQueryBase;

package/core/query/index.d.ts

@@ -1,3 +1,4 @@
 export { EdgeQuery, BaseEdgeQuery, EdgeQueryFilter, PaginationInfo, } from "./query";
 export { AssocEdgeQueryBase, EdgeQuerySource } from "./assoc_query";
 export { CustomEdgeQueryBase } from "./custom_query";
+export { CustomClauseQuery } from "./custom_clause_query";

package/core/query/index.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CustomEdgeQueryBase = exports.AssocEdgeQueryBase = exports.BaseEdgeQuery = void 0;
+exports.CustomClauseQuery = exports.CustomEdgeQueryBase = exports.AssocEdgeQueryBase = exports.BaseEdgeQuery = void 0;
 var query_1 = require("./query");
 Object.defineProperty(exports, "BaseEdgeQuery", { enumerable: true, get: function () { return query_1.BaseEdgeQuery; } });
 var assoc_query_1 = require("./assoc_query");
 Object.defineProperty(exports, "AssocEdgeQueryBase", { enumerable: true, get: function () { return assoc_query_1.AssocEdgeQueryBase; } });
 var custom_query_1 = require("./custom_query");
 Object.defineProperty(exports, "CustomEdgeQueryBase", { enumerable: true, get: function () { return custom_query_1.CustomEdgeQueryBase; } });
+var custom_clause_query_1 = require("./custom_clause_query");
+Object.defineProperty(exports, "CustomClauseQuery", { enumerable: true, get: function () { return custom_clause_query_1.CustomClauseQuery; } });

package/core/query/query.d.ts

@@ -1,4 +1,5 @@
-import { ID, Ent, Viewer, EdgeQueryableDataOptions, Data, PrivacyPolicy } from "../base";
+import { ID, Ent, Viewer, EdgeQueryableDataOptions, Data, PrivacyPolicy, EdgeQueryableDataOptionsConfigureLoader } from "../base";
+import { OrderBy } from "../query_impl";
 export interface EdgeQuery<TSource extends Ent, TDest extends Ent, TEdge extends Data> {
     queryEdges(): Promise<TEdge[]>;
     queryAllEdges(): Promise<Map<ID, TEdge[]>>;
@@ -20,7 +21,7 @@ export interface EdgeQuery<TSource extends Ent, TDest extends Ent, TEdge extends
 }
 export interface EdgeQueryFilter<T extends Data> {
     filter?(id: ID, edges: T[]): T[];
-    query?(options: EdgeQueryableDataOptions): EdgeQueryableDataOptions;
+    query?(options: EdgeQueryableDataOptions): EdgeQueryableDataOptions | Promise<EdgeQueryableDataOptions>;
     paginationInfo?(id: ID): PaginationInfo | undefined;
 }
 export interface PaginationInfo {
@@ -29,9 +30,12 @@ export interface PaginationInfo {
     startCursor: string;
     endCursor: string;
 }
+interface EdgeQueryOptions {
+    cursorCol: string;
+    orderby: OrderBy;
+}
 export declare abstract class BaseEdgeQuery<TSource extends Ent, TDest extends Ent, TEdge extends Data> implements EdgeQuery<TSource, TDest, TEdge> {
     viewer: Viewer;
-    private sortCol;
     private filters;
     private queryDispatched;
     protected edges: Map<ID, TEdge[]>;
@@ -40,7 +44,12 @@ export declare abstract class BaseEdgeQuery<TSource extends Ent, TDest extends E
     protected genIDInfosToFetch: () => Promise<IDInfo[]>;
     private idMap;
     private idsToFetch;
-    constructor(viewer: Viewer, sortCol: string);
+    private sortCol;
+    private cursorCol;
+    private edgeQueryOptions;
+    constructor(viewer: Viewer, sortCol: string, cursorCol: string);
+    constructor(viewer: Viewer, options: EdgeQueryOptions);
+    protected getSortCol(): string;
     getPrivacyPolicy(): PrivacyPolicy<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>>;
     abstract sourceEnt(id: ID): Promise<Ent | null>;
     first(n: number, after?: string): this;
@@ -64,7 +73,11 @@ export declare abstract class BaseEdgeQuery<TSource extends Ent, TDest extends E
     protected abstract loadRawIDs(addID: (src: ID | TSource) => void): Promise<void>;
     protected abstract loadRawData(infos: IDInfo[], options: EdgeQueryableDataOptions): Promise<void>;
     private addID;
+    abstract getTableName(): string | Promise<string>;
     protected genIDInfosToFetchImpl(): Promise<IDInfo[]>;
+    private _defaultEdgeQueryableOptions;
+    protected configureEdgeQueryableDataOptions(opts: EdgeQueryableDataOptionsConfigureLoader): void;
+    protected getDefaultEdgeQueryOptions(): Partial<Pick<import("../base").QueryableDataOptions, "clause" | "limit" | "orderby" | "disableTransformations">> | undefined;
     private loadEdges;
     getCursor(row: TEdge): string;
 }
@@ -72,3 +85,4 @@ export interface IDInfo {
     id: ID;
     invalidated?: boolean;
 }
+export {};

package/core/query/query.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];
@@ -27,6 +31,9 @@ const ent_1 = require("../ent");
 const clause = __importStar(require("../clause"));
 const memoizee_1 = __importDefault(require("memoizee"));
 const privacy_1 = require("../privacy");
+const uuid_1 = require("uuid");
+const query_impl_1 = require("../query_impl");
+const types_1 = require("util/types");
 // TODO can we generalize EdgeQuery to support any clause
 function assertPositive(n) {
     if (n < 0) {
@@ -36,31 +43,32 @@ function assertPositive(n) {
 function assertValidCursor(cursor, col) {
     let decoded = Buffer.from(cursor, "base64").toString("ascii");
     let parts = decoded.split(":");
+    // uuid, don't parse int since it tries to validate just first part
+    if ((0, uuid_1.validate)(parts[1])) {
+        return parts[1];
+    }
     // invalid or unknown cursor. nothing to do here.
     if (parts.length !== 2 || parts[0] !== col) {
         throw new Error(`invalid cursor ${cursor} passed`);
     }
-    // TODO check if numeric or not but for now we're only doing numbers
+    // TODO handle both cases... (time vs not) better
+    // TODO change this to only do the parseInt part if time...
+    // pass flag indicating if time?
     const time = parseInt(parts[1], 10);
     if (isNaN(time)) {
-        throw new Error(`invalid cursor ${cursor} passed`);
+        return parts[1];
     }
     return time;
 }
+const orderbyRegex = new RegExp(/([0-9a-z_]+)[ ]?([0-9a-z_]+)?/i);
 class FirstFilter {
     constructor(options) {
         this.options = options;
         this.pageMap = new Map();
         assertPositive(options.limit);
-        if (options.before) {
-            throw new Error(`cannot specify before with a first filter`);
-        }
-        this.sortCol = options.sortCol || "time";
+        this.sortCol = options.sortCol;
         if (options.after) {
-            this.offset = assertValidCursor(options.after, this.sortCol);
-        }
-        if (this.options.sortColNotTime && !this.options.sortCol) {
-            throw new Error(`cannot specify sortColNotTime without specifying a sortCol`);
+            this.offset = assertValidCursor(options.after, options.cursorCol);
         }
         this.edgeQuery = options.query;
     }
@@ -69,6 +77,8 @@ class FirstFilter {
             const ret = edges.slice(0, this.options.limit);
             this.pageMap.set(id, {
                 hasNextPage: true,
+                // hasPreviousPage always false even if there's a previous page because
+                // we shouldn't be querying in both directions at the same
                 hasPreviousPage: false,
                 startCursor: this.edgeQuery.getCursor(ret[0]),
                 endCursor: this.edgeQuery.getCursor(ret[ret.length - 1]),
@@ -82,24 +92,37 @@ class FirstFilter {
         // so we'd need a way to indicate whether this is done in sql or not
         return edges;
     }
-    query(options) {
+    async query(options) {
         // we fetch an extra one to see if we're at the end
         const limit = this.options.limit + 1;
         options.limit = limit;
-        // todo may not be desc
-        // and if asc
-        // clause below should switch to greater...
-        options.orderby = `${this.sortCol} DESC`;
         // we sort by most recent first
         // so when paging, we fetch afterCursor X
-        if (this.offset) {
-            if (this.options.sortColNotTime) {
-                options.clause = clause.Less(this.sortCol, this.offset);
+        const less = this.options.orderby[0].direction === "DESC";
+        const orderby = this.options.orderby;
+        if (this.options.cursorCol !== this.sortCol) {
+            // we also sort cursor col in same direction. (direction doesn't matter)
+            orderby.push({
+                column: this.options.cursorCol,
+                direction: orderby[0].direction,
+            });
+            if (this.offset) {
+                const res = this.edgeQuery.getTableName();
+                const tableName = (0, types_1.isPromise)(res) ? await res : res;
+                // inner col time
+                options.clause = clause.PaginationMultipleColsSubQuery(this.sortCol, less ? "<" : ">", tableName, this.options.cursorCol, this.offset);
             }
-            else {
-                options.clause = clause.Less(this.sortCol, new Date(this.offset).toISOString());
+        }
+        else {
+            if (this.offset) {
+                let clauseFn = less ? clause.Less : clause.Greater;
+                let val = this.options.sortColTime
+                    ? new Date(this.offset).toISOString()
+                    : this.offset;
+                options.clause = clauseFn(this.sortCol, val);
             }
         }
+        options.orderby = orderby;
         return options;
     }
     // TODO?
@@ -112,15 +135,9 @@ class LastFilter {
         this.options = options;
         this.pageMap = new Map();
         assertPositive(options.limit);
-        if (options.after) {
-            throw new Error(`cannot specify after with a last filter`);
-        }
-        this.sortCol = options.sortCol || "time";
+        this.sortCol = options.sortCol;
         if (options.before) {
-            this.offset = assertValidCursor(options.before, this.sortCol);
-        }
-        if (this.options.sortColNotTime && !this.options.sortCol) {
-            throw new Error(`cannot specify sortColNotTime without specifying a sortCol`);
+            this.offset = assertValidCursor(options.before, options.cursorCol);
         }
         this.edgeQuery = options.query;
     }
@@ -137,11 +154,13 @@ class LastFilter {
             }
         }
         else {
-            ret = edges.slice(edges.length - this.options.limit, edges.length);
+            ret = edges.slice(0, this.options.limit);
         }
         if (edges.length > this.options.limit) {
             this.pageMap.set(id, {
                 hasPreviousPage: true,
+                // hasNextPage always false even if there's a next page because
+                // we shouldn't be querying in both directions at the same
                 hasNextPage: false,
                 startCursor: this.edgeQuery.getCursor(ret[0]),
                 endCursor: this.edgeQuery.getCursor(ret[ret.length - 1]),
@@ -149,18 +168,33 @@ class LastFilter {
         }
         return ret;
     }
-    query(options) {
-        if (!this.offset) {
-            return options;
-        }
-        options.orderby = `${this.sortCol} ASC`;
+    async query(options) {
+        const orderby = (0, query_impl_1.reverseOrderBy)(this.options.orderby);
+        const greater = orderby[0].direction === "ASC";
         options.limit = this.options.limit + 1; // fetch an extra so we know if previous pag
-        if (this.options.sortColNotTime) {
-            options.clause = clause.Greater(this.sortCol, this.offset);
+        if (this.options.cursorCol !== this.sortCol) {
+            const res = this.edgeQuery.getTableName();
+            const tableName = (0, types_1.isPromise)(res) ? await res : res;
+            if (this.offset) {
+                // inner col time
+                options.clause = clause.PaginationMultipleColsSubQuery(this.sortCol, greater ? ">" : "<", tableName, this.options.cursorCol, this.offset);
+            }
+            // we also sort cursor col in same direction. (direction doesn't matter)
+            orderby.push({
+                column: this.options.cursorCol,
+                direction: orderby[0].direction,
+            });
         }
         else {
-            options.clause = clause.Greater(this.sortCol, new Date(this.offset).toISOString());
+            if (this.offset) {
+                let clauseFn = greater ? clause.Greater : clause.Less;
+                let val = this.options.sortColTime
+                    ? new Date(this.offset).toISOString()
+                    : this.offset;
+                options.clause = clauseFn(this.sortCol, val);
+            }
         }
+        options.orderby = orderby;
         return options;
     }
     paginationInfo(id) {
@@ -168,9 +202,8 @@ class LastFilter {
     }
 }
 class BaseEdgeQuery {
-    constructor(viewer, sortCol) {
+    constructor(viewer, sortColOrOptions, cursorColMaybe) {
         this.viewer = viewer;
-        this.sortCol = sortCol;
         this.filters = [];
         this.edges = new Map();
         this.pagination = new Map();
@@ -181,7 +214,7 @@ class BaseEdgeQuery {
             return await this.querySingleEdge("queryEdges");
         };
         this.queryAllEdges = async () => {
-            return await this.memoizedloadEdges();
+            return this.memoizedloadEdges();
         };
         this.queryIDs = async () => {
             const edges = await this.querySingleEdge("queryIDs");
@@ -209,7 +242,7 @@ class BaseEdgeQuery {
         };
         this.queryEnts = async () => {
             const edges = await this.querySingleEdge("queryEnts");
-            return await this.loadEntsFromEdges("id", edges);
+            return this.loadEntsFromEdges("id", edges);
         };
         this.queryAllEnts = async () => {
             // applies filters and then gets things after
@@ -226,9 +259,48 @@ class BaseEdgeQuery {
             await Promise.all(promises);
             return results;
         };
+        let sortCol;
+        let cursorCol;
+        if (typeof sortColOrOptions === "string") {
+            sortCol = sortColOrOptions;
+            cursorCol = cursorColMaybe;
+            this.edgeQueryOptions = {
+                cursorCol,
+                orderby: [
+                    {
+                        column: sortCol,
+                        direction: "DESC",
+                    },
+                ],
+            };
+        }
+        else {
+            if (typeof sortColOrOptions.orderby === "string") {
+                sortCol = sortColOrOptions.orderby;
+            }
+            else {
+                // TODO this orderby isn't consistent and this logic needs to be changed anywhere that's using this and this.getSortCol()
+                sortCol = sortColOrOptions.orderby[0].column;
+            }
+            cursorCol = sortColOrOptions.cursorCol;
+            this.edgeQueryOptions = sortColOrOptions;
+        }
+        this.sortCol = sortCol;
+        let m = orderbyRegex.exec(sortCol);
+        if (!m) {
+            throw new Error(`invalid sort column ${sortCol}`);
+        }
+        this.sortCol = m[1];
+        if (m[2]) {
+            throw new Error(`passing direction in sort column is not supproted. use orderby`);
+        }
+        this.cursorCol = cursorCol;
         this.memoizedloadEdges = (0, memoizee_1.default)(this.loadEdges.bind(this));
         this.genIDInfosToFetch = (0, memoizee_1.default)(this.genIDInfosToFetchImpl.bind(this));
     }
+    getSortCol() {
+        return this.sortCol;
+    }
     getPrivacyPolicy() {
         // default PrivacyPolicy is always allow. nothing to do here
         return privacy_1.AlwaysAllowPrivacyPolicy;
@@ -239,6 +311,8 @@ class BaseEdgeQuery {
             limit: n,
             after,
             sortCol: this.sortCol,
+            cursorCol: this.cursorCol,
+            orderby: this.edgeQueryOptions.orderby,
             query: this,
         }));
         return this;
@@ -249,6 +323,8 @@ class BaseEdgeQuery {
             limit: n,
             before,
             sortCol: this.sortCol,
+            cursorCol: this.cursorCol,
+            orderby: this.edgeQueryOptions.orderby,
             query: this,
         }));
         return this;
@@ -290,21 +366,32 @@ class BaseEdgeQuery {
         await this.loadRawIDs(this.addID.bind(this));
         return applyPrivacyPolicyForEdgeQ(this.viewer, this, this.idsToFetch, this.idMap);
     }
+    // FYI: this should be used sparingly.
+    // currently only exists so that disableTransformations can be configured by the developer
+    // so we're only exposing a partial API for now but maybe in the future we can expose
+    // the full API if there's a reason to use this that's not via filters
+    configureEdgeQueryableDataOptions(opts) {
+        this._defaultEdgeQueryableOptions = opts;
+    }
+    getDefaultEdgeQueryOptions() {
+        return this._defaultEdgeQueryableOptions;
+    }
     async loadEdges() {
         const idsInfo = await this.genIDInfosToFetch();
         if (!this.filters.length) {
             // if no filter, we add the firstN filter to ensure we get pagination info
-            this.first(ent_1.DefaultLimit);
+            this.first((0, ent_1.getDefaultLimit)());
         }
-        let options = {};
+        let options = this._defaultEdgeQueryableOptions ?? {};
         // TODO once we add a lot of complex filters, this needs to be more complicated
         // e.g. commutative filters. what can be done in sql or combined together etc
         // may need to bring sql mode or something back
-        this.filters.forEach((filter) => {
+        for (const filter of this.filters) {
             if (filter.query) {
-                options = filter.query(options);
+                let res = filter.query(options);
+                options = (0, types_1.isPromise)(res) ? await res : res;
             }
-        });
+        }
         await this.loadRawData(idsInfo, options);
         // no filters. nothing to do here.
         if (!this.filters.length) {
@@ -331,17 +418,7 @@ class BaseEdgeQuery {
     getCursor(row) {
         return (0, ent_1.getCursor)({
             row,
-            col: this.sortCol,
-            conv: (datum) => {
-                if (datum instanceof Date) {
-                    return datum.getTime();
-                }
-                // sqlite stores it as string and doesn't convert back
-                if (typeof datum === "string") {
-                    return Date.parse(datum);
-                }
-                return datum;
-            },
+            col: this.cursorCol,
         });
     }
 }

package/core/query/shared_assoc_test.d.ts

@@ -1 +1,2 @@
-export declare function assocTests(): void;
+import { MockLogs } from "../../testutils/mock_log";
+export declare function assocTests(ml: MockLogs, global?: boolean): void;