@tulip-systems/create-app 0.11.1

package/dist/templates/spark/src/app/admin/executions/_lib/router.ts

@@ -0,0 +1,343 @@
+import "server-cli-only";
+
+import { ORPCError } from "@orpc/server";
+import {
+  bulkActionSchema,
+  offsetPaginationResponse,
+  offsetPaginationSchema,
+} from "@tulip-systems/query";
+import { and, count, eq, exists, gte, inArray, sql } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import z from "zod";
+import { getTableData } from "@/lib/helpers/table-data.server";
+import { assignments, registrations } from "@/server/db/schema";
+import type { DatabaseSchema } from "@/server/db/types";
+import { permissionMiddleware } from "@/server/router/middleware";
+import { protectedProcedure } from "@/server/router/procedures";
+import type { RegistrationTableData } from "../../registrations/_components/tables";
+import {
+  registrationTableDatabaseSortsCompiler,
+  registrationTableSortsParser,
+  registrationTableSortsSchema,
+} from "../../registrations/_config/sorting";
+import { mergeDateWithTime } from "../../registrations/_lib/helpers";
+import { createRegistrationSchema } from "../../registrations/_lib/validators";
+import type { ExecutionTableData } from "../_components/tables";
+import {
+  executionDatabaseFiltersCompiler,
+  executionFiltersParser,
+  executionFiltersSchema,
+  executionRegistrationDatabaseFiltersCompiler,
+  executionRegistrationFiltersParser,
+  executionsRegistrationsFiltersSchema,
+} from "../_config/filters";
+import {
+  executionTableDatabaseSortsCompiler,
+  executionTableSortsParser,
+  executionTableSortsSchema,
+} from "../_config/sorting";
+import { executions, executionsRegistrations } from "./schema";
+import { createExecutionSchema, executionStatusSchema, updateExecutionSchema } from "./validators";
+
+function parseExecutionFilters(context: { db: NodePgDatabase<DatabaseSchema> }) {
+  return executionDatabaseFiltersCompiler({
+    title: executions.title,
+    description: executions.description,
+    assignmentId: executions.assignmentId,
+    status: executions.status,
+    scheduledAt: executions.scheduledAt,
+    employeeId: ({ value }) => {
+      if (!Array.isArray(value) || value.length === 0) return undefined;
+
+      return exists(
+        context.db
+          .select({ one: sql`1` })
+          .from(executionsRegistrations)
+          .innerJoin(registrations, eq(registrations.id, executionsRegistrations.registrationId))
+          .where(
+            and(
+              eq(executionsRegistrations.executionId, executions.id),
+              inArray(registrations.employeeId, value as string[]),
+            ),
+          ),
+      );
+    },
+  });
+}
+
+export const executionsRouter = {
+  list: protectedProcedure
+    .use(permissionMiddleware({ execution: ["view"] }))
+    .input(
+      z.object({
+        pagination: offsetPaginationSchema,
+        filters: executionFiltersSchema,
+        sorts: executionTableSortsSchema,
+      }),
+    )
+    .handler(async ({ context, input }) => {
+      const parsedSorts = executionTableSortsParser.parse(input.sorts);
+      const orderBy = executionTableDatabaseSortsCompiler(executions).parse(parsedSorts);
+
+      const parsedFilters = executionFiltersParser.parse(input.filters);
+      const where = parseExecutionFilters(context).parse(parsedFilters);
+
+      const { data, total } = await getTableData(context, executions, {
+        pagination: input.pagination,
+        where,
+        orderBy,
+        with: {
+          assignment: { with: { client: true } },
+          executionsRegistrations: { with: { registration: true } },
+        },
+      });
+
+      return offsetPaginationResponse({
+        data: data as ExecutionTableData[],
+        pagination: input.pagination,
+        total,
+      });
+    }),
+  filterAssignments: protectedProcedure
+    .use(permissionMiddleware({ execution: ["view"] }))
+    .input(z.object({ filters: executionFiltersSchema }))
+    .handler(async ({ context, input: { filters } }) => {
+      const parsedFilters = executionFiltersParser
+        .omit({ assignmentId: true, employeeId: true, scheduledAt: true })
+        .parse(filters);
+      const where = executionDatabaseFiltersCompiler(executions).parse(parsedFilters);
+
+      return context.db
+        .select({
+          value: assignments.id,
+          label: assignments.title,
+          total: count(executions.id),
+        })
+        .from(assignments)
+        .leftJoin(executions, and(eq(assignments.id, executions.assignmentId), where))
+        .where(eq(assignments.isDeleted, false))
+        .groupBy(assignments.id)
+        .having(gte(sql<number>`count(${executions.id})`, 1))
+        .orderBy(assignments.title);
+    }),
+  getById: protectedProcedure
+    .use(permissionMiddleware({ execution: ["view"] }))
+    .input(z.object({ id: z.string() }))
+    .handler(async ({ context, input }) => {
+      const data = await context.db.query.executions.findFirst({
+        where: eq(executions.id, input.id),
+        with: {
+          assignment: { with: { client: true } },
+          executionsRegistrations: { with: { registration: true } },
+        },
+      });
+
+      return data ?? null;
+    }),
+  getAll: protectedProcedure
+    .use(permissionMiddleware({ execution: ["view"] }))
+    .input(z.object({ filters: executionFiltersSchema }))
+    .handler(async ({ context, input: { filters } }) => {
+      const parsedFilters = executionFiltersParser.parse(filters);
+      const data = await context.db.query.executions.findMany({
+        where: parseExecutionFilters(context).parse(parsedFilters),
+        with: {
+          assignment: { with: { client: true } },
+          executionsRegistrations: { with: { registration: true } },
+        },
+      });
+
+      return data;
+    }),
+  create: protectedProcedure
+    .use(permissionMiddleware({ execution: ["create"] }))
+    .input(createExecutionSchema)
+    .handler(async ({ context, input: { employeeIds, startTime, stopTime, ...values } }) => {
+      /**
+       * Create execution
+       */
+      const [result] = await context.db.insert(executions).values(values).returning();
+
+      if (!result) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Execution kon niet worden aangemaakt",
+        });
+      }
+
+      /**
+       * Create registrations
+       * */
+      const registrationsValues = employeeIds?.map((employeeId) => ({
+        startTime: new Date(`${result.scheduledAt}T${startTime}`),
+        stopTime: new Date(`${result.scheduledAt}T${stopTime}`),
+        employeeId,
+      }));
+
+      const registrationResults = await context.db
+        .insert(registrations)
+        .values(registrationsValues)
+        .returning();
+
+      /**
+       * Create executionRegistrations
+       */
+      const executionsRegistrationsValues = registrationResults.map((registration) => ({
+        executionId: result.id,
+        registrationId: registration.id,
+      }));
+
+      await context.db
+        .insert(executionsRegistrations)
+        .values(executionsRegistrationsValues)
+        .returning();
+    }),
+  update: protectedProcedure
+    .use(permissionMiddleware({ execution: ["update"] }))
+    .input(z.object({ id: z.string(), data: updateExecutionSchema.partial() }))
+    .output(z.void())
+    .handler(async ({ context, input }) => {
+      const [result] = await context.db
+        .update(executions)
+        .set(input.data)
+        .where(eq(executions.id, input.id))
+        .returning();
+
+      if (!result) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Execution kon niet worden aangemaakt",
+        });
+      }
+    }),
+  setDate: protectedProcedure
+    .use(permissionMiddleware({ execution: ["update"] }))
+    .input(bulkActionSchema.extend({ scheduledAt: z.string() }))
+    .handler(async ({ context, input }) => {
+      await context.db.transaction(async (tx) => {
+        const [execution] = await tx
+          .update(executions)
+          .set({ scheduledAt: input.scheduledAt })
+          .where(inArray(executions.id, input.ids))
+          .returning();
+
+        if (!execution) {
+          throw new ORPCError("NOT_FOUND", {
+            message: "Execution kon niet worden gewijzigd",
+          });
+        }
+
+        const executionsRegistrationItems = await tx.query.executionsRegistrations.findMany({
+          where: eq(executionsRegistrations.executionId, execution.id),
+          with: { registration: true },
+        });
+
+        await Promise.all(
+          executionsRegistrationItems.map(async ({ registration }) => {
+            await tx
+              .update(registrations)
+              .set({
+                startTime: mergeDateWithTime(new Date(input.scheduledAt), registration.startTime),
+                stopTime: mergeDateWithTime(new Date(input.scheduledAt), registration.stopTime),
+              })
+              .where(eq(registrations.id, registration.id));
+          }),
+        );
+      });
+    }),
+  setStatus: protectedProcedure
+    .use(permissionMiddleware({ execution: ["setStatus"] }))
+    .input(bulkActionSchema.extend({ status: executionStatusSchema }))
+    .handler(async ({ context, input }) => {
+      await context.db
+        .update(executions)
+        .set({ status: input.status })
+        .where(inArray(executions.id, input.ids))
+        .returning();
+    }),
+  delete: protectedProcedure
+    .use(permissionMiddleware({ execution: ["delete"] }))
+    .input(bulkActionSchema)
+    .handler(async ({ context, input }) => {
+      await context.db.delete(executions).where(inArray(executions.id, input.ids));
+    }),
+  listRegistrations: protectedProcedure
+    .use(permissionMiddleware({ execution: ["view"] }))
+    .input(
+      z.object({
+        pagination: offsetPaginationSchema,
+        filters: executionsRegistrationsFiltersSchema,
+        sorts: registrationTableSortsSchema,
+      }),
+    )
+    .handler(async ({ context, input }) => {
+      const parsedSorts = registrationTableSortsParser.parse(input.sorts);
+      const orderBy = registrationTableDatabaseSortsCompiler(registrations).parse(parsedSorts);
+
+      const parsedFilters = executionRegistrationFiltersParser.parse(input.filters);
+      const where =
+        executionRegistrationDatabaseFiltersCompiler(executionsRegistrations).parse(parsedFilters);
+
+      const filteredExecutionsRegistrations = await context.db
+        .select()
+        .from(executionsRegistrations)
+        .where(where);
+
+      const registrationIds = filteredExecutionsRegistrations.flatMap(
+        ({ registrationId }) => registrationId,
+      );
+
+      const { data, total } = await getTableData(context, registrations, {
+        pagination: input.pagination,
+        where: inArray(registrations.id, registrationIds),
+        orderBy,
+        with: { employee: { with: { user: true } } },
+      });
+
+      return offsetPaginationResponse({
+        data: data as RegistrationTableData[],
+        pagination: input.pagination,
+        total,
+      });
+    }),
+  createRegistration: protectedProcedure
+    .use(permissionMiddleware({ execution: ["update"] }))
+    .input(createRegistrationSchema.extend({ executionId: z.string() }))
+    .handler(async ({ context, input: { executionId, employeeIds, ...input } }) => {
+      const execution = await context.db.query.executions.findFirst({
+        where: eq(executions.id, executionId),
+      });
+
+      if (!execution) {
+        throw new ORPCError("NOT_FOUND", {
+          message: "Execution kon niet worden gevonden",
+        });
+      }
+
+      /**
+       * Create registrations
+       * */
+      const registrationsValues = employeeIds.map((id) => ({
+        ...input,
+        startTime: new Date(`${execution.scheduledAt}T${input.startTime}`),
+        stopTime: new Date(`${execution.scheduledAt}T${input.stopTime}`),
+        employeeId: id,
+      }));
+
+      const registrationResults = await context.db
+        .insert(registrations)
+        .values(registrationsValues)
+        .returning();
+
+      /**
+       * Create executionRegistrations
+       */
+      const executionsRegistrationsValues = registrationResults.map((registration) => ({
+        executionId,
+        registrationId: registration.id,
+      }));
+
+      await context.db
+        .insert(executionsRegistrations)
+        .values(executionsRegistrationsValues)
+        .returning();
+    }),
+};

