@tulip-systems/create-app 0.11.1

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

@@ -0,0 +1,336 @@
+import { relations, type SQL, sql } from "drizzle-orm";
+import { index, pgTable } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import type { z } from "zod";
+import { baseColumns } from "@/server/db/helpers";
+
+/**
+ * Users
+ */
+export const users = pgTable("users", (t) => ({
+  ...baseColumns,
+  name: t
+    .varchar()
+    .notNull()
+    .generatedAlwaysAs((): SQL => sql`${users.firstName} || ' ' || ${users.lastName}`),
+  firstName: t.varchar().notNull(),
+  lastName: t.varchar().notNull(),
+  email: t.text().notNull().unique(),
+  emailVerified: t.boolean().notNull(),
+  image: t.text(),
+  role: t.text(),
+  banned: t.boolean(),
+  banReason: t.text(),
+  banExpires: t.timestamp(),
+}));
+
+export const usersRelations = relations(users, ({ many }) => ({
+  sessions: many(sessions),
+  accounts: many(accounts),
+  verifications: many(verifications),
+  passkeys: many(passkeys),
+}));
+
+/**
+ * Sessions
+ */
+export const sessions = pgTable("sessions", (t) => ({
+  ...baseColumns,
+  expiresAt: t.timestamp().notNull(),
+  token: t.text().notNull().unique(),
+  ipAddress: t.text(),
+  userAgent: t.text(),
+  impersonatedBy: t.text(),
+  userId: t
+    .uuid()
+    .notNull()
+    .references(() => users.id, { onDelete: "cascade" }),
+}));
+
+export const sessionsRelations = relations(sessions, ({ one }) => ({
+  user: one(users, {
+    fields: [sessions.userId],
+    references: [users.id],
+  }),
+}));
+
+/**
+ * Accounts
+ */
+export const accounts = pgTable("accounts", (t) => ({
+  ...baseColumns,
+  accountId: t.text().notNull(),
+  providerId: t.text().notNull(),
+  accessToken: t.text(),
+  refreshToken: t.text(),
+  idToken: t.text(),
+  accessTokenExpiresAt: t.timestamp(),
+  refreshTokenExpiresAt: t.timestamp(),
+  scope: t.text(),
+  password: t.text(),
+  userId: t
+    .uuid()
+    .notNull()
+    .references(() => users.id, { onDelete: "cascade" }),
+}));
+
+export const accountsRelations = relations(accounts, ({ one }) => ({
+  user: one(users, {
+    fields: [accounts.userId],
+    references: [users.id],
+  }),
+}));
+
+/**
+ * Verifications
+ */
+export const verifications = pgTable("verifications", (t) => ({
+  ...baseColumns,
+  identifier: t.text().notNull(),
+  value: t.text().notNull(),
+  expiresAt: t.timestamp().notNull(),
+}));
+
+export const verificationsRelations = relations(verifications, ({ one }) => ({
+  user: one(users, {
+    fields: [verifications.identifier],
+    references: [users.id],
+  }),
+}));
+
+/**
+ * Passkeys
+ */
+export const passkeys = pgTable("passkeys", (t) => ({
+  ...baseColumns,
+  name: t.text(),
+  publicKey: t.text().notNull(),
+  credentialID: t.text().notNull(),
+  counter: t.integer().notNull(),
+  deviceType: t.text().notNull(),
+  backedUp: t.boolean().notNull(),
+  transports: t.text(),
+  aaguid: t.text(),
+  userId: t
+    .uuid()
+    .notNull()
+    .references(() => users.id, { onDelete: "cascade" }),
+}));
+
+export const passkeysRelations = relations(passkeys, ({ one }) => ({
+  user: one(users, {
+    fields: [passkeys.userId],
+    references: [users.id],
+  }),
+}));
+
+export type User = typeof users.$inferSelect;
+
+export const selectUserSchema = createInsertSchema(users);
+export type SelectUserSchema = z.infer<typeof selectUserSchema>;
+
+export const updateUserSchema = createInsertSchema(users).pick({
+  firstName: true,
+  lastName: true,
+  email: true,
+  image: true,
+});
+export type UpdateUserSchema = z.infer<typeof updateUserSchema>;
+
+/**
+ * The jwkss table stores the JSON Web Key Sets (JWKS) used for signing and verifying JWTs in the authentication system. Each entry in the table represents a JWKS, which contains a set of cryptographic keys.
+ */
+const jwkss = pgTable("jwkss", (t) => ({
+  ...baseColumns,
+  publicKey: t.text().notNull(),
+  privateKey: t.text().notNull(),
+  expiresAt: t.timestamp(),
+}));
+
+/**
+ * The oauthClients table stores information about OAuth clients that are registered to use the authentication system.
+ */
+const oauthClients = pgTable(
+  "oauth_clients",
+  (t) => ({
+    ...baseColumns,
+    clientId: t.text().notNull().unique(),
+    clientSecret: t.text(),
+    disabled: t.boolean().default(false),
+    skipConsent: t.boolean(),
+    enableEndSession: t.boolean(),
+    subjectType: t.text(),
+    scopes: t.text().array(),
+    userId: t.uuid().references(() => users.id, { onDelete: "cascade" }),
+    createdAt: t.timestamp(),
+    updatedAt: t.timestamp(),
+    name: t.text(),
+    uri: t.text(),
+    icon: t.text(),
+    contacts: t.text().array(),
+    tos: t.text(),
+    policy: t.text(),
+    softwareId: t.text(),
+    softwareVersion: t.text(),
+    softwareStatement: t.text(),
+    redirectUris: t.text().array().notNull(),
+    postLogoutRedirectUris: t.text().array(),
+    tokenEndpointAuthMethod: t.text(),
+    grantTypes: t.text().array(),
+    responseTypes: t.text().array(),
+    public: t.boolean(),
+    type: t.text(),
+    requirePKCE: t.boolean(),
+    referenceId: t.text(),
+    metadata: t.jsonb(),
+  }),
+  (table) => [index("oauthClients_userId_idx").on(table.userId)],
+);
+
+const oauthClientsRelations = relations(oauthClients, ({ one, many }) => ({
+  users: one(users, {
+    fields: [oauthClients.userId],
+    references: [users.id],
+  }),
+  oauthRefreshTokens: many(oauthRefreshTokens),
+  oauthAccessTokens: many(oauthAccessTokens),
+  oauthConsents: many(oauthConsents),
+}));
+
+/**
+ * The oauthRefreshTokens table stores refresh tokens issued to clients for maintaining user sessions in the authentication system.
+ */
+const oauthRefreshTokens = pgTable(
+  "oauth_refresh_tokens",
+  (t) => ({
+    ...baseColumns,
+    token: t.text().notNull(),
+    clientId: t
+      .text()
+      .notNull()
+      .references(() => oauthClients.clientId, { onDelete: "cascade" }),
+    sessionId: t.uuid().references(() => sessions.id, { onDelete: "set null" }),
+    userId: t
+      .uuid()
+      .notNull()
+      .references(() => users.id, { onDelete: "cascade" }),
+    referenceId: t.text(),
+    expiresAt: t.timestamp().notNull(),
+    revoked: t.timestamp(),
+    authTime: t.timestamp(),
+    scopes: t.text().array().notNull(),
+  }),
+  (table) => [
+    index("oauthRefreshTokens_clientId_idx").on(table.clientId),
+    index("oauthRefreshTokens_sessionId_idx").on(table.sessionId),
+    index("oauthRefreshTokens_userId_idx").on(table.userId),
+  ],
+);
+
+const oauthRefreshTokensRelations = relations(oauthRefreshTokens, ({ one, many }) => ({
+  oauthClients: one(oauthClients, {
+    fields: [oauthRefreshTokens.clientId],
+    references: [oauthClients.clientId],
+  }),
+  sessions: one(sessions, {
+    fields: [oauthRefreshTokens.sessionId],
+    references: [sessions.id],
+  }),
+  users: one(users, {
+    fields: [oauthRefreshTokens.userId],
+    references: [users.id],
+  }),
+  oauthAccessTokens: many(oauthAccessTokens),
+}));
+
+/**
+ * The oauthAccessTokens table stores access tokens issued to clients for accessing protected resources in the authentication system.
+ */
+const oauthAccessTokens = pgTable(
+  "oauth_access_tokens",
+  (t) => ({
+    ...baseColumns,
+    token: t.text().notNull().unique(),
+    clientId: t
+      .text()
+      .notNull()
+      .references(() => oauthClients.clientId, { onDelete: "cascade" }),
+    sessionId: t.uuid().references(() => sessions.id, { onDelete: "set null" }),
+    userId: t.uuid().references(() => users.id, { onDelete: "cascade" }),
+    referenceId: t.text(),
+    refreshId: t.uuid().references(() => oauthRefreshTokens.id, { onDelete: "cascade" }),
+    expiresAt: t.timestamp().notNull(),
+    scopes: t.text().array().notNull(),
+  }),
+  (table) => [
+    index("oauthAccessTokens_clientId_idx").on(table.clientId),
+    index("oauthAccessTokens_sessionId_idx").on(table.sessionId),
+    index("oauthAccessTokens_userId_idx").on(table.userId),
+    index("oauthAccessTokens_refreshId_idx").on(table.refreshId),
+  ],
+);
+const oauthAccessTokensRelations = relations(oauthAccessTokens, ({ one }) => ({
+  oauthClients: one(oauthClients, {
+    fields: [oauthAccessTokens.clientId],
+    references: [oauthClients.clientId],
+  }),
+  sessions: one(sessions, {
+    fields: [oauthAccessTokens.sessionId],
+    references: [sessions.id],
+  }),
+  users: one(users, {
+    fields: [oauthAccessTokens.userId],
+    references: [users.id],
+  }),
+  oauthRefreshTokens: one(oauthRefreshTokens, {
+    fields: [oauthAccessTokens.refreshId],
+    references: [oauthRefreshTokens.id],
+  }),
+}));
+
+/**
+ * The oauthConsents table stores user consents for OAuth clients in the authentication system, allowing users to manage their permissions for different applications.
+ */
+const oauthConsents = pgTable(
+  "oauth_consents",
+  (t) => ({
+    ...baseColumns,
+    clientId: t
+      .text()
+      .notNull()
+      .references(() => oauthClients.clientId, { onDelete: "cascade" }),
+    userId: t.uuid().references(() => users.id, { onDelete: "cascade" }),
+    referenceId: t.text(),
+    scopes: t.text().array().notNull(),
+  }),
+  (table) => [
+    index("oauthConsents_clientId_idx").on(table.clientId),
+    index("oauthConsents_userId_idx").on(table.userId),
+  ],
+);
+
+const oauthConsentsRelations = relations(oauthConsents, ({ one }) => ({
+  oauthClients: one(oauthClients, {
+    fields: [oauthConsents.clientId],
+    references: [oauthClients.clientId],
+  }),
+  users: one(users, {
+    fields: [oauthConsents.userId],
+    references: [users.id],
+  }),
+}));
+
+/**
+ * Exports
+ */
+export {
+  jwkss,
+  oauthAccessTokens,
+  oauthAccessTokensRelations,
+  oauthClients,
+  oauthClientsRelations,
+  oauthConsents,
+  oauthConsentsRelations,
+  oauthRefreshTokens,
+  oauthRefreshTokensRelations,
+};

