@snowtop/ent 0.1.0-alpha160-test7 → 0.1.0-alpha160

package/graphql/query/shared_assoc_test.d.ts

@@ -0,0 +1 @@
+export declare function sharedAssocTests(): void;

package/graphql/query/shared_assoc_test.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sharedAssocTests = void 0;
+const viewer_1 = require("../../core/viewer");
+const jest_date_mock_1 = require("jest-date-mock");
+const edge_connection_1 = require("./edge_connection");
+const connection_type_1 = require("./connection_type");
+const graphql_1 = require("graphql");
+const node_1 = require("../builtins/node");
+const ent_graphql_tests_1 = require("../../testutils/ent-graphql-tests");
+const index_1 = require("../../testutils/fake_data/index");
+const test_helpers_1 = require("../../testutils/fake_data/test_helpers");
+function sharedAssocTests() {
+    // pretty sure this works for custom ents but need tests for this eventually
+    describe("not all ents visible", () => {
+        let user;
+        let event;
+        let users;
+        let conn;
+        let friendCount;
+        // let's make it big. 20 people
+        let friendsInput = [...test_helpers_1.inputs, ...test_helpers_1.inputs, ...test_helpers_1.inputs, ...test_helpers_1.inputs];
+        beforeEach(async () => {
+            friendCount = 0;
+            user = await (0, test_helpers_1.createTestUser)();
+            event = await (0, test_helpers_1.createTestEvent)(user);
+            let promises = [];
+            for (let i = 0; i < friendsInput.length; i++) {
+                (0, jest_date_mock_1.advanceBy)(100);
+                let input = friendsInput[i];
+                const builder = (0, index_1.getUserBuilder)(user.viewer, (0, test_helpers_1.getUserInput)(input));
+                if (i % 2 == 1) {
+                    builder.orchestrator.addOutboundEdge(user.id, index_1.EdgeType.UserToFriends, "User");
+                    friendCount++;
+                }
+                // invite user to events
+                builder.orchestrator.addInboundEdge(event.id, index_1.EdgeType.EventToInvited, "User", {
+                    // just to make times deterministic so that tests can consistently work
+                    time: new Date(),
+                });
+                promises.push((async function () {
+                    await builder.saveX();
+                    return builder.editedEntX();
+                })());
+            }
+            users = await Promise.all(promises);
+            // only few of the users invited as friends
+            const vc = new viewer_1.IDViewer(user.id);
+            const friendsEdge = await index_1.UserToFriendsQuery.query(vc, user.id).queryEdges();
+            expect(friendsEdge.length).toBe(friendCount);
+            // everyone  invited to event
+            const invitedEventsEdges = await index_1.EventToInvitedQuery.query(vc, event.id).queryEdges();
+            expect(invitedEventsEdges.length).toBe(friendsInput.length);
+            resetConn();
+        });
+        function resetConn() {
+            conn = new edge_connection_1.GraphQLEdgeConnection(new viewer_1.IDViewer(user.id), event, (v, event) => new index_1.EventToInvitedQuery(v, event));
+        }
+        test("totalCount", async () => {
+            const count = await conn.queryTotalCount();
+            expect(count).toBe(users.length);
+        });
+        test("nodes", async () => {
+            const nodes = await conn.queryNodes();
+            expect(nodes.length).toBe(friendCount);
+        });
+        test("edges", async () => {
+            const edges = await conn.queryEdges();
+            expect(edges.length).toBe(friendCount);
+        });
+        test("pagination", async () => {
+            const edges = await index_1.EventToInvitedQuery.query(new viewer_1.LoggedOutViewer(), event).queryEdges();
+            async function verify(first, length, hasNextpage, index) {
+                let cursor;
+                if (index) {
+                    cursor = edges[index].getCursor();
+                }
+                resetConn();
+                conn.first(first, cursor);
+                const [pagination, gqlEdges, nodes] = await Promise.all([
+                    conn.queryPageInfo(),
+                    conn.queryEdges(),
+                    conn.queryNodes(),
+                ]);
+                expect(pagination.hasNextPage, `${index}`).toBe(hasNextpage);
+                expect(pagination.hasPreviousPage, `${index}`).toBe(false);
+                expect(gqlEdges.length, `${index}`).toBe(length);
+                expect(nodes.length, `${index}`).toBe(length);
+                // TODO: not equal even though we're querying only one because the cursors are not privacy-aware
+                // TODO: fix
+            }
+            // TODO build exponential backoff into EntQuery so this isn't needed
+            // but this is how it is for now
+            await verify(1, 1, true);
+            await verify(2, 1, true);
+            await verify(2, 1, true, 0);
+            await verify(2, 1, true, 2);
+            await verify(2, 1, true, 4);
+            await verify(2, 1, true, 6);
+            await verify(2, 1, true, 8);
+            await verify(2, 1, true, 10);
+            await verify(2, 1, true, 12);
+            await verify(2, 1, true, 14);
+            await verify(2, 1, true, 16);
+            await verify(2, 1, false, 17);
+        });
+    });
+    test("custom edge fields", async () => {
+        let userType = new graphql_1.GraphQLObjectType({
+            name: "User",
+            fields: {
+                id: {
+                    type: new graphql_1.GraphQLNonNull(graphql_1.GraphQLID),
+                },
+                firstName: {
+                    type: graphql_1.GraphQLString,
+                },
+                lastName: {
+                    type: graphql_1.GraphQLString,
+                },
+            },
+            interfaces: [node_1.GraphQLNodeInterface],
+            isTypeOf(obj, _context) {
+                return obj instanceof index_1.FakeUser;
+            },
+        });
+        let eventType = new graphql_1.GraphQLObjectType({
+            name: "Event",
+            fields: {
+                id: {
+                    type: new graphql_1.GraphQLNonNull(graphql_1.GraphQLID),
+                },
+            },
+            interfaces: [node_1.GraphQLNodeInterface],
+            isTypeOf(obj, _context) {
+                return obj instanceof index_1.FakeEvent;
+            },
+        });
+        const conn = new connection_type_1.GraphQLConnectionType("CustomEdge", eventType);
+        const length = (m) => {
+            let count = 0;
+            for (let _ in m) {
+                count++;
+            }
+            return count;
+        };
+        const fields = conn.edgeType.getFields();
+        // default.
+        expect(length(fields)).toBe(2);
+        expect(fields["node"]).toBeDefined();
+        expect(fields["cursor"]).toBeDefined();
+        const conn2 = new connection_type_1.GraphQLConnectionType("CustomEdge", eventType, {
+            fields: () => ({
+                bar: {
+                    type: graphql_1.GraphQLString,
+                    resolve() {
+                        return "customEdgeData";
+                    },
+                },
+            }),
+        });
+        const fields2 = conn2.edgeType.getFields();
+        expect(length(fields2)).toBe(3);
+        expect(fields2["bar"]).toBeDefined();
+        expect(fields2["node"]).toBeDefined();
+        expect(fields2["cursor"]).toBeDefined();
+        const user = await (0, test_helpers_1.createTestUser)();
+        const event = await (0, test_helpers_1.createTestEvent)(user);
+        let rootQuery = new graphql_1.GraphQLObjectType({
+            name: "RootQueryType",
+            fields: {
+                conn: {
+                    type: conn2,
+                    async resolve(_source, { id }, context) {
+                        return new edge_connection_1.GraphQLEdgeConnection(new viewer_1.IDViewer(user.id), user, (v, event) => new index_1.UserToHostedEventsQuery(v, event));
+                    },
+                },
+            },
+        });
+        let schema = new graphql_1.GraphQLSchema({
+            query: rootQuery,
+            types: [userType, eventType],
+        });
+        let cfg = {
+            schema: schema,
+            root: "conn",
+            viewer: new viewer_1.IDViewer(user.id),
+            args: {},
+        };
+        await (0, ent_graphql_tests_1.expectQueryFromRoot)(cfg, [
+            "edges",
+            [
+                {
+                    node: {
+                        id: event.id,
+                    },
+                    bar: "customEdgeData",
+                },
+            ],
+        ]);
+    });
+}
+exports.sharedAssocTests = sharedAssocTests;

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.1.0-alpha160-test7",
+  "version": "0.1.0-alpha160",
   "description": "snowtop ent framework",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "index.js",
