create-fate 1.0.4 → 1.3.0

package/templates/fate/cloudflare/server/src/fate/server.ts

@@ -0,0 +1,411 @@
+import {
+  createFateServer,
+  createSourcePlan,
+  FateRequestError,
+  getNestedSelection,
+  getScopedArgs,
+  hasNestedSelection,
+} from '@nkzw/fate/server';
+import { createDrizzleSourceAdapter } from '@nkzw/fate/server/drizzle';
+import { createCloudflareFateLive } from 'cf-fate/server';
+import { z } from 'zod';
+import { db, eq, like } from '../../db/db.ts';
+import {
+  type CommentItem,
+  type PostItem,
+  createCommentRecord,
+  createPostRecord,
+  deleteCommentRecord,
+  likePostRecord,
+  unlikePostRecord,
+} from '../../db/queries.ts';
+import schema, { comment, user as userTable } from '../../db/schema.ts';
+import { assertCanDeleteComment, getCommentDeleteFetchSelection } from './commentPermissions.ts';
+import { createContext, type AppContext } from './context.ts';
+import { commentDataView, postDataView, Root, userDataView, type Post } from './views.ts';
+
+type ResolverOptions<Input> = {
+  ctx: AppContext;
+  input: Input;
+  select: Array<string>;
+};
+
+type ListResolverOptions = ResolverOptions<{
+  args?: Record<string, unknown>;
+}>;
+
+const source = createDrizzleSourceAdapter<AppContext>({
+  db,
+  schema,
+  views: Root,
+});
+const isDevelopment = Boolean(
+  (globalThis as { process?: { env?: Record<string, string | undefined> } }).process?.env?.DEV,
+);
+export const fateLive = createCloudflareFateLive();
+export const { live } = fateLive;
+
+type CloudflareAdapterContext = {
+  env?: {
+    BETTER_AUTH_SECRET?: string;
+  };
+};
+
+const requireUser = (ctx: AppContext) => {
+  if (!ctx.sessionUser) {
+    throw new FateRequestError('UNAUTHORIZED', 'You must be logged in.');
+  }
+
+  return ctx.sessionUser;
+};
+
+export const fateServer = createFateServer({
+  context: ({ adapterContext, request }) =>
+    createContext({
+      request,
+      secret: (adapterContext as CloudflareAdapterContext | undefined)?.env?.BETTER_AUTH_SECRET,
+    }),
+  lists: {
+    commentSearch: {
+      resolve: async ({ ctx, input, select }: ListResolverOptions) => {
+        const query = input.args?.query;
+        if (typeof query !== 'string' || !query.trim().length) {
+          return {
+            items: [],
+            pagination: { hasNext: false, hasPrevious: false },
+          };
+        }
+
+        if (isDevelopment && query.trim().length > 1) {
+          await new Promise((resolve) => setTimeout(resolve, 500));
+        }
+
+        const first = typeof input.args?.first === 'number' ? input.args.first : 20;
+        const cursor = typeof input.args?.after === 'string' ? input.args.after : undefined;
+        const nodes = await source.resolveConnection({
+          ctx,
+          cursor,
+          direction: 'forward',
+          extra: {
+            where: like(comment.content, `%${query.trim()}%`),
+          },
+          input: { args: input.args, select },
+          skip: cursor ? 1 : undefined,
+          take: first + 1,
+          view: commentDataView,
+        });
+        const hasNext = nodes.length > first;
+        const items = nodes.slice(0, first).map((node) => ({
+          cursor: String(node.id),
+          node,
+        }));
+
+        return {
+          items,
+          pagination: {
+            hasNext,
+            hasPrevious: Boolean(cursor),
+            nextCursor: items.at(-1)?.cursor,
+            previousCursor: cursor ? items[0]?.cursor : undefined,
+          },
+        };
+      },
+      type: 'Comment',
+    },
+  },
+  live,
+  mutations: {
+    'comment.add': {
+      input: z.object({
+        content: z.string().min(1, 'Content is required'),
+        postId: z.string().min(1, 'Post id is required'),
+      }),
+      resolve: async ({
+        ctx,
+        input,
+        select,
+      }: ResolverOptions<{ content: string; postId: string }>) => {
+        const user = requireUser(ctx);
+        const post = await source.resolveById({
+          ctx,
+          id: input.postId,
+          input: { select: ['id'] },
+          view: postDataView,
+        });
+
+        if (!post) {
+          throw new Error('Post not found.');
+        }
+
+        const commentId = await createCommentRecord({
+          authorId: user.id,
+          content: input.content,
+          postId: input.postId,
+        });
+
+        if (!commentId) {
+          throw new Error('Failed to create comment.');
+        }
+
+        const created = (await source.resolveById({
+          ctx,
+          id: commentId,
+          input: {
+            select: select.filter((field) => field !== 'post' && !field.startsWith('post.')),
+          },
+          view: commentDataView,
+        })) as (CommentItem & { post?: PostItem | null }) | null;
+
+        if (!created) {
+          throw new Error('Comment not found.');
+        }
+
+        const liveComment = await source.resolveById({
+          ctx,
+          id: commentId,
+          input: {
+            select: ['author.id', 'author.name', 'author.username', 'content', 'id'],
+          },
+          view: commentDataView,
+        });
+
+        if (hasNestedSelection(select, 'post')) {
+          created.post = (await source.resolveById<PostItem>({
+            ctx,
+            id: input.postId,
+            input: {
+              args: getScopedArgs(undefined, 'post'),
+              select: getNestedSelection(select, 'post'),
+            },
+            view: postDataView,
+          })) as PostItem | null;
+        }
+
+        live
+          .connection('Post.comments', { id: input.postId })
+          .appendNode('Comment', commentId, { node: liveComment ?? created });
+        live.update('Post', input.postId, { changed: ['commentCount', 'comments'] });
+
+        return created as CommentItem & { post?: { commentCount: number } };
+      },
+      type: 'Comment',
+    },
+    'comment.delete': {
+      input: z.object({
+        id: z.string().min(1, 'Comment id is required'),
+      }),
+      resolve: async ({ ctx, input, select }: ResolverOptions<{ id: string }>) => {
+        const plan = createSourcePlan({
+          ctx,
+          select,
+          source: source.getSource(commentDataView),
+        });
+        const commentSelection = getCommentDeleteFetchSelection(select);
+
+        const existing = await source.fetchById<CommentItem>({
+          ctx,
+          extra: { extraFields: ['authorId', 'postId'] },
+          id: input.id,
+          plan: createSourcePlan({
+            ctx,
+            select: commentSelection,
+            source: source.getSource(commentDataView),
+          }),
+        });
+
+        if (!existing) {
+          throw new FateRequestError('NOT_FOUND', 'Comment not found.');
+        }
+
+        assertCanDeleteComment(existing, ctx.sessionUser);
+
+        await deleteCommentRecord(input.id);
+
+        if (existing.postId && hasNestedSelection(select, 'post')) {
+          const post = await source.fetchById<PostItem>({
+            ctx,
+            id: existing.postId,
+            plan: createSourcePlan({
+              args: getScopedArgs(undefined, 'post'),
+              ctx,
+              select: getNestedSelection(select, 'post'),
+              source: source.getSource(postDataView),
+            }),
+          });
+
+          existing.post = post;
+        }
+
+        const resolved = (await plan.resolve(existing)) as CommentItem & {
+          post?: { commentCount: number };
+        };
+
+        if (existing.postId) {
+          live.connection('Post.comments', { id: existing.postId }).deleteEdge('Comment', input.id);
+          live.update('Post', existing.postId, { changed: ['commentCount', 'comments'] });
+        }
+
+        return resolved;
+      },
+      type: 'Comment',
+    },
+    'post.add': {
+      input: z.object({
+        content: z.string().min(1, 'Content is required'),
+        title: z.string().min(1, 'Title is required'),
+      }),
+      resolve: async ({
+        ctx,
+        input,
+        select,
+      }: ResolverOptions<{ content: string; title: string }>) => {
+        const user = requireUser(ctx);
+        const postId = await createPostRecord({
+          authorId: user.id,
+          content: input.content,
+          title: input.title,
+        });
+
+        if (!postId) {
+          throw new Error('Failed to create post.');
+        }
+
+        const post = await source.resolveById({
+          ctx,
+          id: postId,
+          input: { select },
+          view: postDataView,
+        });
+
+        if (!post) {
+          throw new Error('Post not found.');
+        }
+
+        live.connection('posts').prependNode('Post', postId);
+
+        return post as Post;
+      },
+      type: 'Post',
+    },
+    'post.like': {
+      input: z.object({
+        error: z.enum(['boundary', 'callSite']).optional(),
+        id: z.string().min(1, 'Post id is required.'),
+        slow: z.boolean().optional(),
+      }),
+      resolve: async ({
+        ctx,
+        input,
+        select,
+      }: ResolverOptions<{ error?: 'boundary' | 'callSite'; id: string; slow?: boolean }>) => {
+        if (input.slow) {
+          await new Promise((resolve) => setTimeout(resolve, 2000));
+        }
+
+        if (input.error === 'boundary') {
+          throw new Error('Simulated error.');
+        } else if (input.error === 'callSite') {
+          await new Promise((resolve) => setTimeout(resolve, 200));
+          throw new Error('Gotta pay up.');
+        }
+
+        const updated = await likePostRecord(input.id);
+        if (!updated) {
+          throw new Error('Post not found.');
+        }
+
+        const post = await source.resolveById({
+          ctx,
+          id: input.id,
+          input: { select },
+          view: postDataView,
+        });
+
+        if (!post) {
+          throw new Error('Post not found.');
+        }
+
+        live.update('Post', input.id, { changed: ['likes'], data: post });
+
+        return post as Post;
+      },
+      type: 'Post',
+    },
+    'post.unlike': {
+      input: z.object({
+        id: z.string().min(1, 'Post id is required.'),
+      }),
+      resolve: async ({ ctx, input, select }: ResolverOptions<{ id: string }>) => {
+        const updated = await unlikePostRecord(input.id);
+        if (!updated) {
+          throw new Error('Post not found.');
+        }
+
+        const post = await source.resolveById({
+          ctx,
+          id: input.id,
+          input: { select },
+          view: postDataView,
+        });
+
+        if (!post) {
+          throw new Error('Post not found.');
+        }
+
+        live.update('Post', input.id, { changed: ['likes'], data: post });
+
+        return post as Post;
+      },
+      type: 'Post',
+    },
+    'user.update': {
+      input: z.object({
+        name: z
+          .string()
+          .trim()
+          .min(2, 'Name must be at least 2 characters.')
+          .max(50, 'Name must be at most 32 characters.'),
+      }),
+      resolve: async ({ ctx, input, select }: ResolverOptions<{ name: string }>) => {
+        const user = requireUser(ctx);
+
+        await db
+          .update(userTable)
+          .set({ name: input.name, updatedAt: new Date() })
+          .where(eq(userTable.id, user.id));
+
+        const updated = await source.resolveById({
+          ctx,
+          id: user.id,
+          input: { select },
+          view: userDataView,
+        });
+
+        if (!updated) {
+          throw new Error('User not found.');
+        }
+
+        return updated;
+      },
+      type: 'User',
+    },
+  },
+  queries: {
+    viewer: {
+      resolve: ({ ctx, select }: Omit<ResolverOptions<unknown>, 'input'>) =>
+        ctx.sessionUser
+          ? source.resolveById({
+              ctx,
+              id: ctx.sessionUser.id,
+              input: { select },
+              view: Root.viewer,
+            })
+          : null,
+      type: 'User',
+    },
+  },
+  roots: Root,
+  sources: source,
+});
+
+export * from './views.ts';

