@tulip-systems/create-app 0.11.1

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

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

package/dist/templates/spark/src/app/admin/sales-order-executions/_config/columns-data.tsx

@@ -0,0 +1,64 @@
+"use client";
+
+import { formatCurrency, formatDate, formatDuration } from "@tulip-systems/core";
+import { TableCell, type TableColumnDef, TableColumnHeader } from "@tulip-systems/data-tables";
+import { createTableSelectCell } from "@tulip-systems/data-tables/client";
+import Link from "next/link";
+import { Suspense } from "react";
+import { EmployeeAvatars, EmployeeAvatarsLoading } from "../../employees/_components/avatars";
+import type { SalesOrderExecutionTableData } from "../_components/tables";
+
+export const salesOrderExecutionColumns: TableColumnDef<SalesOrderExecutionTableData>[] = [
+  createTableSelectCell(),
+  {
+    accessorKey: "executionScheduledAt",
+    header: ({ column }) => <TableColumnHeader column={column} title="Datum" />,
+    accessorFn: (row) => row.execution?.scheduledAt ?? "",
+    cell: ({ row }) => <TableCell>{formatDate(row.getValue("executionScheduledAt"))}</TableCell>,
+  },
+  {
+    accessorKey: "executionTitle",
+    header: ({ column }) => <TableColumnHeader column={column} title="Omschrijving" />,
+    accessorFn: (row) => row.execution?.title || "",
+    cell: ({ row }) => (
+      <TableCell>
+        <Link href={`/admin/executions/${row.original.executionId}`} className="hover:underline">
+          {row.getValue("executionTitle")}
+        </Link>
+      </TableCell>
+    ),
+  },
+  {
+    accessorKey: "employees",
+    header: ({ column }) => <TableColumnHeader column={column} title="Medewerkers" />,
+    accessorFn: (row) =>
+      row.execution?.executionsRegistrations.flatMap(
+        ({ registration }) => registration.employeeId,
+      ) ?? [],
+    cell: ({ row }) => (
+      <TableCell>
+        <Suspense fallback={<EmployeeAvatarsLoading />}>
+          <EmployeeAvatars ids={row.getValue("employees")} />
+        </Suspense>
+      </TableCell>
+    ),
+    enableSorting: false,
+  },
+  {
+    accessorKey: "quantitySeconds",
+    header: ({ column }) => <TableColumnHeader column={column} title="Aantal uren" />,
+    cell: ({ row }) => <TableCell>{formatDuration(row.getValue("quantitySeconds"))}</TableCell>,
+    enableSorting: false,
+  },
+  {
+    accessorKey: "price",
+    header: ({ column }) => <TableColumnHeader column={column} title="Uurloon" />,
+    cell: ({ row }) => <TableCell>{formatCurrency(row.getValue("price"))}</TableCell>,
+  },
+  {
+    accessorKey: "netAmount",
+    header: ({ column }) => <TableColumnHeader column={column} title="Totaal" />,
+    cell: ({ row }) => <TableCell> {formatCurrency(row.getValue("netAmount"))}</TableCell>,
+    enableSorting: false,
+  },
+];

package/dist/templates/spark/src/app/admin/sales-order-executions/_config/columns-inline.tsx

