@tulip-systems/create-app 0.11.1

package/dist/templates/spark/src/app/admin/purchase-orders/_lib/router.ts

@@ -0,0 +1,456 @@
+import "server-cli-only";
+
+import { ORPCError } from "@orpc/server";
+import { url } from "@tulip-systems/core";
+import { convertEditorContentToHTML, type EditorJSONContent } from "@tulip-systems/editor";
+import {
+  bulkActionSchema,
+  offsetPaginationResponse,
+  offsetPaginationSchema,
+} from "@tulip-systems/query";
+import { getAssetURL } from "@tulip-systems/storage";
+import { and, asc, count, eq, gte, inArray, sql } from "drizzle-orm";
+import z from "zod";
+import { config } from "@/lib/config/base";
+import { getTableData } from "@/lib/helpers/table-data.server";
+import { emails, purchaseOrderItems, suppliers } from "@/server/db/schema";
+import { email } from "@/server/emails/init";
+import { permissionMiddleware } from "@/server/router/middleware";
+import { protectedProcedure } from "@/server/router/procedures";
+import {
+  emailTableDatabaseSortsCompiler,
+  emailTableSortsParser,
+  emailTableSortsSchema,
+} from "../../emails/_config/sorting";
+import { createEmailSchema, sendEmailSchema } from "../../emails/_lib/validators";
+import type { PurchaseOrderEmailTableData } from "../_components/tables";
+import type { PurchaseOrderColumn } from "../_config/columns-data";
+import {
+  purchaseOrderDatabaseFiltersCompiler,
+  purchaseOrderEmailDatabaseFiltersCompiler,
+  purchaseOrderEmailFiltersParser,
+  purchaseOrderFiltersParser,
+  purchaseOrdersEmailsFiltersSchema,
+  purchaseOrdersFiltersSchema,
+} from "../_config/filters";
+import {
+  purchaseOrderTableDatabaseSortsCompiler,
+  purchaseOrderTableSortsParser,
+  purchaseOrderTableSortsSchema,
+} from "../_config/sorting";
+import { purchaseOrderEmailDefaultBody } from "./constants";
+import {
+  generatePurchaseOrderDocument,
+  generatePurchaseOrderNumber,
+  getPurchaseOrderPDFData,
+} from "./helpers.server";
+import { purchaseOrders, purchaseOrdersEmails } from "./schema";
+import {
+  createPurchaseOrderSchema,
+  purchaseOrderStatusSchema,
+  updatePurchaseOrderSchema,
+} from "./validators";
+
+export const purchaseOrdersRouter = {
+  list: protectedProcedure
+    .use(permissionMiddleware({ purchaseOrder: ["view"] }))
+    .input(
+      z.object({
+        pagination: offsetPaginationSchema,
+        filters: purchaseOrdersFiltersSchema,
+        sorts: purchaseOrderTableSortsSchema,
+      }),
+    )
+    .handler(async ({ context, input }) => {
+      const parsedSorts = purchaseOrderTableSortsParser.parse(input.sorts);
+      const orderBy = purchaseOrderTableDatabaseSortsCompiler(purchaseOrders).parse(parsedSorts);
+
+      const parsedFilters = purchaseOrderFiltersParser.parse(input.filters);
+      const where = purchaseOrderDatabaseFiltersCompiler(purchaseOrders).parse(parsedFilters);
+
+      const { data, total } = await getTableData(context, purchaseOrders, {
+        pagination: input.pagination,
+        where,
+        orderBy,
+        with: {
+          supplier: true,
+          project: true,
+          items: { orderBy: asc(purchaseOrderItems.index) },
+        },
+      });
+
+      return offsetPaginationResponse({
+        data: data as PurchaseOrderColumn[],
+        pagination: input.pagination,
+        total,
+      });
+    }),
+  listEmails: protectedProcedure
+    .input(
+      z.object({
+        pagination: offsetPaginationSchema,
+        filters: purchaseOrdersEmailsFiltersSchema,
+        sorts: emailTableSortsSchema,
+      }),
+    )
+    .handler(async ({ context, input }) => {
+      const parsedSorts = emailTableSortsParser.parse(input.sorts);
+      const orderBy = emailTableDatabaseSortsCompiler(emails).parse(parsedSorts);
+
+      const parsedFilters = purchaseOrderEmailFiltersParser
+        .omit({ search: true })
+        .parse(input.filters);
+      const emailWhere =
+        purchaseOrderEmailDatabaseFiltersCompiler(purchaseOrdersEmails).parse(parsedFilters);
+
+      const filteredPurchaseOrderEmails = await context.db
+        .select()
+        .from(purchaseOrdersEmails)
+        .where(emailWhere);
+
+      const emailIds = filteredPurchaseOrderEmails.flatMap(({ emailId }) => emailId);
+      const purchaseOrdersEmailsMap = new Map(
+        filteredPurchaseOrderEmails.map(({ purchaseOrderId, emailId }) => [
+          emailId,
+          purchaseOrderId,
+        ]),
+      );
+
+      const parsedEmailFilters = purchaseOrderEmailFiltersParser
+        .pick({ search: true })
+        .parse(input.filters);
+      const emailSearchWhere = purchaseOrderEmailDatabaseFiltersCompiler({
+        subject: emails.subject,
+        body: emails.body,
+        to: emails.to,
+        cc: emails.cc,
+        bcc: emails.bcc,
+      }).parse(parsedEmailFilters);
+
+      const { data, total } = await getTableData(context, emails, {
+        pagination: input.pagination,
+        where: and(inArray(emails.id, emailIds), emailSearchWhere),
+        orderBy,
+      });
+
+      const emailsData = data
+        .map((email) => ({ ...email, purchaseOrderId: purchaseOrdersEmailsMap.get(email.id) }))
+        .filter((email) => email.purchaseOrderId) as unknown as PurchaseOrderEmailTableData[];
+
+      return offsetPaginationResponse({ data: emailsData, pagination: input.pagination, total });
+    }),
+  getAll: protectedProcedure
+    .use(permissionMiddleware({ purchaseOrder: ["view"] }))
+    .input(z.object({ filters: purchaseOrdersFiltersSchema }))
+    .handler(async ({ context, input: { filters } }) => {
+      const parsedFilters = purchaseOrderFiltersParser.parse(filters);
+      const where = purchaseOrderDatabaseFiltersCompiler(purchaseOrders).parse(parsedFilters);
+
+      const data = await context.db.query.purchaseOrders.findMany({
+        where,
+        with: {
+          supplier: true,
+          project: true,
+          items: { orderBy: asc(purchaseOrderItems.index) },
+        },
+      });
+
+      return data;
+    }),
+  filterSuppliers: protectedProcedure
+    .use(permissionMiddleware({ purchaseOrder: ["view"] }))
+    .input(z.object({ filters: purchaseOrdersFiltersSchema }))
+    .handler(async ({ context, input: { filters } }) => {
+      const parser = purchaseOrderFiltersParser.omit({
+        supplierId: true,
+        projectId: true,
+      });
+      const parsedFilters = parser.parse(filters);
+      const where = purchaseOrderDatabaseFiltersCompiler(purchaseOrders).parse(parsedFilters);
+
+      return context.db
+        .select({
+          value: suppliers.id,
+          label: suppliers.name,
+          total: count(purchaseOrders.id),
+        })
+        .from(suppliers)
+        .leftJoin(purchaseOrders, and(eq(suppliers.id, purchaseOrders.supplierId), where))
+        .where(eq(suppliers.isDeleted, false))
+        .groupBy(suppliers.id)
+        .having(gte(sql<number>`count(${purchaseOrders.id})`, 1))
+        .orderBy(suppliers.name);
+    }),
+  getById: protectedProcedure
+    .use(permissionMiddleware({ purchaseOrder: ["view"] }))
+    .input(z.object({ id: z.string() }))
+    .handler(async ({ context, input: { id } }) => {
+      const data = await context.db.query.purchaseOrders.findFirst({
+        where: eq(purchaseOrders.id, id),
+        with: {
+          supplier: { with: { suppliersContacts: { with: { contact: true } } } },
+          items: { orderBy: asc(purchaseOrderItems.index) },
+        },
+      });
+
+      return data ?? null;
+    }),
+  getPDFData: protectedProcedure
+    .use(permissionMiddleware({ purchaseOrder: ["view"] }))
+    .input(z.object({ id: z.string() }))
+    .handler(async ({ context, input }) => getPurchaseOrderPDFData(context, input)),
+  create: protectedProcedure
+    .use(permissionMiddleware({ purchaseOrder: ["create"] }))
+    .input(createPurchaseOrderSchema)
+    .handler(async ({ context, input }) => {
+      const number = await generatePurchaseOrderNumber(context);
+
+      const [result] = await context.db
+        .insert(purchaseOrders)
+        .values({ ...input, number })
+        .returning();
+
+      if (!result) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Bestelling kon niet worden toegevoegd",
+        });
+      }
+
+      return result;
+    }),
+  update: protectedProcedure
+    .use(permissionMiddleware({ purchaseOrder: ["update"] }))
+    .input(z.object({ id: z.string(), data: updatePurchaseOrderSchema.partial() }))
+    .output(z.void())
+    .handler(async ({ context, input }) => {
+      const [result] = await context.db
+        .update(purchaseOrders)
+        .set(input.data)
+        .where(eq(purchaseOrders.id, input.id))
+        .returning();
+
+      if (!result) {
+        throw new ORPCError("NOT_FOUND", {
+          message: "Project kon niet worden gewijzigd",
+        });
+      }
+    }),
+  copy: protectedProcedure
+    .use(permissionMiddleware({ purchaseOrder: ["create"] }))
+    .input(z.object({ id: z.string() }))
+    .handler(async ({ context, input }) => {
+      const [previousOrder] = await context.db
+        .select()
+        .from(purchaseOrders)
+        .where(eq(purchaseOrders.id, input.id));
+      if (!previousOrder) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Bestelling kon niet worden toegevoegd",
+        });
+      }
+
+      const previousOrderItems = await context.db
+        .select({
+          price: purchaseOrderItems.price,
+          quantity: purchaseOrderItems.quantity,
+          productId: purchaseOrderItems.productId,
+          index: purchaseOrderItems.index,
+        })
+        .from(purchaseOrderItems)
+        .where(eq(purchaseOrderItems.purchaseOrderId, input.id));
+
+      const number = await generatePurchaseOrderNumber(context);
+
+      return await context.db.transaction(async (tx) => {
+        const [result] = await tx
+          .insert(purchaseOrders)
+          .values({
+            number,
+            status: "draft",
+            supplierId: previousOrder.supplierId,
+            projectId: previousOrder.projectId,
+          })
+          .returning();
+
+        if (!result) {
+          throw new ORPCError("INTERNAL_SERVER_ERROR", {
+            message: "Bestelling kon niet worden toegevoegd",
+          });
+        }
+
+        await Promise.allSettled(
+          previousOrderItems.map((item) =>
+            tx.insert(purchaseOrderItems).values({ ...item, purchaseOrderId: result.id }),
+          ),
+        );
+
+        return result;
+      });
+    }),
+  setStatus: protectedProcedure
+    .use(permissionMiddleware({ purchaseOrder: ["update"] }))
+    .input(bulkActionSchema.extend({ status: purchaseOrderStatusSchema }))
+    .handler(async ({ context, input: { ids, status } }) => {
+      await context.db
+        .update(purchaseOrders)
+        .set({ status })
+        .where(inArray(purchaseOrders.id, ids));
+    }),
+  archive: protectedProcedure
+    .use(permissionMiddleware({ purchaseOrder: ["archive"] }))
+    .input(bulkActionSchema)
+    .handler(async ({ context, input: { ids } }) => {
+      await context.db
+        .update(purchaseOrders)
+        .set({ isDeleted: true })
+        .where(inArray(purchaseOrders.id, ids));
+    }),
+  restore: protectedProcedure
+    .use(permissionMiddleware({ purchaseOrder: ["archive"] }))
+    .input(bulkActionSchema)
+    .handler(async ({ context, input: { ids } }) => {
+      await context.db
+        .update(purchaseOrders)
+        .set({ isDeleted: false })
+        .where(inArray(purchaseOrders.id, ids));
+    }),
+  delete: protectedProcedure
+    .use(permissionMiddleware({ purchaseOrder: ["delete"] }))
+    .input(bulkActionSchema)
+    .handler(async ({ context, input: { ids } }) => {
+      await context.db.delete(purchaseOrders).where(inArray(purchaseOrders.id, ids));
+    }),
+  createEmail: protectedProcedure
+    .use(permissionMiddleware({ email: ["create"] }))
+    .input(createEmailSchema.extend({ purchaseOrderId: z.string() }))
+    .handler(async ({ context, input }) => {
+      const { purchaseOrderId, ...emailData } = input;
+      const result = await context.db.transaction(async (tx) => {
+        const [purchaseOrder] = await tx
+          .select()
+          .from(purchaseOrders)
+          .where(eq(purchaseOrders.id, purchaseOrderId));
+
+        if (!purchaseOrder) {
+          throw new ORPCError("NOT_FOUND", {
+            message: "Bestelling kon niet worden gevonden",
+          });
+        }
+
+        const [email] = await tx
+          .insert(emails)
+          .values({
+            ...emailData,
+            status: "draft",
+            subject: `Tulip Bestelling ${purchaseOrder.number}`,
+            bcc: [],
+            body: purchaseOrderEmailDefaultBody,
+          })
+          .returning();
+
+        if (!email) {
+          throw new ORPCError("INTERNAL_SERVER_ERROR", {
+            message: "E-mail kon niet worden aangemaakt",
+          });
+        }
+
+        await tx.insert(purchaseOrdersEmails).values({
+          purchaseOrderId,
+          emailId: email.id,
+        });
+
+        return email;
+      });
+
+      return result;
+    }),
+  sendEmail: protectedProcedure
+    .input(z.object({ id: z.string() }))
+    .handler(async ({ context, input }) => {
+      /**
+       * Get email
+       */
+      const data = await context.db.query.emails.findFirst({
+        where: eq(emails.id, input.id),
+        with: { attachments: { with: { asset: true } } },
+      });
+
+      /**
+       * Validate email
+       */
+      const parsed = sendEmailSchema.safeParse(data);
+      if (!parsed.success) {
+        throw new ORPCError("BAD_REQUEST", {
+          message: parsed.error.message,
+        });
+      }
+
+      const { to, subject, body, cc, bcc, attachments } = parsed.data;
+
+      /**
+       * Generate PDF
+       */
+      const purchaseOrderEmail = await context.db.query.purchaseOrdersEmails.findFirst({
+        where: eq(purchaseOrdersEmails.emailId, input.id),
+      });
+
+      if (!purchaseOrderEmail) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Bestelling kon niet worden gegenereerd",
+        });
+      }
+
+      const pdfData = await getPurchaseOrderPDFData(context, {
+        id: purchaseOrderEmail.purchaseOrderId,
+      });
+
+      if (!pdfData) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Bestelling kon niet worden gegenereerd",
+        });
+      }
+
+      const document = await generatePurchaseOrderDocument(pdfData);
+
+      /**
+       * Send email
+       */
+      const result = await email.emails.send({
+        from: config.email.defaultFrom,
+        to,
+        subject,
+        cc: cc ?? undefined,
+        bcc: bcc ?? undefined,
+        html: convertEditorContentToHTML(body as EditorJSONContent),
+        attachments: [
+          {
+            filename: `${pdfData.number}.pdf`,
+            content: document,
+          },
+          ...(attachments?.flatMap(({ asset }) => ({
+            filename: asset.name,
+            path: url(getAssetURL(asset.id, { disposition: "attachment" })),
+          })) ?? []),
+        ],
+      });
+
+      if (result.error) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: result.error.message,
+        });
+      }
+
+      /**
+       * Update email status
+       * */
+      await context.db
+        .update(emails)
+        .set({ status: "sent", sentAt: new Date() })
+        .where(eq(emails.id, input.id));
+
+      await context.db
+        .update(purchaseOrders)
+        .set({ status: "sent" })
+        .where(eq(purchaseOrders.id, purchaseOrderEmail.purchaseOrderId));
+    }),
+};