package/dist/templates/spark/src/app/admin/executions/_lib/schema.ts

@@ -0,0 +1,62 @@
+import { relations } from "drizzle-orm";
+import { pgEnum, pgTable } from "drizzle-orm/pg-core";
+import { assignments } from "@/app/admin/assignments/_lib/schema";
+import { baseColumns } from "@/server/db/helpers";
+import { registrations } from "@/server/db/schema";
+
+export const executionStatusEnum = pgEnum("execution_status_enum", ["scheduled", "finished"]);
+
+/**
+ * Execution table
+ */
+export const executions = pgTable("executions", (t) => ({
+  ...baseColumns,
+  title: t.varchar().notNull(),
+  scheduledAt: t.date().notNull(),
+  status: executionStatusEnum().default("scheduled").notNull(),
+  description: t.jsonb(),
+  assignmentId: t
+    .uuid()
+    .notNull()
+    .references(() => assignments.id, { onDelete: "cascade" }),
+}));
+
+/**
+ * Relations
+ */
+export const executionsRelations = relations(executions, ({ one, many }) => ({
+  assignment: one(assignments, {
+    fields: [executions.assignmentId],
+    references: [assignments.id],
+  }),
+  executionsRegistrations: many(executionsRegistrations),
+}));
+
+/**
+ * Execution Registration table
+ */
+export const executionsRegistrations = pgTable("executions_registrations", (t) => ({
+  ...baseColumns,
+  executionId: t
+    .uuid()
+    .notNull()
+    .references(() => executions.id, { onDelete: "cascade" }),
+  registrationId: t
+    .uuid()
+    .notNull()
+    .references(() => registrations.id, { onDelete: "cascade" }),
+}));
+
+/**
+ * Relations
+ */
+export const executionsRegistrationsRelations = relations(executionsRegistrations, ({ one }) => ({
+  execution: one(executions, {
+    fields: [executionsRegistrations.executionId],
+    references: [executions.id],
+  }),
+  registration: one(registrations, {
+    fields: [executionsRegistrations.registrationId],
+    references: [registrations.id],
+  }),
+}));

