@tulip-systems/create-app 0.11.1

package/dist/templates/spark/src/app/admin/sales-invoices/_lib/router.ts

@@ -0,0 +1,431 @@
+import "server-cli-only";
+
+import { ORPCError } from "@orpc/server";
+import {
+  bulkActionSchema,
+  offsetPaginationResponse,
+  offsetPaginationSchema,
+} from "@tulip-systems/query";
+import { addDays } from "date-fns";
+import Decimal from "decimal.js";
+import { and, asc, count, desc, eq, gte, inArray, sql } from "drizzle-orm";
+import z from "zod";
+import { config } from "@/lib/config/base";
+import { calculateNetAmount } from "@/lib/helpers/calculate";
+import { getTableData } from "@/lib/helpers/table-data.server";
+import {
+  addresses,
+  clients,
+  salesOrderExecutions,
+  salesOrderItems,
+  salesOrders,
+} from "@/server/db/schema";
+import { permissionMiddleware } from "@/server/router/middleware";
+import { protectedProcedure } from "@/server/router/procedures";
+import { salesInvoiceItems } from "../../sales-invoice-items/_lib/schema";
+import type { SalesInvoiceTableData } from "../_components/tables";
+import {
+  salesInvoiceDatabaseFiltersCompiler,
+  salesInvoiceFiltersParser,
+  salesInvoicesFiltersSchema,
+} from "../_config/filters";
+import {
+  salesInvoiceTableDatabaseSortsCompiler,
+  salesInvoiceTableSortsParser,
+  salesInvoiceTableSortsSchema,
+} from "../_config/sorting";
+import {
+  generateSalesInvoiceExecutionsDescription,
+  generateSalesInvoicePaymentStatement,
+} from "./helpers";
+import { generateSalesInvoiceNumber } from "./helpers.server";
+import { salesInvoices } from "./schema";
+import { salesInvoiceStatusSchema, updateSalesInvoiceSchema } from "./validators";
+
+export const salesInvoicesRouter = {
+  list: protectedProcedure
+    .use(permissionMiddleware({ salesInvoice: ["view"] }))
+    .input(
+      z.object({
+        pagination: offsetPaginationSchema,
+        filters: salesInvoicesFiltersSchema,
+        sorts: salesInvoiceTableSortsSchema,
+      }),
+    )
+    .handler(async ({ context, input }) => {
+      const parsedSorts = salesInvoiceTableSortsParser.parse(input.sorts);
+      const orderBy = salesInvoiceTableDatabaseSortsCompiler(salesInvoices).parse(parsedSorts);
+
+      const parsedFilters = salesInvoiceFiltersParser.parse(input.filters);
+      const where = salesInvoiceDatabaseFiltersCompiler(salesInvoices).parse(parsedFilters);
+
+      const { data, total } = await getTableData(context, salesInvoices, {
+        pagination: input.pagination,
+        where,
+        orderBy,
+        with: {
+          client: true,
+          salesOrder: true,
+          items: { orderBy: asc(salesInvoiceItems.index) },
+        },
+      });
+
+      return offsetPaginationResponse({
+        data: data as SalesInvoiceTableData[],
+        pagination: input.pagination,
+        total,
+      });
+    }),
+  filterClients: protectedProcedure
+    .use(permissionMiddleware({ salesInvoice: ["view"] }))
+    .input(z.object({ filters: salesInvoicesFiltersSchema }))
+    .handler(async ({ context, input: { filters } }) => {
+      const parsedFilters = salesInvoiceFiltersParser.omit({ clientId: true }).parse(filters);
+      const where = salesInvoiceDatabaseFiltersCompiler(salesInvoices).parse(parsedFilters);
+
+      return context.db
+        .select({
+          value: clients.id,
+          label: clients.name,
+          total: count(salesInvoices.id),
+        })
+        .from(clients)
+        .leftJoin(salesInvoices, and(eq(clients.id, salesInvoices.clientId), where))
+        .where(eq(clients.isDeleted, false))
+        .groupBy(clients.id)
+        .having(gte(sql<number>`count(${salesInvoices.id})`, 1))
+        .orderBy(clients.name);
+    }),
+  getById: protectedProcedure
+    .use(permissionMiddleware({ salesInvoice: ["view"] }))
+    .input(z.object({ id: z.string() }))
+    .handler(async ({ context, input: { id } }) => {
+      const data = await context.db.query.salesInvoices.findFirst({
+        where: eq(salesInvoices.id, id),
+        with: {
+          items: { orderBy: asc(salesInvoiceItems.index) },
+          fromAddress: true,
+          toAddress: true,
+          client: true,
+          salesOrder: true,
+        },
+      });
+
+      return data ?? null;
+    }),
+  getPDFData: protectedProcedure
+    .use(permissionMiddleware({ salesInvoice: ["view"] }))
+    .input(z.object({ id: z.string() }))
+    .handler(async ({ context, input }) => {
+      const data = await context.db.query.salesInvoices.findFirst({
+        where: eq(salesInvoices.id, input.id),
+        with: {
+          items: { orderBy: asc(salesInvoiceItems.index) },
+          client: {
+            with: {
+              clientsAddresses: { with: { address: true } },
+              clientsContacts: { with: { contact: true } },
+            },
+          },
+          toAddress: true,
+          fromAddress: true,
+        },
+      });
+
+      return data ?? null;
+    }),
+  create: protectedProcedure
+    .use(permissionMiddleware({ salesInvoice: ["create"] }))
+    .input(z.object({ salesOrderId: z.string() }))
+    .handler(async ({ context, input }) => {
+      const salesOrder = await context.db.query.salesOrders.findFirst({
+        where: eq(salesOrders.id, input.salesOrderId),
+        with: {
+          items: { orderBy: asc(salesOrderItems.index) },
+          executions: { orderBy: asc(salesOrderExecutions.index) },
+          invoice: { with: { items: true, fromAddress: true, toAddress: true } },
+          client: {
+            with: {
+              companyDetails: true,
+              clientsAddresses: { with: { address: true } },
+              clientsContacts: { with: { contact: true } },
+            },
+          },
+        },
+      });
+
+      if (!salesOrder) {
+        throw new ORPCError("NOT_FOUND", {
+          message: "Verkoopbon kon niet worden toegevoegd",
+        });
+      }
+
+      if (salesOrder.invoice?.status === "sent") {
+        throw new ORPCError("NOT_FOUND", {
+          message: "Deze verkoopbon is al gefactureerd, je mag dit factuur niet meer aanpassen",
+        });
+      }
+
+      const clientAddresses = salesOrder.client.clientsAddresses.map(({ address }) => address);
+      const billingAddress = clientAddresses?.find((address) => address.type === "billing");
+      const defaultAddress = clientAddresses?.find((address) => address.type === "default");
+      const address = billingAddress ?? defaultAddress ?? clientAddresses?.[0];
+
+      if (!address) {
+        throw new ORPCError("NOT_FOUND", {
+          message: "De klant heeft geen factuuradres",
+        });
+      }
+
+      /**
+       * If the invoice is already created, we need to update it
+       */
+      if (salesOrder.invoice) {
+        return await context.db.transaction(async (tx) => {
+          /**
+           * Create addresses
+           */
+          const [toAddress, fromAddress] = await tx
+            .insert(addresses)
+            .values([
+              {
+                title: address.title,
+                type: address.type,
+                street: address.street,
+                postalCode: address.postalCode,
+                city: address.city,
+                countryCode: address.countryCode,
+              },
+              config.organisation.address,
+            ])
+            .returning();
+
+          if (!toAddress || !fromAddress) {
+            throw new ORPCError("INTERNAL_SERVER_ERROR", {
+              message: "Factuur kon niet worden gecreerd",
+            });
+          }
+
+          /**
+           * Update salesInvoice
+           */
+          const [invoice] = await tx
+            .update(salesInvoices)
+            .set({
+              title: salesOrder.title,
+              issueDate: new Date(),
+              dueDate: addDays(new Date(), salesOrder.client.paymentTerm ?? 30),
+              // To values
+              toName: salesOrder.client.name,
+              toVatNumber: salesOrder.client.companyDetails?.vatNumber,
+              toAddressId: toAddress.id,
+              // From values
+              fromName: config.organisation.name,
+              fromVatNumber: config.organisation.vatNumber,
+              fromAddressId: fromAddress.id,
+              // Relations
+              clientId: salesOrder.clientId,
+              salesOrderId: salesOrder.id,
+            })
+            .where(eq(salesInvoices.id, salesOrder.invoice.id))
+            .returning();
+
+          if (!invoice) {
+            throw new ORPCError("INTERNAL_SERVER_ERROR", {
+              message: "Factuur kon niet worden aangepast",
+            });
+          }
+
+          /**
+           * Delete old invoice addresses
+           */
+          await tx.delete(addresses).where(eq(addresses.id, salesOrder.invoice.fromAddressId));
+          await tx.delete(addresses).where(eq(addresses.id, salesOrder.invoice.toAddressId));
+
+          /**
+           * Delete old salesInvoice items
+           */
+          await tx
+            .delete(salesInvoiceItems)
+            .where(eq(salesInvoiceItems.salesInvoiceId, salesOrder.invoice.id));
+
+          /**
+           * Create salesInvoice items
+           */
+          await tx.insert(salesInvoiceItems).values([
+            ...salesOrder.items.map((item) => ({
+              articleNumber: item.articleNumber,
+              description: item.description,
+              price: item.price,
+              quantity: item.netQuantity,
+              vatRate: item.vatRate,
+              index: item.index,
+              salesInvoiceId: invoice.id,
+            })),
+            {
+              articleNumber: "Prestaties",
+              description: generateSalesInvoiceExecutionsDescription({ salesOrder }),
+              price: calculateNetAmount(salesOrder.executions).toFixed(3),
+              quantity: new Decimal(1).toFixed(3),
+              vatRate: salesOrder.client.vatRate,
+              index: salesOrder.items.length,
+              salesInvoiceId: invoice.id,
+            },
+          ]);
+
+          /**
+           * Update salesOrder status
+           */
+          await tx
+            .update(salesOrders)
+            .set({ status: "invoiced" })
+            .where(eq(salesOrders.id, salesOrder.id));
+
+          return invoice;
+        });
+      }
+
+      /**
+       * If the invoice is not created, we need to create it
+       */
+      const number = await generateSalesInvoiceNumber(context);
+      const paymentStatement = generateSalesInvoicePaymentStatement(number);
+
+      return await context.db.transaction(async (tx) => {
+        /**
+         * Create addresses
+         */
+        const [toAddress, fromAddress] = await tx
+          .insert(addresses)
+          .values([
+            {
+              title: address.title,
+              type: address.type,
+              street: address.street,
+              postalCode: address.postalCode,
+              city: address.city,
+              countryCode: address.countryCode,
+            },
+            config.organisation.address,
+          ])
+          .returning();
+
+        if (!toAddress || !fromAddress) {
+          throw new ORPCError("INTERNAL_SERVER_ERROR", {
+            message: "Factuur kon niet worden gecreerd",
+          });
+        }
+
+        /**
+         * Create salesInvoice
+         */
+        const [invoice] = await tx
+          .insert(salesInvoices)
+          .values({
+            number,
+            paymentStatement,
+            title: salesOrder.title,
+            issueDate: new Date(),
+            dueDate: addDays(new Date(), salesOrder.client.paymentTerm ?? 30),
+            // To values
+            toName: salesOrder.client.name,
+            toVatNumber: salesOrder.client.companyDetails?.vatNumber,
+            toAddressId: toAddress.id,
+            // From values
+            fromName: config.organisation.name,
+            fromVatNumber: config.organisation.vatNumber,
+            fromAddressId: fromAddress.id,
+            clientId: salesOrder.clientId,
+            salesOrderId: salesOrder.id,
+          })
+          .returning();
+
+        if (!invoice) {
+          throw new ORPCError("INTERNAL_SERVER_ERROR", {
+            message: "Factuur kon niet worden gecreerd",
+          });
+        }
+
+        /**
+         * Create salesInvoice items
+         */
+        await tx.insert(salesInvoiceItems).values([
+          ...salesOrder.items.map((item) => ({
+            articleNumber: item.articleNumber,
+            description: item.description,
+            price: item.price,
+            quantity: item.netQuantity,
+            vatRate: item.vatRate,
+            index: item.index,
+            salesInvoiceId: invoice.id,
+          })),
+          {
+            articleNumber: "Prestaties",
+            description: generateSalesInvoiceExecutionsDescription({ salesOrder }),
+            price: calculateNetAmount(salesOrder.executions).toFixed(3),
+            quantity: new Decimal(1).toFixed(3),
+            vatRate: salesOrder.client.vatRate,
+            index: salesOrder.items.length,
+            salesInvoiceId: invoice.id,
+          },
+        ]);
+
+        /**
+         * Update salesOrder status
+         */
+        await tx
+          .update(salesOrders)
+          .set({ status: "invoiced" })
+          .where(eq(salesOrders.id, salesOrder.id));
+
+        return invoice;
+      });
+    }),
+  update: protectedProcedure
+    .use(permissionMiddleware({ salesInvoice: ["update"] }))
+    .input(z.object({ id: z.string(), data: updateSalesInvoiceSchema.partial() }))
+    .output(z.void())
+    .handler(async ({ context, input }) => {
+      const [result] = await context.db
+        .update(salesInvoices)
+        .set(input.data)
+        .where(eq(salesInvoices.id, input.id))
+        .returning();
+
+      if (!result) {
+        throw new ORPCError("NOT_FOUND", {
+          message: "Project kon niet worden gewijzigd",
+        });
+      }
+    }),
+  setStatus: protectedProcedure
+    .use(permissionMiddleware({ salesInvoice: ["update"] }))
+    .input(bulkActionSchema.extend({ status: salesInvoiceStatusSchema }))
+    .handler(async ({ context, input: { ids, status } }) => {
+      await context.db.update(salesInvoices).set({ status }).where(inArray(salesInvoices.id, ids));
+    }),
+  delete: protectedProcedure
+    .use(permissionMiddleware({ salesInvoice: ["delete"] }))
+    .input(z.object({ id: z.string() }))
+    .handler(async ({ context, input: { id } }) => {
+      const [lastSalesInvoice] = await context.db
+        .select({ id: salesInvoices.id })
+        .from(salesInvoices)
+        .orderBy(desc(salesInvoices.number))
+        .limit(1);
+
+      if (!lastSalesInvoice) {
+        throw new ORPCError("NOT_FOUND", {
+          message: "Geen facturen gevonden",
+        });
+      }
+
+      if (lastSalesInvoice.id !== id) {
+        throw new ORPCError("BAD_REQUEST", {
+          message: "Factuur mag niet worden verwijderd",
+        });
+      }
+
+      await context.db.delete(salesInvoices).where(eq(salesInvoices.id, id));
+    }),
+};

