@snowtop/ent 0.0.11 → 0.0.12

package/core/config.d.ts

@@ -12,6 +12,9 @@ interface CodegenConfig {
     defaultEntPolicy?: PrivacyConfig;
     defaultActionPolicy?: PrivacyConfig;
     prettier?: PrettierConfig;
+    relativeImports?: boolean;
+    disableGraphQLRoot?: boolean;
+    generatedHeader?: string;
 }
 interface PrettierConfig {
     custom?: boolean;

package/core/query/assoc_query.d.ts

@@ -4,6 +4,7 @@ import { AssocEdgeCountLoaderFactory } from "../loaders/assoc_count_loader";
 import { AssocEdgeLoaderFactory } from "../loaders/assoc_edge_loader";
 import { EdgeQuery, BaseEdgeQuery } from "./query";
 export declare type EdgeQuerySource<T extends Ent> = T | T[] | ID | ID[] | EdgeQuery<T, AssocEdge>;
+declare type loaderOptionsFunc = (type: string) => LoadEntOptions<Ent>;
 export declare class AssocEdgeQueryBase<TSource extends Ent, TDest extends Ent, TEdge extends AssocEdge> extends BaseEdgeQuery<TDest, TEdge> {
     viewer: Viewer;
     src: EdgeQuerySource<TSource>;
@@ -12,7 +13,7 @@ export declare class AssocEdgeQueryBase<TSource extends Ent, TDest extends Ent,
     private options;
     private idsResolved;
     private resolvedIDs;
-    constructor(viewer: Viewer, src: EdgeQuerySource<TSource>, countLoaderFactory: AssocEdgeCountLoaderFactory, dataLoaderFactory: AssocEdgeLoaderFactory<TEdge>, options: LoadEntOptions<TDest>);
+    constructor(viewer: Viewer, src: EdgeQuerySource<TSource>, countLoaderFactory: AssocEdgeCountLoaderFactory, dataLoaderFactory: AssocEdgeLoaderFactory<TEdge>, options: LoadEntOptions<TDest> | loaderOptionsFunc);
     private resolveIDs;
     private isEdgeQuery;
     private addID;
@@ -28,3 +29,4 @@ export declare class AssocEdgeQueryBase<TSource extends Ent, TDest extends Ent,
 export interface EdgeQueryCtr<T extends Ent, TEdge extends AssocEdge> {
     new (viewer: Viewer, src: EdgeQuerySource<T>): EdgeQuery<T, TEdge>;
 }
+export {};

package/core/query/assoc_query.js

@@ -4,7 +4,10 @@ exports.AssocEdgeQueryBase = void 0;
 const ent_1 = require("../ent");
 const query_1 = require("./query");
 class AssocEdgeQueryBase extends query_1.BaseEdgeQuery {
-    constructor(viewer, src, countLoaderFactory, dataLoaderFactory, options) {
+    constructor(viewer, src, countLoaderFactory, dataLoaderFactory, 
+    // if function, it's a polymorphic edge and need to provide
+    // a function that goes from edgeType to LoadEntOptions
+    options) {
         super(viewer, "time");
         this.viewer = viewer;
         this.src = src;
@@ -70,6 +73,35 @@ class AssocEdgeQueryBase extends query_1.BaseEdgeQuery {
         return results;
     }
     async loadEntsFromEdges(id, edges) {
+        if (typeof this.options === "function") {
+            const m = new Map();
+            for (const edge of edges) {
+                const nodeType = edge.id2Type;
+                let data = m.get(nodeType);
+                if (data === undefined) {
+                    const opts = this.options(nodeType);
+                    if (opts === undefined) {
+                        throw new Error(`getLoaderOptions returned undefined for type ${nodeType}`);
+                    }
+                    data = {
+                        ids: [],
+                        options: opts,
+                    };
+                }
+                data.ids.push(edge.id2);
+                m.set(nodeType, data);
+            }
+            let promises = [];
+            for (const [_, value] of m) {
+                promises.push((0, ent_1.loadEnts)(this.viewer, value.options, ...value.ids));
+            }
+            const entss = await Promise.all(promises);
+            const r = [];
+            for (const ents of entss) {
+                r.push(...ents);
+            }
+            return r;
+        }
         const ids = edges.map((edge) => edge.id2);
         return await (0, ent_1.loadEnts)(this.viewer, this.options, ...ids);
     }

package/core/query/shared_assoc_test.js

@@ -425,5 +425,145 @@ 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();
+        });
+    });
 }
 exports.assocTests = assocTests;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.0.11",
