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

package/src/graphql/query/page_info.ts

@@ -0,0 +1,34 @@
+import {
+  GraphQLBoolean,
+  GraphQLFieldConfigMap,
+  GraphQLNonNull,
+  GraphQLString,
+  GraphQLObjectType,
+} from "graphql";
+import { RequestContext } from "../../core/context";
+import { PaginationInfo } from "../../core/query/query";
+
+// NB: if this changes, need to update renderer.go also
+export const GraphQLPageInfo = new GraphQLObjectType({
+  name: "PageInfo",
+  fields: (): GraphQLFieldConfigMap<PaginationInfo, RequestContext> => ({
+    hasNextPage: {
+      type: new GraphQLNonNull(GraphQLBoolean),
+      resolve: (source: PaginationInfo) => {
+        return source.hasNextPage || false;
+      },
+    },
+    hasPreviousPage: {
+      type: new GraphQLNonNull(GraphQLBoolean),
+      resolve: (source: PaginationInfo) => {
+        return source.hasPreviousPage || false;
+      },
+    },
+    startCursor: {
+      type: new GraphQLNonNull(GraphQLString),
+    },
+    endCursor: {
+      type: new GraphQLNonNull(GraphQLString),
+    },
+  }),
+});

package/src/graphql/query/shared_edge_connection.ts

