@tulip-systems/create-app 0.11.1

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

@@ -0,0 +1,365 @@
+import "server-cli-only";
+
+import { ORPCError } from "@orpc/server";
+import {
+  bulkActionSchema,
+  offsetPaginationResponse,
+  offsetPaginationSchema,
+  parseOffsetPagination,
+} from "@tulip-systems/query";
+import { and, count, desc, eq, exists, gte, inArray, isNotNull, 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 { clients, projects, 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 { createRegistrationSchema } from "../../registrations/_lib/validators";
+import {
+  runDatabaseFiltersCompiler,
+  runFiltersParser,
+  runFiltersSchema,
+  runRegistrationDatabaseFiltersCompiler,
+  runRegistrationFiltersParser,
+  runsRegistrationsFiltersSchema,
+} from "../_config/filters";
+import {
+  runTableDatabaseSortsCompiler,
+  runTableSortsParser,
+  runTableSortsSchema,
+} from "../_config/sorting";
+import { runs, runsRegistrations } from "./schema";
+import { createRunSchema, runStatusSchema, updateRunSchema } from "./validators";
+
+function parseRunFilters(context: { db: NodePgDatabase<DatabaseSchema> }) {
+  return runDatabaseFiltersCompiler({
+    title: runs.title,
+    projectTitle: projects.title,
+    clientName: clients.name,
+    projectId: runs.projectId,
+    status: runs.status,
+    isDeleted: runs.isDeleted,
+    scheduledAt: runs.scheduledAt,
+    employeeId: ({ value }) => {
+      if (!Array.isArray(value) || value.length === 0) return undefined;
+
+      return exists(
+        context.db
+          .select({ one: sql`1` })
+          .from(runsRegistrations)
+          .innerJoin(registrations, eq(registrations.id, runsRegistrations.registrationId))
+          .where(
+            and(
+              eq(runsRegistrations.runId, runs.id),
+              inArray(registrations.employeeId, value as string[]),
+            ),
+          ),
+      );
+    },
+  });
+}
+
+export const runsRouter = {
+  list: protectedProcedure
+    .use(permissionMiddleware({ run: ["view"] }))
+    .input(
+      z.object({
+        pagination: offsetPaginationSchema,
+        filters: runFiltersSchema,
+        sorts: runTableSortsSchema,
+      }),
+    )
+    .handler(async ({ context, input }) => {
+      const { limit, offset } = parseOffsetPagination(input.pagination);
+      const parsedSorts = runTableSortsParser.parse(input.sorts);
+      const orderBy = runTableDatabaseSortsCompiler({
+        title: runs.title,
+        projectTitle: projects.title,
+        clientName: clients.name,
+        status: runs.status,
+        scheduledAt: runs.scheduledAt,
+      }).parse(parsedSorts);
+
+      const parsedFilters = runFiltersParser.parse(input.filters);
+      const where = parseRunFilters(context).parse(parsedFilters);
+
+      const employeesPerRun = context.db
+        .select({
+          runId: runsRegistrations.runId,
+          employeeIds: sql<string[]>`
+            coalesce(array_agg(distinct ${registrations.employeeId}), array[]::uuid[])
+          `.as("employeeIds"),
+        })
+        .from(runsRegistrations)
+        .innerJoin(registrations, eq(registrations.id, runsRegistrations.registrationId))
+        .groupBy(runsRegistrations.runId)
+        .as("employees_per_run");
+
+      const data = await context.db
+        .select({
+          runs,
+          projects,
+          clients,
+          employeeIds: sql<string[]>`coalesce(${employeesPerRun.employeeIds}, array[]::uuid[])`,
+        })
+        .from(runs)
+        .leftJoin(projects, eq(projects.id, runs.projectId))
+        .leftJoin(clients, eq(clients.id, projects.clientId))
+        .leftJoin(employeesPerRun, eq(employeesPerRun.runId, runs.id))
+        .where(where)
+        .orderBy(...orderBy)
+        .limit(limit)
+        .offset(offset);
+
+      const countQuery = await context.db
+        .select({ total: count() })
+        .from(runs)
+        .leftJoin(projects, eq(projects.id, runs.projectId))
+        .leftJoin(clients, eq(clients.id, projects.clientId))
+        .where(where);
+
+      const total = countQuery[0]?.total ?? 0;
+
+      return offsetPaginationResponse({ data, pagination: input.pagination, total });
+    }),
+  filterProjects: protectedProcedure
+    .use(permissionMiddleware({ run: ["view"] }))
+    .input(z.object({ filters: runFiltersSchema }))
+    .handler(async ({ context, input: { filters } }) => {
+      const parser = runFiltersParser.omit({ search: true });
+      const parsedFilters = parser.parse(filters);
+      const where = parseRunFilters(context).parse(parsedFilters);
+
+      return context.db
+        .select({
+          value: projects.id,
+          label: projects.title,
+          total: count(runs.id),
+        })
+        .from(projects)
+        .leftJoin(runs, and(eq(projects.id, runs.projectId), where))
+        .where(eq(projects.isDeleted, false))
+        .groupBy(projects.id)
+        .having(gte(sql<number>`count(${runs.id})`, 1))
+        .orderBy(projects.title);
+    }),
+  listMessages: protectedProcedure
+    .use(permissionMiddleware({ run: ["view"] }))
+    .input(z.object({ pagination: offsetPaginationSchema, filters: runFiltersSchema }))
+    .handler(async ({ context, input }) => {
+      const parser = runFiltersParser.omit({ search: true });
+      const parsedFilters = parser.parse(input.filters);
+      const where = parseRunFilters(context).parse(parsedFilters);
+
+      const { data, total } = await getTableData(context, runs, {
+        pagination: input.pagination,
+        where: and(isNotNull(runs.message), where),
+        orderBy: [desc(runs.scheduledAt)],
+      });
+
+      return offsetPaginationResponse({ data, pagination: input.pagination, total });
+    }),
+  getById: protectedProcedure
+    .use(permissionMiddleware({ run: ["view"] }))
+    .input(z.object({ id: z.string() }))
+    .handler(async ({ context, input }) => {
+      const data = await context.db.query.runs.findFirst({
+        where: eq(runs.id, input.id),
+        with: { runsRegistrations: { with: { registration: true } } },
+      });
+
+      return data ?? null;
+    }),
+  getAll: protectedProcedure
+    .use(permissionMiddleware({ run: ["view"] }))
+    .input(z.object({ filters: runFiltersSchema }))
+    .handler(async ({ context, input: { filters } }) => {
+      const parser = runFiltersParser.omit({ search: true });
+      const parsedFilters = parser.parse(filters);
+      const where = parseRunFilters(context).parse(parsedFilters);
+
+      const data = await context.db.query.runs.findMany({
+        where,
+        with: {
+          project: { with: { client: true } },
+          runsRegistrations: { with: { registration: true } },
+        },
+      });
+
+      return data;
+    }),
+  create: protectedProcedure
+    .use(permissionMiddleware({ run: ["create"] }))
+    .input(createRunSchema)
+    .handler(async ({ context, input: { employeeIds, startTime, stopTime, ...values } }) => {
+      /**
+       * Create run
+       */
+      const [result] = await context.db.insert(runs).values(values).returning();
+
+      if (!result) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Run 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 runRegistrations
+       */
+      const runsRegistrationsValues = registrationResults.map((registration) => ({
+        runId: result.id,
+        registrationId: registration.id,
+      }));
+
+      await context.db.insert(runsRegistrations).values(runsRegistrationsValues).returning();
+
+      return result;
+    }),
+  update: protectedProcedure
+    .use(permissionMiddleware({ run: ["update"] }))
+    .input(z.object({ id: z.string(), data: updateRunSchema.partial() }))
+    .output(z.void())
+    .handler(async ({ context, input }) => {
+      const [result] = await context.db
+        .update(runs)
+        .set(input.data)
+        .where(eq(runs.id, input.id))
+        .returning();
+
+      if (!result) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Run kon niet worden aangemaakt",
+        });
+      }
+    }),
+  setStatus: protectedProcedure
+    .use(permissionMiddleware({ run: ["setStatus"] }))
+    .input(bulkActionSchema.extend({ status: runStatusSchema }))
+    .handler(async ({ context, input }) => {
+      await context.db
+        .update(runs)
+        .set({ status: input.status })
+        .where(inArray(runs.id, input.ids))
+        .returning();
+    }),
+  archive: protectedProcedure
+    .use(permissionMiddleware({ run: ["archive"] }))
+    .input(bulkActionSchema)
+    .handler(async ({ context, input }) => {
+      await context.db
+        .update(runs)
+        .set({ isDeleted: true })
+        .where(inArray(runs.id, input.ids))
+        .returning();
+    }),
+  restore: protectedProcedure
+    .use(permissionMiddleware({ run: ["archive"] }))
+    .input(bulkActionSchema)
+    .handler(async ({ context, input }) => {
+      await context.db
+        .update(runs)
+        .set({ isDeleted: false })
+        .where(inArray(runs.id, input.ids))
+        .returning();
+    }),
+  delete: protectedProcedure
+    .use(permissionMiddleware({ run: ["delete"] }))
+    .input(bulkActionSchema)
+    .handler(async ({ context, input }) => {
+      await context.db.delete(runs).where(inArray(runs.id, input.ids));
+    }),
+
+  listRegistrations: protectedProcedure
+    .use(permissionMiddleware({ run: ["view"] }))
+    .input(
+      z.object({
+        pagination: offsetPaginationSchema,
+        filters: runsRegistrationsFiltersSchema,
+        sorts: registrationTableSortsSchema,
+      }),
+    )
+    .handler(async ({ context, input }) => {
+      const parsedSorts = registrationTableSortsParser.parse(input.sorts);
+      const orderBy = registrationTableDatabaseSortsCompiler(registrations).parse(parsedSorts);
+
+      const parsedFilters = runRegistrationFiltersParser.parse(input.filters);
+      const where = runRegistrationDatabaseFiltersCompiler(runsRegistrations).parse(parsedFilters);
+
+      const filteredRunsRegistrations = await context.db
+        .select()
+        .from(runsRegistrations)
+        .where(where);
+
+      const registrationIds = filteredRunsRegistrations.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({ run: ["update"] }))
+    .input(createRegistrationSchema.extend({ runId: z.string() }))
+    .handler(async ({ context, input: { runId, employeeIds, ...input } }) => {
+      const run = await context.db.query.runs.findFirst({
+        where: eq(runs.id, runId),
+      });
+      if (!run) throw new ORPCError("NOT_FOUND", { message: "Run niet gevonden" });
+
+      /**
+       * Create registrations
+       * */
+      const registrationsValues = employeeIds.map((id) => ({
+        ...input,
+        startTime: new Date(`${run.scheduledAt}T${input.startTime}`),
+        stopTime: new Date(`${run.scheduledAt}T${input.stopTime}`),
+        employeeId: id,
+      }));
+
+      const registrationResults = await context.db
+        .insert(registrations)
+        .values(registrationsValues)
+        .returning();
+
+      /**
+       * Create runRegistrations
+       */
+      const runsRegistrationsValues = registrationResults.map((registration) => ({
+        runId,
+        registrationId: registration.id,
+      }));
+
+      await context.db.insert(runsRegistrations).values(runsRegistrationsValues).returning();
+    }),
+};

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

