@tulip-systems/create-app 0.11.1

package/dist/templates/code/src/app/admin/initiatives/_lib/router.ts

@@ -0,0 +1,352 @@
+import "server-cli-only";
+
+import { ORPCError } from "@orpc/server";
+import {
+  bulkActionSchema,
+  offsetPaginationResponse,
+  offsetPaginationSchema,
+} from "@tulip-systems/query";
+import { and, asc, desc, eq, gte, inArray, isNotNull, lt, sql } from "drizzle-orm";
+import z from "zod";
+import { getTableData } from "@/app/lib/utils/table-data.server";
+import { employees, tasks, timeEntries, users } from "@/server/db/schema";
+import { permissionMiddleware } from "@/server/router/middleware";
+import { protectedProcedure } from "@/server/router/procedures";
+import { initiativeDatabaseFiltersCompiler, initiativeFiltersParser } from "../_config/filters";
+import {
+  initiativeTableDatabaseSortsCompiler,
+  initiativeTableSortsParser,
+  initiativeTableSortsSchema,
+} from "../_config/sorting";
+import { initiatives } from "./schema";
+import {
+  createInitiativeSchema,
+  initiativeFiltersSchema,
+  initiativeStatusSchema,
+  updateInitiativeSchema,
+} from "./validators";
+
+export const initiativesRouter = {
+  list: protectedProcedure
+    .use(permissionMiddleware({ initiative: ["view"] }))
+    .input(
+      z.object({
+        pagination: offsetPaginationSchema,
+        filters: initiativeFiltersSchema,
+        sorts: initiativeTableSortsSchema,
+      }),
+    )
+    .handler(async ({ context, input }) => {
+      const parsedSorts = initiativeTableSortsParser.parse(input.sorts);
+      const orderBy = initiativeTableDatabaseSortsCompiler(initiatives).parse(parsedSorts);
+
+      const parsedFilters = initiativeFiltersParser.parse(input.filters);
+      const where = initiativeDatabaseFiltersCompiler(initiatives).parse(parsedFilters);
+
+      const { data, total } = await getTableData(context, initiatives, {
+        pagination: input.pagination,
+        where,
+        orderBy,
+      });
+
+      return offsetPaginationResponse({ data, pagination: input.pagination, total });
+    }),
+  getAll: protectedProcedure
+    .use(permissionMiddleware({ initiative: ["view"] }))
+    .input(z.object({ filters: initiativeFiltersSchema }))
+    .handler(async ({ context, input: { filters } }) => {
+      const results = await context.db
+        .select()
+        .from(initiatives)
+        .where(
+          and(
+            filters.projectId ? inArray(initiatives.projectId, filters.projectId) : undefined,
+            filters.status ? inArray(initiatives.status, filters.status) : undefined,
+          ),
+        )
+        .orderBy(asc(initiatives.status), desc(initiatives.startDate), desc(initiatives.endDate));
+
+      return results;
+    }),
+  getCollection: protectedProcedure
+    .use(permissionMiddleware({ initiative: ["view"] }))
+    .handler(async ({ context }) => context.db.select().from(initiatives)),
+  getById: protectedProcedure
+    .use(permissionMiddleware({ initiative: ["view"] }))
+    .input(z.object({ id: z.string() }))
+    .handler(async ({ context, input }) => {
+      const [initiative] = await context.db.query.initiatives.findMany({
+        where: eq(initiatives.id, input.id),
+        with: { project: true },
+      });
+
+      return initiative ?? null;
+    }),
+  getStats: protectedProcedure
+    .use(permissionMiddleware({ initiative: ["view"] }))
+    .input(z.object({ id: z.string() }))
+    .handler(async ({ context, input }) => {
+      const [[timeTotal], [storyPointTotal]] = await Promise.all([
+        context.db
+          .select({
+            totalSeconds: sql<number>`coalesce(sum(${timeEntries.durationSeconds}), 0)`,
+          })
+          .from(tasks)
+          .leftJoin(timeEntries, eq(timeEntries.taskId, tasks.id))
+          .where(eq(tasks.initiativeId, input.id)),
+        context.db
+          .select({
+            totalStoryPoints: sql<number>`coalesce(sum(${tasks.storyPoints}), 0)`,
+            totalDoneStoryPoints: sql<number>`coalesce(sum(case when ${tasks.status} = 'done' then ${tasks.storyPoints} else 0 end), 0)`,
+          })
+          .from(tasks)
+          .where(eq(tasks.initiativeId, input.id)),
+      ]);
+
+      return {
+        totalSeconds: timeTotal?.totalSeconds ?? null,
+        totalStoryPoints: storyPointTotal?.totalStoryPoints ?? null,
+        totalDoneStoryPoints: storyPointTotal?.totalDoneStoryPoints ?? null,
+      };
+    }),
+  getMonthlyHoursByEmployee: protectedProcedure
+    .use(permissionMiddleware({ initiative: ["view"] }))
+    .input(
+      z.object({
+        id: z.string(),
+        year: z.number().int(),
+        month: z.number().int().min(1).max(12),
+      }),
+    )
+    .handler(async ({ context, input }) => {
+      const monthStart = new Date(input.year, input.month - 1, 1);
+      const nextMonthStart = new Date(input.year, input.month, 1);
+      const daySql = sql<string>`date_trunc('day', ${timeEntries.start})::date`;
+
+      const days = await context.db
+        .select({
+          day: daySql,
+          employeeId: employees.id,
+          employeeName: users.name,
+          totalSeconds: sql<number>`coalesce(sum(${timeEntries.durationSeconds}), 0)`,
+        })
+        .from(timeEntries)
+        .innerJoin(tasks, eq(timeEntries.taskId, tasks.id))
+        .innerJoin(employees, eq(timeEntries.employeeId, employees.id))
+        .innerJoin(users, eq(employees.userId, users.id))
+        .where(
+          and(
+            eq(tasks.initiativeId, input.id),
+            gte(timeEntries.start, monthStart),
+            lt(timeEntries.start, nextMonthStart),
+            isNotNull(timeEntries.end),
+          ),
+        )
+        .groupBy(daySql, employees.id, users.name)
+        .orderBy(daySql, asc(users.name));
+
+      return days;
+    }),
+  getTotalHoursByEmployee: protectedProcedure
+    .use(permissionMiddleware({ initiative: ["view"] }))
+    .input(z.object({ id: z.string() }))
+    .handler(async ({ context, input }) => {
+      const totalSecondsSql = sql<number>`coalesce(sum(${timeEntries.durationSeconds}), 0)`;
+
+      const employeesByHours = await context.db
+        .select({
+          employeeId: employees.id,
+          employeeName: users.name,
+          totalSeconds: totalSecondsSql,
+        })
+        .from(timeEntries)
+        .innerJoin(tasks, eq(timeEntries.taskId, tasks.id))
+        .innerJoin(employees, eq(timeEntries.employeeId, employees.id))
+        .innerJoin(users, eq(employees.userId, users.id))
+        .where(and(eq(tasks.initiativeId, input.id), isNotNull(timeEntries.end)))
+        .groupBy(employees.id, users.name)
+        .orderBy(desc(totalSecondsSql), asc(users.name));
+
+      const normalizedEmployeesByHours = employeesByHours.map((employee) => ({
+        ...employee,
+        totalSeconds: Number(employee.totalSeconds),
+      }));
+
+      return {
+        totalSeconds: normalizedEmployeesByHours.reduce(
+          (total, employee) => total + employee.totalSeconds,
+          0,
+        ),
+        employees: normalizedEmployeesByHours,
+      };
+    }),
+  getTopTasksByHours: protectedProcedure
+    .use(permissionMiddleware({ initiative: ["view"] }))
+    .input(z.object({ id: z.string(), limit: z.number().int().min(1).max(10).default(5) }))
+    .handler(async ({ context, input }) => {
+      const totalSecondsSql = sql<number>`coalesce(sum(${timeEntries.durationSeconds}), 0)`;
+
+      const tasksByHours = await context.db
+        .select({
+          taskId: tasks.id,
+          taskCode: tasks.code,
+          taskTitle: tasks.title,
+          storyPoints: tasks.storyPoints,
+          totalSeconds: totalSecondsSql,
+        })
+        .from(timeEntries)
+        .innerJoin(tasks, eq(timeEntries.taskId, tasks.id))
+        .where(and(eq(tasks.initiativeId, input.id), isNotNull(timeEntries.end)))
+        .groupBy(tasks.id, tasks.code, tasks.title, tasks.storyPoints)
+        .orderBy(desc(totalSecondsSql), asc(tasks.title))
+        .limit(input.limit);
+
+      return tasksByHours.map((task) => ({
+        ...task,
+        storyPoints: task.storyPoints ?? null,
+        totalSeconds: Number(task.totalSeconds),
+      }));
+    }),
+  getStoryPointsByStatus: protectedProcedure
+    .use(permissionMiddleware({ initiative: ["view"] }))
+    .input(z.object({ id: z.string() }))
+    .handler(async ({ context, input }) => {
+      const statuses = ["backlog", "todo", "in_progress", "in_review", "done"] as const;
+
+      const rows = await context.db
+        .select({
+          status: tasks.status,
+          totalStoryPoints: sql<number>`coalesce(sum(${tasks.storyPoints}), 0)`,
+        })
+        .from(tasks)
+        .where(and(eq(tasks.initiativeId, input.id), inArray(tasks.status, [...statuses])))
+        .groupBy(tasks.status);
+
+      const totalsByStatus = new Map(rows.map((row) => [row.status, Number(row.totalStoryPoints)]));
+
+      const items = statuses.map((status) => ({
+        status,
+        totalStoryPoints: totalsByStatus.get(status) ?? 0,
+      }));
+
+      return {
+        totalStoryPoints: items.reduce((total, item) => total + item.totalStoryPoints, 0),
+        items,
+      };
+    }),
+  getStoryPointsByAssignee: protectedProcedure
+    .use(permissionMiddleware({ initiative: ["view"] }))
+    .input(z.object({ id: z.string() }))
+    .handler(async ({ context, input }) => {
+      const rows = await context.db
+        .select({
+          assigneeId: employees.id,
+          assigneeName: users.name,
+          totalStoryPoints: sql<number>`coalesce(sum(${tasks.storyPoints}), 0)`,
+        })
+        .from(tasks)
+        .leftJoin(employees, eq(tasks.assigneeId, employees.id))
+        .leftJoin(users, eq(employees.userId, users.id))
+        .where(eq(tasks.initiativeId, input.id))
+        .groupBy(employees.id, users.name);
+
+      const items = rows
+        .map((row) => ({
+          assigneeId: row.assigneeId ?? "unassigned",
+          assigneeName: row.assigneeName ?? "Niet toegewezen",
+          totalStoryPoints: Number(row.totalStoryPoints),
+        }))
+        .filter((row) => row.totalStoryPoints > 0)
+        .sort(
+          (a, b) =>
+            b.totalStoryPoints - a.totalStoryPoints || a.assigneeName.localeCompare(b.assigneeName),
+        );
+
+      return {
+        totalStoryPoints: items.reduce((total, item) => total + item.totalStoryPoints, 0),
+        items,
+      };
+    }),
+  getEffortVsStoryPoints: protectedProcedure
+    .use(permissionMiddleware({ initiative: ["view"] }))
+    .input(z.object({ id: z.string() }))
+    .handler(async ({ context, input }) => {
+      const totalSecondsSql = sql<number>`coalesce(sum(${timeEntries.durationSeconds}), 0)`;
+
+      const rows = await context.db
+        .select({
+          taskId: tasks.id,
+          taskCode: tasks.code,
+          taskTitle: tasks.title,
+          storyPoints: tasks.storyPoints,
+          totalSeconds: totalSecondsSql,
+        })
+        .from(tasks)
+        .leftJoin(timeEntries, eq(timeEntries.taskId, tasks.id))
+        .where(
+          and(
+            eq(tasks.initiativeId, input.id),
+            isNotNull(tasks.storyPoints),
+            isNotNull(timeEntries.end),
+          ),
+        )
+        .groupBy(tasks.id, tasks.code, tasks.title, tasks.storyPoints)
+        .orderBy(asc(tasks.storyPoints), desc(totalSecondsSql), asc(tasks.title));
+
+      return rows.map((row) => ({
+        ...row,
+        storyPoints: Number(row.storyPoints),
+        totalSeconds: Number(row.totalSeconds),
+      }));
+    }),
+  create: protectedProcedure
+    .use(permissionMiddleware({ initiative: ["create"] }))
+    .input(createInitiativeSchema)
+    .handler(async ({ context, input }) => {
+      const [result] = await context.db.insert(initiatives).values(input).returning();
+
+      if (!result) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Initiative kon niet worden aangemaakt",
+        });
+      }
+
+      return result;
+    }),
+  update: protectedProcedure
+    .use(permissionMiddleware({ initiative: ["update"] }))
+    .input(z.object({ id: z.string(), data: updateInitiativeSchema.partial() }))
+    .handler(async ({ context, input }) => {
+      const [result] = await context.db
+        .update(initiatives)
+        .set(input.data)
+        .where(eq(initiatives.id, input.id))
+        .returning();
+
+      if (!result) {
+        throw new ORPCError("NOT_FOUND", {
+          message: "Initiative kon niet worden gewijzigd",
+        });
+      }
+    }),
+  setStatus: protectedProcedure
+    .use(permissionMiddleware({ initiative: ["update"] }))
+    .input(bulkActionSchema.extend({ status: initiativeStatusSchema }))
+    .handler(async ({ context, input }) => {
+      await context.db
+        .update(initiatives)
+        .set({ status: input.status })
+        .where(inArray(initiatives.id, input.ids))
+        .returning();
+    }),
+  delete: protectedProcedure
+    .use(permissionMiddleware({ initiative: ["delete"] }))
+    .input(bulkActionSchema)
+    .handler(async ({ context, input }) => {
+      const result = await context.db
+        .delete(initiatives)
+        .where(inArray(initiatives.id, input.ids))
+        .returning();
+      return result;
+    }),
+};

