@snowtop/ent 0.1.0-alpha9 → 0.1.0-alpha90

package/core/privacy.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AllowIfViewerHasIdentityPrivacyPolicy = exports.AllowIfViewerPrivacyPolicy = exports.AlwaysDenyPrivacyPolicy = exports.AlwaysAllowPrivacyPolicy = exports.applyPrivacyPolicyX = exports.applyPrivacyPolicy = exports.AllowIfSubPolicyAllowsRule = exports.DelayedResultRule = exports.AllowIfConditionAppliesRule = exports.DenyIfViewerOutboundEdgeDoesNotExistRule = exports.DenyIfViewerInboundEdgeDoesNotExistRule = exports.DenyIfEdgeDoesNotExistRule = exports.DenyIfViewerOutboundEdgeExistsRule = exports.DenyIfViewerInboundEdgeExistsRule = exports.DenyIfEdgeExistsRule = exports.AllowIfViewerOutboundEdgeExistsRule = exports.AllowIfViewerInboundEdgeExistsRule = exports.AllowIfEdgeExistsRule = exports.DenyIfEntIsNotVisibleRule = exports.DenyIfEntIsVisibleRule = exports.DenyIfEntIsVisiblePolicy = exports.AllowIfEntIsVisiblePolicy = exports.AllowIfEntIsNotVisibleRule = exports.AllowIfEntIsVisibleRule = exports.DenyIfEntPropertyIsRule = exports.AllowIfEntPropertyIsRule = exports.AllowIfViewerIsEntPropertyRule = exports.AllowIfViewerIsRule = exports.DenyIfFuncRule = exports.AllowIfFuncRule = exports.DenyIfViewerEqualsRule = exports.AllowIfViewerEqualsRule = exports.AllowIfViewerRule = exports.AllowIfHasIdentity = exports.DenyIfLoggedInRule = exports.DenyIfLoggedOutRule = exports.AlwaysDenyRule = exports.AlwaysAllowRule = exports.EntPrivacyError = void 0;
+exports.AllowIfViewerHasIdentityPrivacyPolicy = exports.AllowIfViewerPrivacyPolicy = exports.AlwaysDenyPrivacyPolicy = exports.AlwaysAllowPrivacyPolicy = exports.applyPrivacyPolicyImpl = exports.applyPrivacyPolicyX = exports.applyPrivacyPolicy = exports.AllowIfSubPolicyAllowsRule = exports.DelayedResultRule = exports.AllowIfConditionAppliesRule = exports.DenyIfViewerOutboundEdgeDoesNotExistRule = exports.DenyIfViewerInboundEdgeDoesNotExistRule = exports.DenyIfEdgeDoesNotExistRule = exports.DenyIfViewerOutboundEdgeExistsRule = exports.DenyIfViewerInboundEdgeExistsRule = exports.DenyIfEdgeExistsRule = exports.AllowIfViewerOutboundEdgeExistsRule = exports.AllowIfViewerInboundEdgeExistsRule = exports.AllowIfEdgeExistsRule = exports.DenyIfEntIsNotVisibleRule = exports.DenyIfEntIsVisibleRule = exports.DenyIfEntIsVisiblePolicy = exports.AllowIfEntIsVisiblePolicy = exports.AllowIfEntIsNotVisibleRule = exports.AllowIfEntIsVisibleRule = exports.DenyIfEntPropertyIsRule = exports.AllowIfEntPropertyIsRule = exports.AllowIfViewerIsEntPropertyRule = exports.AllowIfViewerIsRule = exports.DenyIfFuncRule = exports.AllowIfFuncRule = exports.DenyIfViewerEqualsRule = exports.AllowIfViewerEqualsRule = exports.AllowIfViewerRule = exports.AllowIfHasIdentity = exports.DenyIfLoggedInRule = exports.DenyIfLoggedOutRule = exports.AlwaysDenyRule = exports.AlwaysAllowRule = exports.EntPrivacyError = void 0;
 const base_1 = require("./base");
 const ent_1 = require("./ent");