@@ -0,0 +1,65 @@
+import type { EditorJSONContent } from "@tulip-systems/editor";
+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";
+import { registrations } from "@/server/db/schema";
+
+export const runStatusEnum = pgEnum("run_status_enum", ["active", "in_review", "finished"]);
+
+/**
+ * Run table
+ */
+export const runs = pgTable("runs", (t) => ({
+  ...baseColumns,
+  title: t.varchar().notNull(),
+  scheduledAt: t.date().notNull(),
+  status: runStatusEnum().default("active").notNull(),
+  description: t.jsonb().$type<EditorJSONContent>(),
+  message: t.jsonb().$type<EditorJSONContent>(),
+  isDeleted: t.boolean().default(false),
+  projectId: t
+    .uuid()
+    .notNull()
+    .references(() => projects.id, { onDelete: "cascade" }),
+}));
+
+/**
+ * Relations
+ */
+export const runsRelations = relations(runs, ({ one, many }) => ({
+  project: one(projects, {
+    fields: [runs.projectId],
+    references: [projects.id],
+  }),
+  runsRegistrations: many(runsRegistrations),
+}));
+
+/**
+ * Run Registration table
+ */
+export const runsRegistrations = pgTable("runs_registrations", (t) => ({
+  ...baseColumns,
+  runId: t
+    .uuid()
+    .notNull()
+    .references(() => runs.id, { onDelete: "cascade" }),
+  registrationId: t
+    .uuid()
+    .notNull()
+    .references(() => registrations.id, { onDelete: "cascade" }),
+}));
+
+/**
+ * Relations
+ */
+export const runsRegistrationsRelations = relations(runsRegistrations, ({ one }) => ({
+  run: one(runs, {
+    fields: [runsRegistrations.runId],
+    references: [runs.id],
+  }),
+  registration: one(registrations, {
+    fields: [runsRegistrations.registrationId],
+    references: [registrations.id],
+  }),
+}));

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

