create-fate 1.0.3 → 1.3.0

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

@@ -0,0 +1,71 @@
+import prisma from '../../prisma/prisma.tsx';
+import builder, { DateTimeScalar } from '../builder.tsx';
+
+const EventAttendee = builder.prismaNode('EventAttendee', {
+  fields: (t) => ({
+    notes: t.exposeString('notes'),
+    status: t.string({
+      nullable: false,
+      resolve: ({ status }) => status,
+    }),
+    user: t.relation('user', { nullable: false }),
+  }),
+  id: { field: 'id' },
+});
+
+const Event = builder.prismaNode('Event', {
+  fields: (t) => ({
+    attendees: t.relatedConnection('attendees', {
+      cursor: 'id',
+      nullable: false,
+      query: {
+        orderBy: [{ createdAt: 'asc' }, { id: 'asc' }],
+      },
+    }),
+    attendingCount: t.int({
+      nullable: false,
+      resolve: ({ id }) => prisma.eventAttendee.count({ where: { eventId: id, status: 'GOING' } }),
+    }),
+    capacity: t.exposeInt('capacity', { nullable: false }),
+    description: t.exposeString('description', { nullable: false }),
+    endAt: t.field({
+      nullable: false,
+      resolve: ({ endAt }) => endAt,
+      type: DateTimeScalar,
+    }),
+    host: t.relation('host', { nullable: false }),
+    livestreamUrl: t.exposeString('livestreamUrl'),
+    location: t.exposeString('location', { nullable: false }),
+    name: t.exposeString('name', { nullable: false }),
+    startAt: t.field({
+      nullable: false,
+      resolve: ({ startAt }) => startAt,
+      type: DateTimeScalar,
+    }),
+    topics: t.field({
+      nullable: false,
+      resolve: ({ topics }) => topics,
+      type: ['String'],
+    }),
+    type: t.string({
+      nullable: false,
+      resolve: ({ type }) => type,
+    }),
+  }),
+  id: { field: 'id' },
+});
+
+builder.queryFields((t) => ({
+  events: t.prismaConnection({
+    cursor: 'id',
+    resolve: (query) =>
+      prisma.event.findMany({
+        ...query,
+        orderBy: [{ startAt: 'asc' }, { id: 'asc' }],
+      }),
+    type: 'Event',
+  }),
+}));
+
+export { EventAttendee };
+export default Event;

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

@@ -0,0 +1,45 @@
+import prisma from '../../prisma/prisma.tsx';
+import builder from '../builder.tsx';
+
+const Post = builder.prismaNode('Post', {
+  fields: (t) => ({
+    author: t.relation('author', { nullable: false }),
+    category: t.relation('category'),
+    commentCount: t.int({
+      nullable: false,
+      resolve: ({ id }) => prisma.comment.count({ where: { postId: id } }),
+    }),
+    comments: t.relatedConnection('comments', {
+      cursor: 'id',
+      nullable: false,
+      query: {
+        orderBy: [{ createdAt: 'asc' }, { id: 'asc' }],
+      },
+    }),
+    content: t.exposeString('content', { nullable: false }),
+    likes: t.exposeInt('likes', { nullable: false }),
+    tags: t.relatedConnection('tags', {
+      cursor: 'id',
+      nullable: false,
+      query: {
+        orderBy: [{ name: 'asc' }, { id: 'asc' }],
+      },
+    }),
+    title: t.exposeString('title', { nullable: false }),
+  }),
+  id: { field: 'id' },
+});
+
+builder.queryFields((t) => ({
+  posts: t.prismaConnection({
+    cursor: 'id',
+    resolve: (query) =>
+      prisma.post.findMany({
+        ...query,
+        orderBy: [{ createdAt: 'desc' }, { id: 'desc' }],
+      }),
+    type: 'Post',
+  }),
+}));
+
+export default Post;

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

@@ -0,0 +1,11 @@
+import builder from '../builder.tsx';
+
+const Tag = builder.prismaNode('Tag', {
+  fields: (t) => ({
+    description: t.exposeString('description'),
+    name: t.exposeString('name', { nullable: false }),
+  }),
+  id: { field: 'id' },
+});
+
+export default Tag;

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

