@tulip-systems/create-app 0.11.1

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

@@ -0,0 +1,180 @@
+import "server-cli-only";
+
+import { ORPCError } from "@orpc/server";
+import {
+  bulkActionSchema,
+  offsetPaginationResponse,
+  offsetPaginationSchema,
+} from "@tulip-systems/query";
+import { and, count, desc, eq, gte, inArray, sql } from "drizzle-orm";
+import z from "zod";
+import { getTableData } from "@/lib/helpers/table-data.server";
+import { clients, executions } from "@/server/db/schema";
+import { permissionMiddleware } from "@/server/router/middleware";
+import { protectedProcedure } from "@/server/router/procedures";
+import type { AssignmentTableData } from "../_components/tables";
+import {
+  assignmentDatabaseFiltersCompiler,
+  assignmentFiltersParser,
+  assignmentFiltersSchema,
+} from "../_config/filters";
+import {
+  assignmentTableDatabaseSortsCompiler,
+  assignmentTableSortsParser,
+  assignmentTableSortsSchema,
+} from "../_config/sorting";
+import { assignments } from "./schema";
+import {
+  assignmentStatusSchema,
+  createAssignmentSchema,
+  updateAssignmentSchema,
+} from "./validators";
+
+export const assignmentsRouter = {
+  list: protectedProcedure
+    .use(permissionMiddleware({ assignment: ["view"] }))
+    .input(
+      z.object({
+        pagination: offsetPaginationSchema,
+        filters: assignmentFiltersSchema,
+        sorts: assignmentTableSortsSchema,
+      }),
+    )
+    .handler(async ({ context, input }) => {
+      const parsedSorts = assignmentTableSortsParser.parse(input.sorts);
+      const orderBy = assignmentTableDatabaseSortsCompiler(assignments).parse(parsedSorts);
+
+      const parsedFilters = assignmentFiltersParser.parse(input.filters);
+      const where = assignmentDatabaseFiltersCompiler(assignments).parse(parsedFilters);
+
+      const { data, total } = await getTableData(context, assignments, {
+        pagination: input.pagination,
+        where,
+        orderBy,
+        with: {
+          client: true,
+          executions: {
+            orderBy: [desc(executions.scheduledAt)],
+            with: { executionsRegistrations: { with: { registration: true } } },
+          },
+        },
+      });
+
+      return offsetPaginationResponse({
+        data: data as AssignmentTableData[],
+        pagination: input.pagination,
+        total,
+      });
+    }),
+  filterCustomers: protectedProcedure
+    .use(permissionMiddleware({ assignment: ["view"] }))
+    .input(z.object({ filters: assignmentFiltersSchema }))
+    .handler(async ({ context, input: { filters } }) => {
+      const parser = assignmentFiltersParser.omit({ clientId: true });
+      const parsedFilters = parser.parse(filters);
+      const where = assignmentDatabaseFiltersCompiler(assignments).parse(parsedFilters);
+
+      return context.db
+        .select({
+          value: clients.id,
+          label: clients.name,
+          total: count(assignments.id),
+        })
+        .from(clients)
+        .leftJoin(assignments, and(eq(clients.id, assignments.clientId), where))
+        .where(eq(clients.isDeleted, false))
+        .groupBy(clients.id)
+        .having(gte(sql<number>`count(${assignments.id})`, 1))
+        .orderBy(clients.name);
+    }),
+  getAll: protectedProcedure
+    .use(permissionMiddleware({ assignment: ["view"] }))
+    .handler(async ({ context }) =>
+      context.db
+        .select()
+        .from(assignments)
+        .orderBy(desc(assignments.title))
+        .where(eq(assignments.isDeleted, false)),
+    ),
+  getById: protectedProcedure
+    .use(permissionMiddleware({ assignment: ["view"] }))
+    .input(z.object({ id: z.string() }))
+    .handler(async ({ context, input }) => {
+      const data = await context.db.query.assignments.findFirst({
+        where: eq(assignments.id, input.id),
+        with: {
+          client: true,
+          executions: {
+            orderBy: [desc(executions.scheduledAt)],
+            with: { executionsRegistrations: { with: { registration: true } } },
+          },
+        },
+      });
+
+      return data ?? null;
+    }),
+  create: protectedProcedure
+    .use(permissionMiddleware({ assignment: ["create"] }))
+    .input(createAssignmentSchema)
+    .handler(async ({ context, input }) => {
+      const [result] = await context.db.insert(assignments).values(input).returning();
+
+      if (!result) {
+        throw new ORPCError("NOT_FOUND", {
+          message: "Assignment kon niet worden aangemaakt",
+        });
+      }
+
+      return result;
+    }),
+  update: protectedProcedure
+    .use(permissionMiddleware({ assignment: ["update"] }))
+    .input(z.object({ id: z.string(), data: updateAssignmentSchema.partial() }))
+    .output(z.void())
+    .handler(async ({ context, input }) => {
+      const [result] = await context.db
+        .update(assignments)
+        .set(input.data)
+        .where(eq(assignments.id, input.id))
+        .returning();
+
+      if (!result) {
+        throw new ORPCError("NOT_FOUND", {
+          message: "Assignment kon niet worden gewijzigd",
+        });
+      }
+    }),
+  setStatus: protectedProcedure
+    .use(permissionMiddleware({ assignment: ["update"] }))
+    .input(bulkActionSchema.extend({ status: assignmentStatusSchema }))
+    .handler(async ({ context, input }) => {
+      await context.db
+        .update(assignments)
+        .set({ status: input.status })
+        .where(inArray(assignments.id, input.ids));
+    }),
+  archive: protectedProcedure
+    .use(permissionMiddleware({ assignment: ["archive"] }))
+    .input(bulkActionSchema)
+    .handler(async ({ context, input }) => {
+      await context.db
+        .update(assignments)
+        .set({ isDeleted: true })
+        .where(inArray(assignments.id, input.ids));
+    }),
+  restore: protectedProcedure
+    .use(permissionMiddleware({ assignment: ["archive"] }))
+    .input(bulkActionSchema)
+    .handler(async ({ context, input }) => {
+      await context.db
+        .update(assignments)
+        .set({ isDeleted: false })
+        .where(inArray(assignments.id, input.ids));
+    }),
+  delete: protectedProcedure
+    .use(permissionMiddleware({ assignment: ["delete"] }))
+    .input(bulkActionSchema)
+    .handler(async ({ context, input }) => {
+      await context.db.delete(assignments).where(inArray(assignments.id, input.ids));
+    }),
+};

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

