@nubase/create 0.1.4 → 0.1.5

package/dist/index.js

@@ -26,7 +26,7 @@ function replaceInContent(content, options) {
   const kebabName = toKebabCase(options.name);
   const pascalName = toPascalCase(options.name);
   const camelName = toCamelCase(options.name);
-  return content.replace(/__PROJECT_NAME__/g, kebabName).replace(/__PROJECT_NAME_PASCAL__/g, pascalName).replace(/__PROJECT_NAME_CAMEL__/g, camelName).replace(/__DB_NAME__/g, options.dbName).replace(/__DB_USER__/g, options.dbUser).replace(/__DB_PASSWORD__/g, options.dbPassword).replace(/__DEV_PORT__/g, String(options.devPort)).replace(/__TEST_PORT__/g, String(options.testPort)).replace(/__BACKEND_PORT__/g, String(options.backendPort)).replace(/__FRONTEND_PORT__/g, String(options.frontendPort));
+  return content.replace(/__PROJECT_NAME__/g, kebabName).replace(/__PROJECT_NAME_PASCAL__/g, pascalName).replace(/__PROJECT_NAME_CAMEL__/g, camelName).replace(/__DB_NAME__/g, options.dbName).replace(/__DB_USER__/g, options.dbUser).replace(/__DB_PASSWORD__/g, options.dbPassword).replace(/__DEV_PORT__/g, String(options.devPort)).replace(/__TEST_PORT__/g, String(options.testPort)).replace(/__BACKEND_PORT__/g, String(options.backendPort)).replace(/__FRONTEND_PORT__/g, String(options.frontendPort)).replace(/__TEST_BACKEND_PORT__/g, String(options.testBackendPort)).replace(/__TEST_FRONTEND_PORT__/g, String(options.testFrontendPort));
 }
 function copyTemplateDir(src, dest, options) {
   fse.ensureDirSync(dest);
@@ -48,7 +48,7 @@ function copyTemplateDir(src, dest, options) {
   }
 }
 async function main() {
-  program.name("@nubase/create").description("Create a new Nubase application").argument("[project-name]", "Name of the project").option("--db-name <name>", "Database name").option("--db-user <user>", "Database user").option("--db-password <password>", "Database password").option("--dev-port <port>", "Development database port", "5434").option("--test-port <port>", "Test database port", "5435").option("--backend-port <port>", "Backend server port", "3001").option("--frontend-port <port>", "Frontend dev server port", "3002").option("--skip-install", "Skip npm install").parse();
+  program.name("@nubase/create").description("Create a new Nubase application").argument("[project-name]", "Name of the project").option("--db-name <name>", "Database name").option("--db-user <user>", "Database user").option("--db-password <password>", "Database password").option("--dev-port <port>", "Development database port", "5434").option("--test-port <port>", "Test database port", "5435").option("--backend-port <port>", "Backend server port", "3001").option("--frontend-port <port>", "Frontend dev server port", "3002").option("--test-backend-port <port>", "Test backend server port", "4001").option("--test-frontend-port <port>", "Test frontend dev server port", "4002").option("--skip-install", "Skip npm install").parse();
   const args = program.args;
   const opts = program.opts();
   console.log(chalk.bold.cyan("\n  Welcome to Nubase!\n"));
@@ -78,7 +78,9 @@ async function main() {
     devPort: Number.parseInt(opts.devPort, 10),
     testPort: Number.parseInt(opts.testPort, 10),
     backendPort: Number.parseInt(opts.backendPort, 10),
-    frontendPort: Number.parseInt(opts.frontendPort, 10)
+    frontendPort: Number.parseInt(opts.frontendPort, 10),
+    testBackendPort: Number.parseInt(opts.testBackendPort, 10),
+    testFrontendPort: Number.parseInt(opts.testFrontendPort, 10)
   };
   const targetDir = path.join(process.cwd(), projectName);
   if (fs.existsSync(targetDir)) {

package/package.json

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

package/templates/backend/package.json

@@ -4,14 +4,14 @@
   "type": "module",
   "scripts": {
     "dev": "NODE_ENV=development tsx watch src/index.ts",
-    "dev:test": "PORT=__BACKEND_PORT__ DB_PORT=__TEST_PORT__ NODE_ENV=test tsx watch src/index.ts",
+    "dev:test": "PORT=__TEST_BACKEND_PORT__ DB_PORT=__TEST_PORT__ NODE_ENV=test tsx watch src/index.ts",
     "build": "tsc",
     "start": "node dist/index.js",
     "db:dev:up": "docker compose -f docker/dev/docker-compose.yml up -d",
     "db:dev:down": "docker compose -f docker/dev/docker-compose.yml down",
     "db:dev:kill": "docker compose -f docker/dev/docker-compose.yml down -v && rm -rf docker/dev/postgresql-data",
     "db:dev:seed": "NODE_ENV=development tsx src/db/seed.ts",
-    "db:dev:reset": "npm run db:dev:kill && npm run db:schema-sync && npm run db:dev:up && sleep 2 && npm run db:dev:seed",
+    "db:dev:reset": "npm run db:dev:kill && npm run db:schema-sync && npm run db:dev:up && sleep 5 && npm run db:dev:seed",
     "db:test:up": "docker compose -f docker/test/docker-compose.yml up -d",
     "db:test:down": "docker compose -f docker/test/docker-compose.yml down",
     "db:test:kill": "docker compose -f docker/test/docker-compose.yml down -v && rm -rf docker/test/postgresql-data",

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

@@ -8,7 +8,7 @@ import { and, eq, inArray } from "drizzle-orm";
 import { apiEndpoints } from "schema";
 import jwt from "jsonwebtoken";
 import type { __PROJECT_NAME_PASCAL__User } from "../../auth";
-import { db, adminDb } from "../../db/helpers/drizzle";
+import { getAdminDb } from "../../db/helpers/drizzle";
 import { users, userWorkspaces, workspaces } from "../../db/schema";
 
 // Short-lived secret for login tokens (in production, use a proper secret)
@@ -31,7 +31,7 @@ export const authHandlers = {
 		endpoint: apiEndpoints.loginStart,
 		handler: async ({ body }) => {
 			// Find user by username
-			const [user] = await adminDb
+			const [user] = await getAdminDb()
 				.select()
 				.from(users)
 				.where(eq(users.username, body.username));
@@ -50,7 +50,7 @@ export const authHandlers = {
 			}
 
 			// Get all workspaces this user belongs to
-			const userWorkspaceRows = await adminDb
+			const userWorkspaceRows = await getAdminDb()
 				.select()
 				.from(userWorkspaces)
 				.where(eq(userWorkspaces.userId, user.id));
@@ -61,7 +61,7 @@ export const authHandlers = {
 
 			// Fetch workspace details
 			const workspaceIds = userWorkspaceRows.map((uw) => uw.workspaceId);
-			const workspaceList = await adminDb
+			const workspaceList = await getAdminDb()
 				.select()
 				.from(workspaces)
 				.where(inArray(workspaces.id, workspaceIds));
@@ -109,7 +109,7 @@ export const authHandlers = {
 			}
 
 			// Look up the selected workspace
-			const [workspace] = await adminDb
+			const [workspace] = await getAdminDb()
 				.select()
 				.from(workspaces)
 				.where(eq(workspaces.slug, body.workspace));
@@ -119,7 +119,7 @@ export const authHandlers = {
 			}
 
 			// Verify user has access to this workspace
-			const [access] = await adminDb
+			const [access] = await getAdminDb()
 				.select()
 				.from(userWorkspaces)
 				.where(
@@ -134,7 +134,7 @@ export const authHandlers = {
 			}
 
 			// Fetch the user
-			const [dbUser] = await adminDb
+			const [dbUser] = await getAdminDb()
 				.select()
 				.from(users)
 				.where(eq(users.id, decoded.userId));
@@ -180,7 +180,7 @@ export const authHandlers = {
 			const authController = getAuthController<__PROJECT_NAME_PASCAL__User>(ctx);
 
 			// Look up workspace
-			const [workspace] = await adminDb
+			const [workspace] = await getAdminDb()
 				.select()
 				.from(workspaces)
 				.where(eq(workspaces.slug, body.workspace));
@@ -190,7 +190,7 @@ export const authHandlers = {
 			}
 
 			// Find user by username
-			const [dbUser] = await adminDb
+			const [dbUser] = await getAdminDb()
 				.select()
 				.from(users)
 				.where(eq(users.username, body.username));
@@ -209,7 +209,7 @@ export const authHandlers = {
 			}
 
 			// Verify user has access to this workspace
-			const [access] = await adminDb
+			const [access] = await getAdminDb()
 				.select()
 				.from(userWorkspaces)
 				.where(
@@ -293,7 +293,7 @@ export const authHandlers = {
 			}
 
 			// Check if workspace slug already exists
-			const [existingWorkspace] = await adminDb
+			const [existingWorkspace] = await getAdminDb()
 				.select()
 				.from(workspaces)
 				.where(eq(workspaces.slug, body.workspace));
@@ -303,7 +303,7 @@ export const authHandlers = {
 			}
 
 			// Check if username already exists
-			const [existingUser] = await adminDb
+			const [existingUser] = await getAdminDb()
 				.select()
 				.from(users)
 				.where(eq(users.username, body.username));
@@ -313,7 +313,7 @@ export const authHandlers = {
 			}
 
 			// Check if email already exists
-			const [existingEmail] = await adminDb
+			const [existingEmail] = await getAdminDb()
 				.select()
 				.from(users)
 				.where(eq(users.email, body.email));
@@ -328,7 +328,7 @@ export const authHandlers = {
 			}
 
 			// Create the workspace
-			const [newWorkspace] = await adminDb
+			const [newWorkspace] = await getAdminDb()
 				.insert(workspaces)
 				.values({
 					slug: body.workspace,
@@ -340,7 +340,7 @@ export const authHandlers = {
 			const passwordHash = await bcrypt.hash(body.password, 10);
 
 			// Create the admin user
-			const [newUser] = await adminDb
+			const [newUser] = await getAdminDb()
 				.insert(users)
 				.values({
 					email: body.email,
@@ -350,7 +350,7 @@ export const authHandlers = {
 				.returning();
 
 			// Link user to workspace
-			await adminDb.insert(userWorkspaces).values({
+			await getAdminDb().insert(userWorkspaces).values({
 				userId: newUser.id,
 				workspaceId: newWorkspace.id,
 			});

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

@@ -1,2 +1,3 @@
 export * from "./ticket";
 export * from "./auth";
+export * from "./test-utils";

package/templates/backend/src/api/routes/test-utils.ts

@@ -0,0 +1,390 @@
+import { createHttpHandler } from "@nubase/backend";
+import { emptySchema, nu } from "@nubase/core";
+import bcrypt from "bcrypt";
+import { eq, sql } from "drizzle-orm";
+import { getAdminDb } from "../../db/helpers/drizzle";
+import { tickets } from "../../db/schema/ticket";
+import { users } from "../../db/schema/user";
+import { userWorkspaces } from "../../db/schema/user-workspace";
+import { workspaces } from "../../db/schema/workspace";
+
+// Default test workspace slug
+const DEFAULT_TEST_WORKSPACE = "tavern";
+
+/**
+ * Helper to get workspace by slug using admin DB (bypasses RLS).
+ * Used by test utilities that don't have auth context.
+ */
+async function getWorkspaceBySlug(slug: string) {
+	const db = getAdminDb();
+	const workspaceRows = await db
+		.select()
+		.from(workspaces)
+		.where(eq(workspaces.slug, slug));
+
+	if (workspaceRows.length === 0) {
+		throw new Error(`Workspace not found: ${slug}`);
+	}
+	return workspaceRows[0];
+}
+
+// Clear all data from the database - used between tests
+export const handleClearDatabase = createHttpHandler({
+	endpoint: {
+		method: "POST" as const,
+		path: "/api/test/clear-database",
+		requestParams: emptySchema,
+		requestBody: nu.object({
+			workspace: nu.string().optional(),
+		}),
+		responseBody: nu.object({
+			success: nu.boolean(),
+			message: nu.string(),
+		}),
+	},
+	handler: async ({ body }) => {
+		// Only allow in test environment
+		if (process.env.NODE_ENV !== "test" && process.env.DB_PORT !== "__TEST_PORT__") {
+			throw new Error("Database cleanup is only allowed in test environment");
+		}
+
+		const workspaceSlug = body?.workspace || DEFAULT_TEST_WORKSPACE;
+		const workspace = await getWorkspaceBySlug(workspaceSlug);
+		const db = getAdminDb();
+
+		// Clear ALL tickets (not just for this workspace) to avoid sequence conflicts
+		await db.delete(tickets);
+
+		// Reset the ID sequence to start from 1
+		await db.execute(sql`ALTER SEQUENCE tickets_id_seq RESTART WITH 1`);
+
+		// Clear all user_workspaces associations (for all workspaces in test env)
+		await db.delete(userWorkspaces);
+
+		// Clear all users (in test env we start fresh each time)
+		await db.delete(users);
+
+		// Reset the users ID sequence
+		await db.execute(sql`ALTER SEQUENCE users_id_seq RESTART WITH 1`);
+
+		// Seed a default test user for this workspace
+		const passwordHash = await bcrypt.hash("password123", 12);
+
+		// Create the test user
+		const [newUser] = await db
+			.insert(users)
+			.values({
+				email: "admin@example.com",
+				username: "admin",
+				passwordHash,
+			})
+			.returning();
+
+		// Link user to workspace
+		await db.insert(userWorkspaces).values({
+			userId: newUser.id,
+			workspaceId: workspace.id,
+		});
+
+		return {
+			success: true,
+			message: `Database cleared and test user seeded for workspace ${workspace.slug}`,
+		};
+	},
+});
+
+// Seed test data - useful for specific test scenarios
+export const handleSeedTestData = createHttpHandler({
+	endpoint: {
+		method: "POST" as const,
+		path: "/api/test/seed",
+		requestParams: emptySchema,
+		requestBody: nu.object({
+			workspace: nu.string().optional(),
+			tickets: nu
+				.array(
+					nu.object({
+						title: nu.string(),
+						description: nu.string().optional(),
+					}),
+				)
+				.optional(),
+		}),
+		responseBody: nu.object({
+			success: nu.boolean(),
+			message: nu.string(),
+			data: nu
+				.object({
+					ticketIds: nu.array(nu.number()),
+				})
+				.optional(),
+		}),
+	},
+	handler: async ({ body }) => {
+		// Only allow in test environment
+		if (process.env.NODE_ENV !== "test" && process.env.DB_PORT !== "__TEST_PORT__") {
+			throw new Error("Test seeding is only allowed in test environment");
+		}
+
+		const workspaceSlug = body?.workspace || DEFAULT_TEST_WORKSPACE;
+		const workspace = await getWorkspaceBySlug(workspaceSlug);
+		const db = getAdminDb();
+		const insertedTicketIds: number[] = [];
+
+		if (body?.tickets) {
+			for (const ticket of body.tickets) {
+				const result = await db
+					.insert(tickets)
+					.values({
+						workspaceId: workspace.id,
+						title: ticket.title,
+						description: ticket.description,
+					})
+					.returning();
+
+				if (result[0]) {
+					insertedTicketIds.push(result[0].id);
+				}
+			}
+		}
+
+		return {
+			success: true,
+			message: `Test data seeded for workspace ${workspace.slug}`,
+			data: {
+				ticketIds: insertedTicketIds,
+			},
+		};
+	},
+});
+
+// Get database statistics - useful for verifying test state
+export const handleGetDatabaseStats = createHttpHandler({
+	endpoint: {
+		method: "GET" as const,
+		path: "/api/test/stats",
+		requestParams: nu.object({
+			workspace: nu.string().optional(),
+		}),
+		requestBody: emptySchema,
+		responseBody: nu.object({
+			tickets: nu.object({
+				count: nu.number(),
+			}),
+		}),
+	},
+	handler: async ({ params }) => {
+		// Only allow in test environment
+		if (process.env.NODE_ENV !== "test" && process.env.DB_PORT !== "__TEST_PORT__") {
+			throw new Error("Database stats are only available in test environment");
+		}
+
+		const workspaceSlug = params?.workspace || DEFAULT_TEST_WORKSPACE;
+		const workspace = await getWorkspaceBySlug(workspaceSlug);
+		const db = getAdminDb();
+		const ticketRows = await db
+			.select()
+			.from(tickets)
+			.where(eq(tickets.workspaceId, workspace.id));
+
+		return {
+			tickets: {
+				count: ticketRows.length,
+			},
+		};
+	},
+});
+
+// Ensure default workspace exists - called at the start of test runs
+export const handleEnsureWorkspace = createHttpHandler({
+	endpoint: {
+		method: "POST" as const,
+		path: "/api/test/ensure-workspace",
+		requestParams: emptySchema,
+		requestBody: nu.object({
+			workspace: nu.string().optional(),
+		}),
+		responseBody: nu.object({
+			success: nu.boolean(),
+			workspace: nu.object({
+				id: nu.number(),
+				slug: nu.string(),
+				name: nu.string(),
+			}),
+		}),
+	},
+	handler: async ({ body }) => {
+		// Only allow in test environment
+		if (process.env.NODE_ENV !== "test" && process.env.DB_PORT !== "__TEST_PORT__") {
+			throw new Error(
+				"Workspace management is only allowed in test environment",
+			);
+		}
+
+		const workspaceSlug = body?.workspace || DEFAULT_TEST_WORKSPACE;
+		const db = getAdminDb();
+
+		// Check if workspace exists
+		const existingWorkspaces = await db
+			.select()
+			.from(workspaces)
+			.where(eq(workspaces.slug, workspaceSlug));
+
+		if (existingWorkspaces.length > 0) {
+			return {
+				success: true,
+				workspace: {
+					id: existingWorkspaces[0].id,
+					slug: existingWorkspaces[0].slug,
+					name: existingWorkspaces[0].name,
+				},
+			};
+		}
+
+		// Create the workspace
+		const result = await db
+			.insert(workspaces)
+			.values({
+				slug: workspaceSlug,
+				name: workspaceSlug.charAt(0).toUpperCase() + workspaceSlug.slice(1),
+			})
+			.returning();
+
+		if (result.length === 0) {
+			throw new Error("Failed to create workspace");
+		}
+
+		return {
+			success: true,
+			workspace: {
+				id: result[0].id,
+				slug: result[0].slug,
+				name: result[0].name,
+			},
+		};
+	},
+});
+
+/**
+ * Seed a user with multiple workspaces - for testing workspace selection flow
+ */
+export const handleSeedMultiWorkspaceUser = createHttpHandler({
+	endpoint: {
+		method: "POST" as const,
+		path: "/api/test/seed-multi-workspace-user",
+		requestParams: emptySchema,
+		requestBody: nu.object({
+			username: nu.string(),
+			password: nu.string(),
+			email: nu.string(),
+			workspaces: nu.array(
+				nu.object({
+					slug: nu.string(),
+					name: nu.string(),
+				}),
+			),
+		}),
+		responseBody: nu.object({
+			success: nu.boolean(),
+			message: nu.string(),
+			workspaces: nu.array(
+				nu.object({
+					id: nu.number(),
+					slug: nu.string(),
+					name: nu.string(),
+				}),
+			),
+		}),
+	},
+	handler: async ({ body }) => {
+		// Only allow in test environment
+		if (process.env.NODE_ENV !== "test" && process.env.DB_PORT !== "__TEST_PORT__") {
+			throw new Error(
+				"Multi-workspace user seeding is only allowed in test environment",
+			);
+		}
+
+		const db = getAdminDb();
+		const createdWorkspaces: { id: number; slug: string; name: string }[] = [];
+		const passwordHash = await bcrypt.hash(body.password, 12);
+
+		// Check if user already exists
+		let userId: number;
+		const existingUsers = await db
+			.select()
+			.from(users)
+			.where(eq(users.username, body.username));
+
+		if (existingUsers.length > 0) {
+			userId = existingUsers[0].id;
+		} else {
+			// Create user (root-level, no workspace)
+			const [newUser] = await db
+				.insert(users)
+				.values({
+					email: body.email,
+					username: body.username,
+					passwordHash,
+				})
+				.returning();
+			userId = newUser.id;
+		}
+
+		for (const workspaceData of body.workspaces) {
+			// Check if workspace exists
+			let workspace = await db
+				.select()
+				.from(workspaces)
+				.where(eq(workspaces.slug, workspaceData.slug))
+				.then((rows) => rows[0]);
+
+			// Create workspace if it doesn't exist
+			if (!workspace) {
+				const result = await db
+					.insert(workspaces)
+					.values({
+						slug: workspaceData.slug,
+						name: workspaceData.name,
+					})
+					.returning();
+				workspace = result[0];
+			}
+
+			// Check if user already has access to this workspace
+			const existingAccess = await db
+				.select()
+				.from(userWorkspaces)
+				.where(eq(userWorkspaces.userId, userId))
+				.then((rows) => rows.find((uw) => uw.workspaceId === workspace.id));
+
+			// Link user to workspace if not already linked
+			if (!existingAccess) {
+				await db.insert(userWorkspaces).values({
+					userId,
+					workspaceId: workspace.id,
+				});
+			}
+
+			createdWorkspaces.push({
+				id: workspace.id,
+				slug: workspace.slug,
+				name: workspace.name,
+			});
+		}
+
+		return {
+			success: true,
+			message: `User ${body.username} seeded in ${createdWorkspaces.length} workspaces`,
+			workspaces: createdWorkspaces,
+		};
+	},
+});
+
+// Export test utils handlers object
+export const testUtilsHandlers = {
+	clearDatabase: handleClearDatabase,
+	ensureWorkspace: handleEnsureWorkspace,
+	seedTestData: handleSeedTestData,
+	getDatabaseStats: handleGetDatabaseStats,
+	seedMultiWorkspaceUser: handleSeedMultiWorkspaceUser,
+};

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

@@ -1,14 +1,14 @@
 import { createHttpHandler, HttpError } from "@nubase/backend";
 import { eq } from "drizzle-orm";
 import { apiEndpoints } from "schema";
-import { db } from "../../db/helpers/drizzle";
+import { getDb } from "../../db/helpers/drizzle";
 import { tickets } from "../../db/schema";
 
 export const ticketHandlers = {
 	getTickets: createHttpHandler({
 		endpoint: apiEndpoints.getTickets,
 		handler: async () => {
-			const allTickets = await db.select().from(tickets);
+			const allTickets = await getDb().select().from(tickets);
 			return allTickets.map((ticket) => ({
 				id: ticket.id,
 				title: ticket.title,
@@ -20,7 +20,7 @@ export const ticketHandlers = {
 	getTicket: createHttpHandler({
 		endpoint: apiEndpoints.getTicket,
 		handler: async ({ params }) => {
-			const [ticket] = await db
+			const [ticket] = await getDb()
 				.select()
 				.from(tickets)
 				.where(eq(tickets.id, params.id));
@@ -40,7 +40,7 @@ export const ticketHandlers = {
 	postTicket: createHttpHandler({
 		endpoint: apiEndpoints.postTicket,
 		handler: async ({ body }) => {
-			const [ticket] = await db
+			const [ticket] = await getDb()
 				.insert(tickets)
 				.values({
 					workspaceId: 1, // TODO: Get from context
@@ -75,7 +75,7 @@ export const ticketHandlers = {
 				updateData.description = body.description;
 			}
 
-			const [ticket] = await db
+			const [ticket] = await getDb()
 				.update(tickets)
 				.set(updateData)
 				.where(eq(tickets.id, params.id))
@@ -96,7 +96,7 @@ export const ticketHandlers = {
 	deleteTicket: createHttpHandler({
 		endpoint: apiEndpoints.deleteTicket,
 		handler: async ({ params }) => {
-			const [deleted] = await db
+			const [deleted] = await getDb()
 				.delete(tickets)
 				.where(eq(tickets.id, params.id))
 				.returning();

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

@@ -9,7 +9,7 @@ import bcrypt from "bcrypt";
 import { and, eq } from "drizzle-orm";
 import type { Context } from "hono";
 import jwt from "jsonwebtoken";
-import { adminDb } from "../db/helpers/drizzle";
+import { getAdminDb } from "../db/helpers/drizzle";
 import { users, userWorkspaces } from "../db/schema";
 
 /**
@@ -77,7 +77,7 @@ export class __PROJECT_NAME_PASCAL__AuthController
 			) as __PROJECT_NAME_PASCAL__TokenPayload;
 
 			// Fetch user from database to ensure they still exist
-			const [dbUser] = await adminDb
+			const [dbUser] = await getAdminDb()
 				.select()
 				.from(users)
 				.where(eq(users.id, decoded.userId));
@@ -87,7 +87,7 @@ export class __PROJECT_NAME_PASCAL__AuthController
 			}
 
 			// Verify user still has access to the workspace in the token
-			const [access] = await adminDb
+			const [access] = await getAdminDb()
 				.select()
 				.from(userWorkspaces)
 				.where(
@@ -180,7 +180,7 @@ export class __PROJECT_NAME_PASCAL__AuthController
 		}
 
 		// Find user by username
-		const [dbUser] = await adminDb
+		const [dbUser] = await getAdminDb()
 			.select()
 			.from(users)
 			.where(eq(users.username, username));
@@ -196,7 +196,7 @@ export class __PROJECT_NAME_PASCAL__AuthController
 		}
 
 		// Check if user has access to the workspace
-		const [access] = await adminDb
+		const [access] = await getAdminDb()
 			.select()
 			.from(userWorkspaces)
 			.where(