package/dist/templates/code/src/server/db/helpers.ts

@@ -0,0 +1,14 @@
+import { sql } from "drizzle-orm";
+import { timestamp, uuid } from "drizzle-orm/pg-core";
+import { v7 as uuidv7 } from "uuid";
+
+export const generateDefaultUUID = () => uuidv7();
+
+export const baseColumns = {
+  id: uuid().primaryKey().default(sql`uuidv7()`),
+  createdAt: timestamp().defaultNow().notNull(),
+  updatedAt: timestamp()
+    .defaultNow()
+    .notNull()
+    .$onUpdate(() => new Date()),
+};

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

@@ -0,0 +1,17 @@
+import { attachDatabasePool } from "@vercel/functions";
+import { drizzle } from "drizzle-orm/node-postgres";
+import { Pool } from "pg";
+import { env } from "@/env";
+import * as schema from "./schema";
+import type { DatabaseSchema } from "./types";
+
+const pool = new Pool({
+  connectionString: env.DATABASE_URL,
+  max: 15,
+  idleTimeoutMillis: 5000,
+  connectionTimeoutMillis: 2000,
+});
+
+attachDatabasePool(pool);
+
+export const db = drizzle<DatabaseSchema>({ client: pool, schema, casing: "snake_case" });

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

@@ -0,0 +1,18 @@
+// biome-ignore assist/source/organizeImports: The auth schema should be exported first
+export * from "../auth/schema";
+export {
+  storageAssetStatusEnum,
+  storageAssets,
+  storageAssetVisibilityEnum,
+} from "../storage/schema";
+
+export * from "@/app/admin/addresses/_lib/schema";
+export * from "@/app/admin/contacts/_lib/schema";
+export * from "@/app/admin/customers/_lib/schema";
+export * from "@/app/admin/domains/_lib/schema";
+export * from "@/app/admin/employees/_lib/schema";
+export * from "@/app/admin/initiatives/_lib/schema";
+export * from "@/app/admin/projects/_lib/schema";
+export * from "@/app/admin/tasks/_lib/schema";
+export * from "@/app/admin/time/_lib/schema";
+export * from "@/app/admin/prospects/_lib/schema";