@@ -0,0 +1,28 @@
+import prisma from '../../prisma/prisma.tsx';
+import builder from '../builder.tsx';
+
+const User = builder.prismaNode('User', {
+  fields: (t) => ({
+    email: t.exposeString('email', {
+      authScopes: (user) => ({ self: user.id }),
+    }),
+    name: t.exposeString('name', { nullable: false }),
+    username: t.exposeString('username'),
+  }),
+  id: { field: 'id' },
+});
+
+builder.queryFields((t) => ({
+  viewer: t.prismaField({
+    resolve: (query, _root, _args, { sessionUser }) =>
+      sessionUser
+        ? prisma.user.findUniqueOrThrow({
+            ...query,
+            where: { id: sessionUser.id },
+          })
+        : void query.include,
+    type: 'User',
+  }),
+}));
+
+export default User;

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

@@ -0,0 +1,16 @@
+import { writeFileSync } from 'node:fs';
+import './schemaImportMap.tsx';
+import { join } from 'node:path';
+import { printSchemaWithDirectives } from '@graphql-tools/utils';
+import builder from './builder.tsx';
+
+const schema = builder.toSchema();
+
+if (process.env.NODE_ENV === 'development') {
+  writeFileSync(
+    join(process.cwd(), 'src/graphql/schema.graphql'),
+    printSchemaWithDirectives(schema),
+    'utf8',
+  );
+}
+export default schema;

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

