@nubase/create 0.1.1

package/templates/backend/src/api/routes/auth.ts

@@ -0,0 +1,209 @@
+import bcrypt from "bcrypt";
+import { eq } from "drizzle-orm";
+import type { Context } from "hono";
+import { __PROJECT_NAME_PASCAL__AuthController } from "../../auth";
+import { adminDb, db } from "../../db/helpers/drizzle";
+import { userWorkspaces, users, workspaces } from "../../db/schema";
+
+const authController = new __PROJECT_NAME_PASCAL__AuthController();
+
+export const authHandlers = {
+	async loginStart(c: Context) {
+		const { email, password } = await c.req.json();
+
+		const [user] = await db.select().from(users).where(eq(users.email, email));
+
+		if (!user) {
+			return c.json({ error: "Invalid credentials" }, 401);
+		}
+
+		const isValid = await bcrypt.compare(password, user.passwordHash);
+		if (!isValid) {
+			return c.json({ error: "Invalid credentials" }, 401);
+		}
+
+		// Get user's workspaces
+		const userWs = await db
+			.select({
+				id: workspaces.id,
+				slug: workspaces.slug,
+				name: workspaces.name,
+			})
+			.from(userWorkspaces)
+			.innerJoin(workspaces, eq(userWorkspaces.workspaceId, workspaces.id))
+			.where(eq(userWorkspaces.userId, user.id));
+
+		return c.json({ workspaces: userWs });
+	},
+
+	async loginComplete(c: Context) {
+		const { email, password, workspaceId } = await c.req.json();
+
+		const [user] = await db.select().from(users).where(eq(users.email, email));
+
+		if (!user) {
+			return c.json({ error: "Invalid credentials" }, 401);
+		}
+
+		const isValid = await bcrypt.compare(password, user.passwordHash);
+		if (!isValid) {
+			return c.json({ error: "Invalid credentials" }, 401);
+		}
+
+		const [workspace] = await db
+			.select()
+			.from(workspaces)
+			.where(eq(workspaces.id, workspaceId));
+
+		if (!workspace) {
+			return c.json({ error: "Workspace not found" }, 404);
+		}
+
+		const token = authController.generateToken({
+			userId: user.id,
+			workspaceId: workspace.id,
+			email: user.email,
+		});
+
+		return c.json({
+			token,
+			user: { id: user.id, email: user.email, username: user.username },
+			workspace: { id: workspace.id, slug: workspace.slug, name: workspace.name },
+		});
+	},
+
+	async login(c: Context) {
+		const { email, password } = await c.req.json();
+
+		const [user] = await db.select().from(users).where(eq(users.email, email));
+
+		if (!user) {
+			return c.json({ error: "Invalid credentials" }, 401);
+		}
+
+		const isValid = await bcrypt.compare(password, user.passwordHash);
+		if (!isValid) {
+			return c.json({ error: "Invalid credentials" }, 401);
+		}
+
+		// Get first workspace for simple login
+		const [userWs] = await db
+			.select({
+				id: workspaces.id,
+				slug: workspaces.slug,
+				name: workspaces.name,
+			})
+			.from(userWorkspaces)
+			.innerJoin(workspaces, eq(userWorkspaces.workspaceId, workspaces.id))
+			.where(eq(userWorkspaces.userId, user.id));
+
+		if (!userWs) {
+			return c.json({ error: "No workspace found" }, 404);
+		}
+
+		const token = authController.generateToken({
+			userId: user.id,
+			workspaceId: userWs.id,
+			email: user.email,
+		});
+
+		return c.json({
+			token,
+			user: { id: user.id, email: user.email, username: user.username },
+			workspace: userWs,
+		});
+	},
+
+	async logout(c: Context) {
+		// Client-side token removal
+		return c.json({ success: true });
+	},
+
+	async getMe(c: Context) {
+		const authHeader = c.req.header("Authorization");
+		if (!authHeader?.startsWith("Bearer ")) {
+			return c.json({ error: "Unauthorized" }, 401);
+		}
+
+		const token = authHeader.slice(7);
+		const payload = authController.verifyToken(token);
+
+		if (!payload) {
+			return c.json({ error: "Invalid token" }, 401);
+		}
+
+		const [user] = await db
+			.select()
+			.from(users)
+			.where(eq(users.id, payload.userId));
+
+		if (!user) {
+			return c.json({ error: "User not found" }, 404);
+		}
+
+		const [workspace] = await db
+			.select()
+			.from(workspaces)
+			.where(eq(workspaces.id, payload.workspaceId));
+
+		return c.json({
+			user: { id: user.id, email: user.email, username: user.username },
+			workspace: workspace
+				? { id: workspace.id, slug: workspace.slug, name: workspace.name }
+				: null,
+		});
+	},
+
+	async signup(c: Context) {
+		const { email, username, password, workspaceName } = await c.req.json();
+
+		// Check if user exists
+		const [existingUser] = await db
+			.select()
+			.from(users)
+			.where(eq(users.email, email));
+
+		if (existingUser) {
+			return c.json({ error: "Email already registered" }, 400);
+		}
+
+		// Create user
+		const passwordHash = await bcrypt.hash(password, 10);
+		const [user] = await adminDb
+			.insert(users)
+			.values({ email, username, passwordHash })
+			.returning();
+
+		// Create or get workspace
+		const wsSlug = workspaceName?.toLowerCase().replace(/\s+/g, "-") || "default";
+		let [workspace] = await db
+			.select()
+			.from(workspaces)
+			.where(eq(workspaces.slug, wsSlug));
+
+		if (!workspace) {
+			[workspace] = await adminDb
+				.insert(workspaces)
+				.values({ slug: wsSlug, name: workspaceName || "Default Workspace" })
+				.returning();
+		}
+
+		// Link user to workspace
+		await adminDb.insert(userWorkspaces).values({
+			userId: user.id,
+			workspaceId: workspace.id,
+		});
+
+		const token = authController.generateToken({
+			userId: user.id,
+			workspaceId: workspace.id,
+			email: user.email,
+		});
+
+		return c.json({
+			token,
+			user: { id: user.id, email: user.email, username: user.username },
+			workspace: { id: workspace.id, slug: workspace.slug, name: workspace.name },
+		});
+	},
+};