@@ -0,0 +1,106 @@
+"use client";
+
+import { formatCurrency, formatDate, formatDuration } from "@tulip-systems/core";
+import { type TableColumnDef, TableColumnHeader } from "@tulip-systems/data-tables";
+import {
+  createTableDragHandleCell,
+  createTableIndexCell,
+  createTableSelectCell,
+  TableEditableCell,
+  TableReadOnlyCell,
+} from "@tulip-systems/data-tables/client";
+import {
+  InlineDecimalInput,
+  InlineTableCell,
+  InlineTableCellError,
+} from "@tulip-systems/inline/client";
+import Link from "next/link";
+import { Suspense } from "react";
+import { z } from "zod";
+import { orpc } from "@/server/router/client";
+import { EmployeeAvatars, EmployeeAvatarsLoading } from "../../employees/_components/avatars";
+import type { SalesOrderExecutionTableData } from "../_components/tables";
+
+export const salesOrderExecutionInlineColumns: TableColumnDef<SalesOrderExecutionTableData>[] = [
+  createTableSelectCell(),
+  createTableDragHandleCell(),
+  {
+    accessorKey: "executionScheduledAt",
+    header: ({ column }) => <TableColumnHeader column={column} title="Datum" />,
+    accessorFn: (row) => row.execution?.scheduledAt ?? "",
+    cell: ({ row }) => (
+      <TableEditableCell>
+        <TableReadOnlyCell>{formatDate(row.getValue("executionScheduledAt"))}</TableReadOnlyCell>
+      </TableEditableCell>
+    ),
+  },
+  {
+    accessorKey: "executionTitle",
+    header: ({ column }) => <TableColumnHeader column={column} title="Omschrijving" />,
+    accessorFn: (row) => row.execution?.title || "",
+    cell: ({ row }) => (
+      <TableEditableCell>
+        <TableReadOnlyCell>
+          <Link href={`/admin/executions/${row.original.executionId}`} className="hover:underline">
+            {row.getValue("executionTitle")}
+          </Link>
+        </TableReadOnlyCell>
+      </TableEditableCell>
+    ),
+  },
+  {
+    accessorKey: "employees",
+    header: ({ column }) => <TableColumnHeader column={column} title="Medewerkers" />,
+    accessorFn: (row) =>
+      row.execution?.executionsRegistrations.flatMap(
+        ({ registration }) => registration.employeeId,
+      ) ?? [],
+    cell: ({ row }) => (
+      <TableEditableCell>
+        <TableReadOnlyCell className="py-1">
+          <Suspense fallback={<EmployeeAvatarsLoading />}>
+            <EmployeeAvatars ids={row.getValue("employees")} />
+          </Suspense>
+        </TableReadOnlyCell>
+      </TableEditableCell>
+    ),
+    enableSorting: false,
+  },
+  {
+    accessorKey: "quantitySeconds",
+    header: ({ column }) => <TableColumnHeader column={column} title="Aantal uren" />,
+    cell: ({ row }) => (
+      <TableEditableCell>
+        <TableReadOnlyCell>{formatDuration(row.getValue("quantitySeconds"))}</TableReadOnlyCell>
+      </TableEditableCell>
+    ),
+    enableSorting: false,
+  },
+  {
+    accessorKey: "price",
+    header: ({ column }) => <TableColumnHeader column={column} title="Prijs" />,
+    cell: ({ row }) => (
+      <InlineTableCell className="min-w-32">
+        <InlineDecimalInput
+          initialValue={row.original.price ?? undefined}
+          variables={(value) => ({ id: row.original.id, data: { price: value } })}
+          mutation={orpc.salesOrderExecutions.update.mutationOptions()}
+          strategy={{ mutate: { on: "blur" }, validate: { blur: z.string().nullable() } }}
+          permission={{ salesOrder: ["update"] }}
+          variant="table"
+        />
+        <InlineTableCellError />
+      </InlineTableCell>
+    ),
+  },
+  {
+    accessorKey: "netAmount",
+    header: ({ column }) => <TableColumnHeader column={column} title="Totaal" />,
+    cell: ({ row }) => (
+      <TableEditableCell>
+        <TableReadOnlyCell>{formatCurrency(row.getValue("netAmount"))}</TableReadOnlyCell>
+      </TableEditableCell>
+    ),
+  },
+  createTableIndexCell(),
+];

package/dist/templates/spark/src/app/admin/sales-order-executions/_config/commands.tsx

@@ -0,0 +1,60 @@
+"use client";
+
+import { commandBuilder, ensureArray } from "@tulip-systems/commands";
+import {
+  CommandClick,
+  CommandEmpty,
+  CommandLabel,
+  DeleteCommand,
+} from "@tulip-systems/commands/client";
+import { toast } from "@tulip-systems/ui/sonner";
+import { ImportIcon, RefreshCcwIcon } from "lucide-react";
+import Link from "next/link";
+import { orpc } from "@/server/router/client";
+
+type SalesOrderExecutionCommandItem = { id: string };
+
+export const salesOrderExecutionSyncExecutionsCommand = commandBuilder
+  .$type<SalesOrderExecutionCommandItem | SalesOrderExecutionCommandItem[]>()
+  .transform(ensureArray)
+
+  .permission({ salesOrder: ["update"] })
+  .render(({ data }) => (
+    <CommandClick
+      variables={{ ids: data.map((item) => item.id) }}
+      mutation={orpc.salesOrderExecutions.syncExecutions.mutationOptions()}
+      label="Prestaties synchroniseren"
+    >
+      <RefreshCcwIcon />
+      <CommandLabel />
+    </CommandClick>
+  ));
+export const salesOrderExecutionImportExecutionsCommand = commandBuilder
+  .$type<{ salesOrderId: string }>()
+
+  .permission({ salesOrder: ["update"] })
+  .render(({ data }) => (
+    <Link
+      href={`/admin/sales-order-executions/import/executions?salesOrderId=${data.salesOrderId}`}
+    >
+      <CommandEmpty label="Prestaties importeren">
+        <ImportIcon />
+        <CommandLabel />
+      </CommandEmpty>
+    </Link>
+  ));
+export const salesOrderExecutionDeleteCommand = commandBuilder
+  .$type<SalesOrderExecutionCommandItem | SalesOrderExecutionCommandItem[]>()
+  .transform(ensureArray)
+
+  .permission({ salesOrder: ["delete"] })
+  .render(({ data }) => (
+    <DeleteCommand
+      variables={{ ids: data.map((item) => item.id) }}
+      mutation={orpc.salesOrderExecutions.delete.mutationOptions({
+        onSuccess: () => {
+          toast.success("Succesvol verwijderd");
+        },
+      })}
+    />
+  ));

