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

package/src/core/global_schema.ts

@@ -1,49 +0,0 @@
-import { DBType, Field, GlobalSchema } from "../schema/schema";
-
-let globalSchema: GlobalSchema | undefined;
-let globalSchemaFields: Map<string, Field> = new Map();
-
-function isGlobalSchemaField(f: Field) {
-  switch (f.type.dbType) {
-    case DBType.Enum:
-    case DBType.StringEnum:
-    case DBType.IntEnum:
-    case DBType.JSON:
-    case DBType.JSONB:
-      return true;
-  }
-  return false;
-}
-export function setGlobalSchema(val: GlobalSchema) {
-  globalSchema = val;
-  if (val.fields) {
-    for (const [k, v] of Object.entries(val.fields)) {
-      if (isGlobalSchemaField(v) && v.type.type) {
-        globalSchemaFields.set(v.type.type, v);
-      }
-    }
-  }
-}
-
-export function clearGlobalSchema() {
-  globalSchema = undefined;
-  globalSchemaFields.clear();
-}
-
-// used by tests. no guarantee will always exist
-export function __hasGlobalSchema() {
-  return globalSchema !== undefined;
-}
-
-// used by tests. no guarantee will always exist
-export function __getGlobalSchema(): GlobalSchema | undefined {
-  return globalSchema;
-}
-
-export function __getGlobalSchemaFields() {
-  return globalSchemaFields;
-}
-
-export function __getGlobalSchemaField(type: string) {
-  return globalSchemaFields.get(type);
-}

package/src/core/loaders/assoc_count_loader.ts

@@ -1,99 +0,0 @@
-import DataLoader from "dataloader";
-import {
-  ID,
-  Context,
-  Loader,
-  LoaderFactory,
-  EdgeQueryableDataOptionsConfigureLoader,
-} from "../base";
-import {
-  getEdgeClauseAndFields,
-  loadEdgeData,
-  loadRawEdgeCountX,
-} from "../ent";
-import * as clause from "../clause";
-import { getCustomLoader, getLoader } from "./loader";
-import { createCountDataLoader } from "./raw_count_loader";
-import memoize from "memoizee";
-
-export class AssocEdgeCountLoader implements Loader<ID, number> {
-  private loaderFn: () => Promise<DataLoader<ID, number>>;
-  private loader: DataLoader<ID, number> | undefined;
-
-  constructor(
-    private edgeType: string,
-    public context?: Context,
-    private options?: EdgeQueryableDataOptionsConfigureLoader,
-  ) {
-    if (context) {
-      this.loaderFn = memoize(this.getLoader);
-    }
-  }
-
-  private async getLoader() {
-    const edgeData = await loadEdgeData(this.edgeType);
-    if (!edgeData) {
-      throw new Error(`error loading edge data for ${this.edgeType}`);
-    }
-    const { cls } = getEdgeClauseAndFields(
-      clause.Eq("edge_type", this.edgeType),
-      {
-        queryOptions: this.options,
-      },
-    );
-
-    this.loader = createCountDataLoader({
-      tableName: edgeData.edgeTable,
-      groupCol: "id1",
-      clause: cls,
-    });
-    return this.loader;
-  }
-
-  async load(id: ID): Promise<number> {
-    if (!this.loaderFn) {
-      return loadRawEdgeCountX({
-        id1: id,
-        edgeType: this.edgeType,
-        queryOptions: this.options,
-      });
-    }
-    const loader = await this.loaderFn();
-    return await loader.load(id);
-  }
-
-  clearAll() {
-    this.loader && this.loader.clearAll();
-  }
-}
-
-export class AssocEdgeCountLoaderFactory implements LoaderFactory<ID, number> {
-  name: string;
-  constructor(private edgeType: string) {
-    this.name = `assocEdgeLoader:count:${edgeType}`;
-  }
-
-  getEdgeType() {
-    return this.edgeType;
-  }
-
-  createLoader(context?: Context): AssocEdgeCountLoader {
-    return getLoader(
-      this,
-      () => new AssocEdgeCountLoader(this.edgeType, context),
-      context,
-    ) as AssocEdgeCountLoader;
-  }
-
-  createConfigurableLoader(
-    options: EdgeQueryableDataOptionsConfigureLoader,
-    context?: Context,
-  ): AssocEdgeCountLoader {
-    const key = `${this.name}:disableTransformations:${options.disableTransformations}`;
-    return getCustomLoader(
-      key,
-      () => new AssocEdgeCountLoader(this.edgeType, context, options),
-      context,
-    ) as AssocEdgeCountLoader;
-  }
-}

package/src/core/loaders/assoc_edge_loader.ts