package/dist/templates/code/src/app/admin/initiatives/_lib/schema.ts

@@ -0,0 +1,38 @@
+import { relations } from "drizzle-orm";
+import { pgEnum, pgTable } from "drizzle-orm/pg-core";
+import { projects } from "@/app/admin/projects/_lib/schema";
+import { baseColumns } from "@/server/db/helpers";
+
+export const initiativeStatusEnum = pgEnum("initiative_status_enum", [
+  "active",
+  "planned",
+  "completed",
+  "canceled",
+]);
+
+/**
+ * Initiative table
+ */
+export const initiatives = pgTable("initiatives", (t) => ({
+  ...baseColumns,
+  title: t.varchar().notNull(),
+  status: initiativeStatusEnum().default("planned").notNull(),
+  budget: t.numeric({ precision: 12, scale: 2 }),
+  startDate: t.date(),
+  endDate: t.date(),
+  deadline: t.date(),
+  projectId: t
+    .uuid()
+    .notNull()
+    .references(() => projects.id, { onDelete: "cascade" }),
+}));
+
+/**
+ * Relations
+ */
+export const initiativesRelations = relations(initiatives, ({ one }) => ({
+  project: one(projects, {
+    fields: [initiatives.projectId],
+    references: [projects.id],
+  }),
+}));