package/dist/templates/spark/src/app/admin/purchase-orders/_lib/schema.ts

@@ -0,0 +1,69 @@
+import type { EditorJSONContent } from "@tulip-systems/editor";
+import { relations } from "drizzle-orm";
+import { pgEnum, pgTable, uuid } from "drizzle-orm/pg-core";
+import { baseColumns } from "@/server/db/helpers";
+import { emails, projects, purchaseOrderItems, suppliers } from "@/server/db/schema";
+
+/**
+ * Purchase order status
+ */
+export const purchaseOrderStatusEnum = pgEnum("purchase_order_status", [
+  "draft",
+  "sent",
+  "received",
+  "paid",
+]);
+
+/**
+ * Purchase orders table
+ */
+export const purchaseOrders = pgTable("purchase_orders", (t) => ({
+  ...baseColumns,
+  number: t.text().notNull().unique(),
+  status: purchaseOrderStatusEnum().default("draft").notNull(),
+  sentDate: t.timestamp(),
+  notes: t.jsonb().$type<EditorJSONContent>(),
+  isDeleted: t.boolean().default(false).notNull(),
+  projectId: uuid().references(() => projects.id, { onDelete: "restrict" }),
+  supplierId: uuid()
+    .notNull()
+    .references(() => suppliers.id, { onDelete: "restrict" }),
+}));
+
+export const purchaseOrdersRelations = relations(purchaseOrders, ({ one, many }) => ({
+  items: many(purchaseOrderItems),
+  supplier: one(suppliers, {
+    fields: [purchaseOrders.supplierId],
+    references: [suppliers.id],
+  }),
+  project: one(projects, {
+    fields: [purchaseOrders.projectId],
+    references: [projects.id],
+  }),
+}));
+
+/**
+ * PurchaseOrders Emails table
+ */
+export const purchaseOrdersEmails = pgTable("purchase_orders_emails", (t) => ({
+  ...baseColumns,
+  purchaseOrderId: t
+    .uuid()
+    .notNull()
+    .references(() => purchaseOrders.id, { onDelete: "cascade" }),
+  emailId: t
+    .uuid()
+    .notNull()
+    .references(() => emails.id, { onDelete: "cascade" }),
+}));
+
+export const purchaseOrdersEmailsRelations = relations(purchaseOrdersEmails, ({ one }) => ({
+  purchaseOrder: one(purchaseOrders, {
+    fields: [purchaseOrdersEmails.purchaseOrderId],
+    references: [purchaseOrders.id],
+  }),
+  email: one(emails, {
+    fields: [purchaseOrdersEmails.emailId],
+    references: [emails.id],
+  }),
+}));

