@tulip-systems/create-app 0.11.1

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

@@ -0,0 +1,21 @@
+"use client";
+
+import { TableCell, type TableColumnDef, TableColumnHeader } from "@tulip-systems/data-tables";
+import { createTableSelectCell } from "@tulip-systems/data-tables/client";
+import Link from "next/link";
+import type { TemplateTableData } from "../_components/tables";
+
+export const templateColumns: TableColumnDef<TemplateTableData>[] = [
+  createTableSelectCell(),
+  {
+    accessorKey: "title",
+    header: ({ column }) => <TableColumnHeader column={column} title="Titel" />,
+    cell: ({ row }) => (
+      <TableCell>
+        <Link href={`/admin/templates/${row.original.id}`} className="hover:underline">
+          {row.getValue("title")}
+        </Link>
+      </TableCell>
+    ),
+  },
+];

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

@@ -0,0 +1,107 @@
+"use client";
+
+import { commandBuilder, ensureArray } from "@tulip-systems/commands";
+import {
+  ArchiveCommand,
+  CommandClick,
+  CommandLabel,
+  type CommandMutationMeta,
+  DeleteCommand,
+  RestoreCommand,
+} from "@tulip-systems/commands/client";
+import { toast } from "@tulip-systems/ui/sonner";
+import { Icons } from "@/components/icons";
+import { orpc } from "@/server/router/client";
+import { CreateTemplateCommand, CreateTemplateCommandTrigger } from "../_components/create-command";
+import type { Template } from "../_lib/validators";
+
+type TemplateCommandItem = Pick<Template, "id" | "isDeleted">;
+
+export const templateCopyCommand = commandBuilder
+  .$type<TemplateCommandItem>()
+
+  .visibleWhen(({ data }) => !data.isDeleted)
+  .render(({ data }) => (
+    <CommandClick
+      variables={{ id: data.id }}
+      mutation={orpc.templates.copy.mutationOptions({
+        onSuccess: (result, _vars, _mutationResult, context) => {
+          toast.success("Template is gedupliceerd");
+          const meta = context.meta as CommandMutationMeta;
+          meta.router.push(`/admin/templates/${result.id}`);
+        },
+      })}
+      label="Dupliceer"
+    >
+      <Icons.copy className="size-4" />
+      <CommandLabel />
+    </CommandClick>
+  ));
+export const templateCreateCommand = commandBuilder
+
+  .permission({ template: ["update"] })
+  .render(() => (
+    <CreateTemplateCommand
+      variables={(values) => values}
+      mutation={orpc.templates.create.mutationOptions({
+        onSuccess: (data, _vars, _result, context) => {
+          toast.success("Template succesvol toegevoegd");
+          const meta = context.meta as CommandMutationMeta;
+          meta.router.push(`/admin/templates/${data.id}`);
+        },
+      })}
+    >
+      <CreateTemplateCommandTrigger label="Toevoegen" hotkey="mod+i">
+        <Icons.add />
+        <CommandLabel />
+      </CreateTemplateCommandTrigger>
+    </CreateTemplateCommand>
+  ));
+export const templateArchiveCommand = commandBuilder
+  .$type<TemplateCommandItem | TemplateCommandItem[]>()
+  .transform(ensureArray)
+
+  .permission({ template: ["archive"] })
+  .disabledWhen(({ data }) => data.length > 0)
+  .visibleWhen(({ data }) => data.every((item) => !item.isDeleted))
+  .render(({ data }) => (
+    <ArchiveCommand
+      variables={{ ids: data.map((item) => item.id) }}
+      mutation={orpc.templates.archive.mutationOptions({
+        onSuccess: () => toast.success("Succesvol gearchiveerd"),
+      })}
+    />
+  ));
+export const templateRestoreCommand = commandBuilder
+  .$type<TemplateCommandItem | TemplateCommandItem[]>()
+  .transform(ensureArray)
+
+  .permission({ template: ["archive"] })
+  .disabledWhen(({ data }) => data.length > 0)
+  .visibleWhen(({ data }) => data.every((item) => item.isDeleted))
+  .render(({ data }) => (
+    <RestoreCommand
+      variables={{ ids: data.map((item) => item.id) }}
+      mutation={orpc.templates.restore.mutationOptions({
+        onSuccess: () => toast.success("Succesvol hersteld"),
+      })}
+    />
+  ));
+export const templateDeleteCommand = commandBuilder
+  .$type<TemplateCommandItem | TemplateCommandItem[]>()
+  .transform(ensureArray)
+
+  .permission({ template: ["delete"] })
+  .disabledWhen(({ data }) => data.length > 0)
+  .render(({ data }) => (
+    <DeleteCommand
+      variables={{ ids: data.map((item) => item.id) }}
+      mutation={orpc.templates.delete.mutationOptions({
+        onSuccess: (_result, _vars, _mutationResult, context) => {
+          toast.success("Succesvol verwijderd");
+          const meta = context.meta as CommandMutationMeta;
+          meta.router.push("/admin/templates");
+        },
+      })}
+    />
+  ));

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