package/templates/fate/cloudflare/server/src/fate/views.ts

@@ -0,0 +1,164 @@
+import { computed, count, dataView, field, list, type Entity } from '@nkzw/fate/server';
+import type {
+  CategoryItem,
+  CommentItem,
+  EventAttendeeItem,
+  EventItem,
+  PostItem,
+} from '../../db/queries.ts';
+import type { CategoryRow, TagRow, UserRow } from '../../db/schema.ts';
+import type { AppContext } from './context.ts';
+
+export const userDataView = dataView<UserRow>('User')({
+  email: computed<UserRow, string | null, AppContext>({
+    authorize: ({ id }, context) => context?.sessionUser?.id === id,
+    resolve: (_item, deps) => (deps.email as string | null) ?? null,
+    select: {
+      email: field('email'),
+    },
+  }),
+  id: true,
+  name: true,
+  username: true,
+});
+
+export const tagDataView = dataView<TagRow>('Tag')({
+  description: true,
+  id: true,
+  name: true,
+});
+
+export const categorySummaryDataView = dataView<CategoryRow>('Category')({
+  id: true,
+  name: true,
+});
+
+const basePost = {
+  author: userDataView,
+  category: categorySummaryDataView,
+  commentCount: computed<PostItem, number>({
+    resolve: (_item, deps) => (deps.count as number) ?? 0,
+    select: {
+      count: count('comments'),
+    },
+  }),
+  content: true,
+  id: true,
+  likes: true,
+  title: true,
+} as const;
+
+export const postSummaryDataView = dataView<PostItem>('Post')({
+  ...basePost,
+  tags: list(tagDataView),
+});
+
+export const commentDataView = dataView<CommentItem>('Comment')({
+  author: userDataView,
+  content: true,
+  id: true,
+  post: postSummaryDataView,
+});
+
+export const postDataView = dataView<PostItem>('Post')({
+  ...basePost,
+  comments: list(commentDataView, { orderBy: { createdAt: 'asc', id: 'asc' } }),
+  tags: list(tagDataView),
+});
+
+export const categoryDataView = dataView<CategoryItem>('Category')({
+  description: true,
+  id: true,
+  name: true,
+  postCount: computed<CategoryItem, number>({
+    resolve: (_item, deps) => (deps.count as number) ?? 0,
+    select: {
+      count: count('posts'),
+    },
+  }),
+  posts: list(postDataView),
+});
+
+export const eventAttendeeDataView = dataView<EventAttendeeItem>('EventAttendee')({
+  id: true,
+  notes: true,
+  status: true,
+  user: userDataView,
+});
+
+export const eventDataView = dataView<EventItem>('Event')({
+  attendees: list(eventAttendeeDataView, { orderBy: { createdAt: 'asc', id: 'asc' } }),
+  attendingCount: computed<EventItem, number>({
+    resolve: (_item, deps) => (deps.count as number) ?? 0,
+    select: {
+      count: count('attendees', {
+        where: { status: 'GOING' },
+      }),
+    },
+  }),
+  capacity: true,
+  description: true,
+  endAt: true,
+  host: userDataView,
+  id: true,
+  livestreamUrl: true,
+  location: true,
+  name: true,
+  startAt: true,
+  topics: true,
+  type: true,
+});
+
+export type User = Entity<typeof userDataView, 'User'>;
+export type Tag = Entity<typeof tagDataView, 'Tag'>;
+export type Comment = Entity<
+  typeof commentDataView,
+  'Comment',
+  {
+    author: User;
+    post: Post;
+  }
+>;
+export type EventAttendee = Entity<
+  typeof eventAttendeeDataView,
+  'EventAttendee',
+  {
+    user: User;
+  }
+>;
+export type Post = Entity<
+  typeof postDataView,
+  'Post',
+  {
+    author: User;
+    category: Category | null;
+    comments: Array<Comment>;
+    tags: Array<Tag>;
+  }
+>;
+export type Category = Entity<
+  typeof categoryDataView,
+  'Category',
+  {
+    posts: Array<Post>;
+  }
+>;
+export type Event = Entity<
+  typeof eventDataView,
+  'Event',
+  {
+    attendees: Array<EventAttendee>;
+    host: User;
+  }
+>;
+
+export const Root = {
+  categories: list(categoryDataView, { orderBy: { createdAt: 'asc', id: 'asc' } }),
+  commentSearch: {
+    procedure: 'search',
+    view: list(commentDataView, { orderBy: { createdAt: 'desc', id: 'desc' } }),
+  },
+  events: list(eventDataView, { orderBy: [{ startAt: 'asc' }, { id: 'asc' }] }),
+  posts: list(postDataView, { orderBy: { createdAt: 'desc', id: 'desc' } }),
+  viewer: userDataView,
+};

