create-ej-app 11.0.0 → 14.0.0

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

@@ -1,27 +0,0 @@
-import { AvatarProps } from '@radix-ui/react-avatar'
-import { FC } from 'react'
-
-import { Icons } from '@/components/icons'
-import { Avatar, AvatarFallback, AvatarImage } from '@/components/ui/avatar'
-
-interface UserAvatarProps extends AvatarProps {
-  user: {
-    name?: string | null
-    image?: string | null
-  }
-}
-
-export const UserAvatar: FC<UserAvatarProps> = ({ user, ...props }) => {
-  return (
-    <Avatar {...props}>
-      {user.image ? (
-        <AvatarImage alt="Picture" src={user.image} />
-      ) : (
-        <AvatarFallback>
-          <span className="sr-only">{user.name}</span>
-          <Icons.user className="h-4 w-4" />
-        </AvatarFallback>
-      )}
-    </Avatar>
-  )
-}

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

@@ -1,85 +0,0 @@
-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/old/src/data-access/role-permission.ts

@@ -1,45 +0,0 @@
-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/old/src/data-access/role.ts

@@ -1,105 +0,0 @@
-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/old/src/data-access/task.ts

@@ -1,141 +0,0 @@
-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/old/src/data-access/user.ts

@@ -1,141 +0,0 @@
-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/old/src/db/index.ts

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