@@ -0,0 +1,32 @@
+import { relations } from "drizzle-orm";
+import { pgEnum, pgTable } from "drizzle-orm/pg-core";
+import { baseColumns } from "@/server/db/helpers";
+import { clients, executions } from "@/server/db/schema";
+
+export const assignmentEnum = pgEnum("assignment_status_enum", ["active", "in_review", "finished"]);
+
+/**
+ * Table
+ */
+export const assignments = pgTable("assignments", (t) => ({
+  ...baseColumns,
+  title: t.varchar().notNull(),
+  status: assignmentEnum().default("active").notNull(),
+  notes: t.jsonb(),
+  isDeleted: t.boolean().default(false).notNull(),
+  clientId: t
+    .uuid()
+    .notNull()
+    .references(() => clients.id, { onDelete: "restrict" }),
+}));
+
+/**
+ * Relations
+ */
+export const assignmentsRelations = relations(assignments, ({ many, one }) => ({
+  client: one(clients, {
+    fields: [assignments.clientId],
+    references: [clients.id],
+  }),
+  executions: many(executions),
+}));

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

@@ -0,0 +1,39 @@
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from "drizzle-zod";
+import { z } from "zod";
+
+export type { AssignmentFilters } from "../_config/filters";
+export { assignmentFiltersSchema } from "../_config/filters";
+
+import { assignmentEnum, assignments } from "./schema";
+
+/**
+ * Contact type
+ */
+export type Assignment = typeof assignments.$inferSelect;
+
+/**
+ * Issue status
+ */
+export const assignmentStatusSchema = z.enum(assignmentEnum.enumValues);
+export type AssignmentStatus = z.infer<typeof assignmentStatusSchema>;
+
+/**
+ * Select schema
+ */
+export const selectAssignmentSchema = createSelectSchema(assignments);
+export type SelectAssignmentSchema = z.infer<typeof selectAssignmentSchema>;
+
+/**
+ * Schema
+ */
+export const createAssignmentSchema = createInsertSchema(assignments);
+export const updateAssignmentSchema = createUpdateSchema(assignments);
+
+/**
+ * Create assignment schema
+ */
+export type CreateAssignmentInput = z.input<typeof createAssignmentSchema>;
+export type CreateAssignmentSchema = z.infer<typeof createAssignmentSchema>;
+
+export type UpdateAssignmentInput = z.input<typeof updateAssignmentSchema>;
+export type UpdateAssignmentSchema = z.infer<typeof updateAssignmentSchema>;

