@tulip-systems/create-app 0.11.1

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

@@ -0,0 +1,48 @@
+import { createInsertSchema, createSelectSchema } from "drizzle-zod";
+import { z } from "zod";
+
+export type { RegistrationFiltersSchema } from "../_config/filters";
+export { registrationFiltersSchema } from "../_config/filters";
+
+import { registrations } from "./schema";
+
+/**
+ * Registration type
+ */
+export type Registration = typeof registrations.$inferSelect;
+
+export const selectRegistrationSchema = createSelectSchema(registrations);
+export type SelectRegistrationSchema = z.infer<typeof selectRegistrationSchema>;
+
+/**
+ * Schema
+ */
+export const createRegistrationSchema = createInsertSchema(registrations)
+  .omit({ employeeId: true, startTime: true, stopTime: true })
+  .extend({
+    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"),
+  });
+
+export const updateRegistrationSchema = createInsertSchema(registrations);
+
+/**
+ * Create project schema
+ */
+export type CreateRegistrationInput = z.input<typeof createRegistrationSchema>;
+export type CreateRegistrationSchema = z.infer<typeof createRegistrationSchema>;
+
+export type UpdateRegistrationInput = z.input<typeof updateRegistrationSchema>;
+export type UpdateRegistrationSchema = z.infer<typeof updateRegistrationSchema>;
+
+/**
+ * Create inline registration schema
+ */
+export const createInlineRegistrationSchema = createInsertSchema(registrations)
+  .omit({ id: true })
+  .extend({ id: z.string() });
+
+export type CreateInlineRegistrationSchema = z.infer<typeof createInlineRegistrationSchema>;

package/dist/templates/spark/src/app/admin/run-tasks/_components/tables.tsx