package/dist/templates/spark/src/app/admin/sales-invoices/_lib/schema-enums.ts

@@ -0,0 +1,3 @@
+import { pgEnum } from "drizzle-orm/pg-core";
+
+export const salesInvoiceStatusEnum = pgEnum("sales_invoice_status", ["draft", "sent", "paid"]);

package/dist/templates/spark/src/app/admin/sales-invoices/_lib/schema.ts

@@ -0,0 +1,62 @@
+import type { EditorJSONContent } from "@tulip-systems/editor";
+import { relations } from "drizzle-orm";
+import { type AnyPgColumn, pgTable, uuid } from "drizzle-orm/pg-core";
+import { baseColumns } from "@/server/db/helpers";
+import { addresses, salesOrders } from "@/server/db/schema";
+import { clients } from "../../clients/_lib/schema";
+import { salesInvoiceItems } from "../../sales-invoice-items/_lib/schema";
+import { salesInvoiceStatusEnum } from "./schema-enums";
+
+/**
+ * Table
+ */
+export const salesInvoices = pgTable("sales_invoices", (t) => ({
+  ...baseColumns,
+  title: t.text().notNull(),
+  number: t.text().notNull().unique(),
+  status: salesInvoiceStatusEnum().default("draft").notNull(),
+  issueDate: t.timestamp({ mode: "date" }),
+  dueDate: t.timestamp({ mode: "date" }),
+  sentDate: t.timestamp({ mode: "date" }),
+  notes: t.jsonb().$type<EditorJSONContent>(),
+  paymentStatement: t.text().notNull(),
+  // From values
+  fromName: t.text().notNull(),
+  fromVatNumber: t.text().notNull(),
+  fromAddressId: t
+    .uuid()
+    .notNull()
+    .references(() => addresses.id, { onDelete: "restrict" }),
+  // To values
+  toName: t.text().notNull(),
+  toVatNumber: t.text(),
+  toAddressId: t
+    .uuid()
+    .notNull()
+    .references(() => addresses.id, { onDelete: "restrict" }),
+  // Relations
+  salesOrderId: t.uuid().references((): AnyPgColumn => salesOrders.id, { onDelete: "restrict" }),
+  clientId: uuid()
+    .notNull()
+    .references(() => clients.id, { onDelete: "restrict" }),
+}));
+
+export const salesInvoicesRelations = relations(salesInvoices, ({ one, many }) => ({
+  items: many(salesInvoiceItems),
+  fromAddress: one(addresses, {
+    fields: [salesInvoices.fromAddressId],
+    references: [addresses.id],
+  }),
+  toAddress: one(addresses, {
+    fields: [salesInvoices.toAddressId],
+    references: [addresses.id],
+  }),
+  salesOrder: one(salesOrders, {
+    fields: [salesInvoices.salesOrderId],
+    references: [salesOrders.id],
+  }),
+  client: one(clients, {
+    fields: [salesInvoices.clientId],
+    references: [clients.id],
+  }),
+}));