-const logger_1 = require("./logger");
 // copied from ./base
 var privacyResult;
 (function (privacyResult) {
@@ -437,45 +436,42 @@ class AllowIfSubPolicyAllowsRule {
 }
 exports.AllowIfSubPolicyAllowsRule = AllowIfSubPolicyAllowsRule;
 async function applyPrivacyPolicy(v, policy, ent) {
-    try {
-        return await applyPrivacyPolicyX(v, policy, ent);
-    }
-    catch (e) {
-        // TODO privacy errors should not throw
-        // but other expected errors should throw...
-        // we shouldn't just hide them
-        (0, logger_1.log)("debug", e);
-        return false;
-    }
+    const err = await applyPrivacyPolicyImpl(v, policy, ent);
+    return err === null;
 }
 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];
+    const err = await applyPrivacyPolicyImpl(v, policy, ent, throwErr);
+    if (err !== null) {
+        throw err;
+    }
+    return true;
+}
+exports.applyPrivacyPolicyX = applyPrivacyPolicyX;
+// this will throw an exception if fails or return error | null?
+async function applyPrivacyPolicyImpl(v, policy, ent, throwErr) {
+    for (const rule of policy.rules) {
+        const res = await rule.apply(v, ent);
         if (res.result == privacyResult.Allow) {
-            return true;
+            return null;
         }
         else if (res.result == privacyResult.Deny) {
             // specific error throw that
             if (res.error) {
-                throw res.error;
+                return res.error;
             }
             if (res.getError) {
-                throw res.getError(policy, rule, ent);
+                return res.getError(policy, rule, ent);
             }
             if (throwErr) {
-                throw throwErr();
+                return throwErr();
             }
-            throw new EntPrivacyError(policy, rule, ent);
+            return new EntPrivacyError(policy, rule, ent);
         }
     }
-    throw new EntInvalidPrivacyPolicyError(policy, ent);
+    return new EntInvalidPrivacyPolicyError(policy, ent);
 }
-exports.applyPrivacyPolicyX = applyPrivacyPolicyX;
+exports.applyPrivacyPolicyImpl = applyPrivacyPolicyImpl;
 exports.AlwaysAllowPrivacyPolicy = {
     rules: [exports.AlwaysAllowRule],
 };

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_clause_query.d.ts

@@ -0,0 +1,24 @@
+import { Data, EdgeQueryableDataOptions, Ent, ID, LoadEntOptions, Viewer } from "../base";
+import { Clause } from "../clause";
+import { BaseEdgeQuery, IDInfo } from "./query";
+interface CustomClauseQueryOptions<TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
+    loadEntOptions: LoadEntOptions<TDest, TViewer>;
+    clause: Clause;
+    name: string;
+    sortColumn?: string;
+    disableTransformations?: boolean;
+}
+export declare class CustomClauseQuery<TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> extends BaseEdgeQuery<any, TDest, Data> {
+    viewer: TViewer;
+    private options;
+    private clause;
+    constructor(viewer: TViewer, options: CustomClauseQueryOptions<TDest, TViewer>);
+    sourceEnt(_id: ID): Promise<null>;
+    queryRawCount(): Promise<number>;
+    queryAllRawCount(): Promise<Map<ID, number>>;
+    protected loadRawIDs(_addID: (src: ID) => void): Promise<void>;
+    protected loadRawData(_infos: IDInfo[], options: EdgeQueryableDataOptions): Promise<void>;
+    dataToID(edge: Data): ID;
+    protected loadEntsFromEdges(id: ID, rows: Data[]): Promise<TDest[]>;
+}
+export {};

package/core/query/custom_clause_query.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomClauseQuery = void 0;
+const clause_1 = require("../clause");
+const ent_1 = require("../ent");
+const query_loader_1 = require("../loaders/query_loader");
+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);
+}
+class CustomClauseQuery extends query_1.BaseEdgeQuery {
+    constructor(viewer, options) {
+        super(viewer, options.sortColumn || "created_at");
+        this.viewer = viewer;
+        this.options = options;
+        this.clause = getClause(options);
+    }
+    async sourceEnt(_id) {
+        return null;
+    }
+    async queryRawCount() {
+        const row = await (0, ent_1.loadRow)({
+            tableName: this.options.loadEntOptions.tableName,
+            // sqlite needs as count otherwise it returns count(1)
+            fields: ["count(1) as count"],
+            clause: this.clause,
+            context: this.viewer.context,
+        });
+        return parseInt(row?.count, 10) || 0;
+    }
+    async queryAllRawCount() {
+        throw new Error(`queryAllRawCount doesn't make sense in CustomClauseQuery`);
+    }
+    // nothing to do here
+    async loadRawIDs(_addID) { }
+    async loadRawData(_infos, options) {
+        if (!options.orderby) {
+            options.orderby = `${this.options.sortColumn} DESC`;
+        }
+        if (!options.limit) {
+            options.limit = ent_1.DefaultLimit;
+        }
+        let sortCol = this.options.sortColumn || "created_at";
+        const rows = await (0, ent_1.loadRows)({
+            tableName: this.options.loadEntOptions.tableName,
+            fields: this.options.loadEntOptions.fields,
+            clause: (0, clause_1.AndOptional)(this.clause, options.clause),
+            orderby: (0, query_loader_1.getOrderBy)(sortCol, options?.orderby),
+            limit: options?.limit || ent_1.DefaultLimit,
+            context: this.viewer.context,
+        });
+        this.edges.set(1, rows);
+    }
+    dataToID(edge) {
+        return edge.id;
+    }
+    async loadEntsFromEdges(id, rows) {
+        return (0, ent_1.applyPrivacyPolicyForRows)(this.viewer, rows, this.options.loadEntOptions);
+    }
+}
+exports.CustomClauseQuery = CustomClauseQuery;