@@ -0,0 +1,156 @@
+"use client";
+import { useSuspenseInfiniteQuery, useSuspenseQuery } from "@tanstack/react-query";
+import type { VisibilityState } from "@tanstack/react-table";
+import type { CommandFor } from "@tulip-systems/commands";
+import type { TableColumnDef } from "@tulip-systems/data-tables";
+import {
+  createTableConfig,
+  TableConfigProvider,
+  useInfiniteStrategy,
+  usePaginationStrategy,
+} from "@tulip-systems/data-tables/client";
+import { offsetPagination } from "@tulip-systems/query";
+import {
+  type UseFiltersOptions,
+  useFilters,
+  usePagination,
+  useSorting,
+} from "@tulip-systems/query/client";
+import { type PropsWithChildren, useDeferredValue, useMemo } from "react";
+import { orpc } from "@/server/router/client";
+import type { Subproject } from "../../subprojects/_lib/validators";
+import type { Task } from "../../tasks/_lib/validators";
+import { runTasksFilters } from "../_config/filters";
+import { runTaskTableSorts } from "../_config/sorting";
+import type { RunTask } from "../_lib/validators";
+
+export type RunTaskTableData = RunTask & { task: Task & { subproject: Subproject } };
+
+/**
+ * Client data table
+ */
+type RunTaskTableProviderProps = PropsWithChildren<{
+  columns: TableColumnDef<RunTaskTableData>[];
+  commands?: CommandFor<RunTaskTableData[]>[];
+  filterOptions?: UseFiltersOptions<typeof runTasksFilters>;
+  columnVisibility?: VisibilityState;
+}>;
+
+/**
+ * Infinite table
+ */
+export function RunTaskInfiniteTableProvider({
+  columns,
+  commands,
+  filterOptions,
+  columnVisibility,
+  children,
+}: RunTaskTableProviderProps) {
+  const pagination = usePagination(offsetPagination);
+  const filtering = useFilters(runTasksFilters, filterOptions);
+  const sorting = useSorting(runTaskTableSorts);
+
+  const input = useDeferredValue({
+    pagination: pagination.input,
+    filters: filtering.input,
+    sorts: sorting.input,
+  });
+
+  /**
+   * Data
+   */
+  const response = useSuspenseInfiniteQuery(
+    orpc.runTasks.list.infiniteOptions({
+      initialPageParam: 0,
+      input: (page: number | undefined) => ({
+        ...input,
+        pagination: { ...input.pagination, page: page ?? input.pagination.page },
+      }),
+      getNextPageParam: ({ pagination }) => pagination.nextPage,
+      getPreviousPageParam: ({ pagination }) => pagination.previousPage,
+    }),
+  );
+
+  const { total } = response.data.pages.at(-1)?.pagination ?? {};
+
+  /**
+   * Strategy
+   */
+  const strategy = useInfiniteStrategy({
+    pagination,
+    total,
+    fetchNextPage: response.fetchNextPage,
+    isFetching: response.isFetching,
+    isFetchingNextPage: response.isFetchingNextPage,
+  });
+
+  const queryData = useMemo(
+    () => response.data.pages.flatMap(({ data }) => data) ?? [],
+    [response.data],
+  );
+
+  /**
+   * Table
+   */
+  const config = createTableConfig<RunTaskTableData>({
+    queryData,
+    getRowId: (row) => row.id,
+    columns,
+    strategy,
+    filtering,
+    sorting,
+    commands,
+    columnVisibility,
+  });
+
+  return <TableConfigProvider config={config}>{children}</TableConfigProvider>;
+}
+
+/**
+ * Pagination table
+ */
+export function RunTaskPaginationTableProvider({
+  columns,
+  commands,
+  filterOptions,
+  columnVisibility,
+  children,
+}: RunTaskTableProviderProps) {
+  const pagination = usePagination(offsetPagination);
+  const filtering = useFilters(runTasksFilters, filterOptions);
+  const sorting = useSorting(runTaskTableSorts);
+
+  const input = useDeferredValue({
+    pagination: pagination.input,
+    filters: filtering.input,
+    sorts: sorting.input,
+  });
+
+  /**
+   * Data
+   */
+  const response = useSuspenseQuery(orpc.runTasks.list.queryOptions({ input }));
+
+  const queryData = useMemo(() => response.data.data ?? [], [response.data.data]);
+  const { total } = response.data.pagination;
+
+  /**
+   * Strategy
+   */
+  const strategy = usePaginationStrategy({ pagination, total });
+
+  /**
+   * Table
+   */
+  const config = createTableConfig<RunTaskTableData>({
+    queryData,
+    getRowId: (row) => row.id,
+    columns,
+    strategy,
+    sorting,
+    commands,
+    columnVisibility,
+  });
+
+  return <TableConfigProvider config={config}>{children}</TableConfigProvider>;
+}

package/dist/templates/spark/src/app/admin/run-tasks/_components/toolbars.tsx

@@ -0,0 +1,50 @@
+"use client";
+
+import { useSuspenseQuery } from "@tanstack/react-query";
+import { TableToolbar, TableToolbarList } from "@tulip-systems/data-tables";
+import { useTableConfigContext } from "@tulip-systems/data-tables/client";
+import { resolveFilterDescriptors } from "@tulip-systems/query";
+import { FilterCombobox, FilterSearch } from "@tulip-systems/query/client";
+import { type PropsWithChildren, Suspense, useDeferredValue } from "react";
+import { orpc } from "@/server/router/client";
+import { runTasksFilters } from "../_config/filters";
+
+const runTasksFiltersDescriptors = resolveFilterDescriptors(runTasksFilters);
+
+export function RunTaskTableToolbar({ children }: PropsWithChildren) {
+  return (
+    <TableToolbar>
+      <TableToolbarList>
+        <FilterSearch placeholder="Zoeken..." filter={runTasksFiltersDescriptors.search} />
+
+        <Suspense>
+          <RunTaskSubprojectFilter />
+        </Suspense>
+      </TableToolbarList>
+
+      <TableToolbarList>{children}</TableToolbarList>
+    </TableToolbar>
+  );
+}
+
+/**
+ * Run task subproject filter
+ */
+export function RunTaskSubprojectFilter() {
+  const table = useTableConfigContext();
+  const input = useDeferredValue({ filters: table.filtering?.input ?? {} });
+
+  const { data } = useSuspenseQuery(
+    orpc.runTasks.filterSubprojects.queryOptions({
+      input,
+    }),
+  );
+
+  return (
+    <FilterCombobox
+      title="Subprojecten"
+      filter={runTasksFiltersDescriptors.subprojectId}
+      options={data}
+    />
+  );
+}

