@snowtop/ent 0.1.0-alpha7 → 0.1.0-alpha73

package/core/loaders/assoc_edge_loader.d.ts

@@ -20,8 +20,8 @@ export declare class AssocDirectEdgeLoader<T extends AssocEdge> implements Loade
     private edgeType;
     private edgeCtr;
     private options?;
-    context?: Context | undefined;
-    constructor(edgeType: string, edgeCtr: AssocEdgeConstructor<T>, options?: Partial<Pick<import("../base").QueryableDataOptions, "limit" | "orderby" | "clause">> | undefined, context?: Context | undefined);
+    context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
+    constructor(edgeType: string, edgeCtr: AssocEdgeConstructor<T>, options?: Partial<Pick<import("../base").QueryableDataOptions, "limit" | "orderby" | "clause">> | undefined, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
     load(id: ID): Promise<T[]>;
     loadEdgeForID2(id: ID, id2: ID): Promise<T | undefined>;
     clearAll(): void;
@@ -32,7 +32,7 @@ export declare class AssocEdgeLoaderFactory<T extends AssocEdge> implements Load
     name: string;
     constructor(edgeType: string, edgeCtr: AssocEdgeConstructor<T> | (() => AssocEdgeConstructor<T>));
     createLoader(context?: Context): AssocLoader<T>;
-    private isFunction;
+    private isConstructor;
     createConfigurableLoader(options: EdgeQueryableDataOptions, context?: Context): AssocLoader<T>;
 }
 export {};

package/core/loaders/assoc_edge_loader.js

