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

package/src/core/query/assoc_query.ts

@@ -0,0 +1,240 @@
+import {
+  ID,
+  Ent,
+  Viewer,
+  LoadEntOptions,
+  EdgeQueryableDataOptions,
+} from "../base";
+import { AssocEdge, loadEdgeData, loadEntsList } from "../ent";
+import { AssocEdgeCountLoaderFactory } from "../loaders/assoc_count_loader";
+import { AssocEdgeLoaderFactory } from "../loaders/assoc_edge_loader";
+import { EdgeQuery, BaseEdgeQuery, IDInfo } from "./query";
+
+// TODO no more plurals for privacy reasons?
+export type EdgeQuerySource<
+  TSource extends Ent<TViewer>,
+  TDest extends Ent<TViewer> = Ent<any>,
+  TViewer extends Viewer = Viewer,
+> = TSource | TSource[] | ID | ID[] | EdgeQuery<TDest, Ent, AssocEdge>;
+
+type loaderOptionsFunc<TViewer extends Viewer> = (
+  type: string,
+) => LoadEntOptions<Ent, TViewer>;
+
+interface typeData {
+  ids: ID[];
+  options: LoadEntOptions<Ent>;
+}
+
+// would be nice to someday have an API for assoc asc
+export abstract class AssocEdgeQueryBase<
+    TSource extends Ent<TViewer>,
+    TDest extends Ent<TViewer>,
+    TEdge extends AssocEdge,
+    TViewer extends Viewer = Viewer,
+  >
+  extends BaseEdgeQuery<TSource, TDest, TEdge>
+  implements EdgeQuery<TSource, TDest, TEdge>
+{
+  constructor(
+    public viewer: TViewer,
+    public src: EdgeQuerySource<TSource, TDest, TViewer>,
+    private countLoaderFactory: AssocEdgeCountLoaderFactory,
+    private dataLoaderFactory: AssocEdgeLoaderFactory<TEdge>,
+    // if function, it's a polymorphic edge and need to provide
+    // a function that goes from edgeType to LoadEntOptions
+    private options:
+      | LoadEntOptions<TDest, TViewer>
+      | loaderOptionsFunc<TViewer>,
+  ) {
+    super(viewer, "time", "id2");
+  }
+
+  private isEdgeQuery(
+    obj: TSource | ID | EdgeQuery<TDest, Ent, AssocEdge>,
+  ): obj is EdgeQuery<TDest, Ent, AssocEdge> {
+    if ((obj as EdgeQuery<TDest, Ent, AssocEdge>).queryIDs !== undefined) {
+      return true;
+    }
+    return false;
+  }
+
+  abstract sourceEnt(id: ID): Promise<Ent | null>;
+
+  async getTableName(): Promise<string> {
+    const edgeData = await loadEdgeData(this.countLoaderFactory.getEdgeType());
+    if (!edgeData) {
+      throw new Error(`couldn't load edgeData`);
+    }
+    return edgeData.edgeTable;
+  }
+
+  private async getSingleID() {
+    const infos = await this.genIDInfosToFetch();
+    if (infos.length !== 1) {
+      throw new Error(
+        "cannot call queryRawCount when more than one id is requested",
+      );
+    }
+    return infos[0];
+  }
+
+  // doesn't work with filters...
+  async queryRawCount(): Promise<number> {
+    const info = await this.getSingleID();
+    if (info.invalidated) {
+      return 0;
+    }
+
+    return this.countLoaderFactory
+      .createConfigurableLoader(
+        this.getDefaultEdgeQueryOptions() ?? {},
+        this.viewer.context,
+      )
+      .load(info.id);
+  }
+
+  async queryAllRawCount(): Promise<Map<ID, number>> {
+    let results: Map<ID, number> = new Map();
+    const infos = await this.genIDInfosToFetch();
+
+    const loader = this.countLoaderFactory.createLoader(this.viewer.context);
+    await Promise.all(
+      infos.map(async (info) => {
+        if (info.invalidated) {
+          results.set(info.id, 0);
+          return;
+        }
+        const count = await loader.load(info.id);
+        results.set(info.id, count);
+      }),
+    );
+    return results;
+  }
+
+  protected async loadEntsFromEdges(
+    id: ID,
+    edges: AssocEdge[],
+  ): Promise<TDest[]> {
+    if (typeof this.options === "function") {
+      const m = new Map<string, typeData>();
+      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: Promise<Ent[]>[] = [];
+      for (const [_, value] of m) {
+        promises.push(loadEntsList(this.viewer, value.options, ...value.ids));
+      }
+      const entss = await Promise.all(promises);
+      const r: Ent[] = [];
+      for (const ents of entss) {
+        r.push(...ents);
+      }
+      return r as TDest[];
+    }
+    const ids = edges.map((edge) => edge.id2);
+    return loadEntsList(this.viewer, this.options, ...ids);
+  }
+
+  dataToID(edge: AssocEdge): ID {
+    return edge.id2;
+  }
+
+  protected async loadRawIDs(addID: (src: ID | TSource) => void) {
+    if (Array.isArray(this.src)) {
+      this.src.forEach((obj: TSource | ID) => addID(obj));
+    } else if (this.isEdgeQuery(this.src)) {
+      const idsMap = await this.src.queryAllIDs();
+      for (const [_, ids] of idsMap) {
+        ids.forEach((id) => addID(id));
+      }
+    } else {
+      addID(this.src);
+    }
+  }
+
+  protected async loadRawData(
+    infos: IDInfo[],
+    options: EdgeQueryableDataOptions,
+  ) {
+    const loader = this.dataLoaderFactory.createConfigurableLoader(
+      options,
+      this.viewer.context,
+    );
+
+    await Promise.all(
+      infos.map(async (info) => {
+        if (info.invalidated) {
+          this.edges.set(info.id, []);
+          return;
+        }
+        // there'll be filters for special edges here...
+        // and then depending on that, we use this
+        // what happens if you do first(10).id2(XX)
+        // doesn't make sense
+        // so only makes sense if one of these...
+
+        // Id2 needs to be an option
+        const edges = await loader.load(info.id);
+        this.edges.set(info.id, edges);
+      }),
+    );
+  }
+
+  async queryID2(id2: ID): Promise<TEdge | undefined> {
+    const info = await this.getSingleID();
+    if (info.invalidated) {
+      return;
+    }
+
+    const loader = this.dataLoaderFactory.createLoader(this.viewer.context);
+    return loader.loadEdgeForID2(info.id, id2);
+  }
+
+  async queryAllID2(id2: ID): Promise<Map<ID, TEdge>> {
+    const infos = await this.genIDInfosToFetch();
+
+    const loader = this.dataLoaderFactory.createLoader(this.viewer.context);
+
+    const m = new Map<ID, TEdge>();
+    await Promise.all(
+      infos.map(async (info) => {
+        if (info.invalidated) {
+          return;
+        }
+        const edge = await loader.loadEdgeForID2(info.id, id2);
+        if (edge) {
+          m.set(info.id, edge);
+        }
+      }),
+    );
+    return m;
+  }
+}
+
+export interface EdgeQueryCtr<
+  TSource extends Ent,
+  TDest extends Ent,
+  TEdge extends AssocEdge,
+> {
+  new (viewer: Viewer, src: EdgeQuerySource<TSource>): EdgeQuery<
+    TSource,
+    TDest,
+    TEdge
+  >;
+}