+  "types": "index.d.ts",
   "directories": {
     "example": "examples"
   },
@@ -45,56 +45,11 @@
   "engines": {
     "node": ">=16.0"
   },
-  "devDependencies": {
-    "@swc/core": "^1.3.57",
-    "@swc/jest": "^0.2.26",
-    "@types/bcryptjs": "^2.4.2",
-    "@types/better-sqlite3": "^7.6.4",
-    "@types/express": "^4.17.15",
-    "@types/glob": "^8.0.0",
-    "@types/graphql-upload": "^8.0.12",
-    "@types/jest": "^29.2.4",
-    "@types/js-yaml": "^4.0.5",
-    "@types/luxon": "^3.1.0",
-    "@types/memoizee": "^0.4.8",
-    "@types/minimist": "^1.2.2",
-    "@types/passport": "^1.0.11",
-    "@types/passport-jwt": "^3.0.8",
-    "@types/pg": "^8.6.6",
-    "@types/pluralize": "0.0.29",
-    "@types/supertest": "^2.0.12",
-    "@types/uuid": "^9.0.0",
-    "better-sqlite3": "^8.4.0",
-    "email-addresses": "^5.0.0",
-    "express": "^4.18.2",
-    "graphql": "^16.6.0",
-    "graphql-helix": "^1.13.0",
-    "graphql-type-json": "^0.3.2",
-    "graphql-upload": "^13.0.0",
-    "jest": "^29.3.1",
-    "jest-date-mock": "^1.0.8",
-    "jest-each": "^29.5.0",
-    "jest-expect-message": "^1.1.3",
-    "jest-mock": "^29.3.1",
-    "node-sql-parser": "^3.9.4",
-    "object-path": "^0.11.8",
-    "pg-copy-streams": "^6.0.5",
-    "pluralize": "^8.0.0",
-    "supertest": "^6.3.3",
-    "ts-jest": "^29.1.0"
-  },
-  "scripts": {
-    "compile": "tsc",
-    "test": "jest",
-    "clean": "rm -rf dist",
-    "prepublish": "npm run clean && npm run compile && node src/setupPackage.js"
-  },
+  "devDependencies": {},
+  "scripts": {},
   "bin": {
-    "ent-custom-graphql": "dist/scripts/custom_graphql.js",
-    "ent-custom-compiler": "dist/scripts/custom_compiler.js",
-    "ent-read-schema": "dist/scripts/read_schema.js",
-    "ent-move-types": "dist/scripts/move-types.js",
-    "ent-migrate-v0.1": "dist/scripts/migrate-v0.1"
+    "ent-custom-graphql": "scripts/custom_graphql.js",
+    "ent-custom-compiler": "scripts/custom_compiler.js"
   },
   "author": "lolopinto",
   "license": "MIT",
