@snowtop/ent 0.0.2 → 0.0.3-5.alpha.2

package/core/query/query.d.ts

@@ -1,5 +1,5 @@
-import { ID, Ent, Viewer, EdgeQueryableDataOptions, Data } from "../base";
-export interface EdgeQuery<T extends Ent, TEdge extends Data> {
+import { ID, Ent, Viewer, EdgeQueryableDataOptions, Data, PrivacyPolicy } from "../base";
+export interface EdgeQuery<TSource extends Ent, TDest extends Ent, TEdge extends Data> {
     queryEdges(): Promise<TEdge[]>;
     queryAllEdges(): Promise<Map<ID, TEdge[]>>;
     queryIDs(): Promise<ID[]>;
@@ -8,13 +8,15 @@ export interface EdgeQuery<T extends Ent, TEdge extends Data> {
     queryAllCount(): Promise<Map<ID, number>>;
     queryRawCount(): Promise<number>;
     queryAllRawCount(): Promise<Map<ID, number>>;
-    queryEnts(): Promise<T[]>;
-    queryAllEnts(): Promise<Map<ID, T[]>>;
-    first(n: number, after?: string): EdgeQuery<T, TEdge>;
-    last(n: number, before?: string): EdgeQuery<T, TEdge>;
+    queryEnts(): Promise<TDest[]>;
+    queryAllEnts(): Promise<Map<ID, TDest[]>>;
+    first(n: number, after?: string): EdgeQuery<TSource, TDest, TEdge>;
+    last(n: number, before?: string): EdgeQuery<TSource, TDest, TEdge>;
     paginationInfo(): Map<ID, PaginationInfo>;
     getCursor(row: TEdge): string;
     dataToID(edge: TEdge): ID;
+    getPrivacyPolicy(): PrivacyPolicy;
+    sourceEnt(id: ID): Promise<Ent | null>;
 }
 export interface EdgeQueryFilter<T extends Data> {
     filter?(id: ID, edges: T[]): T[];
@@ -27,7 +29,7 @@ export interface PaginationInfo {
     startCursor: string;
     endCursor: string;
 }
-export declare abstract class BaseEdgeQuery<TDest extends Ent, TEdge extends Data> {
+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;
@@ -35,11 +37,18 @@ export declare abstract class BaseEdgeQuery<TDest extends Ent, TEdge extends Dat
     protected edges: Map<ID, TEdge[]>;
     private pagination;
     private memoizedloadEdges;
+    protected genIDInfosToFetch: () => Promise<IDInfo[]>;
+    private idMap;
+    private idsToFetch;
     constructor(viewer: Viewer, sortCol: string);
+    getPrivacyPolicy(): PrivacyPolicy;
+    abstract sourceEnt(id: ID): Promise<Ent | null>;
     first(n: number, after?: string): this;
     last(n: number, before?: string): this;
     private querySingleEdge;
     readonly queryEdges: () => Promise<TEdge[]>;
+    abstract queryRawCount(): Promise<number>;
+    abstract queryAllRawCount(): Promise<Map<ID, number>>;
     readonly queryAllEdges: () => Promise<Map<ID, TEdge[]>>;
     abstract dataToID(edge: TEdge): ID;
     readonly queryIDs: () => Promise<ID[]>;
@@ -52,7 +61,14 @@ export declare abstract class BaseEdgeQuery<TDest extends Ent, TEdge extends Dat
     paginationInfo(): Map<ID, PaginationInfo>;
     private assertQueryDispatched;
     private assertQueryNotDispatched;
-    protected abstract loadRawData(options: EdgeQueryableDataOptions): Promise<void>;
+    protected abstract loadRawIDs(addID: (src: ID | TSource) => void): Promise<void>;
+    protected abstract loadRawData(infos: IDInfo[], options: EdgeQueryableDataOptions): Promise<void>;
+    private addID;
+    protected genIDInfosToFetchImpl(): Promise<IDInfo[]>;
     private loadEdges;
     getCursor(row: TEdge): string;
 }
+export interface IDInfo {
+    id: ID;
+    invalidated?: boolean;
+}

package/core/query/query.js

@@ -26,6 +26,7 @@ exports.BaseEdgeQuery = void 0;
 const ent_1 = require("../ent");
 const clause = __importStar(require("../clause"));
 const memoizee_1 = __importDefault(require("memoizee"));
+const privacy_1 = require("../privacy");
 // TODO can we generalize EdgeQuery to support any clause
 function assertPositive(n) {
     if (n < 0) {
@@ -173,6 +174,8 @@ class BaseEdgeQuery {
         this.filters = [];
         this.edges = new Map();
         this.pagination = new Map();
+        this.idMap = new Map();
+        this.idsToFetch = [];
         // this is basically just raw rows
         this.queryEdges = async () => {
             return await this.querySingleEdge("queryEdges");
@@ -223,7 +226,12 @@ class BaseEdgeQuery {
             await Promise.all(promises);
             return results;
         };
-        this.memoizedloadEdges = memoizee_1.default(this.loadEdges.bind(this));
+        this.memoizedloadEdges = (0, memoizee_1.default)(this.loadEdges.bind(this));
+        this.genIDInfosToFetch = (0, memoizee_1.default)(this.genIDInfosToFetchImpl.bind(this));
+    }
+    getPrivacyPolicy() {
+        // default PrivacyPolicy is always allow. nothing to do here
+        return privacy_1.AlwaysAllowPrivacyPolicy;
     }
     first(n, after) {
         this.assertQueryNotDispatched("first");
@@ -269,9 +277,23 @@ class BaseEdgeQuery {
             throw new Error(`cannot call ${str} after query is dispatched`);
         }
     }
+    addID(id) {
+        if (typeof id === "object") {
+            this.idMap.set(id.id, id);
+            this.idsToFetch.push(id.id);
+        }
+        else {
+            this.idsToFetch.push(id);
+        }
+    }
+    async genIDInfosToFetchImpl() {
+        await this.loadRawIDs(this.addID.bind(this));
+        return applyPrivacyPolicyForEdgeQ(this.viewer, this, this.idsToFetch, this.idMap);
+    }
     async loadEdges() {
-        // if no filter, we add the firstN filter to ensure we get pagination info
+        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);
         }
         let options = {};
@@ -283,7 +305,7 @@ class BaseEdgeQuery {
                 options = filter.query(options);
             }
         });
-        await this.loadRawData(options);
+        await this.loadRawData(idsInfo, options);
         // no filters. nothing to do here.
         if (!this.filters.length) {
             return this.edges;
@@ -307,7 +329,7 @@ class BaseEdgeQuery {
         return this.edges;
     }
     getCursor(row) {
-        return ent_1.getCursor({
+        return (0, ent_1.getCursor)({
             row,
             col: this.sortCol,
             conv: (datum) => {
@@ -324,3 +346,18 @@ class BaseEdgeQuery {
     }
 }
 exports.BaseEdgeQuery = BaseEdgeQuery;
+async function applyPrivacyPolicyForEdgeQ(viewer, edgeQ, ids, map) {
+    const result = [];
+    await Promise.all(ids.map(async (id) => {
+        let ent = map.get(id);
+        if (!ent) {
+            ent = await edgeQ.sourceEnt(id);
+        }
+        const r = await (0, privacy_1.applyPrivacyPolicy)(viewer, edgeQ.getPrivacyPolicy(), ent || undefined);
+        result.push({
+            id,
+            invalidated: !r,
+        });
+    }));
+    return result;
+}

package/core/query/shared_assoc_test.js

@@ -31,8 +31,8 @@ function assocTests() {
     describe("custom edge", () => {
         let user1, user2;
         beforeEach(async () => {
-            user2 = await test_helpers_1.createTestUser();
-            const builder = index_1.getUserBuilder(new viewer_1.LoggedOutViewer(), test_helpers_1.getUserInput());
+            user2 = await (0, test_helpers_1.createTestUser)();
+            const builder = (0, index_1.getUserBuilder)(new viewer_1.LoggedOutViewer(), (0, test_helpers_1.getUserInput)());
             builder.orchestrator.addOutboundEdge(user2.id, index_1.EdgeType.UserToCustomEdge, index_1.NodeType.FakeUser);
             await builder.saveX();
             user1 = await builder.editedEntX();
@@ -92,6 +92,8 @@ function assocTests() {
             expect(query.qs?.whereClause).toBe(`id1 = $1 AND edge_type = $2`);
         }
     }
+    // TODO need to test multi-ids with id1s that aren't visible...
+    // so 2 user's friend requests at the same time
     class MultiIDsTestQueryFilter {
         constructor(filter, ents, limit) {
             this.filter = filter;
@@ -101,9 +103,9 @@ function assocTests() {
         }
         async beforeEach() {
             let [user1, user2, user3] = await Promise.all([
-                test_helpers_1.createAllContacts({ firstName: "Jon", lastName: "Snow" }),
-                test_helpers_1.createAllContacts({ firstName: "Aegon", lastName: "Targaryen" }),
-                test_helpers_1.createAllContacts({ firstName: "Ned", lastName: "Stark" }),
+                (0, test_helpers_1.createAllContacts)({ firstName: "Jon", lastName: "Snow" }),
+                (0, test_helpers_1.createAllContacts)({ firstName: "Aegon", lastName: "Targaryen" }),
+                (0, test_helpers_1.createAllContacts)({ firstName: "Ned", lastName: "Stark" }),
             ]);
             // modify contacts as needed
             user1[1] = this.ents(user1[1]);
@@ -156,7 +158,7 @@ function assocTests() {
             expect(edgesMap.size).toBe(this.dataz.length);
             for (let i = 0; i < this.dataz.length; i++) {
                 let data = this.dataz[i];
-                test_helpers_1.verifyUserToContactEdges(data[0], edgesMap.get(data[0].id) || [], data[1]);
+                (0, test_helpers_1.verifyUserToContactEdges)(data[0], edgesMap.get(data[0].id) || [], data[1]);
             }
             verifyQuery({
                 length: this.dataz.length,
@@ -170,14 +172,14 @@ function assocTests() {
             expect(entsMap.size).toBe(this.dataz.length);
             for (let i = 0; i < this.dataz.length; i++) {
                 let data = this.dataz[i];
-                test_helpers_1.verifyUserToContacts(data[0], entsMap.get(data[0].id) || [], []);
+                (0, test_helpers_1.verifyUserToContacts)(data[0], entsMap.get(data[0].id) || [], []);
             }
             // privacy. only data for the first id is visible in this case
             const entsMap2 = await this.getQuery(new viewer_1.IDViewer(this.dataz[0][0].id)).queryAllEnts();
             expect(entsMap2.size).toBe(this.dataz.length);
             for (let i = 0; i < this.dataz.length; i++) {
                 let data = this.dataz[i];
-                test_helpers_1.verifyUserToContacts(data[0], entsMap2.get(data[0].id) || [], i == 0 ? data[1] : []);
+                (0, test_helpers_1.verifyUserToContacts)(data[0], entsMap2.get(data[0].id) || [], i == 0 ? data[1] : []);
             }
             verifyQuery({
                 // extra query for the nodes
@@ -270,13 +272,13 @@ function assocTests() {
             this.lastHopFilter = lastHopFilter;
         }
         async beforeEach() {
-            this.user = await test_helpers_1.createTestUser();
-            this.event = await test_helpers_1.createTestEvent(this.user);
-            this.event2 = await test_helpers_1.createTestEvent(this.user, { title: "Red Wedding" });
+            this.user = await (0, test_helpers_1.createTestUser)();
+            this.event = await (0, test_helpers_1.createTestEvent)(this.user);
+            this.event2 = await (0, test_helpers_1.createTestEvent)(this.user, { title: "Red Wedding" });
             this.friends = await Promise.all(test_helpers_1.inputs.map(async (input) => {
                 // just to make times deterministic so that tests can consistently work
-                jest_date_mock_1.advanceBy(100);
-                const builder = index_1.getUserBuilder(this.user.viewer, test_helpers_1.getUserInput(input));
+                (0, jest_date_mock_1.advanceBy)(100);
+                const builder = (0, index_1.getUserBuilder)(this.user.viewer, (0, test_helpers_1.getUserInput)(input));
                 // add edge from user to contact
                 builder.orchestrator.addOutboundEdge(this.user.id, index_1.EdgeType.UserToFriends, index_1.NodeType.FakeUser, {
                     time: new Date(), // set time to advanceBy time
@@ -425,5 +427,247 @@ function assocTests() {
             await filter.testEnts();
         });
     });
+    class PolymorphicID2sTestQueryFilter {
+        constructor(filter, ents, limit) {
+            this.filter = filter;
+            this.ents = ents;
+            this.limit = limit;
+            this.users = [];
+            this.events = [];
+        }
+        async beforeEach() {
+            this.users = [];
+            this.events = [];
+            this.user = await (0, test_helpers_1.createTestUser)();
+            for (let i = 0; i < 5; i++) {
+                (0, jest_date_mock_1.advanceBy)(100);
+                const builder = (0, index_1.getUserBuilder)(this.user.viewer, (0, test_helpers_1.getUserInput)());
+                builder.orchestrator.addOutboundEdge(this.user.id, index_1.EdgeType.ObjectToFollowedUsers, index_1.NodeType.FakeUser);
+                await builder.saveX();
+                const user2 = await builder.editedEntX();
+                this.users.push(user2);
+            }
+            for (let i = 0; i < 5; i++) {
+                (0, jest_date_mock_1.advanceBy)(100);
+                const builder = (0, index_1.getEventBuilder)(this.user.viewer, (0, test_helpers_1.getEventInput)(this.user));
+                builder.orchestrator.addOutboundEdge(this.user.id, index_1.EdgeType.ObjectToFollowedUsers, index_1.NodeType.FakeUser);
+                await builder.saveX();
+                const event = await builder.editedEntX();
+                this.events.push(event);
+            }
+            //order is users, then events
+            this.expCount = this.ents([...this.users, ...this.events]).length;
+            db_mock_1.QueryRecorder.clearQueries();
+        }
+        getQuery(viewer) {
+            return this.filter(index_1.UserToFollowingQuery.query(viewer || new viewer_1.IDViewer(this.user.id), this.user));
+        }
+        async testIDs() {
+            const ids = await this.getQuery().queryIDs();
+            expect(ids.length).toBe(this.expCount);
+            const expIDs = this.users
+                .map((user) => user.id)
+                .concat(this.events.map((event) => event.id))
+                .reverse();
+            expect(expIDs).toEqual(ids);
+            verifyQuery({
+                length: 1,
+                numQueries: 1,
+                limit: this.limit || ent_1.DefaultLimit,
+            });
+        }
+        // rawCount isn't affected by filters...
+        async testRawCount() {
+            const count = await this.getQuery().queryRawCount();
+            expect(count).toBe(this.expCount);
+            verifyCountQuery({ numQueries: 1, length: 1 });
+        }
+        async testCount() {
+            const count = await this.getQuery().queryCount();
+            expect(count).toBe(this.expCount);
+            verifyQuery({
+                length: 1,
+                numQueries: 1,
+                limit: this.limit || ent_1.DefaultLimit,
+            });
+        }
+        async testEdges() {
+            const edges = await this.getQuery().queryEdges();
+            expect(edges.length).toBe(this.expCount);
+            let userCount = 0;
+            let eventCount = 0;
+            edges.forEach((edge) => {
+                if (edge.id2Type === index_1.NodeType.FakeEvent) {
+                    eventCount++;
+                }
+                if (edge.id2Type === index_1.NodeType.FakeUser) {
+                    userCount++;
+                }
+            });
+            expect(userCount).toBe(this.expCount / 2);
+            expect(eventCount).toBe(this.expCount / 2);
+            verifyQuery({
+                length: 1,
+                numQueries: 1,
+                limit: this.limit || ent_1.DefaultLimit,
+            });
+        }
+        async testEnts() {
+            // privacy...
+            const ents = await this.getQuery().queryEnts();
+            expect(ents.length).toBe(this.expCount);
+            let userCount = 0;
+            let eventCount = 0;
+            ents.forEach((ent) => {
+                if (ent instanceof index_1.FakeEvent) {
+                    eventCount++;
+                }
+                if (ent instanceof index_1.FakeUser) {
+                    userCount++;
+                }
+            });
+            expect(userCount).toBe(this.expCount / 2);
+            expect(eventCount).toBe(this.expCount / 2);
+            // when doing privacy checks, hard to say what will be fetched
+            // verifyQuery({
+            //   // 1 for edges, 1 for users, 1 for events
+            //   length: 3,
+            //   numQueries: 3,
+            //   limit: this.limit || DefaultLimit,
+            // });
+        }
+    }
+    describe("polymorphic id2s", () => {
+        const filter = new PolymorphicID2sTestQueryFilter((q) => {
+            // no filters
+            return q;
+        }, (ents) => {
+            // nothing to do here
+            // reverse because edges are most recent first
+            return ents.reverse();
+        });
+        // TODO not working when it's a beforeAll
+        // working with beforeEach but we should only need to create this data once
+        beforeEach(async () => {
+            await filter.beforeEach();
+        });
+        test("ids", async () => {
+            await filter.testIDs();
+        });
+        test("rawCount", async () => {
+            await filter.testRawCount();
+        });
+        test("count", async () => {
+            await filter.testCount();
+        });
+        test("edges", async () => {
+            await filter.testEdges();
+        });
+        test("ents", async () => {
+            await filter.testEnts();
+        });
+    });
+    describe("privacy", () => {
+        let user;
+        let friendRequests;
+        let user2;
+        beforeEach(async () => {
+            [user, friendRequests] = await (0, test_helpers_1.createUserPlusFriendRequests)();
+            user2 = await (0, test_helpers_1.createTestUser)();
+        });
+        function getQuery(viewer) {
+            return index_1.UserToIncomingFriendRequestsQuery.query(viewer, user.id);
+        }
+        test("ids", async () => {
+            const ids = await getQuery(user2.viewer).queryIDs();
+            expect(ids.length).toBe(0);
+            const idsFromUser = await getQuery(user.viewer).queryIDs();
+            expect(idsFromUser.length).toBe(friendRequests.length);
+        });
+        test("count", async () => {
+            const count = await getQuery(user2.viewer).queryCount();
+            expect(count).toBe(0);
+            const countFromUser = await getQuery(user.viewer).queryCount();
+            expect(countFromUser).toBe(friendRequests.length);
+        });
+        test("rawCount", async () => {
+            const rawCount = await getQuery(user2.viewer).queryRawCount();
+            expect(rawCount).toBe(0);
+            const rawCountFromUser = await getQuery(user.viewer).queryRawCount();
+            expect(rawCountFromUser).toBe(friendRequests.length);
+        });
+        test("edges", async () => {
+            const edges = await getQuery(user2.viewer).queryEdges();
+            expect(edges.length).toBe(0);
+            const edgesFromUser = await getQuery(user.viewer).queryEdges();
+            expect(edgesFromUser.length).toBe(friendRequests.length);
+        });
+        test("ents", async () => {
+            const ents = await getQuery(user2.viewer).queryEnts();
+            expect(ents.length).toBe(0);
+            const entsFromUser = await getQuery(user.viewer).queryEnts();
+            expect(entsFromUser.length).toBe(0);
+            const entsFromUserVCToken = await getQuery(new index_1.ViewerWithAccessToken(user.id, {
+                tokens: {
+                    allow_incoming_friend_request: true,
+                },
+            })).queryEnts();
+            expect(entsFromUserVCToken.length).toBe(friendRequests.length);
+        });
+    });
+    describe("multi-ids privacy", () => {
+        let user;
+        let friendRequests;
+        let user2;
+        let friendRequests2;
+        beforeEach(async () => {
+            [user, friendRequests] = await (0, test_helpers_1.createUserPlusFriendRequests)();
+            [user2, friendRequests2] = await (0, test_helpers_1.createUserPlusFriendRequests)();
+        });
+        function getQuery(viewer) {
+            return index_1.UserToIncomingFriendRequestsQuery.query(viewer || user.viewer, [
+                user.id,
+                user2.id,
+            ]);
+        }
+        test("ids", async () => {
+            const idsMap = await getQuery().queryAllIDs();
+            expect(idsMap.size).toBe(2);
+            expect(idsMap.get(user.id)?.length).toBe(friendRequests.length);
+            expect(idsMap.get(user2.id)?.length).toBe(0);
+        });
+        test("count", async () => {
+            const countMap = await getQuery().queryAllCount();
+            expect(countMap.size).toBe(2);
+            expect(countMap.get(user.id)).toBe(friendRequests.length);
+            expect(countMap.get(user2.id)).toBe(0);
+        });
+        test("count", async () => {
+            const countMap = await getQuery().queryAllRawCount();
+            expect(countMap.size).toBe(2);
+            expect(countMap.get(user.id)).toBe(friendRequests.length);
+            expect(countMap.get(user2.id)).toBe(0);
+        });
+        test("edges", async () => {
+            const edgesMap = await getQuery().queryAllEdges();
+            expect(edgesMap.size).toBe(2);
+            expect(edgesMap.get(user.id)?.length).toBe(friendRequests.length);
+            expect(edgesMap.get(user2.id)?.length).toBe(0);
+        });
+        test("ents", async () => {
+            const entsMap = await getQuery().queryAllEnts();
+            expect(entsMap.size).toBe(2);
+            expect(entsMap.get(user.id)?.length).toBe(0);
+            expect(entsMap.get(user2.id)?.length).toBe(0);
+            const entsMapFromUserVCToken = await getQuery(new index_1.ViewerWithAccessToken(user.id, {
+                tokens: {
+                    allow_incoming_friend_request: true,
+                },
+            })).queryAllEnts();
+            expect(entsMapFromUserVCToken.size).toBe(2);
+            expect(entsMapFromUserVCToken.get(user.id)?.length).toBe(friendRequests.length);
+            expect(entsMapFromUserVCToken.get(user2.id)?.length).toBe(0);
+        });
+    });
 }
 exports.assocTests = assocTests;

package/core/query/shared_test.d.ts

@@ -2,7 +2,7 @@ import { Data, Viewer } from "../base";
 import { FakeUser, FakeContact } from "../../testutils/fake_data/index";
 import { EdgeQuery } from "./query";
 interface options<TData extends Data> {
-    newQuery: (v: Viewer, user: FakeUser) => EdgeQuery<FakeContact, TData>;
+    newQuery: (v: Viewer, user: FakeUser) => EdgeQuery<FakeUser, FakeContact, TData>;
     tableName: string;
     entsLength?: number;
     where: string;

package/core/query/shared_test.js

@@ -20,7 +20,7 @@ class TestQueryFilter {
     }
     async beforeEach() {
         //    console.log("sss");
-        [this.user, this.allContacts] = await test_helpers_1.createAllContacts();
+        [this.user, this.allContacts] = await (0, test_helpers_1.createAllContacts)();
         //    console.log(this.user, this.contacts);
         //    this.allContacts = this.allContacts.reverse();
         this.filteredContacts = this.ents(this.allContacts);
@@ -59,10 +59,10 @@ class TestQueryFilter {
         const q = this.getQuery();
         // TODO sad not generic enough
         if (q instanceof index_1.UserToContactsFkeyQuery) {
-            test_helpers_1.verifyUserToContactRawData(this.user, edges, this.filteredContacts);
+            (0, test_helpers_1.verifyUserToContactRawData)(this.user, edges, this.filteredContacts);
         }
         else {
-            test_helpers_1.verifyUserToContactEdges(this.user, edges, this.filteredContacts);
+            (0, test_helpers_1.verifyUserToContactEdges)(this.user, edges, this.filteredContacts);
         }
     }
     async testEnts() {
@@ -70,7 +70,7 @@ class TestQueryFilter {
         this.verifyEnts(entsMap);
     }
     verifyEnts(ents) {
-        test_helpers_1.verifyUserToContacts(this.user, ents, this.filteredContacts);
+        (0, test_helpers_1.verifyUserToContacts)(this.user, ents, this.filteredContacts);
     }
     async testAll() {
         const query = this.getQuery(new viewer_1.IDViewer(this.user.id));
@@ -156,7 +156,7 @@ const commonTests = (opts) => {
         // based on getContactBuilder
         // so regardless of if we're doing assoc or custom queries, we can get the time
         // from the created_at field
-        return ent_1.getCursor({
+        return (0, ent_1.getCursor)({
             row: contacts[idx],
             col: "createdAt",
             conv: (t) => {
@@ -174,20 +174,20 @@ const commonTests = (opts) => {
     let tdb;
     if (opts.sqlite) {
         // tableName just to make it unique
-        test_db_1.setupSqlite(`sqlite:///shared_test+${opts.tableName}.db`, test_helpers_1.tempDBTables);
+        (0, test_db_1.setupSqlite)(`sqlite:///shared_test+${opts.tableName}.db`, test_helpers_1.tempDBTables);
     }
     beforeAll(async () => {
         // want error on by default in tests?
-        logger_1.setLogLevels(["error", "warn", "info"]);
+        (0, logger_1.setLogLevels)(["error", "warn", "info"]);
         if (opts.livePostgresDB) {
-            tdb = await test_helpers_1.setupTempDB();
+            tdb = await (0, test_helpers_1.setupTempDB)();
         }
     });
     beforeEach(async () => {
         if (opts.livePostgresDB) {
             return;
         }
-        await test_helpers_1.createEdges();
+        await (0, test_helpers_1.createEdges)();
     });
     afterAll(async () => {
         if (opts.livePostgresDB && tdb) {
@@ -338,7 +338,7 @@ const commonTests = (opts) => {
         });
     });
     test("first. after each cursor", async () => {
-        let [user, contacts] = await test_helpers_1.createAllContacts();
+        let [user, contacts] = await (0, test_helpers_1.createAllContacts)();
         contacts = contacts.reverse();
         const edges = await opts.newQuery(getViewer(), user).queryEdges();
         let query;
@@ -406,7 +406,7 @@ const commonTests = (opts) => {
         });
     });
     test("last. before each cursor", async () => {
-        let [user, contacts] = await test_helpers_1.createAllContacts();
+        let [user, contacts] = await (0, test_helpers_1.createAllContacts)();
         contacts = contacts.reverse();
         const edges = await opts.newQuery(getViewer(), user).queryEdges();
         let query;

package/core/viewer.js

@@ -4,6 +4,7 @@ exports.IDViewer = exports.LoggedOutViewer = void 0;
 class LoggedOutViewer {
     constructor(context) {
         this.context = context;
+        this.viewerID = null;
     }
     async viewer() {
         return null;

package/graphql/builtins/connection.js

@@ -5,18 +5,19 @@ const graphql_1 = require("graphql");
 const node_1 = require("./node");
 const edge_1 = require("./edge");
 const page_info_1 = require("../query/page_info");
+// NB: if this changes, need to update renderer.go also
 exports.GraphQLConnectionInterface = new graphql_1.GraphQLInterfaceType({
     name: "Connection",
     description: "connection interface",
     fields: () => ({
         edges: {
-            type: graphql_1.GraphQLNonNull(graphql_1.GraphQLList(graphql_1.GraphQLNonNull(edge_1.GraphQLEdgeInterface))),
+            type: (0, graphql_1.GraphQLNonNull)((0, graphql_1.GraphQLList)((0, graphql_1.GraphQLNonNull)(edge_1.GraphQLEdgeInterface))),
         },
         nodes: {
-            type: graphql_1.GraphQLNonNull(graphql_1.GraphQLList(graphql_1.GraphQLNonNull(node_1.GraphQLNodeInterface))),
+            type: (0, graphql_1.GraphQLNonNull)((0, graphql_1.GraphQLList)((0, graphql_1.GraphQLNonNull)(node_1.GraphQLNodeInterface))),
         },
         pageInfo: {
-            type: graphql_1.GraphQLNonNull(page_info_1.GraphQLPageInfo),
+            type: (0, graphql_1.GraphQLNonNull)(page_info_1.GraphQLPageInfo),
         },
     }),
 });

package/graphql/builtins/edge.js

@@ -3,15 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GraphQLEdgeInterface = void 0;
 const graphql_1 = require("graphql");
 const node_1 = require("./node");
+// NB: if this changes, need to update renderer.go also
 exports.GraphQLEdgeInterface = new graphql_1.GraphQLInterfaceType({
     name: "Edge",
     description: "edge interface",
     fields: () => ({
         node: {
-            type: graphql_1.GraphQLNonNull(node_1.GraphQLNodeInterface),
+            type: (0, graphql_1.GraphQLNonNull)(node_1.GraphQLNodeInterface),
         },
         cursor: {
-            type: graphql_1.GraphQLNonNull(graphql_1.GraphQLString),
+            type: (0, graphql_1.GraphQLNonNull)(graphql_1.GraphQLString),
         },
     }),
 });

package/graphql/builtins/node.js

@@ -2,12 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GraphQLNodeInterface = void 0;
 const graphql_1 = require("graphql");
+// NB: if this changes, need to update renderer.go also
 exports.GraphQLNodeInterface = new graphql_1.GraphQLInterfaceType({
     name: "Node",
     description: "node interface",
     fields: () => ({
         id: {
-            type: graphql_1.GraphQLNonNull(graphql_1.GraphQLID),
+            type: (0, graphql_1.GraphQLNonNull)(graphql_1.GraphQLID),
         },
     }),
 });

package/graphql/graphql.d.ts

@@ -8,6 +8,7 @@ export interface CustomType {
     importPath: string;
     tsType?: string;
     tsImportPath?: string;
+    [x: string]: any;
 }
 declare type Type = GraphQLScalarType | ClassType | string | CustomType;
 export declare type GraphQLConnection<T> = {
@@ -81,6 +82,7 @@ declare enum NullableResult {
     CONTENTS_AND_LIST = "contentsAndList",
     ITEM = "true"
 }
+export declare const addCustomType: (type: CustomType) => void;
 export declare class GQLCapture {
     private static enabled;
     static enable(enabled: boolean): void;