@@ -0,0 +1,287 @@
+import { IDViewer } from "../../core/viewer";
+import { Viewer, Data, Ent } from "../../core/base";
+import { getCursor } from "../../core/ent";
+import { GraphQLEdgeConnection } from "./edge_connection";
+import { FakeUser, FakeContact } from "../../testutils/fake_data/index";
+import {
+  inputs,
+  createAllContacts,
+} from "../../testutils/fake_data/test_helpers";
+import { EdgeQuery } from "../../core/query/query";
+
+class TestConnection<TEdge extends Data> {
+  private user: FakeUser;
+  private allContacts: FakeContact[];
+  private filteredContacts: FakeContact[] = [];
+
+  conn: GraphQLEdgeConnection<Ent, TEdge>;
+  constructor(
+    private getQuery: (
+      v: Viewer,
+      user: FakeUser,
+    ) => EdgeQuery<FakeContact, Ent, TEdge>,
+    private ents: (contacts: FakeContact[]) => FakeContact[],
+    private filter?: (
+      conn: GraphQLEdgeConnection<Ent, TEdge>,
+      user: FakeUser,
+      contacts: FakeContact[],
+    ) => void,
+  ) {}
+
+  async beforeEach() {
+    [this.user, this.allContacts] = await createAllContacts();
+    this.allContacts = this.allContacts.reverse();
+    this.conn = new GraphQLEdgeConnection<Ent, TEdge>(
+      new IDViewer(this.user.id),
+      this.user,
+      (v, user: FakeUser) => this.getQuery(v, user),
+    );
+    if (this.filter) {
+      this.filter(this.conn, this.user, this.allContacts);
+    }
+    this.filteredContacts = this.ents(this.allContacts);
+  }
+
+  async testTotalCount() {
+    const count = await this.conn.queryTotalCount();
+    expect(count).toBe(inputs.length);
+  }
+
+  async testNodes() {
+    const nodes = await this.conn.queryNodes();
+    expect(nodes.length).toBe(this.filteredContacts.length);
+    for (let i = 0; i < this.filteredContacts.length; i++) {
+      expect(nodes[i].id).toBe(this.filteredContacts[i].id);
+    }
+  }
+
+  async testEdges() {
+    const edges = await this.conn.queryEdges();
+    expect(edges.length).toBe(this.filteredContacts.length);
+    for (let i = 0; i < this.filteredContacts.length; i++) {
+      const edge = edges[i];
+      expect(edge.node.id).toBe(this.filteredContacts[i].id);
+      expect(this.conn.query.dataToID(edge.edge)).toBe(
+        this.filteredContacts[i].id,
+      );
+    }
+  }
+}
+
+interface options<TEnt extends Ent, TEdge extends Data> {
+  getQuery: (v: Viewer, src: Ent) => EdgeQuery<TEnt, Ent, TEdge>;
+  tableName: string;
+  sortCol: string;
+}
+
+export const commonTests = <TEdge extends Data>(
+  opts: options<FakeContact, TEdge>,
+) => {
+  function getCursorFrom(contacts: FakeContact[], idx: number) {
+    return getCursor({
+      row: contacts[idx],
+      col: "id",
+    });
+  }
+
+  describe("no filters", () => {
+    const filter = new TestConnection(
+      (v, user: FakeUser) => opts.getQuery(v, user),
+      (contacts) => contacts,
+    );
+
+    beforeEach(async () => {
+      await filter.beforeEach();
+    });
+
+    test("totalCount", async () => {
+      await filter.testTotalCount();
+    });
+
+    test("nodes", async () => {
+      await filter.testNodes();
+    });
+
+    test("edges", async () => {
+      await filter.testEdges();
+    });
+
+    test("pagination", async () => {
+      const pagination = await filter.conn.queryPageInfo();
+      expect(pagination.hasNextPage).toBe(false);
+      expect(pagination.hasPreviousPage).toBe(false);
+    });
+  });
+
+  describe("filters. firstN", () => {
+    const filter = new TestConnection(
+      (v, user: FakeUser) => opts.getQuery(v, user),
+      (contacts) => contacts.slice(0, 2),
+      (conn: GraphQLEdgeConnection<Ent, TEdge>) => {
+        conn.first(2);
+      },
+    );
+
+    beforeEach(async () => {
+      await filter.beforeEach();
+    });
+
+    test("totalCount", async () => {
+      await filter.testTotalCount();
+    });
+
+    test("nodes", async () => {
+      await filter.testNodes();
+    });
+
+    test("edges", async () => {
+      await filter.testEdges();
+    });
+
+    test("pagination", async () => {
+      const [pagination, edges] = await Promise.all([
+        filter.conn.queryPageInfo(),
+        filter.conn.queryEdges(),
+      ]);
+      expect(pagination.hasNextPage).toBe(true);
+      expect(pagination.hasPreviousPage).toBe(false);
+      expect(edges.length).toBe(2);
+      expect(edges[0].cursor).toBe(pagination.startCursor);
+      expect(edges[1].cursor).toBe(pagination.endCursor);
+    });
+  });
+
+  describe("filters. firstN + cursor", () => {
+    const idx = 1;
+    const N = 3;
+    const filter = new TestConnection(
+      (v, user: FakeUser) => opts.getQuery(v, user),
+      // get the next 2
+      (contacts) => contacts.slice(idx + 1, idx + N),
+      (
+        conn: GraphQLEdgeConnection<Ent, TEdge>,
+        user: FakeUser,
+        contacts: FakeContact[],
+      ) => {
+        const cursor = getCursorFrom(contacts, idx);
+        conn.first(2, cursor);
+      },
+    );
+
+    beforeEach(async () => {
+      await filter.beforeEach();
+    });
+
+    test("totalCount", async () => {
+      await filter.testTotalCount();
+    });
+
+    test("nodes", async () => {
+      await filter.testNodes();
+    });
+
+    test("edges", async () => {
+      await filter.testEdges();
+    });
+
+    test("pagination", async () => {
+      const [pagination, edges] = await Promise.all([
+        filter.conn.queryPageInfo(),
+        filter.conn.queryEdges(),
+      ]);
+      expect(pagination.hasNextPage).toBe(true);
+      expect(pagination.hasPreviousPage).toBe(false);
+      expect(edges.length).toBe(2);
+      expect(edges[0].cursor).toBe(pagination.startCursor);
+      expect(edges[1].cursor).toBe(pagination.endCursor);
+    });
+  });
+
+  describe("filters. before  cursor", () => {
+    const filter = new TestConnection(
+      (v, user: FakeUser) => opts.getQuery(v, user),
+      (contacts) => contacts.slice(2, 4).reverse(),
+      (
+        conn: GraphQLEdgeConnection<Ent, TEdge>,
+        user: FakeUser,
+        contacts: FakeContact[],
+      ) => {
+        // get the 2 before it
+        const cursor = getCursorFrom(contacts, 4);
+
+        conn.last(2, cursor);
+      },
+    );
+
+    beforeEach(async () => {
+      await filter.beforeEach();
+    });
+
+    test("totalCount", async () => {
+      await filter.testTotalCount();
+    });
+
+    test("nodes", async () => {
+      await filter.testNodes();
+    });
+
+    test("edges", async () => {
+      await filter.testEdges();
+    });
+
+    test("pagination", async () => {
+      const [pagination, edges] = await Promise.all([
+        filter.conn.queryPageInfo(),
+        filter.conn.queryEdges(),
+      ]);
+      expect(pagination.hasNextPage).toBe(false);
+      expect(pagination.hasPreviousPage).toBe(true);
+      expect(edges.length).toBe(2);
+      expect(edges[0].cursor).toBe(pagination.startCursor);
+      expect(edges[1].cursor).toBe(pagination.endCursor);
+    });
+  });
+
+  describe("no source", () => {
+    test("no filter", async () => {
+      const [user, allContacts] = await createAllContacts();
+
+      const conn = new GraphQLEdgeConnection<FakeContact, TEdge>(
+        new IDViewer(user.id),
+        (v) => opts.getQuery(v, user),
+      );
+      allContacts.reverse();
+
+      const nodes = await conn.queryNodes();
+      expect(nodes.length).toBe(allContacts.length);
+      for (let i = 0; i < allContacts.length; i++) {
+        expect(nodes[i].id).toBe(allContacts[i].id);
+      }
+
+      const pagination = await conn.queryPageInfo();
+      expect(pagination.hasNextPage).toBe(false);
+      expect(pagination.hasPreviousPage).toBe(false);
+    });
+
+    test("with filter", async () => {
+      const [user, allContacts] = await createAllContacts();
+
+      const conn = new GraphQLEdgeConnection<Ent, TEdge>(
+        new IDViewer(user.id),
+        (v) => opts.getQuery(v, user).first(2),
+      );
+      allContacts.reverse();
+      const filtered = allContacts.slice(0, 2);
+
+      const nodes = await conn.queryNodes();
+      expect(nodes.length).toBe(filtered.length);
+      for (let i = 0; i < filtered.length; i++) {
+        expect(nodes[i].id).toBe(filtered[i].id);
+      }
+
+      const pagination = await conn.queryPageInfo();
+      expect(pagination.hasNextPage).toBe(true);
+      expect(pagination.hasPreviousPage).toBe(false);
+    });
+  });
+};