+  "version": "0.0.12",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",
@@ -37,6 +37,9 @@
       "optional": true
     }
   },
+  "engines": {
+    "node": "^16.1.0"
+  },
   "devDependencies": {},
   "scripts": {},
   "bin": {

package/parse_schema/parse.d.ts

@@ -0,0 +1,41 @@
+import { Schema, AssocEdge, AssocEdgeGroup, Action } from "../schema";
+import { ActionField } from "../schema/schema";
+declare enum NullableResult {
+    CONTENTS = "contents",
+    CONTENTS_AND_LIST = "contentsAndList",
+    ITEM = "true"
+}
+declare type ProcessedActionField = Omit<ActionField, "nullable"> & {
+    nullable?: NullableResult;
+};
+declare type ProcessedAssocEdge = Omit<AssocEdge, "actionOnlyFields" | "edgeActions"> & {
+    patternName?: string;
+    edgeActions?: OutputAction[];
+};
+declare type ProcessedSchema = Omit<Schema, "edges" | "actions" | "edgeGroups"> & {
+    actions: OutputAction[];
+    assocEdges: ProcessedAssocEdge[];
+    assocEdgeGroups: ProcessedAssocEdgeGroup[];
+};
+declare type ProcessedAssocEdgeGroup = Omit<AssocEdgeGroup, "edgeAction"> & {
+    edgeAction?: OutputAction;
+};
+declare type OutputAction = Omit<Action, "actionOnlyFields"> & {
+    actionOnlyFields?: ProcessedActionField[];
+};
+interface schemasDict {
+    [key: string]: ProcessedSchema;
+}
+interface ProcessedPattern {
+    name: string;
+    assocEdges: ProcessedAssocEdge[];
+}
+interface patternsDict {
+    [key: string]: ProcessedPattern;
+}
+interface Result {
+    schemas: schemasDict;
+    patterns: patternsDict;
+}
+export declare function parseSchema(potentialSchemas: {}): Result;
+export {};

package/parse_schema/parse.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSchema = void 0;
+function processFields(processedSchema, src) {
+    for (const field of src) {
+        let f = { ...field };
+        f["hasDefaultValueOnCreate"] = field.defaultValueOnCreate != undefined;
+        f["hasDefaultValueOnEdit"] = field.defaultValueOnEdit != undefined;
+        if (field.polymorphic) {
+            // convert boolean into object
+            // we keep boolean as an option to keep API simple
+            if (typeof field.polymorphic === "boolean") {
+                f["polymorphic"] = {};
+            }
+            else {
+                f["polymorphic"] = field.polymorphic;
+            }
+        }
+        processedSchema.fields.push(f);
+    }
+}
+function processEdges(dst, src, patternName) {
+    for (const edge of src) {
+        let edge2 = { ...edge };
+        edge2.edgeActions = edge.edgeActions?.map((action) => processAction(action));
+        edge2.patternName = patternName;
+        dst.push(edge2);
+    }
+}
+function processEdgeGroups(processedSchema, edgeGroups) {
+    // array-ify this
+    for (const group of edgeGroups) {
+        if (group.nullStates && !Array.isArray(group.nullStates)) {
+            group.nullStates = [group.nullStates];
+        }
+        let group2 = { ...group };
+        if (group.edgeAction) {
+            group2.edgeAction = processAction(group.edgeAction);
+        }
+        processedSchema.assocEdgeGroups.push(group2);
+    }
+}
+function processPattern(patterns, pattern, processedSchema) {
+    // TODO kill
+    let name = pattern.name || "node";
+    if (patterns[name] === undefined) {
+        const edges = [];
+        if (pattern.edges) {
+            processEdges(edges, pattern.edges);
+        }
+        patterns[name] = {
+            name: pattern.name,
+            assocEdges: edges,
+        };
+    }
+    else {
+        // TODO ideally we want to make sure that different patterns don't have the same name
+        // can't do a deepEqual check because function calls and therefore different instances in fields
+    }
+    processFields(processedSchema, pattern.fields);
+    if (pattern.edges) {
+        processEdges(processedSchema.assocEdges, pattern.edges, pattern.name);
+    }
+}
+var NullableResult;
+(function (NullableResult) {
+    NullableResult["CONTENTS"] = "contents";
+    NullableResult["CONTENTS_AND_LIST"] = "contentsAndList";
+    NullableResult["ITEM"] = "true";
+})(NullableResult || (NullableResult = {}));
+function processAction(action) {
+    if (!action.actionOnlyFields) {
+        return { ...action };
+    }
+    let ret = { ...action };
+    let actionOnlyFields = action.actionOnlyFields.map((f) => {
+        let f2 = f;
+        if (!f.nullable) {
+            return f2;
+        }
+        if (typeof f.nullable === "boolean") {
+            f2.nullable = NullableResult.ITEM;
+        }
+        else {
+            if (f.nullable === "contentsAndList") {
+                f2.nullable = NullableResult.CONTENTS_AND_LIST;
+            }
+            else {
+                f2.nullable = NullableResult.CONTENTS;
+            }
+        }
+        return f2;
+    });
+    ret.actionOnlyFields = actionOnlyFields;
+    return ret;
+}
+function parseSchema(potentialSchemas) {
+    let schemas = {};
+    let patterns = {};
+    for (const key in potentialSchemas) {
+        const value = potentialSchemas[key];
+        let schema;
+        if (value.constructor == Object) {
+            schema = value;
+        }
+        else {
+            schema = new value();
+        }
+        let processedSchema = {
+            fields: [],
+            tableName: schema.tableName,
+            enumTable: schema.enumTable,
+            dbRows: schema.dbRows,
+            constraints: schema.constraints,
+            indices: schema.indices,
+            hideFromGraphQL: schema.hideFromGraphQL,
+            actions: schema.actions?.map((action) => processAction(action)) || [],
+            assocEdges: [],
+            assocEdgeGroups: [],
+        };
+        // let's put patterns first just so we have id, created_at, updated_at first
+        // ¯\_(ツ)_/¯
+        if (schema.patterns) {
+            for (const pattern of schema.patterns) {
+                processPattern(patterns, pattern, processedSchema);
+            }
+        }
+        processFields(processedSchema, schema.fields);
+        if (schema.edges) {
+            processEdges(processedSchema.assocEdges, schema.edges);
+        }
+        if (schema.edgeGroups) {
+            processEdgeGroups(processedSchema, schema.edgeGroups);
+        }
+        schemas[key] = processedSchema;
+    }
+    return { schemas, patterns };
+}
+exports.parseSchema = parseSchema;

package/schema/base_schema.d.ts

@@ -2,8 +2,10 @@ import { Pattern } from "./schema";
 export declare const Timestamps: Pattern;
 export declare const Node: Pattern;
 export declare abstract class BaseEntSchema {
+    addPatterns(...patterns: Pattern[]): void;
     patterns: Pattern[];
 }
 export declare abstract class BaseEntSchemaWithTZ {
+    addPatterns(...patterns: Pattern[]): void;
     patterns: Pattern[];
 }

package/schema/base_schema.js

@@ -26,6 +26,7 @@ let tsFields = [
 ];
 // Timestamps is a Pattern that adds a createdAt and updatedAt timestamp fields to the ent
 exports.Timestamps = {
+    name: "timestamps",
     fields: tsFields,
 };
 let nodeField = (0, field_1.UUIDType)({
@@ -63,6 +64,7 @@ let nodeFieldsWithTZ = [
 ];
 // Node is a Pattern that adds 3 fields to the ent: (id, createdAt, and updatedAt timestamps)
 exports.Node = {
+    name: "node",
     fields: nodeFields,
 };
 // Base ent schema. has Node Pattern by default.
@@ -71,15 +73,23 @@ class BaseEntSchema {
     constructor() {
         this.patterns = [exports.Node];
     }
+    addPatterns(...patterns) {
+        this.patterns.push(...patterns);
+    }
 }
 exports.BaseEntSchema = BaseEntSchema;
 class BaseEntSchemaWithTZ {
     constructor() {
         this.patterns = [
             {
+                // default schema added
+                name: "nodeWithTZ",
                 fields: nodeFieldsWithTZ,
             },
         ];
     }
+    addPatterns(...patterns) {
+        this.patterns.push(...patterns);
+    }
 }
 exports.BaseEntSchemaWithTZ = BaseEntSchemaWithTZ;

package/schema/schema.d.ts

@@ -24,6 +24,7 @@ export interface AssocEdge {
     tableName?: string;
     edgeActions?: EdgeAction[];
     hideFromGraphQL?: boolean;
+    edgeConstName?: string;
 }
 export interface EdgeAction {
     operation: ActionOperation;
@@ -34,6 +35,7 @@ export interface EdgeAction {
 }
 export interface InverseAssocEdge {
     name: string;
+    edgeConstName?: string;
 }
 export interface EdgeGroupAction {
     operation: ActionOperation.EdgeGroup;
@@ -54,7 +56,9 @@ export interface AssocEdgeGroup {
 }
 export declare type Edge = AssocEdge;
 export interface Pattern {
+    name: string;
     fields: Field[];
+    edges?: Edge[];
 }
 export declare enum DBType {
     UUID = "UUID",

package/scripts/read_schema.js

@@ -27,56 +27,7 @@ const path = __importStar(require("path"));
 const pascal_case_1 = require("pascal-case");
 const minimist_1 = __importDefault(require("minimist"));
 const process_1 = require("process");
-function processFields(dst, src) {
-    for (const field of src) {
-        let f = {};
-        f = field;
-        f["hasDefaultValueOnCreate"] = field.defaultValueOnCreate != undefined;
-        f["hasDefaultValueOnEdit"] = field.defaultValueOnEdit != undefined;
-        if (field.polymorphic) {
-            // convert boolean into object
-            // we keep boolean as an option to keep API simple
-            if (typeof field.polymorphic === "boolean") {
-                f["polymorphic"] = {};
-            }
-            else {
-                f["polymorphic"] = field.polymorphic;
-            }
-        }
-        dst.push(f);
-    }
-}
-var NullableResult;
-(function (NullableResult) {
-    NullableResult["CONTENTS"] = "contents";
-    NullableResult["CONTENTS_AND_LIST"] = "contentsAndList";
-    NullableResult["ITEM"] = "true";
-})(NullableResult || (NullableResult = {}));
-function processAction(action) {
-    if (!action.actionOnlyFields) {
-        return action;
-    }
-    let ret = action;
-    ret.actionOnlyFields = action.actionOnlyFields.map((f) => {
-        let f2 = f;
-        if (!f.nullable) {
-            return f2;
-        }
-        if (typeof f.nullable === "boolean") {
-            f2.nullable = NullableResult.ITEM;
-        }
-        else {
-            if (f.nullable === "contentsAndList") {
-                f2.nullable = NullableResult.CONTENTS_AND_LIST;
-            }
-            else {
-                f2.nullable = NullableResult.CONTENTS;
-            }
-        }
-        return f2;
-    });
-    return ret;
-}
+const parse_1 = require("../parse_schema/parse");
 function main() {
     const options = (0, minimist_1.default)(process.argv.slice(2));
     if (!options.path) {
@@ -96,61 +47,8 @@ function main() {
         potentialSchemas[(0, pascal_case_1.pascalCase)(match[1])] = require(p).default;
     }
     //  console.log(potentialSchemas);
-    let schemas = {};
-    for (const key in potentialSchemas) {
-        const value = potentialSchemas[key];
-        let schema;
-        if (value.constructor == Object) {
-            schema = value;
-        }
-        else {
-            schema = new value();
-        }
-        // let's put patterns first just so we have id, created_at, updated_at first
-        // ¯\_(ツ)_/¯
-        let fields = [];
-        if (schema.patterns) {
-            for (const pattern of schema.patterns) {
-                processFields(fields, pattern.fields);
-            }
-        }
-        processFields(fields, schema.fields);
-        let assocEdges = [];
-        let assocEdgeGroups = [];
-        if (schema.edges) {
-            for (const edge of schema.edges) {
-                let edge2 = edge;
-                edge2.edgeActions = edge.edgeActions?.map((action) => processAction(action));
-                assocEdges.push(edge2);
-            }
-        }
-        if (schema.edgeGroups) {
-            // array-ify this
-            for (const group of schema.edgeGroups) {
-                if (group.nullStates && !Array.isArray(group.nullStates)) {
-                    group.nullStates = [group.nullStates];
-                }
-                let group2 = group;
-                if (group.edgeAction) {
-                    group2.edgeAction = processAction(group.edgeAction);
-                }
-                assocEdgeGroups.push(group2);
-            }
-        }
-        schemas[key] = {
-            tableName: schema.tableName,
-            fields: fields,
-            assocEdges: assocEdges,
-            assocEdgeGroups: assocEdgeGroups,
-            actions: schema.actions?.map((action) => processAction(action)),
-            enumTable: schema.enumTable,
-            dbRows: schema.dbRows,
-            constraints: schema.constraints,
-            indices: schema.indices,
-            hideFromGraphQL: schema.hideFromGraphQL,
-        };
-    }
-    console.log(JSON.stringify(schemas));
+    const result = (0, parse_1.parseSchema)(potentialSchemas);
+    console.log(JSON.stringify(result));
 }
 try {
     main();

package/testutils/db/test_db.js

@@ -354,11 +354,9 @@ class TempDB {
                 await this.dbClient.query(table.create());
             }
             else {
-                //        console.log(table.create());
                 this.sqlite.exec(table.create());
             }
         }
-        //    await this.sqlite.exec("nonsense");
     }
     getSqliteClient() {
         return this.sqlite;

package/testutils/fake_data/const.d.ts

@@ -1,3 +1,4 @@
+import { Ent, LoadEntOptions } from "../../core/base";
 export declare enum EdgeType {
     UserToContacts = "userToContacts",
     UserToFriends = "userToFriends",
@@ -10,7 +11,9 @@ export declare enum EdgeType {
     EventToHosts = "eventToHosts",
     UserToHostedEvents = "userToHostedEvents",
     UserToFriendRequests = "userToFriendRequests",
-    UserToIncomingFriendRequests = "userToIncomingFriendRequests"
+    UserToIncomingFriendRequests = "userToIncomingFriendRequests",
+    UserToFollowing = "userToFollowing",
+    ObjectToFollowedUsers = "objectToFollowedUsers"
 }
 export declare enum NodeType {
     FakeUser = "user",
@@ -19,3 +22,4 @@ export declare enum NodeType {
 }
 export declare const SymmetricEdges: Set<string>;
 export declare const InverseEdges: Map<EdgeType, EdgeType>;
+export declare function getLoaderOptions(type: NodeType): LoadEntOptions<Ent>;

package/testutils/fake_data/const.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InverseEdges = exports.SymmetricEdges = exports.NodeType = exports.EdgeType = void 0;
+exports.getLoaderOptions = exports.InverseEdges = exports.SymmetricEdges = exports.NodeType = exports.EdgeType = void 0;
+const internal_1 = require("./internal");
 var EdgeType;
 (function (EdgeType) {
     EdgeType["UserToContacts"] = "userToContacts";
@@ -16,6 +17,10 @@ var EdgeType;
     EdgeType["UserToHostedEvents"] = "userToHostedEvents";
     EdgeType["UserToFriendRequests"] = "userToFriendRequests";
     EdgeType["UserToIncomingFriendRequests"] = "userToIncomingFriendRequests";
+    // can follow users or events...
+    // so a polymorphic edge
+    EdgeType["UserToFollowing"] = "userToFollowing";
+    EdgeType["ObjectToFollowedUsers"] = "objectToFollowedUsers";
 })(EdgeType = exports.EdgeType || (exports.EdgeType = {}));
 var NodeType;
 (function (NodeType) {
@@ -32,4 +37,17 @@ exports.InverseEdges = new Map([
     [EdgeType.EventToHosts, EdgeType.UserToHostedEvents],
     [EdgeType.UserToFriendRequests, EdgeType.UserToIncomingFriendRequests],
     [EdgeType.UserToIncomingFriendRequests, EdgeType.UserToFriendRequests],
+    [EdgeType.UserToFollowing, EdgeType.ObjectToFollowedUsers],
+    [EdgeType.ObjectToFollowedUsers, EdgeType.UserToFollowing],
 ]);
+function getLoaderOptions(type) {
+    switch (type) {
+        case NodeType.FakeContact:
+            return internal_1.FakeContact.loaderOptions();
+        case NodeType.FakeUser:
+            return internal_1.FakeUser.loaderOptions();
+        case NodeType.FakeEvent:
+            return internal_1.FakeEvent.loaderOptions();
+    }
+}
+exports.getLoaderOptions = getLoaderOptions;

package/testutils/fake_data/fake_user.js

@@ -31,6 +31,8 @@ class FakeUser {
                 privacy_1.AllowIfViewerRule,
                 //can view user if friends
                 new privacy_1.AllowIfViewerInboundEdgeExistsRule(internal_1.EdgeType.UserToFriends),
+                //can view user if following
+                new privacy_1.AllowIfViewerInboundEdgeExistsRule(internal_1.EdgeType.UserToFollowing),
                 new privacy_1.AllowIfConditionAppliesRule((viewer, ent) => {
                     if (!(viewer instanceof ViewerWithAccessToken)) {
                         return false;

package/testutils/fake_data/user_query.d.ts

@@ -1,4 +1,4 @@
-import { ID, Viewer } from "../../core/base";
+import { Ent, ID, Viewer } from "../../core/base";
 import { CustomEdgeQueryBase } from "../../core/query/custom_query";
 import { AssocEdge } from "../../core/ent";
 import * as clause from "../../core/clause";
@@ -81,3 +81,7 @@ export declare class UserToEventsInNextWeekQuery extends CustomEdgeQueryBase<Fak
     constructor(viewer: Viewer, src: ID | FakeUser);
     static query(viewer: Viewer, src: FakeUser | ID): UserToEventsInNextWeekQuery;
 }
+export declare class UserToFollowingQuery extends AssocEdgeQueryBase<FakeUser, Ent, AssocEdge> {
+    constructor(viewer: Viewer, src: EdgeQuerySource<FakeUser>);
+    static query(viewer: Viewer, src: EdgeQuerySource<FakeUser>): UserToFollowingQuery;
+}

package/testutils/fake_data/user_query.js

@@ -19,7 +19,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UserToEventsInNextWeekQuery = exports.userToEventsInNextWeekDataLoaderFactory = exports.userToEventsInNextWeekCountLoaderFactory = exports.getCompleteClause = exports.getNextWeekClause = exports.UserToHostedEventsQuery = exports.UserToEventsAttendingQuery = exports.UserToIncomingFriendRequestsQuery = exports.UserToFriendRequestsQuery = exports.UserToCustomEdgeQuery = exports.CustomEdge = exports.UserToFriendsQuery = exports.UserToContactsFkeyQuery = exports.userToContactsDataLoaderFactory = exports.userToContactsCountLoaderFactory = exports.UserToContactsQuery = void 0;
+exports.UserToFollowingQuery = exports.UserToEventsInNextWeekQuery = exports.userToEventsInNextWeekDataLoaderFactory = exports.userToEventsInNextWeekCountLoaderFactory = exports.getCompleteClause = exports.getNextWeekClause = exports.UserToHostedEventsQuery = exports.UserToEventsAttendingQuery = exports.UserToIncomingFriendRequestsQuery = exports.UserToFriendRequestsQuery = exports.UserToCustomEdgeQuery = exports.CustomEdge = exports.UserToFriendsQuery = exports.UserToContactsFkeyQuery = exports.userToContactsDataLoaderFactory = exports.userToContactsCountLoaderFactory = exports.UserToContactsQuery = void 0;
 const custom_query_1 = require("../../core/query/custom_query");
 const ent_1 = require("../../core/ent");
 const clause = __importStar(require("../../core/clause"));
@@ -34,6 +34,7 @@ const jest_date_mock_1 = require("jest-date-mock");
 const luxon_1 = require("luxon");
 const query_loader_1 = require("../../core/loaders/query_loader");
 const mock_date_1 = require("./../mock_date");
+const _1 = require(".");
 class UserToContactsQuery extends assoc_query_1.AssocEdgeQueryBase {
     constructor(viewer, src) {
         super(viewer, src, new assoc_count_loader_1.AssocEdgeCountLoaderFactory(internal_1.EdgeType.UserToContacts), new assoc_edge_loader_1.AssocEdgeLoaderFactory(internal_1.EdgeType.UserToContacts, ent_1.AssocEdge), internal_1.FakeContact.loaderOptions());
@@ -257,3 +258,12 @@ class UserToEventsInNextWeekQuery extends custom_query_1.CustomEdgeQueryBase {
     }
 }
 exports.UserToEventsInNextWeekQuery = UserToEventsInNextWeekQuery;
+class UserToFollowingQuery extends assoc_query_1.AssocEdgeQueryBase {
+    constructor(viewer, src) {
+        super(viewer, src, new assoc_count_loader_1.AssocEdgeCountLoaderFactory(internal_1.EdgeType.UserToFollowing), new assoc_edge_loader_1.AssocEdgeLoaderFactory(internal_1.EdgeType.UserToFollowing, ent_1.AssocEdge), _1.getLoaderOptions);
+    }
+    static query(viewer, src) {
+        return new UserToFollowingQuery(viewer, src);
+    }
+}
+exports.UserToFollowingQuery = UserToFollowingQuery;