create-fate 1.0.4 → 1.3.0

package/templates/fate/graphql/server/src/graphql/lib/authDirectives.tsx

@@ -0,0 +1,93 @@
+import SchemaBuilder, {
+  BasePlugin,
+  PothosOutputFieldConfig,
+  PothosTypeConfig,
+  SchemaTypes,
+} from '@pothos/core';
+import { FieldAuthScopes, TypeAuthScopes } from '@pothos/plugin-scope-auth';
+
+declare global {
+  export namespace PothosSchemaTypes {
+    export interface Plugins<Types extends SchemaTypes> {
+      authDirectives: AuthDirectivesPlugin<Types>;
+    }
+  }
+}
+
+export class AuthDirectivesPlugin<Types extends SchemaTypes> extends BasePlugin<Types> {
+  override onOutputFieldConfig(
+    fieldConfig: PothosOutputFieldConfig<Types>,
+  ): PothosOutputFieldConfig<Types> | null {
+    const { authScopes } = fieldConfig.pothosOptions;
+
+    if (!authScopes) {
+      return fieldConfig;
+    }
+
+    const scopes = this.#resolveScopes(authScopes);
+
+    return {
+      ...fieldConfig,
+      extensions: {
+        ...fieldConfig.extensions,
+        directives: {
+          ...(fieldConfig.extensions?.directives as Record<string, unknown>),
+          auth: scopes,
+        },
+      },
+    };
+  }
+
+  override onTypeConfig(typeConfig: PothosTypeConfig): PothosTypeConfig {
+    if (
+      typeConfig.kind === 'Enum' ||
+      typeConfig.kind === 'Scalar' ||
+      typeConfig.kind === 'InputObject' ||
+      typeConfig.kind === 'Union' ||
+      !typeConfig.pothosOptions.authScopes
+    ) {
+      return typeConfig;
+    }
+
+    const scopes = this.#resolveScopes(typeConfig.pothosOptions.authScopes);
+
+    return {
+      ...typeConfig,
+      extensions: {
+        ...typeConfig.extensions,
+        directives: {
+          ...(typeConfig.extensions?.directives as Record<string, unknown>),
+          auth: scopes,
+        },
+      },
+    };
+  }
+
+  #resolveScopes(
+    authScopes:
+      | FieldAuthScopes<Types, object, Record<string, unknown>>
+      | TypeAuthScopes<SchemaTypes, object>,
+  ) {
+    if (typeof authScopes !== 'function') {
+      return authScopes;
+    }
+
+    try {
+      const resolved = authScopes({}, {}, {}, {} as never);
+
+      if (typeof resolved !== 'object' || !resolved) {
+        return {};
+      }
+
+      return Object.fromEntries(
+        Object.entries(resolved).map(([key, value]) => [key, value === undefined ? true : value]),
+      );
+    } catch {
+      return {};
+    }
+  }
+}
+
+SchemaBuilder.registerPlugin('authDirectives', AuthDirectivesPlugin);
+
+export default 'authDirectives';

package/templates/fate/graphql/server/src/graphql/lib/decodeGlobalID.tsx

@@ -0,0 +1,12 @@
+export default function decodeGlobalID(globalID: string) {
+  const separator = globalID.indexOf('-');
+  if (separator <= 0 || separator >= globalID.length - 1) {
+    throw new Error(`decodeGlobalID: Invalid global ID '${globalID}'.`);
+  }
+  const typename = globalID.slice(0, separator);
+  const id = globalID.slice(separator + 1);
+  if (!id) {
+    throw new Error(`decodeGlobalID: Provided an empty id for '${typename}'.`);
+  }
+  return { id, typename };
+}

package/templates/fate/graphql/server/src/graphql/lib/decodeIDOrThrow.tsx

@@ -0,0 +1,10 @@
+import PrismaTypes from '../../prisma/pothos-types.ts';
+import decodeGlobalID from './decodeGlobalID.tsx';
+
+export default function decodeIDOrThrow(type: keyof PrismaTypes, globalID: string) {
+  const { id, typename } = decodeGlobalID(globalID);
+  if (typename !== type || !id) {
+    throw new Error(`Expected '${type}' but received '${typename}' with id '${id}'.`);
+  }
+  return id;
+}