package/src/graphql/scalars/orderby_direction.ts

@@ -0,0 +1,13 @@
+import { GraphQLEnumType } from "graphql";
+
+export const GraphQLOrderByDirection = new GraphQLEnumType({
+  name: "OrderByDirection",
+  values: {
+    ASC: {
+      value: "ASC",
+    },
+    DESC: {
+      value: "DESC",
+    },
+  },
+});

package/src/graphql/scalars/time.ts

@@ -0,0 +1,38 @@
+import { GraphQLScalarType, GraphQLError } from "graphql";
+import { Kind, ValueNode } from "graphql/language";
+import { DateTime } from "luxon";
+import { parseDate } from "../../core/date";
+
+// Time refers to a Timestamp or Date scalar
+
+function parseValue(input: any): Date {
+  return parseDate(input, (msg: string) => {
+    return new GraphQLError(msg);
+  }).toJSDate();
+}
+
+// Date or Timestamp
+// Need feedback. should this be renamed to Timestamp?
+// This is called Time but only supports Date and Timestamp values
+// and `Time` isn't supported. that's a string
+export const GraphQLTime = new GraphQLScalarType({
+  name: "Time",
+  description: "Time scalar type",
+  serialize: (outputValue: any) => {
+    if (outputValue instanceof Date) {
+      return outputValue.toISOString();
+    } else if (outputValue instanceof DateTime) {
+      return outputValue.toUTC().toISO();
+    }
+    return parseValue(outputValue).toISOString();
+  },
+  parseValue: parseValue,
+  parseLiteral: (ast: ValueNode) => {
+    //    console.log("literal", ast);
+    if (ast.kind === Kind.INT) {
+      return new Date(+ast.value);
+    }
+    // TODO?
+    throw new GraphQLError(`Time cannot represent literal value ${ast}`);
+  },
+});

package/src/imports/dataz/example1/_auth.ts