package/dist/templates/code/src/server/db/seed.ts

@@ -0,0 +1,119 @@
+import { faker } from "@faker-js/faker/locale/nl_BE";
+import { reset, seed } from "drizzle-seed";
+import { COUNTRY_CODES, DEFAULT_ADDRESS_TYPE } from "@/app/admin/addresses/_lib/constants";
+import { projectStatusConfig } from "@/app/admin/projects/_config/status";
+import { generateDefaultUUID } from "./helpers";
+import { db } from "./init";
+import * as schema from "./schema";
+
+const seedSchema = {
+  addresses: schema.addresses,
+  contacts: schema.contacts,
+  customers: schema.customers,
+  customersContacts: schema.customersContacts,
+  customersAddresses: schema.customersAddresses,
+  projects: schema.projects,
+  tasks: schema.tasks,
+};
+
+console.info("🌱  The seed command has been started. \n");
+
+console.info("🗑️  Resetting the database...");
+await reset(db, seedSchema);
+
+console.info("--------------------");
+
+console.info("🌱  Seeding the database...");
+const ids = Array.from({ length: 100000 }, () => generateDefaultUUID());
+
+await seed(db, seedSchema).refine((f) => ({
+  addresses: {
+    count: 100,
+    columns: {
+      id: f.valuesFromArray({ values: ids, isUnique: true }),
+      street: f.streetAddress(),
+      postalCode: f.postcode(),
+      city: f.city(),
+      countryCode: f.valuesFromArray({ values: COUNTRY_CODES }),
+      type: f.default({ defaultValue: DEFAULT_ADDRESS_TYPE }),
+      //   type: f.valuesFromArray({ values: ADDRESS_TYPES.map((type) => type.id) }),
+      name: f.default({ defaultValue: null }),
+      isDeleted: f.boolean(),
+    },
+  },
+  contacts: {
+    count: 150,
+    columns: {
+      id: f.valuesFromArray({ values: ids, isUnique: true }),
+      firstName: f.firstName(),
+      lastName: f.lastName(),
+      email: f.email(),
+      phone: f.phoneNumber({ template: "+32 484 ## ## ##" }),
+      position: f.jobTitle(),
+    },
+  },
+  customers: {
+    count: 50,
+    columns: {
+      id: f.valuesFromArray({ values: ids, isUnique: true }),
+      name: f.companyName({ isUnique: true }),
+      tradeName: f.default({ defaultValue: null }),
+      vat: f.valuesFromArray({
+        values: Array.from(
+          { length: 50 },
+          () => `BE${faker.number.bigInt({ min: 10000000000, max: 99999999999 })}`,
+        ),
+      }),
+      email: f.email(),
+      phone: f.phoneNumber({ template: "011 ## ## ##" }),
+      website: f.default({ defaultValue: null }),
+      notes: f.default({ defaultValue: null }),
+      isDeleted: f.boolean(),
+    },
+    with: {
+      customersAddresses: 1,
+      customersContacts: 1,
+    },
+  },
+  projects: {
+    count: 30,
+    columns: {
+      id: f.valuesFromArray({ values: ids, isUnique: true }),
+      name: f.companyName({ isUnique: true }),
+      budget: f.int({ minValue: 0, maxValue: 100000 }),
+      startDate: f.date({ maxDate: new Date() }),
+      deadline: f.date({ minDate: new Date() }),
+      notes: f.default({ defaultValue: null }),
+      endDate: f.default({ defaultValue: null }),
+      status: f.valuesFromArray({ values: projectStatusConfig.flatMap(({ value }) => value) }),
+      isDeleted: f.weightedRandom([
+        { weight: 0.8, value: f.default({ defaultValue: false }) },
+        { weight: 0.2, value: f.default({ defaultValue: true }) },
+      ]),
+    },
+    with: {
+      tasks: [
+        { weight: 0.2, count: 100 },
+        { weight: 0.2, count: 50 },
+        { weight: 0.2, count: 10 },
+        { weight: 0.4, count: 30 },
+      ],
+    },
+  },
+  tasks: {
+    columns: {
+      id: f.valuesFromArray({ values: ids, isUnique: true }),
+      title: f.valuesFromArray({
+        values: Array.from({ length: 1000 }, () => faker.hacker.phrase()),
+      }),
+      status: f.valuesFromArray({ values: schema.taskStatusEnum.enumValues }),
+      description: f.default({ defaultValue: null }),
+      isDeleted: f.boolean(),
+    },
+  },
+}));
+
+console.info("✅  The seed command has been completed.");
+
+console.info("--------------------");
+process.exit(0);

