@tulip-systems/create-app 0.12.4 → 0.14.0

package/dist/templates/code/src/app/admin/settings/queue/page.tsx

@@ -0,0 +1,21 @@
+import { InlineCommandMenu } from "@tulip-systems/commands/client";
+import { TableLayout } from "@tulip-systems/data-tables";
+import { DataTable } from "@tulip-systems/data-tables/client";
+import { QueueExecutionsTableProvider } from "@/app/admin/queue/_components/tables";
+import { QueueExecutionsTableToolbar } from "@/app/admin/queue/_components/toolbars";
+import { queueExecutionColumns } from "@/app/admin/queue/_config/columns-data";
+import { queueDeleteCommand, queueEnqueueCommand } from "@/app/admin/queue/_config/commands";
+
+export default function Page() {
+  return (
+    <TableLayout className="p-content">
+      <QueueExecutionsTableProvider columns={queueExecutionColumns} commands={[queueDeleteCommand]}>
+        <QueueExecutionsTableToolbar>
+          <InlineCommandMenu data={null} commands={[queueEnqueueCommand]} />
+        </QueueExecutionsTableToolbar>
+
+        <DataTable />
+      </QueueExecutionsTableProvider>
+    </TableLayout>
+  );
+}

package/dist/templates/code/src/app/admin/tasks/_components/domains-tabs-grid.tsx

@@ -1,10 +1,10 @@
 "use client";
 
 import type { Tab } from "@tulip-systems/app/components";
+import { Link } from "@tulip-systems/core/navigation";
 import { buttonVariants } from "@tulip-systems/ui/button";
 import { cn } from "@tulip-systems/ui/cn";
 import { Skeleton } from "@tulip-systems/ui/skeleton";