@@ -106,4 +61,4 @@
     "url": "https://github.com/lolopinto/ent/issues"
   },
   "homepage": "https://github.com/lolopinto/ent#readme"
-}
+}

package/dist/package.json

@@ -1,64 +0,0 @@
-{
-  "name": "@snowtop/ent",
-  "version": "0.1.0-alpha160-test6",
-  "description": "snowtop ent framework",
-  "main": "index.js",
-  "types": "dist/index.d.ts",
-  "directories": {
-    "example": "examples"
-  },
-  "dependencies": {
-    "@types/node": "^20.2.5",
-    "camel-case": "^4.1.2",
-    "cosmiconfig": "^8.1.3",
-    "dataloader": "^2.2.2",
-    "glob": "^10.2.6",
-    "graph-data-structure": "^3.3.0",
-    "js-yaml": "^4.1.0",
-    "json5": "^2.2.3",
-    "luxon": "^3.3.0",
-    "memoizee": "^0.4.15",
-    "minimist": "^1.2.8",
-    "pascal-case": "^3.1.2",
-    "pg": "^8.11.0",
-    "prettier": "^2.8.8",
-    "snake-case": "^3.0.4",
-    "ts-node": "^10.9.1",
-    "tsconfig-paths": "^4.2.0",
-    "tslib": "^2.5.2",
-    "typescript": "^5.0.4",
-    "uuid": "^9.0.0"
-  },
-  "peerDependencies": {
-    "@swc-node/register": "^1.6.5",
-    "better-sqlite3": "^8.4.0",
-    "graphql": "^16.5.0"
-  },
-  "peerDependenciesMeta": {
-    "better-sqlite3": {
-      "optional": true
-    },
-    "@swc-node/register": {
-      "optional": true
-    }
-  },
-  "engines": {
-    "node": ">=16.0"
-  },
-  "devDependencies": {},
-  "scripts": {},
-  "bin": {
-    "ent-custom-graphql": "scripts/custom_graphql.js",
-    "ent-custom-compiler": "scripts/custom_compiler.js"
-  },
-  "author": "lolopinto",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/lolopinto/ent.git"
-  },
-  "bugs": {
-    "url": "https://github.com/lolopinto/ent/issues"
-  },
-  "homepage": "https://github.com/lolopinto/ent#readme"
-}

