create-ej-app 3.2.0 → 4.0.0

package/template/base/src/db/schema.ts

@@ -0,0 +1,287 @@
+import { createId } from '@paralleldrive/cuid2'
+import { relations, sql } from 'drizzle-orm'
+import {
+  bigint,
+  boolean,
+  index,
+  integer,
+  pgEnum,
+  pgTable,
+  primaryKey,
+  text,
+  timestamp,
+  unique,
+  varchar
+} from 'drizzle-orm/pg-core'
+
+export const Account = pgTable(
+  'Accounts',
+  {
+    id: text('id')
+      .notNull()
+      .primaryKey()
+      .$defaultFn(() => createId()),
+    userId: text('userId')
+      .notNull()
+      .references(() => User.id),
+    type: varchar('type', { length: 255 }).notNull(),
+    provider: varchar('provider', { length: 255 }).notNull(),
+    providerAccountId: varchar('providerAccountId', { length: 255 }).notNull(),
+    refresh_token: text('refresh_token'),
+    access_token: text('access_token'),
+    expires_at: integer('expires_at'),
+    token_type: varchar('token_type', { length: 255 }),
+    scope: varchar('scope', { length: 255 }),
+    id_token: text('id_token'),
+    session_state: varchar('session_state', { length: 255 })
+  },
+  account => ({
+    userIdIdx: index('Accounts_idx_userId').on(account.userId),
+    uniqueProviderAccount: unique('Accounts_uq_provider_providerAccountId').on(
+      account.provider,
+      account.providerAccountId
+    )
+  })
+)
+
+export const AccountRelations = relations(Account, ({ one }) => ({
+  user: one(User, { fields: [Account.userId], references: [User.id] })
+}))
+
+export const Session = pgTable(
+  'Sessions',
+  {
+    id: text('id')
+      .notNull()
+      .primaryKey()
+      .$defaultFn(() => createId()),
+    sessionToken: varchar('sessionToken', { length: 255 }).notNull().unique(),
+    userId: text('userId')
+      .notNull()
+      .references(() => User.id),
+    expires: timestamp('expires', {
+      mode: 'date',
+      withTimezone: true
+    }).notNull(),
+    createdAt: timestamp('createdAt', {
+      mode: 'date',
+      withTimezone: true
+    })
+      .default(sql`CURRENT_TIMESTAMP`)
+      .notNull(),
+    updatedAt: timestamp('updatedAt', {
+      mode: 'date',
+      withTimezone: true
+    })
+  },
+  session => ({
+    userIdIdx: index('Sessions_idx_userId').on(session.userId)
+  })
+)
+
+export const SessionRelations = relations(Session, ({ one }) => ({
+  user: one(User, { fields: [Session.userId], references: [User.id] })
+}))
+
+export const Role = pgTable('Roles', {
+  id: text('id')
+    .notNull()
+    .primaryKey()
+    .$defaultFn(() => createId()),
+  name: varchar('name', { length: 255 }).notNull().unique(),
+  createdAt: timestamp('createdAt', {
+    mode: 'date',
+    withTimezone: true
+  })
+    .default(sql`CURRENT_TIMESTAMP`)
+    .notNull(),
+  updatedAt: timestamp('updatedAt', {
+    mode: 'date',
+    withTimezone: true
+  })
+})
+
+export const RoleRelations = relations(Role, ({ many }) => ({
+  permissions: many(RolePermission),
+  users: many(User)
+}))
+
+export const PermissionEnum = pgEnum('PermissionEnum', [
+  'TaskList',
+  'TaskView',
+  'TaskCreate',
+  'TaskUpdate',
+  'TaskDelete'
+])
+
+export const RolePermission = pgTable(
+  'RolePermissions',
+  {
+    id: text('id')
+      .notNull()
+      .primaryKey()
+      .$defaultFn(() => createId()),
+    roleId: text('roleId')
+      .notNull()
+      .references(() => Role.id, {
+        onDelete: 'cascade'
+      }),
+    permission: PermissionEnum('permission').notNull()
+  },
+  rp => ({
+    roleIdIdx: index('RolePermissions_idx_roleId').on(rp.roleId),
+    uniqueRolePermission: unique('RolePermissions_uq_roleId_permission').on(
+      rp.roleId,
+      rp.permission
+    )
+  })
+)
+
+export const RolePermissionRelations = relations(RolePermission, ({ one }) => ({
+  role: one(Role, { fields: [RolePermission.roleId], references: [Role.id] })
+}))
+
+export const UserTypeEnum = pgEnum('UserTypeEnum', ['Root', 'Normal'])
+
+export const User = pgTable('Users', {
+  id: text('id')
+    .notNull()
+    .primaryKey()
+    .$defaultFn(() => createId()),
+  name: varchar('name', { length: 255 }),
+  email: varchar('email', { length: 255 }).notNull().unique(),
+  emailVerified: timestamp('emailVerified', {
+    mode: 'date',
+    withTimezone: true
+  }),
+  image: varchar('image', { length: 255 }),
+  type: UserTypeEnum('type').notNull().default('Normal'),
+  roleId: text('roleId').references(() => Role.id),
+  createdAt: timestamp('createdAt', {
+    mode: 'date',
+    withTimezone: true
+  })
+    .default(sql`CURRENT_TIMESTAMP`)
+    .notNull(),
+  updatedAt: timestamp('updatedAt', {
+    mode: 'date',
+    withTimezone: true
+  })
+})
+
+export const UserRelations = relations(User, ({ many, one }) => ({
+  accounts: many(Account),
+  sessions: many(Session),
+  role: one(Role, {
+    fields: [User.roleId],
+    references: [Role.id]
+  })
+}))
+
+export const VerificationToken = pgTable(
+  'VerificationTokens',
+  {
+    identifier: varchar('identifier', { length: 255 }).notNull(),
+    token: varchar('token', { length: 255 }).notNull(),
+    expires: timestamp('expires', {
+      mode: 'date',
+      withTimezone: true
+    }).notNull()
+  },
+  vt => ({
+    pk: primaryKey({ columns: [vt.identifier, vt.token] })
+  })
+)
+
+export const TaskStatusEnum = pgEnum('TaskStatusEnum', [
+  'Backlog',
+  'Todo',
+  'In Progress',
+  'Done',
+  'Cancelled'
+])
+
+export const Task = pgTable('Tasks', {
+  id: text('id')
+    .notNull()
+    .primaryKey()
+    .$defaultFn(() => createId()),
+  title: varchar('title', { length: 255 }).notNull(),
+  status: TaskStatusEnum('status').notNull().default('Todo'),
+  description: text('description'),
+  createdAt: timestamp('createdAt', {
+    mode: 'date',
+    withTimezone: true
+  })
+    .default(sql`CURRENT_TIMESTAMP`)
+    .notNull(),
+  updatedAt: timestamp('updatedAt', {
+    mode: 'date',
+    withTimezone: true
+  }),
+  createdById: text('createdById')
+    .notNull()
+    .references(() => User.id),
+  updatedById: text('updatedById').references(() => User.id)
+})
+
+export const TaskRelations = relations(Task, ({ one, many }) => ({
+  createdBy: one(User, {
+    fields: [Task.createdById],
+    references: [User.id]
+  }),
+  updatedBy: one(User, {
+    fields: [Task.updatedById],
+    references: [User.id]
+  }),
+  images: many(Resource)
+}))
+
+export const Resource = pgTable(
+  'Resources',
+  {
+    id: text('id')
+      .notNull()
+      .primaryKey()
+      .$defaultFn(() => createId()),
+    filename: varchar('filename', { length: 255 }).notNull(),
+    key: varchar('key', { length: 255 }).notNull().unique(),
+    isTemp: boolean('isTemp').notNull().default(false),
+    url: varchar('url', { length: 255 }).notNull().unique(),
+    size: bigint('size', { mode: 'number' }).notNull(),
+    contentType: varchar('contentType', { length: 255 }).notNull(),
+
+    taskId: text('taskId').references(() => Task.id),
+
+    createdAt: timestamp('createdAt', {
+      mode: 'date',
+      withTimezone: true
+    })
+      .default(sql`CURRENT_TIMESTAMP`)
+      .notNull(),
+    updatedAt: timestamp('updatedAt', {
+      mode: 'date',
+      withTimezone: true
+    }),
+    createdById: text('createdById').references(() => User.id),
+    updatedById: text('updatedById').references(() => User.id)
+  },
+  resource => ({
+    taskIdIdx: index('Resources_idx_taskId').on(resource.taskId)
+  })
+)
+
+export const ResourceRelations = relations(Resource, ({ one }) => ({
+  task: one(Task, {
+    fields: [Resource.taskId],
+    references: [Task.id]
+  }),
+  createdBy: one(User, {
+    fields: [Resource.createdById],
+    references: [User.id]
+  }),
+  updatedBy: one(User, {
+    fields: [Resource.updatedById],
+    references: [User.id]
+  })
+}))