package/dist/templates/spark/src/app/admin/purchase-orders/_lib/validators.ts

@@ -0,0 +1,43 @@
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from "drizzle-zod";
+import { z } from "zod";
+
+export type {
+  PurchaseOrdersEmailsFiltersSchema,
+  PurchaseOrdersFilters,
+} from "../_config/filters";
+export {
+  purchaseOrdersEmailsFiltersSchema,
+  purchaseOrdersFiltersSchema,
+} from "../_config/filters";
+
+import { purchaseOrderStatusEnum, purchaseOrders } from "./schema";
+
+/**
+ * PurchaseOrder type
+ */
+export type PurchaseOrder = typeof purchaseOrders.$inferSelect;
+
+export const selectPurchaseOrderSchema = createSelectSchema(purchaseOrders);
+export type SelectPurchaseOrderSchema = z.infer<typeof selectPurchaseOrderSchema>;
+
+/**
+ * Schema
+ */
+export const createPurchaseOrderSchema = createInsertSchema(purchaseOrders).omit({ number: true });
+
+export const updatePurchaseOrderSchema = createUpdateSchema(purchaseOrders);
+
+/**
+ * Status
+ */
+export const purchaseOrderStatusSchema = z.enum(purchaseOrderStatusEnum.enumValues);
+export type PurchaseOrderStatus = z.infer<typeof purchaseOrderStatusSchema>;
+
+export type UpdatePurchaseOrderInput = z.input<typeof updatePurchaseOrderSchema>;
+export type UpdatePurchaseOrderSchema = z.infer<typeof updatePurchaseOrderSchema>;
+
+/**
+ * Create purchaseOrder schema
+ */
+export type CreatePurchaseOrderInput = z.input<typeof createPurchaseOrderSchema>;
+export type CreatePurchaseOrderSchema = z.infer<typeof createPurchaseOrderSchema>;