@@ -0,0 +1,32 @@
+import {
+  booleanFilter,
+  createFilteringParser,
+  defineFilters,
+  resolveFiltersSchema,
+  stringFilter,
+} from "@tulip-systems/query";
+import { createDatabaseFiltersCompiler } from "@tulip-systems/query/drizzle";
+import type { z } from "zod";
+
+export const templatesFilters = defineFilters({
+  search: stringFilter.build((value) =>
+    value ? { field: "title", operator: "ilike", value: `%${value}%` } : null,
+  ),
+  isDeleted: booleanFilter.build((value) => ({
+    field: "isDeleted",
+    operator: "eq",
+    value: value ?? false,
+  })),
+});
+
+/**
+ * Validators
+ */
+export const templatesFiltersSchema = resolveFiltersSchema(templatesFilters);
+export type TemplatesFilters = z.input<typeof templatesFiltersSchema>;
+
+/**
+ * Parser and compilers
+ */
+export const templateFiltersParser = createFilteringParser(templatesFilters);
+export const templateDatabaseFiltersCompiler = createDatabaseFiltersCompiler(templatesFilters);

package/dist/templates/spark/src/app/admin/templates/_config/sorting.ts

@@ -0,0 +1,27 @@
+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 templateTableSorts = defineSorting({
+  title: sortOption((direction) => ({ field: "title", direction })),
+});
+
+/**
+ * Validators
+ */
+export const templateTableSortsSchema = resolveSortingSchema(templateTableSorts);
+
+/**
+ * Parsers
+ */
+export const templateTableSortsParser = createSortingParser(templateTableSorts, {
+  fallback: [{ key: "title", direction: "desc" }],
+});
+
+export const templateTableLocalSortsCompiler = createLocalSortingCompiler(templateTableSorts);
+export const templateTableDatabaseSortsCompiler = createDatabaseSortingCompiler(templateTableSorts);

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

