@tulip-systems/create-app 0.11.1

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

@@ -0,0 +1,614 @@
+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, desc, eq, exists, 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 {
+  assignments,
+  clients,
+  emails,
+  executions,
+  quotationItems,
+  quotations,
+  salesOrderExecutions,
+} 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 { calculateTotalDuration } from "../../registrations/_lib/helpers";
+import { salesOrderItems } from "../../sales-order-items/_lib/schema";
+import type { SalesOrderItem } from "../../sales-order-items/_lib/validators";
+import type { SalesOrderEmailTableData, SalesOrderTableData } from "../_components/tables";
+import {
+  salesOrderDatabaseFiltersCompiler,
+  salesOrderEmailDatabaseFiltersCompiler,
+  salesOrderEmailFiltersParser,
+  salesOrderFiltersParser,
+  salesOrdersEmailsFiltersSchema,
+  salesOrdersFiltersSchema,
+} from "../_config/filters";
+import {
+  salesOrderTableDatabaseSortsCompiler,
+  salesOrderTableSortsParser,
+  salesOrderTableSortsSchema,
+} from "../_config/sorting";
+import { salesOrderEmailDefaultBody } from "./constants";
+import {
+  generateSalesOrderDocument,
+  generateSalesOrderNumber,
+  getSalesOrderPDFData,
+} from "./helpers.server";
+import { salesOrders, salesOrdersEmails } from "./schema";
+import {
+  createSalesOrderSchema,
+  salesOrderStatusSchema,
+  updateSalesOrderSchema,
+} from "./validators";
+
+export const salesOrdersRouter = {
+  list: protectedProcedure
+    .use(permissionMiddleware({ salesOrder: ["view"] }))
+    .input(
+      z.object({
+        pagination: offsetPaginationSchema,
+        filters: salesOrdersFiltersSchema,
+        sorts: salesOrderTableSortsSchema,
+      }),
+    )
+    .handler(async ({ context, input }) => {
+      const parsedSorts = salesOrderTableSortsParser.parse(input.sorts);
+      const orderBy = salesOrderTableDatabaseSortsCompiler(salesOrders).parse(parsedSorts);
+
+      const parsedFilters = salesOrderFiltersParser.parse(input.filters);
+      const where = salesOrderDatabaseFiltersCompiler({
+        number: salesOrders.number,
+        title: salesOrders.title,
+        notes: salesOrders.notes,
+        clientId: salesOrders.clientId,
+        status: salesOrders.status,
+        associationId: salesOrders.associationId,
+        isDeleted: salesOrders.isDeleted,
+        assignmentId: ({ value }) => {
+          if (!Array.isArray(value) || value.length === 0) return undefined;
+
+          return exists(
+            context.db
+              .select({ one: sql`1` })
+              .from(salesOrderExecutions)
+              .innerJoin(executions, eq(executions.id, salesOrderExecutions.executionId))
+              .where(
+                and(
+                  eq(salesOrderExecutions.salesOrderId, salesOrders.id),
+                  inArray(executions.assignmentId, value as string[]),
+                ),
+              ),
+          );
+        },
+      }).parse(parsedFilters);
+
+      const { data, total } = await getTableData(context, salesOrders, {
+        pagination: input.pagination,
+        where,
+        orderBy,
+        with: {
+          client: true,
+          nextSalesOrder: true,
+          items: { orderBy: asc(salesOrderItems.index) },
+          executions: { orderBy: asc(salesOrderExecutions.index) },
+        },
+      });
+
+      return offsetPaginationResponse({
+        data: data as SalesOrderTableData[],
+        pagination: input.pagination,
+        total,
+      });
+    }),
+  listEmails: protectedProcedure
+    .input(
+      z.object({
+        pagination: offsetPaginationSchema,
+        filters: salesOrdersEmailsFiltersSchema,
+        sorts: emailTableSortsSchema,
+      }),
+    )
+    .handler(async ({ context, input }) => {
+      const parsedSorts = emailTableSortsParser.parse(input.sorts);
+      const orderBy = emailTableDatabaseSortsCompiler(emails).parse(parsedSorts);
+
+      const parsedFilters = salesOrderEmailFiltersParser
+        .omit({ search: true })
+        .parse(input.filters);
+      const emailWhere =
+        salesOrderEmailDatabaseFiltersCompiler(salesOrdersEmails).parse(parsedFilters);
+
+      const filteredSalesOrderEmails = await context.db
+        .select()
+        .from(salesOrdersEmails)
+        .where(emailWhere);
+
+      const emailIds = filteredSalesOrderEmails.flatMap(({ emailId }) => emailId);
+      const salesOrdersEmailsMap = new Map(
+        filteredSalesOrderEmails.map(({ salesOrderId, emailId }) => [emailId, salesOrderId]),
+      );
+
+      const parsedEmailFilters = salesOrderEmailFiltersParser
+        .pick({ search: true })
+        .parse(input.filters);
+      const emailSearchWhere = salesOrderEmailDatabaseFiltersCompiler({
+        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, salesOrderId: salesOrdersEmailsMap.get(email.id) }))
+        .filter((email) => email.salesOrderId) as unknown as SalesOrderEmailTableData[];
+
+      return offsetPaginationResponse({ data: emailsData, pagination: input.pagination, total });
+    }),
+  filterClients: protectedProcedure
+    .use(permissionMiddleware({ salesOrder: ["view"] }))
+    .input(z.object({ filters: salesOrdersFiltersSchema }))
+    .handler(async ({ context, input: { filters } }) => {
+      const parser = salesOrderFiltersParser.omit({ assignmentId: true, clientId: true });
+      const parsedFilters = parser.parse(filters);
+      const where = salesOrderDatabaseFiltersCompiler(salesOrders).parse(parsedFilters);
+
+      return context.db
+        .select({
+          value: clients.id,
+          label: clients.name,
+          total: count(salesOrders.id),
+        })
+        .from(clients)
+        .leftJoin(salesOrders, and(eq(clients.id, salesOrders.clientId), where))
+        .where(eq(clients.isDeleted, false))
+        .groupBy(clients.id)
+        .having(gte(sql<number>`count(${salesOrders.id})`, 1))
+        .orderBy(clients.name);
+    }),
+  getById: protectedProcedure
+    .use(permissionMiddleware({ salesOrder: ["view"] }))
+    .input(z.object({ id: z.string() }))
+    .handler(async ({ context, input: { id } }) => {
+      const data = await context.db.query.salesOrders.findFirst({
+        where: eq(salesOrders.id, id),
+        with: {
+          items: { orderBy: asc(salesOrderItems.index) },
+          executions: { orderBy: asc(salesOrderExecutions.index) },
+          client: { with: { clientsContacts: { with: { contact: true } } } },
+          quotation: true,
+          nextSalesOrder: true,
+          previousSalesOrder: true,
+          invoice: true,
+        },
+      });
+
+      return data ?? null;
+    }),
+  getQuotationByAssociatedId: protectedProcedure
+    .use(permissionMiddleware({ salesOrder: ["view"] }))
+    .input(z.object({ associatedId: z.string() }))
+    .handler(async ({ context, input }) => {
+      const [result] = await context.db
+        .select({ quotation: quotations })
+        .from(quotations)
+        .innerJoin(salesOrders, eq(salesOrders.quotationId, quotations.id))
+        .where(eq(salesOrders.associationId, input.associatedId))
+        .limit(1);
+
+      if (!result?.quotation) return null;
+
+      const items = await context.db
+        .select()
+        .from(quotationItems)
+        .where(eq(quotationItems.quotationId, result.quotation.id));
+
+      return { ...result.quotation, items };
+    }),
+  getPDFData: protectedProcedure
+    .use(permissionMiddleware({ salesOrder: ["view"] }))
+    .input(z.object({ id: z.string() }))
+    .handler(async ({ context, input }) => getSalesOrderPDFData(context, input)),
+  create: protectedProcedure
+    .use(permissionMiddleware({ salesOrder: ["create"] }))
+    .input(createSalesOrderSchema)
+    .handler(async ({ context, input }) => {
+      const number = await generateSalesOrderNumber(context);
+
+      const [result] = await context.db
+        .insert(salesOrders)
+        .values({ ...input, number })
+        .returning();
+
+      if (!result) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Verkoopbon kon niet worden toegevoegd",
+        });
+      }
+
+      return result;
+    }),
+  createFromQuotation: protectedProcedure
+    .use(permissionMiddleware({ salesOrder: ["create"] }))
+    .input(
+      createSalesOrderSchema
+        .pick({ title: true, ratioType: true })
+        .extend({ quotationId: z.string() }),
+    )
+    .handler(async ({ context, input: { title, ratioType, quotationId } }) => {
+      const quotation = await context.db.query.quotations.findFirst({
+        where: eq(quotations.id, quotationId),
+        with: { items: { orderBy: asc(salesOrderItems.index) }, client: true },
+      });
+
+      if (!quotation) {
+        throw new ORPCError("NOT_FOUND", { message: "Verkoopbon bestaat niet" });
+      }
+
+      const salesOrderItemValues = quotation.items.flatMap(
+        (item) =>
+          ({
+            articleNumber: item.articleNumber,
+            description: item.description,
+            price: item.price,
+            quantity: item.quantity,
+            vatRate: item.vatRate,
+            index: item.index,
+            ratioType,
+          }) satisfies Partial<SalesOrderItem>,
+      );
+
+      const number = await generateSalesOrderNumber(context);
+
+      return await context.db.transaction(async (tx) => {
+        const [result] = await tx
+          .insert(salesOrders)
+          .values({ number, title, ratioType, quotationId, clientId: quotation.clientId })
+          .returning();
+
+        if (!result) {
+          throw new ORPCError("INTERNAL_SERVER_ERROR", {
+            message: "Verkoopbon kon niet worden toegevoegd",
+          });
+        }
+
+        await Promise.allSettled(
+          salesOrderItemValues.map((item) =>
+            tx.insert(salesOrderItems).values({ ...item, salesOrderId: result.id }),
+          ),
+        );
+
+        return result;
+      });
+    }),
+  createFromAssignment: protectedProcedure
+    .use(permissionMiddleware({ salesOrder: ["create"] }))
+    .input(
+      createSalesOrderSchema
+        .pick({ title: true, ratioType: true })
+        .extend({ assignmentId: z.string() }),
+    )
+    .handler(async ({ context, input: { title, ratioType, assignmentId } }) => {
+      const assignment = await context.db.query.assignments.findFirst({
+        where: eq(assignments.id, assignmentId),
+        with: {
+          client: true,
+          executions: {
+            orderBy: desc(executions.scheduledAt),
+            with: { executionsRegistrations: { with: { registration: true } } },
+          },
+        },
+      });
+
+      if (!assignment) {
+        throw new ORPCError("NOT_FOUND", { message: "Verkoopbon bestaat niet" });
+      }
+
+      const number = await generateSalesOrderNumber(context);
+
+      return await context.db.transaction(async (tx) => {
+        const [result] = await tx
+          .insert(salesOrders)
+          .values({ number, title, ratioType, clientId: assignment.clientId })
+          .returning();
+
+        if (!result) {
+          throw new ORPCError("INTERNAL_SERVER_ERROR", {
+            message: "Verkoopbon kon niet worden toegevoegd",
+          });
+        }
+
+        await Promise.allSettled(
+          assignment.executions.map((execution, index) => {
+            const registrations = execution.executionsRegistrations.flatMap(
+              (item) => item.registration,
+            );
+
+            return tx.insert(salesOrderExecutions).values({
+              price: assignment.client?.hourlyRate ?? "50.00",
+              quantitySeconds: calculateTotalDuration(registrations),
+              vatRate: assignment.client?.vatRate,
+              executionId: execution.id,
+              salesOrderId: result.id,
+              index,
+            });
+          }),
+        );
+
+        return result;
+      });
+    }),
+  createAssociatedSalesOrder: protectedProcedure
+    .use(permissionMiddleware({ salesOrder: ["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: true, client: true },
+      });
+
+      if (!salesOrder) {
+        throw new ORPCError("NOT_FOUND", { message: "Verkoopbon bestaat niet" });
+      }
+
+      const salesOrderItemValues = salesOrder.items.flatMap(
+        (item) =>
+          ({
+            articleNumber: item.articleNumber,
+            description: item.description,
+            price: item.price,
+            quantity: item.quantity,
+            ratioType: item.ratioType,
+            vatRate: item.vatRate,
+            index: item.index,
+            associationId: item.associationId,
+          }) satisfies Partial<SalesOrderItem>,
+      );
+
+      const number = await generateSalesOrderNumber(context);
+
+      return await context.db.transaction(async (tx) => {
+        /**
+         * Mark sales order as associate
+         */
+        await tx
+          .update(salesOrders)
+          .set({ isAssociated: true })
+          .where(eq(salesOrders.id, salesOrder.id));
+
+        /**
+         * Create new sales order
+         */
+        const [result] = await tx
+          .insert(salesOrders)
+          .values({
+            number,
+            title: salesOrder.title,
+            ratioType: salesOrder.ratioType,
+            associationId: salesOrder.associationId,
+            clientId: salesOrder.clientId,
+            isAssociated: true,
+            previousSalesOrderId: salesOrder.id,
+          })
+          .returning();
+
+        if (!result) {
+          throw new ORPCError("INTERNAL_SERVER_ERROR", {
+            message: "Verkoopbon kon niet worden toegevoegd",
+          });
+        }
+
+        /**
+         * Create sales order items
+         */
+        await Promise.allSettled(
+          salesOrderItemValues.map((item) =>
+            tx.insert(salesOrderItems).values({ ...item, salesOrderId: result.id }),
+          ),
+        );
+
+        return result;
+      });
+    }),
+  update: protectedProcedure
+    .use(permissionMiddleware({ salesOrder: ["update"] }))
+    .input(z.object({ id: z.string(), data: updateSalesOrderSchema.partial() }))
+    .output(z.void())
+    .handler(async ({ context, input }) => {
+      const [result] = await context.db
+        .update(salesOrders)
+        .set(input.data)
+        .where(eq(salesOrders.id, input.id))
+        .returning();
+
+      if (!result) {
+        throw new ORPCError("NOT_FOUND", {
+          message: "Project kon niet worden gewijzigd",
+        });
+      }
+    }),
+  setStatus: protectedProcedure
+    .use(permissionMiddleware({ salesOrder: ["update"] }))
+    .input(bulkActionSchema.extend({ status: salesOrderStatusSchema }))
+    .handler(async ({ context, input: { ids, status } }) => {
+      await context.db.update(salesOrders).set({ status }).where(inArray(salesOrders.id, ids));
+    }),
+  archive: protectedProcedure
+    .use(permissionMiddleware({ salesOrder: ["archive"] }))
+    .input(bulkActionSchema)
+    .handler(async ({ context, input: { ids } }) => {
+      await context.db
+        .update(salesOrders)
+        .set({ isDeleted: true })
+        .where(inArray(salesOrders.id, ids));
+    }),
+  restore: protectedProcedure
+    .use(permissionMiddleware({ salesOrder: ["archive"] }))
+    .input(bulkActionSchema)
+    .handler(async ({ context, input: { ids } }) => {
+      await context.db
+        .update(salesOrders)
+        .set({ isDeleted: false })
+        .where(inArray(salesOrders.id, ids));
+    }),
+  delete: protectedProcedure
+    .use(permissionMiddleware({ salesOrder: ["delete"] }))
+    .input(bulkActionSchema)
+    .handler(async ({ context, input: { ids } }) => {
+      await context.db.delete(salesOrders).where(inArray(salesOrders.id, ids));
+    }),
+  createEmail: protectedProcedure
+    .use(permissionMiddleware({ email: ["create"] }))
+    .input(createEmailSchema.extend({ salesOrderId: z.string() }))
+    .handler(async ({ context, input: { salesOrderId, ...emailData } }) => {
+      const result = await context.db.transaction(async (tx) => {
+        const salesOrder = await tx.query.salesOrders.findFirst({
+          where: eq(salesOrders.id, salesOrderId),
+        });
+
+        if (!salesOrder) {
+          throw new ORPCError("NOT_FOUND", { message: "Verkoopbon bestaat niet" });
+        }
+
+        const [email] = await tx
+          .insert(emails)
+          .values({
+            ...emailData,
+            status: "draft",
+            bcc: [],
+            subject: `${config.general.name} Verkoopbon ${salesOrder.number}`,
+            body: salesOrderEmailDefaultBody,
+          })
+          .returning();
+
+        if (!email) {
+          throw new ORPCError("INTERNAL_SERVER_ERROR", {
+            message: "E-mail kon niet worden aangemaakt",
+          });
+        }
+        await tx.insert(salesOrdersEmails).values({
+          salesOrderId,
+          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 salesOrderEmail = await context.db.query.salesOrdersEmails.findFirst({
+        where: eq(salesOrdersEmails.emailId, input.id),
+      });
+
+      if (!salesOrderEmail) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Verkoopbon kon niet worden gegenereerd",
+        });
+      }
+
+      const pdfData = await getSalesOrderPDFData(context, { id: salesOrderEmail.salesOrderId });
+
+      if (!pdfData) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Verkoopbon kon niet worden gegenereerd",
+        });
+      }
+
+      const document = await generateSalesOrderDocument(pdfData);
+
+      return await context.db.transaction(async (tx) => {
+        /**
+         * 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 tx
+          .update(emails)
+          .set({ status: "sent", sentAt: new Date() })
+          .where(eq(emails.id, input.id));
+
+        await tx
+          .update(salesOrders)
+          .set({ status: "sent" })
+          .where(eq(salesOrders.id, salesOrderEmail.salesOrderId));
+      });
+    }),
+};

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

@@ -0,0 +1,4 @@
+import { pgEnum } from "drizzle-orm/pg-core";
+
+export const salesOrderStatusEnum = pgEnum("sales_order_status", ["draft", "sent", "invoiced"]);
+export const salesOrderRatioTypeEnum = pgEnum("sales_order_ratio_type", ["percentage", "fixed"]);

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

@@ -0,0 +1,91 @@
+import type { EditorJSONContent } from "@tulip-systems/editor";
+import { relations } from "drizzle-orm";
+import { type AnyPgColumn, pgTable } from "drizzle-orm/pg-core";
+import { baseColumns } from "@/server/db/helpers";
+import { emails, quotations, salesInvoices, salesOrderExecutions } from "@/server/db/schema";
+import { clients } from "../../clients/_lib/schema";
+import { salesOrderItems } from "../../sales-order-items/_lib/schema";
+import { salesOrderRatioTypeEnum, salesOrderStatusEnum } from "./schema-enums";
+
+/**
+ * Purchase orders table
+ */
+export const salesOrders = pgTable("sales_orders", (t) => ({
+  ...baseColumns,
+  title: t.text().notNull(),
+  number: t.text().notNull().unique(),
+  status: salesOrderStatusEnum().default("draft").notNull(),
+  issueDate: t.timestamp({ mode: "date" }),
+  dueDate: t.timestamp({ mode: "date" }),
+  sentDate: t.timestamp({ mode: "date" }),
+  notes: t.jsonb().$type<EditorJSONContent>(),
+  isDeleted: t.boolean().default(false).notNull(),
+  // Associated sales order
+  isAssociated: t.boolean().default(false).notNull(),
+  associationId: t.uuid().notNull().defaultRandom(),
+  ratioType: salesOrderRatioTypeEnum().default("percentage").notNull(),
+  previousSalesOrderId: t
+    .uuid()
+    .references((): AnyPgColumn => salesOrders.id, { onDelete: "restrict" })
+    .unique(),
+  // Relations
+  quotationId: t
+    .uuid()
+    .references(() => quotations.id, { onDelete: "restrict" })
+    .unique(),
+  clientId: t
+    .uuid()
+    .notNull()
+    .references(() => clients.id, { onDelete: "restrict" }),
+}));
+
+export const salesOrdersRelations = relations(salesOrders, ({ one, many }) => ({
+  items: many(salesOrderItems),
+  executions: many(salesOrderExecutions),
+  previousSalesOrder: one(salesOrders, {
+    fields: [salesOrders.previousSalesOrderId],
+    references: [salesOrders.id],
+  }),
+  nextSalesOrder: one(salesOrders, {
+    fields: [salesOrders.id],
+    references: [salesOrders.previousSalesOrderId],
+  }),
+  quotation: one(quotations, {
+    fields: [salesOrders.quotationId],
+    references: [quotations.id],
+  }),
+  client: one(clients, {
+    fields: [salesOrders.clientId],
+    references: [clients.id],
+  }),
+  invoice: one(salesInvoices, {
+    fields: [salesOrders.id],
+    references: [salesInvoices.salesOrderId],
+  }),
+}));
+
+/**
+ * SalesOrders Emails table
+ */
+export const salesOrdersEmails = pgTable("sales_orders_emails", (t) => ({
+  ...baseColumns,
+  salesOrderId: t
+    .uuid()
+    .notNull()
+    .references(() => salesOrders.id, { onDelete: "cascade" }),
+  emailId: t
+    .uuid()
+    .notNull()
+    .references(() => emails.id, { onDelete: "cascade" }),
+}));
+
+export const salesOrdersEmailsRelations = relations(salesOrdersEmails, ({ one }) => ({
+  salesOrder: one(salesOrders, {
+    fields: [salesOrdersEmails.salesOrderId],
+    references: [salesOrders.id],
+  }),
+  email: one(emails, {
+    fields: [salesOrdersEmails.emailId],
+    references: [emails.id],
+  }),
+}));