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

package/src/graphql/graphql_field_helpers.ts

@@ -1,221 +0,0 @@
-import {
-  GQLCapture,
-  CustomField,
-  Field,
-  CustomObject,
-  CustomMutation,
-  CustomQuery,
-  CustomType,
-  CustomTypeInput,
-} from "./graphql";
-
-export function validateOneCustomField(expected: CustomField) {
-  let customFields = GQLCapture.getCustomFields();
-  // only 1 node
-  expect(customFields.size).toBe(1);
-  let fields = customFields.get(expected.nodeName);
-  expect(fields).toBeDefined();
-  validateCustomFieldImpl(expected, fields![0]);
-}
-
-function validateCustomFieldsImpl(
-  expected: CustomField[],
-  actual: CustomField[],
-) {
-  expect(actual.length).toBe(expected.length);
-
-  for (let i = 0; i < actual.length; i++) {
-    let customField = actual[i];
-    let expectedCustomField = expected[i];
-    validateCustomFieldImpl(expectedCustomField, customField);
-  }
-}
-
-function validateCustomFieldImpl(
-  expectedCustomField: CustomField,
-  customField: CustomField,
-) {
-  expect(customField.nodeName).toBe(expectedCustomField.nodeName);
-  expect(customField.functionName).toBe(expectedCustomField.functionName);
-  expect(customField.gqlName).toBe(expectedCustomField.gqlName);
-  expect(customField.fieldType).toBe(expectedCustomField.fieldType);
-
-  validateFields(customField.results, expectedCustomField.results);
-
-  validateFields(customField.args, expectedCustomField.args);
-}
-
-// we keep the simple API for the client and map to what the underlying data structure supports...
-export function validateCustomFields(expected: CustomField[]) {
-  let map = new Map<string, CustomField[]>();
-  expected.forEach((field) => {
-    let list = map.get(field.nodeName);
-
-    if (list === undefined) {
-      list = [field];
-      map.set(field.nodeName, list);
-    } else {
-      list.push(field);
-    }
-  });
-
-  let customFields = GQLCapture.getCustomFields();
-
-  expect(map.size).toEqual(customFields.size);
-
-  for (const [key, list] of customFields) {
-    let expFields = map.get(key);
-    expect(expFields).toBeDefined();
-
-    validateCustomFieldsImpl(expFields!, list);
-  }
-}
-
-export function validateCustomMutations(expected: CustomMutation[]) {
-  validateCustomFieldsImpl(expected, GQLCapture.getCustomMutations());
-}
-
-export function validateCustomQueries(expected: CustomQuery[]) {
-  validateCustomFieldsImpl(expected, GQLCapture.getCustomQueries());
-}
-
-export function validateFields(actual: Field[], expected: Field[]) {
-  expect(actual.length).toBe(expected.length);
-
-  for (let j = 0; j < actual.length; j++) {
-    let field = actual[j];
-    let expField = expected[j];
-
-    expect(field.type).toBe(expField.type);
-    expect(field.name).toBe(expField.name);
-    expect(field.needsResolving, field.name).toBe(expField.needsResolving);
-    expect(field.nullable, field.name).toBe(expField.nullable);
-    expect(field.isContextArg, field.name).toBe(expField.isContextArg);
-
-    // TODO set this for everyone and then don't need this...
-    if (expField.tsType) {
-      expect(field.tsType).toBe(expField.tsType);
-    }
-  }
-}
-
-export function validateNoCustomFields() {
-  expect(GQLCapture.getCustomFields().size).toBe(0);
-}
-
-function validateCustom(
-  expected: CustomObject[],
-  actual: Map<string, CustomObject>,
-) {
-  expect(actual.size).toBe(expected.length);
-
-  for (let i = 0; i < expected.length; i++) {
-    let expectedObj = expected[i];
-    let obj = actual.get(expectedObj.className);
-    expect(obj).not.toBe(undefined);
-    //    let arg = args[i];
-
-    expect(obj!.className).toBe(expectedObj.className);
-    expect(obj!.nodeName).toBe(expectedObj.nodeName);
-  }
-}
-
-export function validateCustomArgs(expected: CustomObject[]) {
-  validateCustom(expected, GQLCapture.getCustomArgs());
-}
-
-export function validateCustomInputObjects(expected: CustomObject[]) {
-  validateCustom(expected, GQLCapture.getCustomInputObjects());
-}
-
-export function validateCustomObjects(expected: CustomObject[]) {
-  validateCustom(expected, GQLCapture.getCustomObjects());
-}
-
-export function validateCustomInterfaces(expected: CustomObject[]) {
-  validateCustom(expected, GQLCapture.getCustomInterfaces());
-}
-
-export function validateCustomUnions(expected: CustomObject[]) {
-  validateCustom(expected, GQLCapture.getCustomUnions());
-}
-
-export function validateNoCustomArgs() {
-  expect(GQLCapture.getCustomArgs().size).toBe(0);
-}
-
-export function validateNoCustomQueries() {
-  expect(GQLCapture.getCustomQueries().length).toBe(0);
-}
-
-export function validateNoCustomMutations() {
-  expect(GQLCapture.getCustomMutations().length).toBe(0);
-}
-
-export function validateNoCustomInputObjects() {
-  expect(GQLCapture.getCustomInputObjects().size).toBe(0);
-}
-
-export function validateNoCustomObjects() {
-  expect(GQLCapture.getCustomObjects().size).toBe(0);
-}
-
-export function validateNoCustomTypes() {
-  expect(GQLCapture.getCustomTypes().size).toBe(0);
-}
-
-export function validateNoCustomInterfaces() {
-  expect(GQLCapture.getCustomInterfaces().size).toBe(0);
-}
-
-export function validateNoCustomUnions() {
-  expect(GQLCapture.getCustomUnions().size).toBe(0);
-}
-
-export enum CustomObjectTypes {
-  Field = 0x1,
-  Arg = 0x2,
-  Object = 0x4,
-  InputObject = 0x8,
-  Query = 0x10,
-  Mutation = 0x20,
-  CustomTypes = 0x40,
-  Interface = 0x80,
-  Union = 0x100,
-}
-
-// what's a good name for this instead?
-export function validateNoCustom(...exceptions: number[]) {
-  let bit = 0;
-  exceptions.forEach((exp) => (bit = bit | exp));
-  const validate = (typ: CustomObjectTypes, validateFn: () => void) => {
-    if (!(bit & typ)) {
-      validateFn();
-    }
-  };
-  validate(CustomObjectTypes.Field, validateNoCustomFields);
-  validate(CustomObjectTypes.Arg, validateNoCustomArgs);
-  validate(CustomObjectTypes.Object, validateNoCustomObjects);
-  validate(CustomObjectTypes.Query, validateNoCustomQueries);
-  validate(CustomObjectTypes.Mutation, validateNoCustomMutations);
-  validate(CustomObjectTypes.InputObject, validateNoCustomInputObjects);
-  validate(CustomObjectTypes.CustomTypes, validateNoCustomTypes);
-  validate(CustomObjectTypes.Interface, validateNoCustomInterfaces);
-  validate(CustomObjectTypes.Union, validateNoCustomUnions);
-}
-
-export function validateCustomTypes(expected: CustomTypeInput[]) {
-  const actual = GQLCapture.getCustomTypes();
-  expect(actual.size).toBe(expected.length);
-
-  for (let i = 0; i < expected.length; i++) {
-    let expectedObj = expected[i];
-    let obj = actual.get(expectedObj.type);
-    expect(obj).not.toBe(undefined);
-
-    expect(obj!.type).toBe(expectedObj.type);
-    expect(obj!.importPath).toBe(expectedObj.importPath);
-    expect(obj!.tsType).toBe(expectedObj.tsType);
-    expect(obj!.tsImportPath).toBe(expectedObj.tsImportPath);
-  }
-}

