@tulip-systems/create-app 0.11.1

package/dist/templates/code/src/server/mcp/router.ts

@@ -0,0 +1,155 @@
+import "server-cli-only";
+import { and, eq, inArray, isNotNull, isNull } from "drizzle-orm";
+import z from "zod";
+import { customerWhereInputSchema } from "@/app/admin/customers/_lib/validators";
+import { projectFiltersSchema } from "@/app/admin/projects/_lib/validators";
+import { taskFiltersSchema, taskStatusSchema } from "@/app/admin/tasks/_lib/validators";
+import { customers, projects, tasks } from "../db/schema";
+import { mcpProcedure } from "./procedures";
+
+/**
+ * MCP Router with protected procedures that require authentication and permission checks
+ */
+export const mcpRouter = {
+  get_customers: mcpProcedure
+    .meta({
+      title: "Get Customers",
+      description: "Retrieve a list of all customers.",
+    })
+    .input(z.object({ filters: customerWhereInputSchema }))
+    .handler(async ({ context, input: { filters } }) => {
+      const data = await context.db
+        .select({
+          id: customers.id,
+          name: customers.name,
+        })
+        .from(customers)
+        .where(and(eq(customers.isDeleted, filters.isDeleted)));
+
+      return {
+        content: [
+          { type: "text" as const, text: "Customer List:" },
+          ...data.map((customer) => ({
+            type: "text" as const,
+            text: `- ${customer.name} (ID: ${customer.id})`,
+          })),
+        ],
+      };
+    }),
+  get_customer_projects: mcpProcedure
+    .meta({
+      title: "Get Customer Projects",
+      description: "Retrieve all active projects for a specific customer.",
+    })
+    .input(z.object({ customerId: z.string() }))
+    .handler(async ({ context, input: { customerId } }) => {
+      const data = await context.db
+        .select({
+          id: projects.id,
+          key: projects.key,
+          title: projects.title,
+          status: projects.status,
+        })
+        .from(projects)
+        .where(and(eq(projects.customerId, customerId), isNull(projects.deletedAt)));
+
+      return {
+        content: [
+          { type: "text" as const, text: `Projects for customer ${customerId}:` },
+          ...data.map((project) => ({
+            type: "text" as const,
+            text: `- ${project.title} (${project.key}, ID: ${project.id}, Status: ${project.status})`,
+          })),
+        ],
+      };
+    }),
+  get_projects: mcpProcedure
+    .meta({
+      title: "Get Projects",
+      description: "Retrieve a list of all active projects.",
+    })
+    .input(z.object({ filters: projectFiltersSchema }))
+    .handler(async ({ context, input: { filters } }) => {
+      const data = await context.db
+        .select({
+          id: projects.id,
+          key: projects.key,
+          title: projects.title,
+          customerId: projects.customerId,
+        })
+        .from(projects)
+        .where(
+          and(
+            filters.isDeleted ? isNotNull(projects.deletedAt) : isNull(projects.deletedAt),
+            filters.customerId ? inArray(projects.customerId, filters.customerId) : undefined,
+            filters.status ? inArray(projects.status, filters.status) : undefined,
+          ),
+        );
+
+      return {
+        content: [
+          { type: "text" as const, text: "Project List:" },
+          ...data.map((project) => ({
+            type: "text" as const,
+            text: `- ${project.title} (${project.key}, ID: ${project.id}, Customer ID: ${project.customerId})`,
+          })),
+        ],
+      };
+    }),
+  get_tasks: mcpProcedure
+    .meta({
+      title: "Get Tasks",
+      description: "Retrieve a list of all tasks.",
+    })
+    .input(z.object({ filters: taskFiltersSchema }))
+    .handler(async ({ context, input: { filters } }) => {
+      const data = await context.db
+        .select({
+          id: tasks.id,
+          title: tasks.title,
+          code: tasks.code,
+          status: tasks.status,
+        })
+        .from(tasks)
+        .where(
+          and(
+            filters.assigneeId ? inArray(tasks.assigneeId, filters.assigneeId) : undefined,
+            filters.projectId ? inArray(tasks.projectId, filters.projectId) : undefined,
+            filters.parentId ? eq(tasks.parentId, filters.parentId) : undefined,
+            filters.initiativeId ? inArray(tasks.initiativeId, filters.initiativeId) : undefined,
+            filters.domainId ? inArray(tasks.domainId, filters.domainId) : undefined,
+            filters.status ? inArray(tasks.status, filters.status) : undefined,
+          ),
+        );
+
+      return {
+        content: [
+          { type: "text" as const, text: "Task List:" },
+          ...data.map((task) => ({
+            type: "text" as const,
+            text: `- ${task.title} (${task.code}, ID: ${task.id}, Status: ${task.status})`,
+          })),
+        ],
+      };
+    }),
+  set_task_status: mcpProcedure
+    .meta({
+      title: "Set Task Status",
+      description: "Update the status of multiple tasks.",
+    })
+    .input(z.object({ taskIds: z.array(z.string()), status: taskStatusSchema }))
+    .handler(async ({ context, input: { taskIds, status } }) => {
+      await context.db.update(tasks).set({ status }).where(inArray(tasks.id, taskIds));
+
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `Updated status of tasks with IDs: ${taskIds.join(", ")} to ${status}`,
+          },
+        ],
+      };
+    }),
+};
+
+export type McpProcedure = (typeof mcpRouter)[keyof typeof mcpRouter];

