Tutorial example (#3452)

* Initial update

* codegen update

* prettier

.eslintignore

@@ -2,6 +2,7 @@ packages/graphql-yoga/src/landing-page-html.ts
 packages/graphql-yoga/src/graphiql-html.ts
 .tool-versions
 **/generated/**
+**/*.generated.*
 examples/apollo-federation-compatibility/src/resolvers-types.ts
 **/node_modules
 **/dist

.prettierignore

@@ -13,6 +13,7 @@ packages/graphql-yoga/src/landing-page-html.ts
 packages/render-graphiql/src/graphiql.ts
 .changeset/
 examples/apollo-federation-compatibility/src/resolvers-types.ts
+examples/hackernews/**/*.generated.*
 out/
 
 # Since prettier doesn't support MDX2 he breaks formatting for the following

examples/hackernews/.gitignore

@@ -3,3 +3,5 @@ node_modules
 .env
 prisma/migrations/migration_lock.toml
 prisma/*.db*
+# Ignore codegen auto-generated files
+*.generated.*

examples/hackernews/codegen.ts

@@ -0,0 +1,16 @@
+import { defineConfig } from '@eddeee888/gcg-typescript-resolver-files';
+import type { CodegenConfig } from '@graphql-codegen/cli';
+
+const config: CodegenConfig = {
+  schema: 'src/schema/**/schema.graphql',
+  generates: {
+    'src/schema': defineConfig({
+      resolverGeneration: 'minimal',
+      typesPluginsConfig: {
+        contextType: '../context#GraphQLContext',
+      },
+    }),
+  },
+  hooks: { afterAllFileWrite: ['prettier --write'] },
+};
+export default config;

examples/hackernews/package.json