package/dist/templates/code/src/app/admin/initiatives/_lib/validators.ts

@@ -0,0 +1,38 @@
+import { resolveFiltersSchema } from "@tulip-systems/query";
+import { createInsertSchema, createUpdateSchema } from "drizzle-zod";
+import { z } from "zod";
+import { initiativesFilters } from "../_config/filters";
+import { initiativeStatusEnum, initiatives } from "./schema";
+
+/**
+ * Contact type
+ */
+export type Initiative = typeof initiatives.$inferSelect;
+
+/**
+ * Task status
+ */
+export const initiativeStatusSchema = z.enum(initiativeStatusEnum.enumValues);
+export type InitiativeStatus = z.infer<typeof initiativeStatusSchema>;
+
+/**
+ * Schema
+ */
+export const createInitiativeSchema = createInsertSchema(initiatives);
+export const updateInitiativeSchema = createUpdateSchema(initiatives);
+
+/**
+ * Create initiative schema
+ */
+export type CreateInitiativeInput = z.input<typeof createInitiativeSchema>;
+export type CreateInitiativeSchema = z.infer<typeof createInitiativeSchema>;
+
+export type UpdateInitiativeInput = z.input<typeof updateInitiativeSchema>;
+export type UpdateInitiativeSchema = z.infer<typeof updateInitiativeSchema>;
+
+/**
+ * initiative where input
+ */
+export const initiativeFiltersSchema = resolveFiltersSchema(initiativesFilters);
+
+export type InitiativeFilters = z.input<typeof initiativeFiltersSchema>;