package/src/graphql/index.ts

@@ -1,42 +0,0 @@
-export {
-  gqlFieldOptions,
-  gqlObjectOptions,
-  gqlField,
-  gqlArgType,
-  gqlInputObjectType,
-  gqlObjectType,
-  gqlQuery,
-  gqlMutation,
-  gqlContextType,
-  gqlConnection,
-  GraphQLConnection,
-  GQLCapture,
-  gqlFileUpload,
-  CustomType,
-  gqlInterfaceType,
-  gqlUnionType,
-} from "./graphql";
-
-export { GraphQLTime } from "./scalars/time";
-export { GraphQLOrderByDirection } from "./scalars/orderby_direction";
-export { GraphQLPageInfo } from "./query/page_info";
-export { GraphQLEdge, GraphQLEdgeConnection } from "./query/edge_connection";
-export {
-  GraphQLEdgeType,
-  GraphQLConnectionType,
-} from "./query/connection_type";
-export { GraphQLNodeInterface } from "./builtins/node";
-export { GraphQLConnectionInterface } from "./builtins/connection";
-export { GraphQLEdgeInterface } from "./builtins/edge";
-export {
-  NodeResolver,
-  EntNodeResolver,
-  registerResolver,
-  clearResolvers,
-  resolveID,
-  nodeIDEncoder,
-  mustDecodeIDFromGQLID,
-  mustDecodeNullableIDFromGQLID,
-  encodeGQLID,
-} from "./node_resolver";
-export { transformUnionTypes } from "./mutations/union";