package/dist/templates/spark/src/app/admin/run-tasks/_config/columns-data.tsx

@@ -0,0 +1,66 @@
+"use client";
+
+import { TableCell, type TableColumnDef, TableColumnHeader } from "@tulip-systems/data-tables";
+import { createTableSelectCell } from "@tulip-systems/data-tables/client";
+import { Editor, EditorContent } from "@tulip-systems/editor/client";
+import Link from "next/link";
+import { TaskStatusField } from "../../tasks/_config/status";
+import type { RunTaskTableData } from "../_components/tables";
+
+export const runTaskTableColumns: TableColumnDef<RunTaskTableData>[] = [
+  createTableSelectCell(),
+  {
+    id: "articleNumber",
+    header: ({ column }) => <TableColumnHeader column={column} title="Artikel" />,
+    accessorFn: (row) => row.task.articleNumber,
+    cell: ({ row }) => <TableCell className="min-w-40">{row.getValue("articleNumber")}</TableCell>,
+    enableSorting: false,
+  },
+  {
+    id: "description",
+    header: ({ column }) => <TableColumnHeader column={column} title="Omschrijving" />,
+    accessorFn: (row) => row.task.description,
+    cell: ({ row }) => (
+      <TableCell className="w-full min-w-80">
+        <Editor value={row.getValue("description")} variant="preview" disabled>
+          <EditorContent />
+        </Editor>
+      </TableCell>
+    ),
+    enableSorting: false,
+  },
+  {
+    accessorKey: "previousStatus",
+    header: ({ column }) => <TableColumnHeader column={column} title="Vorige status" />,
+    cell: ({ row }) => (
+      <TableCell className="min-w-52">
+        <TaskStatusField status={row.getValue("previousStatus")} />
+      </TableCell>
+    ),
+  },
+  {
+    accessorKey: "newStatus",
+    header: ({ column }) => <TableColumnHeader column={column} title="Nieuwe status" />,
+    cell: ({ row }) => (
+      <TableCell className="min-w-52">
+        <TaskStatusField status={row.getValue("newStatus")} />
+      </TableCell>
+    ),
+  },
+  {
+    id: "subprojectTitle",
+    header: ({ column }) => <TableColumnHeader column={column} title="Subproject" />,
+    accessorFn: (row) => row.task.subproject?.title ?? "",
+    cell: ({ row }) => (
+      <TableCell className="w-40" readonly>
+        <Link
+          href={`/admin/subproject/${row.original.task.subprojectId}`}
+          className="hover:underline"
+        >
+          {row.getValue("subprojectTitle")}
+        </Link>
+      </TableCell>
+    ),
+    enableSorting: false,
+  },
+];

package/dist/templates/spark/src/app/admin/run-tasks/_config/commands.tsx

@@ -0,0 +1,42 @@
+"use client";
+
+import { commandBuilder, ensureArray } from "@tulip-systems/commands";
+import { CommandClick, CommandLabel, DeleteCommand } from "@tulip-systems/commands/client";
+import { toast } from "@tulip-systems/ui/sonner";
+import { RotateCcwIcon } from "lucide-react";
+import { orpc } from "@/server/router/client";
+
+export const runTaskResetCommand = commandBuilder
+  .$type<{ id: string } | { id: string }[]>()
+  .transform(ensureArray)
+
+  .permission({ run: ["update"] })
+  .render(({ data }) => (
+    <CommandClick
+      label="Reset"
+      variables={{ ids: data.map((item) => item.id) }}
+      mutation={orpc.runTasks.reset.mutationOptions({
+        onSettled: () => {
+          toast.success("Succesvol gereset");
+        },
+      })}
+    >
+      <RotateCcwIcon />
+      <CommandLabel />
+    </CommandClick>
+  ));
+export const runTaskDeleteCommand = commandBuilder
+  .$type<{ id: string } | { id: string }[]>()
+  .transform(ensureArray)
+
+  .permission({ run: ["update"] })
+  .render(({ data }) => (
+    <DeleteCommand
+      variables={{ ids: data.map((item) => item.id) }}
+      mutation={orpc.runTasks.delete.mutationOptions({
+        onSuccess: () => {
+          toast.success("Succesvol verwijderd");
+        },
+      })}
+    />
+  ));