package/dist/templates/code/src/server/router/caller.ts

@@ -0,0 +1,10 @@
+import "server-only";
+
+import { createRouterClient } from "@orpc/server";
+import { headers } from "next/headers";
+import { createContext } from "./init";
+import { appRouter } from "./router";
+
+export const caller = createRouterClient(appRouter, {
+  context: async () => createContext({ headers: await headers() }),
+});

package/dist/templates/code/src/server/router/client.ts

@@ -0,0 +1,26 @@
+import { createORPCClient } from "@orpc/client";
+import { RPCLink } from "@orpc/client/fetch";
+import type { RouterClient } from "@orpc/server";
+import { createTanstackQueryUtils, type RouterUtils } from "@orpc/tanstack-query";
+import type { AppRouter } from "./router";
+
+type ORPCClient = RouterClient<AppRouter>;
+type ORPCTanstackQueryUtils = RouterUtils<ORPCClient>;
+
+declare global {
+  var $client: ORPCClient | undefined;
+}
+
+const link = new RPCLink({
+  url: () => {
+    if (typeof window === "undefined") {
+      throw new Error("RPCLink is not allowed on the server side.");
+    }
+
+    return `${window.location.origin}/api/rpc`;
+  },
+});
+
+const client: ORPCClient = createORPCClient(link);
+
+export const orpc: ORPCTanstackQueryUtils = createTanstackQueryUtils(globalThis.$client ?? client);

package/dist/templates/code/src/server/router/init.ts

@@ -0,0 +1,17 @@
+import "server-cli-only";
+
+import { os } from "@orpc/server";
+import { auth } from "../auth/init";
+import { db } from "../db/init";
+
+export type RPCContext = {
+  db: typeof db;
+  auth: typeof auth;
+  headers: Headers;
+};
+
+export const rpc = os.$context<RPCContext>();
+
+export function createContext<TExtendedContext>(context: TExtendedContext & { headers: Headers }) {
+  return { db, auth, ...context } as RPCContext & TExtendedContext;
+}

package/dist/templates/code/src/server/router/middleware.ts

