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

package/src/core/query/assoc_query.ts

@@ -1,240 +0,0 @@
-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

@@ -1,174 +0,0 @@
-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

@@ -1,302 +0,0 @@
-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);
-  }
-}