package/dist/templates/spark/src/app/admin/executions/_lib/validators.ts

@@ -0,0 +1,63 @@
+import { createInsertSchema, createSelectSchema } from "drizzle-zod";
+import { z } from "zod";
+
+export type {
+  ExecutionFiltersSchema,
+  ExecutionsRegistrationsFiltersSchema,
+} from "../_config/filters";
+export {
+  executionFiltersSchema,
+  executionsRegistrationsFiltersSchema,
+} from "../_config/filters";
+
+import { executionStatusEnum, executions, executionsRegistrations } from "./schema";
+
+/**
+ * Execution type
+ */
+export type Execution = typeof executions.$inferSelect;
+
+export type ExecutionRegistration = typeof executionsRegistrations.$inferSelect;
+
+export const selectExecutionSchema = createSelectSchema(executions);
+export type SelectExecutionSchema = z.infer<typeof selectExecutionSchema>;
+
+export const selectExecutionRegistrationSchema = createSelectSchema(executionsRegistrations);
+export type SelectExecutionRegistrationSchema = z.infer<typeof selectExecutionRegistrationSchema>;
+
+/**
+ * Execution status
+ */
+export const executionStatusSchema = z.enum(executionStatusEnum.enumValues);
+export type ExecutionStatus = z.infer<typeof executionStatusSchema>;
+
+/**
+ * Schema
+ */
+/**
+ * Create execution input validation
+ */
+export const createExecutionSchema = z.object({
+  title: z
+    .string({ error: "Titel is niet geldig" })
+    .min(3, "Titel moet minimaal 3 tekens bevatten")
+    .max(50, "Titel mag maximaal 50 tekens bevatten"),
+  scheduledAt: z.string({ error: "Datum is niet geldig" }).regex(/^\d{4}-\d{2}-\d{2}$/),
+  startTime: z.string({ error: "Starttijd is niet geldig" }),
+  stopTime: z.string({ error: "Stoptijd is niet geldig" }),
+  employeeIds: z
+    .array(z.string(), { error: "Medewerkers zijn niet geldig" })
+    .min(1, "Medewerkers zijn verplicht"),
+  assignmentId: z.string({ error: "Project is niet geldig" }),
+});
+
+export const updateExecutionSchema = createInsertSchema(executions);
+
+/**
+ * Create project schema
+ */
+export type CreateExecutionInput = z.input<typeof createExecutionSchema>;
+export type CreateExecutionSchema = z.infer<typeof createExecutionSchema>;
+
+export type UpdateExecutionInput = z.input<typeof updateExecutionSchema>;
+export type UpdateExecutionSchema = z.infer<typeof updateExecutionSchema>;

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