@@ -0,0 +1,51 @@
+import { ORPCError } from "@orpc/server";
+import type { AuthServerSession, AuthServerUser } from "@tulip-systems/auth";
+import type { Permission } from "@tulip-systems/auth/permissions";
+import type { AuthServerOptions } from "../auth/init";
+import type { AccessControl } from "../auth/permissions";
+import { type RPCContext, rpc } from "./init";
+
+/**
+ * Session middleware function to check if the user is authenticated
+ */
+export const sessionMiddleware = rpc.middleware(async ({ next, context }) => {
+  const data = await context.auth.api.getSession({ headers: context.headers });
+
+  if (!data?.session || !data?.user) {
+    throw new ORPCError("UNAUTHORIZED", {
+      message: "Jou hebt geen toegang om deze actie uit te voeren",
+    });
+  }
+
+  const { session, user } = data;
+
+  return next({ context: { session, user } });
+});
+
+export type ProtectedContext = RPCContext & {
+  session: AuthServerSession<AuthServerOptions>;
+  user: AuthServerUser<AuthServerOptions>;
+};
+
+/**
+ * Middleware function to check if the user has the required permission
+ */
+export function permissionMiddleware(permissions: Permission<AccessControl>) {
+  return rpc.$context<ProtectedContext>().middleware(async ({ next, context }) => {
+    const { success, error } = await context.auth.api.userHasPermission({
+      headers: context.headers as Headers,
+      body: {
+        userId: context.user.id,
+        permissions,
+      },
+    });
+
+    if (error || !success) {
+      throw new ORPCError("UNAUTHORIZED", {
+        message: "Jou hebt geen toegang om deze actie uit te voeren",
+      });
+    }
+
+    return next({ context });
+  });
+}

package/dist/templates/code/src/server/router/procedures.ts

@@ -0,0 +1,5 @@
+import { rpc } from "./init";
+import { sessionMiddleware } from "./middleware";
+
+export const publicProcedure = rpc;
+export const protectedProcedure = rpc.use(sessionMiddleware);

package/dist/templates/code/src/server/router/register.ts

@@ -0,0 +1,5 @@
+import "server-only";
+
+import { caller } from "./caller";
+
+globalThis.$client ??= caller;

package/dist/templates/code/src/server/router/router.ts

@@ -0,0 +1,74 @@
+import { type InferRouterInputs, type InferRouterOutputs, lazy } from "@orpc/server";
+
+export const appRouter = {
+  assistant: lazy(() =>
+    import("@/app/admin/assistant/_lib/router").then((module) => ({
+      default: module.assistantRouter,
+    })),
+  ),
+  addresses: lazy(() =>
+    import("@/app/admin/addresses/_lib/router").then((module) => ({
+      default: module.addressesRouter,
+    })),
+  ),
+  contacts: lazy(() =>
+    import("@/app/admin/contacts/_lib/router").then((module) => ({
+      default: module.contactsRouter,
+    })),
+  ),
+  domains: lazy(() =>
+    import("@/app/admin/domains/_lib/router").then((module) => ({
+      default: module.domainsRouter,
+    })),
+  ),
+  googleDrive: lazy(() =>
+    import("@/app/admin/drive/_lib/router").then((module) => ({
+      default: module.googleDriveRouter,
+    })),
+  ),
+  storage: lazy(() =>
+    import("../storage/router").then((module) => ({
+      default: module.storageRouter,
+    })),
+  ),
+  tasks: lazy(() =>
+    import("@/app/admin/tasks/_lib/router").then((module) => ({
+      default: module.tasksRouter,
+    })),
+  ),
+  projects: lazy(() =>
+    import("@/app/admin/projects/_lib/router").then((module) => ({
+      default: module.projectsRouter,
+    })),
+  ),
+  timeEntries: lazy(() =>
+    import("@/app/admin/time/_lib/router").then((module) => ({
+      default: module.timeEntriesRouter,
+    })),
+  ),
+  customers: lazy(() =>
+    import("@/app/admin/customers/_lib/router").then((module) => ({
+      default: module.customersRouter,
+    })),
+  ),
+  employees: lazy(() =>
+    import("@/app/admin/employees/_lib/router").then((module) => ({
+      default: module.employeesRouter,
+    })),
+  ),
+  initiatives: lazy(() =>
+    import("@/app/admin/initiatives/_lib/router").then((module) => ({
+      default: module.initiativesRouter,
+    })),
+  ),
+  prospects: lazy(() =>
+    import("@/app/admin/prospects/_lib/router").then((module) => ({
+      default: module.prospectsRouter,
+    })),
+  ),
+};
+
+// export type definition of API
+export type AppRouter = typeof appRouter;
+export type RouterOutputs = InferRouterOutputs<AppRouter>;
+export type RouterInputs = InferRouterInputs<AppRouter>;