package/dist/templates/code/src/server/db/types.ts

@@ -0,0 +1,3 @@
+import type * as schema from "./schema";
+
+export type DatabaseSchema = typeof schema;

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

@@ -0,0 +1,4 @@
+import { Resend } from "resend";
+import { env } from "@/env";
+
+export const email = new Resend(env.RESEND_API_KEY);

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

@@ -0,0 +1,50 @@
+import "server-cli-only";
+
+import { ORPCError } from "@orpc/server";
+import type { JWTPayload } from "better-auth";
+import { type RPCContext, rpc } from "../router/init";
+
+/**
+ * MCP Router meta
+ */
+export type McpRouterMeta = {
+  title: string;
+  description: string;
+};
+
+/**
+ * MCP Context type that extends the RPCContext with an optional JWT payload
+ */
+export type McpContext = RPCContext & {
+  jwt?: JWTPayload;
+};
+/**
+ * MCP Procedure with access token middleware to ensure that only authenticated users can access the procedures defined in this router
+ */
+export const mcpProcedure = rpc
+  .$meta<McpRouterMeta>({
+    title: "MCP Procedure",
+    description: "A procedure that requires an access token to be called.",
+  })
+  .$context<McpContext>()
+  .use(async ({ next, context }) => {
+    const { jwt, headers } = context;
+
+    // Extract the access token from the authorization header
+    const authorization = headers?.get("authorization") ?? undefined;
+    const accessToken = authorization?.startsWith("Bearer ")
+      ? authorization.replace("Bearer ", "")
+      : authorization;
+
+    // Extract the user ID from the JWT payload
+    const userId = context.jwt?.sub;
+
+    // If the user ID or access token is missing, throw an unauthorized error
+    if (!userId || !accessToken) {
+      throw new ORPCError("UNAUTHORIZED", {
+        message: "Jou hebt geen toegang om deze actie uit te voeren",
+      });
+    }
+
+    return next({ context: { accessToken, userId, jwt } });
+  });