@@ -0,0 +1,21 @@
+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 type { PropsWithChildren } from "react";
+import { AdminSidebar } from "@/lib/config/paths";
+import { authClient } from "@/server/auth/client";
+import { auth } from "@/server/auth/init";
+
+export default async function Layout(props: PropsWithChildren) {
+  return (
+    <AuthGuard auth={auth}>
+      <AuthProvider authClient={authClient}>
+        <AdminLayout>
+          <AdminSidebar />
+          <AdminContent>{props.children}</AdminContent>
+        </AdminLayout>
+      </AuthProvider>
+    </AuthGuard>
+  );
+}

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

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

package/dist/templates/spark/src/app/admin/products/(list)/(default)/loading.tsx

@@ -0,0 +1,5 @@
+import { TableSkeleton } from "@tulip-systems/data-tables";
+
+export default function Loading() {
+  return <TableSkeleton />;
+}

package/dist/templates/spark/src/app/admin/products/(list)/(default)/page.tsx

@@ -0,0 +1,32 @@
+import { Allowed } from "@tulip-systems/auth/permissions/client";
+import { DataTable } from "@tulip-systems/data-tables/client";
+import { ProductPaginationTableProvider } from "../../_components/tables";
+import { ProductTableToolbar } from "../../_components/toolbars";
+import { productColumns } from "../../_config/columns-data";
+import {
+  productAddToFavoritesCommand,
+  productArchiveCommand,
+  productDeleteCommand,
+  productRemoveFromFavoritesCommand,
+  productRestoreCommand,
+} from "../../_config/commands";
+
+export default function Page() {
+  return (
+    <Allowed permission={{ product: ["view"] }}>
+      <ProductPaginationTableProvider
+        columns={productColumns}
+        commands={[
+          productAddToFavoritesCommand,
+          productRemoveFromFavoritesCommand,
+          productArchiveCommand,
+          productRestoreCommand,
+          productDeleteCommand,
+        ]}
+      >
+        <ProductTableToolbar />
+        <DataTable />
+      </ProductPaginationTableProvider>
+    </Allowed>
+  );
+}