package/dist/templates/spark/src/app/admin/clients/_config/commands.tsx

@@ -0,0 +1,122 @@
+"use client";
+
+import { commandBuilder, ensureArray } from "@tulip-systems/commands";
+import {
+  ArchiveCommand,
+  CommandLabel,
+  type CommandMutationMeta,
+  DeleteCommand,
+  RestoreCommand,
+} from "@tulip-systems/commands/client";
+import { toast } from "@tulip-systems/ui/sonner";
+import { Icons } from "@/components/icons";
+import { orpc } from "@/server/router/client";
+import {
+  AddressCreateCommand,
+  AddressCreateCommandTrigger,
+} from "../../addresses/_components/create-command";
+import {
+  ContactCreateCommand,
+  ContactCreateCommandTrigger,
+} from "../../contacts/_components/create-command";
+
+type ClientBulkCommandItem = { id: string; isDeleted: boolean };
+
+const bulkClientCommandBuilder = commandBuilder
+  .$type<ClientBulkCommandItem | ClientBulkCommandItem[]>()
+  .transform(ensureArray);
+
+export const clientCreateCommand = commandBuilder
+  .$type<{ clientId: string }>()
+
+  .permission({ client: ["update"] })
+  .render(({ data }) => (
+    <ContactCreateCommand
+      variables={(values) => ({ ...values, ...data })}
+      mutation={orpc.clients.createContact.mutationOptions({
+        onSuccess: () => {
+          toast.success("Contact succesvol toegevoegd");
+        },
+      })}
+    >
+      <ContactCreateCommandTrigger label="Toevoegen" hotkey="mod+i">
+        <Icons.add />
+        <CommandLabel />
+      </ContactCreateCommandTrigger>
+    </ContactCreateCommand>
+  ));
+export const clientCreateAddressCommand = commandBuilder
+  .$type<{ clientId: string }>()
+
+  .permission({ client: ["update"] })
+  .render(({ data }) => (
+    <AddressCreateCommand
+      variables={(values) => ({ ...values, ...data })}
+      mutation={orpc.clients.createAddress.mutationOptions({
+        onSuccess: () => {
+          toast.success("Adres succesvol toegevoegd");
+        },
+      })}
+    >
+      <AddressCreateCommandTrigger label="Adres toevoegen">
+        <Icons.add />
+        <CommandLabel />
+      </AddressCreateCommandTrigger>
+    </AddressCreateCommand>
+  ));
+export const clientCreateContactCommand = commandBuilder
+  .$type<{ clientId: string }>()
+
+  .permission({ client: ["update"] })
+  .render(({ data }) => (
+    <ContactCreateCommand
+      variables={(values) => ({ ...values, ...data })}
+      mutation={orpc.clients.createContact.mutationOptions({
+        onSuccess: () => {
+          toast.success("Contact succesvol toegevoegd");
+        },
+      })}
+    >
+      <ContactCreateCommandTrigger label="Contact toevoegen">
+        <Icons.add />
+        <CommandLabel />
+      </ContactCreateCommandTrigger>
+    </ContactCreateCommand>
+  ));
+export const clientArchiveCommand = bulkClientCommandBuilder
+  .permission({ client: ["archive"] })
+  .visibleWhen(({ data }) => data.every((item) => !item.isDeleted))
+  .render(({ data }) => (
+    <ArchiveCommand
+      variables={{ ids: data.map((item) => item.id) }}
+      mutation={orpc.clients.archive.mutationOptions({
+        onSuccess: () => toast.success("Succesvol gearchiveerd"),
+      })}
+    />
+  ));
+export const clientRestoreCommand = bulkClientCommandBuilder
+  .permission({ client: ["archive"] })
+  .visibleWhen(({ data }) => data.every((item) => item.isDeleted))
+  .render(({ data }) => (
+    <RestoreCommand
+      variables={{ ids: data.map((item) => item.id) }}
+      mutation={orpc.clients.restore.mutationOptions({
+        onSuccess: () => toast.success("Succesvol hersteld"),
+      })}
+    />
+  ));
+export const clientDeleteCommand = bulkClientCommandBuilder
+  .permission({ client: ["delete"] })
+  .visibleWhen(({ data }) => data.every((item) => item.isDeleted))
+  .render(({ data }) => (
+    <DeleteCommand
+      variables={{ ids: data.map((item) => item.id) }}
+      mutation={orpc.clients.delete.mutationOptions({
+        onSuccess: (_data, _vars, _result, context) => {
+          toast.success("Succesvol verwijderd");
+          const meta = context.meta as CommandMutationMeta;
+          meta.router.push("/admin/clients");
+        },
+      })}
+    />
+  ));