@@ -0,0 +1,51 @@
+import {
+  gqlInputObjectType,
+  gqlField,
+  gqlMutation,
+  gqlObjectType,
+} from "../../../graphql/graphql";
+import { ID } from "../../../core/base";
+import { GraphQLID, GraphQLString } from "graphql";
+
+@gqlInputObjectType()
+class UserAuthInput {
+  @gqlField({
+    class: "UserAuthInput",
+    type: GraphQLString,
+  })
+  emailAddress: string;
+  @gqlField({
+    class: "UserAuthInput",
+    type: GraphQLString,
+  })
+  password: string;
+}
+
+@gqlObjectType()
+class UserAuthResponse {
+  @gqlField({
+    class: "UserAuthResponse",
+    type: GraphQLString,
+  })
+  token: string;
+
+  @gqlField({ class: "UserAuthResponses", type: GraphQLID })
+  viewerID: ID;
+}
+
+class AuthResolver {
+  @gqlMutation({
+    class: "AuthResolver",
+    name: "userAuth",
+    type: UserAuthResponse,
+    args: [
+      {
+        name: "input",
+        type: UserAuthInput,
+      },
+    ],
+  })
+  async userAuth(input: UserAuthInput): Promise<UserAuthResponse> {
+    throw new Error("not implemented");
+  }
+}

package/src/imports/dataz/example1/_viewer.ts

@@ -0,0 +1,35 @@
+import {
+  gqlField,
+  gqlObjectType,
+  gqlContextType,
+  gqlQuery,
+} from "../../../graphql/graphql";
+import { Viewer } from "../../../core/base";
+import { GraphQLID } from "graphql";
+import { RequestContext } from "../../../core/context";
+
+@gqlObjectType({ name: "Viewer" })
+class ViewerType {
+  constructor(private viewer: Viewer) {}
+
+  @gqlField({
+    class: "ViewerType",
+    type: GraphQLID,
+    nullable: true,
+  })
+  get viewerID() {
+    return this.viewer.viewerID;
+  }
+}
+
+export default class ViewerResolver {
+  @gqlQuery({
+    class: "ViewerResolver",
+    name: "viewer",
+    type: ViewerType,
+    args: [gqlContextType()],
+  })
+  viewer(context: RequestContext): ViewerType {
+    return new ViewerType(context.getViewer());
+  }
+}

package/src/imports/index.ts