@@ -0,0 +1,179 @@
+import "server-cli-only";
+
+import { ORPCError } from "@orpc/server";
+import {
+  bulkActionSchema,
+  offsetPaginationResponse,
+  offsetPaginationSchema,
+} from "@tulip-systems/query";
+import { asc, desc, eq, inArray } from "drizzle-orm";
+import z from "zod";
+import { getTableData } from "@/lib/helpers/table-data.server";
+import { templateTasks } from "@/server/db/schema";
+import { permissionMiddleware } from "@/server/router/middleware";
+import { protectedProcedure } from "@/server/router/procedures";
+import type { TemplateTableData } from "../_components/tables";
+import {
+  templateDatabaseFiltersCompiler,
+  templateFiltersParser,
+  templatesFiltersSchema,
+} from "../_config/filters";
+import {
+  templateTableDatabaseSortsCompiler,
+  templateTableSortsParser,
+  templateTableSortsSchema,
+} from "../_config/sorting";
+import { templates } from "./schema";
+import { createTemplateSchema, updateTemplateSchema } from "./validators";
+
+export const templatesRouter = {
+  list: protectedProcedure
+    .use(permissionMiddleware({ template: ["view"] }))
+    .input(
+      z.object({
+        pagination: offsetPaginationSchema,
+        filters: templatesFiltersSchema,
+        sorts: templateTableSortsSchema,
+      }),
+    )
+    .handler(async ({ context, input }) => {
+      const parsedSorts = templateTableSortsParser.parse(input.sorts);
+      const orderBy = templateTableDatabaseSortsCompiler(templates).parse(parsedSorts);
+
+      const parsedFilters = templateFiltersParser.parse(input.filters);
+      const where = templateDatabaseFiltersCompiler(templates).parse(parsedFilters);
+
+      const { data, total } = await getTableData(context, templates, {
+        pagination: input.pagination,
+        where,
+        orderBy,
+        with: { tasks: { orderBy: asc(templateTasks.index) } },
+      });
+
+      return offsetPaginationResponse({
+        data: data as TemplateTableData[],
+        pagination: input.pagination,
+        total,
+      });
+    }),
+  getAll: protectedProcedure
+    .use(permissionMiddleware({ template: ["view"] }))
+    .handler(async ({ context }) =>
+      context.db
+        .select()
+        .from(templates)
+        .where(eq(templates.isDeleted, false))
+        .orderBy(desc(templates.title)),
+    ),
+  getById: protectedProcedure
+    .use(permissionMiddleware({ template: ["view"] }))
+    .input(z.object({ id: z.string() }))
+    .handler(async ({ context, input: { id } }) => {
+      const data = await context.db.query.templates.findFirst({
+        where: eq(templates.id, id),
+        with: { tasks: { orderBy: asc(templateTasks.index) } },
+      });
+
+      return data ?? null;
+    }),
+  create: protectedProcedure
+    .use(permissionMiddleware({ template: ["create"] }))
+    .input(createTemplateSchema)
+    .handler(async ({ context, input }) => {
+      const [result] = await context.db.insert(templates).values(input).returning();
+
+      if (!result) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Template kon niet worden toegevoegd",
+        });
+      }
+
+      return result;
+    }),
+  update: protectedProcedure
+    .use(permissionMiddleware({ template: ["update"] }))
+    .input(z.object({ id: z.string(), data: updateTemplateSchema.partial() }))
+    .output(z.void())
+    .handler(async ({ context, input }) => {
+      const [result] = await context.db
+        .update(templates)
+        .set(input.data)
+        .where(eq(templates.id, input.id))
+        .returning();
+
+      if (!result) {
+        throw new ORPCError("NOT_FOUND", {
+          message: "Project kon niet worden gewijzigd",
+        });
+      }
+    }),
+  copy: protectedProcedure
+    .use(permissionMiddleware({ template: ["create"] }))
+    .input(z.object({ id: z.string() }))
+    .handler(async ({ context, input }) => {
+      const [previousTemplate] = await context.db
+        .select()
+        .from(templates)
+        .where(eq(templates.id, input.id));
+
+      if (!previousTemplate) {
+        throw new ORPCError("INTERNAL_SERVER_ERROR", {
+          message: "Template kon niet worden toegevoegd",
+        });
+      }
+
+      const previousTemplateItems = await context.db
+        .select({
+          articleNumber: templateTasks.articleNumber,
+          description: templateTasks.description,
+          price: templateTasks.price,
+          metaPrice: templateTasks.metaPrice,
+          index: templateTasks.index,
+        })
+        .from(templateTasks)
+        .where(eq(templateTasks.templateId, input.id));
+
+      return await context.db.transaction(async (tx) => {
+        const [result] = await tx
+          .insert(templates)
+          .values({ title: `${previousTemplate.title} (kopie)` })
+          .returning();
+
+        if (!result) {
+          throw new ORPCError("INTERNAL_SERVER_ERROR", {
+            message: "Template kon niet worden toegevoegd",
+          });
+        }
+
+        await Promise.allSettled(
+          previousTemplateItems.map((item) =>
+            tx.insert(templateTasks).values({ ...item, templateId: result.id }),
+          ),
+        );
+
+        return result;
+      });
+    }),
+  archive: protectedProcedure
+    .use(permissionMiddleware({ template: ["archive"] }))
+    .input(bulkActionSchema)
+    .handler(async ({ context, input: { ids } }) => {
+      await context.db.update(templates).set({ isDeleted: true }).where(inArray(templates.id, ids));
+    }),
+  restore: protectedProcedure
+    .use(permissionMiddleware({ template: ["archive"] }))
+    .input(bulkActionSchema)
+    .handler(async ({ context, input: { ids } }) => {
+      await context.db
+        .update(templates)
+        .set({ isDeleted: false })
+        .where(inArray(templates.id, ids));
+    }),
+
+  delete: protectedProcedure
+    .use(permissionMiddleware({ template: ["delete"] }))
+    .input(bulkActionSchema)
+    .handler(async ({ context, input: { ids } }) => {
+      await context.db.delete(templates).where(inArray(templates.id, ids));
+    }),
+};

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