package/dist/templates/spark/src/app/admin/sales-invoices/_lib/validators.ts

@@ -0,0 +1,34 @@
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from "drizzle-zod";
+import { z } from "zod";
+
+export type { SalesInvoicesFilters } from "../_config/filters";
+export { salesInvoicesFiltersSchema } from "../_config/filters";
+
+import { salesInvoices } from "./schema";
+import { salesInvoiceStatusEnum } from "./schema-enums";
+
+/**
+ * SalesInvoice type
+ */
+export type SalesInvoice = typeof salesInvoices.$inferSelect;
+
+export const selectSalesInvoiceSchema = createSelectSchema(salesInvoices);
+export type SelectSalesInvoiceSchema = z.infer<typeof selectSalesInvoiceSchema>;
+
+/**
+ * Schema
+ */
+export const createSalesInvoiceSchema = createInsertSchema(salesInvoices).omit({ number: true });
+export const updateSalesInvoiceSchema = createUpdateSchema(salesInvoices);
+
+export type CreateSalesInvoiceInput = z.input<typeof createSalesInvoiceSchema>;
+export type CreateSalesInvoiceSchema = z.infer<typeof createSalesInvoiceSchema>;
+
+export type UpdateSalesInvoiceInput = z.input<typeof updateSalesInvoiceSchema>;
+export type UpdateSalesInvoiceSchema = z.infer<typeof updateSalesInvoiceSchema>;
+
+/**
+ * Status
+ */
+export const salesInvoiceStatusSchema = z.enum(salesInvoiceStatusEnum.enumValues);
+export type SalesInvoiceStatus = z.infer<typeof salesInvoiceStatusSchema>;