package/template/base/src/env.mjs

@@ -2,22 +2,15 @@ import { createEnv } from '@t3-oss/env-nextjs'
 import { z } from 'zod'
 
 export const env = createEnv({
-  /**
-   * Specify your server-side environment variables schema here. This way you can ensure the app
-   * isn't built with invalid env vars.
-   */
   server: {
-    NODE_ENV: z.enum(['development', 'test', 'production']),
+    NODE_ENV: z.enum(['development', 'production']),
     DATABASE_URL: z.string().url(),
     NEXTAUTH_SECRET:
       process.env.NODE_ENV === 'production'
         ? z.string().min(1)
         : z.string().min(1).optional(),
     NEXTAUTH_URL: z.preprocess(
-      // This makes Vercel deployments not fail if you don't set NEXTAUTH_URL
-      // Since NextAuth.js automatically uses the VERCEL_URL if present.
       str => process.env.VERCEL_URL ?? str,
-      // VERCEL_URL doesn't include `https` so it cant be validated as a URL
       process.env.VERCEL ? z.string().min(1) : z.string().url()
     ),
     EMAIL_SERVER_HOST: z.string().min(1),
@@ -29,25 +22,16 @@ export const env = createEnv({
     GOOGLE_SECRET: z.string().min(1),
     GITHUB_ID: z.string().min(1),
     GITHUB_SECRET: z.string().min(1),
-    FIREBASE_PROJECT_ID: z.string().min(1),
-    FIREBASE_PRIVATE_KEY: z.string().min(1),
-    FIREBASE_CLIENT_EMAIL: z.string().min(1),
-    FIREBASE_STORAGE_BUCKET: z.string().min(1)
+    S3_REGION: z.string().min(1),
+    S3_BUCKET: z.string().min(1),
+    S3_ACCESS_KEY: z.string().min(1),
+    S3_SECRET_KEY: z.string().min(1)
   },
 
-  /**
-   * Specify your client-side environment variables schema here. This way you can ensure the app
-   * isn't built with invalid env vars. To expose them to the client, prefix them with
-   * `NEXT_PUBLIC_`.
-   */
   client: {
     // NEXT_PUBLIC_CLIENTVAR: z.string().min(1),
   },
 
-  /**
-   * You can't destruct `process.env` as a regular object in the Next.js edge runtimes (e.g.
-   * middlewares) or client-side so we need to destruct manually.
-   */
   runtimeEnv: {
     NODE_ENV: process.env.NODE_ENV,
     DATABASE_URL: process.env.DATABASE_URL,
@@ -62,17 +46,13 @@ export const env = createEnv({
     GOOGLE_SECRET: process.env.GOOGLE_SECRET,
     GITHUB_ID: process.env.GITHUB_ID,
     GITHUB_SECRET: process.env.GITHUB_SECRET,
-    FIREBASE_PROJECT_ID: process.env.FIREBASE_PROJECT_ID,
-    FIREBASE_PRIVATE_KEY: process.env.FIREBASE_PRIVATE_KEY,
-    FIREBASE_CLIENT_EMAIL: process.env.FIREBASE_CLIENT_EMAIL,
-    FIREBASE_STORAGE_BUCKET: process.env.FIREBASE_STORAGE_BUCKET
+    S3_REGION: process.env.S3_REGION,
+    S3_BUCKET: process.env.S3_BUCKET,
+    S3_ACCESS_KEY: process.env.S3_ACCESS_KEY,
+    S3_SECRET_KEY: process.env.S3_SECRET_KEY
   },
-  /**
-   * Run `build` or `dev` with `SKIP_ENV_VALIDATION` to skip env validation.
-   * This is especially useful for Docker builds.
-   */
+
   skipValidation: !!process.env.SKIP_ENV_VALIDATION,
 
-  // This makes empty strings be treated as undefined
   emptyStringAsUndefined: true
 })

package/template/base/src/hooks/use-lock-body.tsx

@@ -1,6 +1,7 @@
+'use client'
+
 import { useLayoutEffect } from 'react'
 
-// @see https://usehooks.com/useLockBodyScroll.
 export function useLockBody() {
   useLayoutEffect((): (() => void) => {
     const originalStyle: string = window.getComputedStyle(

package/template/base/src/lib/auth.ts

@@ -1,38 +1,36 @@
-import { PrismaAdapter } from '@next-auth/prisma-adapter'
-import { User as PrismaUser } from '@prisma/client'
+import { DrizzleAdapter } from '@auth/drizzle-adapter'
+import { InferSelectModel } from 'drizzle-orm'
 import {
+  Session as NextAuthSession,
   getServerSession,
   type DefaultSession,
   type NextAuthOptions
 } from 'next-auth'
+import { Adapter } from 'next-auth/adapters'
 import EmailProvider from 'next-auth/providers/email'
 import GitHubProvider from 'next-auth/providers/github'
 import GoogleProvider from 'next-auth/providers/google'
+import { cache } from 'react'
 
+import type { RolePermissionType } from '@/data-access/role-permission'
+import type { UserType } from '@/data-access/user'
+import { db } from '@/db'
+import { Account, Session, User, VerificationToken } from '@/db/schema'
 import { env } from '@/env.mjs'
-import { prisma } from '@/lib/db'
+import { checkForRolePermissionUseCase } from '@/use-case/role-permission'
 
-/**
- * Module augmentation for `next-auth` types. Allows us to add custom properties to the `session`
- * object and keep type safety.
- *
- * @see https://next-auth.js.org/getting-started/typescript#module-augmentation
- */
 declare module 'next-auth' {
   interface Session extends DefaultSession {
     user: {
       id: string
+      type: UserType['type']
+      roleId?: string | null
     } & DefaultSession['user']
   }
 
-  interface User extends PrismaUser {}
+  interface User extends InferSelectModel<typeof User> {}
 }
 
-/**
- * Options for NextAuth.js used to configure adapters, providers, callbacks, etc.
- *
- * @see https://next-auth.js.org/configuration/options
- */
 export const authOptions: NextAuthOptions = {
   pages: {
     signIn: '/login'
@@ -43,12 +41,19 @@ export const authOptions: NextAuthOptions = {
         ...session,
         user: {
           ...session.user,
-          id: user.id
+          id: user.id,
+          type: user.type,
+          roleId: user.roleId
         }
       }
     }
   },
-  adapter: PrismaAdapter(prisma),
+  adapter: DrizzleAdapter(db, {
+    usersTable: User,
+    accountsTable: Account,
+    sessionsTable: Session,
+    verificationTokensTable: VerificationToken
+  }) as Adapter,
   providers: [
     EmailProvider({
       server: {
@@ -72,9 +77,13 @@ export const authOptions: NextAuthOptions = {
   ]
 }
 
-/**
- * Wrapper for `getServerSession` so that you don't need to import the `authOptions` in every file.
- *
- * @see https://next-auth.js.org/configuration/nextjs
- */
-export const getAuthSession = () => getServerSession(authOptions)
+export const getAuthSession = cache(() => getServerSession(authOptions))
+
+export const authGuard = cache(
+  (session: NextAuthSession, permission?: RolePermissionType['permission']) =>
+    checkForRolePermissionUseCase(
+      session.user.type,
+      session.user.roleId,
+      permission
+    )
+)

package/template/base/src/lib/currentUser.ts

@@ -0,0 +1,8 @@
+import { User } from '@/db/schema'
+import { InferSelectModel } from 'drizzle-orm'
+
+export type CurrentUser = {
+  id: string
+  type: InferSelectModel<typeof User>['type']
+  roleId?: string | null
+}

package/template/base/src/lib/s3Client.ts

@@ -0,0 +1,156 @@
+import {
+  DeleteObjectCommand,
+  HeadObjectCommand,
+  HeadObjectCommandOutput,
+  S3Client
+} from '@aws-sdk/client-s3'
+import { createPresignedPost } from '@aws-sdk/s3-presigned-post'
+import { createId } from '@paralleldrive/cuid2'
+import { extname } from 'path'
+
+import {
+  createResource,
+  deleteResource,
+  getResourceById,
+  updateResourceById
+} from '@/data-access/resource'
+import { env } from '@/env.mjs'
+import { CurrentUser } from './currentUser'
+
+export const S3_HOST = `https://${env.S3_BUCKET}.s3.${env.S3_REGION}.amazonaws.com`
+
+export const s3Client = new S3Client({
+  region: env.S3_REGION,
+  credentials: {
+    accessKeyId: env.S3_ACCESS_KEY,
+    secretAccessKey: env.S3_SECRET_KEY
+  }
+})
+
+export const getUrl = (key: string) => `${S3_HOST}/${key}`
+
+const uploadLimit = 1024 * 1024 * 10 // 10 MB
+
+export const getPresignedUrl = async ({
+  filename,
+  contentType,
+  contentTypeStartsWith,
+  isPublic,
+  createdById
+}: {
+  filename: string
+  contentType: string
+  contentTypeStartsWith?: string
+  isPublic?: boolean
+  createdById?: string | null
+}) => {
+  const id = createId()
+
+  const extension = extname(filename)
+
+  const key = `${id}${extension}`
+
+  const url = getUrl(key)
+
+  await createResource({
+    id,
+    filename,
+    key,
+    isTemp: true,
+    url,
+    createdById,
+    size: 0,
+    contentType
+  })
+
+  const Conditions: any[] = [
+    ['content-length-range', 1024, uploadLimit],
+    { bucket: env.S3_BUCKET },
+    { key },
+    ['eq', '$Content-Type', contentType],
+    ['eq', '$x-amz-meta-filename', filename],
+    ['eq', '$x-amz-meta-extension', extension]
+  ]
+
+  if (isPublic) Conditions.push({ acl: 'public-read' })
+  if (contentTypeStartsWith)
+    Conditions.push(['starts-with', '$Content-Type', contentTypeStartsWith])
+  if (createdById)
+    Conditions.push(['eq', '$x-amz-meta-createdById', createdById])
+
+  const presigned = await createPresignedPost(s3Client, {
+    Bucket: env.S3_BUCKET,
+    Key: key,
+    Expires: 300,
+    Conditions,
+    Fields: {
+      ...(isPublic
+        ? {
+            acl: 'public-read'
+          }
+        : {}),
+
+      ...(createdById
+        ? {
+            'X-Amz-Meta-createdById': createdById
+          }
+        : {}),
+
+      'X-Amz-Meta-filename': filename,
+      'X-Amz-Meta-extension': extension,
+      'Content-Type': contentType,
+      'Content-Disposition': `inline; filename="${encodeURIComponent(filename)}"`
+    }
+  })
+
+  return {
+    id,
+    key,
+    url,
+    presigned
+  }
+}
+
+export const markFileUploaded = async (
+  currentUser: CurrentUser,
+  id: string
+) => {
+  const resource = await getResourceById(id)
+
+  if (!resource) throw new Error('Resource not found')
+
+  let response: HeadObjectCommandOutput
+  try {
+    response = await s3Client.send(
+      new HeadObjectCommand({
+        Bucket: env.S3_BUCKET,
+        Key: resource.key
+      })
+    )
+  } catch (err) {
+    throw new Error('File not found')
+  }
+
+  await updateResourceById({
+    id: resource.id,
+    isTemp: false,
+    contentType: response.ContentType,
+    size: response.ContentLength,
+    updatedById: currentUser.id
+  })
+}
+
+export const deleteFile = async (id: string) => {
+  const resource = await getResourceById(id)
+
+  if (!resource) throw new Error('Resource not found')
+
+  await s3Client.send(
+    new DeleteObjectCommand({
+      Bucket: env.S3_BUCKET,
+      Key: resource.key
+    })
+  )
+
+  await deleteResource(id)
+}

package/template/base/src/lib/safe-action.ts

@@ -0,0 +1,19 @@
+import { createSafeActionClient } from 'next-safe-action'
+
+import { getAuthSession } from './auth'
+
+const actionClient = createSafeActionClient()
+
+export const authActionClient = actionClient.use(async ({ next }) => {
+  const session = await getAuthSession()
+
+  if (!session?.user) {
+    throw new Error('Unauthorized')
+  }
+
+  return next({
+    ctx: {
+      user: session.user
+    }
+  })
+})

package/template/base/src/lib/sortOrderEnum.ts

@@ -0,0 +1,2 @@
+export const SortOrderEnum = ['asc', 'desc'] as const
+export type SortOrderEnum = (typeof SortOrderEnum)[number]

package/template/base/src/use-case/role-permission.ts

@@ -0,0 +1,19 @@
+import {
+  checkForRolePermission,
+  type RolePermissionType
+} from '@/data-access/role-permission'
+import { type UserType } from '@/data-access/user'
+
+export const checkForRolePermissionUseCase = async (
+  userType: UserType['type'],
+  roleId?: string | null,
+  permission?: RolePermissionType['permission']
+) => {
+  if (userType === 'Root') return true
+
+  if (!roleId) return false
+
+  if (!permission) return true
+
+  return await checkForRolePermission(roleId, permission)
+}