@@ -0,0 +1,19 @@
+import type { EditorJSONContent } from "@tulip-systems/editor";
+import { relations } from "drizzle-orm";
+import { pgTable } from "drizzle-orm/pg-core";
+import { baseColumns } from "@/server/db/helpers";
+import { templateTasks } from "@/server/db/schema";
+
+/**
+ * Templates table
+ */
+export const templates = pgTable("templates", (t) => ({
+  ...baseColumns,
+  title: t.text().notNull(),
+  notes: t.jsonb().$type<EditorJSONContent>(),
+  isDeleted: t.boolean().default(false).notNull(),
+}));
+
+export const templatesRelations = relations(templates, ({ many }) => ({
+  tasks: many(templateTasks),
+}));

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

@@ -0,0 +1,31 @@
+import { createInsertSchema, createSelectSchema, createUpdateSchema } from "drizzle-zod";
+import type { z } from "zod";
+
+export type { TemplatesFilters } from "../_config/filters";
+export { templatesFiltersSchema } from "../_config/filters";
+
+import { templates } from "./schema";
+
+/**
+ * Template type
+ */
+export type Template = typeof templates.$inferSelect;
+
+export const selectTemplateSchema = createSelectSchema(templates);
+export type SelectTemplateSchema = z.infer<typeof selectTemplateSchema>;
+
+/**
+ * Create schema
+ */
+export const createTemplateSchema = createInsertSchema(templates);
+
+export type CreateTemplateInput = z.input<typeof createTemplateSchema>;
+export type CreateTemplateSchema = z.infer<typeof createTemplateSchema>;
+
+/**
+ * Update schema
+ */
+export const updateTemplateSchema = createUpdateSchema(templates);
+
+export type UpdateTemplateInput = z.input<typeof updateTemplateSchema>;
+export type UpdateTemplateSchema = z.infer<typeof updateTemplateSchema>;

package/dist/templates/spark/src/app/api/auth/[...all]/route.ts

@@ -0,0 +1,4 @@
+import { toNextJsHandler } from "better-auth/next-js";
+import { auth } from "@/server/auth/init";
+
+export const { GET, POST } = toNextJsHandler(auth.handler);

package/dist/templates/spark/src/app/api/drive/[[...rest]]/route.ts

@@ -0,0 +1,5 @@
+import { createLocalDriveRouteHandler } from "@tulip-systems/drive-local/server";
+import { drive } from "@/app/admin/drive/_lib/service.server";
+import { auth } from "@/server/auth/init";
+
+export const { GET, POST, PUT, PATCH, DELETE } = createLocalDriveRouteHandler({ auth, drive });

package/dist/templates/spark/src/app/api/rpc/[[...rest]]/route.ts

@@ -0,0 +1,28 @@
+import { onError } from "@orpc/server";
+import { RPCHandler } from "@orpc/server/fetch";
+import { createContext } from "@/server/router/init";
+import { appRouter } from "@/server/router/router";
+
+const handler = new RPCHandler(appRouter, {
+  interceptors: [
+    onError((error) => {
+      console.error("[orpc] Unhandled RPC error", error);
+    }),
+  ],
+});
+
+async function handleRequest(request: Request) {
+  const { response } = await handler.handle(request, {
+    prefix: "/api/rpc",
+    context: createContext({ headers: request.headers }),
+  });
+
+  return response ?? new Response("Not found", { status: 404 });
+}
+
+export const HEAD = handleRequest;
+export const GET = handleRequest;
+export const POST = handleRequest;
+export const PUT = handleRequest;
+export const PATCH = handleRequest;
+export const DELETE = handleRequest;

package/dist/templates/spark/src/app/api/storage/[[...rest]]/route.ts

@@ -0,0 +1,5 @@
+import { createStorageRouteHandler } from "@tulip-systems/storage/server";
+import { auth } from "@/server/auth/init";
+import { storage } from "@/server/storage/init";
+
+export const { GET, POST, PUT, PATCH, DELETE } = createStorageRouteHandler({ auth, storage });

package/dist/templates/spark/src/app/auth/create-first-user/page.tsx

@@ -0,0 +1,11 @@
+import { CreateFirstUserPage } from "@tulip-systems/auth/components/client";
+import { CreateFirstUserPageGuard } from "@tulip-systems/auth/next/guards";
+import { auth } from "@/server/auth/init";
+
+export default function Page() {
+  return (
+    <CreateFirstUserPageGuard auth={auth}>
+      <CreateFirstUserPage />
+    </CreateFirstUserPageGuard>
+  );
+}

package/dist/templates/spark/src/app/auth/forget-password/loading.tsx

@@ -0,0 +1,3 @@
+import { AuthLoading } from "@tulip-systems/auth/components";
+
+export default AuthLoading;

package/dist/templates/spark/src/app/auth/forget-password/page.tsx