package/src/graphql/mutations/union.ts

@@ -1,39 +0,0 @@
-import { Data } from "../../core/base";
-
-// this transforms an input for union types from graphql format to TS format
-// in graphql, we represent it as UnionType =  {foo: FooType, bar: BarType, baz: BazType}
-// in TS, we repseent it as UnionType = FooType | BarType | BazType
-// this takes an input, paths to unions and transforms them as needed
-// only works on fields that are defined. depends on graphql to handle nullable/missing fields
-export function transformUnionTypes<T extends Data>(
-  input: T,
-  pathsList: string[][],
-) {
-  for (const paths of pathsList) {
-    const lastPath = paths[paths.length - 1];
-    let last: Data = input;
-    for (const path of paths) {
-      let curr = last[path];
-
-      if (curr === undefined) {
-        break;
-      }
-      if (path === lastPath) {
-        let count = 0;
-        let lastKey: string | undefined = undefined;
-        for (const k in curr) {
-          count++;
-          lastKey = k;
-        }
-        if (count != 1) {
-          throw new Error(
-            `can only only pass one key of union. passed ${count}`,
-          );
-        }
-        last[path] = curr[lastKey!];
-      }
-      last = curr;
-    }
-  }
-  return input;
-}

package/src/graphql/node_resolver.ts

