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

package/src/graphql/graphql_field_helpers.ts

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

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

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

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

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

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