package/dist/templates/spark/src/app/admin/clients/_config/filters.ts

@@ -0,0 +1,39 @@
+import {
+  booleanFilter,
+  createFilteringParser,
+  defineFilters,
+  resolveFiltersSchema,
+  stringFilter,
+} from "@tulip-systems/query";
+import { createDatabaseFiltersCompiler } from "@tulip-systems/query/drizzle";
+import type { z } from "zod";
+
+export const clientsFilters = defineFilters({
+  search: stringFilter.build((value) =>
+    value
+      ? {
+          or: [
+            { field: "name", operator: "ilike", value: `%${value}%` },
+            { field: "notes", operator: "ilike", value: `%${value}%` },
+          ],
+        }
+      : null,
+  ),
+  isDeleted: booleanFilter.build((value) => ({
+    field: "isDeleted",
+    operator: "eq",
+    value: value ?? false,
+  })),
+});
+
+/**
+ * Validators
+ */
+export const clientFiltersSchema = resolveFiltersSchema(clientsFilters);
+export type ClientFilters = z.input<typeof clientFiltersSchema>;
+
+/**
+ * Parser and compilers
+ */
+export const clientFiltersParser = createFilteringParser(clientsFilters);
+export const clientDatabaseFiltersCompiler = createDatabaseFiltersCompiler(clientsFilters);

package/dist/templates/spark/src/app/admin/clients/_lib/constants.ts

@@ -0,0 +1,15 @@
+import Decimal from "decimal.js";
+
+export const VAT_RATES = [
+  { value: Decimal(0).toFixed(3), label: "0 %" },
+  { value: Decimal(0.06).toFixed(3), label: "6 %" },
+  { value: Decimal(0.12).toFixed(3), label: "12 %" },
+  { value: Decimal(0.21).toFixed(3), label: "21 %" },
+] as const;
+
+export const DEFAULT_VAT_RATE = Decimal(0.21).toFixed(3);
+
+export const vatRateComboboxOptions = VAT_RATES.map((vatRate) => ({
+  id: vatRate.value,
+  value: vatRate.label,
+}));

package/dist/templates/spark/src/app/admin/clients/_lib/helpers.ts

@@ -0,0 +1,8 @@
+import type { Route } from "next";
+import type { Client } from "./validators";
+
+export function generateClientHref(client: Pick<Client, "id" | "type"> | undefined): Route {
+  if (client?.type === "company") return `/admin/companies/${client.id}` as Route;
+  if (client?.type === "customer") return `/admin/customers/${client.id}` as Route;
+  return "";
+}

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