@@ -1,122 +0,0 @@
-import { ID, Ent, Viewer } from "../core/base";
-import { loadEnt } from "../core/ent";
-import { GraphQLFieldResolver } from "graphql";
-
-interface Node {
-  id: ID;
-}
-
-export interface NodeResolver {
-  decodeObj(viewer: Viewer, id: string): Promise<Node | null>;
-}
-
-// generated loadEntByType signature....
-interface loadEnt {
-  (v: Viewer, nodeType: string, id: ID): Promise<Ent | null>;
-}
-
-export class EntNodeResolver implements NodeResolver {
-  constructor(private loader: loadEnt) {}
-
-  encode(node: Ent): string {
-    // let's do 3 parts. we take the "node" prefix
-    const str = `node:${node.nodeType}:${node.id}`;
-    return Buffer.from(str, "ascii").toString("base64");
-  }
-
-  static decode(id: string): ID | null {
-    const decoded = Buffer.from(id, "base64").toString("ascii");
-    let parts = decoded.split(":");
-    if (parts.length != 3) {
-      return null;
-    }
-    return parts[2];
-  }
-
-  mustDecode(id: string): [ID, string] {
-    const decoded = Buffer.from(id, "base64").toString("ascii");
-    let parts = decoded.split(":");
-    if (parts.length != 3) {
-      throw new Error(`invalid id ${id} passed to EntNodeResolver`);
-    }
-    return [parts[0], parts[1]];
-  }
-
-  async decodeObj(viewer: Viewer, id: string): Promise<Node | null> {
-    const decoded = Buffer.from(id, "base64").toString("ascii");
-    let parts = decoded.split(":");
-    if (parts.length != 3 || parts[0] != "node") {
-      return null;
-    }
-    return this.loader(viewer, parts[1], parts[2]);
-  }
-}
-
-let resolvers: Map<string, NodeResolver> = new Map();
-
-// used to register a new NodeResolver
-export async function registerResolver(name: string, resolver: NodeResolver) {
-  resolvers.set(name, resolver);
-}
-
-// mainly needed for tests
-export async function clearResolvers() {
-  resolvers.clear();
-}
-
-export async function resolveID(
-  viewer: Viewer,
-  id: string,
-): Promise<Node | null> {
-  for (const [_, resolver] of resolvers) {
-    const node = await resolver.decodeObj(viewer, id);
-    if (node !== null) {
-      return node;
-    }
-  }
-  return null;
-}
-
-// this takes an id and uses the default node resolver which
-// should have been registered as part of entcodegen and decodes
-export const nodeIDEncoder: GraphQLFieldResolver<Ent, {}> = (
-  source: Ent,
-  _args: {},
-) => {
-  const r = resolvers.get("entNode") as EntNodeResolver;
-  if (!r) {
-    throw new Error(`cannot resolve id when entNode not previously registered`);
-  }
-  return r.encode(source);
-};
-
-// This takes a GraphQL id and converts it to an ent id
-export function mustDecodeIDFromGQLID(id: string): ID {
-  const decoded = EntNodeResolver.decode(id);
-  if (!decoded) {
-    throw new Error(`wasn't able to decode invalid ${id}`);
-  }
-  return decoded;
-}
-
-// TODO get the right (non-any) return type here. may need to change codegen to do the right thing here
-export function mustDecodeNullableIDFromGQLID(
-  id: string | null | undefined,
-): any {
-  // support undefined because fields in action
-  if (id === null || id === undefined) {
-    return id;
-  }
-  const decoded = EntNodeResolver.decode(id);
-  if (!decoded) {
-    throw new Error(`wasn't able to decode invalid ${id}`);
-  }
-  return decoded;
-}
-
-// This takes an ent and returns the graphql id
-export function encodeGQLID(node: Ent): string {
-  // let's do 3 parts. we take the "node" prefix
-  const str = `node:${node.nodeType}:${node.id}`;
-  return Buffer.from(str, "ascii").toString("base64");
-}

package/src/graphql/query/connection_type.ts