package/templates/backend/src/api/routes/index.ts

@@ -0,0 +1,2 @@
+export * from "./ticket";
+export * from "./auth";

package/templates/backend/src/api/routes/ticket.ts

@@ -0,0 +1,62 @@
+import { eq } from "drizzle-orm";
+import type { Context } from "hono";
+import { db } from "../../db/helpers/drizzle";
+import { tickets } from "../../db/schema";
+
+export const ticketHandlers = {
+	async getTickets(c: Context) {
+		const allTickets = await db.select().from(tickets);
+		return c.json(allTickets);
+	},
+
+	async getTicket(c: Context) {
+		const id = Number(c.req.param("id"));
+		const [ticket] = await db.select().from(tickets).where(eq(tickets.id, id));
+
+		if (!ticket) {
+			return c.json({ error: "Ticket not found" }, 404);
+		}
+
+		return c.json(ticket);
+	},
+
+	async postTicket(c: Context) {
+		const body = await c.req.json();
+		const [ticket] = await db
+			.insert(tickets)
+			.values({
+				workspaceId: 1, // TODO: Get from context
+				title: body.title,
+				description: body.description,
+			})
+			.returning();
+
+		return c.json(ticket, 201);
+	},
+
+	async patchTicket(c: Context) {
+		const id = Number(c.req.param("id"));
+		const body = await c.req.json();
+
+		const [ticket] = await db
+			.update(tickets)
+			.set({
+				...body,
+				updatedAt: new Date(),
+			})
+			.where(eq(tickets.id, id))
+			.returning();
+
+		if (!ticket) {
+			return c.json({ error: "Ticket not found" }, 404);
+		}
+
+		return c.json(ticket);
+	},
+
+	async deleteTicket(c: Context) {
+		const id = Number(c.req.param("id"));
+		await db.delete(tickets).where(eq(tickets.id, id));
+		return c.json({ success: true });
+	},
+};