@@ -0,0 +1,85 @@
+import "server-cli-only";
+
+import { bulkActionSchema } from "@tulip-systems/query";
+import { asc, eq, inArray } from "drizzle-orm";
+import z from "zod";
+import { permissionMiddleware } from "@/server/router/middleware";
+import { protectedProcedure } from "@/server/router/procedures";
+import { createAddress } from "../../addresses/_lib/helpers.server";
+import { createAddressSchema } from "../../addresses/_lib/validators";
+import { createContact } from "../../contacts/_lib/helpers.server";
+import { createContactSchema } from "../../contacts/_lib/validators";
+import { clients, clientsAddresses, clientsContacts } from "./schema";
+
+export const clientsRouter = {
+  getAll: protectedProcedure
+    .use(permissionMiddleware({ client: ["view"] }))
+    .handler(async ({ context }) =>
+      context.db
+        .select()
+        .from(clients)
+        .orderBy(asc(clients.name))
+        .where(eq(clients.isDeleted, false)),
+    ),
+  getById: protectedProcedure
+    .use(permissionMiddleware({ client: ["view"] }))
+    .input(z.object({ id: z.string() }))
+    .handler(async ({ context, input }) => {
+      const data = await context.db.query.clients.findFirst({ where: eq(clients.id, input.id) });
+      return data ?? null;
+    }),
+  createContact: protectedProcedure
+    .use(permissionMiddleware({ client: ["update"], contact: ["create"] }))
+    .input(createContactSchema.extend({ clientId: z.string() }))
+    .output(z.void())
+    .handler(async (opts) => {
+      await createContact(opts, async ({ tx, data }) => {
+        await tx.insert(clientsContacts).values({
+          clientId: opts.input.clientId,
+          contactId: data.id,
+        });
+      });
+    }),
+  createAddress: protectedProcedure
+    .use(permissionMiddleware({ client: ["update"], address: ["create"] }))
+    .input(createAddressSchema.extend({ clientId: z.string() }))
+    .output(z.void())
+    .handler(async (opts) => {
+      await createAddress(opts, async ({ tx, data }) => {
+        await tx
+          .insert(clientsAddresses)
+          .values({ clientId: opts.input.clientId, addressId: data.id });
+      });
+    }),
+  archive: protectedProcedure
+    .use(permissionMiddleware({ client: ["archive"] }))
+    .input(bulkActionSchema)
+    .output(z.void())
+    .handler(async ({ context, input }) => {
+      await context.db
+        .update(clients)
+        .set({ isDeleted: true })
+        .where(inArray(clients.id, input.ids));
+    }),
+  restore: protectedProcedure
+    .use(permissionMiddleware({ client: ["archive"] }))
+    .input(bulkActionSchema)
+    .output(z.void())
+    .handler(async ({ context, input }) => {
+      await context.db
+        .update(clients)
+        .set({ isDeleted: false })
+        .where(inArray(clients.id, input.ids));
+    }),
+  delete: protectedProcedure
+    .use(permissionMiddleware({ client: ["delete"] }))
+    .input(bulkActionSchema)
+    .output(z.void())
+    .handler(async ({ context, input }) => {
+      await context.db.transaction(async (tx) => {
+        await tx.delete(clientsContacts).where(inArray(clientsContacts.clientId, input.ids));
+        await tx.delete(clientsAddresses).where(inArray(clientsAddresses.clientId, input.ids));
+        await tx.delete(clients).where(inArray(clients.id, input.ids));
+      });
+    }),
+};

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

