create-ej-app 6.0.0 → 8.0.0

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

@@ -1,14 +1,7 @@
 import { drizzle } from 'drizzle-orm/postgres-js'
-import postgres from 'postgres'
-
-import { env } from '@/env.mjs'
+import { env } from '~/env'
 import * as schema from './schema'
 
-const globalForDb = globalThis as unknown as {
-  conn: postgres.Sql | undefined
-}
-
-const conn = globalForDb.conn ?? postgres(env.DATABASE_URL)
-if (env.NODE_ENV !== 'production') globalForDb.conn = conn
-
-export const db = drizzle(conn, { schema })
+export const db = drizzle(env.DATABASE_URL, {
+  schema: { ...schema }
+})

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

@@ -1,287 +1,79 @@
 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'
+import { boolean, pgTable, text, timestamp, 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()
+const commonFieldDefs = {
+  id: (prefix: string) =>
+    varchar('id')
       .primaryKey()
-      .$defaultFn(() => createId()),
-    sessionToken: varchar('sessionToken', { length: 255 }).notNull().unique(),
-    userId: text('userId')
-      .notNull()
-      .references(() => User.id),
-    expires: timestamp('expires', {
+      .$defaultFn(() => prefix + '_' + createId()),
+  date: (name: string) =>
+    timestamp(name, {
       mode: 'date',
       withTimezone: true
-    }).notNull(),
-    createdAt: timestamp('createdAt', {
+    }),
+  dates: {
+    createdAt: timestamp('created_at', {
       mode: 'date',
       withTimezone: true
     })
-      .default(sql`CURRENT_TIMESTAMP`)
-      .notNull(),
-    updatedAt: timestamp('updatedAt', {
+      .notNull()
+      .defaultNow(),
+    updatedAt: timestamp('updated_at', {
       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'])
+      .defaultNow()
+  }
+}
+
+export const usersTable = pgTable('users', {
+  id: commonFieldDefs.id('user'),
+  email: text('email').notNull().unique(),
+  name: text('name').notNull(),
+  emailVerified: boolean('email_verified').default(false).notNull(),
+  image: text('image'),
+  role: text('role'),
+  banned: boolean('banned').default(false),
+  banReason: text('ban_reason'),
+  banExpires: commonFieldDefs.date('ban_expires'),
+  ...commonFieldDefs.dates
+})
 
-export const User = pgTable('Users', {
-  id: text('id')
+export const sessionsTable = pgTable('sessions', {
+  id: commonFieldDefs.id('session'),
+  expiresAt: commonFieldDefs.date('expires_at').notNull(),
+  token: text('token').notNull().unique(),
+  ipAddress: text('ip_address'),
+  userAgent: text('user_agent'),
+  userId: text('user_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
-  })
+    .references(() => usersTable.id, { onDelete: 'cascade' }),
+  impersonatedBy: text('impersonated_by'),
+  ...commonFieldDefs.dates
 })
 
-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')
+export const accountsTable = pgTable('accounts', {
+  id: commonFieldDefs.id('account'),
+  accountId: text('account_id').notNull(),
+  providerId: text('provider_id').notNull(),
+  userId: text('user_id')
     .notNull()
-    .references(() => User.id),
-  updatedById: text('updatedById').references(() => User.id)
+    .references(() => usersTable.id, { onDelete: 'cascade' }),
+  accessToken: text('access_token'),
+  refreshToken: text('refresh_token'),
+  idToken: text('id_token'),
+  accessTokenExpiresAt: commonFieldDefs.date('access_token_expires_at'),
+  refreshTokenExpiresAt: commonFieldDefs.date('refresh_token_expires_at'),
+  scope: text('scope'),
+  password: text('password'),
+  ...commonFieldDefs.dates
 })
 
-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]
-  })
-}))
+export const verificationsTable = pgTable('verifications', {
+  id: commonFieldDefs.id('verification'),
+  identifier: text('identifier').notNull(),
+  value: text('value').notNull(),
+  expiresAt: commonFieldDefs.date('expires_at').notNull(),
+  ...commonFieldDefs.dates
+})

package/template/{new → base}/src/env.ts

@@ -3,7 +3,7 @@ import { z } from 'zod'
 
 export const env = createEnv({
   server: {
-    NODE_ENV: z.enum(['development', 'production']),
+    APP_ENV: z.enum(['development', 'staging', 'production']),
     ANALYZE: z.string().optional(),
     DATABASE_URL: z.url(),
     BETTER_AUTH_URL: z.url(),
@@ -22,7 +22,7 @@ export const env = createEnv({
   client: {},
 
   runtimeEnv: {
-    NODE_ENV: process.env.NODE_ENV,
+    APP_ENV: process.env.APP_ENV,
     ANALYZE: process.env.ANALYZE,
     DATABASE_URL: process.env.DATABASE_URL,
     BETTER_AUTH_URL: process.env.BETTER_AUTH_URL,

package/template/{new → base}/src/lib/auth-client.ts

@@ -1,6 +1,7 @@
 'use client'
 
 import {
+  adminClient,
   inferAdditionalFields,
   lastLoginMethodClient,
   magicLinkClient
@@ -13,6 +14,7 @@ export const { signIn, signOut, useSession, getLastUsedLoginMethod } =
     plugins: [
       inferAdditionalFields<typeof auth>(),
       magicLinkClient(),
+      adminClient(),
       lastLoginMethodClient()
     ]
   })

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

@@ -1,89 +1,73 @@
-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 { createId } from '@paralleldrive/cuid2'
+import { betterAuth } from 'better-auth'
+import { drizzleAdapter } from 'better-auth/adapters/drizzle'
+import { admin, lastLoginMethod, magicLink } from 'better-auth/plugins'
+import { headers } from 'next/headers'
 import { cache } from 'react'
+import { db } from '~/db'
+import {
+  accountsTable,
+  sessionsTable,
+  usersTable,
+  verificationsTable
+} from '~/db/schema'
+import { env } from '~/env'
 
-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 { checkForRolePermissionUseCase } from '@/use-case/role-permission'
-
-declare module 'next-auth' {
-  interface Session extends DefaultSession {
-    user: {
-      id: string
-      type: UserType['type']
-      roleId?: string | null
-    } & DefaultSession['user']
-  }
-
-  interface User extends InferSelectModel<typeof User> {}
-}
-
-export const authOptions: NextAuthOptions = {
-  pages: {
-    signIn: '/login'
+export const auth = betterAuth({
+  database: drizzleAdapter(db, {
+    provider: 'pg',
+    schema: {
+      user: usersTable,
+      session: sessionsTable,
+      account: accountsTable,
+      verification: verificationsTable
+    }
+  }),
+  account: {
+    accountLinking: {
+      enabled: true
+    }
   },
-  callbacks: {
-    session({ session, user }) {
-      return {
-        ...session,
-        user: {
-          ...session.user,
-          id: user.id,
-          type: user.type,
-          roleId: user.roleId
-        }
-      }
+  advanced: {
+    database: {
+      generateId: ({ model }) => `${model}_${createId()}`
     }
   },
-  adapter: DrizzleAdapter(db, {
-    usersTable: User,
-    accountsTable: Account,
-    sessionsTable: Session,
-    verificationTokensTable: VerificationToken
-  }) as Adapter,
-  providers: [
-    EmailProvider({
-      server: {
-        host: env.EMAIL_SERVER_HOST,
-        port: env.EMAIL_SERVER_PORT,
-        auth: {
-          user: env.EMAIL_SERVER_USER,
-          pass: env.EMAIL_SERVER_PASSWORD
-        }
-      },
-      from: env.EMAIL_FROM
-    }),
-    GoogleProvider({
-      clientId: env.GOOGLE_ID,
-      clientSecret: env.GOOGLE_SECRET
+  socialProviders: {
+    github: {
+      prompt: 'select_account',
+      clientId: env.BETTER_AUTH_GITHUB_ID,
+      clientSecret: env.BETTER_AUTH_GITHUB_SECRET
+    },
+    google: {
+      prompt: 'select_account',
+      clientId: env.BETTER_AUTH_GOOGLE_ID,
+      clientSecret: env.BETTER_AUTH_GOOGLE_SECRET
+    }
+  },
+  plugins: [
+    magicLink({
+      sendMagicLink: async ({ email, token, url }) => {
+        console.warn('TODO: send email', {
+          email,
+          token,
+          url
+        })
+      }
     }),
-    GitHubProvider({
-      clientId: env.GITHUB_ID,
-      clientSecret: env.GITHUB_SECRET
-    })
+    admin(),
+    lastLoginMethod()
   ]
-}
+})
+
+export const getAuthSession = cache(async () => {
+  const authSession = await auth.api.getSession({
+    headers: await headers()
+  })
+
+  if (!authSession || !authSession.user || !authSession.session) return null
 
-export const getAuthSession = cache(() => getServerSession(authOptions))
+  const isAdmin = authSession.user.role === 'admin'
 
-export const authGuard = cache(
-  (session: NextAuthSession, permission?: RolePermissionType['permission']) =>
-    checkForRolePermissionUseCase(
-      session.user.type,
-      session.user.roleId,
-      permission
-    )
-)
+  return { ...authSession, isAdmin }
+})

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

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

package/template/base/tsconfig.json

@@ -1,6 +1,6 @@
 {
   "compilerOptions": {
-    "target": "ES2022",
+    "target": "ES2017",
     "lib": ["DOM", "DOM.Iterable", "ESNext"],
     "allowJs": true,
     "checkJs": true,
@@ -22,26 +22,28 @@
     "moduleResolution": "bundler",
     "resolveJsonModule": true,
     "isolatedModules": true,
-    "jsx": "preserve",
+    "jsx": "react-jsx",
     "incremental": true,
     "plugins": [
       {
         "name": "next"
+      },
+      {
+        "name": "workflow"
       }
     ],
     "paths": {
-      "@/*": ["./src/*"]
+      "~/*": ["./src/*"]
     }
   },
   "include": [
-    ".eslintrc.cjs",
     "next-env.d.ts",
     "**/*.ts",
     "**/*.tsx",
-    "**/*.js",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts",
     "**/*.cjs",
-    "**/*.mjs",
-    ".next/types/**/*.ts"
+    "**/*.mjs"
   ],
   "exclude": ["node_modules"]
 }

package/template/{prisma-advanced → old}/.env.example

@@ -1,4 +1,5 @@
-DATABASE_URL="postgresql://postgres:postgres@localhost:5432/postgres?schema=public"
+NODE_ENV="development"
+DATABASE_URL="postgresql://postgres:postgres@localhost:5432/postgres"
 NEXTAUTH_SECRET="secret"
 NEXTAUTH_URL="http://localhost:3000"
 EMAIL_SERVER_HOST="example.com"
@@ -6,11 +7,11 @@ EMAIL_SERVER_PORT="123"
 EMAIL_SERVER_USER="example@example.com"
 EMAIL_SERVER_PASSWORD="password"
 EMAIL_FROM="example@example.com"
-GOOGLE_ID=""
-GOOGLE_SECRET=""
-GITHUB_ID=""
-GITHUB_SECRET=""
-FIREBASE_PROJECT_ID=""
-FIREBASE_PRIVATE_KEY=""
-FIREBASE_CLIENT_EMAIL=""
-FIREBASE_STORAGE_BUCKET=""
+GOOGLE_ID="id"
+GOOGLE_SECRET="secret"
+GITHUB_ID="id"
+GITHUB_SECRET="secret"
+S3_REGION="ap-south-1"
+S3_BUCKET="bucket"
+S3_ACCESS_KEY="key"
+S3_SECRET_KEY="secret"