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

package/src/graphql/query/page_info.ts

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

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

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

package/src/graphql/scalars/time.ts

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

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

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

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