@@ -1,250 +0,0 @@
-import DataLoader from "dataloader";
-import {
-  Context,
-  ID,
-  EdgeQueryableDataOptions,
-  Loader,
-  LoaderFactory,
-} from "../base";
-import {
-  AssocEdge,
-  loadCustomEdges,
-  AssocEdgeConstructor,
-  loadEdgeData,
-  getDefaultLimit,
-  performRawQuery,
-  loadEdgeForID2,
-  buildGroupQuery,
-  AssocEdgeData,
-  getEdgeClauseAndFields,
-} from "../ent";
-import * as clause from "../clause";
-import { logEnabled } from "../logger";
-import { CacheMap, getCustomLoader } from "./loader";
-import memoizee from "memoizee";
-
-function createLoader<T extends AssocEdge>(
-  options: EdgeQueryableDataOptions,
-  edgeType: string,
-  edgeCtr: AssocEdgeConstructor<T>,
-  edgeData: AssocEdgeData,
-) {
-  const loaderOptions: DataLoader.Options<ID, T[]> = {};
-
-  if (logEnabled("query")) {
-    loaderOptions.cacheMap = new CacheMap({
-      tableName: edgeData.edgeTable,
-    });
-  }
-
-  return new DataLoader(async (keys: ID[]) => {
-    if (keys.length === 1) {
-      // 1 key, just be simple and move on
-      // same as AssocDirectEdgeLoader
-      const r = await loadCustomEdges({
-        id1: keys[0],
-        edgeType: edgeType,
-        queryOptions: options,
-        ctr: edgeCtr,
-      });
-      return [r];
-    }
-
-    let m = new Map<ID, number>();
-    let result: T[][] = [];
-    for (let i = 0; i < keys.length; i++) {
-      result.push([]);
-      // store the index....
-      m.set(keys[i], i);
-    }
-
-    options.orderby = options.orderby || [
-      {
-        column: "time",
-        direction: "DESC",
-      },
-    ];
-    // TODO defaultEdgeQueryOptions
-    options.limit = options.limit || getDefaultLimit();
-
-    const tableName = edgeData.edgeTable;
-    const { cls: cls1, fields } = getEdgeClauseAndFields(
-      clause.Eq("edge_type", edgeType),
-      {
-        queryOptions: options,
-      },
-    );
-    const [query, cls] = buildGroupQuery({
-      tableName: tableName,
-      fields,
-      values: keys,
-      orderby: options.orderby,
-      limit: options.limit || getDefaultLimit(),
-      groupColumn: "id1",
-      clause: cls1,
-    });
-
-    const rows = await performRawQuery(query, cls.values(), cls.logValues());
-    for (const row of rows) {
-      const srcID = row.id1;
-      const idx = m.get(srcID);
-      delete row.row_num;
-      if (idx === undefined) {
-        throw new Error(
-          `malformed query. got ${srcID} back but didn't query for it`,
-        );
-      }
-      result[idx].push(new edgeCtr(row));
-    }
-    return result;
-  }, loaderOptions);
-}
-
-export interface AssocLoader<T extends AssocEdge> extends Loader<ID, T[]> {
-  loadEdgeForID2(id: ID, id2: ID): Promise<T | undefined>;
-}
-
-export class AssocEdgeLoader<T extends AssocEdge> implements Loader<ID, T[]> {
-  private loaderFn: () => Promise<DataLoader<ID, T[]>>;
-  private loader: DataLoader<ID, T[]> | undefined;
-  constructor(
-    private edgeType: string,
-    private edgeCtr: AssocEdgeConstructor<T>,
-    private options: EdgeQueryableDataOptions,
-    public context: Context,
-  ) {
-    this.loaderFn = memoizee(this.getLoader);
-  }
-
-  private async getLoader() {
-    const edgeData = await loadEdgeData(this.edgeType);
-    if (!edgeData) {
-      throw new Error(`error loading edge data for ${this.edgeType}`);
-    }
-    this.loader = createLoader(
-      this.options,
-      this.edgeType,
-      this.edgeCtr,
-      edgeData,
-    );
-    return this.loader;
-  }
-
-  async load(id: ID): Promise<T[]> {
-    const loader = await this.loaderFn();
-    return loader.load(id);
-  }
-
-  // maybe eventually optimize this
-  async loadEdgeForID2(id: ID, id2: ID) {
-    return loadEdgeForID2({
-      id1: id,
-      edgeType: this.edgeType,
-      id2,
-      context: this.context,
-      ctr: this.edgeCtr,
-      queryOptions: this.options,
-    });
-  }
-
-  clearAll() {
-    this.loader && this.loader.clearAll();
-  }
-}
-
-export class AssocDirectEdgeLoader<T extends AssocEdge>
-  implements Loader<ID, T[]>
-{
-  constructor(
-    private edgeType: string,
-    private edgeCtr: AssocEdgeConstructor<T>,
-    private options?: EdgeQueryableDataOptions,
-    public context?: Context,
-  ) {}
-
-  async load(id: ID) {
-    return loadCustomEdges({
-      id1: id,
-      edgeType: this.edgeType,
-      context: this.context,
-      queryOptions: this.options,
-      ctr: this.edgeCtr,
-    });
-  }
-
-  async loadEdgeForID2(id: ID, id2: ID) {
-    return loadEdgeForID2({
-      id1: id,
-      edgeType: this.edgeType,
-      id2,
-      context: this.context,
-      queryOptions: this.options,
-      ctr: this.edgeCtr,
-    });
-  }
-
-  clearAll() {}
-}
-
-export class AssocEdgeLoaderFactory<T extends AssocEdge>
-  implements LoaderFactory<ID, T[]>
-{
-  name: string;
-
-  constructor(
-    private edgeType: string,
-    private edgeCtr: AssocEdgeConstructor<T> | (() => AssocEdgeConstructor<T>),
-  ) {
-    this.name = `assocEdgeLoader:${edgeType}`;
-  }
-
-  createLoader(context?: Context) {
-    return this.createConfigurableLoader({}, context);
-  }
-
-  private isConstructor(
-    edgeCtr: AssocEdgeConstructor<T> | (() => AssocEdgeConstructor<T>),
-  ): edgeCtr is AssocEdgeConstructor<T> {
-    return (
-      edgeCtr.prototype &&
-      edgeCtr.prototype.constructor &&
-      edgeCtr.prototype.constructor.name.length > 0
-    );
-  }
-
-  createConfigurableLoader(
-    options: EdgeQueryableDataOptions,
-    context?: Context,
-  ): AssocLoader<T> {
-    let edgeCtr = this.edgeCtr;
-    // in generated code, the edge is not necessarily defined at the time of loading
-    // so we call this as follows:
-    // const loader = new AssocEdgeLoaderFactory(EdgeType.Foo, ()=>DerivedEdgeClass);
-    if (!this.isConstructor(edgeCtr)) {
-      edgeCtr = edgeCtr();
-    }
-    // rename to make TS happy
-    let ctr: AssocEdgeConstructor<T> = edgeCtr;
-
-    // there's a clause which implies there's an offset or something else complicated
-    // let's be simple for now and just return a regular Loader that does nothing fancy and hits
-    // the db for each query
-    // or no context. just do the simple query
-    if (options?.clause || !context) {
-      return new AssocDirectEdgeLoader(
-        this.edgeType,
-        edgeCtr,
-        options,
-        context,
-      );
-    }
-
-    // we create a loader which can combine first X queries in the same fetch
-    const key = `${this.name}:limit:${options.limit}:orderby:${options.orderby}:disableTransformations:${options.disableTransformations}`;
-    return getCustomLoader(
-      key,
-      () => new AssocEdgeLoader(this.edgeType, ctr, options, context),
-      context,
-    ) as AssocEdgeLoader<T>;
-  }
-}