package/src/core/query/custom_clause_query.ts

@@ -0,0 +1,174 @@
+import {
+  Data,
+  EdgeQueryableDataOptions,
+  Ent,
+  ID,
+  LoadEntOptions,
+  Viewer,
+} from "../base";
+import { AndOptional, Clause } from "../clause";
+import {
+  applyPrivacyPolicyForRows,
+  getDefaultLimit,
+  loadRow,
+  loadRows,
+} from "../ent";
+import { OrderBy } from "../query_impl";
+
+import { BaseEdgeQuery, IDInfo } from "./query";
+
+export interface CustomClauseQueryOptions<
+  TDest extends Ent<TViewer>,
+  TViewer extends Viewer = Viewer,
+> {
+  loadEntOptions: LoadEntOptions<TDest, TViewer>;
+  clause: Clause;
+  // query-name used to create loaders...
+  // and then from there it does what it needs to do to do the right thing...
+  name: string;
+  // pass this if the primary sort (first column in orderby) column is unique and it'll be used for the cursor and used to
+  // generate the query
+  primarySortColIsUnique?: boolean;
+  orderby?: OrderBy;
+
+  // these next 3 are deprecated. use orderby
+  // defaults to id
+  // @deprecated use orderby
+  sortColumn?: string;
+  // @deprecated use orderby
+  orderByDirection?: "ASC" | "DESC";
+  // in Postgres, NULLS FIRST is the default for DESC order, and NULLS LAST otherwise.
+  // @deprecated user orderby`
+  nullsPlacement?: "first" | "last";
+
+  disableTransformations?: boolean;
+}
+
+function getClause<TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer>(
+  opts: CustomClauseQueryOptions<TDest, TViewer>,
+) {
+  let cls = opts.clause;
+  if (opts.disableTransformations) {
+    return cls;
+  }
+  let optClause = opts.loadEntOptions.loaderFactory?.options?.clause;
+  if (typeof optClause === "function") {
+    optClause = optClause();
+  }
+  if (!optClause) {
+    return cls;
+  }
+  return AndOptional(cls, optClause);
+}
+
+export class CustomClauseQuery<
+  TDest extends Ent<TViewer>,
+  TViewer extends Viewer = Viewer,
+> extends BaseEdgeQuery<any, TDest, Data> {
+  private clause: Clause;
+  constructor(
+    public viewer: TViewer,
+    private options: CustomClauseQueryOptions<TDest, TViewer>,
+  ) {
+    let orderby: OrderBy;
+    let primarySortCol: string;
+
+    if (
+      options.orderby &&
+      (options.sortColumn || options.orderByDirection || options.nullsPlacement)
+    ) {
+      throw new Error(
+        `cannot pass orderby and sortColumn|orderByDirection|nullsPlacement`,
+      );
+    }
+    if (options.orderby) {
+      primarySortCol = options.orderby[0].column;
+      orderby = options.orderby;
+    } else {
+      primarySortCol = options.sortColumn || "id";
+      orderby = [
+        {
+          column: primarySortCol,
+          direction: options.orderByDirection ?? "DESC",
+          nullsPlacement: options.nullsPlacement,
+        },
+      ];
+    }
+    let cursorCol = options.primarySortColIsUnique
+      ? primarySortCol
+      : options.loadEntOptions.loaderFactory.options?.key || "id";
+
+    super(viewer, {
+      orderby,
+      cursorCol,
+    });
+    this.clause = getClause(options);
+  }
+
+  async sourceEnt(_id: ID) {
+    return null;
+  }
+
+  getTableName() {
+    return this.options.loadEntOptions.tableName;
+  }
+
+  async queryRawCount(): Promise<number> {
+    const row = await loadRow({
+      tableName: this.options.loadEntOptions.tableName,
+      // sqlite needs as count otherwise it returns count(1)
+      fields: ["count(1) as count"],
+      clause: this.clause,
+      context: this.viewer.context,
+    });
+    return parseInt(row?.count, 10) || 0;
+  }
+
+  async queryAllRawCount(): Promise<Map<ID, number>> {
+    throw new Error(`queryAllRawCount doesn't make sense in CustomClauseQuery`);
+  }
+
+  // nothing to do here
+  protected async loadRawIDs(_addID: (src: ID) => void): Promise<void> {}
+
+  protected async loadRawData(
+    _infos: IDInfo[],
+    options: EdgeQueryableDataOptions,
+  ) {
+    if (!options.orderby) {
+      options.orderby = [
+        {
+          column: this.getSortCol(),
+          direction: this.options.orderByDirection ?? "DESC",
+          nullsPlacement: this.options.nullsPlacement,
+        },
+      ];
+    }
+    if (!options.limit) {
+      options.limit = getDefaultLimit();
+    }
+
+    const rows = await loadRows({
+      tableName: this.options.loadEntOptions.tableName,
+      fields: this.options.loadEntOptions.fields,
+      clause: AndOptional(this.clause, options.clause),
+      orderby: options.orderby,
+      limit: options?.limit || getDefaultLimit(),
+      context: this.viewer.context,
+    });
+
+    this.edges.set(1, rows);
+  }
+
+  dataToID(edge: Data): ID {
+    return edge.id;
+  }
+
+  protected async loadEntsFromEdges(id: ID, rows: Data[]): Promise<TDest[]> {
+    return applyPrivacyPolicyForRows(
+      this.viewer,
+      rows,
+      this.options.loadEntOptions,
+    );
+  }
+}