@@ -0,0 +1,98 @@
+import type { EditorJSONContent } from "@tulip-systems/editor";
+import { relations } from "drizzle-orm";
+import { pgEnum, pgTable, unique } from "drizzle-orm/pg-core";
+import { baseColumns } from "@/server/db/helpers";
+import { addresses, companyDetails, contacts, projects, quotations } from "@/server/db/schema";
+
+export const clientTypeEnum = pgEnum("client_type", ["customer", "company"]);
+
+/**
+ * Companys table
+ */
+export const clients = pgTable("clients", (t) => ({
+  ...baseColumns,
+  name: t.varchar().notNull(),
+  type: clientTypeEnum().notNull(),
+  vatRate: t.numeric({ precision: 5, scale: 3 }).default("0.21").notNull(),
+  paymentTerm: t.integer().default(30),
+  hourlyRate: t.numeric({ precision: 12, scale: 3 }),
+  notes: t.jsonb().$type<EditorJSONContent>(),
+  isDeleted: t.boolean().default(false).notNull(),
+}));
+
+/**
+ * Relations
+ */
+export const clientsRelations = relations(clients, ({ one, many }) => ({
+  companyDetails: one(companyDetails),
+  clientsAddresses: many(clientsAddresses),
+  clientsContacts: many(clientsContacts),
+  projects: many(projects),
+  quotations: many(quotations),
+}));
+
+/**
+ * Company address
+ */
+export const clientsAddresses = pgTable(
+  "clients_addresses",
+  (t) => ({
+    ...baseColumns,
+    clientId: t
+      .uuid()
+      .references(() => clients.id, { onDelete: "cascade" })
+      .notNull(),
+    addressId: t
+      .uuid()
+      .references(() => addresses.id, { onDelete: "cascade" })
+      .notNull(),
+  }),
+  (t) => [unique("client_address_unique").on(t.clientId, t.addressId)],
+);
+
+/**
+ * Relations
+ */
+export const clientsAddressesRelations = relations(clientsAddresses, ({ one }) => ({
+  client: one(clients, {
+    fields: [clientsAddresses.clientId],
+    references: [clients.id],
+  }),
+  address: one(addresses, {
+    fields: [clientsAddresses.addressId],
+    references: [addresses.id],
+  }),
+}));
+
+/**
+ * Company contact
+ */
+export const clientsContacts = pgTable(
+  "clients_contacts",
+  (t) => ({
+    ...baseColumns,
+    clientId: t
+      .uuid()
+      .references(() => clients.id, { onDelete: "cascade" })
+      .notNull(),
+    contactId: t
+      .uuid()
+      .references(() => contacts.id, { onDelete: "cascade" })
+      .notNull(),
+  }),
+  (t) => [unique("client_contact_unique").on(t.clientId, t.contactId)],
+);
+
+/**
+ * Relations
+ */
+export const clientsContactsRelations = relations(clientsContacts, ({ one }) => ({
+  client: one(clients, {
+    fields: [clientsContacts.clientId],
+    references: [clients.id],
+  }),
+  contact: one(contacts, {
+    fields: [clientsContacts.contactId],
+    references: [contacts.id],
+  }),
+}));

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

@@ -0,0 +1,51 @@
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from "drizzle-zod";
+import { z } from "zod";
+import { clients } from "./schema";
+
+/**
+ * Contact type
+ */
+export type Client = typeof clients.$inferSelect;
+
+/**
+ * Select schema
+ */
+export const selectClientSchema = createSelectSchema(clients);
+export type SelectClientSchema = z.infer<typeof selectClientSchema>;
+
+/**
+ * Schema
+ */
+export const createClientSchema = createInsertSchema(clients);
+export const updateClientSchema = createUpdateSchema(clients).extend({
+  name: z
+    .string({ error: "Naam is niet geldig" })
+    .trim()
+    .min(1, "Naam is verplicht")
+    .max(255, "Naam mag maximaal 255 tekens bevatten")
+    .optional(),
+  vatRate: z
+    .string({ error: "BTW-tarief is niet geldig" })
+    .trim()
+    .min(1, "BTW-tarief is verplicht")
+    .max(20, "BTW-tarief mag maximaal 20 tekens bevatten")
+    .optional(),
+  paymentTerm: z
+    .number({ error: "Betalingstermijn is niet geldig" })
+    .int("Betalingstermijn moet een heel getal zijn")
+    .min(0, "Betalingstermijn mag niet negatief zijn")
+    .max(365, "Betalingstermijn mag maximaal 365 dagen zijn")
+    .nullable()
+    .optional(),
+  hourlyRate: z
+    .string({ error: "Uurtarief is niet geldig" })
+    .regex(/^\d+(?:[.,]\d{1,3})?$/, "Uurtarief is niet geldig")
+    .nullable()
+    .optional(),
+});
+
+export type CreateClientInput = z.input<typeof createClientSchema>;
+export type CreateClientSchema = z.infer<typeof createClientSchema>;
+
+export type UpdateClientInput = z.input<typeof updateClientSchema>;
+export type UpdateClientSchema = z.infer<typeof updateClientSchema>;