@@ -1,113 +0,0 @@
-import {
-  GraphQLFieldConfigMap,
-  GraphQLInt,
-  GraphQLList,
-  GraphQLNonNull,
-  GraphQLObjectType,
-  GraphQLInterfaceType,
-  GraphQLString,
-} from "graphql";
-import { RequestContext } from "../../core/context";
-import { GraphQLEdge, GraphQLEdgeConnection } from "./edge_connection";
-import { GraphQLPageInfo } from "./page_info";
-import { GraphQLEdgeInterface } from "../builtins/edge";
-import { GraphQLConnectionInterface } from "../builtins/connection";
-import { Data, Ent, Viewer } from "../../core/base";
-
-type nodeType = GraphQLObjectType | GraphQLInterfaceType;
-export class GraphQLEdgeType<
-  TNode extends nodeType,
-  TEdge extends Data,
-  TViewer extends Viewer,
-> extends GraphQLObjectType {
-  constructor(
-    name: string,
-    nodeType: TNode,
-    optionalFields?: () => GraphQLFieldConfigMap<
-      GraphQLEdge<TEdge>,
-      RequestContext<TViewer>
-    >,
-  ) {
-    let optional:
-      | GraphQLFieldConfigMap<GraphQLEdge<TEdge>, RequestContext<TViewer>>
-      | undefined;
-    if (optionalFields) {
-      optional = optionalFields();
-    }
-    super({
-      name: `${name}Edge`,
-      fields: (): GraphQLFieldConfigMap<
-        GraphQLEdge<TEdge>,
-        RequestContext<TViewer>
-      > => ({
-        node: {
-          type: new GraphQLNonNull(nodeType),
-        },
-        cursor: {
-          type: new GraphQLNonNull(GraphQLString),
-        },
-        ...optional,
-      }),
-      interfaces: [GraphQLEdgeInterface],
-    });
-  }
-}
-
-interface connectionOptions<T extends Data, TViewer extends Viewer> {
-  fields?(): GraphQLFieldConfigMap<GraphQLEdge<T>, RequestContext<TViewer>>;
-}
-
-export class GraphQLConnectionType<
-  TNode extends nodeType,
-  TEdge extends Data,
-  TViewer extends Viewer,
-> extends GraphQLObjectType {
-  edgeType: GraphQLEdgeType<TNode, TEdge, TViewer>;
-  constructor(
-    name: string,
-    nodeType: TNode,
-    options?: connectionOptions<TEdge, TViewer>,
-  ) {
-    const edgeType = new GraphQLEdgeType(name, nodeType, options?.fields);
-
-    super({
-      name: `${name}Connection`,
-      fields: (): GraphQLFieldConfigMap<
-        GraphQLEdgeConnection<Ent, TEdge, TViewer>,
-        RequestContext<TViewer>
-      > => ({
-        edges: {
-          type: new GraphQLNonNull(
-            new GraphQLList(new GraphQLNonNull(edgeType)),
-          ),
-          resolve: (source: GraphQLEdgeConnection<Ent, TEdge, TViewer>) => {
-            return source.queryEdges();
-          },
-        },
-        nodes: {
-          type: new GraphQLNonNull(
-            new GraphQLList(new GraphQLNonNull(nodeType)),
-          ),
-          resolve: (source: GraphQLEdgeConnection<Ent, TEdge, TViewer>) => {
-            return source.queryNodes();
-          },
-        },
-        pageInfo: {
-          type: new GraphQLNonNull(GraphQLPageInfo),
-          resolve: (source: GraphQLEdgeConnection<Ent, TEdge, TViewer>) => {
-            return source.queryPageInfo();
-          },
-        },
-        rawCount: {
-          type: new GraphQLNonNull(GraphQLInt),
-          resolve: (source: GraphQLEdgeConnection<Ent, TEdge, TViewer>) => {
-            return source.queryTotalCount();
-          },
-        },
-      }),
-      interfaces: [GraphQLConnectionInterface],
-    });
-
-    this.edgeType = edgeType;
-  }
-}

package/src/graphql/query/edge_connection.ts

