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

package/src/core/ent.ts

@@ -0,0 +1,1740 @@
+import DB, {
+  Dialect,
+  Queryer,
+  SyncQueryer,
+  QueryResult,
+  QueryResultRow,
+} from "./db";
+import {
+  Viewer,
+  Ent,
+  ID,
+  LoadRowsOptions,
+  LoadRowOptions,
+  Data,
+  DataOptions,
+  QueryableDataOptions,
+  EditRowOptions,
+  LoadEntOptions,
+  LoadCustomEntOptions,
+  EdgeQueryableDataOptions,
+  Context,
+  SelectDataOptions,
+  CreateRowOptions,
+  QueryDataOptions,
+  EntConstructor,
+  PrivacyPolicy,
+  SelectCustomDataOptions,
+  PrimableLoader,
+  Loader,
+  LoaderWithLoadMany,
+} from "./base";
+
+import { applyPrivacyPolicy, applyPrivacyPolicyImpl } from "./privacy";
+
+import * as clause from "./clause";
+import { log, logEnabled, logTrace } from "./logger";
+import DataLoader from "dataloader";
+import { __getGlobalSchema } from "./global_schema";
+import { OrderBy, getOrderByPhrase } from "./query_impl";
+import { CacheMap } from "./loaders/loader";
+
+class entCacheMap<TViewer extends Viewer, TEnt extends Ent<TViewer>> {
+  private m = new Map();
+  private logEnabled = false;
+  constructor(
+    private viewer: TViewer,
+    private options: LoadEntOptions<TEnt, TViewer>,
+  ) {
+    this.logEnabled = logEnabled("cache");
+  }
+
+  get(id: ID) {
+    const ret = this.m.get(id);
+    if (this.logEnabled && ret) {
+      const key = getEntKey(this.viewer, id, this.options);
+      log("cache", {
+        "ent-cache-hit": key,
+      });
+    }
+    return ret;
+  }
+
+  set(key: string, value: any) {
+    return this.m.set(key, value);
+  }
+
+  delete(key: string) {
+    return this.m.delete(key);
+  }
+
+  clear() {
+    return this.m.clear();
+  }
+}
+
+function createAssocEdgeConfigLoader(options: SelectDataOptions) {
+  const loaderOptions: DataLoader.Options<ID, Data | null> = {};
+
+  // if query logging is enabled, we should log what's happening with loader
+  if (logEnabled("query")) {
+    loaderOptions.cacheMap = new CacheMap(options);
+  }
+
+  // something here brokwn with strict:true
+  return new DataLoader<ID, Data | null>(async (ids: ID[]) => {
+    if (!ids.length) {
+      return [];
+    }
+    let col = options.key;
+    // defaults to uuid
+    let typ = options.keyType || "uuid";
+
+    const rowOptions: LoadRowOptions = {
+      ...options,
+      clause: clause.DBTypeIn(col, ids, typ),
+    };
+
+    // TODO is there a better way of doing this?
+    // context not needed because we're creating a loader which has its own cache which is being used here
+    const nodes = await loadRows(rowOptions);
+    let result: (Data | null)[] = ids.map((id) => {
+      for (const node of nodes) {
+        if (node[col] === id) {
+          return node;
+        }
+      }
+      return null;
+    });
+
+    return result;
+  }, loaderOptions);
+}
+
+// used to wrap errors that would eventually be thrown in ents
+// not an Error because DataLoader automatically rejects that
+class ErrorWrapper {
+  constructor(public error: Error) {}
+}
+
+// note if storing the result of this in something that checks instanceof Error e.g. DataLoader, we need to check instanceof at that callsite
+export function rowIsError(row: any): row is Error {
+  // jest does things that break instanceof checks
+  // so we need to check the name as well for native error SqliteError
+  return row instanceof Error || row?.constructor?.name === "SqliteError";
+}
+
+function createEntLoader<TEnt extends Ent<TViewer>, TViewer extends Viewer>(
+  viewer: Viewer,
+  options: LoadEntOptions<TEnt, TViewer>,
+  map: entCacheMap<TViewer, TEnt>,
+): DataLoader<ID, TEnt | ErrorWrapper> {
+  // share the cache across loaders even if we create a new instance
+  const loaderOptions: DataLoader.Options<any, any> = {};
+  loaderOptions.cacheMap = map;
+
+  return new DataLoader(async (ids: ID[]) => {
+    if (!ids.length) {
+      return [];
+    }
+
+    let result: (TEnt | ErrorWrapper | Error)[] = [];
+
+    const tableName = options.loaderFactory.options?.tableName;
+    const loader = options.loaderFactory.createLoader(viewer.context);
+    const rows = await loader.loadMany(ids);
+    // this is a loader which should return the same order based on passed-in ids
+    // so let's depend on that...
+
+    for (let idx = 0; idx < rows.length; idx++) {
+      const row = rows[idx];
+
+      // db error
+      if (rowIsError(row)) {
+        if (row instanceof Error) {
+          result[idx] = row;
+        } else {
+          // @ts-ignore SqliteError
+          result[idx] = new Error(row.message);
+        }
+        continue;
+      } else if (!row) {
+        if (tableName) {
+          result[idx] = new ErrorWrapper(
+            new Error(
+              `couldn't find row for value ${ids[idx]} in table ${tableName}`,
+            ),
+          );
+        } else {
+          result[idx] = new ErrorWrapper(
+            new Error(`couldn't find row for value ${ids[idx]}`),
+          );
+        }
+      } else {
+        const r = await applyPrivacyPolicyForRowImpl(viewer, options, row);
+        if (rowIsError(r)) {
+          result[idx] = new ErrorWrapper(r);
+        } else {
+          result[idx] = r;
+        }
+      }
+    }
+
+    return result;
+  }, loaderOptions);
+}
+
+class EntLoader<TViewer extends Viewer, TEnt extends Ent<TViewer>>
+  implements LoaderWithLoadMany<ID, TEnt | ErrorWrapper | Error>
+{
+  private loader: DataLoader<ID, TEnt | ErrorWrapper>;
+  private map: entCacheMap<TViewer, TEnt>;
+
+  constructor(
+    private viewer: TViewer,
+    private options: LoadEntOptions<TEnt, TViewer>,
+  ) {
+    this.map = new entCacheMap(viewer, options);
+    this.loader = createEntLoader(this.viewer, this.options, this.map);
+  }
+
+  getMap() {
+    return this.map;
+  }
+
+  async load(id: ID): Promise<TEnt | ErrorWrapper> {
+    return this.loader.load(id);
+  }
+
+  async loadMany(ids: ID[]): Promise<Array<TEnt | ErrorWrapper | Error>> {
+    return this.loader.loadMany(ids);
+  }
+
+  prime(id: ID, ent: TEnt | ErrorWrapper) {
+    this.loader.prime(id, ent);
+  }
+
+  clear(id: ID) {
+    this.loader.clear(id);
+  }
+
+  clearAll() {
+    this.loader.clearAll();
+  }
+}
+
+export function getEntLoader<TViewer extends Viewer, TEnt extends Ent<TViewer>>(
+  viewer: TViewer,
+  options: LoadEntOptions<TEnt, TViewer>,
+): EntLoader<TViewer, TEnt> {
+  if (!viewer.context?.cache) {
+    return new EntLoader(viewer, options);
+  }
+  const name = `ent-loader:${viewer.instanceKey()}:${
+    options.loaderFactory.name
+  }`;
+
+  return viewer.context.cache.getLoaderWithLoadMany(
+    name,
+    () => new EntLoader(viewer, options),
+  ) as EntLoader<TViewer, TEnt>;
+}
+
+export function getEntKey<TEnt extends Ent<TViewer>, TViewer extends Viewer>(
+  viewer: TViewer,
+  id: ID,
+  options: LoadEntOptions<TEnt, TViewer>,
+) {
+  return `${viewer.instanceKey()}:${options.loaderFactory.name}:${id}`;
+}
+
+export async function loadEnt<
+  TEnt extends Ent<TViewer>,
+  TViewer extends Viewer,
+>(
+  viewer: TViewer,
+  id: ID,
+  options: LoadEntOptions<TEnt, TViewer>,
+): Promise<TEnt | null> {
+  if (
+    typeof id !== "string" &&
+    typeof id !== "number" &&
+    typeof id !== "bigint"
+  ) {
+    throw new Error(`invalid id ${id} passed to loadEnt`);
+  }
+  const r = await getEntLoader(viewer, options).load(id);
+  return r instanceof ErrorWrapper ? null : r;
+}
+
+async function applyPrivacyPolicyForRowAndStoreInEntLoader<
+  TEnt extends Ent<TViewer>,
+  TViewer extends Viewer,
+>(
+  viewer: TViewer,
+  row: Data,
+  options: LoadEntOptions<TEnt, TViewer>,
+  // can pass in loader when calling this for multi-id cases...
+  loader?: EntLoader<TViewer, TEnt>,
+) {
+  if (!loader) {
+    loader = getEntLoader(viewer, options);
+  }
+  // TODO every row.id needs to be audited...
+  // https://github.com/lolopinto/ent/issues/1064
+  const id = row.id;
+
+  // we should check the ent loader cache to see if this is already there
+  // TODO hmm... we eventually need a custom data-loader for this too so that it's all done correctly if there's a complicated fetch deep down in graphql
+  const result = loader.getMap().get(id);
+  if (result !== undefined) {
+    return result;
+  }
+
+  const r = await applyPrivacyPolicyForRowImpl(viewer, options, row);
+  if (rowIsError(r)) {
+    loader.prime(id, new ErrorWrapper(r));
+    return new ErrorWrapper(r);
+  } else {
+    loader.prime(id, r);
+    return r;
+  }
+}
+
+// this is the same implementation-wise (right now) as loadEnt. it's just clearer that it's not loaded via ID.
+// used for load via email address etc
+export async function loadEntViaKey<
+  TEnt extends Ent<TViewer>,
+  TViewer extends Viewer,
+>(
+  viewer: TViewer,
+  key: any,
+  options: LoadEntOptions<TEnt, TViewer>,
+): Promise<TEnt | null> {
+  const row = await options.loaderFactory
+    .createLoader(viewer.context)
+    .load(key);
+  if (!row) {
+    return null;
+  }
+
+  const r = await applyPrivacyPolicyForRowAndStoreInEntLoader(
+    viewer,
+    row,
+    options,
+  );
+  return r instanceof ErrorWrapper ? null : r;
+}
+
+export async function loadEntX<
+  TEnt extends Ent<TViewer>,
+  TViewer extends Viewer,
+>(
+  viewer: TViewer,
+  id: ID,
+  options: LoadEntOptions<TEnt, TViewer>,
+): Promise<TEnt> {
+  if (
+    typeof id !== "string" &&
+    typeof id !== "number" &&
+    typeof id !== "bigint"
+  ) {
+    throw new Error(`invalid id ${id} passed to loadEntX`);
+  }
+  const r = await getEntLoader(viewer, options).load(id);
+  if (r instanceof ErrorWrapper) {
+    throw r.error;
+  }
+  return r;
+}
+
+export async function loadEntXViaKey<
+  TEnt extends Ent<TViewer>,
+  TViewer extends Viewer,
+>(
+  viewer: TViewer,
+  key: any,
+  options: LoadEntOptions<TEnt, TViewer>,
+): Promise<TEnt> {
+  const row = await options.loaderFactory
+    .createLoader(viewer.context)
+    .load(key);
+  if (!row) {
+    // todo make this better
+    throw new Error(
+      `${options.loaderFactory.name}: couldn't find row for value ${key}`,
+    );
+  }
+  const r = await applyPrivacyPolicyForRowAndStoreInEntLoader(
+    viewer,
+    row,
+    options,
+  );
+  if (r instanceof ErrorWrapper) {
+    throw r.error;
+  }
+  return r;
+}
+
+/**
+ * @deprecated use loadCustomEnts
+ */
+export async function loadEntFromClause<
+  TEnt extends Ent<TViewer>,
+  TViewer extends Viewer,
+>(
+  viewer: TViewer,
+  options: LoadEntOptions<TEnt, TViewer>,
+  clause: clause.Clause,
+): Promise<TEnt | null> {
+  const rowOptions: LoadRowOptions = {
+    ...options,
+    clause: clause,
+    context: viewer.context,
+  };
+  const row = await loadRow(rowOptions);
+  if (row === null) {
+    return null;
+  }
+  return applyPrivacyPolicyForRow(viewer, options, row);
+}
+
+// same as loadEntFromClause
+// only works for ents where primary key is "id"
+// use loadEnt with a loaderFactory if different
+/**
+ * @deprecated use loadCustomEnts
+ */
+export async function loadEntXFromClause<
+  TEnt extends Ent<TViewer>,
+  TViewer extends Viewer,
+>(
+  viewer: TViewer,
+  options: LoadEntOptions<TEnt, TViewer>,
+  clause: clause.Clause,
+): Promise<TEnt> {
+  const rowOptions: LoadRowOptions = {
+    ...options,
+    clause: clause,
+    context: viewer.context,
+  };
+  const row = await loadRowX(rowOptions);
+  return await applyPrivacyPolicyForRowX(viewer, options, row);
+}
+
+export async function loadEnts<
+  TEnt extends Ent<TViewer>,
+  TViewer extends Viewer,
+>(
+  viewer: TViewer,
+  options: LoadEntOptions<TEnt, TViewer>,
+  ...ids: ID[]
+): Promise<Map<ID, TEnt>> {
+  if (!ids.length) {
+    return new Map();
+  }
+
+  // result
+  let m: Map<ID, TEnt> = new Map();
+
+  const ret = await getEntLoader(viewer, options).loadMany(ids);
+  for (const r of ret) {
+    if (rowIsError(r)) {
+      throw r;
+    }
+    if (r instanceof ErrorWrapper) {
+      continue;
+    }
+
+    m.set(r.id, r);
+  }
+
+  return m;
+}
+
+// calls loadEnts and returns the results sorted in the order they were passed in
+// useful for EntQuery and other paths where the order matters
+export async function loadEntsList<
+  TEnt extends Ent<TViewer>,
+  TViewer extends Viewer,
+>(
+  viewer: TViewer,
+  options: LoadEntOptions<TEnt, TViewer>,
+  ...ids: ID[]
+): Promise<TEnt[]> {
+  const m = await loadEnts(viewer, options, ...ids);
+  const result: TEnt[] = [];
+  ids.forEach((id) => {
+    let ent = m.get(id);
+    if (ent) {
+      result.push(ent);
+    }
+  });
+  return result;
+}
+
+// we return a map here so that any sorting for queries that exist
+// can be done in O(N) time
+/**
+ * @deperecated use loadCustomEnts
+ */
+export async function loadEntsFromClause<
+  TEnt extends Ent<TViewer>,
+  TViewer extends Viewer,
+>(
+  viewer: TViewer,
+  clause: clause.Clause,
+  options: LoadEntOptions<TEnt, TViewer>,
+): Promise<Map<ID, TEnt>> {
+  const rowOptions: LoadRowOptions = {
+    ...options,
+    clause: clause,
+    context: viewer.context,
+  };
+
+  const rows = await loadRows(rowOptions);
+  return applyPrivacyPolicyForRowsDeprecated(viewer, rows, options);
+}
+
+export async function loadCustomEnts<
+  TEnt extends Ent<TViewer>,
+  TViewer extends Viewer,
+  TQueryData extends Data = Data,
+  TResultData extends Data = TQueryData,
+  TKey = keyof TQueryData,
+>(
+  viewer: TViewer,
+  options: LoadCustomEntOptions<TEnt, TViewer, TResultData>,
+  query: CustomQuery<TQueryData, TKey>,
+) {
+  const rows = await loadCustomData<TQueryData, TResultData, TKey>(
+    options,
+    query,
+    viewer.context,
+  );
+
+  return applyPrivacyPolicyForRows(viewer, rows, options);
+}
+
+export interface parameterizedQueryOptions {
+  query: string;
+  values?: any[];
+  logValues?: any[];
+}
+
+export type CustomQuery<T extends Data = Data, K = keyof T> =
+  | string
+  | parameterizedQueryOptions
+  | clause.Clause<T, K>
+  | QueryDataOptions<T, K>;
+
+function isClause<T extends Data = Data, K = keyof T>(
+  opts:
+    | clause.Clause<T, K>
+    | QueryDataOptions<T, K>
+    | parameterizedQueryOptions,
+): opts is clause.Clause<T, K> {
+  const cls = opts as clause.Clause<T, K>;
+
+  return cls.clause !== undefined && cls.values !== undefined;
+}
+
+function isParameterizedQuery<T extends Data = Data, K = keyof T>(
+  opts: QueryDataOptions<T, K> | parameterizedQueryOptions,
+): opts is parameterizedQueryOptions {
+  return (opts as parameterizedQueryOptions).query !== undefined;
+}
+
+/**
+ * Note that if there's default read transformations (e.g. soft delete) and a clause is passed in
+ * either as Clause or QueryDataOptions without {disableTransformations: true}, the default transformation
+ * (e.g. soft delete) is applied.
+ *
+ * Passing a full SQL string or Paramterized SQL string doesn't apply it and the given string is sent to the
+ * database as written.
+ *
+ * e.g.
+ * Foo.loadCustom(opts, 'SELECT * FROM foo') // doesn't change the query
+ * Foo.loadCustom(opts, { query: 'SELECT * FROM foo WHERE id = ?', values: [1]}) // doesn't change the query
+ * Foo.loadCustom(opts, query.Eq('time', Date.now())) // changes the query
+ * Foo.loadCustom(opts, {
+ *   clause:  query.LessEq('time', Date.now()),
+ *   limit: 100,
+ *   orderby: 'time',
+ *  }) // changes the query
+ * Foo.loadCustom(opts, {
+ *   clause:  query.LessEq('time', Date.now()),
+ *   limit: 100,
+ *   orderby: 'time',
+ *   disableTransformations: false
+ *  }) // doesn't change the query
+ *
+ * For queries that pass in a clause, we batch them with an underlying dataloader so that multiple queries with the same clause
+ * or parallel queries with the same clause are batched together.
+ *
+ * If a raw or parameterized query is passed in, we don't attempt to batch them together and they're executed as is.
+ * If you end up with a scenario where you may need to coalesce or batch (non-clause) queries here, you should use some kind of memoization here.
+ */
+export async function loadCustomData<
+  TQueryData extends Data = Data,
+  TResultData extends Data = TQueryData,
+  K = keyof TQueryData,
+>(
+  options: SelectCustomDataOptions<TResultData>,
+  query: CustomQuery<TQueryData, K>,
+  context: Context | undefined,
+): Promise<TResultData[]> {
+  const rows = await loadCustomDataImpl<TQueryData, TResultData, K>(
+    options,
+    query,
+    context,
+  );
+
+  // prime the data so that subsequent fetches of the row with this id are a cache hit.
+  if (options.prime) {
+    const loader = options.loaderFactory.createLoader(context);
+    if (isPrimableLoader(loader) && loader.primeAll !== undefined) {
+      for (const row of rows) {
+        loader.primeAll(row);
+      }
+    }
+  }
+  return rows;
+}
+
+// NOTE: if you use a raw query or paramterized query with this,
+// you should use `SELECT count(*) as count...`
+export async function loadCustomCount<T extends Data = Data, K = keyof T>(
+  options: SelectCustomDataOptions<T>,
+  query: CustomQuery<T, K>,
+  context: Context | undefined,
+): Promise<number> {
+  // if clause, we'll use the loader and strong typing/coalescing it provides
+  if (typeof query !== "string" && isClause(query)) {
+    return options.loaderFactory.createCountLoader<K>(context).load(query);
+  }
+
+  const rows = await loadCustomDataImpl(
+    {
+      ...options,
+      fields: ["count(1) as count"],
+    },
+    query,
+    context,
+  );
+
+  if (rows.length) {
+    return parseInt(rows[0].count);
+  }
+  return 0;
+}
+
+function isPrimableLoader(
+  loader: Loader<any, Data | null>,
+): loader is PrimableLoader<any, Data> {
+  return (loader as PrimableLoader<any, Data>) != undefined;
+}
+
+async function loadCustomDataImpl<
+  TQueryData extends Data = Data,
+  TResultData extends Data = TQueryData,
+  K = keyof TQueryData,
+>(
+  options: SelectCustomDataOptions<TResultData>,
+  query: CustomQuery<TQueryData, K>,
+  context: Context | undefined,
+): Promise<TResultData[]> {
+  if (typeof query === "string") {
+    // no caching, perform raw query
+    return performRawQuery(query, [], []) as Promise<TResultData[]>;
+  } else if (isClause(query)) {
+    const r = await options.loaderFactory
+      .createTypedLoader<TQueryData, TResultData, K>(context)
+      .load(query);
+    return r as unknown as TResultData[];
+  } else if (isParameterizedQuery(query)) {
+    // no caching, perform raw query
+    return performRawQuery(
+      query.query,
+      query.values || [],
+      query.logValues,
+    ) as Promise<TResultData[]>;
+  } else {
+    // this will have rudimentary caching but nothing crazy
+    let cls = query.clause;
+    if (!query.disableTransformations) {
+      cls = clause.getCombinedClause(
+        options.loaderFactory.options,
+        query.clause,
+      );
+    }
+    return loadRows({
+      ...query,
+      ...options,
+      context: context,
+      // @ts-expect-error
+      clause: cls,
+    }) as Promise<TResultData[]>;
+  }
+}
+
+// Derived ents
+// no ent caching
+export async function loadDerivedEnt<
+  TEnt extends Ent<TViewer>,
+  TViewer extends Viewer,
+>(
+  viewer: TViewer,
+  data: Data,
+  loader: new (viewer: TViewer, data: Data) => TEnt,
+): Promise<TEnt | null> {
+  const ent = new loader(viewer, data);
+  const r = await applyPrivacyPolicyForEnt(viewer, ent, data, {
+    ent: loader,
+  });
+  if (rowIsError(r)) {
+    return null;
+  }
+  return r as TEnt | null;
+}
+
+// won't have caching yet either
+export async function loadDerivedEntX<
+  TEnt extends Ent<TViewer>,
+  TViewer extends Viewer,
+>(
+  viewer: TViewer,
+  data: Data,
+  loader: new (viewer: TViewer, data: Data) => TEnt,
+): Promise<TEnt> {
+  const ent = new loader(viewer, data);
+  return await applyPrivacyPolicyForEntX(viewer, ent, data, { ent: loader });
+}
+
+interface FieldPrivacyOptions<
+  TEnt extends Ent,
+  TViewer extends Viewer = Viewer,
+> {
+  ent: EntConstructor<TEnt, TViewer>;
+  fieldPrivacy?: Map<string, PrivacyPolicy>;
+}
+
+// everything calls into this two so should be fine
+// TODO is there a smarter way to not instantiate two objects here?
+async function applyPrivacyPolicyForEnt<
+  TEnt extends Ent<TViewer>,
+  TViewer extends Viewer,
+>(
+  viewer: TViewer,
+  ent: TEnt,
+  data: Data,
+  fieldPrivacyOptions: FieldPrivacyOptions<TEnt, TViewer>,
+): Promise<TEnt | Error> {
+  const error = await applyPrivacyPolicyImpl(
+    viewer,
+    ent.getPrivacyPolicy(),
+    ent,
+  );
+  if (error === null) {
+    return doFieldPrivacy(viewer, ent, data, fieldPrivacyOptions);
+  }
+  return error;
+}
+
+async function applyPrivacyPolicyForEntX<
+  TEnt extends Ent<TViewer>,
+  TViewer extends Viewer,
+>(
+  viewer: TViewer,
+  ent: TEnt,
+  data: Data,
+  options: FieldPrivacyOptions<TEnt, TViewer>,
+): Promise<TEnt> {
+  const r = await applyPrivacyPolicyForEnt(viewer, ent, data, options);
+  if (rowIsError(r)) {
+    throw r;
+  }
+  if (r === null) {
+    throw new Error(`couldn't apply privacyPoliy for ent ${ent.id}`);
+  }
+  return r;
+}
+
+async function doFieldPrivacy<
+  TEnt extends Ent<TViewer>,
+  TViewer extends Viewer,
+>(
+  viewer: TViewer,
+  ent: TEnt,
+  data: Data,
+  options: FieldPrivacyOptions<TEnt, TViewer>,
+): Promise<TEnt> {
+  if (!options.fieldPrivacy) {
+    return ent;
+  }
+  const promises: Promise<void>[] = [];
+  let somethingChanged = false;
+  const clone = { ...data };
+  const origData = {
+    ...data,
+  };
+  for (const [k, policy] of options.fieldPrivacy) {
+    const curr = clone[k];
+    if (curr === null || curr === undefined) {
+      continue;
+    }
+
+    promises.push(
+      (async () => {
+        // don't do anything if key is null or for some reason missing
+        const r = await applyPrivacyPolicy(viewer, policy, ent);
+        if (!r) {
+          clone[k] = null;
+          somethingChanged = true;
+        }
+      })(),
+    );
+  }
+  await Promise.all(promises);
+  if (somethingChanged) {
+    // have to create new instance
+    const ent = new options.ent(viewer, clone);
+    ent.__setRawDBData(origData);
+    return ent;
+  }
+  ent.__setRawDBData(origData);
+  return ent;
+}
+
+export function logQuery(query: string, logValues: any[]) {
+  log("query", {
+    query: query,
+    values: logValues,
+  });
+  logTrace();
+}
+
+// TODO long term figure out if this API should be exposed
+export async function loadRowX(options: LoadRowOptions): Promise<Data> {
+  const result = await loadRow(options);
+  if (result == null) {
+    // todo make this better
+    // make clause have a description
+    throw new Error(
+      `couldn't find row for query ${options.clause.clause(
+        1,
+      )} with values ${options.clause.values()}`,
+    );
+  }
+  return result;
+}
+
+// primitive data fetching. called by loaders
+export async function loadRow(options: LoadRowOptions): Promise<Data | null> {
+  let cache = options.context?.cache;
+  if (cache) {
+    let row = cache.getCachedRow(options);
+    if (row !== null) {
+      return row;
+    }
+  }
+
+  const query = buildQuery(options);
+  logQuery(query, options.clause.logValues());
+  const pool = DB.getInstance().getPool();
+
+  const res = await pool.query(query, options.clause.values());
+  if (res.rowCount != 1) {
+    if (res.rowCount > 1) {
+      log("error", "got more than one row for query " + query);
+    }
+    return null;
+  }
+
+  // put the row in the cache...
+  if (cache) {
+    cache.primeCache(options, res.rows[0]);
+  }
+
+  return res.rows[0];
+}
+
+var _logQueryWithError = false;
+
+export function ___setLogQueryErrorWithError(val: boolean | undefined) {
+  _logQueryWithError = val || false;
+}
+
+// this always goes to the db, no cache, nothing
+export async function performRawQuery(
+  query: string,
+  values: any[],
+  logValues?: any[],
+): Promise<Data[]> {
+  const pool = DB.getInstance().getPool();
+
+  logQuery(query, logValues || []);
+  try {
+    const res = await pool.queryAll(query, values);
+    return res.rows;
+  } catch (e) {
+    if (_logQueryWithError) {
+      const msg = (e as Error).message;
+      throw new Error(
+        `error \`${msg}\` running query: \`${query}\` with values: \`${logValues}\``,
+      );
+    }
+    throw e;
+  }
+}
+
+// TODO this should throw, we can't be hiding errors here
+export async function loadRows(options: LoadRowsOptions): Promise<Data[]> {
+  let cache = options.context?.cache;
+  if (cache) {
+    let rows = cache.getCachedRows(options);
+    if (rows !== null) {
+      return rows;
+    }
+  }
+
+  const query = buildQuery(options);
+  const r = await performRawQuery(
+    query,
+    options.clause.values(),
+    options.clause.logValues(),
+  );
+  if (cache) {
+    // put the rows in the cache...
+    cache.primeCache(options, r);
+  }
+  return r;
+}
+
+// private to ent
+export function buildQuery(options: QueryableDataOptions): string {
+  const fields = options.fields.join(", ");
+  // always start at 1
+  const whereClause = options.clause.clause(1);
+  const parts: string[] = [];
+  parts.push(`SELECT ${fields} FROM ${options.tableName} WHERE ${whereClause}`);
+  if (options.groupby) {
+    parts.push(`GROUP BY ${options.groupby}`);
+  }
+  if (options.orderby) {
+    parts.push(`ORDER BY ${getOrderByPhrase(options.orderby)}`);
+  }
+  if (options.limit) {
+    parts.push(`LIMIT ${options.limit}`);
+  }
+  return parts.join(" ");
+}
+
+interface GroupQueryOptions<T extends Data, K = keyof T> {
+  tableName: string;
+
+  // extra clause to join
+  clause?: clause.Clause<T, K>;
+  groupColumn: K;
+  fields: K[];
+  values: any[];
+  orderby?: OrderBy;
+  limit: number;
+}
+
+// this is used for queries when we select multiple ids at once
+export function buildGroupQuery<T extends Data = Data, K = keyof T>(
+  options: GroupQueryOptions<T, K>,
+): [string, clause.Clause<T, K>] {
+  const fields = [...options.fields, "row_number()"];
+
+  let cls = clause.In<T, K>(options.groupColumn, ...options.values);
+  if (options.clause) {
+    cls = clause.And<T, K>(cls, options.clause);
+  }
+  let orderby = "";
+  if (options.orderby) {
+    orderby = `ORDER BY ${getOrderByPhrase(options.orderby)}`;
+  }
+
+  // window functions work in sqlite!
+  //    https://www.sqlite.org/windowfunctions.html
+  return [
+    `SELECT * FROM (SELECT ${fields.join(",")} OVER (PARTITION BY ${
+      options.groupColumn
+    } ${orderby}) as row_num FROM ${options.tableName} WHERE ${cls.clause(
+      1,
+    )}) t WHERE row_num <= ${options.limit}`,
+    cls,
+  ];
+}
+
+function isSyncQueryer(queryer: Queryer): queryer is SyncQueryer {
+  return (queryer as SyncQueryer).execSync !== undefined;
+}
+
+async function mutateRow(
+  queryer: Queryer,
+  query: string,
+  values: any[],
+  logValues: any[],
+  options: DataOptions,
+) {
+  logQuery(query, logValues);
+
+  let cache = options.context?.cache;
+  let res: QueryResult<QueryResultRow>;
+  try {
+    if (isSyncQueryer(queryer)) {
+      res = queryer.execSync(query, values);
+    } else {
+      res = await queryer.exec(query, values);
+    }
+  } catch (e) {
+    if (_logQueryWithError) {
+      const msg = (e as Error).message;
+      throw new Error(`error \`${msg}\` running query: \`${query}\``);
+    }
+    throw e;
+  }
+  if (cache) {
+    cache.clearCache();
+  }
+  return res;
+}
+
+function mutateRowSync(
+  queryer: SyncQueryer,
+  query: string,
+  values: any[],
+  logValues: any[],
+  options: DataOptions,
+) {
+  logQuery(query, logValues);
+
+  let cache = options.context?.cache;
+  try {
+    const res = queryer.execSync(query, values);
+    if (cache) {
+      cache.clearCache();
+    }
+    return res;
+  } catch (e) {
+    if (_logQueryWithError) {
+      const msg = (e as Error).message;
+      throw new Error(`error \`${msg}\` running query: \`${query}\``);
+    }
+    throw e;
+  }
+}
+
+export function buildInsertQuery(
+  options: CreateRowOptions,
+  suffix?: string,
+): [string, string[], string[]] {
+  let fields: string[] = [];
+  let values: any[] = [];
+  let logValues: any[] = [];
+  let valsString: string[] = [];
+  let idx = 1;
+  const dialect = DB.getDialect();
+  for (const key in options.fields) {
+    fields.push(key);
+    values.push(options.fields[key]);
+    if (options.fieldsToLog) {
+      logValues.push(options.fieldsToLog[key]);
+    }
+    if (dialect === Dialect.Postgres) {
+      valsString.push(`$${idx}`);
+    } else {
+      valsString.push("?");
+    }
+    idx++;
+  }
+
+  const cols = fields.join(", ");
+  const vals = valsString.join(", ");
+
+  let query = `INSERT INTO ${options.tableName} (${cols}) VALUES (${vals})`;
+
+  if (options.onConflict) {
+    let onConflict = "";
+    if (options.onConflict.onConflictConstraint) {
+      onConflict = `ON CONFLICT ON CONSTRAINT ${options.onConflict.onConflictConstraint}`;
+    } else {
+      onConflict = `ON CONFLICT(${options.onConflict.onConflictCols.join(
+        ", ",
+      )})`;
+    }
+    if (options.onConflict.updateCols?.length) {
+      onConflict += ` DO UPDATE SET ${options.onConflict.updateCols
+        .map((f) => `${f} = EXCLUDED.${f}`)
+        .join(", ")}`;
+    } else {
+      onConflict += ` DO NOTHING`;
+    }
+    query = query + " " + onConflict;
+  }
+
+  if (suffix) {
+    query += " " + suffix;
+  }
+
+  return [query, values, logValues];
+}
+
+// TODO: these three are not to be exported out of this package
+// only from this file
+export async function createRow(
+  queryer: Queryer,
+  options: CreateRowOptions,
+  suffix: string,
+): Promise<Data | null> {
+  const [query, values, logValues] = buildInsertQuery(options, suffix);
+
+  const res = await mutateRow(queryer, query, values, logValues, options);
+
+  if (res?.rowCount === 1) {
+    return res.rows[0];
+  }
+  return null;
+}
+
+export function createRowSync(
+  queryer: SyncQueryer,
+  options: CreateRowOptions,
+  suffix: string,
+): Data | null {
+  const [query, values, logValues] = buildInsertQuery(options, suffix);
+
+  const res = mutateRowSync(queryer, query, values, logValues, options);
+
+  if (res?.rowCount === 1) {
+    return res.rows[0];
+  }
+  return null;
+}
+
+export function buildUpdateQuery(
+  options: EditRowOptions,
+  suffix?: string,
+): [string, any[], any[]] {
+  let valsString: string[] = [];
+  let values: any[] = [];
+  let logValues: any[] = [];
+  const dialect = DB.getDialect();
+
+  let idx = 1;
+  for (const key in options.fields) {
+    if (options.expressions && options.expressions.has(key)) {
+      const cls = options.expressions.get(key)!;
+      valsString.push(`${key} = ${cls.clause(idx)}`);
+      // TODO need to test a clause with more than one value...
+      const newVals = cls.values();
+      idx += newVals.length;
+      values.push(...newVals);
+      logValues.push(...cls.logValues());
+    } else {
+      const val = options.fields[key];
+      values.push(val);
+      if (options.fieldsToLog) {
+        logValues.push(options.fieldsToLog[key]);
+      }
+      // TODO would be nice to use clause here. need update version of the queries so that
+      // we don't have to handle dialect specifics here
+      // can't use clause because of IS NULL
+      // valsString.push(clause.Eq(key, val).clause(idx));
+      if (dialect === Dialect.Postgres) {
+        valsString.push(`${key} = $${idx}`);
+      } else {
+        valsString.push(`${key} = ?`);
+      }
+      idx++;
+    }
+  }
+
+  const vals = valsString.join(", ");
+
+  let query = `UPDATE ${options.tableName} SET ${vals} WHERE `;
+
+  query = query + options.whereClause.clause(idx);
+  values.push(...options.whereClause.values());
+  if (options.fieldsToLog) {
+    logValues.push(...options.whereClause.logValues());
+  }
+
+  if (suffix) {
+    query = query + " " + suffix;
+  }
+
+  return [query, values, logValues];
+}
+
+export async function editRow(
+  queryer: Queryer,
+  options: EditRowOptions,
+  suffix?: string,
+): Promise<Data | null> {
+  const [query, values, logValues] = buildUpdateQuery(options, suffix);
+
+  const res = await mutateRow(queryer, query, values, logValues, options);
+
+  if (res?.rowCount == 1) {
+    // for now assume id primary key
+    // TODO make this extensible as needed.
+    let row = res.rows[0];
+    return row;
+  }
+  return null;
+}
+
+export function editRowSync(
+  queryer: SyncQueryer,
+  options: EditRowOptions,
+  suffix?: string,
+): Data | null {
+  const [query, values, logValues] = buildUpdateQuery(options, suffix);
+
+  const res = mutateRowSync(queryer, query, values, logValues, options);
+
+  if (res?.rowCount == 1) {
+    // for now assume id primary key
+    // TODO make this extensible as needed.
+    let row = res.rows[0];
+    return row;
+  }
+  return null;
+}
+
+export async function deleteRows(
+  queryer: Queryer,
+  options: DataOptions,
+  cls: clause.Clause,
+): Promise<void> {
+  const query = `DELETE FROM ${options.tableName} WHERE ${cls.clause(1)}`;
+  await mutateRow(queryer, query, cls.values(), cls.logValues(), options);
+}
+
+export function deleteRowsSync(
+  queryer: SyncQueryer,
+  options: DataOptions,
+  cls: clause.Clause,
+): void {
+  const query = `DELETE FROM ${options.tableName} WHERE ${cls.clause(1)}`;
+  mutateRowSync(queryer, query, cls.values(), cls.logValues(), options);
+}
+
+export class AssocEdge {
+  id1: ID;
+  id1Type: string;
+  edgeType: string;
+  id2: ID;
+  id2Type: string;
+  time: Date;
+  data?: string | null;
+
+  private rawData: Data;
+
+  constructor(data: Data) {
+    this.id1 = data.id1;
+    this.id1Type = data.id1_type;
+    this.id2 = data.id2;
+    this.id2Type = data.id2_type;
+    this.edgeType = data.edge_type;
+    this.time = data.time;
+    this.data = data.data;
+    this.rawData = data;
+  }
+
+  __getRawData() {
+    // incase there's extra db fields. useful for tests
+    // in production, a subclass of this should be in use so we won't need this...
+    return this.rawData;
+  }
+
+  getCursor(): string {
+    return getCursor({
+      row: this,
+      col: "id2",
+    });
+  }
+}
+
+interface cursorOptions {
+  row: Data;
+  col: string;
+  cursorKey?: string; // used by tests. if cursor is from one column but the key in the name is different e.g. time for assocs and created_at when taken from the object
+  conv?: (any: any) => any;
+}
+
+// TODO eventually update this for sortCol time unique keys
+export function getCursor(opts: cursorOptions) {
+  const { row, col, conv } = opts;
+  //  row: Data, col: string, conv?: (any) => any) {
+  if (!row) {
+    throw new Error(`no row passed to getCursor`);
+  }
+  let datum = row[col];
+  if (!datum) {
+    return "";
+  }
+  if (conv) {
+    datum = conv(datum);
+  }
+
+  const cursorKey = opts.cursorKey || col;
+  const str = `${cursorKey}:${datum}`;
+  return Buffer.from(str, "ascii").toString("base64");
+}
+
+export class AssocEdgeData {
+  edgeType: string;
+  edgeName: string;
+  symmetricEdge: boolean;
+  inverseEdgeType?: string;
+  edgeTable: string;
+
+  constructor(data: Data) {
+    this.edgeType = data.edge_type;
+    this.edgeName = data.edge_name;
+    this.symmetricEdge = data.symmetric_edge;
+    this.inverseEdgeType = data.inverse_edge_type;
+    this.edgeTable = data.edge_table;
+  }
+}
+
+const assocEdgeFields = [
+  "edge_type",
+  "edge_name",
+  "symmetric_edge",
+  "inverse_edge_type",
+  "edge_table",
+];
+
+export const assocEdgeLoader = createAssocEdgeConfigLoader({
+  tableName: "assoc_edge_config",
+  fields: assocEdgeFields,
+  key: "edge_type",
+  keyType: "uuid",
+});
+
+// we don't expect assoc_edge_config information to change
+// so not using ContextCache but just caching it as needed once per server
+
+export async function loadEdgeData(
+  edgeType: string,
+): Promise<AssocEdgeData | null> {
+  const row = await assocEdgeLoader.load(edgeType);
+  if (!row) {
+    return null;
+  }
+  return new AssocEdgeData(row);
+}
+
+export async function loadEdgeDatas(
+  ...edgeTypes: string[]
+): Promise<Map<string, AssocEdgeData>> {
+  if (!edgeTypes.length) {
+    return new Map();
+  }
+
+  const rows = await assocEdgeLoader.loadMany(edgeTypes);
+  const m = new Map<string, AssocEdgeData>();
+  rows.forEach((row) => {
+    if (!row) {
+      return;
+    }
+    if (rowIsError(row)) {
+      throw row;
+    }
+    m.set(row["edge_type"], new AssocEdgeData(row));
+  });
+  return m;
+}
+
+const edgeFields = [
+  "id1",
+  "id1_type",
+  "edge_type",
+  "id2",
+  "id2_type",
+  "time",
+  "data",
+];
+
+export interface AssocEdgeConstructor<T extends AssocEdge> {
+  new (row: Data): T;
+}
+
+interface loadEdgesOptions {
+  id1: ID;
+  edgeType: string;
+  context?: Context;
+  queryOptions?: EdgeQueryableDataOptions;
+}
+
+interface loadCustomEdgesOptions<T extends AssocEdge> extends loadEdgesOptions {
+  ctr: AssocEdgeConstructor<T>;
+}
+
+let defaultLimit = 1000;
+
+export function setDefaultLimit(limit: number) {
+  defaultLimit = limit;
+}
+
+export function getDefaultLimit() {
+  return defaultLimit;
+}
+
+function defaultEdgeQueryOptions(
+  id1: ID,
+  edgeType: string,
+  id2?: ID,
+): EdgeQueryableDataOptions {
+  let cls = clause.And(clause.Eq("id1", id1), clause.Eq("edge_type", edgeType));
+  if (id2) {
+    cls = clause.And(cls, clause.Eq("id2", id2));
+  }
+  return {
+    clause: cls,
+    orderby: [
+      {
+        column: "time",
+        direction: "DESC",
+      },
+    ],
+    limit: defaultLimit,
+  };
+}
+
+export async function loadEdges(
+  options: loadEdgesOptions,
+): Promise<AssocEdge[]> {
+  return loadCustomEdges({ ...options, ctr: AssocEdge });
+}
+
+export function getEdgeClauseAndFields(
+  cls: clause.Clause,
+  options: Pick<loadEdgesOptions, "queryOptions">,
+) {
+  let fields = edgeFields;
+
+  const transformEdgeRead = __getGlobalSchema()?.transformEdgeRead;
+  if (transformEdgeRead) {
+    const transformClause = transformEdgeRead();
+    if (!options.queryOptions?.disableTransformations) {
+      cls = clause.And(cls, transformClause);
+    }
+    fields = edgeFields.concat(transformClause.columns() as string[]);
+  }
+  return {
+    cls,
+    fields,
+  };
+}
+
+export async function loadCustomEdges<T extends AssocEdge>(
+  options: loadCustomEdgesOptions<T>,
+): Promise<T[]> {
+  const {
+    cls: actualClause,
+    fields,
+    defaultOptions,
+    tableName,
+  } = await loadEgesInfo(options);
+
+  const rows = await loadRows({
+    tableName,
+    fields: fields,
+    clause: actualClause,
+    orderby: options.queryOptions?.orderby || defaultOptions.orderby,
+    limit: options.queryOptions?.limit || defaultOptions.limit,
+    context: options.context,
+  });
+  return rows.map((row) => {
+    return new options.ctr(row);
+  });
+}
+
+async function loadEgesInfo<T extends AssocEdge>(
+  options: loadCustomEdgesOptions<T>,
+  id2?: ID,
+) {
+  const { id1, edgeType } = options;
+  const edgeData = await loadEdgeData(edgeType);
+  if (!edgeData) {
+    throw new Error(`error loading edge data for ${edgeType}`);
+  }
+
+  const defaultOptions = defaultEdgeQueryOptions(id1, edgeType, id2);
+  let cls = defaultOptions.clause!;
+  if (options.queryOptions?.clause) {
+    cls = clause.And(cls, options.queryOptions.clause);
+  }
+
+  return {
+    ...getEdgeClauseAndFields(cls, options),
+    defaultOptions,
+    tableName: edgeData.edgeTable,
+  };
+}
+
+export async function loadUniqueEdge(
+  options: loadEdgesOptions,
+): Promise<AssocEdge | null> {
+  const { id1, edgeType, context } = options;
+
+  const edgeData = await loadEdgeData(edgeType);
+  if (!edgeData) {
+    throw new Error(`error loading edge data for ${edgeType}`);
+  }
+  const { cls, fields } = getEdgeClauseAndFields(
+    clause.And(clause.Eq("id1", id1), clause.Eq("edge_type", edgeType)),
+    options,
+  );
+
+  const row = await loadRow({
+    tableName: edgeData.edgeTable,
+    fields: fields,
+    clause: cls,
+    context,
+  });
+  if (!row) {
+    return null;
+  }
+  return new AssocEdge(row);
+}
+
+export async function loadUniqueNode<
+  TEnt extends Ent<TViewer>,
+  TViewer extends Viewer,
+>(
+  viewer: TViewer,
+  id1: ID,
+  edgeType: string,
+  options: LoadEntOptions<TEnt, TViewer>,
+): Promise<TEnt | null> {
+  const edge = await loadUniqueEdge({
+    id1,
+    edgeType,
+    context: viewer.context,
+  });
+  if (!edge) {
+    return null;
+  }
+  return await loadEnt(viewer, edge.id2, options);
+}
+
+export async function loadRawEdgeCountX(
+  options: loadEdgesOptions,
+): Promise<number> {
+  const { id1, edgeType, context } = options;
+  const edgeData = await loadEdgeData(edgeType);
+  if (!edgeData) {
+    throw new Error(`error loading edge data for ${edgeType}`);
+  }
+
+  const { cls } = getEdgeClauseAndFields(
+    clause.And(clause.Eq("id1", id1), clause.Eq("edge_type", edgeType)),
+    options,
+  );
+  const row = await loadRowX({
+    tableName: edgeData.edgeTable,
+    // sqlite needs as count otherwise it returns count(1)
+    fields: ["count(1) as count"],
+    clause: cls,
+    context,
+  });
+  return parseInt(row["count"], 10) || 0;
+}
+
+interface loadEdgeForIDOptions<T extends AssocEdge>
+  extends loadCustomEdgesOptions<T> {
+  id2: ID;
+}
+
+export async function loadEdgeForID2<T extends AssocEdge>(
+  options: loadEdgeForIDOptions<T>,
+): Promise<T | undefined> {
+  const {
+    cls: actualClause,
+    fields,
+    tableName,
+  } = await loadEgesInfo(options, options.id2);
+
+  const row = await loadRow({
+    tableName,
+    fields: fields,
+    clause: actualClause,
+    context: options.context,
+  });
+  if (row) {
+    return new options.ctr(row);
+  }
+}
+
+export async function loadNodesByEdge<T extends Ent>(
+  viewer: Viewer,
+  id1: ID,
+  edgeType: string,
+  options: LoadEntOptions<T>,
+): Promise<T[]> {
+  // load edges
+  const rows = await loadEdges({
+    id1,
+    edgeType,
+    context: viewer.context,
+  });
+
+  // extract id2s
+  const ids = rows.map((row) => row.id2);
+
+  return loadEntsList(viewer, options, ...ids);
+}
+
+export async function applyPrivacyPolicyForRow<
+  TEnt extends Ent<TViewer>,
+  TViewer extends Viewer,
+>(
+  viewer: TViewer,
+  options: LoadEntOptions<TEnt, TViewer>,
+  row: Data,
+): Promise<TEnt | null> {
+  const r = await applyPrivacyPolicyForRowImpl(viewer, options, row);
+  return rowIsError(r) ? null : r;
+}
+
+async function applyPrivacyPolicyForRowImpl<
+  TEnt extends Ent<TViewer>,
+  TViewer extends Viewer,
+>(
+  viewer: TViewer,
+  options: LoadEntOptions<TEnt, TViewer>,
+  row: Data,
+): Promise<TEnt | Error> {
+  const ent = new options.ent(viewer, row);
+  return applyPrivacyPolicyForEnt(viewer, ent, row, options);
+}
+
+async function applyPrivacyPolicyForRowX<
+  TEnt extends Ent<TViewer>,
+  TViewer extends Viewer,
+>(
+  viewer: TViewer,
+  options: LoadEntOptions<TEnt, TViewer>,
+  row: Data,
+): Promise<TEnt> {
+  const ent = new options.ent(viewer, row);
+  return await applyPrivacyPolicyForEntX(viewer, ent, row, options);
+}
+
+// deprecated. doesn't use entcache
+async function applyPrivacyPolicyForRowsDeprecated<
+  TEnt extends Ent<TViewer>,
+  TViewer extends Viewer,
+>(viewer: TViewer, rows: Data[], options: LoadEntOptions<TEnt, TViewer>) {
+  let m: Map<ID, TEnt> = new Map();
+  // apply privacy logic
+  await Promise.all(
+    rows.map(async (row) => {
+      let privacyEnt = await applyPrivacyPolicyForRow(viewer, options, row);
+      if (privacyEnt) {
+        m.set(privacyEnt.id, privacyEnt);
+      }
+    }),
+  );
+  return m;
+}
+
+export async function applyPrivacyPolicyForRows<
+  TEnt extends Ent<TViewer>,
+  TViewer extends Viewer,
+>(viewer: TViewer, rows: Data[], options: LoadEntOptions<TEnt, TViewer>) {
+  const result: TEnt[] = new Array(rows.length);
+
+  if (!rows.length) {
+    return [];
+  }
+
+  const entLoader = getEntLoader(viewer, options);
+
+  await Promise.all(
+    rows.map(async (row, idx) => {
+      const r = await applyPrivacyPolicyForRowAndStoreInEntLoader(
+        viewer,
+        row,
+        options,
+        entLoader,
+      );
+      if (r instanceof ErrorWrapper) {
+        return;
+      }
+      result[idx] = r;
+    }),
+  );
+  // filter ents that aren't visible because of privacy
+  return result.filter((r) => r !== undefined);
+}
+
+// given a viewer, an id pair, and a map of edgeEnum to EdgeType
+// return the edgeEnum that's set in the group
+export async function getEdgeTypeInGroup<T extends string>(
+  viewer: Viewer,
+  id1: ID,
+  id2: ID,
+  m: Map<T, string>,
+): Promise<[T, AssocEdge] | undefined> {
+  let promises: Promise<[T, AssocEdge | undefined] | undefined>[] = [];
+  const edgeDatas = await loadEdgeDatas(...Array.from(m.values()));
+
+  let tableToEdgeEnumMap = new Map<string, T[]>();
+  for (const [edgeEnum, edgeType] of m) {
+    const edgeData = edgeDatas.get(edgeType);
+    if (!edgeData) {
+      throw new Error(`could not load edge data for '${edgeType}'`);
+    }
+    const l = tableToEdgeEnumMap.get(edgeData.edgeTable) ?? [];
+    l.push(edgeEnum);
+    tableToEdgeEnumMap.set(edgeData.edgeTable, l);
+  }
+  tableToEdgeEnumMap.forEach((edgeEnums, tableName) => {
+    promises.push(
+      (async () => {
+        const edgeTypes = edgeEnums.map((edgeEnum) => m.get(edgeEnum)!);
+
+        const { cls, fields } = getEdgeClauseAndFields(
+          clause.And(
+            clause.Eq("id1", id1),
+            clause.UuidIn("edge_type", edgeTypes),
+            clause.Eq("id2", id2),
+          ),
+          {},
+        );
+
+        const rows = await loadRows({
+          tableName,
+          fields,
+          clause: cls,
+          context: viewer.context,
+        });
+
+        const row = rows[0];
+        if (row) {
+          const edgeType = row.edge_type;
+          for (const [k, v] of m) {
+            if (v === edgeType) {
+              return [k, new AssocEdge(row)];
+            }
+          }
+        }
+      })(),
+    );
+  });
+  const results = await Promise.all(promises);
+  for (const res of results) {
+    if (res && res[1]) {
+      return [res[0], res[1]];
+    }
+  }
+}