package/dist/templates/spark/src/app/admin/products/(list)/archive/loading.tsx

@@ -0,0 +1,5 @@
+import { TableSkeleton } from "@tulip-systems/data-tables";
+
+export default function Loading() {
+  return <TableSkeleton />;
+}

package/dist/templates/spark/src/app/admin/products/(list)/archive/page.tsx

@@ -0,0 +1,31 @@
+import { Allowed } from "@tulip-systems/auth/permissions/client";
+import { DataTable } from "@tulip-systems/data-tables/client";
+import { ProductPaginationTableProvider } from "../../_components/tables";
+import { productColumns } from "../../_config/columns-data";
+import {
+  productAddToFavoritesCommand,
+  productArchiveCommand,
+  productDeleteCommand,
+  productRemoveFromFavoritesCommand,
+  productRestoreCommand,
+} from "../../_config/commands";
+
+export default function Page() {
+  return (
+    <Allowed permission={{ product: ["view"] }}>
+      <ProductPaginationTableProvider
+        columns={productColumns}
+        commands={[
+          productAddToFavoritesCommand,
+          productRemoveFromFavoritesCommand,
+          productArchiveCommand,
+          productRestoreCommand,
+          productDeleteCommand,
+        ]}
+        filterOptions={{ constraints: { isDeleted: true } }}
+      >
+        <DataTable />
+      </ProductPaginationTableProvider>
+    </Allowed>
+  );
+}