@@ -1,171 +0,0 @@
-import { EdgeQuery, PaginationInfo } from "../../core/query/query";
-import { Data, Ent, ID, Viewer } from "../../core/base";
-
-// TODO getCursor...
-export interface GraphQLEdge<T extends Data> {
-  edge: T;
-  node: Ent;
-  cursor: string;
-}
-
-interface edgeQueryCtr<
-  T extends Ent,
-  TEdge extends Data,
-  TViewer extends Viewer,
-> {
-  (v: TViewer, src: T): EdgeQuery<T, Ent, TEdge>;
-}
-
-interface edgeQueryCtr2<
-  T extends Ent,
-  TEdge extends Data,
-  TViewer extends Viewer,
-> {
-  (v: TViewer): EdgeQuery<T, Ent, TEdge>;
-}
-
-// TODO probably need to template Ent. maybe 2 ents?
-export class GraphQLEdgeConnection<
-  TSource extends Ent,
-  TEdge extends Data,
-  TViewer extends Viewer = Viewer,
-> {
-  query: EdgeQuery<TSource, Ent, TEdge>;
-  private results: GraphQLEdge<TEdge>[] = [];
-  private viewer: TViewer;
-  private source?: TSource;
-  private args?: Data;
-
-  constructor(
-    viewer: TViewer,
-    source: TSource,
-    getQuery: edgeQueryCtr<TSource, TEdge, TViewer>,
-    args?: Data,
-  );
-  constructor(
-    viewer: TViewer,
-    getQuery: edgeQueryCtr2<TSource, TEdge, TViewer>,
-    args?: Data,
-  );
-  constructor(
-    viewer: TViewer,
-    arg2: TSource | edgeQueryCtr2<TSource, TEdge, TViewer>,
-    arg3: edgeQueryCtr<TSource, TEdge, TViewer> | Data,
-    args?: Data,
-  ) {
-    this.viewer = viewer;
-    if (typeof arg2 === "function") {
-      this.query = arg2(this.viewer);
-    } else {
-      this.source = arg2;
-    }
-    if (typeof arg3 === "function") {
-      this.query = arg3(this.viewer, this.source!);
-    } else {
-      this.args = arg3;
-    }
-    if (args !== undefined) {
-      this.args = args;
-    }
-    if (this.args) {
-      if (this.args.after && !this.args.first) {
-        throw new Error("cannot process after without first");
-      }
-      if (this.args.before && !this.args.before) {
-        throw new Error("cannot process before without last");
-      }
-      if (this.args.first) {
-        this.query = this.query.first(this.args.first, this.args.after);
-      }
-      if (this.args.last) {
-        this.query = this.query.last(this.args.last, this.args.cursor);
-      }
-      // TODO custom args
-      // how to proceed
-    }
-  }
-
-  first(limit: number, cursor?: string) {
-    this.query = this.query.first(limit, cursor);
-  }
-
-  last(limit: number, cursor?: string) {
-    this.query = this.query.last(limit, cursor);
-  }
-
-  // any custom filters can be applied here...
-  modifyQuery(
-    fn: (
-      query: EdgeQuery<TSource, Ent, TEdge>,
-    ) => EdgeQuery<TSource, Ent, TEdge>,
-  ) {
-    this.query = fn(this.query);
-  }
-
-  async queryTotalCount() {
-    return await this.query.queryRawCount();
-  }
-
-  async queryEdges() {
-    // because of privacy, we need to query the node regardless of if the node is there
-    // otherwise we'd be returning a phantom edge that doesn't actually exist
-    await this.queryData();
-    return this.results;
-  }
-
-  // if nodes queried just return ents
-  // unlikely to query nodes and pageInfo so we just load this separately for now
-  async queryNodes() {
-    return await this.query.queryEnts();
-  }
-
-  private defaultPageInfo() {
-    return {
-      hasNextPage: false,
-      hasPreviousPage: false,
-      startCursor: "",
-      endCursor: "",
-    };
-  }
-
-  async queryPageInfo(): Promise<PaginationInfo> {
-    await this.queryData();
-    const paginationInfo = this.query.paginationInfo();
-    if (this.source !== undefined) {
-      return paginationInfo.get(this.source.id) || this.defaultPageInfo();
-    }
-    if (paginationInfo.size > 1) {
-      throw new Error(`Query mas more than one item yet no source was given`);
-    }
-    for (const [_, value] of paginationInfo) {
-      return value;
-    }
-    return this.defaultPageInfo();
-  }
-
-  private async queryData() {
-    const [edges, ents] = await Promise.all([
-      // TODO need a test that this will only fetch edges once
-      // and then fetch ents afterward
-      this.query.queryEdges(),
-      this.query.queryEnts(),
-    ]);
-
-    let entsMap = new Map<ID, Ent>();
-    ents.forEach((ent) => entsMap.set(ent.id, ent));
-
-    let results: GraphQLEdge<TEdge>[] = [];
-    for (const edge of edges) {
-      const node = entsMap.get(this.query.dataToID(edge));
-      if (!node) {
-        continue;
-      }
-      results.push({
-        edge,
-        node,
-        cursor: this.query.getCursor(edge),
-      });
-    }
-    this.results = results;
-  }
-}