package/dist/templates/code/src/app/admin/layout.tsx

@@ -0,0 +1,28 @@
+import { AgentContextProvider } from "@tulip-systems/ai/context/client";
+import { AdminContent } from "@tulip-systems/app/components/client";
+import { AdminLayout } from "@tulip-systems/app/components/server";
+import { AuthProvider } from "@tulip-systems/auth/client";
+import { AuthGuard } from "@tulip-systems/auth/next/guards";
+import { Suspense } from "react";
+import { AdminSidebar } from "@/lib/config/paths";
+import { AdminAssistantSidepanel } from "@/lib/config/sidepanel";
+import { authClient } from "@/server/auth/client";
+import { auth } from "@/server/auth/init";
+
+export default function Layout(props: LayoutProps<"/admin">) {
+  return (
+    <Suspense>
+      <AuthGuard auth={auth}>
+        <AuthProvider authClient={authClient}>
+          <AgentContextProvider>
+            <AdminLayout>
+              <AdminSidebar />
+              <AdminContent>{props.children}</AdminContent>
+              <AdminAssistantSidepanel />
+            </AdminLayout>
+          </AgentContextProvider>
+        </AuthProvider>
+      </AuthGuard>
+    </Suspense>
+  );
+}

package/dist/templates/code/src/app/admin/not-found.tsx