package/templates/backend/src/auth/index.ts

@@ -0,0 +1,37 @@
+import bcrypt from "bcrypt";
+import jwt from "jsonwebtoken";
+import type { User, Workspace } from "__PROJECT_NAME__-schema";
+
+export interface __PROJECT_NAME_PASCAL__User extends User {
+	workspace: Workspace;
+}
+
+export interface TokenPayload {
+	userId: number;
+	workspaceId: number;
+	email: string;
+}
+
+const JWT_SECRET = process.env.JWT_SECRET || "your-secret-key";
+
+export class __PROJECT_NAME_PASCAL__AuthController {
+	async hashPassword(password: string): Promise<string> {
+		return bcrypt.hash(password, 10);
+	}
+
+	async verifyPassword(password: string, hash: string): Promise<boolean> {
+		return bcrypt.compare(password, hash);
+	}
+
+	generateToken(payload: TokenPayload): string {
+		return jwt.sign(payload, JWT_SECRET, { expiresIn: "7d" });
+	}
+
+	verifyToken(token: string): TokenPayload | null {
+		try {
+			return jwt.verify(token, JWT_SECRET) as TokenPayload;
+		} catch {
+			return null;
+		}
+	}
+}

package/templates/backend/src/db/helpers/drizzle.ts

@@ -0,0 +1,34 @@
+import { drizzle } from "drizzle-orm/node-postgres";
+import pg from "pg";
+import * as schema from "../schema";
+
+const { Pool } = pg;
+
+// Main app pool (uses RLS-restricted user)
+const appPool = new Pool({
+	connectionString: process.env.DATABASE_URL,
+});
+
+// Admin pool (bypasses RLS for setup operations)
+const adminPool = new Pool({
+	connectionString: process.env.DATABASE_URL_ADMIN,
+});
+
+export const db = drizzle(appPool, { schema });
+export const adminDb = drizzle(adminPool, { schema });
+
+// Set workspace context for RLS
+export async function withWorkspaceContext<T>(
+	workspaceId: number,
+	fn: () => Promise<T>,
+): Promise<T> {
+	const client = await appPool.connect();
+	try {
+		await client.query(`SET app.current_workspace_id = '${workspaceId}'`);
+		const result = await fn();
+		return result;
+	} finally {
+		await client.query("RESET app.current_workspace_id");
+		client.release();
+	}
+}

package/templates/backend/src/db/schema/index.ts

@@ -0,0 +1,4 @@
+export * from "./workspace";
+export * from "./user";
+export * from "./user-workspace";
+export * from "./ticket";

package/templates/backend/src/db/schema/ticket.ts

@@ -0,0 +1,13 @@
+import { integer, pgTable, serial, text, timestamp, varchar } from "drizzle-orm/pg-core";
+import { workspaces } from "./workspace";
+
+export const tickets = pgTable("tickets", {
+	id: serial("id").primaryKey(),
+	workspaceId: integer("workspace_id")
+		.notNull()
+		.references(() => workspaces.id, { onDelete: "cascade" }),
+	title: varchar("title", { length: 255 }).notNull(),
+	description: text("description"),
+	createdAt: timestamp("created_at", { withTimezone: true }).defaultNow(),
+	updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow(),
+});

package/templates/backend/src/db/schema/user-workspace.ts