@@ -161,16 +161,17 @@ class AssocEdgeLoaderFactory {
     createLoader(context) {
         return this.createConfigurableLoader({}, context);
     }
-    isFunction(edgeCtr) {
-        // not constructor
-        return !(edgeCtr.prototype && edgeCtr.prototype.constructor === edgeCtr);
+    isConstructor(edgeCtr) {
+        return (edgeCtr.prototype &&
+            edgeCtr.prototype.constructor &&
+            edgeCtr.prototype.constructor.name.length > 0);
     }
     createConfigurableLoader(options, context) {
         let edgeCtr = this.edgeCtr;
         // in generated code, the edge is not necessarily defined at the time of loading
         // so we call this as follows:
         // const loader = new AssocEdgeLoaderFactory(EdgeType.Foo, ()=>DerivedEdgeClass);
-        if (this.isFunction(edgeCtr)) {
+        if (!this.isConstructor(edgeCtr)) {
             edgeCtr = edgeCtr();
         }
         // rename to make TS happy

package/core/loaders/index_loader.js

@@ -4,6 +4,7 @@ exports.IndexLoaderFactory = void 0;
 const query_loader_1 = require("./query_loader");
 // we're keeping this for legacy reasons so as to not break existing callers
 // and to decouple the change here but all callers can safely be changed here to use QueryLoaderFactory
+// @deprecated use QueryLoaderFactory
 class IndexLoaderFactory {
     constructor(options, col, opts) {
         this.factory = new query_loader_1.QueryLoaderFactory({

package/core/loaders/loader.js

@@ -37,12 +37,12 @@ class cacheMap {
             // might be a lot?
             // TODO this is not the best log format
             // was designed for ObjectLoader time. Now we have different needs e.g. count, assoc etc
-            (0, logger_1.log)("query", {
+            (0, logger_1.log)("cache", {
                 "dataloader-cache-hit": key,
                 "tableName": this.options.tableName,
             });
             // } else {
-            //   log("query", {
+            //   log("cache", {
             //     "dataloader-cache-miss": key,
             //     "tableName": options.tableName,
             //   });
@@ -50,21 +50,21 @@ class cacheMap {
         return ret;
     }
     set(key, value) {
-        // log("query", {
+        // log("cache", {
         //   "dataloader-cache-set": key,
         //   "tableName": options.tableName,
         // });
         return this.m.set(key, value);
     }
     delete(key) {
-        // log("query", {
+        // log("cache", {
         //   "dataloader-cache-delete": key,
         //   "tableName": options.tableName,
         // });
         return this.m.delete(key);
     }
     clear() {
-        // log("query", {
+        // log("cache", {
         //   "dataloader-cache-clear": true,
         //   "tableName": options.tableName,
         // });

package/core/loaders/object_loader.d.ts

@@ -1,23 +1,28 @@
-import { Data, SelectDataOptions, Context, Loader, LoaderFactory } from "../base";
+import { ID, Data, SelectDataOptions, Context, Loader, LoaderFactory } from "../base";
 export declare class ObjectLoader<T> implements Loader<T, Data | null> {
     private options;
-    context?: Context | undefined;
+    context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
     private toPrime?;
     private loader;
     private primedLoaders;
     private memoizedInitPrime;
-    constructor(options: SelectDataOptions, context?: Context | undefined, toPrime?: ObjectLoaderFactory<T>[] | undefined);
+    constructor(options: SelectDataOptions, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined, toPrime?: ObjectLoaderFactory<T>[] | undefined);
+    getOptions(): SelectDataOptions;
     private initPrime;
     load(key: T): Promise<Data | null>;
     clearAll(): void;
     loadMany(keys: T[]): Promise<Data[]>;
     prime(data: Data): void;
 }
+interface ObjectLoaderOptions extends SelectDataOptions {
+    instanceKey?: string;
+}
 export declare class ObjectLoaderFactory<T> implements LoaderFactory<T, Data | null> {
-    options: SelectDataOptions;
+    options: ObjectLoaderOptions;
     name: string;
     private toPrime;
-    constructor(options: SelectDataOptions);
+    constructor(options: ObjectLoaderOptions);
     createLoader(context?: Context): ObjectLoader<T>;
     addToPrime(factory: ObjectLoaderFactory<T>): void;
 }
+export {};

package/core/loaders/object_loader.js

@@ -29,6 +29,9 @@ const clause = __importStar(require("../clause"));
 const logger_1 = require("../logger");
 const loader_1 = require("./loader");
 const memoizee_1 = __importDefault(require("memoizee"));
+// optional clause...
+// so ObjectLoaderFactory and createDataLoader need to take a new optional field which is a clause that's always added here
+// and we need a disableTransform which skips loader completely and uses loadRow...
 function createDataLoader(options) {
     const loaderOptions = {};
     // if query logging is enabled, we should log what's happening with loader
@@ -40,9 +43,22 @@ function createDataLoader(options) {
             return [];
         }
         let col = options.key;
+        let cls = clause.In(col, ...ids);
+        if (options.clause) {
+            let optionClause;
+            if (typeof options.clause === "function") {
+                optionClause = options.clause();
+            }
+            else {
+                optionClause = options.clause;
+            }
+            if (optionClause) {
+                cls = clause.And(optionClause, cls);
+            }
+        }
         const rowOptions = {
             ...options,
-            clause: clause.In(col, ...ids),
+            clause: cls,
         };
         let m = new Map();
         let result = [];
@@ -77,6 +93,9 @@ class ObjectLoader {
         }
         this.memoizedInitPrime = (0, memoizee_1.default)(this.initPrime.bind(this));
     }
+    getOptions() {
+        return this.options;
+    }
     initPrime() {
         if (!this.context || !this.toPrime) {
             return;
@@ -107,9 +126,22 @@ class ObjectLoader {
             }
             return result;
         }
+        let cls = clause.Eq(this.options.key, key);
+        if (this.options.clause) {
+            let optionClause;
+            if (typeof this.options.clause === "function") {
+                optionClause = this.options.clause();
+            }
+            else {
+                optionClause = this.options.clause;
+            }
+            if (optionClause) {
+                cls = clause.And(optionClause, cls);
+            }
+        }
         const rowOptions = {
             ...this.options,
-            clause: clause.Eq(this.options.key, key),
+            clause: cls,
             context: this.context,
         };
         return await (0, ent_1.loadRow)(rowOptions);
@@ -121,9 +153,22 @@ class ObjectLoader {
         if (this.loader) {
             return await this.loader.loadMany(keys);
         }
+        let cls = clause.In(this.options.key, ...keys);
+        if (this.options.clause) {
+            let optionClause;
+            if (typeof this.options.clause === "function") {
+                optionClause = this.options.clause();
+            }
+            else {
+                optionClause = this.options.clause;
+            }
+            if (optionClause) {
+                cls = clause.And(optionClause, cls);
+            }
+        }
         const rowOptions = {
             ...this.options,
-            clause: clause.In(this.options.key, ...keys),
+            clause: cls,
             context: this.context,
         };
         return await (0, ent_1.loadRows)(rowOptions);
@@ -142,7 +187,16 @@ class ObjectLoaderFactory {
     constructor(options) {
         this.options = options;
         this.toPrime = [];
-        this.name = `${options.tableName}:${options.key}`;
+        let instanceKey = options.instanceKey || "";
+        if (typeof this.options.clause === "function") {
+            if (!options.instanceKey) {
+                throw new Error(`need to pass an instanceKey to ObjectLoader if clause is a function`);
+            }
+        }
+        else if (this.options.clause) {
+            instanceKey = this.options.clause.instanceKey();
+        }
+        this.name = `${options.tableName}:${options.key}:${instanceKey}`;
     }
     createLoader(context) {
         return (0, loader_1.getLoader)(this, () => {

package/core/loaders/query_loader.d.ts

@@ -10,12 +10,12 @@ export declare class QueryDirectLoader<K extends any> implements Loader<K, Data[
 }
 export declare class QueryLoader<K extends any> implements Loader<K, Data[]> {
     private options;
-    context?: Context | undefined;
+    context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
     private queryOptions?;
     private loader;
     private primedLoaders;
     private memoizedInitPrime;
-    constructor(options: QueryOptions, context?: Context | undefined, queryOptions?: Partial<Pick<import("../base").QueryableDataOptions, "limit" | "orderby" | "clause">> | undefined);
+    constructor(options: QueryOptions, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined, queryOptions?: Partial<Pick<import("../base").QueryableDataOptions, "limit" | "orderby" | "clause">> | undefined);
     private initPrime;
     load(id: K): Promise<Data[]>;
     clearAll(): void;

package/core/loaders/raw_count_loader.d.ts

@@ -9,9 +9,9 @@ interface QueryCountOptions {
 export declare function createCountDataLoader<K extends any>(options: QueryCountOptions): DataLoader<K, number, K>;
 export declare class RawCountLoader<K extends any> implements Loader<K, number> {
     private options;
-    context?: Context | undefined;
+    context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
     private loader;
-    constructor(options: QueryCountOptions, context?: Context | undefined);
+    constructor(options: QueryCountOptions, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
     load(id: K): Promise<number>;
     clearAll(): void;
 }

package/core/logger.d.ts

@@ -1,4 +1,4 @@
-declare type logType = "query" | "warn" | "info" | "error" | "debug";
+declare type logType = "query" | "warn" | "info" | "error" | "debug" | "cache";
 export declare function setLogLevels(levels: logType | logType[]): void;
 export declare function clearLogLevels(): void;
 export declare function log(level: logType, msg: any): void;

package/core/logger.js

@@ -7,6 +7,7 @@ var m = {
     info: "log",
     error: "error",
     debug: "debug",
+    cache: "log",
 };
 var logLevels = new Map();
 function setLogLevels(levels) {

package/core/privacy.d.ts

@@ -6,22 +6,22 @@ export declare class EntPrivacyError extends Error implements PrivacyError {
     constructor(privacyPolicy: PrivacyPolicy, rule: PrivacyPolicyRule, ent?: Ent);
 }
 export declare const AlwaysAllowRule: {
-    apply(_v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(_v: Viewer, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
 };
 export declare const AlwaysDenyRule: {
-    apply(_v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(_v: Viewer, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
 };
 export declare const DenyIfLoggedOutRule: {
-    apply(v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(v: Viewer, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
 };
 export declare const DenyIfLoggedInRule: {
-    apply(v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(v: Viewer, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
 };
 export declare const AllowIfHasIdentity: {
-    apply(v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(v: Viewer, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
 };
 export declare const AllowIfViewerRule: {
-    apply(v: Viewer, ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(v: Viewer, ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
 };
 export declare class AllowIfViewerEqualsRule {
     private id;
@@ -71,45 +71,45 @@ export declare class DenyIfEntPropertyIsRule<T extends Ent> implements PrivacyPo
     constructor(property: keyof T, val: any);
     apply(v: Viewer, ent?: T): Promise<PrivacyResult>;
 }
-export declare class AllowIfEntIsVisibleRule<T extends Ent> implements PrivacyPolicyRule {
+export declare class AllowIfEntIsVisibleRule<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicyRule {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
-    apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
+    apply(v: TViewer, _ent?: Ent): Promise<PrivacyResult>;
 }
-export declare class AllowIfEntIsNotVisibleRule<T extends Ent> implements PrivacyPolicyRule {
+export declare class AllowIfEntIsNotVisibleRule<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicyRule {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
-    apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
+    apply(v: TViewer, _ent?: Ent): Promise<PrivacyResult>;
 }
-export declare class AllowIfEntIsVisiblePolicy<T extends Ent> implements PrivacyPolicy {
+export declare class AllowIfEntIsVisiblePolicy<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicy<TEnt, TViewer> {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
     rules: {
-        apply(_v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+        apply(_v: Viewer<Ent<any> | null, ID | null>, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
     }[];
 }
-export declare class DenyIfEntIsVisiblePolicy<T extends Ent> implements PrivacyPolicy {
+export declare class DenyIfEntIsVisiblePolicy<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicy<TEnt, TViewer> {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
     rules: {
-        apply(_v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+        apply(_v: Viewer<Ent<any> | null, ID | null>, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
     }[];
 }
-export declare class DenyIfEntIsVisibleRule<T extends Ent> implements PrivacyPolicyRule {
+export declare class DenyIfEntIsVisibleRule<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicyRule<TEnt, TViewer> {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
-    apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
+    apply(v: TViewer, _ent?: Ent): Promise<PrivacyResult>;
 }
-export declare class DenyIfEntIsNotVisibleRule<T extends Ent> implements PrivacyPolicyRule {
+export declare class DenyIfEntIsNotVisibleRule<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicyRule {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
-    apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
+    apply(v: TViewer, _ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class AllowIfEdgeExistsRule implements PrivacyPolicyRule {
     private id1;
@@ -121,7 +121,7 @@ export declare class AllowIfEdgeExistsRule implements PrivacyPolicyRule {
 export declare class AllowIfViewerInboundEdgeExistsRule implements PrivacyPolicyRule {
     private edgeType;
     constructor(edgeType: string);
-    apply(v: Viewer, ent: Ent): Promise<PrivacyResult>;
+    apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class AllowIfViewerOutboundEdgeExistsRule implements PrivacyPolicyRule {
     private edgeType;

package/core/privacy.js

@@ -451,11 +451,8 @@ async function applyPrivacyPolicy(v, policy, ent) {
 exports.applyPrivacyPolicy = applyPrivacyPolicy;
 // this will throw an exception if fails or return error | null?
 async function applyPrivacyPolicyX(v, policy, ent, throwErr) {
-    // right now we apply all at same time. todo: be smart about this in the future
-    const results = await Promise.all(policy.rules.map((rule) => rule.apply(v, ent)));
-    for (let i = 0; i < results.length; i++) {
-        const res = results[i];
-        const rule = policy.rules[i];
+    for (const rule of policy.rules) {
+        const res = await rule.apply(v, ent);
         if (res.result == privacyResult.Allow) {
             return true;
         }
@@ -464,6 +461,9 @@ async function applyPrivacyPolicyX(v, policy, ent, throwErr) {
             if (res.error) {
                 throw res.error;
             }
+            if (res.getError) {
+                throw res.getError(policy, rule, ent);
+            }
             if (throwErr) {
                 throw throwErr();
             }

package/core/query/assoc_query.d.ts

@@ -3,15 +3,15 @@ import { AssocEdge } from "../ent";
 import { AssocEdgeCountLoaderFactory } from "../loaders/assoc_count_loader";
 import { AssocEdgeLoaderFactory } from "../loaders/assoc_edge_loader";
 import { EdgeQuery, BaseEdgeQuery, IDInfo } from "./query";
-export declare type EdgeQuerySource<TSource extends Ent, TDest extends Ent = Ent> = TSource | TSource[] | ID | ID[] | EdgeQuery<TDest, Ent, AssocEdge>;
-declare type loaderOptionsFunc = (type: string) => LoadEntOptions<Ent>;
-export declare abstract class AssocEdgeQueryBase<TSource extends Ent, TDest extends Ent, TEdge extends AssocEdge> extends BaseEdgeQuery<TSource, TDest, TEdge> implements EdgeQuery<TSource, TDest, TEdge> {
-    viewer: Viewer;
-    src: EdgeQuerySource<TSource, TDest>;
+export declare type EdgeQuerySource<TSource extends Ent<TViewer>, TDest extends Ent<TViewer> = Ent<any>, TViewer extends Viewer = Viewer> = TSource | TSource[] | ID | ID[] | EdgeQuery<TDest, Ent, AssocEdge>;
+declare type loaderOptionsFunc<TViewer extends Viewer> = (type: string) => LoadEntOptions<Ent, TViewer>;
+export declare abstract class AssocEdgeQueryBase<TSource extends Ent<TViewer>, TDest extends Ent<TViewer>, TEdge extends AssocEdge, TViewer extends Viewer = Viewer> extends BaseEdgeQuery<TSource, TDest, TEdge> implements EdgeQuery<TSource, TDest, TEdge> {
+    viewer: TViewer;
+    src: EdgeQuerySource<TSource, TDest, TViewer>;
     private countLoaderFactory;
     private dataLoaderFactory;
     private options;
-    constructor(viewer: Viewer, src: EdgeQuerySource<TSource, TDest>, countLoaderFactory: AssocEdgeCountLoaderFactory, dataLoaderFactory: AssocEdgeLoaderFactory<TEdge>, options: LoadEntOptions<TDest> | loaderOptionsFunc);
+    constructor(viewer: TViewer, src: EdgeQuerySource<TSource, TDest, TViewer>, countLoaderFactory: AssocEdgeCountLoaderFactory, dataLoaderFactory: AssocEdgeLoaderFactory<TEdge>, options: LoadEntOptions<TDest, TViewer> | loaderOptionsFunc<TViewer>);
     private isEdgeQuery;
     abstract sourceEnt(id: ID): Promise<Ent | null>;
     private getSingleID;

package/core/query/custom_query.d.ts

@@ -1,17 +1,17 @@
 import { Data, Ent, ID, EdgeQueryableDataOptions, LoadEntOptions, Viewer, LoaderFactory, ConfigurableLoaderFactory } from "../base";
 import { BaseEdgeQuery, IDInfo, EdgeQuery } from "./query";
-export interface CustomEdgeQueryOptions<TSource extends Ent, TDest extends Ent> {
+export interface CustomEdgeQueryOptions<TSource extends Ent<TViewer>, TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
     src: TSource | ID;
     countLoaderFactory: LoaderFactory<ID, number>;
     dataLoaderFactory: ConfigurableLoaderFactory<ID, Data[]>;
-    options: LoadEntOptions<TDest>;
+    options: LoadEntOptions<TDest, TViewer>;
     sortColumn?: string;
 }
-export declare abstract class CustomEdgeQueryBase<TSource extends Ent, TDest extends Ent> extends BaseEdgeQuery<TSource, TDest, Data> implements EdgeQuery<TSource, TDest, Data> {
-    viewer: Viewer;
+export declare abstract class CustomEdgeQueryBase<TSource extends Ent<TViewer>, TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> extends BaseEdgeQuery<TSource, TDest, Data> implements EdgeQuery<TSource, TDest, Data> {
+    viewer: TViewer;
     private options;
     private id;
-    constructor(viewer: Viewer, options: CustomEdgeQueryOptions<TSource, TDest>);
+    constructor(viewer: TViewer, options: CustomEdgeQueryOptions<TSource, TDest, TViewer>);
     abstract sourceEnt(id: ID): Promise<Ent | null>;
     private idVisible;
     queryRawCount(): Promise<number>;

package/core/query/query.d.ts

@@ -41,7 +41,7 @@ export declare abstract class BaseEdgeQuery<TSource extends Ent, TDest extends E
     private idMap;
     private idsToFetch;
     constructor(viewer: Viewer, sortCol: string);
-    getPrivacyPolicy(): PrivacyPolicy<Ent>;
+    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;
     last(n: number, before?: string): this;

package/core/query/shared_assoc_test.d.ts

@@ -1 +1 @@
-export declare function assocTests(): void;
+export declare function assocTests(global?: boolean): void;

package/core/query/shared_assoc_test.js

@@ -27,7 +27,7 @@ const jest_date_mock_1 = require("jest-date-mock");
 const index_1 = require("../../testutils/fake_data/index");
 const test_helpers_1 = require("../../testutils/fake_data/test_helpers");
 const db_1 = __importStar(require("../db"));
-function assocTests() {
+function assocTests(global = false) {
     describe("custom edge", () => {
         let user1, user2;
         beforeEach(async () => {
@@ -76,9 +76,16 @@ function assocTests() {
         for (let i = 0; i < numQueries; i++) {
             const query = queries[i];
             let expLimit = disablePaginationBump ? limit : limit + 1;
-            expect(query.qs?.whereClause, `${i}`).toBe(
-            // default limit
-            `id1 = $1 AND edge_type = $2 ORDER BY time DESC LIMIT ${expLimit}`);
+            if (global) {
+                expect(query.qs?.whereClause, `${i}`).toBe(
+                // default limit
+                `id1 = $1 AND edge_type = $2 AND deleted_at IS NULL ORDER BY time DESC LIMIT ${expLimit}`);
+            }
+            else {
+                expect(query.qs?.whereClause, `${i}`).toBe(
+                // default limit
+                `id1 = $1 AND edge_type = $2 ORDER BY time DESC LIMIT ${expLimit}`);
+            }
         }
     }
     function verifyCountQuery({ length = 1, numQueries = 1 }) {
@@ -89,7 +96,12 @@ function assocTests() {
         expect(queries.length).toBe(length);
         for (let i = 0; i < numQueries; i++) {
             const query = queries[i];
-            expect(query.qs?.whereClause).toBe(`id1 = $1 AND edge_type = $2`);
+            if (global) {
+                expect(query.qs?.whereClause).toBe(`id1 = $1 AND edge_type = $2 AND deleted_at IS NULL`);
+            }
+            else {
+                expect(query.qs?.whereClause).toBe(`id1 = $1 AND edge_type = $2`);
+            }
         }
     }
     // TODO need to test multi-ids with id1s that aren't visible...

package/core/query/shared_test.d.ts

@@ -4,11 +4,14 @@ import { EdgeQuery } from "./query";
 interface options<TData extends Data> {
     newQuery: (v: Viewer, user: FakeUser) => EdgeQuery<FakeUser, FakeContact, TData>;
     tableName: string;
+    uniqKey: string;
     entsLength?: number;
     where: string;
     sortCol: string;
     livePostgresDB?: boolean;
     sqlite?: boolean;
+    globalSchema?: boolean;
+    rawDataVerify?(user: FakeUser): Promise<void>;
 }
 export declare const commonTests: <TData extends Data>(opts: options<TData>) => void;
 export {};