package/dist/templates/spark/src/app/admin/sales-order-executions/_config/filters.ts

@@ -0,0 +1,35 @@
+import {
+  arrayFilter,
+  createFilteringParser,
+  defineFilters,
+  resolveFiltersSchema,
+  stringFilter,
+} from "@tulip-systems/query";
+import { createDatabaseFiltersCompiler } from "@tulip-systems/query/drizzle";
+import type { z } from "zod";
+
+export const salesOrderExecutionsFilters = defineFilters({
+  search: stringFilter.build((value) =>
+    value ? { field: "executionTitle", operator: "ilike", value: `%${value}%` } : null,
+  ),
+  salesOrderId: arrayFilter(stringFilter).build((value) =>
+    value?.length ? { field: "salesOrderId", operator: "in", value } : null,
+  ),
+  executionId: arrayFilter(stringFilter).build((value) =>
+    value?.length ? { field: "executionId", operator: "in", value } : null,
+  ),
+});
+
+/**
+ * Validators
+ */
+export const salesOrderExecutionsFiltersSchema = resolveFiltersSchema(salesOrderExecutionsFilters);
+export type SalesOrderExecutionsFilters = z.input<typeof salesOrderExecutionsFiltersSchema>;
+
+/**
+ * Parser and compilers
+ */
+export const salesOrderExecutionFiltersParser = createFilteringParser(salesOrderExecutionsFilters);
+export const salesOrderExecutionDatabaseFiltersCompiler = createDatabaseFiltersCompiler(
+  salesOrderExecutionsFilters,
+);

package/dist/templates/spark/src/app/admin/sales-order-executions/_config/sorting.ts

@@ -0,0 +1,34 @@
+import {
+  createSortingParser,
+  defineSorting,
+  resolveSortingSchema,
+  sortOption,
+} from "@tulip-systems/query";
+import { createDatabaseSortingCompiler } from "@tulip-systems/query/drizzle";
+import { createLocalSortingCompiler } from "@tulip-systems/query/tanstack-db";
+
+export const salesOrderExecutionTableSorts = defineSorting({
+  index: sortOption((direction) => ({ field: "index", direction })),
+});
+
+/**
+ * Validators
+ */
+export const salesOrderExecutionTableSortsSchema = resolveSortingSchema(
+  salesOrderExecutionTableSorts,
+);
+
+/**
+ * Parsers
+ */
+export const salesOrderExecutionTableSortsParser = createSortingParser(
+  salesOrderExecutionTableSorts,
+  { fallback: [{ key: "index", direction: "asc" }] },
+);
+
+export const salesOrderExecutionTableLocalSortsCompiler = createLocalSortingCompiler(
+  salesOrderExecutionTableSorts,
+);
+export const salesOrderExecutionTableDatabaseSortsCompiler = createDatabaseSortingCompiler(
+  salesOrderExecutionTableSorts,
+);

package/dist/templates/spark/src/app/admin/sales-order-executions/_lib/helpers.ts

@@ -0,0 +1,11 @@
+import Decimal from "decimal.js";
+
+/**
+ * Calculate salesOrder net amount
+ */
+export function calculateSalesOrderExecutionsTotalQuantity(items: { quantity: string | null }[]) {
+  return items.reduce((total, item) => {
+    if (item.quantity === null) return total;
+    return total.add(item.quantity);
+  }, new Decimal(0));
+}

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