package/dist/templates/spark/src/app/admin/sales-order-executions/_components/tables.tsx

@@ -0,0 +1,155 @@
+"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 { Execution } from "../../executions/_lib/validators";
+import type { Registration } from "../../registrations/_lib/validators";
+import { salesOrderExecutionsFilters } from "../_config/filters";
+import { salesOrderExecutionTableSorts } from "../_config/sorting";
+import type { SalesOrderExecution } from "../_lib/validators";
+
+export type SalesOrderExecutionTableData = SalesOrderExecution & {
+  execution: Execution & { executionsRegistrations: { registration: Registration }[] };
+};
+//  & { employee: Employee & { user: User } };
+
+/**
+ * Client data table
+ */
+type SalesOrderExecutionTableProviderProps<TData extends SalesOrderExecutionTableData> = {
+  columns: TableColumnDef<TData>[];
+  commands?: CommandFor<TData[]>[];
+  filterOptions?: UseFiltersOptions<typeof salesOrderExecutionsFilters>;
+  columnVisibility?: VisibilityState;
+};
+
+export function SalesOrderExecutionInfiniteTableProvider({
+  columns,
+  commands,
+  filterOptions,
+  columnVisibility,
+
+  children,
+}: PropsWithChildren<SalesOrderExecutionTableProviderProps<SalesOrderExecutionTableData>>) {
+  const pagination = usePagination(offsetPagination);
+  const filtering = useFilters(salesOrderExecutionsFilters, filterOptions);
+  const sorting = useSorting(salesOrderExecutionTableSorts);
+
+  const input = useDeferredValue({
+    pagination: pagination.input,
+    filters: filtering.input,
+    sorts: sorting.input,
+  });
+
+  /**
+   * Data
+   */
+  const response = useSuspenseInfiniteQuery(
+    orpc.salesOrderExecutions.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<SalesOrderExecutionTableData>({
+    queryData,
+    getRowId: (row) => row.id,
+    columns,
+    strategy,
+    filtering,
+    sorting,
+    commands,
+    columnVisibility,
+  });
+
+  return <TableConfigProvider config={config}>{children}</TableConfigProvider>;
+}
+
+export function SalesOrderExecutionPaginationTableProvider({
+  columns,
+  commands,
+  filterOptions,
+  columnVisibility,
+
+  children,
+}: PropsWithChildren<SalesOrderExecutionTableProviderProps<SalesOrderExecutionTableData>>) {
+  const pagination = usePagination(offsetPagination);
+  const filtering = useFilters(salesOrderExecutionsFilters, filterOptions);
+  const sorting = useSorting(salesOrderExecutionTableSorts);
+
+  const input = useDeferredValue({
+    pagination: pagination.input,
+    filters: filtering.input,
+    sorts: sorting.input,
+  });
+
+  /**
+   * Data
+   */
+  const response = useSuspenseQuery(orpc.salesOrderExecutions.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<SalesOrderExecutionTableData>({
+    queryData,
+    getRowId: (row) => row.id,
+    columns,
+    strategy,
+    sorting,
+    commands,
+    columnVisibility,
+  });
+
+  return <TableConfigProvider config={config}>{children}</TableConfigProvider>;
+}