package/src/core/query/custom_query.ts

@@ -0,0 +1,302 @@
+import {
+  Data,
+  Ent,
+  ID,
+  EdgeQueryableDataOptions,
+  LoadEntOptions,
+  Viewer,
+  LoaderFactory,
+  ConfigurableLoaderFactory,
+} from "../base";
+import { AndOptional, Clause } from "../clause";
+import { applyPrivacyPolicyForRows, getDefaultLimit } from "../ent";
+import {
+  ObjectLoaderFactory,
+  QueryLoaderFactory,
+  RawCountLoader,
+} from "../loaders";
+import { OrderBy } from "../query_impl";
+import { BaseEdgeQuery, IDInfo, EdgeQuery } from "./query";
+
+// TODO kill this. only used in graphql tests
+export interface CustomEdgeQueryOptionsDeprecated<
+  TSource extends Ent<TViewer>,
+  TDest extends Ent<TViewer>,
+  TViewer extends Viewer = Viewer,
+> {
+  src: TSource | ID;
+  countLoaderFactory: LoaderFactory<ID, number>;
+  dataLoaderFactory: ConfigurableLoaderFactory<ID, Data[]>;
+  options: LoadEntOptions<TDest, TViewer>;
+  // defaults to id
+  sortColumn?: string;
+}
+
+export interface CustomEdgeQueryOptions<
+  TSource extends Ent<TViewer>,
+  TDest extends Ent<TViewer>,
+  TViewer extends Viewer = Viewer,
+> {
+  src: TSource | ID;
+  loadEntOptions: LoadEntOptions<TDest, TViewer>;
+  // must provide at least one of these
+  groupCol?: string;
+  clause?: Clause;
+  // query-name used to create loaders...
+  // and then from there it does what it needs to do to do the right thing...
+  name: string;
+  // defaults to id
+  // @deprecated use orderby
+  sortColumn?: string;
+  orderby?: OrderBy;
+  // pass this if the primary sort (first column in orderby) column is unique and it'll be used for the cursor and used to
+  // generate the query
+  primarySortColIsUnique?: boolean;
+
+  disableTransformations?: boolean;
+}
+
+function getClause<
+  TSource extends Ent<TViewer>,
+  TDest extends Ent<TViewer>,
+  TViewer extends Viewer = Viewer,
+>(opts: CustomEdgeQueryOptions<TSource, TDest, TViewer>) {
+  let cls = opts.clause;
+  if (opts.disableTransformations) {
+    return cls;
+  }
+  let optClause = opts.loadEntOptions.loaderFactory?.options?.clause;
+  if (typeof optClause === "function") {
+    optClause = optClause();
+  }
+  if (!optClause) {
+    return cls;
+  }
+  return AndOptional(cls, optClause);
+}
+
+function getRawCountLoader<
+  TSource extends Ent<TViewer>,
+  TDest extends Ent<TViewer>,
+  TViewer extends Viewer = Viewer,
+>(viewer: TViewer, opts: CustomEdgeQueryOptions<TSource, TDest, TViewer>) {
+  if (!viewer.context?.cache) {
+    return new RawCountLoader({
+      tableName: opts.loadEntOptions.tableName,
+      groupCol: opts.groupCol,
+      clause: getClause(opts),
+    });
+  }
+  const name = `custom_query_count_loader:${opts.name}`;
+  return viewer.context.cache.getLoader(
+    name,
+    () =>
+      new RawCountLoader({
+        tableName: opts.loadEntOptions.tableName,
+        groupCol: opts.groupCol,
+        clause: getClause(opts),
+      }),
+  ) as RawCountLoader<ID>;
+}
+
+function getQueryLoader<
+  TSource extends Ent<TViewer>,
+  TDest extends Ent<TViewer>,
+  TViewer extends Viewer = Viewer,
+>(
+  viewer: TViewer,
+  opts: CustomEdgeQueryOptions<TSource, TDest, TViewer>,
+  options: EdgeQueryableDataOptions,
+) {
+  const loader = opts.loadEntOptions.loaderFactory as ObjectLoaderFactory<Data>;
+  const name = `custom_query_loader:${opts.name}`;
+
+  return QueryLoaderFactory.createConfigurableLoader(
+    name,
+    {
+      tableName: opts.loadEntOptions.tableName,
+      fields: opts.loadEntOptions.fields,
+      groupCol: opts.groupCol,
+      clause: getClause(opts),
+      toPrime: [loader],
+    },
+    options,
+    viewer.context,
+  );
+}
+
+function isDeprecatedOptions<
+  TSource extends Ent<TViewer>,
+  TDest extends Ent<TViewer>,
+  TViewer extends Viewer = Viewer,
+>(
+  options:
+    | CustomEdgeQueryOptionsDeprecated<TSource, TDest, TViewer>
+    | CustomEdgeQueryOptions<TSource, TDest, TViewer>,
+): options is CustomEdgeQueryOptionsDeprecated<TSource, TDest, TViewer> {
+  return (
+    (options as CustomEdgeQueryOptionsDeprecated<TSource, TDest, TViewer>)
+      .countLoaderFactory !== undefined
+  );
+}
+
+export abstract class CustomEdgeQueryBase<
+    TSource extends Ent<TViewer>,
+    TDest extends Ent<TViewer>,
+    TViewer extends Viewer = Viewer,
+  >
+  extends BaseEdgeQuery<TSource, TDest, Data>
+  implements EdgeQuery<TSource, TDest, Data>
+{
+  private id: ID;
+  private opts: LoadEntOptions<TDest>;
+  constructor(
+    public viewer: TViewer,
+    private options:
+      | CustomEdgeQueryOptionsDeprecated<TSource, TDest, TViewer>
+      | CustomEdgeQueryOptions<TSource, TDest, TViewer>,
+  ) {
+    let opts: LoadEntOptions<TDest>;
+    let defaultSort = "id";
+
+    let uniqueColIsSort = false;
+
+    let orderby: OrderBy | undefined;
+    let sortCol: string | undefined;
+
+    if (isDeprecatedOptions(options)) {
+      opts = options.options;
+    } else {
+      opts = options.loadEntOptions;
+      if (options.primarySortColIsUnique) {
+        uniqueColIsSort = true;
+      }
+      if (options.orderby) {
+        orderby = options.orderby;
+        sortCol = options.orderby[0].column;
+      }
+    }
+    let uniqueCol = opts.loaderFactory.options?.key || "id";
+
+    if (!orderby) {
+      options.sortColumn = options.sortColumn || defaultSort;
+      sortCol = options.sortColumn;
+
+      orderby = [
+        {
+          column: options.sortColumn,
+          direction: "DESC",
+        },
+      ];
+    }
+
+    if (uniqueColIsSort) {
+      uniqueCol = sortCol || defaultSort;
+    }
+    super(viewer, {
+      cursorCol: uniqueCol,
+      orderby,
+    });
+    if (typeof options.src === "object") {
+      this.id = options.src.id;
+    } else {
+      this.id = options.src;
+    }
+
+    this.opts = opts;
+  }
+
+  getTableName() {
+    return this.opts.tableName;
+  }
+
+  abstract sourceEnt(id: ID): Promise<Ent | null>;
+
+  private async idVisible() {
+    const ids = await this.genIDInfosToFetch();
+    if (ids.length !== 1) {
+      throw new Error("invalid number of IDInfo");
+    }
+    return !ids[0].invalidated;
+  }
+
+  private getCountLoader() {
+    if (isDeprecatedOptions(this.options)) {
+      return this.options.countLoaderFactory.createLoader(this.viewer.context);
+    }
+    return getRawCountLoader(this.viewer, this.options);
+  }
+
+  private getQueryLoader(options: EdgeQueryableDataOptions) {
+    if (isDeprecatedOptions(this.options)) {
+      return this.options.dataLoaderFactory.createConfigurableLoader(
+        options,
+        this.viewer.context,
+      );
+    }
+    return getQueryLoader(this.viewer, this.options, options);
+  }
+
+  async queryRawCount(): Promise<number> {
+    const idVisible = await this.idVisible();
+    if (!idVisible) {
+      return 0;
+    }
+
+    return this.getCountLoader().load(this.id);
+  }
+
+  async queryAllRawCount(): Promise<Map<ID, number>> {
+    let count = 0;
+    const idVisible = await this.idVisible();
+    if (idVisible) {
+      count = await this.queryRawCount();
+    }
+    return new Map<ID, number>([[this.id, count]]);
+  }
+
+  protected async loadRawIDs(
+    addID: (src: ID | TSource) => void,
+  ): Promise<void> {
+    addID(this.options.src);
+  }
+
+  protected async loadRawData(
+    infos: IDInfo[],
+    options: EdgeQueryableDataOptions,
+  ) {
+    if (infos.length !== 1) {
+      throw new Error(
+        `expected 1 info passed to loadRawData. ${infos.length} passed`,
+      );
+    }
+    if (!options.orderby) {
+      options.orderby = [
+        {
+          column: this.getSortCol(),
+          direction: "DESC",
+        },
+      ];
+    }
+    if (!options.limit) {
+      options.limit = getDefaultLimit();
+    }
+    const loader = this.getQueryLoader(options);
+    const info = infos[0];
+    if (info.invalidated) {
+      this.edges.set(this.id, []);
+      return;
+    }
+    const rows = await loader.load(this.id);
+
+    this.edges.set(this.id, rows);
+  }
+
+  dataToID(edge: Data): ID {
+    return edge.id;
+  }
+
+  protected async loadEntsFromEdges(id: ID, rows: Data[]): Promise<TDest[]> {
+    return applyPrivacyPolicyForRows(this.viewer, rows, this.opts);
+  }
+}