@@ -0,0 +1,214 @@
+import "server-cli-only";
+
+import { ORPCError } from "@orpc/server";
+import { arrayMove } from "@tulip-systems/core";
+import {
+  bulkActionSchema,
+  offsetPaginationResponse,
+  offsetPaginationSchema,
+} from "@tulip-systems/query";
+import { and, asc, desc, eq, exists, getTableColumns, ilike, inArray, sql } from "drizzle-orm";
+import { z } from "zod";
+import { getTableData } from "@/lib/helpers/table-data.server";
+import { executions, salesOrders } from "@/server/db/schema";
+import { permissionMiddleware } from "@/server/router/middleware";
+import { protectedProcedure } from "@/server/router/procedures";
+import { calculateTotalDuration } from "../../registrations/_lib/helpers";
+import type { SalesOrderExecutionTableData } from "../_components/tables";
+import {
+  salesOrderExecutionDatabaseFiltersCompiler,
+  salesOrderExecutionFiltersParser,
+  salesOrderExecutionsFiltersSchema,
+} from "../_config/filters";
+import {
+  salesOrderExecutionTableDatabaseSortsCompiler,
+  salesOrderExecutionTableSortsParser,
+  salesOrderExecutionTableSortsSchema,
+} from "../_config/sorting";
+import { salesOrderExecutions } from "./schema";
+import { updateSalesOrderExecutionSchema } from "./validators";
+
+export const salesOrderExecutionsRouter = {
+  list: protectedProcedure
+    .use(permissionMiddleware({ salesOrder: ["view"] }))
+    .input(
+      z.object({
+        pagination: offsetPaginationSchema,
+        filters: salesOrderExecutionsFiltersSchema,
+        sorts: salesOrderExecutionTableSortsSchema,
+      }),
+    )
+    .handler(async ({ context, input }) => {
+      const parsedSorts = salesOrderExecutionTableSortsParser.parse(input.sorts);
+      const orderBy =
+        salesOrderExecutionTableDatabaseSortsCompiler(salesOrderExecutions).parse(parsedSorts);
+
+      const parsedFilters = salesOrderExecutionFiltersParser.parse(input.filters);
+      const where = salesOrderExecutionDatabaseFiltersCompiler({
+        ...getTableColumns(salesOrderExecutions),
+        executionTitle: ({ value }) =>
+          exists(
+            context.db
+              .select({ one: sql`1` })
+              .from(executions)
+              .where(
+                and(
+                  eq(executions.id, salesOrderExecutions.executionId),
+                  ilike(sql`${executions.title}::text`, value as string),
+                ),
+              ),
+          ),
+      }).parse(parsedFilters);
+
+      const { data, total } = await getTableData(context, salesOrderExecutions, {
+        pagination: input.pagination,
+        where,
+        orderBy,
+        with: {
+          execution: { with: { executionsRegistrations: { with: { registration: true } } } },
+        },
+      });
+
+      /*
+       * Return data
+       */
+      return offsetPaginationResponse({
+        data: data as SalesOrderExecutionTableData[],
+        pagination: input.pagination,
+        total,
+      });
+    }),
+  getAll: protectedProcedure
+    .use(permissionMiddleware({ salesOrder: ["view"] }))
+    .input(z.object({ salesOrderId: z.string() }))
+    .handler(async ({ context, input }) =>
+      context.db
+        .select()
+        .from(salesOrderExecutions)
+        .where(eq(salesOrderExecutions.salesOrderId, input.salesOrderId))
+        .orderBy(asc(salesOrderExecutions.index)),
+    ),
+  importExecutions: protectedProcedure
+    .use(permissionMiddleware({ salesOrder: ["create"] }))
+    .input(z.object({ salesOrderId: z.string(), executionIds: z.string().array() }))
+    .handler(async ({ context, input }) => {
+      const salesOrder = await context.db.query.salesOrders.findFirst({
+        where: eq(salesOrders.id, input.salesOrderId),
+        with: { client: true },
+      });
+
+      if (!salesOrder) {
+        throw new ORPCError("NOT_FOUND", {
+          message: "Verkoopbon kon niet worden gevonden",
+        });
+      }
+
+      const lastSalesOrderExecution = await context.db
+        .select({ index: salesOrderExecutions.index })
+        .from(salesOrderExecutions)
+        .limit(1)
+        .where(eq(salesOrderExecutions.salesOrderId, input.salesOrderId))
+        .orderBy(desc(salesOrderExecutions.index));
+
+      const lastIndex = (lastSalesOrderExecution[0]?.index ?? 0) + 1;
+
+      const selectedExecutions = await context.db.query.executions.findMany({
+        where: inArray(executions.id, input.executionIds),
+        with: { executionsRegistrations: { with: { registration: true } } },
+      });
+
+      await context.db.transaction(async (tx) =>
+        Promise.allSettled(
+          selectedExecutions.map((execution, index) => {
+            const registrations = execution.executionsRegistrations.flatMap(
+              (item) => item.registration,
+            );
+
+            return tx.insert(salesOrderExecutions).values({
+              price: salesOrder.client?.hourlyRate ?? "50.00",
+              quantitySeconds: calculateTotalDuration(registrations),
+              vatRate: salesOrder.client?.vatRate,
+              executionId: execution.id,
+              salesOrderId: input.salesOrderId,
+              index: lastIndex + index,
+            });
+          }),
+        ),
+      );
+    }),
+  update: protectedProcedure
+    .use(permissionMiddleware({ salesOrder: ["update"] }))
+    .input(z.object({ id: z.string(), data: updateSalesOrderExecutionSchema.partial() }))
+    .output(z.void())
+    .handler(async ({ context, input }) => {
+      const [result] = await context.db
+        .update(salesOrderExecutions)
+        .set(input.data)
+        .where(eq(salesOrderExecutions.id, input.id))
+        .returning();
+
+      if (!result) {
+        throw new ORPCError("NOT_FOUND", {
+          message: "Verkoopbon item kon niet worden gewijzigd",
+        });
+      }
+    }),
+  syncExecutions: protectedProcedure
+    .use(permissionMiddleware({ salesOrder: ["update"] }))
+    .input(bulkActionSchema)
+    .handler(async ({ context, input }) => {
+      const data = await context.db.query.salesOrderExecutions.findMany({
+        where: inArray(salesOrderExecutions.id, input.ids),
+        with: {
+          execution: { with: { executionsRegistrations: { with: { registration: true } } } },
+        },
+      });
+
+      await Promise.allSettled(
+        data.map((execution) => {
+          const registrations = execution.execution.executionsRegistrations.flatMap(
+            (item) => item.registration,
+          );
+
+          return context.db
+            .update(salesOrderExecutions)
+            .set({ quantitySeconds: calculateTotalDuration(registrations) })
+            .where(eq(salesOrderExecutions.id, execution.id));
+        }),
+      );
+    }),
+  move: protectedProcedure
+    .use(permissionMiddleware({ salesOrder: ["update"] }))
+    .input(z.object({ salesOrderId: z.string(), fromIndex: z.number(), toIndex: z.number() }))
+    .handler(async ({ context, input }) => {
+      /**
+       * Get all items
+       */
+      const items = await context.db
+        .select({ id: salesOrderExecutions.id })
+        .from(salesOrderExecutions)
+        .where(eq(salesOrderExecutions.salesOrderId, input.salesOrderId))
+        .orderBy(asc(salesOrderExecutions.index));
+      const newItems = arrayMove(items, input);
+
+      /**
+       * Update the index of the items by splicing the item to the new index.
+       */
+      await context.db.transaction(async (tx) =>
+        Promise.allSettled(
+          newItems.map((item, index) =>
+            tx
+              .update(salesOrderExecutions)
+              .set({ index })
+              .where(eq(salesOrderExecutions.id, item.id)),
+          ),
+        ),
+      );
+    }),
+  delete: protectedProcedure
+    .use(permissionMiddleware({ salesOrder: ["delete"] }))
+    .input(bulkActionSchema)
+    .handler(async ({ context, input: { ids } }) => {
+      await context.db.delete(salesOrderExecutions).where(inArray(salesOrderExecutions.id, ids));
+    }),
+};

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