@@ -0,0 +1,3 @@
+import { AdminNotFoundPage } from "@tulip-systems/app/components";
+
+export default AdminNotFoundPage;

package/dist/templates/code/src/app/admin/projects/(list)/(default)/page.tsx

@@ -0,0 +1,30 @@
+import { Allowed } from "@tulip-systems/auth/permissions/client";
+import { DataTable } from "@tulip-systems/data-tables/client";
+import { ProjectPaginationTableProvider } from "../../_components/tables";
+import { ProjectTableToolbar } from "../../_components/toolbars";
+import { projectColumns } from "../../_config/columns-data";
+import {
+  projectArchiveCommand,
+  projectDeleteCommand,
+  projectRestoreCommand,
+  projectUpdateStatusCommand,
+} from "../../_config/commands";
+
+export default async function Page() {
+  return (
+    <Allowed permission={{ project: ["view"] }}>
+      <ProjectPaginationTableProvider
+        columns={projectColumns}
+        commands={[
+          projectUpdateStatusCommand,
+          projectRestoreCommand,
+          projectArchiveCommand,
+          projectDeleteCommand,
+        ]}
+      >
+        <ProjectTableToolbar />
+        <DataTable />
+      </ProjectPaginationTableProvider>
+    </Allowed>
+  );
+}

package/dist/templates/code/src/app/admin/projects/(list)/active/page.tsx

@@ -0,0 +1,32 @@
+import { Allowed } from "@tulip-systems/auth/permissions/client";
+import { DataTable } from "@tulip-systems/data-tables/client";
+import { ProjectPaginationTableProvider } from "../../_components/tables";
+import { ProjectTableToolbar } from "../../_components/toolbars";
+import { projectColumns } from "../../_config/columns-data";
+import {
+  projectArchiveCommand,
+  projectDeleteCommand,
+  projectRestoreCommand,
+  projectUpdateStatusCommand,
+} from "../../_config/commands";
+
+export default async function ProjectListPage() {
+  return (
+    <Allowed permission={{ project: ["view"] }}>
+      <ProjectPaginationTableProvider
+        columns={projectColumns}
+        commands={[
+          projectUpdateStatusCommand,
+          projectRestoreCommand,
+          projectArchiveCommand,
+          projectDeleteCommand,
+        ]}
+        filterOptions={{ constraints: { status: ["active"] } }}
+        columnVisibility={{ status: false }}
+      >
+        <ProjectTableToolbar />
+        <DataTable />
+      </ProjectPaginationTableProvider>
+    </Allowed>
+  );
+}

package/dist/templates/code/src/app/admin/projects/(list)/archive/page.tsx