@@ -0,0 +1,56 @@
+import { createInsertSchema, createSelectSchema } from "drizzle-zod";
+import { z } from "zod";
+
+export type {
+  RunFilters,
+  RunFiltersSchema,
+  RunsRegistrationsFiltersSchema,
+} from "../_config/filters";
+export { runFiltersSchema, runsRegistrationsFiltersSchema } from "../_config/filters";
+
+import { runStatusEnum, runs } from "./schema";
+
+/**
+ * Run type
+ */
+export type Run = typeof runs.$inferSelect;
+
+/**
+ * Select run schema
+ */
+export const selectRunSchema = createSelectSchema(runs);
+export type SelectRunSchema = z.infer<typeof selectRunSchema>;
+
+/**
+ * Run status
+ */
+export const runStatusSchema = z.enum(runStatusEnum.enumValues);
+export type RunStatus = z.infer<typeof runStatusSchema>;
+
+/**
+ * Create run input validation
+ */
+export const createRunSchema = 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"),
+  projectId: z.string({ error: "Project is niet geldig" }),
+});
+
+export const updateRunSchema = createInsertSchema(runs);
+
+/**
+ * Create project schema
+ */
+export type CreateRunInput = z.input<typeof createRunSchema>;
+export type CreateRunSchema = z.infer<typeof createRunSchema>;
+
+export type UpdateRunInput = z.input<typeof updateRunSchema>;
+export type UpdateRunSchema = z.infer<typeof updateRunSchema>;

