create-fate 0.0.0 → 1.0.0

package/templates/fate/void/src/App.css

@@ -0,0 +1,130 @@
+@import 'tailwindcss';
+
+body {
+  font-family:
+    system-ui,
+    -apple-system,
+    BlinkMacSystemFont,
+    'Segoe UI',
+    'Open Sans',
+    'Helvetica Neue',
+    sans-serif;
+
+  background-color: hsl(var(--background));
+  color: hsl(var(--foreground));
+}
+
+@theme {
+  --color-accent: hsl(var(--accent));
+  --color-accent-foreground: hsl(var(--accent-foreground));
+
+  --color-background: hsl(var(--background));
+  --color-foreground: hsl(var(--foreground));
+  --color-border: hsl(var(--border));
+  --color-ring: hsl(var(--ring));
+
+  --color-card: hsl(var(--card));
+  --color-card-foreground: hsl(var(--card-foreground));
+
+  --color-muted: hsl(var(--muted));
+  --color-muted-foreground: hsl(var(--muted-foreground));
+
+  --color-secondary: hsl(var(--secondary));
+  --color-secondary-foreground: hsl(var(--secondary-foreground));
+
+  --color-destructive: hsl(var(--destructive));
+  --color-destructive-foreground: hsl(var(--destructive-foreground));
+}
+
+@layer utilities {
+  .text-balance {
+    text-wrap: balance;
+  }
+}
+
+@layer base {
+  :root {
+    --background: 0 0% 100%;
+    --foreground: 0 0% 3.9%;
+    --card: 0 0% 100%;
+    --card-foreground: 0 0% 3.9%;
+    --popover: 0 0% 100%;
+    --popover-foreground: 0 0% 3.9%;
+    --primary: 0 0% 9%;
+    --primary-foreground: 0 0% 98%;
+    --secondary: 0 0% 96.1%;
+    --secondary-foreground: 0 0% 9%;
+    --muted: 0 0% 96.1%;
+    --muted-foreground: 0 0 40%;
+    --accent: 0 0% 96.1%;
+    --accent-foreground: 0 0% 9%;
+    --destructive: 0 84.2% 60.2%;
+    --destructive-foreground: 0 0% 98%;
+    --border: 0 0% 89.8%;
+    --input: 0 0% 89.8%;
+    --ring: 0 0% 3.9%;
+    --chart-1: 12 76% 61%;
+    --chart-2: 173 58% 39%;
+    --chart-3: 197 37% 24%;
+    --chart-4: 43 74% 66%;
+    --chart-5: 27 87% 67%;
+    --radius: 0.5rem;
+    --sidebar-background: 0 0% 98%;
+    --sidebar-foreground: 240 5.3% 26.1%;
+    --sidebar-primary: 240 5.9% 10%;
+    --sidebar-primary-foreground: 0 0% 98%;
+    --sidebar-accent: 240 4.8% 95.9%;
+    --sidebar-accent-foreground: 240 5.9% 10%;
+    --sidebar-border: 220 13% 91%;
+    --sidebar-ring: 217.2 91.2% 59.8%;
+  }
+  @media (prefers-color-scheme: dark) {
+    :root {
+      --background: 0 0% 3.9%;
+      --foreground: 0 0% 98%;
+      --card: 0 0% 3.9%;
+      --card-foreground: 0 0% 98%;
+      --popover: 0 0% 3.9%;
+      --popover-foreground: 0 0% 98%;
+      --primary: 0 0% 98%;
+      --primary-foreground: 0 0% 9%;
+      --secondary: 0 0% 14.9%;
+      --secondary-foreground: 0 0% 98%;
+      --muted: 0 0% 14.9%;
+      --muted-foreground: 0 0% 63.9%;
+      --accent: 0 0% 14.9%;
+      --accent-foreground: 0 0% 98%;
+      --destructive: 0 62.8% 30.6%;
+      --destructive-foreground: 0 0% 98%;
+      --border: 0 0% 14.9%;
+      --input: 0 0% 14.9%;
+      --ring: 0 0% 83.1%;
+      --chart-1: 220 70% 50%;
+      --chart-2: 160 60% 45%;
+      --chart-3: 30 80% 55%;
+      --chart-4: 280 65% 60%;
+      --chart-5: 340 75% 55%;
+      --sidebar-background: 240 5.9% 10%;
+      --sidebar-foreground: 240 4.8% 95.9%;
+      --sidebar-primary: 224.3 76.3% 48%;
+      --sidebar-primary-foreground: 0 0% 100%;
+      --sidebar-accent: 240 3.7% 15.9%;
+      --sidebar-accent-foreground: 240 4.8% 95.9%;
+      --sidebar-border: 240 3.7% 15.9%;
+      --sidebar-ring: 217.2 91.2% 59.8%;
+    }
+  }
+
+  * {
+    @apply border-border;
+  }
+}
+
+textarea {
+  resize: none;
+}
+
+.squircle {
+  border-radius: 32px;
+  corner-shape: squircle;
+}

