@nubase/create 0.1.1 → 0.1.3

package/dist/index.js

@@ -107,10 +107,7 @@ Creating project in ${chalk.bold(targetDir)}...
     if (template === "root") {
       copyTemplateDir(templatePath, targetDir, options);
     } else {
-      const destPath = path.join(
-        targetDir,
-        `${toKebabCase(projectName)}-${template}`
-      );
+      const destPath = path.join(targetDir, template);
       copyTemplateDir(templatePath, destPath, options);
     }
     console.log(chalk.green(`  \u2713 Created ${template}`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nubase/create",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Create a new Nubase application",
   "type": "module",
   "bin": {

package/templates/backend/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "__PROJECT_NAME__-backend",
+  "name": "backend",
   "version": "0.1.0",
   "type": "module",
   "scripts": {
@@ -31,7 +31,7 @@
     "hono": "^4.6.14",
     "jsonwebtoken": "^9.0.2",
     "pg": "^8.13.1",
-    "__PROJECT_NAME__-schema": "*"
+    "schema": "*"
   },
   "devDependencies": {
     "@faker-js/faker": "^9.3.0",

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

@@ -62,7 +62,7 @@ export const authHandlers = {
 		const token = authController.generateToken({
 			userId: user.id,
 			workspaceId: workspace.id,
-			email: user.email,
+			username: user.username,
 		});
 
 		return c.json({
@@ -104,7 +104,7 @@ export const authHandlers = {
 		const token = authController.generateToken({
 			userId: user.id,
 			workspaceId: userWs.id,
-			email: user.email,
+			username: user.username,
 		});
 
 		return c.json({
@@ -197,7 +197,7 @@ export const authHandlers = {
 		const token = authController.generateToken({
 			userId: user.id,
 			workspaceId: workspace.id,
-			email: user.email,
+			username: user.username,
 		});
 
 		return c.json({

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

@@ -1,15 +1,10 @@
 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;
+	username: string;
 }
 
 const JWT_SECRET = process.env.JWT_SECRET || "your-secret-key";

package/templates/frontend/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "__PROJECT_NAME__-frontend",
+  "name": "frontend",
   "private": true,
   "version": "0.1.0",
   "type": "module",
@@ -15,10 +15,11 @@
     "@nubase/frontend": "*",
     "@tailwindcss/vite": "^4.1.18",
     "@tanstack/react-router": "^1.141.8",
+    "lucide-react": "^0.511.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
     "tailwindcss": "^4.1.18",
-    "__PROJECT_NAME__-schema": "*"
+    "schema": "*"
   },
   "devDependencies": {
     "@types/react": "^19.0.10",

package/templates/frontend/src/auth/__PROJECT_NAME_PASCAL__AuthController.ts

@@ -1,59 +1,269 @@
-import type { AuthController, AuthState } from "@nubase/frontend";
-import type { ApiEndpoints } from "__PROJECT_NAME__-schema";
+import type {
+	AuthenticatedUser,
+	AuthenticationController,
+	AuthenticationState,
+	AuthenticationStateListener,
+	LoginCompleteCredentials,
+	LoginCredentials,
+	LoginStartResponse,
+	SignupCredentials,
+	WorkspaceInfo,
+} from "@nubase/frontend";
 
-const TOKEN_KEY = "__PROJECT_NAME___auth_token";
+/**
+ * Application-specific implementation of AuthenticationController.
+ * Communicates with the backend auth endpoints using HttpOnly cookies.
+ */
+export class __PROJECT_NAME_PASCAL__AuthController
+	implements AuthenticationController
+{
+	private state: AuthenticationState = {
+		status: "loading",
+		user: null,
+		error: null,
+	};
 
-export class __PROJECT_NAME_PASCAL__AuthController implements AuthController<ApiEndpoints> {
-	private token: string | null = null;
+	private listeners = new Set<AuthenticationStateListener>();
+	private apiBaseUrl: string;
 
-	constructor() {
-		this.token = localStorage.getItem(TOKEN_KEY);
+	constructor(apiBaseUrl: string) {
+		this.apiBaseUrl = apiBaseUrl;
 	}
 
-	async getAuthState(
-		httpClient: {
-			request: <E extends keyof ApiEndpoints>(
-				endpoint: E,
-				options?: { body?: unknown; params?: unknown },
-			) => Promise<ApiEndpoints[E]["responseBody"]>;
-		},
-		workspace: string,
-	): Promise<AuthState> {
-		if (!this.token) {
-			return { isAuthenticated: false };
+	getState(): AuthenticationState {
+		return this.state;
+	}
+
+	subscribe(listener: AuthenticationStateListener): () => void {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+
+	private setState(newState: Partial<AuthenticationState>): void {
+		this.state = { ...this.state, ...newState };
+		for (const listener of this.listeners) {
+			listener(this.state);
+		}
+	}
+
+	async login(credentials: LoginCredentials): Promise<void> {
+		this.setState({ status: "loading", error: null });
+
+		try {
+			// Include workspace in the login request body for path-based multi-workspace
+			const response = await fetch(`${this.apiBaseUrl}/auth/login`, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+				},
+				credentials: "include", // Important for cookies
+				body: JSON.stringify({
+					username: credentials.username,
+					password: credentials.password,
+					workspace: credentials.workspace,
+				}),
+			});
+
+			if (!response.ok) {
+				const errorData = await response.json().catch(() => ({}));
+				throw new Error(errorData.error || "Invalid username or password");
+			}
+
+			const data = await response.json();
+			const user: AuthenticatedUser = data.user;
+
+			this.setState({
+				status: "authenticated",
+				user,
+				error: null,
+			});
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error("Login failed");
+			this.setState({
+				status: "unauthenticated",
+				user: null,
+				error: err,
+			});
+			throw err;
 		}
+	}
 
+	async logout(): Promise<void> {
 		try {
-			const response = await httpClient.request("getMe", {});
-			return {
-				isAuthenticated: true,
-				user: response.user,
-				workspace: response.workspace,
-			};
+			await fetch(`${this.apiBaseUrl}/auth/logout`, {
+				method: "POST",
+				credentials: "include",
+			});
 		} catch {
-			this.clearToken();
-			return { isAuthenticated: false };
+			// Logout errors are not critical - clear local state anyway
 		}
+
+		this.setState({
+			status: "unauthenticated",
+			user: null,
+			error: null,
+		});
 	}
 
-	getAuthHeaders(): Record<string, string> {
-		if (!this.token) {
-			return {};
+	async initialize(): Promise<void> {
+		this.setState({ status: "loading", error: null });
+
+		try {
+			const response = await fetch(`${this.apiBaseUrl}/auth/me`, {
+				method: "GET",
+				credentials: "include",
+			});
+
+			if (!response.ok) {
+				this.setState({
+					status: "unauthenticated",
+					user: null,
+					error: null,
+				});
+				return;
+			}
+
+			const data = await response.json();
+
+			if (data.user) {
+				this.setState({
+					status: "authenticated",
+					user: data.user,
+					error: null,
+				});
+			} else {
+				this.setState({
+					status: "unauthenticated",
+					user: null,
+					error: null,
+				});
+			}
+		} catch {
+			// Network error or server unavailable - treat as unauthenticated
+			this.setState({
+				status: "unauthenticated",
+				user: null,
+				error: null,
+			});
 		}
-		return { Authorization: `Bearer ${this.token}` };
 	}
 
-	setToken(token: string): void {
-		this.token = token;
-		localStorage.setItem(TOKEN_KEY, token);
+	/**
+	 * Start the two-step login process.
+	 * Step 1: Validates credentials and returns list of workspaces user belongs to.
+	 */
+	async loginStart(credentials: {
+		username: string;
+		password: string;
+	}): Promise<LoginStartResponse> {
+		const response = await fetch(`${this.apiBaseUrl}/auth/login/start`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+			},
+			credentials: "include",
+			body: JSON.stringify({
+				username: credentials.username,
+				password: credentials.password,
+			}),
+		});
+
+		if (!response.ok) {
+			const errorData = await response.json().catch(() => ({}));
+			throw new Error(errorData.error || "Invalid username or password");
+		}
+
+		return response.json();
 	}
 
-	clearToken(): void {
-		this.token = null;
-		localStorage.removeItem(TOKEN_KEY);
+	/**
+	 * Complete the two-step login process.
+	 * Step 2: Select a workspace and complete authentication.
+	 */
+	async loginComplete(
+		credentials: LoginCompleteCredentials,
+	): Promise<WorkspaceInfo> {
+		this.setState({ status: "loading", error: null });
+
+		try {
+			const response = await fetch(`${this.apiBaseUrl}/auth/login/complete`, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+				},
+				credentials: "include",
+				body: JSON.stringify({
+					loginToken: credentials.loginToken,
+					workspace: credentials.workspace,
+				}),
+			});
+
+			if (!response.ok) {
+				const errorData = await response.json().catch(() => ({}));
+				throw new Error(errorData.error || "Login failed");
+			}
+
+			const data = await response.json();
+			const user: AuthenticatedUser = data.user;
+
+			this.setState({
+				status: "authenticated",
+				user,
+				error: null,
+			});
+
+			return data.workspace;
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error("Login failed");
+			this.setState({
+				status: "unauthenticated",
+				user: null,
+				error: err,
+			});
+			throw err;
+		}
 	}
 
-	getToken(): string | null {
-		return this.token;
+	/**
+	 * Sign up a new user and create a new workspace.
+	 * After successful signup, the user is automatically logged in.
+	 */
+	async signup(credentials: SignupCredentials): Promise<void> {
+		this.setState({ status: "loading", error: null });
+
+		try {
+			const response = await fetch(`${this.apiBaseUrl}/auth/signup`, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+				},
+				credentials: "include",
+				body: JSON.stringify(credentials),
+			});
+
+			if (!response.ok) {
+				const errorData = await response.json().catch(() => ({}));
+				throw new Error(errorData.error || "Signup failed");
+			}
+
+			const data = await response.json();
+			const user: AuthenticatedUser = data.user;
+
+			this.setState({
+				status: "authenticated",
+				user,
+				error: null,
+			});
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error("Signup failed");
+			this.setState({
+				status: "unauthenticated",
+				user: null,
+				error: err,
+			});
+			throw err;
+		}
 	}
 }

package/templates/frontend/src/config.tsx

@@ -1,58 +1,20 @@
-import {
-	type NubaseFrontendConfig,
-	defaultKeybindings,
-	resourceLink,
-} from "@nubase/frontend";
-import { apiEndpoints } from "__PROJECT_NAME__-schema";
+import type { NubaseFrontendConfig } from "@nubase/frontend";
+import { defaultKeybindings, resourceLink } from "@nubase/frontend";
+import { Home, TicketIcon } from "lucide-react";
+import { apiEndpoints } from "schema";
 import { __PROJECT_NAME_PASCAL__AuthController } from "./auth/__PROJECT_NAME_PASCAL__AuthController";
 import { ticketResource } from "./resources/ticket";
 
-// Icons (inline SVG from Tabler Icons)
-const HomeIcon = () => (
-	<svg
-		xmlns="http://www.w3.org/2000/svg"
-		width="20"
-		height="20"
-		viewBox="0 0 24 24"
-		fill="none"
-		stroke="currentColor"
-		strokeWidth="2"
-		strokeLinecap="round"
-		strokeLinejoin="round"
-	>
-		<path d="M5 12l-2 0l9 -9l9 9l-2 0" />
-		<path d="M5 12v7a2 2 0 0 0 2 2h10a2 2 0 0 0 2 -2v-7" />
-		<path d="M9 21v-6a2 2 0 0 1 2 -2h2a2 2 0 0 1 2 2v6" />
-	</svg>
-);
-
-const TicketIcon = () => (
-	<svg
-		xmlns="http://www.w3.org/2000/svg"
-		width="20"
-		height="20"
-		viewBox="0 0 24 24"
-		fill="none"
-		stroke="currentColor"
-		strokeWidth="2"
-		strokeLinecap="round"
-		strokeLinejoin="round"
-	>
-		<path d="M15 5l0 2" />
-		<path d="M15 11l0 2" />
-		<path d="M15 17l0 2" />
-		<path d="M5 5h14a2 2 0 0 1 2 2v3a2 2 0 0 0 0 4v3a2 2 0 0 1 -2 2h-14a2 2 0 0 1 -2 -2v-3a2 2 0 0 0 0 -4v-3a2 2 0 0 1 2 -2" />
-	</svg>
-);
-
-const authController = new __PROJECT_NAME_PASCAL__AuthController();
+const apiBaseUrl =
+	import.meta.env.VITE_API_BASE_URL || "http://localhost:__BACKEND_PORT__";
+const authController = new __PROJECT_NAME_PASCAL__AuthController(apiBaseUrl);
 
 export const config: NubaseFrontendConfig<typeof apiEndpoints> = {
 	appName: "__PROJECT_NAME_PASCAL__",
 	mainMenu: [
 		{
 			id: "home",
-			icon: HomeIcon,
+			icon: Home,
 			label: "Home",
 			href: "/",
 		},
@@ -66,8 +28,8 @@ export const config: NubaseFrontendConfig<typeof apiEndpoints> = {
 	resources: {
 		[ticketResource.id]: ticketResource,
 	},
-	keybindings: defaultKeybindings,
-	apiBaseUrl: import.meta.env.VITE_API_BASE_URL || "http://localhost:__BACKEND_PORT__",
+	keybindings: defaultKeybindings.extend(),
+	apiBaseUrl: apiBaseUrl,
 	apiEndpoints,
 	themeIds: ["dark", "light"],
 	defaultThemeId: "dark",

package/templates/frontend/src/resources/ticket.ts

@@ -1,32 +1,56 @@
 import { createResource } from "@nubase/frontend";
-import { apiEndpoints, ticketBaseSchema } from "__PROJECT_NAME__-schema";
+import { apiEndpoints } from "schema";
 
 export const ticketResource = createResource("ticket")
 	.withApiEndpoints(apiEndpoints)
 	.withViews({
 		create: {
 			type: "resource-create",
+			id: "create-ticket",
 			title: "Create Ticket",
-			schema: ticketBaseSchema.omit("id", "createdAt", "updatedAt"),
-			submitEndpoint: "postTicket",
+			schemaPost: (api) => api.postTicket.requestBody,
+			breadcrumbs: [
+				{ label: "Tickets", to: "/r/ticket/search" },
+				"Create Ticket",
+			],
+			onSubmit: async ({ data, context }) => {
+				return context.http.postTicket({ data });
+			},
 		},
 		view: {
 			type: "resource-view",
+			id: "view-ticket",
 			title: "View Ticket",
-			schema: ticketBaseSchema,
-			fetchEndpoint: "getTicket",
-		},
-		edit: {
-			type: "resource-edit",
-			title: "Edit Ticket",
-			schema: ticketBaseSchema,
-			fetchEndpoint: "getTicket",
-			submitEndpoint: "patchTicket",
+			schemaGet: (api) => api.getTicket.responseBody.omit("id"),
+			schemaParams: (api) => api.getTicket.requestParams,
+			breadcrumbs: ({ context, data }) => [
+				{ label: "Tickets", to: "/r/ticket/search" },
+				{
+					label: data?.title || `Ticket #${context.params?.id || "Unknown"}`,
+				},
+			],
+			onLoad: async ({ context }) => {
+				return context.http.getTicket({
+					params: { id: context.params.id },
+				});
+			},
+			onPatch: async ({ data, context }) => {
+				return context.http.patchTicket({
+					params: { id: context.params.id },
+					data: data,
+				});
+			},
 		},
 		search: {
 			type: "resource-search",
-			title: "Tickets",
-			schema: ticketBaseSchema,
-			fetchEndpoint: "getTickets",
+			id: "search-tickets",
+			title: "Search Tickets",
+			schemaGet: (api) => api.getTickets.responseBody,
+			breadcrumbs: () => [{ label: "Tickets", to: "/r/ticket/search" }],
+			onLoad: async ({ context }) => {
+				return context.http.getTickets({
+					params: {},
+				});
+			},
 		},
 	});

package/templates/root/README.md

@@ -49,10 +49,10 @@ The application will be available at:
 
 ```
 __PROJECT_NAME__/
-├── __PROJECT_NAME__-schema/    # Shared API schemas and types
-├── __PROJECT_NAME__-backend/   # Node.js backend (Hono + PostgreSQL)
-├── __PROJECT_NAME__-frontend/  # React frontend (Vite + Nubase)
-└── package.json                # Root workspace configuration
+├── schema/      # Shared API schemas and types
+├── backend/     # Node.js backend (Hono + PostgreSQL)
+├── frontend/    # React frontend (Vite + Nubase)
+└── package.json # Root workspace configuration
 ```
 
 ## Available Scripts

package/templates/root/package.json

@@ -4,17 +4,17 @@
   "private": true,
   "type": "module",
   "workspaces": [
-    "__PROJECT_NAME__-schema",
-    "__PROJECT_NAME__-backend",
-    "__PROJECT_NAME__-frontend"
+    "schema",
+    "backend",
+    "frontend"
   ],
   "scripts": {
     "dev": "turbo run dev",
     "build": "turbo run build",
-    "db:up": "cd __PROJECT_NAME__-backend && npm run db:dev:up",
-    "db:down": "cd __PROJECT_NAME__-backend && npm run db:dev:down",
-    "db:kill": "cd __PROJECT_NAME__-backend && npm run db:dev:kill",
-    "db:seed": "cd __PROJECT_NAME__-backend && npm run db:seed",
+    "db:up": "cd backend && npm run db:dev:up",
+    "db:down": "cd backend && npm run db:dev:down",
+    "db:kill": "cd backend && npm run db:dev:kill",
+    "db:seed": "cd backend && npm run db:seed",
     "typecheck": "turbo run typecheck",
     "lint": "turbo run lint",
     "lint:fix": "turbo run lint:fix"
@@ -25,6 +25,8 @@
     "typescript": "^5.7.2"
   },
   "engines": {
-    "node": ">=18"
-  }
+    "node": ">=18",
+    "npm": ">=10.9.2"
+  },
+  "packageManager": "npm@10.9.2"
 }

package/templates/schema/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "__PROJECT_NAME__-schema",
+  "name": "schema",
   "version": "0.1.0",
   "description": "Schema for __PROJECT_NAME_PASCAL__",
   "type": "module",

package/templates/schema/src/schema/auth.ts

@@ -1,89 +1,144 @@
-import { type RequestSchema, nu } from "@nubase/core";
-
-export const workspaceSchema = nu.object({
-	id: nu.number(),
-	slug: nu.string(),
-	name: nu.string(),
-});
-
-export type Workspace = (typeof workspaceSchema)["_output"];
+import { emptySchema, nu, type RequestSchema } from "@nubase/core";
 
+/**
+ * User schema for authenticated user data
+ */
 export const userSchema = nu.object({
 	id: nu.number(),
 	email: nu.string(),
 	username: nu.string(),
 });
 
-export type User = (typeof userSchema)["_output"];
+/**
+ * Workspace info returned during login
+ */
+export const workspaceInfoSchema = nu.object({
+	id: nu.number(),
+	slug: nu.string(),
+	name: nu.string(),
+});
 
+/**
+ * Login start request schema - Step 1 of two-step auth
+ * POST /auth/login/start
+ *
+ * Validates credentials and returns list of workspaces the user belongs to.
+ * If user has multiple workspaces, frontend should show selection.
+ * If user has one workspace, frontend can auto-complete login.
+ */
 export const loginStartSchema = {
-	method: "POST",
+	method: "POST" as const,
 	path: "/auth/login/start",
+	requestParams: emptySchema,
 	requestBody: nu.object({
-		email: nu.string(),
+		username: nu.string(),
 		password: nu.string(),
 	}),
 	responseBody: nu.object({
-		workspaces: nu.array(workspaceSchema),
+		/** Temporary token for completing login (short-lived) */
+		loginToken: nu.string(),
+		/** User's username (for display) */
+		username: nu.string(),
+		/** List of workspaces the user belongs to */
+		workspaces: nu.array(workspaceInfoSchema),
 	}),
 } satisfies RequestSchema;
 
+/**
+ * Login complete request schema - Step 2 of two-step auth
+ * POST /auth/login/complete
+ *
+ * Completes login by selecting a workspace and issuing the full auth token.
+ */
 export const loginCompleteSchema = {
-	method: "POST",
+	method: "POST" as const,
 	path: "/auth/login/complete",
+	requestParams: emptySchema,
 	requestBody: nu.object({
-		email: nu.string(),
-		password: nu.string(),
-		workspaceId: nu.number(),
+		/** Temporary login token from login/start */
+		loginToken: nu.string(),
+		/** Selected workspace slug */
+		workspace: nu.string(),
 	}),
 	responseBody: nu.object({
-		token: nu.string(),
 		user: userSchema,
-		workspace: workspaceSchema,
+		workspace: workspaceInfoSchema,
 	}),
 } satisfies RequestSchema;
 
+/**
+ * Legacy login request schema (kept for backwards compatibility)
+ * POST /auth/login
+ *
+ * For path-based multi-workspace, the workspace slug is required in the request body.
+ * @deprecated Use loginStartSchema and loginCompleteSchema for two-step flow
+ */
 export const loginSchema = {
-	method: "POST",
+	method: "POST" as const,
 	path: "/auth/login",
+	requestParams: emptySchema,
 	requestBody: nu.object({
-		email: nu.string(),
+		username: nu.string(),
 		password: nu.string(),
+		/** Workspace slug for path-based multi-workspace */
+		workspace: nu.string(),
 	}),
 	responseBody: nu.object({
-		token: nu.string(),
 		user: userSchema,
-		workspace: workspaceSchema,
 	}),
 } satisfies RequestSchema;
 
+/**
+ * Logout request schema
+ * POST /auth/logout
+ */
 export const logoutSchema = {
-	method: "POST",
+	method: "POST" as const,
 	path: "/auth/logout",
-	responseBody: nu.object({ success: nu.boolean() }),
+	requestParams: emptySchema,
+	responseBody: nu.object({
+		success: nu.boolean(),
+	}),
 } satisfies RequestSchema;
 
+/**
+ * Get current user schema
+ * GET /auth/me
+ */
 export const getMeSchema = {
-	method: "GET",
+	method: "GET" as const,
 	path: "/auth/me",
+	requestParams: emptySchema,
 	responseBody: nu.object({
-		user: userSchema,
-		workspace: workspaceSchema,
+		user: userSchema.optional(),
 	}),
 } satisfies RequestSchema;
 
+/**
+ * Signup request schema
+ * POST /auth/signup
+ *
+ * Creates a new workspace and the initial admin user.
+ * After successful signup, the user is automatically logged in.
+ */
 export const signupSchema = {
-	method: "POST",
+	method: "POST" as const,
 	path: "/auth/signup",
+	requestParams: emptySchema,
 	requestBody: nu.object({
-		email: nu.string(),
+		/** Workspace slug (unique identifier) */
+		workspace: nu.string(),
+		/** Display name for the workspace */
+		workspaceName: nu.string(),
+		/** Username for the admin user */
 		username: nu.string(),
+		/** Email for the admin user */
+		email: nu.string(),
+		/** Password for the admin user */
 		password: nu.string(),
-		workspaceName: nu.string().optional(),
 	}),
 	responseBody: nu.object({
-		token: nu.string(),
 		user: userSchema,
-		workspace: workspaceSchema,
+		workspace: workspaceInfoSchema,
 	}),
 } satisfies RequestSchema;

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

@@ -1,68 +1,71 @@
-import { type RequestSchema, nu } from "@nubase/core";
+import {
+	emptySchema,
+	idNumberSchema,
+	nu,
+	type RequestSchema,
+	successSchema,
+} from "@nubase/core";
 
 export const ticketBaseSchema = nu
 	.object({
 		id: nu.number(),
 		title: nu.string().withMeta({
 			label: "Title",
-			placeholder: "Enter ticket title",
+			description: "Enter the title of the ticket",
 		}),
 		description: nu.string().optional().withMeta({
 			label: "Description",
-			placeholder: "Enter ticket description",
+			description: "Enter the description of the ticket",
 			renderer: "multiline",
 		}),
-		createdAt: nu.string().optional().withMeta({
-			label: "Created At",
-		}),
-		updatedAt: nu.string().optional().withMeta({
-			label: "Updated At",
-		}),
 	})
 	.withId("id")
 	.withTableLayouts({
 		default: {
-			fields: ["id", "title", "description", "createdAt"],
+			fields: [
+				{ name: "id", columnWidthPx: 80, pinned: true },
+				{ name: "title", columnWidthPx: 300, pinned: true },
+				{ name: "description", columnWidthPx: 400 },
+			],
 			metadata: {
 				linkFields: ["title"],
 			},
 		},
 	});
 
-export type Ticket = (typeof ticketBaseSchema)["_output"];
-
 export const getTicketsSchema = {
-	method: "GET",
+	method: "GET" as const,
 	path: "/tickets",
-	requestParams: ticketBaseSchema.omit("id", "createdAt", "updatedAt").partial(),
+	requestParams: ticketBaseSchema.omit("id").partial(),
 	responseBody: nu.array(ticketBaseSchema),
 } satisfies RequestSchema;
 
 export const getTicketSchema = {
-	method: "GET",
+	method: "GET" as const,
 	path: "/tickets/:id",
-	pathParams: nu.object({ id: nu.number() }),
+	requestParams: idNumberSchema,
 	responseBody: ticketBaseSchema,
 } satisfies RequestSchema;
 
 export const postTicketSchema = {
-	method: "POST",
+	method: "POST" as const,
 	path: "/tickets",
-	requestBody: ticketBaseSchema.omit("id", "createdAt", "updatedAt"),
+	requestParams: emptySchema,
+	requestBody: ticketBaseSchema.omit("id"),
 	responseBody: ticketBaseSchema,
 } satisfies RequestSchema;
 
 export const patchTicketSchema = {
-	method: "PATCH",
+	method: "PATCH" as const,
 	path: "/tickets/:id",
-	pathParams: nu.object({ id: nu.number() }),
-	requestBody: ticketBaseSchema.omit("id", "createdAt", "updatedAt").partial(),
+	requestParams: idNumberSchema,
+	requestBody: ticketBaseSchema.omit("id").partial(),
 	responseBody: ticketBaseSchema,
 } satisfies RequestSchema;
 
 export const deleteTicketSchema = {
-	method: "DELETE",
+	method: "DELETE" as const,
 	path: "/tickets/:id",
-	pathParams: nu.object({ id: nu.number() }),
-	responseBody: nu.object({ success: nu.boolean() }),
+	requestParams: idNumberSchema,
+	responseBody: successSchema,
 } satisfies RequestSchema;