@@ -0,0 +1,17 @@
+import { integer, pgTable, primaryKey, timestamp } from "drizzle-orm/pg-core";
+import { users } from "./user";
+import { workspaces } from "./workspace";
+
+export const userWorkspaces = pgTable(
+	"user_workspaces",
+	{
+		userId: integer("user_id")
+			.notNull()
+			.references(() => users.id, { onDelete: "cascade" }),
+		workspaceId: integer("workspace_id")
+			.notNull()
+			.references(() => workspaces.id, { onDelete: "cascade" }),
+		createdAt: timestamp("created_at", { withTimezone: true }).defaultNow(),
+	},
+	(table) => [primaryKey({ columns: [table.userId, table.workspaceId] })],
+);

package/templates/backend/src/db/schema/user.ts

@@ -0,0 +1,10 @@
+import { pgTable, serial, timestamp, varchar } from "drizzle-orm/pg-core";
+
+export const users = pgTable("users", {
+	id: serial("id").primaryKey(),
+	email: varchar("email", { length: 255 }).unique().notNull(),
+	username: varchar("username", { length: 100 }).unique().notNull(),
+	passwordHash: varchar("password_hash", { length: 255 }).notNull(),
+	createdAt: timestamp("created_at", { withTimezone: true }).defaultNow(),
+	updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow(),
+});

package/templates/backend/src/db/schema/workspace.ts

@@ -0,0 +1,9 @@
+import { pgTable, serial, timestamp, varchar } from "drizzle-orm/pg-core";
+
+export const workspaces = pgTable("workspaces", {
+	id: serial("id").primaryKey(),
+	slug: varchar("slug", { length: 100 }).unique().notNull(),
+	name: varchar("name", { length: 255 }).notNull(),
+	createdAt: timestamp("created_at", { withTimezone: true }).defaultNow(),
+	updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow(),
+});

package/templates/backend/src/db/seed.ts

@@ -0,0 +1,71 @@
+import { faker } from "@faker-js/faker";
+import bcrypt from "bcrypt";
+import { loadEnv } from "../helpers/env";
+import { adminDb } from "./helpers/drizzle";
+import { tickets, userWorkspaces, users, workspaces } from "./schema";
+
+loadEnv();
+
+async function seed() {
+	console.log("Seeding database...");
+
+	// Create default workspace
+	const [workspace] = await adminDb
+		.insert(workspaces)
+		.values({
+			slug: "default",
+			name: "Default Workspace",
+		})
+		.onConflictDoNothing()
+		.returning();
+
+	const workspaceId = workspace?.id ?? 1;
+	console.log(`Created/found workspace: ${workspaceId}`);
+
+	// Create test user
+	const passwordHash = await bcrypt.hash("password123", 10);
+	const [user] = await adminDb
+		.insert(users)
+		.values({
+			email: "demo@example.com",
+			username: "demo",
+			passwordHash,
+		})
+		.onConflictDoNothing()
+		.returning();
+
+	if (user) {
+		console.log(`Created user: ${user.email}`);
+
+		// Link user to workspace
+		await adminDb
+			.insert(userWorkspaces)
+			.values({
+				userId: user.id,
+				workspaceId,
+			})
+			.onConflictDoNothing();
+	}
+
+	// Create sample tickets
+	const ticketData = Array.from({ length: 10 }, () => ({
+		workspaceId,
+		title: faker.lorem.sentence(),
+		description: faker.lorem.paragraph(),
+	}));
+
+	await adminDb.insert(tickets).values(ticketData).onConflictDoNothing();
+	console.log(`Created ${ticketData.length} sample tickets`);
+
+	console.log("Database seeded successfully!");
+	console.log("\nTest credentials:");
+	console.log("  Email: demo@example.com");
+	console.log("  Password: password123");
+
+	process.exit(0);
+}
+
+seed().catch((error) => {
+	console.error("Seed failed:", error);
+	process.exit(1);
+});

package/templates/backend/src/helpers/env.ts

@@ -0,0 +1,10 @@
+import dotenv from "dotenv";
+import path from "node:path";
+
+export function loadEnv(): void {
+	const nodeEnv = process.env.NODE_ENV || "development";
+	const envFile = `.env.${nodeEnv}`;
+
+	dotenv.config({ path: path.resolve(process.cwd(), envFile) });
+	dotenv.config({ path: path.resolve(process.cwd(), ".env") });
+}