package/dist/templates/code/src/server/storage/client.ts

@@ -0,0 +1,18 @@
+import { createUploadClient } from "@tulip-systems/storage/client";
+import { orpc } from "../router/client";
+
+/**
+ * Uplaod client
+ */
+export const uploadClient = createUploadClient({
+  endpoints: {
+    presign: (input) => orpc.storage.presign.call(input),
+    confirm: (uploadId) => orpc.storage.confirm.call(uploadId),
+    deleteAsset: (id) => orpc.storage.deleteAsset.call(id),
+    deleteAssets: (ids) => orpc.storage.deleteAssets.call(ids),
+    restoreAsset: (id) => orpc.storage.restoreAsset.call(id),
+    restoreAssets: (ids) => orpc.storage.restoreAssets.call(ids),
+    purgeAsset: (id) => orpc.storage.purgeAsset.call(id),
+    purgeAssets: (ids) => orpc.storage.purgeAssets.call(ids),
+  },
+});

package/dist/templates/code/src/server/storage/init.ts

@@ -0,0 +1,19 @@
+import { storageDrizzleAdapter } from "@tulip-systems/storage/drizzle";
+import { storageS3Adapter } from "@tulip-systems/storage/s3";
+import { Storage } from "@tulip-systems/storage/server";
+import { env } from "@/env";
+import { db } from "../db/init";
+import * as schema from "./schema";
+
+export const storage = Storage.init({
+  database: storageDrizzleAdapter({ db, schema }),
+  adapter: storageS3Adapter({
+    bucketName: env.S3_BUCKET,
+    region: "auto",
+    endpoint: env.S3_ENDPOINT,
+    credentials: {
+      accessKeyId: env.S3_ACCESS_KEY_ID,
+      secretAccessKey: env.S3_SECRET_ACCESS_KEY,
+    },
+  }),
+});

package/dist/templates/code/src/server/storage/router.ts

@@ -0,0 +1,38 @@
+import { implement } from "@orpc/server";
+import { storageRouterContract } from "@tulip-systems/storage/server";
+import type { RPCContext } from "../router/init";
+import { sessionMiddleware } from "../router/middleware";
+import { storage } from "./init";
+
+/**
+ * Storage procedure with session middleware applied
+ */
+export const storageProcedure = implement(storageRouterContract)
+  .$context<RPCContext>()
+  .use(sessionMiddleware);
+
+/**
+ * Storage router defines the procedures for handling storage-related operations such as presigning uploads, confirming uploads, deleting assets, restoring assets, and purging assets.
+ * Each procedure is implemented with the corresponding handler that interacts with the storage service.
+ * The procedures are protected by session middleware to ensure that only authenticated users can access them.
+ */
+export const storageRouter = {
+  presign: storageProcedure.presign.handler(async ({ input }) => storage.presignUpload(input)),
+  confirm: storageProcedure.confirm.handler(async ({ input }) => storage.confirmUpload(input)),
+  deleteAsset: storageProcedure.deleteAsset.handler(async ({ input }) =>
+    storage.deleteAsset(input),
+  ),
+  deleteAssets: storageProcedure.deleteAssets.handler(async ({ input }) =>
+    storage.deleteAssets(input),
+  ),
+  restoreAsset: storageProcedure.restoreAsset.handler(async ({ input }) =>
+    storage.restoreAsset(input),
+  ),
+  restoreAssets: storageProcedure.restoreAssets.handler(async ({ input }) =>
+    storage.restoreAssets(input),
+  ),
+  purgeAsset: storageProcedure.purgeAsset.handler(async ({ input }) => storage.purgeAsset(input)),
+  purgeAssets: storageProcedure.purgeAssets.handler(async ({ input }) =>
+    storage.purgeAssets(input),
+  ),
+};