@@ -8,18 +8,22 @@
   "keywords": [],
   "scripts": {
     "check": "tsc --pretty --noEmit",
+    "codegen": "graphql-codegen",
     "dev": "cross-env NODE_ENV=development ts-node-dev --exit-child --respawn src/main.ts",
     "migrate": "prisma migrate dev",
-    "postinstall": "prisma generate",
+    "postinstall": "pnpm run prisma:generate && pnpm run codegen",
+    "precheck": "pnpm run codegen",
+    "prisma:generate": "prisma generate",
     "start": "ts-node src/main.ts"
   },
   "dependencies": {
     "graphql": "16.6.0",
     "graphql-yoga": "workspace:*"
   },
   "devDependencies": {
+    "@eddeee888/gcg-typescript-resolver-files": "0.10.4",
+    "@graphql-codegen/cli": "5.0.2",
     "@prisma/client": "5.13.0",
-    "@prisma/internals": "5.13.0",
     "@prisma/migrate": "5.13.0",
     "@types/node": "22.9.0",
     "cross-env": "7.0.3",

examples/hackernews/prisma/migrations/20220223114846_comments/migration.sql

@@ -3,6 +3,6 @@ CREATE TABLE "Comment" (
     "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
     "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
     "body" TEXT NOT NULL,
-    "linkId" INTEGER,
-    CONSTRAINT "Comment_linkId_fkey" FOREIGN KEY ("linkId") REFERENCES "Link" ("id") ON DELETE SET NULL ON UPDATE CASCADE
+    "linkId" INTEGER NOT NULL,
+    CONSTRAINT "Comment_linkId_fkey" FOREIGN KEY ("linkId") REFERENCES "Link" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
 );

examples/hackernews/prisma/schema.prisma

@@ -22,6 +22,6 @@ model Comment {
   id        Int      @id @default(autoincrement())
   createdAt DateTime @default(now())
   body      String
-  link      Link?    @relation(fields: [linkId], references: [id])
-  linkId    Int?
+  link      Link    @relation(fields: [linkId], references: [id])
+  linkId    Int
 }

examples/hackernews/src/schema.ts

@@ -1,144 +1,8 @@
-import { createGraphQLError, createSchema } from 'graphql-yoga';
-import { Prisma, type Link } from '@prisma/client';
-import type { GraphQLContext } from './context';
-
-const typeDefinitions = /* GraphQL */ `
-  type Link {
-    id: ID!
-    description: String!
-    url: String!
-    comments: [Comment!]!
-  }
-
-  type Comment {
-    id: ID!
-    body: String!
-  }
-
-  type Query {
-    hello: String!
-    feed(filterNeedle: String, skip: Int, take: Int): [Link!]!
-    comment(id: ID!): Comment
-  }
-
-  type Mutation {
-    postLink(url: String!, description: String!): Link!
-    postCommentOnLink(linkId: ID!, body: String!): Comment!
-  }
-`;
-
-const parseIntSafe = (value: string): number | null => {
-  if (/^(\d+)$/.test(value)) {
-    return parseInt(value, 10);
-  }
-  return null;
-};
-
-const applyTakeConstraints = (params: { min: number; max: number; value: number }) => {
-  if (params.value < params.min || params.value > params.max) {
-    throw createGraphQLError(
-      `'take' argument value '${params.value}' is outside the valid range of '${params.min}' to '${params.max}'.`,
-    );
-  }
-  return params.value;
-};
-
-const resolvers = {
-  Query: {
-    hello: () => `Hello World!`,
-    feed: async (
-      parent: unknown,
-      args: { filterNeedle?: string; skip?: number; take?: number },
-      context: GraphQLContext,
-    ) => {
-      const where = args.filterNeedle
-        ? {
-            OR: [
-              { description: { contains: args.filterNeedle } },
-              { url: { contains: args.filterNeedle } },
-            ],
-          }
-        : {};
-
-      const take = applyTakeConstraints({
-        min: 1,
-        max: 50,
-        value: args.take ?? 30,
-      });
-
-      return context.prisma.link.findMany({
-        where,
-        skip: args.skip,
-        take,
-      });
-    },
-    comment: async (parent: unknown, args: { id: string }, context: GraphQLContext) => {
-      return context.prisma.comment.findUnique({
-        where: { id: parseInt(args.id) },
-      });
-    },
-  },
-  Link: {
-    id: (parent: Link) => parent.id,
-    description: (parent: Link) => parent.description,
-    url: (parent: Link) => parent.url,
-    comments: (parent: Link, _: unknown, context: GraphQLContext) => {
-      return context.prisma.comment.findMany({
-        where: {
-          linkId: parent.id,
-        },
-      });
-    },
-  },
-  Mutation: {
-    postLink: async (
-      parent: unknown,
-      args: { description: string; url: string },
-      context: GraphQLContext,
-    ) => {
-      const newLink = await context.prisma.link.create({
-        data: {
-          url: args.url,
-          description: args.description,
-        },
-      });
-      return newLink;
-    },
-    postCommentOnLink: async (
-      parent: unknown,
-      args: { linkId: string; body: string },
-      context: GraphQLContext,
-    ) => {
-      const linkId = parseIntSafe(args.linkId);
-      if (linkId === null) {
-        return Promise.reject(
-          createGraphQLError(`Cannot post common on non-existing link with id '${args.linkId}'.`),
-        );
-      }
-
-      const comment = await context.prisma.comment
-        .create({
-          data: {
-            body: args.body,
-            linkId,
-          },
-        })
-        .catch((err: unknown) => {
-          if (err instanceof Prisma.PrismaClientKnownRequestError && err.code === 'P2003') {
-            return Promise.reject(
-              createGraphQLError(
-                `Cannot post common on non-existing link with id '${args.linkId}'.`,
-              ),
-            );
-          }
-          return Promise.reject(err);
-        });
-      return comment;
-    },
-  },
-};
+import { createSchema } from 'graphql-yoga';
+import { resolvers } from './schema/resolvers.generated';
+import { typeDefs } from './schema/typeDefs.generated';
 
 export const schema = createSchema({
   resolvers: [resolvers],
-  typeDefs: [typeDefinitions],
+  typeDefs: [typeDefs],
 });

examples/hackernews/src/schema/base/resolvers/Comment.ts

@@ -0,0 +1,15 @@
+import type { CommentResolvers } from '../../types.generated';
+
+export const Comment: CommentResolvers = {
+  link(parent, _arg, context) {
+    if (!parent.linkId) {
+      return null;
+    }
+
+    return context.prisma.link.findUnique({
+      where: {
+        id: parent.linkId,
+      },
+    });
+  },
+};

examples/hackernews/src/schema/base/resolvers/Link.ts

@@ -0,0 +1,11 @@
+import type { LinkResolvers } from '../../types.generated';
+
+export const Link: LinkResolvers = {
+  comments: async (parent, _arg, context) => {
+    return context.prisma.comment.findMany({
+      where: {
+        linkId: parent.id,
+      },
+    });
+  },
+};

examples/hackernews/src/schema/base/resolvers/Mutation/postCommentOnLink.ts

@@ -0,0 +1,39 @@
+import { GraphQLError } from 'graphql';
+import { Prisma } from '@prisma/client';
+import { parseIntSafe } from '../../../../utils';
+import type { MutationResolvers } from '../../../types.generated';
+
+export const postCommentOnLink: NonNullable<MutationResolvers['postCommentOnLink']> = async (
+  _parent,
+  args,
+  context,
+) => {
+  const linkId = parseIntSafe(args.linkId);
+  if (linkId === null) {
+    return Promise.reject(
+      new GraphQLError(`Cannot post comment on non-existing link with id '${args.linkId}'.`),
+    );
+  }
+
+  if (!args.body || args.body.trim().length === 0) {
+    return Promise.reject(new GraphQLError(`Comment body cannot be empty.`));
+  }
+
+  const newComment = await context.prisma.comment
+    .create({
+      data: {
+        linkId,
+        body: args.body,
+      },
+    })
+    .catch((err: unknown) => {
+      if (err instanceof Prisma.PrismaClientKnownRequestError && err.code === 'P2003') {
+        return Promise.reject(
+          new GraphQLError(`Cannot post comment on non-existing link with id '${args.linkId}'.`),
+        );
+      }
+      return Promise.reject(err);
+    });
+
+  return newComment;
+};

examples/hackernews/src/schema/base/resolvers/Mutation/postLink.ts

@@ -0,0 +1,15 @@
+import type { MutationResolvers } from '../../../types.generated';
+
+export const postLink: NonNullable<MutationResolvers['postLink']> = async (
+  _parent,
+  args,
+  context,
+) => {
+  const newLink = await context.prisma.link.create({
+    data: {
+      url: args.url,
+      description: args.description,
+    },
+  });
+  return newLink;
+};

examples/hackernews/src/schema/base/resolvers/Query/comment.ts

@@ -0,0 +1,7 @@
+import type { QueryResolvers } from '../../../types.generated';
+
+export const comment: NonNullable<QueryResolvers['comment']> = async (_parent, args, context) => {
+  return context.prisma.comment.findUnique({
+    where: { id: parseInt(args.id) },
+  });
+};

examples/hackernews/src/schema/base/resolvers/Query/feed.ts

@@ -0,0 +1,27 @@
+import { applySkipConstraints, applyTakeConstraints } from '../../../../utils';
+import type { QueryResolvers } from '../../../types.generated';
+
+export const feed: NonNullable<QueryResolvers['feed']> = async (_parent, args, context) => {
+  const where = args.filterNeedle
+    ? {
+        OR: [
+          { description: { contains: args.filterNeedle } },
+          { url: { contains: args.filterNeedle } },
+        ],
+      }
+    : {};
+
+  const take = applyTakeConstraints({
+    min: 1,
+    max: 50,
+    value: args.take ?? 30,
+  });
+
+  const skip = applySkipConstraints(args.skip ?? 0);
+
+  return context.prisma.link.findMany({
+    where,
+    skip,
+    take,
+  });
+};

examples/hackernews/src/schema/base/resolvers/Query/info.ts

@@ -0,0 +1,5 @@
+import type { QueryResolvers } from '../../../types.generated';
+
+export const info: NonNullable<QueryResolvers['info']> = async (_parent, _arg, _ctx) => {
+  return `This is the API of a Hackernews Clone`;
+};

examples/hackernews/src/schema/base/resolvers/Query/link.ts

@@ -0,0 +1,7 @@
+import type { QueryResolvers } from '../../../types.generated';
+
+export const link: NonNullable<QueryResolvers['link']> = async (_parent, args, context) => {
+  return context.prisma.link.findUnique({
+    where: { id: parseInt(args.id) },
+  });
+};

examples/hackernews/src/schema/base/schema.graphql

@@ -0,0 +1,24 @@
+type Query {
+  info: String!
+  feed(filterNeedle: String, skip: Int, take: Int): [Link!]!
+  comment(id: ID!): Comment
+  link(id: ID!): Link
+}
+
+type Mutation {
+  postLink(url: String!, description: String!): Link!
+  postCommentOnLink(linkId: ID!, body: String!): Comment!
+}
+
+type Link {
+  id: ID!
+  description: String!
+  url: String!
+  comments: [Comment!]!
+}
+
+type Comment {
+  id: ID!
+  body: String!
+  link: Link
+}

examples/hackernews/src/schema/base/schema.mappers.ts

@@ -0,0 +1,4 @@
+import type { Comment, Link } from '@prisma/client';
+
+export type LinkMapper = Link;
+export type CommentMapper = Comment;