package/templates/fate/graphql/server/src/graphql/lib/encodeGlobalID.tsx

@@ -0,0 +1,5 @@
+import PrismaTypes from '../../prisma/pothos-types.ts';
+
+export default function encodeGlobalID(typename: keyof PrismaTypes, id: string | number | bigint) {
+  return `${typename}-${id}`;
+}

package/templates/fate/graphql/server/src/graphql/live.tsx

@@ -0,0 +1,241 @@
+import type { LiveConnectionSourceEvent, LiveSourceEvent } from '@nkzw/fate/server';
+import { isRecord } from '@nkzw/fate/server';
+import builder, { JSONScalar } from './builder.tsx';
+import type { AppContext } from './context.tsx';
+import { fate, live, viewsByType } from './fate.ts';
+import decodeGlobalID from './lib/decodeGlobalID.tsx';
+
+type ViewType = keyof typeof viewsByType;
+
+type LiveNodePayload = {
+  data?: unknown;
+  delete?: boolean;
+  id?: string | number;
+  select?: Array<string>;
+};
+
+type LiveConnectionPayload = {
+  cursor?: string;
+  id?: string | number;
+  node?: unknown;
+  nodeType?: string;
+  targetCursor?: string;
+  type: LiveConnectionSourceEvent['type'];
+};
+
+const asRecord = (value: unknown): Record<string, unknown> | undefined =>
+  isRecord(value) ? value : undefined;
+
+const decodeLiveId = (type: string, id: string) => {
+  const decoded = decodeGlobalID(id);
+  if (decoded.typename !== type) {
+    throw new Error(`Expected '${type}' but received '${decoded.typename}'.`);
+  }
+  return decoded.id;
+};
+
+const asViewType = (type: string): ViewType => {
+  if (!(type in viewsByType)) {
+    throw new Error(`Unknown Fate live type '${type}'.`);
+  }
+  return type as ViewType;
+};
+
+async function* entityEvents(type: string, id: string) {
+  for await (const [event] of live.subscribe(type, id)) {
+    yield event;
+  }
+}
+
+async function* connectionEvents(procedure: string, args: Record<string, unknown> | undefined) {
+  for await (const [event] of live.subscribeConnection({ args, procedure })) {
+    yield event;
+  }
+}
+
+const resolveNodePayload = async ({
+  args,
+  context,
+  event,
+  select,
+  type,
+}: {
+  args?: Record<string, unknown>;
+  context: AppContext;
+  event: LiveSourceEvent;
+  select: Array<string>;
+  type: string;
+}): Promise<LiveNodePayload> => {
+  if (event.type === 'delete') {
+    return {
+      delete: true,
+      id: event.id,
+    };
+  }
+
+  const viewType = asViewType(type);
+  const eventSelect = event.changed?.filter((path) => select.includes(path));
+  const liveSelect = eventSelect?.length ? eventSelect : select;
+  const data =
+    event.data ??
+    (await fate.resolveById({
+      ctx: context,
+      id: String(event.id),
+      input: {
+        args,
+        select: liveSelect,
+      },
+      view: viewsByType[viewType] as never,
+    }));
+
+  return {
+    data,
+    id: event.id,
+    select: liveSelect,
+  };
+};
+
+const resolveConnectionPayload = async ({
+  context,
+  event,
+  select,
+  selectionArgs,
+  type,
+}: {
+  context: AppContext;
+  event: LiveConnectionSourceEvent;
+  select: Array<string>;
+  selectionArgs?: Record<string, unknown>;
+  type: string;
+}): Promise<LiveConnectionPayload> => {
+  if (event.type === 'invalidate') {
+    return { type: event.type };
+  }
+
+  if (event.type === 'deleteEdge') {
+    return {
+      id: event.id,
+      nodeType: event.nodeType ?? type,
+      type: event.type,
+    };
+  }
+
+  const nodeType = asViewType(event.nodeType ?? type);
+  const node =
+    event.node ??
+    (event.id == null
+      ? null
+      : await fate.resolveById({
+          ctx: context,
+          id: String(event.id),
+          input: {
+            args: selectionArgs,
+            select,
+          },
+          view: viewsByType[nodeType] as never,
+        }));
+
+  return {
+    cursor: event.cursor,
+    id: event.id,
+    node,
+    nodeType,
+    targetCursor: event.targetCursor,
+    type: event.type,
+  };
+};
+
+const FateLiveNodeEvent = builder.objectRef<LiveNodePayload>('FateLiveNodeEvent').implement({
+  fields: (t) => ({
+    data: t.field({
+      nullable: true,
+      resolve: (event) => event.data,
+      type: JSONScalar,
+    }),
+    delete: t.boolean({
+      nullable: true,
+      resolve: (event) => event.delete,
+    }),
+    id: t.string({
+      nullable: true,
+      resolve: (event) => (event.id == null ? null : String(event.id)),
+    }),
+    select: t.field({
+      nullable: true,
+      resolve: (event) => event.select,
+      type: ['String'],
+    }),
+  }),
+});
+
+const FateLiveConnectionEvent = builder
+  .objectRef<LiveConnectionPayload>('FateLiveConnectionEvent')
+  .implement({
+    fields: (t) => ({
+      cursor: t.string({
+        nullable: true,
+        resolve: (event) => event.cursor,
+      }),
+      id: t.string({
+        nullable: true,
+        resolve: (event) => (event.id == null ? null : String(event.id)),
+      }),
+      node: t.field({
+        nullable: true,
+        resolve: (event) => event.node,
+        type: JSONScalar,
+      }),
+      nodeType: t.string({
+        nullable: true,
+        resolve: (event) => event.nodeType,
+      }),
+      targetCursor: t.string({
+        nullable: true,
+        resolve: (event) => event.targetCursor,
+      }),
+      type: t.string({
+        nullable: false,
+        resolve: (event) => event.type,
+      }),
+    }),
+  });
+
+builder.subscriptionFields((t) => ({
+  fateLiveConnection: t.field({
+    args: {
+      args: t.arg({ type: JSONScalar }),
+      procedure: t.arg.string({ required: true }),
+      select: t.arg({ required: true, type: ['String'] }),
+      selectionArgs: t.arg({ type: JSONScalar }),
+      type: t.arg.string({ required: true }),
+    },
+    resolve: (event, { select, selectionArgs, type }, context) =>
+      resolveConnectionPayload({
+        context,
+        event: event as LiveConnectionSourceEvent,
+        select,
+        selectionArgs: asRecord(selectionArgs),
+        type,
+      }),
+    subscribe: (_root, { args, procedure }) => connectionEvents(procedure, asRecord(args)),
+    type: FateLiveConnectionEvent,
+  }),
+  fateLiveNode: t.field({
+    args: {
+      args: t.arg({ type: JSONScalar }),
+      id: t.arg.id({ required: true }),
+      select: t.arg({ required: true, type: ['String'] }),
+      type: t.arg.string({ required: true }),
+    },
+    resolve: (event, { args, select, type }, context) =>
+      resolveNodePayload({
+        args: asRecord(args),
+        context,
+        event: event as LiveSourceEvent,
+        select,
+        type,
+      }),
+    subscribe: (_root, { id, type }) => entityEvents(type, decodeLiveId(type, String(id))),
+    type: FateLiveNodeEvent,
+  }),
+}));