@@ -0,0 +1,213 @@
+import * as glob from "glob";
+import ts from "typescript";
+import * as fs from "fs";
+import * as path from "path";
+import { readCompilerOptions } from "../tsc/compilerOptions";
+
+function getFiles(filePath: string, opts?: Options): string[] {
+  if (!path.isAbsolute(filePath)) {
+    throw new Error("absolute file path required");
+  }
+  // graphql path should be passed to this
+  // this is more agnostic about what it expect here
+
+  let pattern = `${filePath}/**/*.ts`;
+  if (opts?.justCurrentDir) {
+    pattern = `${filePath}/**.ts`;
+  }
+  let files = glob.sync(pattern, {
+    ignore: opts?.ignore,
+  });
+  if (opts?.filter) {
+    files = files.filter(opts.filter);
+  }
+  return files;
+}
+
+export interface Options {
+  filter?: (file: string, index: number, array: string[]) => boolean;
+  justCurrentDir?: boolean;
+  ignore?: string | string[] | undefined;
+}
+
+export interface PathResult {
+  m: Map<string, file[]>;
+  // throws if there's more than one class that maps to this
+  getInfoForClass(className: string): classResult;
+}
+
+interface classResult {
+  class: classInfo;
+  file: file;
+}
+
+interface ParseInput {
+  root: string;
+  opts?: Options;
+}
+
+export function parseCustomImports(
+  filePath: string,
+  inputs: ParseInput[],
+): PathResult {
+  const files: string[] = [];
+  // simplifies tests and other simple callsites
+  if (inputs.length === 0) {
+    inputs.push({ root: filePath });
+  }
+  for (const input of inputs) {
+    files.push(...getFiles(input.root, input.opts));
+  }
+  const options = readCompilerOptions(filePath);
+
+  let classMap = new Map<string, file[]>();
+
+  files.forEach((file) => {
+    const sourceFile = ts.createSourceFile(
+      file,
+      fs.readFileSync(file).toString(),
+      options.target || ts.ScriptTarget.ES2015,
+    );
+
+    let f: file = {
+      path: sourceFile.fileName,
+      imports: new Map(),
+      classes: new Map(),
+    };
+    traverse(sourceFile, f, classMap);
+    //console.log(f);
+    //    console.log(classMap);
+  });
+
+  return {
+    m: classMap,
+    getInfoForClass: (className: string) => {
+      let files = classMap.get(className);
+      if (files?.length !== 1) {
+        throw new Error(
+          `expected 1 class with name ${className}, got ${
+            files?.length || 0
+          } classes instead`,
+        );
+      }
+      let f = files[0];
+      let info = f.classes.get(className);
+      if (!info) {
+        throw new Error(
+          `expected to find info for class ${className} in file ${f.path}`,
+        );
+      }
+      return {
+        class: info,
+        file: f,
+      };
+    },
+  };
+}
+
+export interface importInfo {
+  name: string; // name in the file
+  importPath: string; // where it's imported from
+  defaultImport?: boolean; // default import?
+}
+
+export interface classInfo {
+  name: string;
+  exported: boolean;
+  defaultExport: boolean;
+}
+
+export interface file {
+  path: string; // path to file
+  imports: Map<string, importInfo>; // imported things, mapping from name to importInfo
+  classes: Map<string, classInfo>; // classInfo
+}
+
+function traverse(
+  sourceFile: ts.SourceFile,
+  f: file,
+  classMap: Map<string, file[]>,
+) {
+  ts.forEachChild(sourceFile, function (node: ts.Node) {
+    switch (node.kind) {
+      case ts.SyntaxKind.ImportDeclaration:
+        let importNode = node as ts.ImportDeclaration;
+        let text = importNode.moduleSpecifier.getText(sourceFile);
+        // remove quotes
+        text = text.slice(1, -1);
+
+        let imported = importNode.importClause?.namedBindings;
+        if (imported) {
+          if (imported?.kind === ts.SyntaxKind.NamedImports) {
+            imported.elements.forEach((el) => {
+              f.imports.set(el.name.text, {
+                name: el.name.text,
+                importPath: text,
+              });
+            });
+          } else {
+            // TODO
+            //            console.log("ttt?", sourceFile.fileName, text, imported.name);
+          }
+        } else {
+          let name = importNode.importClause?.name?.text;
+          if (name) {
+            f.imports.set(name, {
+              name,
+              importPath: text,
+              defaultImport: true,
+            });
+          }
+        }
+
+        break;
+      case ts.SyntaxKind.ClassDeclaration:
+        let classNode = node as ts.ClassDeclaration;
+        //        console.log(classNode);
+        let exported = false;
+        let defaultExport = false;
+        if (classNode.modifiers?.length) {
+          classNode.modifiers.forEach((modifier) => {
+            if (modifier.kind === ts.SyntaxKind.ExportKeyword) {
+              exported = true;
+            }
+            if (modifier.kind === ts.SyntaxKind.DefaultKeyword) {
+              defaultExport = true;
+            }
+          });
+        }
+        let name = classNode.name?.text;
+        if (name) {
+          f.classes.set(name, {
+            name,
+            exported,
+            defaultExport,
+          });
+          if (classMap.has(name)) {
+            let files = classMap.get(name)!;
+            files.push(f);
+          } else {
+            let files = [f];
+            classMap.set(name, files);
+          }
+        }
+        // TODO functions and other things from files incase needed to disambiguate duplicate classes
+        //        console.log(classNode.name?.text, exported, defaultExport);
+        // classNode.members.forEach((member) => {
+        //   member.decorators?.forEach((decorator) => {
+        //     console.log(decorator.expression.getText(sourceFile));
+        //   });
+        //   console.log(
+        //     classNode.name?.text,
+        //     member.name?.getText(sourceFile),
+        //     member.decorators?.length,
+        //   );
+        // });
+
+        //        console.log(classNode.modifiers);
+        //        console.log(classNode);
+        //        classNode.members.map((member) => console.log(member));
+        break;
+    }
+  });
+}