@@ -0,0 +1,69 @@
+import { relations, type SQL, sql } from "drizzle-orm";
+import { pgTable, uuid } from "drizzle-orm/pg-core";
+import { baseColumns } from "@/server/db/helpers";
+import { executions } from "@/server/db/schema";
+import { salesOrders } from "../../sales-orders/_lib/schema";
+
+/**
+ * Purchase order items table
+ */
+export const salesOrderExecutions = pgTable("sales_order_executions", (t) => ({
+  ...baseColumns,
+  // Quantity in seconds
+  quantitySeconds: t.integer(),
+  // Quantity in hours
+  quantity: t
+    .numeric({ precision: 12, scale: 3 })
+    .generatedAlwaysAs(
+      (): SQL => sql<number>`(${salesOrderExecutions.quantitySeconds}::numeric / 3600)`,
+    ),
+  // Price
+  price: t.numeric({ precision: 12, scale: 3 }),
+  // Net
+  netAmount: t
+    .numeric({ precision: 12, scale: 2 })
+    .generatedAlwaysAs((): SQL => netExpression(salesOrderExecutions)),
+  // VAT
+  vatRate: t.numeric({ precision: 5, scale: 3 }).notNull(),
+  vatAmount: t
+    .numeric({ precision: 12, scale: 2 })
+    .generatedAlwaysAs(
+      (): SQL =>
+        sql`round(${netExpression(salesOrderExecutions)} * ${salesOrderExecutions.vatRate}, 2)`,
+    ),
+  // Total
+  totalAmount: t
+    .numeric({ precision: 12, scale: 2 })
+    .generatedAlwaysAs(
+      (): SQL =>
+        sql`round(${netExpression(salesOrderExecutions)} * (1 + ${salesOrderExecutions.vatRate}), 2)`,
+    ),
+  index: t.integer().notNull(),
+  executionId: uuid()
+    .notNull()
+    .references(() => executions.id, { onDelete: "restrict" }),
+  salesOrderId: uuid()
+    .notNull()
+    .references(() => salesOrders.id, { onDelete: "cascade" }),
+}));
+
+/**
+ * Relations
+ */
+export const salesOrderExecutionsRelations = relations(salesOrderExecutions, ({ one }) => ({
+  salesOrder: one(salesOrders, {
+    fields: [salesOrderExecutions.salesOrderId],
+    references: [salesOrders.id],
+  }),
+  execution: one(executions, {
+    fields: [salesOrderExecutions.executionId],
+    references: [executions.id],
+  }),
+}));
+
+/**
+ * Expressions
+ */
+function netExpression(alias: typeof salesOrderExecutions) {
+  return sql`round((${alias.price} * ${alias.quantitySeconds}::numeric) / 3600, 2)`;
+}

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