@@ -0,0 +1,29 @@
+import { Allowed } from "@tulip-systems/auth/permissions/client";
+import { DataTable } from "@tulip-systems/data-tables/client";
+import { ProjectPaginationTableProvider } from "../../_components/tables";
+import { projectColumns } from "../../_config/columns-data";
+import {
+  projectArchiveCommand,
+  projectDeleteCommand,
+  projectRestoreCommand,
+  projectUpdateStatusCommand,
+} from "../../_config/commands";
+
+export default async function ProjectListPage() {
+  return (
+    <Allowed permission={{ project: ["view"] }}>
+      <ProjectPaginationTableProvider
+        columns={projectColumns}
+        commands={[
+          projectUpdateStatusCommand,
+          projectRestoreCommand,
+          projectArchiveCommand,
+          projectDeleteCommand,
+        ]}
+        filterOptions={{ constraints: { isDeleted: true } }}
+      >
+        <DataTable />
+      </ProjectPaginationTableProvider>
+    </Allowed>
+  );
+}

package/dist/templates/code/src/app/admin/projects/(list)/backlog/page.tsx

@@ -0,0 +1,32 @@
+import { Allowed } from "@tulip-systems/auth/permissions/client";
+import { DataTable } from "@tulip-systems/data-tables/client";
+import { ProjectPaginationTableProvider } from "../../_components/tables";
+import { ProjectTableToolbar } from "../../_components/toolbars";
+import { projectColumns } from "../../_config/columns-data";
+import {
+  projectArchiveCommand,
+  projectDeleteCommand,
+  projectRestoreCommand,
+  projectUpdateStatusCommand,
+} from "../../_config/commands";
+
+export default async function ProjectListPage() {
+  return (
+    <Allowed permission={{ project: ["view"] }}>
+      <ProjectPaginationTableProvider
+        columns={projectColumns}
+        commands={[
+          projectUpdateStatusCommand,
+          projectRestoreCommand,
+          projectArchiveCommand,
+          projectDeleteCommand,
+        ]}
+        filterOptions={{ constraints: { status: ["backlog"] } }}
+        columnVisibility={{ status: false }}
+      >
+        <ProjectTableToolbar />
+        <DataTable />
+      </ProjectPaginationTableProvider>
+    </Allowed>
+  );
+}

package/dist/templates/code/src/app/admin/projects/(list)/canceled/page.tsx

@@ -0,0 +1,32 @@
+import { Allowed } from "@tulip-systems/auth/permissions/client";
+import { DataTable } from "@tulip-systems/data-tables/client";
+import { ProjectPaginationTableProvider } from "../../_components/tables";
+import { ProjectTableToolbar } from "../../_components/toolbars";
+import { projectColumns } from "../../_config/columns-data";
+import {
+  projectArchiveCommand,
+  projectDeleteCommand,
+  projectRestoreCommand,
+  projectUpdateStatusCommand,
+} from "../../_config/commands";
+
+export default async function ProjectListPage() {
+  return (
+    <Allowed permission={{ project: ["view"] }}>
+      <ProjectPaginationTableProvider
+        columns={projectColumns}
+        commands={[
+          projectUpdateStatusCommand,
+          projectRestoreCommand,
+          projectArchiveCommand,
+          projectDeleteCommand,
+        ]}
+        filterOptions={{ constraints: { status: ["canceled"] } }}
+        columnVisibility={{ status: false }}
+      >
+        <ProjectTableToolbar />
+        <DataTable />
+      </ProjectPaginationTableProvider>
+    </Allowed>
+  );
+}

package/dist/templates/code/src/app/admin/projects/(list)/completed/page.tsx

@@ -0,0 +1,32 @@
+import { Allowed } from "@tulip-systems/auth/permissions/client";
+import { DataTable } from "@tulip-systems/data-tables/client";
+import { ProjectPaginationTableProvider } from "../../_components/tables";
+import { ProjectTableToolbar } from "../../_components/toolbars";
+import { projectColumns } from "../../_config/columns-data";
+import {
+  projectArchiveCommand,
+  projectDeleteCommand,
+  projectRestoreCommand,
+  projectUpdateStatusCommand,
+} from "../../_config/commands";
+
+export default async function ProjectListPage() {
+  return (
+    <Allowed permission={{ project: ["view"] }}>
+      <ProjectPaginationTableProvider
+        columns={projectColumns}
+        commands={[
+          projectUpdateStatusCommand,
+          projectRestoreCommand,
+          projectArchiveCommand,
+          projectDeleteCommand,
+        ]}
+        filterOptions={{ constraints: { status: ["completed"] } }}
+        columnVisibility={{ status: false }}
+      >
+        <ProjectTableToolbar />
+        <DataTable />
+      </ProjectPaginationTableProvider>
+    </Allowed>
+  );
+}