package/src/core/loaders/index.ts

@@ -1,12 +0,0 @@
-export { ObjectLoader, ObjectLoaderFactory } from "./object_loader";
-export { RawCountLoader, RawCountLoaderFactory } from "./raw_count_loader";
-export {
-  AssocEdgeCountLoader,
-  AssocEdgeCountLoaderFactory,
-} from "./assoc_count_loader";
-export {
-  AssocDirectEdgeLoader,
-  AssocEdgeLoader,
-  AssocEdgeLoaderFactory,
-} from "./assoc_edge_loader";
-export { QueryLoaderFactory } from "./query_loader";

package/src/core/loaders/loader.ts

@@ -1,66 +0,0 @@
-import { Loader, LoaderFactory, Context, DataOptions } from "../base";
-import { log } from "../logger";
-
-// this is like factory factory FML
-// helper function to handle context vs not
-// and to keep the API clean for clients who shouldn't have to worry about this
-export function getLoader<K, V>(
-  factory: LoaderFactory<K, V>,
-  create: () => Loader<K, V>,
-  context?: Context,
-): Loader<K, V> {
-  // just create a new one every time if no context cache
-  if (!context?.cache) {
-    log("debug", `new loader created for ${factory.name}`);
-    return create();
-  }
-
-  // g|set from context cache
-  return context.cache.getLoader(factory.name, create);
-}
-
-export function getCustomLoader<K, V>(
-  key: string,
-  create: () => Loader<K, V>,
-  context?: Context,
-): Loader<K, V> {
-  // just create a new one every time if no context cache
-  if (!context?.cache) {
-    log("debug", `new loader created for ${key}`);
-    return create();
-  }
-
-  // g|set from context cache
-  return context.cache.getLoader(key, create);
-}
-
-export class CacheMap {
-  private m = new Map();
-  constructor(private options: DataOptions) {}
-  get(key) {
-    const ret = this.m.get(key);
-    if (ret) {
-      // should this be debug?
-      // might be a lot?
-      // TODO this is not the best log format
-      // was designed for ObjectLoader time. Now we have different needs e.g. count, assoc etc
-      log("cache", {
-        "dataloader-cache-hit": key,
-        "tableName": this.options.tableName,
-      });
-    }
-    return ret;
-  }
-
-  set(key, value) {
-    return this.m.set(key, value);
-  }
-
-  delete(key) {
-    return this.m.delete(key);
-  }
-
-  clear() {
-    return this.m.clear();
-  }
-}