package/dist/templates/spark/src/app/admin/sales-invoice-items/_components/tables.tsx

@@ -0,0 +1,151 @@
+"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 { SalesInvoice } from "../../sales-invoices/_lib/validators";
+import { salesInvoiceItemsFilters } from "../_config/filters";
+import { salesInvoiceItemTableSorts } from "../_config/sorting";
+import type { SalesInvoiceItem } from "../_lib/validators";
+
+export type SalesInvoiceItemTableData = SalesInvoiceItem & { salesInvoice: SalesInvoice };
+
+/**
+ * Client data table
+ */
+type SalesInvoiceItemTableProviderProps<TData extends SalesInvoiceItemTableData> = {
+  columns: TableColumnDef<TData>[];
+  commands?: CommandFor<TData[]>[];
+  filterOptions?: UseFiltersOptions<typeof salesInvoiceItemsFilters>;
+  columnVisibility?: VisibilityState;
+};
+
+export function SalesInvoiceItemInfiniteTableProvider({
+  columns,
+  commands,
+  filterOptions,
+  columnVisibility,
+
+  children,
+}: PropsWithChildren<SalesInvoiceItemTableProviderProps<SalesInvoiceItemTableData>>) {
+  const pagination = usePagination(offsetPagination);
+  const filtering = useFilters(salesInvoiceItemsFilters, filterOptions);
+  const sorting = useSorting(salesInvoiceItemTableSorts);
+
+  const input = useDeferredValue({
+    pagination: pagination.input,
+    filters: filtering.input,
+    sorts: sorting.input,
+  });
+
+  /**
+   * Data
+   */
+  const response = useSuspenseInfiniteQuery(
+    orpc.salesInvoiceItems.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<SalesInvoiceItemTableData>({
+    queryData,
+    getRowId: (row) => row.id,
+    columns,
+    strategy,
+    filtering,
+    sorting,
+    commands,
+    columnVisibility,
+  });
+
+  return <TableConfigProvider config={config}>{children}</TableConfigProvider>;
+}
+
+export function SalesInvoiceItemPaginationTableProvider({
+  columns,
+  commands,
+  filterOptions,
+  columnVisibility,
+
+  children,
+}: PropsWithChildren<SalesInvoiceItemTableProviderProps<SalesInvoiceItemTableData>>) {
+  const pagination = usePagination(offsetPagination);
+  const filtering = useFilters(salesInvoiceItemsFilters, filterOptions);
+  const sorting = useSorting(salesInvoiceItemTableSorts);
+
+  const input = useDeferredValue({
+    pagination: pagination.input,
+    filters: filtering.input,
+    sorts: sorting.input,
+  });
+
+  /**
+   * Data
+   */
+  const response = useSuspenseQuery(orpc.salesInvoiceItems.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<SalesInvoiceItemTableData>({
+    queryData,
+    getRowId: (row) => row.id,
+    columns,
+    strategy,
+    sorting,
+    commands,
+    columnVisibility,
+  });
+
+  return <TableConfigProvider config={config}>{children}</TableConfigProvider>;
+}

package/dist/templates/spark/src/app/admin/sales-invoice-items/_components/toolbars.tsx

@@ -0,0 +1,21 @@
+"use client";
+
+import { TableToolbar, TableToolbarList } from "@tulip-systems/data-tables";
+import { resolveFilterDescriptors } from "@tulip-systems/query";
+import { FilterSearch } from "@tulip-systems/query/client";
+import type { PropsWithChildren } from "react";
+import { salesInvoiceItemsFilters } from "../_config/filters";
+
+const salesInvoiceItemsFiltersDescriptors = resolveFilterDescriptors(salesInvoiceItemsFilters);
+
+export function SalesInvoiceItemTableToolbar({ children }: PropsWithChildren) {
+  return (
+    <TableToolbar>
+      <TableToolbarList>
+        <FilterSearch placeholder="Zoeken..." filter={salesInvoiceItemsFiltersDescriptors.search} />
+      </TableToolbarList>
+
+      <TableToolbarList>{children}</TableToolbarList>
+    </TableToolbar>
+  );
+}