package/templates/backend/src/index.ts

@@ -0,0 +1,55 @@
+import { serve } from "@hono/node-server";
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { ticketHandlers } from "./api/routes/ticket";
+import { authHandlers } from "./api/routes/auth";
+import { workspaceMiddleware } from "./middleware/workspace-middleware";
+import { __PROJECT_NAME_PASCAL__AuthController } from "./auth";
+import { loadEnv } from "./helpers/env";
+
+// Load environment variables
+loadEnv();
+
+const app = new Hono();
+
+// CORS configuration
+app.use(
+	"*",
+	cors({
+		origin: ["http://localhost:__FRONTEND_PORT__"],
+		credentials: true,
+	}),
+);
+
+// Workspace middleware (extracts workspace from path)
+app.use("/:workspace/*", workspaceMiddleware);
+
+// Auth controller
+const authController = new __PROJECT_NAME_PASCAL__AuthController();
+
+// Routes
+app.get("/:workspace", (c) => c.json({ message: "Welcome to __PROJECT_NAME_PASCAL__ API" }));
+
+// Auth routes
+app.post("/:workspace/auth/login/start", authHandlers.loginStart);
+app.post("/:workspace/auth/login/complete", authHandlers.loginComplete);
+app.post("/:workspace/auth/login", authHandlers.login);
+app.post("/:workspace/auth/logout", authHandlers.logout);
+app.get("/:workspace/auth/me", authHandlers.getMe);
+app.post("/:workspace/auth/signup", authHandlers.signup);
+
+// Ticket routes
+app.get("/:workspace/tickets", ticketHandlers.getTickets);
+app.get("/:workspace/tickets/:id", ticketHandlers.getTicket);
+app.post("/:workspace/tickets", ticketHandlers.postTicket);
+app.patch("/:workspace/tickets/:id", ticketHandlers.patchTicket);
+app.delete("/:workspace/tickets/:id", ticketHandlers.deleteTicket);
+
+const port = Number(process.env.PORT) || __BACKEND_PORT__;
+
+console.log(`Server is running on http://localhost:${port}`);
+
+serve({
+	fetch: app.fetch,
+	port,
+});

package/templates/backend/src/middleware/workspace-middleware.ts

@@ -0,0 +1,11 @@
+import type { Context, Next } from "hono";
+
+export async function workspaceMiddleware(c: Context, next: Next) {
+	const workspace = c.req.param("workspace");
+
+	if (workspace) {
+		c.set("workspace", workspace);
+	}
+
+	await next();
+}

package/templates/backend/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/templates/backend/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+	test: {
+		globals: true,
+		environment: "node",
+	},
+});

package/templates/frontend/.env.development.template

@@ -0,0 +1 @@
+VITE_API_BASE_URL=http://localhost:__BACKEND_PORT__

package/templates/frontend/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>__PROJECT_NAME_PASCAL__</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package/templates/frontend/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "__PROJECT_NAME__-frontend",
+  "private": true,
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b && vite build",
+    "preview": "vite preview",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check .",
+    "lint:fix": "biome check . --write --unsafe"
+  },
+  "dependencies": {
+    "@nubase/frontend": "*",
+    "@tailwindcss/vite": "^4.1.18",
+    "@tanstack/react-router": "^1.141.8",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "tailwindcss": "^4.1.18",
+    "__PROJECT_NAME__-schema": "*"
+  },
+  "devDependencies": {
+    "@types/react": "^19.0.10",
+    "@types/react-dom": "^19.0.4",
+    "@vitejs/plugin-react": "^5.1.2",
+    "typescript": "^5.9.3",
+    "vite": "^7.3.0"
+  }
+}

package/templates/frontend/postcss.config.js

@@ -0,0 +1,5 @@
+export default {
+	plugins: {
+		"@tailwindcss/postcss": {},
+	},
+};