package/src/action/action.ts

@@ -1,330 +0,0 @@
-import {
-  Ent,
-  EntConstructor,
-  Viewer,
-  ID,
-  Data,
-  PrivacyPolicy,
-  Context,
-  WriteOperation,
-} from "../core/base";
-import { loadEdgeForID2, AssocEdge } from "../core/ent";
-import { DataOperation, AssocEdgeInputOptions } from "./operations";
-import { Queryer } from "../core/db";
-import { log } from "../core/logger";
-import { TransformedUpdateOperation, UpdateOperation } from "../schema";
-import { FieldInfoMap } from "../schema/schema";
-
-export { WriteOperation };
-
-type MaybeNull<T extends Ent> = T | null;
-type TMaybleNullableEnt<T extends Ent> = T | MaybeNull<T>;
-
-interface BuilderOrchestrator {
-  __getOptions(): {
-    fieldInfo: FieldInfoMap;
-  };
-}
-
-export interface Builder<
-  TEnt extends Ent<TViewer>,
-  TViewer extends Viewer = Viewer,
-  TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>,
-> {
-  existingEnt: TExistingEnt;
-  ent: EntConstructor<TEnt, TViewer>;
-  placeholderID: ID;
-  readonly viewer: TViewer;
-  build(): Promise<Changeset>;
-  buildWithOptions_BETA?(options: ChangesetOptions): Promise<Changeset>;
-  operation: WriteOperation;
-  editedEnt?(): Promise<TEnt | null>;
-  nodeType: string;
-  // TODO TInput in Builder
-  getInput(): Data;
-  // TODO full orchestrator...
-  orchestrator: BuilderOrchestrator;
-}
-
-// PS: this is a private API subject to change
-export interface Executor
-  extends Iterable<DataOperation>,
-    Iterator<DataOperation> {
-  placeholderID: ID;
-  // this returns a non-privacy checked "ent"
-  resolveValue(val: any): Ent | null;
-  builderOpChanged(builder: Builder<any>): boolean;
-  builder?: Builder<Ent>;
-
-  execute(): Promise<void>;
-
-  // TODO add this so we can differentiate btw when ops are being executed?
-  // vs gathered for other use
-  // or change how execute() works?
-  // right now have to reset at the end of next() if we call for (const op of executor) {}
-  // also want to throw if DataOperation.returnedRow or DataOperation.createdEnt
-  // called too early
-  //  getSortedOps(): DataOperation[];
-
-  // these 3 are to help chained/contained executors
-  preFetch?(queryer: Queryer, context?: Context): Promise<void>;
-  postFetch?(queryer: Queryer, context?: Context): Promise<void>;
-  executeObservers?(): Promise<void>;
-}
-
-export interface Changeset {
-  executor(): Executor;
-  viewer: Viewer;
-  placeholderID: ID;
-  //  ent: EntConstructor<T>;
-  changesets?: Changeset[];
-  dependencies?: Map<ID, Builder<Ent>>;
-}
-
-export type TriggerReturn =
-  | void
-  | Promise<Changeset | void | (Changeset | void)[]>
-  | Promise<Changeset>[];
-
-export interface Trigger<
-  TEnt extends Ent<TViewer>,
-  TBuilder extends Builder<TEnt, TViewer, TExistingEnt>,
-  TViewer extends Viewer = Viewer,
-  TInput extends Data = Data,
-  TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>,
-> {
-  // TODO: way in the future. detect any writes happening in changesets and optionally throw if configured to do so
-  // can throw if it wants. not expected to throw tho.
-  // input passed in here !== builder.getInput()
-  // builder.getInput() can have other default fields
-  changeset(builder: TBuilder, input: TInput): TriggerReturn;
-}
-
-export interface Observer<
-  TEnt extends Ent<TViewer>,
-  TBuilder extends Builder<TEnt, TViewer, TExistingEnt>,
-  TViewer extends Viewer = Viewer,
-  TInput extends Data = Data,
-  TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>,
-> {
-  // input passed in here !== builder.getInput()
-  // builder.getInput() can have other default fields
-  observe(builder: TBuilder, input: TInput): void | Promise<void>;
-}
-
-export interface Validator<
-  TEnt extends Ent<TViewer>,
-  TBuilder extends Builder<TEnt, TViewer, TExistingEnt>,
-  TViewer extends Viewer = Viewer,
-  TInput extends Data = Data,
-  TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>,
-> {
-  // can throw if it wants
-  // input passed in here !== builder.getInput()
-  // builder.getInput() can have other default fields
-  validate(
-    builder: TBuilder,
-    input: TInput,
-  ): Promise<void | undefined | Error> | void | Error | undefined;
-}
-
-export interface ChangesetOptions {
-  // conditional on builder operation remaining the same
-  // TODO I don't really like this
-  // https://github.com/lolopinto/ent/issues/1437
-  conditionalBuilder: Builder<any, any>;
-}
-
-export interface Action<
-  TEnt extends Ent<TViewer>,
-  TBuilder extends Builder<TEnt, TViewer, TExistingEnt>,
-  TViewer extends Viewer = Viewer,
-  TInput extends Data = Data,
-  TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>,
-> {
-  readonly viewer: Viewer;
-  changeset(): Promise<Changeset>;
-  changesetWithOptions_BETA?(options: ChangesetOptions): Promise<Changeset>;
-  builder: TBuilder;
-  getPrivacyPolicy(): PrivacyPolicy<TEnt>;
-
-  // we allow grouping triggers to indicate dependency trees
-  // so that you can say one or more triggers is higher priority
-  // than the others and should be run first
-  // any encountered list is a different priority from prior and subsequent triggers
-  getTriggers?(): (
-    | Trigger<TEnt, TBuilder, TViewer, TInput, TExistingEnt>
-    | Trigger<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[]
-  )[];
-  getObservers?(): Observer<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[];
-  getValidators?(): Validator<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[];
-  getInput(): TInput; // this input is passed to Triggers, Observers, Validators
-  transformWrite?: (
-    stmt: UpdateOperation<TEnt, TViewer>,
-  ) =>
-    | Promise<TransformedUpdateOperation<TEnt, TViewer>>
-    | TransformedUpdateOperation<TEnt, TViewer>
-    | null;
-
-  valid(): Promise<boolean>;
-  // throws if invalid
-  validX(): Promise<void>;
-
-  // this is used to load the ent after the action
-  // you can imagine this being overwritten for a create user or create account
-  // action to load the just-created user after the fact
-  viewerForEntLoad?(
-    data: Data,
-    context?: Context<TViewer>,
-  ): TViewer | Promise<TViewer>;
-
-  // if we have overloads we need to provide all which sucks
-  // so maybe don't make the ones below required
-  // save(): Promise<T | null>;
-  // save(): Promise<void>;
-  // saveX(): Promise<T>;
-  // saveX(): Promise<T>;
-}
-
-export async function saveBuilder<
-  TEnt extends Ent<TViewer>,
-  TViewer extends Viewer,
->(builder: Builder<TEnt, TViewer>): Promise<void> {
-  await saveBuilderImpl(builder, false);
-}
-
-export async function saveBuilderX<
-  TEnt extends Ent<TViewer>,
-  TViewer extends Viewer,
->(builder: Builder<TEnt, TViewer>): Promise<void> {
-  await saveBuilderImpl(builder, true);
-}
-
-async function saveBuilderImpl<
-  TEnt extends Ent<TViewer>,
-  TViewer extends Viewer,
->(builder: Builder<TEnt, TViewer>, throwErr: boolean): Promise<void> {
-  let changeset: Changeset;
-  try {
-    changeset = await builder.build();
-  } catch (e) {
-    log("error", e);
-    if (throwErr) {
-      throw e;
-    } else {
-      // expected...
-      return;
-    }
-  }
-  const executor = changeset.executor();
-  if (throwErr) {
-    return executor.execute();
-  } else {
-    try {
-      return executor.execute();
-    } catch (e) {
-      // it's already caught and logged upstream
-    }
-  }
-}
-
-// Orchestrator in orchestrator.ts in generated Builders
-// we indicate the API we expect here. Not typing it to Orchestrator class in Orchestrator.ts
-// for flexibility
-interface Orchestrator {
-  addOutboundEdge<T2 extends Ent>(
-    id2: ID | Builder<T2>,
-    edgeType: string,
-    nodeType: string,
-    options?: AssocEdgeInputOptions,
-  ): void;
-  removeOutboundEdge(id2: ID, edgeType: string): void;
-  viewer: Viewer;
-}
-
-async function modifyEdgeSet<T extends string>(
-  orchestrator: Orchestrator,
-  id1: ID,
-  id2: ID,
-  inputEnumValue: string,
-  enumValue: string,
-  edgeType: T,
-  nodeType: string,
-) {
-  let edge = await loadEdgeForID2({
-    id1: id1,
-    id2: id2,
-    edgeType: edgeType,
-    ctr: AssocEdge,
-    context: orchestrator.viewer.context,
-  });
-  // always add the edge because the data field may be getting overwritten later on
-  // and we need to give that operation a chance to succeed
-  // TODO: can save a write here by checking in EdgeOperation and not doing this write if nothing
-  // has changed.
-  if (inputEnumValue === enumValue) {
-    orchestrator.addOutboundEdge(id2, edgeType, nodeType);
-  }
-  if (edge) {
-    if (enumValue !== inputEnumValue) {
-      orchestrator.removeOutboundEdge(id2, edgeType);
-    }
-  }
-}
-
-// This sets one edge in a group
-// used for assoc groups where setting the value of one edge in the group
-// unsets the other
-// e.g. 3 states for event rsvp: attending, maybe, declined. user can't be rsvped as more than one at a time so this helps you
-// so that setting an rsvp status for one clears the others (if set)
-// or for friendship status: incoming_friend_request, outgoing_friend_request, are_friends
-// accepting a friend request should clear an incoming or outgoing friend request
-// @args
-// orchestrator: see interface
-// inputEnumValue: the value of the enum. should be one of the keys of m
-// id1: source ID in Orchestrator. We take this as extra param because we need it to check if edge exists
-// id2: target id
-// nodeType: nodeType of ent in question
-// m: Map<enumType, to EdgeType to check>
-export async function setEdgeTypeInGroup<T extends string>(
-  orchestrator: Orchestrator,
-  inputEnumValue: string,
-  id1: ID,
-  id2: ID,
-  nodeType: string,
-  m: Map<T, string>,
-) {
-  let promises: Promise<void>[] = [];
-  for (const [k, v] of m) {
-    promises.push(
-      modifyEdgeSet(orchestrator, id1, id2, inputEnumValue, k, v, nodeType),
-    );
-  }
-  await Promise.all(promises);
-}
-
-export async function clearEdgeTypeInGroup<T extends string>(
-  orchestrator: Orchestrator,
-  id1: ID,
-  id2: ID,
-  m: Map<T, string>,
-) {
-  let promises: Promise<void>[] = [];
-  for (const [_, edgeType] of m) {
-    promises.push(
-      (async () => {
-        let edge = await loadEdgeForID2({
-          id1,
-          id2,
-          edgeType,
-          ctr: AssocEdge,
-          context: orchestrator.viewer.context,
-        });
-        if (edge) {
-          orchestrator.removeOutboundEdge(id2, edgeType);
-        }
-      })(),
-    );
-  }
-  await Promise.all(promises);
-}