@@ -0,0 +1,3 @@
+import { ForgetPasswordPage } from "@tulip-systems/auth/components/client";
+
+export default ForgetPasswordPage;

package/dist/templates/spark/src/app/auth/layout.tsx

@@ -0,0 +1,30 @@
+import { AuthProvider } from "@tulip-systems/auth/client";
+import {
+  AuthLayout,
+  AuthLayoutContent,
+  AuthLayoutImage,
+  AuthLayoutImageFooter,
+  AuthLayoutImageHeader,
+} from "@tulip-systems/auth/components";
+import Link from "next/link";
+import type { PropsWithChildren } from "react";
+import { config } from "@/lib/config/base";
+import { authClient } from "@/server/auth/client";
+
+export default function Layout(props: PropsWithChildren) {
+  return (
+    <AuthProvider authClient={authClient}>
+      <AuthLayout>
+        <AuthLayoutImage src="/images/auth-background.jpeg" alt="">
+          <AuthLayoutImageHeader>
+            <Link href="/">{config.general.name}</Link>
+          </AuthLayoutImageHeader>
+
+          <AuthLayoutImageFooter>Developed by NewCode</AuthLayoutImageFooter>
+        </AuthLayoutImage>
+
+        <AuthLayoutContent>{props.children}</AuthLayoutContent>
+      </AuthLayout>
+    </AuthProvider>
+  );
+}

package/dist/templates/spark/src/app/auth/login/loading.tsx

@@ -0,0 +1,3 @@
+import { AuthLoading } from "@tulip-systems/auth/components";
+
+export default AuthLoading;

package/dist/templates/spark/src/app/auth/login/page.tsx

@@ -0,0 +1,3 @@
+import { LoginPage } from "@tulip-systems/auth/components/client";
+
+export default LoginPage;

package/dist/templates/spark/src/app/auth/reset-password/loading.tsx

@@ -0,0 +1,3 @@
+import { AuthLoading } from "@tulip-systems/auth/components";
+
+export default AuthLoading;

package/dist/templates/spark/src/app/auth/reset-password/page.tsx

@@ -0,0 +1,3 @@
+import { ResetPasswordPage } from "@tulip-systems/auth/components/client";
+
+export default ResetPasswordPage;

package/dist/templates/spark/src/app/globals.css

@@ -0,0 +1,13 @@
+@import "tailwindcss";
+@import "@tulip-systems/ui/styles.css";
+@import "@tulip-systems/app/styles.css";
+@import "@tulip-systems/auth/styles.css";
+@import "@tulip-systems/commands/styles.css";
+@import "@tulip-systems/data-tables/styles.css";
+@import "@tulip-systems/drive/styles.css";
+@import "@tulip-systems/drive-local/styles.css";
+@import "@tulip-systems/editor/styles.css";
+@import "@tulip-systems/inline/styles.css";
+@import "@tulip-systems/query/styles.css";
+@import "@tulip-systems/storage/styles.css";
+@plugin "@tailwindcss/typography";

package/dist/templates/spark/src/app/layout.tsx

@@ -0,0 +1,20 @@
+import "./globals.css";
+import "../server/router/register";
+
+import { ColorThemeProvider, Providers } from "@tulip-systems/app/components/client";
+import { generateRootLayoutMetadata, RootLayout } from "@tulip-systems/app/components/server";
+import { DriveViewScript } from "@tulip-systems/drive/server";
+import { config } from "@/lib/config/base";
+
+export const { metadata, viewport } = generateRootLayoutMetadata(config);
+
+export default function Layout({ children }: LayoutProps<"/">) {
+  return (
+    <RootLayout defaultColorTheme="iris">
+      <DriveViewScript />
+      <ColorThemeProvider defaultTheme="iris">
+        <Providers>{children}</Providers>
+      </ColorThemeProvider>
+    </RootLayout>
+  );
+}

package/dist/templates/spark/src/app/loading.tsx

@@ -0,0 +1,3 @@
+import { RootLoading } from "@tulip-systems/app/components";
+
+export default RootLoading;

package/dist/templates/spark/src/app/manifest.ts

@@ -0,0 +1,4 @@
+import { generateManifest } from "@tulip-systems/core";
+import { config } from "@/lib/config/base";
+
+export default generateManifest(config);

package/dist/templates/spark/src/app/not-found.tsx

@@ -0,0 +1,3 @@
+import { RootNotFoundPage } from "@tulip-systems/app/components";
+
+export default RootNotFoundPage;