package/templates/fate/graphql/server/src/graphql/mutations.tsx

@@ -0,0 +1,265 @@
+import { auth } from '../lib/auth.tsx';
+import prisma from '../prisma/prisma.tsx';
+import builder, { JSONScalar } from './builder.tsx';
+import { live } from './fate.ts';
+
+const PostAddInput = builder.inputType('PostAddInput', {
+  fields: (t) => ({
+    args: t.field({ type: JSONScalar }),
+    content: t.string({ required: true }),
+    title: t.string({ required: true }),
+  }),
+});
+
+const PostLikeInput = builder.inputType('PostLikeInput', {
+  fields: (t) => ({
+    args: t.field({ type: JSONScalar }),
+    error: t.string(),
+    id: t.string({ required: true }),
+    slow: t.boolean(),
+  }),
+});
+
+const PostUnlikeInput = builder.inputType('PostUnlikeInput', {
+  fields: (t) => ({
+    args: t.field({ type: JSONScalar }),
+    id: t.string({ required: true }),
+  }),
+});
+
+const CommentAddInput = builder.inputType('CommentAddInput', {
+  fields: (t) => ({
+    args: t.field({ type: JSONScalar }),
+    content: t.string({ required: true }),
+    postId: t.string({ required: true }),
+  }),
+});
+
+const CommentDeleteInput = builder.inputType('CommentDeleteInput', {
+  fields: (t) => ({
+    args: t.field({ type: JSONScalar }),
+    id: t.string({ required: true }),
+  }),
+});
+
+const UserUpdateInput = builder.inputType('UserUpdateInput', {
+  fields: (t) => ({
+    args: t.field({ type: JSONScalar }),
+    name: t.string({ required: true }),
+  }),
+});
+
+builder.mutationField('postAdd', (t) =>
+  t.prismaField({
+    args: {
+      input: t.arg({ required: true, type: PostAddInput }),
+    },
+    resolve: async (query, _root, { input }, { sessionUser }) => {
+      if (!sessionUser) {
+        throw new Error('You must be logged in to add a post.');
+      }
+
+      const post = await prisma.post.create({
+        ...query,
+        data: {
+          authorId: sessionUser.id,
+          content: input.content,
+          title: input.title,
+        },
+      });
+
+      live.connection('posts').prependNode('Post', post.id);
+      return post;
+    },
+    type: 'Post',
+  }),
+);
+
+builder.mutationField('postLike', (t) =>
+  t.prismaField({
+    args: {
+      input: t.arg({ required: true, type: PostLikeInput }),
+    },
+    resolve: async (query, _root, { input }) => {
+      if (input.slow) {
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+      }
+
+      if (input.error === 'boundary') {
+        throw new Error('Simulated error.');
+      }
+
+      if (input.error === 'callSite') {
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        throw new Error('Gotta pay up.');
+      }
+
+      const existing = await prisma.post.findUnique({
+        where: { id: input.id },
+      });
+
+      if (!existing) {
+        throw new Error('Post not found.');
+      }
+
+      const post = await prisma.post.update({
+        ...query,
+        data: {
+          likes: {
+            increment: 1,
+          },
+        },
+        where: { id: input.id },
+      });
+
+      live.update('Post', input.id, { changed: ['likes'] });
+      return post;
+    },
+    type: 'Post',
+  }),
+);
+
+builder.mutationField('postUnlike', (t) =>
+  t.prismaField({
+    args: {
+      input: t.arg({ required: true, type: PostUnlikeInput }),
+    },
+    resolve: async (query, _root, { input }) => {
+      const post = await prisma.$transaction(async (tx) => {
+        const existing = await tx.post.findUnique({
+          select: {
+            likes: true,
+          },
+          where: {
+            id: input.id,
+          },
+        });
+
+        if (!existing) {
+          throw new Error('Post not found.');
+        }
+
+        if (existing.likes <= 0) {
+          return tx.post.findUniqueOrThrow({
+            ...query,
+            where: { id: input.id },
+          });
+        }
+
+        return tx.post.update({
+          ...query,
+          data: {
+            likes: {
+              decrement: 1,
+            },
+          },
+          where: { id: input.id },
+        });
+      });
+
+      live.update('Post', input.id, { changed: ['likes'] });
+      return post;
+    },
+    type: 'Post',
+  }),
+);
+
+builder.mutationField('commentAdd', (t) =>
+  t.prismaField({
+    args: {
+      input: t.arg({ required: true, type: CommentAddInput }),
+    },
+    resolve: async (query, _root, { input }, { sessionUser }) => {
+      if (!sessionUser) {
+        throw new Error('You must be logged in to add a comment.');
+      }
+
+      const post = await prisma.post.findUnique({
+        where: {
+          id: input.postId,
+        },
+      });
+
+      if (!post) {
+        throw new Error('Post not found.');
+      }
+
+      const comment = await prisma.comment.create({
+        ...query,
+        data: {
+          authorId: sessionUser.id,
+          content: input.content,
+          postId: input.postId,
+        },
+      });
+
+      live.connection('Post.comments', { id: input.postId }).appendNode('Comment', comment.id);
+      live.update('Post', input.postId, { changed: ['commentCount', 'comments'] });
+
+      return comment;
+    },
+    type: 'Comment',
+  }),
+);
+
+builder.mutationField('commentDelete', (t) =>
+  t.prismaField({
+    args: {
+      input: t.arg({ required: true, type: CommentDeleteInput }),
+    },
+    resolve: async (query, _root, { input }) => {
+      const comment = await prisma.comment.findUnique({
+        select: { authorId: true, postId: true },
+        where: { id: input.id },
+      });
+
+      if (!comment) {
+        throw new Error('Comment not found.');
+      }
+
+      const result = await prisma.comment.delete({
+        ...query,
+        where: { id: input.id },
+      });
+
+      live.connection('Post.comments', { id: comment.postId }).deleteEdge('Comment', input.id);
+      live.update('Post', comment.postId, { changed: ['commentCount', 'comments'] });
+
+      return result;
+    },
+    type: 'Comment',
+  }),
+);
+
+builder.mutationField('userUpdate', (t) =>
+  t.prismaField({
+    args: {
+      input: t.arg({ required: true, type: UserUpdateInput }),
+    },
+    resolve: async (query, _root, { input }, { headers, sessionUser }) => {
+      if (!sessionUser) {
+        throw new Error('You must be logged in to update your name.');
+      }
+
+      const name = input.name.trim();
+
+      if (name.length < 2 || name.length > 50) {
+        throw new Error('Name must be between 2 and 50 characters.');
+      }
+
+      await auth.api.updateUser({
+        body: { name },
+        headers,
+      });
+
+      const user = await prisma.user.findUniqueOrThrow({
+        ...query,
+        where: { id: sessionUser.id },
+      });
+
+      live.update('User', sessionUser.id, { changed: ['name'] });
+      return user;
+    },
+    type: 'User',
+  }),
+);

