create-fate 1.5.2 → 1.6.1

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

@@ -1,414 +0,0 @@
-import {
-  createFateServer,
-  createSourcePlan,
-  FateRequestError,
-  getNestedSelection,
-  getScopedArgs,
-  hasNestedSelection,
-} from '@nkzw/fate/server';
-import { createDrizzleSourceAdapter, type DrizzleQueryExtra } 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()}%`,
-            ) 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';

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

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

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