package/core/query/custom_query.d.ts

@@ -1,22 +1,37 @@
 import { Data, Ent, ID, EdgeQueryableDataOptions, LoadEntOptions, Viewer, LoaderFactory, ConfigurableLoaderFactory } from "../base";
+import { Clause } from "../clause";
 import { BaseEdgeQuery, IDInfo, EdgeQuery } from "./query";
-export interface CustomEdgeQueryOptions<TSource extends Ent, TDest extends Ent> {
+export interface CustomEdgeQueryOptionsDeprecated<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 interface CustomEdgeQueryOptions<TSource extends Ent<TViewer>, TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
+    src: TSource | ID;
+    loadEntOptions: LoadEntOptions<TDest, TViewer>;
+    groupCol?: string;
+    clause?: Clause;
+    name: string;
+    sortColumn?: string;
+    disableTransformations?: boolean;
+}
+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>);
+    private opts;
+    constructor(viewer: TViewer, options: CustomEdgeQueryOptionsDeprecated<TSource, TDest, TViewer> | CustomEdgeQueryOptions<TSource, TDest, TViewer>);
     abstract sourceEnt(id: ID): Promise<Ent | null>;
     private idVisible;
+    private isDeprecatedOptions;
+    private getCountLoader;
+    private getQueryLoader;
     queryRawCount(): Promise<number>;
     queryAllRawCount(): Promise<Map<ID, number>>;
     protected loadRawIDs(addID: (src: ID | TSource) => void): Promise<void>;
+    private getLoadEntOptions;
     protected loadRawData(infos: IDInfo[], options: EdgeQueryableDataOptions): Promise<void>;
     dataToID(edge: Data): ID;
     protected loadEntsFromEdges(id: ID, rows: Data[]): Promise<TDest[]>;

package/core/query/custom_query.js

@@ -1,11 +1,54 @@
 "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);
+}
 class CustomEdgeQueryBase extends query_1.BaseEdgeQuery {
     constructor(viewer, options) {
-        super(viewer, options.sortColumn || "created_at");
+        // @ts-ignore
+        super(viewer, options?.sortColumn || "created_at");
         this.viewer = viewer;
         this.options = options;
         options.sortColumn = options.sortColumn || "created_at";
@@ -15,6 +58,7 @@ class CustomEdgeQueryBase extends query_1.BaseEdgeQuery {
         else {
             this.id = options.src;
         }
+        this.opts = this.getLoadEntOptions();
     }
     async idVisible() {
         const ids = await this.genIDInfosToFetch();
@@ -23,14 +67,28 @@ class CustomEdgeQueryBase extends query_1.BaseEdgeQuery {
         }
         return !ids[0].invalidated;
     }
+    isDeprecatedOptions(options) {
+        return (options
+            .countLoaderFactory !== undefined);
+    }
+    getCountLoader() {
+        if (this.isDeprecatedOptions(this.options)) {
+            return this.options.countLoaderFactory.createLoader(this.viewer.context);
+        }
+        return getRawCountLoader(this.viewer, this.options);
+    }
+    getQueryLoader(options) {
+        if (this.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;
@@ -43,17 +101,27 @@ class CustomEdgeQueryBase extends query_1.BaseEdgeQuery {
     async loadRawIDs(addID) {
         addID(this.options.src);
     }
+    getLoadEntOptions() {
+        let opts;
+        if (this.isDeprecatedOptions(this.options)) {
+            opts = this.options.options;
+        }
+        else {
+            opts = this.options.loadEntOptions;
+        }
+        return opts;
+    }
     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`;
         }
         if (!options.limit) {
             options.limit = ent_1.DefaultLimit;
         }
-        if (infos.length !== 1) {
-            throw new Error(`expected 1 info passed to loadRawData. ${infos.length} passed`);
-        }
+        const loader = this.getQueryLoader(options);
         const info = infos[0];
         if (info.invalidated) {
             this.edges.set(this.id, []);
@@ -66,8 +134,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

@@ -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/query.js

@@ -89,7 +89,13 @@ class FirstFilter {
         // todo may not be desc
         // and if asc
         // clause below should switch to greater...
-        options.orderby = `${this.sortCol} DESC`;
+        const sortCol = this.sortCol.toLowerCase();
+        if (sortCol.endsWith("desc") || sortCol.endsWith("asc")) {
+            options.orderby = `${this.sortCol}`;
+        }
+        else {
+            options.orderby = `${this.sortCol} DESC`;
+        }
         // we sort by most recent first
         // so when paging, we fetch afterCursor X
         if (this.offset) {
@@ -100,6 +106,7 @@ class FirstFilter {
                 options.clause = clause.Less(this.sortCol, new Date(this.offset).toISOString());
             }
         }
+        // console.debug("filter opts", options, this.options);
         return options;
     }
     // TODO?

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 {};