package/templates/fate/void/src/fate/__tests__/commentPermissions.test.ts

@@ -0,0 +1,31 @@
+import { FateRequestError } from '@nkzw/fate/server';
+import { expect, test } from 'vite-plus/test';
+import { assertCanDeleteComment, getCommentDeleteFetchSelection } from '../commentPermissions.ts';
+
+test('allows comment authors to delete their own comments', () => {
+  expect(() => assertCanDeleteComment({ authorId: 'user-1' }, { id: 'user-1' })).not.toThrow();
+});
+
+test('rejects anonymous comment deletion with a protocol error', () => {
+  expect(() => assertCanDeleteComment({ authorId: 'user-1' }, null)).toThrow(
+    new FateRequestError('UNAUTHORIZED', 'You must be logged in.'),
+  );
+});
+
+test('rejects deleting another users comment with a protocol error', () => {
+  expect(() => assertCanDeleteComment({ authorId: 'user-1' }, { id: 'user-2' })).toThrow(
+    new FateRequestError('FORBIDDEN', 'You can only delete your own comments.'),
+  );
+});
+
+test('rejects deleting orphaned comments with a protocol error', () => {
+  expect(() => assertCanDeleteComment({ authorId: null }, { id: 'user-1' })).toThrow(
+    new FateRequestError('FORBIDDEN', 'You can only delete your own comments.'),
+  );
+});
+
+test('excludes post selections from the initial delete comment fetch', () => {
+  expect(
+    getCommentDeleteFetchSelection(['content', 'id', 'post', 'post.commentCount', 'post.title']),
+  ).toEqual(['content', 'id']);
+});

package/templates/fate/void/src/fate/commentPermissions.ts

@@ -0,0 +1,17 @@
+import { FateRequestError } from '@nkzw/fate/server';
+
+type CommentOwner = Readonly<{ authorId?: string | null }>;
+type SessionUser = Readonly<{ id: string }> | null | undefined;
+
+export const assertCanDeleteComment = (comment: CommentOwner, user: SessionUser) => {
+  if (!user) {
+    throw new FateRequestError('UNAUTHORIZED', 'You must be logged in.');
+  }
+
+  if (!comment.authorId || comment.authorId !== user.id) {
+    throw new FateRequestError('FORBIDDEN', 'You can only delete your own comments.');
+  }
+};
+
+export const getCommentDeleteFetchSelection = (select: ReadonlyArray<string>): Array<string> =>
+  select.filter((path) => path !== 'post' && !path.startsWith('post.'));

package/templates/fate/void/src/fate/context.ts

@@ -0,0 +1,15 @@
+import { getSession } from 'void/auth';
+import { db } from 'void/db';
+import { toSessionUser } from '../user/SessionUser.tsx';
+
+export const createContext = async ({ request }: { request: Request }) => {
+  const session = getSession();
+
+  return {
+    db,
+    headers: request.headers,
+    sessionUser: session?.user ? toSessionUser(session.user) : null,
+  };
+};
+
+export type AppContext = Awaited<ReturnType<typeof createContext>>;

package/templates/fate/void/src/fate/live.ts

@@ -0,0 +1,6 @@
+import { defineLiveStream } from 'void/live';
+
+export const fateStream = defineLiveStream({
+  allowAnonymousControl: true,
+  id: 'fate',
+});

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

@@ -0,0 +1,401 @@
+import {
+  createFateServer,
+  createSourcePlan,
+  FateRequestError,
+  getNestedSelection,
+  getScopedArgs,
+  hasNestedSelection,
+} from '@nkzw/fate/server';
+import { createDrizzleSourceAdapter, type DrizzleQueryExtra } from '@nkzw/fate/server/drizzle';
+import { createVoidFateLive } from 'void-fate/server';
+import { db, eq, like } from 'void/db';
+import { z } from 'zod';
+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,
+});
+export const fateLive = createVoidFateLive();
+export const { live } = fateLive;
+
+const requireUser = (ctx: AppContext) => {
+  if (!ctx.sessionUser) {
+    throw new FateRequestError('UNAUTHORIZED', 'You must be logged in.');
+  }
+
+  return ctx.sessionUser;
+};
+
+export const fateServer = createFateServer({
+  context: ({ request }) => createContext({ request }),
+  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 (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()}%`,
+            ) as unknown as DrizzleQueryExtra['where'],
+          },
+          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';