-import Link from "next/link";
 import { useSelectedLayoutSegment } from "next/navigation";
 
 type TaskSubprojectTabGridProps = {

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

@@ -1,10 +1,10 @@
 "use client";
 
 import { formatDate } from "@tulip-systems/core";
+import { Link } from "@tulip-systems/core/navigation";
 import { TableCell, type TableColumnDef, TableColumnHeader } from "@tulip-systems/data-tables";
 import { createTableSelectCell } from "@tulip-systems/data-tables/client";
 import { cn } from "@tulip-systems/ui/cn";
-import Link from "next/link";
 import type { TaskTableData } from "../_components/tables";
 import { TaskStatusField } from "./status";
 

package/dist/templates/code/src/app/admin/tasks/_config/columns-inline.tsx

@@ -1,4 +1,5 @@
 "use client";
+import { Link } from "@tulip-systems/core/navigation";
 import { type TableColumnDef, TableColumnHeader } from "@tulip-systems/data-tables";
 import {
   createTableIndexCell,
@@ -15,7 +16,6 @@ import {
   InlineTableCell,
   InlineTableCellError,
 } from "@tulip-systems/inline/client";
-import Link from "next/link";
 import { z } from "zod";
 import { orpc } from "@/server/router/client";
 import type { TaskTableData, TaskTableMeta } from "../_components/tables";

package/dist/templates/code/src/app/admin/tasks/_lib/events.ts

@@ -0,0 +1,40 @@
+import { defineEvent } from "@tulip-systems/events";
+import { z } from "zod";
+import { eventHistoryMetadata, historyJSONSchema } from "@/app/admin/history/_lib/validators";
+import { taskStatusSchema } from "./validators";
+
+/**
+ * Published for each created or imported task. Carries actor, identity, project context,
+ * initial status and the complete inserted row snapshot.
+ */
+export const taskCreatedEvent = defineEvent("task.created", {
+  version: 2,
+  schema: z.object({
+    ...eventHistoryMetadata,
+    taskId: z.uuid(),
+    projectId: z.uuid(),
+    projectTitle: z.string(),
+    code: z.string(),
+    title: z.string(),
+    status: taskStatusSchema,
+    after: z.record(z.string(), historyJSONSchema),
+  }),
+});
+
+/**
+ * Published for general edits, status changes and assignment changes, once per affected task.
+ * Carries actor, identity, project context and complete before/after row snapshots.
+ */
+export const taskUpdatedEvent = defineEvent("task.updated", {
+  version: 1,
+  schema: z.object({
+    ...eventHistoryMetadata,
+    taskId: z.uuid(),
+    projectId: z.uuid(),
+    projectTitle: z.string(),
+    code: z.string(),
+    title: z.string(),
+    before: z.record(z.string(), historyJSONSchema),
+    after: z.record(z.string(), historyJSONSchema),
+  }),
+});

package/dist/templates/code/src/app/admin/tasks/_lib/listeners.server.ts

@@ -0,0 +1,46 @@
+import "server-cli-only";
+
+import { createHistoryDiff } from "@/app/admin/history/_lib/helpers";
+import { createHistoryEntry } from "@/app/admin/history/_lib/service.server";
+import { taskCreatedEvent, taskUpdatedEvent } from "./events";
+
+/**
+ * Tasks supply historical labels, project context and diffs from captured row snapshots.
+ */
+export const taskHistoryEventListeners = {
+  taskCreated: taskCreatedEvent.listen(async ({ event, payload: p }) => {
+    await createHistoryEntry({
+      eventId: event.id,
+      eventName: event.name,
+      eventVersion: event.version,
+      occurredAt: event.occurredAt,
+      actorId: p.actor.id,
+      actorName: p.actor.name,
+      resourceType: "tasks",
+      resourceId: p.taskId,
+      resourceLabel: `${p.code} · ${p.title}`,
+      context: [{ type: "projects", id: p.projectId, label: p.projectTitle }],
+      action: "created",
+      diff: createHistoryDiff(null, p.after),
+    });
+  }),
+  taskUpdated: taskUpdatedEvent.listen(async ({ event, payload: p }) => {
+    const diff = createHistoryDiff(p.before, p.after);
+    if (!diff.changes.some((change) => change.path !== "/updated_at")) return;
+
+    await createHistoryEntry({
+      eventId: event.id,
+      eventName: event.name,
+      eventVersion: event.version,
+      occurredAt: event.occurredAt,
+      actorId: p.actor.id,
+      actorName: p.actor.name,
+      resourceType: "tasks",
+      resourceId: p.taskId,
+      resourceLabel: `${p.code} · ${p.title}`,
+      context: [{ type: "projects", id: p.projectId, label: p.projectTitle }],
+      action: "updated",
+      diff,
+    });
+  }),
+};

package/dist/templates/code/src/app/admin/tasks/_lib/router.ts

@@ -8,12 +8,15 @@ import {
   offsetPaginationSchema,
   parseOffsetPagination,
 } from "@tulip-systems/query";
-import { and, asc, count, desc, eq, gte, inArray, sql } from "drizzle-orm";
+import { and, asc, count, eq, getTableColumns, gte, inArray, sql } from "drizzle-orm";
+import { after } from "next/server";
 import z from "zod";
 import { domains } from "@/app/admin/domains/_lib/schema";
+import type { JSONValue } from "@/app/admin/history/_lib/validators";
 import { initiatives } from "@/app/admin/initiatives/_lib/schema";
 import { getTableData } from "@/app/lib/utils/table-data.server";
 import { employees, projects, timeEntries, users } from "@/server/db/schema";
+import { events } from "@/server/events/init";
 import { permissionMiddleware } from "@/server/router/middleware";
 import { protectedProcedure } from "@/server/router/procedures";
 import type { TaskTableData } from "../_components/tables";
@@ -28,6 +31,7 @@ import {
   taskTableSortsParser,
   taskTableSortsSchema,
 } from "../_config/sorting";
+import { taskCreatedEvent, taskUpdatedEvent } from "./events";
 import { extractTaskCodeSQL, generateTaskCode } from "./helpers";
 import { tasks } from "./schema";
 import {
@@ -265,17 +269,6 @@ export const tasksRouter = {
     .use(permissionMiddleware({ task: ["create"] }))
     .input(createTaskSchema)
     .handler(async ({ context, input }) => {
-      const [project] = await context.db
-        .select()
-        .from(projects)
-        .where(eq(projects.id, input.projectId));
-
-      if (!project) {
-        throw new ORPCError("NOT_FOUND", {
-          message: "Project kon niet worden gevonden",
-        });
-      }
-
       if (input.parentId) {
         const [parent] = await context.db.select().from(tasks).where(eq(tasks.id, input.parentId));
 
@@ -292,51 +285,61 @@ export const tasksRouter = {
         }
       }
 
-      const [lastTask] = await context.db
-        .select({ index: tasks.index })
-        .from(tasks)
-        .limit(1)
-        .where(eq(tasks.projectId, input.projectId))
-        .orderBy(desc(tasks.index));
-
-      const [lastCode] = await context.db
-        .select({ lastNumber: extractTaskCodeSQL(tasks.code) })
-        .from(tasks)
-        .limit(1)
-        .where(eq(tasks.projectId, input.projectId))
-        .orderBy(desc(extractTaskCodeSQL(tasks.code)));
-
-      const index = (lastTask?.index ?? 0) + 1;
-
-      const lastNumber = lastCode?.lastNumber ?? null;
-      const code = generateTaskCode(project.key, lastNumber);
+      const { result, projectTitle } = await context.db.transaction(async (tx) => {
+        const [project] = await tx
+          .select({ key: projects.key, title: projects.title })
+          .from(projects)
+          .where(eq(projects.id, input.projectId))
+          .for("update");
+        if (!project) {
+          throw new ORPCError("NOT_FOUND", { message: "Project kon niet worden gevonden" });
+        }
 
-      const [result] = await context.db
-        .insert(tasks)
-        .values({ ...input, code, index })
-        .returning();
+        // Allocate the task code and ordering position while holding the project lock.
+        const [lastTask] = await tx
+          .select({
+            index: sql<number>`coalesce(max(${tasks.index}), 0)`,
+            number: sql<number>`coalesce(max(${extractTaskCodeSQL(tasks.code)}), 0)`,
+          })
+          .from(tasks)
+          .where(eq(tasks.projectId, input.projectId));
+
+        const [result] = await tx
+          .insert(tasks)
+          .values({
+            ...input,
+            index: (lastTask?.index ?? 0) + 1,
+            code: generateTaskCode(project.key, lastTask?.number ?? 0),
+          })
+          .returning({
+            ...getTableColumns(tasks),
+            after: sql<Record<string, JSONValue>>`to_jsonb(NEW)`,
+          });
+        if (!result) throw new ORPCError("INTERNAL_SERVER_ERROR");
+        return { result, projectTitle: project.title };
+      });
 
-      if (!result) {
-        throw new ORPCError("INTERNAL_SERVER_ERROR", {
-          message: "Task kon niet worden aangemaakt",
-        });
-      }
+      after(async () => {
+        await events.publish(
+          taskCreatedEvent,
+          {
+            actor: { id: context.user.id, name: context.user.name },
+            taskId: result.id,
+            projectId: result.projectId,
+            projectTitle,
+            code: result.code,
+            title: result.title,
+            status: result.status,
+            after: result.after,
+          },
+          { occurredAt: new Date().toISOString() },
+        );
+      });
     }),
   importExcel: protectedProcedure
     .use(permissionMiddleware({ task: ["create"] }))
     .input(importExcelTasksSchema)
     .handler(async ({ context, input }) => {
-      const [project] = await context.db
-        .select()
-        .from(projects)
-        .where(eq(projects.id, input.projectId));
-
-      if (!project) {
-        throw new ORPCError("NOT_FOUND", {
-          message: "Project kon niet worden gevonden",
-        });
-      }
-
       const assigneeEmails = input.items
         .map((item) => item.assignee)
         .filter((email): email is string => Boolean(email));
@@ -347,25 +350,8 @@ export const tasksRouter = {
         .leftJoin(users, eq(users.id, employees.userId))
         .where(inArray(users.email, assigneeEmails));
 
-      const [lastTask] = await context.db
-        .select({ index: tasks.index })
-        .from(tasks)
-        .limit(1)
-        .where(eq(tasks.projectId, input.projectId))
-        .orderBy(desc(tasks.index));
-
-      const [lastCode] = await context.db
-        .select({ lastNumber: extractTaskCodeSQL(tasks.code) })
-        .from(tasks)
-        .limit(1)
-        .where(eq(tasks.projectId, input.projectId))
-        .orderBy(desc(extractTaskCodeSQL(tasks.code)));
-
-      const lastIndex = (lastTask?.index ?? 0) + 1;
-      const lastNumber = lastCode?.lastNumber ?? 0;
-
       const values = input.items.map(
-        (item, index) =>
+        (item) =>
           ({
             projectId: input.projectId,
             initiativeId: input.initiativeId,
@@ -377,20 +363,67 @@ export const tasksRouter = {
               ? (assignees.find((assignee) => assignee.email === item.assignee)?.id ?? null)
               : null,
             description: convertMarkdownToEditorContent(item.description ?? ""),
-            code: generateTaskCode(project.key, lastNumber + index),
-            index: lastIndex + index,
           }) satisfies Partial<Task>,
       );
 
-      const results = await context.db.insert(tasks).values(values).returning();
+      if (!values.length) return [];
+      const { results, projectTitle } = await context.db.transaction(async (tx) => {
+        const [project] = await tx
+          .select({ key: projects.key, title: projects.title })
+          .from(projects)
+          .where(eq(projects.id, input.projectId))
+          .for("update");
+        if (!project) {
+          throw new ORPCError("NOT_FOUND", { message: "Project kon niet worden gevonden" });
+        }
 
-      if (!results) {
-        throw new ORPCError("BAD_REQUEST", {
-          message: "Tasks konden niet worden geïmporteerd",
-        });
-      }
+        // Allocate the task code and ordering position while holding the project lock.
+        const [lastTask] = await tx
+          .select({
+            index: sql<number>`coalesce(max(${tasks.index}), 0)`,
+            number: sql<number>`coalesce(max(${extractTaskCodeSQL(tasks.code)}), 0)`,
+          })
+          .from(tasks)
+          .where(eq(tasks.projectId, input.projectId));
+
+        const results = await tx
+          .insert(tasks)
+          .values(
+            values.map((value, index) => ({
+              ...value,
+              index: (lastTask?.index ?? 0) + index + 1,
+              code: generateTaskCode(project.key, (lastTask?.number ?? 0) + index),
+            })),
+          )
+          .returning({
+            ...getTableColumns(tasks),
+            after: sql<Record<string, JSONValue>>`to_jsonb(NEW)`,
+          });
+        return { results, projectTitle: project.title };
+      });
+
+      after(async () => {
+        await Promise.all(
+          results.map((task) =>
+            events.publish(
+              taskCreatedEvent,
+              {
+                actor: { id: context.user.id, name: context.user.name },
+                taskId: task.id,
+                projectId: task.projectId,
+                projectTitle,
+                code: task.code,
+                title: task.title,
+                status: task.status,
+                after: task.after,
+              },
+              { occurredAt: new Date().toISOString() },
+            ),
+          ),
+        );
+      });
 
-      return results;
+      return results.map(({ after: _after, ...task }) => task);
     }),
   update: protectedProcedure
     .use(permissionMiddleware({ task: ["update"] }))
@@ -400,33 +433,132 @@ export const tasksRouter = {
       const [result] = await context.db
         .update(tasks)
         .set(input.data)
-        .where(eq(tasks.id, input.id))
-        .returning();
-
-      if (!result) {
-        throw new ORPCError("INTERNAL_SERVER_ERROR", {
-          message: "Task kon niet worden aangemaakt",
+        .from(projects)
+        .where(
+          and(eq(tasks.id, input.id), eq(projects.id, input.data.projectId ?? tasks.projectId)),
+        )
+        .returning({
+          id: tasks.id,
+          projectId: tasks.projectId,
+          code: tasks.code,
+          title: tasks.title,
+          projectTitle: projects.title,
+          before: sql<Record<string, JSONValue>>`to_jsonb(OLD)`,
+          after: sql<Record<string, JSONValue>>`to_jsonb(NEW)`,
         });
-      }
+
+      if (!result) throw new ORPCError("NOT_FOUND", { message: "Task kon niet worden gewijzigd" });
+
+      after(async () => {
+        await events.publish(
+          taskUpdatedEvent,
+          {
+            actor: { id: context.user.id, name: context.user.name },
+            taskId: result.id,
+            projectId: result.projectId,
+            projectTitle: result.projectTitle,
+            code: result.code,
+            title: result.title,
+            before: result.before,
+            after: result.after,
+          },
+          { occurredAt: new Date().toISOString() },
+        );
+      });
     }),
   setStatus: protectedProcedure
     .use(permissionMiddleware({ task: ["update"] }))
     .input(bulkActionSchema.extend({ status: taskStatusSchema }))
     .handler(async ({ context, input }) => {
-      await context.db
+      const updated = await context.db
         .update(tasks)
         .set({ status: input.status })
-        .where(inArray(tasks.id, input.ids))
-        .returning();
+        .from(projects)
+        .where(
+          and(
+            eq(tasks.projectId, projects.id),
+            inArray(tasks.id, input.ids),
+            sql`${tasks.status} IS DISTINCT FROM ${input.status}`,
+          ),
+        )
+        .returning({
+          id: tasks.id,
+          projectId: tasks.projectId,
+          projectTitle: projects.title,
+          code: tasks.code,
+          title: tasks.title,
+          before: sql<Record<string, JSONValue>>`to_jsonb(OLD)`,
+          after: sql<Record<string, JSONValue>>`to_jsonb(NEW)`,
+        });
+
+      after(async () => {
+        await Promise.all(
+          updated.map((task) =>
+            events.publish(
+              taskUpdatedEvent,
+              {
+                actor: { id: context.user.id, name: context.user.name },
+                taskId: task.id,
+                projectId: task.projectId,
+                projectTitle: task.projectTitle,
+                code: task.code,
+                title: task.title,
+                before: task.before,
+                after: task.after,
+              },
+              { occurredAt: new Date().toISOString() },
+            ),
+          ),
+        );
+      });
     }),
   setAssignee: protectedProcedure
     .use(permissionMiddleware({ task: ["update"] }))
-    .input(bulkActionSchema.extend({ assigneeId: z.string() }))
+    .input(bulkActionSchema.extend({ assigneeId: z.uuid().nullable() }))
     .handler(async ({ context, input }) => {
-      await context.db
+      const updated = await context.db
         .update(tasks)
         .set({ assigneeId: input.assigneeId })
-        .where(inArray(tasks.id, input.ids));
+        .from(projects)
+        .where(
+          and(
+            eq(tasks.projectId, projects.id),
+            inArray(tasks.id, input.ids),
+            sql`${tasks.assigneeId} IS DISTINCT FROM ${input.assigneeId}`,
+          ),
+        )
+        .returning({
+          id: tasks.id,
+          projectId: tasks.projectId,
+          projectTitle: projects.title,
+          code: tasks.code,
+          title: tasks.title,
+          before: sql<Record<string, JSONValue>>`to_jsonb(OLD)`,
+          after: sql<Record<string, JSONValue>>`to_jsonb(NEW)`,
+        });
+
+      if (!updated.length) return;
+
+      after(async () => {
+        await Promise.all(
+          updated.map((task) =>
+            events.publish(
+              taskUpdatedEvent,
+              {
+                actor: { id: context.user.id, name: context.user.name },
+                taskId: task.id,
+                projectId: task.projectId,
+                projectTitle: task.projectTitle,
+                code: task.code,
+                title: task.title,
+                before: task.before,
+                after: task.after,
+              },
+              { occurredAt: new Date().toISOString() },
+            ),
+          ),
+        );
+      });
     }),
   move: protectedProcedure
     .use(permissionMiddleware({ task: ["update"] }))

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

@@ -1,9 +1,9 @@
 "use client";
 
 import { formatDateTime, formatDuration } from "@tulip-systems/core";
+import { Link } from "@tulip-systems/core/navigation";
 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 { User } from "@/server/auth/validators";
 import type { Customer } from "../../customers/_lib/validators";
 import type { Employee } from "../../employees/_lib/validators";

package/dist/templates/code/src/app/admin/time/_config/columns-inline.tsx

@@ -1,6 +1,7 @@
 "use client";
 
 import { formatDuration } from "@tulip-systems/core";
+import { Link } from "@tulip-systems/core/navigation";
 import { type TableColumnDef, TableColumnHeader } from "@tulip-systems/data-tables";
 import { createTableSelectCell, TableReadOnlyCell } from "@tulip-systems/data-tables/client";
 import {
@@ -9,7 +10,6 @@ import {
   InlineTableCell,
   InlineTableCellError,
 } from "@tulip-systems/inline/client";
-import Link from "next/link";
 import { z } from "zod";
 import { orpc } from "@/server/router/client";
 import { formatDurationInDecimalHours } from "../_lib/helpers";

package/dist/templates/code/src/app/api/[transport]/route.ts

@@ -1,18 +1,18 @@
-import { mcpHandler } from "@better-auth/oauth-provider";
+import { requireMcpAuth } from "@better-auth/mcp";
+import { createMcpHandler, McpServer } from "@modelcontextprotocol/server";
 import { type AnyProcedure, call } from "@orpc/server";
-import { createMcpHandler } from "mcp-handler";
-import { OAUTH_AUDIENCES, OAUTH_ISSUER, OAUTH_JWKS_URI } from "@/server/auth/constants";
+import {
+  OAUTH_AUDIENCE,
+  OAUTH_ISSUER,
+  OAUTH_JWKS_URI,
+  OAUTH_SCOPES,
+} from "@/server/auth/constants";
+import { auth } from "@/server/auth/init";
 import { type McpProcedure, mcpRouter } from "@/server/mcp/router";
 import { createContext } from "@/server/router/init";
 
-const handler = mcpHandler(
-  {
-    jwksUrl: OAUTH_JWKS_URI,
-    verifyOptions: {
-      issuer: OAUTH_ISSUER,
-      audience: OAUTH_AUDIENCES,
-    },
-  },
+const POST = requireMcpAuth(
+  auth,
   (req, jwt) => {
     const transport = new URL(req.url).pathname.split("/").filter(Boolean).pop();
 
@@ -22,8 +22,12 @@ const handler = mcpHandler(
       });
     }
 
-    return createMcpHandler(
-      (server) => {
+    const mcpServerHandler = createMcpHandler(
+      () => {
+        const server = new McpServer({
+          name: "tulip-demo-code",
+          version: "1.0.0",
+        });
         const context = createContext({ headers: req.headers, jwt });
 
         const entries = Object.entries(mcpRouter) as Array<[string, McpProcedure]>;
@@ -33,7 +37,7 @@ const handler = mcpHandler(
 
           const definition = procedure["~orpc"];
 
-          server.registerTool<never, Procedure["~orpc"]["inputSchema"]>(
+          server.registerTool(
             procedureName,
             {
               title: definition.meta.title,
@@ -44,18 +48,24 @@ const handler = mcpHandler(
               call(procedure as AnyProcedure, input, { context })) as never,
           );
         });
+
+        return server;
       },
       {
-        serverInfo: {
-          name: "tulip-demo-code",
-          version: "1.0.0",
-        },
-        verboseLogs: true,
+        legacy: "reject",
       },
-    )(req);
+    );
+
+    return mcpServerHandler.fetch(req);
+  },
+  {
+    resource: OAUTH_AUDIENCE,
+    issuer: OAUTH_ISSUER,
+    jwksUrl: OAUTH_JWKS_URI,
+    challengeScopes: [...OAUTH_SCOPES],
   },
 );
 
 export const maxDuration = 60;
 
-export { handler as DELETE, handler as GET, handler as POST };
+export { POST };

package/dist/templates/code/src/app/api/queue/dispatch/route.ts

@@ -0,0 +1,4 @@
+import { queueHandlers } from "@/server/queue/handlers";
+import { queue } from "@/server/queue/init";
+
+export const POST = queue.handleCallback({ handlers: queueHandlers });

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

@@ -8,8 +8,8 @@ import {
   ForgetPasswordTitle,
   ForgetPasswordView,
 } from "@tulip-systems/auth/components/client";
+import { Link } from "@tulip-systems/core/navigation";
 import type { Metadata } from "next";
-import Link from "next/link";
 
 export const metadata: Metadata = {
   title: "Wachtwoord vergeten",