package/dist/templates/spark/src/app/admin/purchase-orders/emails/layout.tsx

@@ -0,0 +1,22 @@
+import { Header, Topbar, TopbarTitle } from "@tulip-systems/app/components/client";
+import { TableLayout } from "@tulip-systems/data-tables";
+import type { PropsWithChildren } from "react";
+
+export default async function Layout({ children }: PropsWithChildren) {
+  return (
+    <>
+      <Header>
+        <Topbar>
+          <TopbarTitle
+            breadcrumbs={[
+              { label: "Bestellingen", href: "/admin/purchase-orders" },
+              { label: "Emails" },
+            ]}
+          />
+        </Topbar>
+      </Header>
+
+      <TableLayout className="p-content">{children}</TableLayout>
+    </>
+  );
+}

package/dist/templates/spark/src/app/admin/purchase-orders/emails/page.tsx

@@ -0,0 +1,20 @@
+import { Allowed } from "@tulip-systems/auth/permissions/client";
+import { DataTable } from "@tulip-systems/data-tables/client";
+import { emailTableCommands } from "@/app/admin/emails/_components/tables";
+import { EmailTableToolbar } from "@/app/admin/emails/_components/toolbars";
+import { PurchaseOrderEmailsPaginationTableProvider } from "../_components/tables";
+import { purchaseOrderEmailsColumns } from "../_config/columns-data";
+
+export default async function Page() {
+  return (
+    <Allowed permission={{ email: ["view"] }}>
+      <PurchaseOrderEmailsPaginationTableProvider
+        columns={purchaseOrderEmailsColumns}
+        commands={emailTableCommands}
+      >
+        <EmailTableToolbar />
+        <DataTable />
+      </PurchaseOrderEmailsPaginationTableProvider>
+    </Allowed>
+  );
+}