@@ -0,0 +1,33 @@
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from "drizzle-zod";
+import type { z } from "zod";
+
+export type { SalesOrderExecutionsFilters } from "../_config/filters";
+export { salesOrderExecutionsFiltersSchema } from "../_config/filters";
+
+import { salesOrderExecutions } from "./schema";
+
+/**
+ * SalesOrderExecution type
+ */
+export type SalesOrderExecution = typeof salesOrderExecutions.$inferSelect;
+
+export const selectSalesOrderExecutionSchema = createSelectSchema(salesOrderExecutions);
+export type SelectSalesOrderExecutionSchema = z.infer<typeof selectSalesOrderExecutionSchema>;
+
+/**
+ * Create salesOrderExecution schema
+ */
+export const createSalesOrderExecutionSchema = createInsertSchema(salesOrderExecutions).omit({
+  index: true,
+});
+
+export type CreateSalesOrderExecutionInput = z.input<typeof createSalesOrderExecutionSchema>;
+export type CreateSalesOrderExecutionSchema = z.infer<typeof createSalesOrderExecutionSchema>;
+
+/**
+ * Update salesOrderExecution schema
+ */
+export const updateSalesOrderExecutionSchema = createUpdateSchema(salesOrderExecutions);
+
+export type UpdateSalesOrderExecutionInput = z.input<typeof updateSalesOrderExecutionSchema>;
+export type UpdateSalesOrderExecutionSchema = z.infer<typeof updateSalesOrderExecutionSchema>;

package/dist/templates/spark/src/app/admin/sales-order-executions/import/executions/layout.tsx

@@ -0,0 +1,18 @@
+import { Header, Topbar, TopbarTitle } from "@tulip-systems/app/components/client";
+import { TableLayout } from "@tulip-systems/data-tables";
+
+export default function Page(
+  props: LayoutProps<"/admin/sales-order-executions/import/executions">,
+) {
+  return (
+    <>
+      <Header>
+        <Topbar>
+          <TopbarTitle breadcrumbs={[{ label: "Prestaties importeren" }]} />
+        </Topbar>
+      </Header>
+
+      <TableLayout className="p-10 pb-40">{props.children}</TableLayout>
+    </>
+  );
+}

package/dist/templates/spark/src/app/admin/sales-order-executions/import/executions/loading.tsx

@@ -0,0 +1,5 @@
+import { TableSkeleton } from "@tulip-systems/data-tables";
+
+export default function Loading() {
+  return <TableSkeleton />;
+}