package/dist/templates/spark/src/app/admin/run-tasks/_config/filters.ts

@@ -0,0 +1,40 @@
+import {
+  arrayFilter,
+  createFilteringParser,
+  defineFilters,
+  resolveFiltersSchema,
+  stringFilter,
+} from "@tulip-systems/query";
+import { createDatabaseFiltersCompiler } from "@tulip-systems/query/drizzle";
+import type { z } from "zod";
+
+export const runTasksFilters = defineFilters({
+  search: stringFilter.build((value) =>
+    value
+      ? {
+          or: [
+            { field: "taskArticleNumber", operator: "ilike", value: `%${value}%` },
+            { field: "taskDescription", operator: "ilike", value: `%${value}%` },
+          ],
+        }
+      : null,
+  ),
+  runId: arrayFilter(stringFilter).build((value) =>
+    value?.length ? { field: "runId", operator: "in", value } : null,
+  ),
+  subprojectId: arrayFilter(stringFilter).build((value) =>
+    value?.length ? { field: "subprojectId", operator: "in", value } : null,
+  ),
+});
+
+/**
+ * Validators
+ */
+export const runTaskFiltersInputSchema = resolveFiltersSchema(runTasksFilters);
+export type RunTaskFiltersInputSchema = z.input<typeof runTaskFiltersInputSchema>;
+
+/**
+ * Parser and compilers
+ */
+export const runTaskFiltersParser = createFilteringParser(runTasksFilters);
+export const runTaskDatabaseFiltersCompiler = createDatabaseFiltersCompiler(runTasksFilters);

package/dist/templates/spark/src/app/admin/run-tasks/_config/sorting.ts

@@ -0,0 +1,26 @@
+import {
+  createSortingParser,
+  defineSorting,
+  resolveSortingSchema,
+  sortOption,
+} from "@tulip-systems/query";
+import { createDatabaseSortingCompiler } from "@tulip-systems/query/drizzle";
+import { createLocalSortingCompiler } from "@tulip-systems/query/tanstack-db";
+
+export const runTaskTableSorts = defineSorting({
+  previousStatus: sortOption((direction) => ({ field: "previousStatus", direction })),
+  newStatus: sortOption((direction) => ({ field: "newStatus", direction })),
+});
+
+/**
+ * Validators
+ */
+export const runTaskTableSortsSchema = resolveSortingSchema(runTaskTableSorts);
+
+/**
+ * Parsers
+ */
+export const runTaskTableSortsParser = createSortingParser(runTaskTableSorts);
+
+export const runTaskTableLocalSortsCompiler = createLocalSortingCompiler(runTaskTableSorts);
+export const runTaskTableDatabaseSortsCompiler = createDatabaseSortingCompiler(runTaskTableSorts);

package/dist/templates/spark/src/app/admin/run-tasks/_lib/router.ts