package/templates/fate/graphql/server/src/graphql/nodes/Category.tsx

@@ -0,0 +1,35 @@
+import prisma from '../../prisma/prisma.tsx';
+import builder from '../builder.tsx';
+
+const Category = builder.prismaNode('Category', {
+  fields: (t) => ({
+    description: t.exposeString('description'),
+    name: t.exposeString('name', { nullable: false }),
+    postCount: t.int({
+      nullable: false,
+      resolve: ({ id }) => prisma.post.count({ where: { categoryId: id } }),
+    }),
+    posts: t.relatedConnection('posts', {
+      cursor: 'id',
+      nullable: false,
+      query: {
+        orderBy: [{ createdAt: 'desc' }, { id: 'desc' }],
+      },
+    }),
+  }),
+  id: { field: 'id' },
+});
+
+builder.queryFields((t) => ({
+  categories: t.prismaConnection({
+    cursor: 'id',
+    resolve: (query) =>
+      prisma.category.findMany({
+        ...query,
+        orderBy: [{ createdAt: 'asc' }, { id: 'asc' }],
+      }),
+    type: 'Category',
+  }),
+}));
+
+export default Category;

package/templates/fate/graphql/server/src/graphql/nodes/Comment.tsx

@@ -0,0 +1,46 @@
+import prisma from '../../prisma/prisma.tsx';
+import builder from '../builder.tsx';
+
+const isDevelopment = process.env.NODE_ENV === 'development' || Boolean(process.env.DEV);
+
+const Comment = builder.prismaNode('Comment', {
+  fields: (t) => ({
+    author: t.relation('author'),
+    content: t.exposeString('content', { nullable: false }),
+    post: t.relation('post', { nullable: false }),
+  }),
+  id: { field: 'id' },
+});
+
+builder.queryFields((t) => ({
+  commentSearch: t.prismaConnection({
+    args: {
+      query: t.arg.string({ required: true }),
+    },
+    cursor: 'id',
+    resolve: async (query, _, { query: searchQuery }) => {
+      const value = searchQuery.trim();
+      if (!value.length) {
+        return [];
+      }
+
+      if (isDevelopment && value.length > 1) {
+        await new Promise((resolve) => setTimeout(resolve, 500));
+      }
+
+      return prisma.comment.findMany({
+        ...query,
+        orderBy: [{ createdAt: 'desc' }, { id: 'desc' }],
+        where: {
+          content: {
+            contains: value,
+            mode: 'insensitive',
+          },
+        },
+      });
+    },
+    type: 'Comment',
+  }),
+}));
+
+export default Comment;