create-ej-app 3.2.0 → 4.0.0

package/template/base/src/components/ui/sonner.tsx

@@ -0,0 +1,31 @@
+'use client'
+
+import { useTheme } from 'next-themes'
+import { Toaster as Sonner } from 'sonner'
+
+type ToasterProps = React.ComponentProps<typeof Sonner>
+
+const Toaster = ({ ...props }: ToasterProps) => {
+  const { theme = 'system' } = useTheme()
+
+  return (
+    <Sonner
+      theme={theme as ToasterProps['theme']}
+      className="toaster group"
+      toastOptions={{
+        classNames: {
+          toast:
+            'group toast group-[.toaster]:bg-background group-[.toaster]:text-foreground group-[.toaster]:border-border group-[.toaster]:shadow-lg',
+          description: 'group-[.toast]:text-muted-foreground',
+          actionButton:
+            'group-[.toast]:bg-primary group-[.toast]:text-primary-foreground',
+          cancelButton:
+            'group-[.toast]:bg-muted group-[.toast]:text-muted-foreground'
+        }
+      }}
+      {...props}
+    />
+  )
+}
+
+export { Toaster }

package/template/base/src/components/user-avatar.tsx

@@ -1,4 +1,3 @@
-import { User } from '@prisma/client'
 import { AvatarProps } from '@radix-ui/react-avatar'
 import { FC } from 'react'
 