@@ -0,0 +1,266 @@
+import "server-cli-only";
+
+import { ORPCError } from "@orpc/server";
+import {
+  bulkActionSchema,
+  offsetPaginationResponse,
+  offsetPaginationSchema,
+} from "@tulip-systems/query";
+import {
+  and,
+  count,
+  eq,
+  exists,
+  getTableColumns,
+  gte,
+  ilike,
+  inArray,
+  isNull,
+  or,
+  sql,
+} from "drizzle-orm";
+import z from "zod";
+import { getTableData } from "@/lib/helpers/table-data.server";
+import { subprojects, tasks } from "@/server/db/schema";
+import { permissionMiddleware } from "@/server/router/middleware";
+import { protectedProcedure } from "@/server/router/procedures";
+import type { RunTaskTableData } from "../_components/tables";
+import {
+  runTaskDatabaseFiltersCompiler,
+  runTaskFiltersInputSchema,
+  runTaskFiltersParser,
+} from "../_config/filters";
+import {
+  runTaskTableDatabaseSortsCompiler,
+  runTaskTableSortsParser,
+  runTaskTableSortsSchema,
+} from "../_config/sorting";
+import { runTasks } from "./schema";
+import { runTaskStatusChangeSchema } from "./validators";
+
+export const runTasksRouter = {
+  list: protectedProcedure
+    .use(permissionMiddleware({ run: ["view"] }))
+    .input(
+      z.object({
+        pagination: offsetPaginationSchema,
+        filters: runTaskFiltersInputSchema,
+        sorts: runTaskTableSortsSchema,
+      }),
+    )
+    .handler(async ({ context, input }) => {
+      const parsedSorts = runTaskTableSortsParser.parse(input.sorts);
+      const orderBy = runTaskTableDatabaseSortsCompiler(runTasks).parse(parsedSorts);
+
+      const parsedFilters = runTaskFiltersParser.parse(input.filters);
+      const where = runTaskDatabaseFiltersCompiler({
+        runId: runTasks.runId,
+        taskArticleNumber: ({ value }) =>
+          exists(
+            context.db
+              .select({ one: sql`1` })
+              .from(tasks)
+              .where(
+                and(
+                  eq(tasks.id, runTasks.taskId),
+                  ilike(sql`${tasks.articleNumber}::text`, value as string),
+                ),
+              ),
+          ),
+        taskDescription: ({ value }) =>
+          exists(
+            context.db
+              .select({ one: sql`1` })
+              .from(tasks)
+              .where(
+                and(
+                  eq(tasks.id, runTasks.taskId),
+                  ilike(sql`${tasks.description}::text`, value as string),
+                ),
+              ),
+          ),
+        subprojectId: ({ value }) => {
+          if (!Array.isArray(value) || value.length === 0) return undefined;
+
+          const includesUnassigned = value.includes("none");
+          const assignedSubprojectIds = value.filter((id) => id !== "none");
+
+          return exists(
+            context.db
+              .select({ one: sql`1` })
+              .from(tasks)
+              .where(
+                and(
+                  eq(tasks.id, runTasks.taskId),
+                  or(
+                    includesUnassigned ? isNull(tasks.subprojectId) : undefined,
+                    assignedSubprojectIds.length
+                      ? inArray(tasks.subprojectId, assignedSubprojectIds)
+                      : undefined,
+                  ),
+                ),
+              ),
+          );
+        },
+      }).parse(parsedFilters);
+
+      const { data, total } = await getTableData(context, runTasks, {
+        pagination: input.pagination,
+        where,
+        orderBy,
+        with: { task: { with: { subproject: true } } },
+      });
+
+      return offsetPaginationResponse({
+        data: data as RunTaskTableData[],
+        pagination: input.pagination,
+        total,
+      });
+    }),
+  filterSubprojects: protectedProcedure
+    .use(permissionMiddleware({ run: ["view"] }))
+    .input(z.object({ filters: runTaskFiltersInputSchema }))
+    .handler(async ({ context, input: { filters } }) => {
+      const parsedFilters = runTaskFiltersParser.omit({ subprojectId: true }).parse(filters);
+      const where = runTaskDatabaseFiltersCompiler({
+        ...getTableColumns(runTasks),
+        taskArticleNumber: ({ value }) =>
+          exists(
+            context.db
+              .select({ one: sql`1` })
+              .from(tasks)
+              .where(
+                and(
+                  eq(tasks.id, runTasks.taskId),
+                  ilike(sql`${tasks.articleNumber}::text`, value as string),
+                ),
+              ),
+          ),
+        taskDescription: ({ value }) =>
+          exists(
+            context.db
+              .select({ one: sql`1` })
+              .from(tasks)
+              .where(
+                and(
+                  eq(tasks.id, runTasks.taskId),
+                  ilike(sql`${tasks.description}::text`, value as string),
+                ),
+              ),
+          ),
+      }).parse(parsedFilters);
+
+      return context.db
+        .select({
+          value: sql<string>`coalesce(${tasks.subprojectId}::text, 'none')`.as("value"),
+          label: sql<string>`coalesce(${subprojects.title}, 'Algemeen')`.as("label"),
+          total: count(runTasks.id),
+        })
+        .from(runTasks)
+        .leftJoin(tasks, eq(runTasks.taskId, tasks.id))
+        .leftJoin(subprojects, eq(subprojects.id, tasks.subprojectId))
+        .where(where)
+        .groupBy(tasks.subprojectId, subprojects.title)
+        .having(gte(sql<number>`count(${runTasks.id})`, 1))
+        .orderBy(sql`coalesce(${subprojects.title}, 'Algemeen')`);
+    }),
+  setTaskStatus: protectedProcedure
+    .use(permissionMiddleware({ run: ["update"] }))
+    .input(runTaskStatusChangeSchema)
+    .handler(async ({ context, input }) => {
+      await Promise.all(
+        input.ids.map(async (taskId) => {
+          /**
+           * Get run task by run id and task id
+           */
+          const [runTask] = await context.db
+            .select()
+            .from(runTasks)
+            .where(and(eq(runTasks.runId, input.runId), eq(runTasks.taskId, taskId)));
+
+          /**
+           * Get task by id
+           */
+          const [task] = await context.db.select().from(tasks).where(eq(tasks.id, taskId));
+
+          if (!task) {
+            throw new ORPCError("INTERNAL_SERVER_ERROR", {
+              message: "Taak kon niet worden gewijzigd",
+            });
+          }
+          /**
+           * Update the status of the task
+           */
+          await context.db
+            .update(tasks)
+            .set({ status: input.newStatus })
+            .where(eq(tasks.id, taskId))
+            .returning();
+
+          if (!runTask) {
+            /**
+             * If the run task does not exist, create it
+             */
+            await context.db.insert(runTasks).values({
+              taskId,
+              runId: input.runId,
+              previousStatus: task.status,
+              newStatus: input.newStatus,
+            });
+          } else if (runTask.previousStatus === input.newStatus) {
+            /**
+             * If the previous status is the same as the new status, delete the run task
+             */
+            await context.db.delete(runTasks).where(eq(runTasks.id, runTask.id));
+          } else {
+            /**
+             * If the previous status is not the same as the new status, update the run task
+             */
+            await context.db
+              .update(runTasks)
+              .set({ previousStatus: runTask.previousStatus, newStatus: input.newStatus })
+              .where(and(eq(runTasks.runId, input.runId), eq(runTasks.taskId, taskId)));
+          }
+        }),
+      );
+    }),
+  reset: protectedProcedure
+    .use(permissionMiddleware({ run: ["update"] }))
+    .input(bulkActionSchema)
+    .handler(async ({ context, input }) => {
+      const items = await context.db.select().from(runTasks).where(inArray(runTasks.id, input.ids));
+
+      const results = await Promise.allSettled(
+        items.map(({ id, taskId, previousStatus }) =>
+          context.db.transaction(async (tx) => {
+            const [task] = await tx
+              .update(tasks)
+              .set({ status: previousStatus })
+              .where(eq(tasks.id, taskId))
+              .returning();
+
+            if (!task) {
+              throw new ORPCError("INTERNAL_SERVER_ERROR", {
+                message: "Taak kon niet worden gewijzigd",
+              });
+            }
+
+            await tx.delete(runTasks).where(eq(runTasks.id, id));
+          }),
+        ),
+      );
+
+      const errors = results.filter((result) => result.status === "rejected");
+      if (errors.length > 0) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Een of meerdere taken konden niet worden gewijzigd",
+        });
+      }
+    }),
+  delete: protectedProcedure
+    .use(permissionMiddleware({ run: ["update"] }))
+    .input(bulkActionSchema)
+    .handler(async ({ context, input }) => {
+      await context.db.delete(runTasks).where(inArray(runTasks.id, input.ids));
+    }),
+};