package/dist/templates/code/src/server/storage/schema.ts

@@ -0,0 +1,32 @@
+import { storageAdapterKeys } from "@tulip-systems/storage";
+import { index, pgEnum, pgTable, unique } from "drizzle-orm/pg-core";
+import { baseColumns } from "../db/helpers";
+
+export const storageAssetStatusEnum = pgEnum("storage_asset_status", ["pending", "ready", "error"]);
+export const storageAssetVisibilityEnum = pgEnum("storage_asset_visibility", ["private", "public"]);
+
+export const storageAssets = pgTable(
+  "storage_assets",
+  (t) => ({
+    ...baseColumns,
+    provider: t.text({ enum: storageAdapterKeys }).notNull(),
+    bucket: t.text().notNull(),
+    key: t.text().notNull(),
+    status: storageAssetStatusEnum().notNull(),
+    visibility: storageAssetVisibilityEnum().notNull().default("private"),
+    size: t.integer().default(0),
+    contentType: t.varchar({ length: 255 }),
+    uploadId: t.uuid().notNull().defaultRandom(),
+    name: t.text(),
+    metadata: t.jsonb().$type<Record<string, unknown>>(),
+    etag: t.text(),
+    uploadedAt: t.timestamp().defaultNow().notNull(),
+    deletedAt: t.timestamp(),
+  }),
+  (t) => [
+    unique("storage_assets_upload_id_unique").on(t.uploadId),
+    unique("storage_assets_provider_bucket_key_unique").on(t.provider, t.bucket, t.key),
+    index("storage_assets_status_idx").on(t.status),
+    index("storage_assets_bucket_key_idx").on(t.bucket, t.key),
+  ],
+);

package/dist/templates/code/tsconfig.json

@@ -0,0 +1,44 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "declaration": false,
+    "declarationMap": false,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": [
+        "./src/*"
+      ]
+    }
+  },
+  "include": [
+    "**/*.ts",
+    "**/*.tsx",
+    "next-env.d.ts",
+    "next.config.ts",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

package/dist/templates/spark/README.md

@@ -0,0 +1 @@
+# Tulip docs

package/dist/templates/spark/drizzle.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+  out: "./src/server/db/migrations",
+  schema: "./src/server/db/schema.ts",
+  dialect: "postgresql",
+  casing: "snake_case",
+  dbCredentials: {
+    url: process.env.DATABASE_URL as string,
+  },
+});

package/dist/templates/spark/next.config.ts

@@ -0,0 +1,35 @@
+import type { NextConfig } from "next";
+import { env } from "./src/env";
+
+const nextConfig: NextConfig = {
+  cacheComponents: true,
+  partialPrefetching: true,
+  reactCompiler: true,
+  images: {
+    localPatterns: [
+      {
+        pathname: "/images/**",
+      },
+      {
+        pathname: "/api/storage/files/**",
+      },
+      {
+        pathname: "/api/drive/files/**",
+      },
+    ],
+  },
+  redirects: async () => {
+    return [
+      {
+        source: "/",
+        destination: "/admin",
+        permanent: true,
+      },
+    ];
+  },
+  env: {
+    NEXT_PUBLIC_HOST: env.NEXT_PUBLIC_HOST,
+  },
+};
+
+export default nextConfig;

package/dist/templates/spark/package.json