package/templates/fate/cloudflare/server/src/index.ts

@@ -0,0 +1,80 @@
+import {
+  createCloudflareFateLiveDurableObject,
+  defineCloudflareFateLiveRoute,
+  defineCloudflareFateRoute,
+} from 'cf-fate/server';
+import { withDatabase, type D1Binding } from '../db/db.ts';
+import { fateStream } from './fate/live.ts';
+import { fateLive, fateServer } from './fate/server.ts';
+import { createAuth } from './lib/auth.ts';
+import { clientOrigin, resolveCorsOrigin } from './lib/origins.ts';
+
+type ExecutionContext = {
+  waitUntil(promise: Promise<unknown>): void;
+};
+
+type Env = Record<string, unknown> & {
+  BETTER_AUTH_SECRET?: string;
+  DB: D1Binding;
+  FATE_LIVE: unknown;
+};
+
+const fateRoute = defineCloudflareFateRoute(fateServer, fateLive, { stream: fateStream });
+const fateLiveRoute = defineCloudflareFateLiveRoute(fateStream);
+
+export const FateLiveDurableObject = createCloudflareFateLiveDurableObject({
+  binding: 'FATE_LIVE',
+});
+
+const corsHeaders = (request: Request): Headers => {
+  const origin = resolveCorsOrigin(request.headers.get('origin'));
+  const headers = new Headers();
+  if (origin) {
+    headers.set('access-control-allow-origin', origin);
+    headers.set('access-control-allow-credentials', 'true');
+    headers.set('vary', 'Origin');
+  }
+  return headers;
+};
+
+const withCors = (request: Request, response: Response): Response => {
+  const headers = new Headers(response.headers);
+  corsHeaders(request).forEach((value, key) => headers.set(key, value));
+  return new Response(response.body, {
+    headers,
+    status: response.status,
+    statusText: response.statusText,
+  });
+};
+
+const optionsResponse = (request: Request) => {
+  const headers = corsHeaders(request);
+  headers.set('access-control-allow-headers', 'content-type, authorization');
+  headers.set('access-control-allow-methods', 'GET, POST, OPTIONS');
+  headers.set('access-control-max-age', '86400');
+  return new Response(null, { headers, status: 204 });
+};
+
+export default {
+  fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
+    return withDatabase(env.DB, async () => {
+      if (request.method === 'OPTIONS') {
+        return optionsResponse(request);
+      }
+
+      const url = new URL(request.url);
+      let response: Response;
+      if (url.pathname === '/fate' || url.pathname.startsWith('/fate/')) {
+        response = await fateRoute.fetch(request, env, ctx);
+      } else if (url.pathname === '/fate-live' || url.pathname.startsWith('/fate-live/')) {
+        response = await fateLiveRoute.fetch(request, env, ctx);
+      } else if (url.pathname.startsWith('/api/auth/')) {
+        response = await createAuth(url.origin, env.BETTER_AUTH_SECRET).handler(request);
+      } else {
+        response = Response.redirect(clientOrigin, 302);
+      }
+
+      return withCors(request, response);
+    });
+  },
+};