package/dist/templates/spark/src/app/admin/products/(list)/favorites/loading.tsx

@@ -0,0 +1,5 @@
+import { TableSkeleton } from "@tulip-systems/data-tables";
+
+export default function Loading() {
+  return <TableSkeleton />;
+}

package/dist/templates/spark/src/app/admin/products/(list)/favorites/page.tsx

@@ -0,0 +1,33 @@
+import { Allowed } from "@tulip-systems/auth/permissions/client";
+import { DataTable } from "@tulip-systems/data-tables/client";
+import { ProductPaginationTableProvider } from "../../_components/tables";
+import { ProductTableToolbar } from "../../_components/toolbars";
+import { productColumns } from "../../_config/columns-data";
+import {
+  productAddToFavoritesCommand,
+  productArchiveCommand,
+  productDeleteCommand,
+  productRemoveFromFavoritesCommand,
+  productRestoreCommand,
+} from "../../_config/commands";
+
+export default function Page() {
+  return (
+    <Allowed permission={{ product: ["view"] }}>
+      <ProductPaginationTableProvider
+        columns={productColumns}
+        commands={[
+          productAddToFavoritesCommand,
+          productRemoveFromFavoritesCommand,
+          productArchiveCommand,
+          productRestoreCommand,
+          productDeleteCommand,
+        ]}
+        filterOptions={{ constraints: { isFavorite: true } }}
+      >
+        <ProductTableToolbar />
+        <DataTable />
+      </ProductPaginationTableProvider>
+    </Allowed>
+  );
+}

package/dist/templates/spark/src/app/admin/products/(list)/layout.tsx

@@ -0,0 +1,59 @@
+import {
+  BottomBar,
+  BottomBarLinks,
+  Header,
+  Topbar,
+  TopbarTitle,
+  TopbarTools,
+} from "@tulip-systems/app/components/client";
+import { InlineCommandMenu, InlineCommandMenuLoading } from "@tulip-systems/commands/client";
+import { TableLayout } from "@tulip-systems/data-tables";
+import { type PropsWithChildren, Suspense } from "react";
+import { productCreateCommand } from "../_config/commands";
+
+export default function ProductListLayout({ children }: PropsWithChildren) {
+  return (
+    <>
+      <Header>
+        <Topbar>
+          <TopbarTitle breadcrumbs={[{ label: "Producten" }]} />
+
+          <TopbarTools>
+            <Suspense fallback={<InlineCommandMenuLoading />}>
+              <InlineCommandMenu data={null} commands={[productCreateCommand]} />
+            </Suspense>
+          </TopbarTools>
+        </Topbar>
+
+        <BottomBar>
+          <BottomBarLinks
+            paths={[
+              {
+                name: "Overzicht",
+                href: "/admin/products",
+                segment: "(default)",
+              },
+              {
+                name: "Favorieten",
+                href: "/admin/products/favorites",
+                segment: "favorites",
+              },
+            ]}
+          />
+
+          <BottomBarLinks
+            paths={[
+              {
+                name: "Archief",
+                href: "/admin/products/archive",
+                segment: "archive",
+              },
+            ]}
+          />
+        </BottomBar>
+      </Header>
+
+      <TableLayout className="p-content">{children}</TableLayout>
+    </>
+  );
+}

package/dist/templates/spark/src/app/admin/products/(list)/loading.tsx

@@ -0,0 +1,5 @@
+import { TableSkeleton } from "@tulip-systems/data-tables";
+
+export default function Loading() {
+  return <TableSkeleton />;
+}