@@ -0,0 +1,193 @@
+import { computed, count, dataView, field, list, type Entity } from '@nkzw/fate/server';
+import type {
+  Category as PrismaCategory,
+  Comment as PrismaComment,
+  Event as PrismaEvent,
+  EventAttendee as PrismaEventAttendee,
+  Post as PrismaPost,
+  Tag as PrismaTag,
+  User as PrismaUser,
+} from '../prisma/prisma-client/client.ts';
+import type { AppContext } from './context.tsx';
+
+export type CommentItem = PrismaComment & {
+  author?: PrismaUser | null;
+  post?: PrismaPost | null;
+};
+
+export type PostItem = PrismaPost & {
+  _count?: { comments: number };
+  author?: PrismaUser | null;
+  category?: PrismaCategory | null;
+  comments?: Array<CommentItem>;
+  tags?: Array<PrismaTag>;
+};
+
+export type CategoryItem = PrismaCategory & {
+  _count?: { posts: number };
+  posts?: Array<PostItem>;
+};
+
+type EventAttendeeItem = PrismaEventAttendee & {
+  user?: PrismaUser | null;
+};
+
+export type EventItem = PrismaEvent & {
+  _count?: { attendees: number };
+  attendees?: Array<EventAttendeeItem>;
+  host?: PrismaUser | null;
+};
+
+export const userDataView = dataView<PrismaUser>('User')({
+  email: computed<PrismaUser, 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<PrismaTag>('Tag')({
+  description: true,
+  id: true,
+  name: true,
+});
+
+export const categorySummaryDataView = dataView<PrismaCategory>('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/graphql/server/src/index.tsx

@@ -0,0 +1,45 @@
+#!/usr/bin/env NODE_ENV=development node_modules/.bin/nodemon -q -I --exec node --no-warnings --experimental-specifier-resolution=node --loader ts-node/esm --env-file .env
+import { parseArgs, styleText } from 'node:util';
+import { serve } from '@hono/node-server';
+import parseInteger from '@nkzw/core/parseInteger.js';
+import app from './app.tsx';
+
+const name = 'Pothos GraphQL Server';
+
+const {
+  values: { port: portArg },
+} = parseArgs({
+  options: {
+    port: {
+      default: '9000',
+      short: 'p',
+      type: 'string',
+    },
+  },
+});
+
+const port = (portArg && parseInteger(portArg)) || 9000;
+
+// See https://github.com/honojs/node-server/issues/233
+process.on('uncaughtException', (error) => {
+  if (
+    !(error instanceof Error) ||
+    !error.message.includes('Invalid state: ReadableStream is already closed')
+  ) {
+    throw error;
+  }
+});
+
+serve({ fetch: app.fetch, port }, () =>
+  console.log(
+    `${styleText(['green', 'bold'], `${name}\n  ➜`)}  Server running on port ${styleText('bold', String(port))}.\n`,
+  ),
+);
+
+const setTitle = (title: string) => {
+  process.title = title;
+  if (process.stdout.isTTY) {
+    process.stdout.write(`${String.fromCharCode(27)}]0;🚀 ${title}${String.fromCharCode(7)}`);
+  }
+};
+setTimeout(() => setTitle(name), 0);

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

@@ -0,0 +1,31 @@
+import { betterAuth } from 'better-auth';
+import { prismaAdapter } from 'better-auth/adapters/prisma';
+import { admin, username } from 'better-auth/plugins';
+import prisma from '../prisma/prisma.tsx';
+import { trustedOrigins } from './origins.ts';
+
+export const auth = betterAuth({
+  advanced: {
+    database: {
+      generateId: false,
+    },
+  },
+  database: prismaAdapter(prisma, {
+    provider: 'postgresql',
+  }),
+  emailAndPassword: {
+    autoSignIn: true,
+    enabled: true,
+    maxPasswordLength: 128,
+    minPasswordLength: 8,
+  },
+  plugins: [admin(), username()],
+  session: {
+    cookieCache: {
+      enabled: true,
+      maxAge: 15 * 24 * 60 * 60,
+    },
+  },
+  telemetry: { enabled: false },
+  trustedOrigins,
+});

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

@@ -0,0 +1,3 @@
+import defineEnv from '@nkzw/define-env';
+
+export default defineEnv(['CLIENT_DOMAIN', 'DATABASE_URL', 'BETTER_AUTH_SECRET']);

package/templates/fate/graphql/server/src/lib/origins.ts

@@ -0,0 +1,18 @@
+import env from './env.tsx';
+
+const localDevOriginPattern = /^https?:\/\/(?:localhost|127\.0\.0\.1)(?::\d+)?$/;
+
+const isDevelopment = process.env.NODE_ENV === 'development' || process.env.DEV;
+
+export const clientOrigin = env('CLIENT_DOMAIN');
+
+export const trustedOrigins = [
+  clientOrigin,
+  ...(isDevelopment ? ['http://localhost:*', 'http://127.0.0.1:*'] : []),
+];
+
+export const resolveCorsOrigin = (origin: string) => {
+  if (origin === clientOrigin || (isDevelopment && localDevOriginPattern.test(origin))) {
+    return origin;
+  }
+};

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

@@ -0,0 +1,9 @@
+import { PrismaPg } from '@prisma/adapter-pg';
+import env from '../lib/env.tsx';
+import { PrismaClient } from './prisma-client/client.ts';
+
+const adapter = new PrismaPg({
+  connectionString: env('DATABASE_URL'),
+});
+
+export default new PrismaClient({ adapter });

package/templates/fate/graphql/server/src/prisma/schema.prisma

@@ -0,0 +1,181 @@
+// This is your Prisma schema file,
+// learn more about it in the docs: https://pris.ly/d/prisma-schema
+
+generator client {
+  binaryTargets       = ["native", "linux-musl"]
+  importFileExtension = "ts"
+  output              = "./prisma-client"
+  provider            = "prisma-client"
+  engineType          = "client"
+}
+
+generator pothos {
+  provider     = "prisma-pothos-types"
+  clientOutput = "./prisma-client"
+  output       = "./pothos-types.ts"
+}
+
+generator json {
+  provider     = "prisma-json-types-generator"
+  clientOutput = "./prisma-client"
+}
+
+datasource db {
+  provider = "postgresql"
+}
+
+model User {
+  id              String          @id @unique @default(uuid(7))
+  accounts        Account[]
+  banExpires      DateTime?
+  banned          Boolean?
+  banReason       String?
+  createdAt       DateTime        @default(now())
+  displayUsername String?
+  email           String          @unique
+  emailVerified   Boolean
+  image           String?
+  name            String
+  password        String?
+  role            String          @default("user")
+  sessions        Session[]
+  posts           Post[]
+  comments        Comment[]
+  hostedEvents    Event[]         @relation("EventHost")
+  eventAttendance EventAttendee[]
+  updatedAt       DateTime
+  username        String?         @unique
+
+  @@index([id(sort: Asc)])
+  @@map("user")
+}
+
+model Session {
+  id        String   @unique @default(uuid(7))
+  expiresAt DateTime
+  token     String
+  createdAt DateTime
+  updatedAt DateTime
+  ipAddress String?
+  userAgent String?
+  userId    String
+  user      User     @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  @@unique([token])
+  @@map("session")
+}
+
+model Account {
+  id                    String    @unique @default(uuid(7))
+  accountId             String
+  providerId            String
+  userId                String
+  user                  User      @relation(fields: [userId], references: [id], onDelete: Cascade)
+  accessToken           String?
+  refreshToken          String?
+  idToken               String?
+  accessTokenExpiresAt  DateTime?
+  refreshTokenExpiresAt DateTime?
+  scope                 String?
+  password              String?
+  createdAt             DateTime
+  updatedAt             DateTime
+
+  @@unique([providerId, accountId])
+  @@map("account")
+}
+
+model Post {
+  id         String    @id @default(uuid(7))
+  title      String
+  content    String
+  likes      Int       @default(0)
+  createdAt  DateTime  @default(now())
+  updatedAt  DateTime  @updatedAt
+  authorId   String
+  author     User      @relation(fields: [authorId], references: [id], onDelete: Cascade)
+  comments   Comment[]
+  categoryId String?
+  category   Category? @relation(fields: [categoryId], references: [id], onDelete: SetNull)
+  tags       Tag[]     @relation("PostTags")
+
+  @@index([authorId(sort: Asc)])
+}
+
+model Comment {
+  id        String   @id @default(uuid(7))
+  content   String
+  createdAt DateTime @default(now())
+  postId    String
+  authorId  String?
+  post      Post     @relation(fields: [postId], references: [id], onDelete: Cascade)
+  author    User?    @relation(fields: [authorId], references: [id], onDelete: SetNull)
+
+  @@index([authorId(sort: Asc)])
+  @@index([postId(sort: Asc)])
+}
+
+model Category {
+  id          String   @id @default(uuid(7))
+  name        String   @unique
+  description String?
+  createdAt   DateTime @default(now())
+  posts       Post[]
+}
+
+model Tag {
+  id          String   @id @default(uuid(7))
+  name        String   @unique
+  description String?
+  createdAt   DateTime @default(now())
+  posts       Post[]   @relation("PostTags")
+}
+
+enum RSVPStatus {
+  INVITED
+  GOING
+  INTERESTED
+  DECLINED
+}
+
+enum EventType {
+  WORKSHOP
+  MEETUP
+  AMA
+  LAUNCH
+  COMMUNITY_CALL
+}
+
+model Event {
+  id            String          @id @default(uuid(7))
+  name          String
+  description   String
+  type          EventType       @default(MEETUP)
+  hostId        String
+  host          User            @relation("EventHost", fields: [hostId], references: [id], onDelete: Cascade)
+  location      String
+  startAt       DateTime
+  endAt         DateTime
+  capacity      Int
+  topics        String[]        @default([])
+  livestreamUrl String?
+  attendees     EventAttendee[]
+  createdAt     DateTime        @default(now())
+  updatedAt     DateTime        @updatedAt
+
+  @@index([hostId(sort: Asc)])
+}
+
+model EventAttendee {
+  id        String     @id @default(uuid(7))
+  eventId   String
+  userId    String
+  status    RSVPStatus @default(INVITED)
+  notes     String?
+  event     Event      @relation(fields: [eventId], references: [id], onDelete: Cascade)
+  user      User       @relation(fields: [userId], references: [id], onDelete: Cascade)
+  createdAt DateTime   @default(now())
+
+  @@unique([eventId, userId])
+  @@index([userId(sort: Asc)])
+}