@@ -6,7 +5,10 @@ import { Icons } from '@/components/icons'
 import { Avatar, AvatarFallback, AvatarImage } from '@/components/ui/avatar'
 
 interface UserAvatarProps extends AvatarProps {
-  user: Pick<User, 'image' | 'name'>
+  user: {
+    name?: string | null
+    image?: string | null
+  }
 }
 
 export const UserAvatar: FC<UserAvatarProps> = ({ user, ...props }) => {

package/template/base/src/data-access/resource.ts

@@ -0,0 +1,85 @@
+import { db } from '@/db'
+import { Resource } from '@/db/schema'
+import { eq, or, sql } from 'drizzle-orm'
+
+type createResourceInput = {
+  id?: string
+  filename: string
+  key: string
+  isTemp: boolean
+  url: string
+  size: number
+  contentType: string
+  createdById?: string | null
+
+  taskId?: string | null
+}
+
+export const createResource = async (data: createResourceInput) => {
+  const newResource = await db
+    .insert(Resource)
+    .values({
+      ...data
+    })
+    .returning({
+      id: Resource.id
+    })
+
+  const id = newResource[0]?.id
+
+  if (!id) throw new Error('Failed to create resource')
+
+  return id
+}
+
+export const getResourceById = async (id: string) => {
+  return await db.query.Resource.findFirst({
+    where: eq(Resource.id, id)
+  })
+}
+
+type updateResourceByIdInput = {
+  id: string
+  isTemp?: boolean
+  contentType?: string
+  size?: number
+  updatedById?: string | null
+
+  taskId?: string | null
+}
+
+export const updateResourceById = async (data: updateResourceByIdInput) => {
+  return await db
+    .update(Resource)
+    .set({
+      ...data,
+      updatedAt: sql`now()`
+    })
+    .where(eq(Resource.id, data.id))
+}
+
+type updateResourceByIdsInput = {
+  ids: string[]
+  taskId?: string | null
+  updatedById?: string | null
+}
+
+export const updateResourceByIds = async (data: updateResourceByIdsInput) => {
+  return await db
+    .update(Resource)
+    .set({
+      ...data,
+      updatedAt: sql`now()`
+    })
+    .where(or(...data.ids.map(id => eq(Resource.id, id))))
+}
+
+export const getResourcesByTaskId = async (taskId: string) => {
+  return await db.query.Resource.findMany({
+    where: eq(Resource.taskId, taskId)
+  })
+}
+
+export const deleteResource = async (id: string) => {
+  return await db.delete(Resource).where(eq(Resource.id, id))
+}

package/template/base/src/data-access/role-permission.ts

@@ -0,0 +1,45 @@
+import { InferSelectModel, and, count, eq } from 'drizzle-orm'
+
+import { db } from '@/db'
+import { RolePermission } from '@/db/schema'
+
+export type RolePermissionType = InferSelectModel<typeof RolePermission>
+
+export const checkForRolePermission = async (
+  roleId: string,
+  permission: RolePermissionType['permission']
+) => {
+  const c = await db
+    .select({ count: count() })
+    .from(RolePermission)
+    .where(
+      and(
+        eq(RolePermission.roleId, roleId),
+        eq(RolePermission.permission, permission)
+      )
+    )
+
+  return !!c?.[0]?.count
+}
+
+type createRolePermissionsInput = {
+  roleId: string
+  permissions: RolePermissionType['permission'][]
+}
+
+export const createRolePermissions = async (
+  data: createRolePermissionsInput
+) => {
+  return await db.insert(RolePermission).values(
+    data.permissions.map(p => ({
+      roleId: data.roleId,
+      permission: p
+    }))
+  )
+}
+
+export const deleteRolePermissionsByRoleId = async (roleId: string) => {
+  return await db
+    .delete(RolePermission)
+    .where(eq(RolePermission.roleId, roleId))
+}

package/template/base/src/data-access/role.ts

@@ -0,0 +1,105 @@
+import { InferSelectModel, asc, count, desc, eq, ilike, sql } from 'drizzle-orm'
+
+import { db } from '@/db'
+import { Role } from '@/db/schema'
+import { type SortOrderEnum } from '@/lib/sortOrderEnum'
+
+export type RoleType = InferSelectModel<typeof Role>
+
+type getRolesInput = {
+  page: number
+  limit: number
+  sortBy?: keyof RoleType
+  sortOrder?: SortOrderEnum
+  filters?: {
+    name?: string
+  }
+}
+
+export const getRoles = async ({
+  page,
+  limit,
+  sortBy,
+  sortOrder,
+  filters
+}: getRolesInput) => {
+  const where = filters?.name
+    ? ilike(Role.name, `%${filters.name}%`)
+    : undefined
+
+  const [roles, total] = await Promise.all([
+    db.query.Role.findMany({
+      columns: {
+        id: true,
+        name: true,
+        createdAt: true,
+        updatedAt: true
+      },
+      where,
+      orderBy: [
+        sortOrder === 'asc'
+          ? asc(Role[sortBy || 'createdAt'])
+          : desc(Role[sortBy || 'createdAt'])
+      ],
+      offset: (page - 1) * limit,
+      limit
+    }),
+    db
+      .select({
+        count: count()
+      })
+      .from(Role)
+      .where(where)
+  ])
+
+  return { roles, total: total[0]?.count || 0 }
+}
+
+export const getRoleByIdWithPermissions = async (id: string) => {
+  return await db.query.Role.findFirst({
+    where: eq(Role.id, id),
+    with: {
+      permissions: true
+    }
+  })
+}
+
+type createRoleInput = {
+  name: string
+}
+
+export const createRole = async (data: createRoleInput) => {
+  const newRole = await db.insert(Role).values(data).returning({
+    id: Role.id
+  })
+
+  const id = newRole[0]?.id
+  if (!id) throw new Error('Failed to create role')
+
+  return id
+}
+
+type updateRoleInput = createRoleInput & {
+  id: string
+}
+
+export const updateRole = async (data: updateRoleInput) => {
+  return await db
+    .update(Role)
+    .set({ ...data, updatedAt: sql`now()` })
+    .where(eq(Role.id, data.id))
+}
+
+export const deleteRole = async (id: string) => {
+  return await db.delete(Role).where(eq(Role.id, id))
+}
+
+export const getRolesMini = async () => {
+  return await db.query.Role.findMany({
+    columns: {
+      id: true,
+      name: true
+    },
+    orderBy: [asc(Role.name)]
+  })
+}

package/template/base/src/data-access/task.ts

@@ -0,0 +1,141 @@
+import {
+  InferSelectModel,
+  asc,
+  count,
+  desc,
+  eq,
+  ilike,
+  or,
+  sql
+} from 'drizzle-orm'
+
+import { db } from '@/db'
+import { Task } from '@/db/schema'
+import { type SortOrderEnum } from '@/lib/sortOrderEnum'
+
+export type TaskType = InferSelectModel<typeof Task>
+
+type getTasksInput = {
+  page: number
+  limit: number
+  sortBy?: keyof TaskType
+  sortOrder?: SortOrderEnum
+  filters?: {
+    title?: string
+    status?: TaskType['status'][]
+  }
+}
+
+export const getTasksWithUser = async ({
+  page,
+  limit,
+  sortBy,
+  sortOrder,
+  filters
+}: getTasksInput) => {
+  const where = or(
+    filters?.title ? ilike(Task.title, `%${filters.title}%`) : undefined,
+    ...(filters?.status || []).map(f => eq(Task.status, f))
+  )
+
+  const [tasks, total] = await Promise.all([
+    db.query.Task.findMany({
+      columns: {
+        id: true,
+        title: true,
+        status: true,
+        createdAt: true,
+        updatedAt: true
+      },
+      with: {
+        createdBy: {
+          columns: {
+            id: true,
+            name: true
+          }
+        },
+        updatedBy: {
+          columns: {
+            id: true,
+            name: true
+          }
+        }
+      },
+      where,
+      orderBy: [
+        sortOrder === 'asc'
+          ? asc(Task[sortBy || 'createdAt'])
+          : desc(Task[sortBy || 'createdAt'])
+      ],
+      offset: (page - 1) * limit,
+      limit
+    }),
+    db
+      .select({
+        count: count()
+      })
+      .from(Task)
+      .where(where)
+  ])
+
+  return { tasks, total: total[0]?.count || 0 }
+}
+
+export const getTaskByIdWithUser = async (id: string) => {
+  return await db.query.Task.findFirst({
+    where: eq(Task.id, id),
+    with: {
+      createdBy: {
+        columns: {
+          id: true,
+          name: true
+        }
+      },
+      updatedBy: {
+        columns: {
+          id: true,
+          name: true
+        }
+      }
+    }
+  })
+}
+
+type createTaskInput = {
+  title: string
+  description?: string | null
+  status: TaskType['status']
+  createdById: string
+}
+
+export const createTask = async (data: createTaskInput) => {
+  const newTask = await db.insert(Task).values(data).returning({
+    id: Task.id
+  })
+
+  if (!newTask[0]?.id) throw new Error('Failed to create task')
+
+  return newTask[0].id
+}
+
+type updateTaskInput = {
+  id: string
+  title?: string
+  description?: string | null
+  status?: TaskType['status']
+  updatedById: string
+}
+
+export const updateTask = async (data: updateTaskInput) => {
+  return await db
+    .update(Task)
+    .set({
+      ...data,
+      updatedAt: sql`now()`
+    })
+    .where(eq(Task.id, data.id))
+}
+
+export const deleteTask = async (id: string) => {
+  return await db.delete(Task).where(eq(Task.id, id))
+}

package/template/base/src/data-access/user.ts

@@ -0,0 +1,141 @@
+import {
+  InferSelectModel,
+  asc,
+  count,
+  desc,
+  eq,
+  ilike,
+  or,
+  sql
+} from 'drizzle-orm'
+
+import { db } from '@/db'
+import { User } from '@/db/schema'
+import { type SortOrderEnum } from '@/lib/sortOrderEnum'
+
+export type UserType = InferSelectModel<typeof User>
+
+type updateUserByIdInput = {
+  name?: string | null
+  type?: UserType['type']
+  roleId?: string | null
+}
+
+export const updateUser = async (id: string, data: updateUserByIdInput) => {
+  await db
+    .update(User)
+    .set({ ...data, updatedAt: sql`now()` })
+    .where(eq(User.id, id))
+}
+
+type getUsersInput = {
+  page: number
+  limit: number
+  sortBy?: keyof UserType
+  sortOrder?: SortOrderEnum
+  filters?: {
+    name?: string
+    email?: string
+    type?: UserType['type'][]
+  }
+}
+
+export const getUsersWithRole = async ({
+  page,
+  limit,
+  sortBy,
+  sortOrder,
+  filters
+}: getUsersInput) => {
+  const where = or(
+    filters?.name ? ilike(User.name, `%${filters.name}%`) : undefined,
+    filters?.email ? ilike(User.email, `%${filters.email}%`) : undefined,
+    ...(filters?.type || []).map(f => eq(User.type, f))
+  )
+
+  const [users, total] = await Promise.all([
+    db.query.User.findMany({
+      columns: {
+        id: true,
+        name: true,
+        email: true,
+        type: true,
+        roleId: true,
+        image: true,
+        emailVerified: true,
+        createdAt: true,
+        updatedAt: true
+      },
+      with: {
+        role: true
+      },
+      where,
+      orderBy: [
+        sortOrder === 'asc'
+          ? asc(User[sortBy || 'createdAt'])
+          : desc(User[sortBy || 'createdAt'])
+      ],
+      offset: (page - 1) * limit,
+      limit
+    }),
+    db
+      .select({
+        count: count()
+      })
+      .from(User)
+      .where(where)
+  ])
+
+  return { users, total: total[0]?.count || 0 }
+}
+
+export const getUserById = async (id: string) => {
+  return await db.query.User.findFirst({
+    where: eq(User.id, id),
+    columns: {
+      id: true,
+      name: true,
+      email: true,
+      emailVerified: true,
+      type: true,
+      roleId: true,
+      createdAt: true,
+      updatedAt: true
+    }
+  })
+}
+
+type createUserInput = {
+  name?: string | null
+  email: string
+  type: UserType['type']
+  roleId?: string | null
+}
+
+export const createUser = async ({
+  name,
+  email,
+  type,
+  roleId
+}: createUserInput) => {
+  const newUser = await db
+    .insert(User)
+    .values({
+      name,
+      email,
+      type,
+      roleId
+    })
+    .returning({
+      id: User.id
+    })
+
+  const id = newUser[0]?.id
+  if (!id) throw new Error('Failed to create user')
+
+  return id
+}
+
+export const deleteUser = async (id: string) => {
+  return await db.delete(User).where(eq(User.id, id))
+}

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

@@ -0,0 +1,14 @@
+import { drizzle } from 'drizzle-orm/postgres-js'
+import postgres from 'postgres'
+
+import { env } from '@/env.mjs'
+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 })