@@ -0,0 +1,97 @@
+{
+  "name": "tulip-spark-template",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "license": "AGPL-3.0",
+  "engines": {
+    "node": "24.x"
+  },
+  "scripts": {
+    "dev": "next dev --turbopack",
+    "build": "next build",
+    "start": "next start",
+    "lint": "biome check",
+    "format": "biome format --write",
+    "typecheck": "next typegen && tsc --noEmit",
+    "db:push": "dotenv drizzle-kit push",
+    "db:studio": "dotenv drizzle-kit studio",
+    "db:seed": "dotenv tsx src/server/db/seed.ts"
+  },
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.1106.0",
+    "@aws-sdk/s3-request-presigner": "^3.1106.0",
+    "@better-auth/passkey": "^1.6.26",
+    "@dnd-kit/collision": "^0.5.0",
+    "@dnd-kit/helpers": "^0.5.0",
+    "@dnd-kit/react": "^0.5.0",
+    "@hookform/resolvers": "^5.7.1",
+    "@orpc/client": "^1.14.15",
+    "@orpc/server": "^1.14.15",
+    "@orpc/tanstack-query": "^1.14.15",
+    "@react-pdf/renderer": "^4.5.1",
+    "@t3-oss/env-nextjs": "^0.13.11",
+    "@tailwindcss/typography": "^0.5.20",
+    "@tanstack/db": "^0.6.17",
+    "@tanstack/react-query": "^5.101.4",
+    "@tanstack/react-table": "^8.21.3",
+    "@tulip-systems/app": "0.11.1",
+    "@tulip-systems/auth": "0.11.1",
+    "@tulip-systems/commands": "0.11.1",
+    "@tulip-systems/core": "0.11.1",
+    "@tulip-systems/data-tables": "0.11.1",
+    "@tulip-systems/drive": "0.11.1",
+    "@tulip-systems/drive-local": "0.11.1",
+    "@tulip-systems/editor": "0.11.1",
+    "@tulip-systems/editor-storage": "0.11.1",
+    "@tulip-systems/inline": "0.11.1",
+    "@tulip-systems/query": "0.11.1",
+    "@tulip-systems/storage": "0.11.1",
+    "@tulip-systems/ui": "0.11.1",
+    "@vercel/functions": "^3.9.0",
+    "@zip.js/zip.js": "^2.8.34",
+    "better-auth": "^1.6.26",
+    "class-variance-authority": "^0.7.1",
+    "client-only": "^0.0.1",
+    "date-fns": "^4.4.0",
+    "decimal.js": "^10.6.0",
+    "drizzle-orm": "^0.45.2",
+    "drizzle-seed": "^0.3.1",
+    "drizzle-zod": "^0.8.3",
+    "lucide-react": "^1.30.0",
+    "motion": "^13.0.0",
+    "next": "16.3.0",
+    "nuqs": "2.9.5",
+    "pdf-lib": "^1.17.1",
+    "pg": "8.22.0",
+    "postgres": "^3.4.9",
+    "react": "19.2.8",
+    "react-dom": "19.2.8",
+    "react-hook-form": "^7.84.0",
+    "react-pdf-tailwind": "^3.0.0",
+    "recharts": "3.10.1",
+    "resend": "^6.18.1",
+    "sanitize-filename": "^1.6.4",
+    "sharp": "^0.35.3",
+    "server-only": "^0.0.1",
+    "uuid": "^14.0.1",
+    "xlsx": "^0.18.5",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@faker-js/faker": "^10.5.0",
+    "@tailwindcss/postcss": "^4.3.3",
+    "@types/node": "^26.2.0",
+    "@types/pg": "^8.21.0",
+    "@types/react": "19.2.17",
+    "@types/react-dom": "19.2.4",
+    "baseline-browser-mapping": "^2.11.12",
+    "dotenv-cli": "^11.0.0",
+    "drizzle-kit": "^0.31.10",
+    "postcss": "^8.5.26",
+    "server-cli-only": "^0.3.2",
+    "tailwindcss": "^4.3.3",
+    "tsx": "^4.23.11",
+    "typescript": "5.9.3"
+  }
+}

package/dist/templates/spark/postcss.config.js

@@ -0,0 +1,6 @@
+/** @type {import('postcss-load-config').Config} */
+const config = {
+  plugins: ["@tailwindcss/postcss"],
+};
+
+export default config;