run knip to remove unused code

Author: jamesholcombe

packages/api/src/authz/README.md

@@ -71,7 +71,7 @@ const canView = await authzService.canViewProject(userId, projectId);
 const canWrite = await authzService.canAccessProject(
   userId,
   projectId,
-  "write"
+  "write",
 );
 
 // Get user context

packages/api/src/authz/service.ts

@@ -65,11 +65,11 @@ export class AuthorizationService {
    */
   async getUserContext(
     userId: string,
-    organizationId: string
+    organizationId: string,
   ): Promise<UserContext> {
     try {
       console.log(
-        `Checking user context for userId: ${userId}, organizationId: ${organizationId}`
+        `Checking user context for userId: ${userId}, organizationId: ${organizationId}`,
       );
 
       // Get user's organization role
@@ -79,16 +79,16 @@ export class AuthorizationService {
         .where(
           and(
             eq(userOrganization.userId, userId),
-            eq(userOrganization.organizationId, organizationId)
-          )
+            eq(userOrganization.organizationId, organizationId),
+          ),
         )
         .limit(1);
 
       console.log(`User org result:`, userOrg);
 
       if (!userOrg) {
         console.log(
-          `User ${userId} not found in organization ${organizationId}`
+          `User ${userId} not found in organization ${organizationId}`,
         );
         throw new ApiError("User not found in organization", 403);
       }
@@ -113,17 +113,17 @@ export class AuthorizationService {
    */
   async getProjectContext(
     projectId: string,
-    organizationId?: string
+    organizationId?: string,
   ): Promise<ProjectContext> {
     try {
       console.log(
-        `[AUTHZ] Getting project context for projectId: ${projectId}, organizationId: ${organizationId}`
+        `[AUTHZ] Getting project context for projectId: ${projectId}, organizationId: ${organizationId}`,
       );
 
       const whereConditions = organizationId
         ? and(
             eq(project.id, projectId),
-            eq(project.organizationId, organizationId)
+            eq(project.organizationId, organizationId),
           )
         : eq(project.id, projectId);
 
@@ -142,12 +142,12 @@ export class AuthorizationService {
               name: projectData.name,
               visibility: projectData.visibility,
             }
-          : "null"
+          : "null",
       );
 
       if (!projectData) {
         console.log(
-          `[AUTHZ] Project not found for projectId: ${projectId}, organizationId: ${organizationId}`
+          `[AUTHZ] Project not found for projectId: ${projectId}, organizationId: ${organizationId}`,
         );
         throw new ApiError("Project not found", 404);
       }
@@ -171,22 +171,22 @@ export class AuthorizationService {
     userId: string,
     projectId: string,
     action: Permission,
-    organizationId?: string
+    organizationId?: string,
   ): Promise<boolean> {
     try {
       const projectContext = await this.getProjectContext(
         projectId,
-        organizationId
+        organizationId,
       );
       const userContext = await this.getUserContext(
         userId,
-        projectContext.organizationId
+        projectContext.organizationId,
       );
 
       // Check organization-level permissions
       const orgPermission = this.checkOrganizationPermission(
         userContext.roles[0] || "",
-        action
+        action,
       );
 
       if (orgPermission) {
@@ -196,7 +196,7 @@ export class AuthorizationService {
       // Check project-level permissions
       const projectPermission = this.checkProjectPermission(
         userContext.roles[0] || "",
-        action
+        action,
       );
 
       return projectPermission;
@@ -212,16 +212,16 @@ export class AuthorizationService {
   async canAccessOrganization(
     userId: string,
     organizationId: string,
-    action: Permission
+    action: Permission,
   ): Promise<boolean> {
     try {
       console.log(
-        `Checking organization access for userId: ${userId}, organizationId: ${organizationId}, action: ${action}`
+        `Checking organization access for userId: ${userId}, organizationId: ${organizationId}, action: ${action}`,
       );
       const userContext = await this.getUserContext(userId, organizationId);
       const hasPermission = this.checkOrganizationPermission(
         userContext.roles[0] || "",
-        action
+        action,
       );
       console.log(`Organization access result: ${hasPermission}`);
       return hasPermission;
@@ -237,23 +237,23 @@ export class AuthorizationService {
   async canViewProject(
     userId: string,
     projectId: string,
-    organizationId?: string
+    organizationId?: string,
   ): Promise<boolean> {
     try {
       const projectContext = await this.getProjectContext(
         projectId,
-        organizationId
+        organizationId,
       );
       const userContext = await this.getUserContext(
         userId,
-        projectContext.organizationId
+        projectContext.organizationId,
       );
 
       // Check if user has organization access
       const hasOrgAccess = await this.canAccessOrganization(
         userId,
         projectContext.organizationId,
-        "read"
+        "read",
       );
 
       if (!hasOrgAccess) {
@@ -293,8 +293,8 @@ export class AuthorizationService {
         .where(
           and(
             eq(userProject.userId, userId),
-            eq(userProject.projectId, projectId)
-          )
+            eq(userProject.projectId, projectId),
+          ),
         )
         .limit(1);
 
@@ -325,7 +325,7 @@ export class AuthorizationService {
     if (role in AuthorizationService.PROJECT_PERMISSIONS) {
       const projectRole = role as ProjectRole;
       return AuthorizationService.PROJECT_PERMISSIONS[projectRole].map(
-        (p) => `project:${p}`
+        (p) => `project:${p}`,
       );
     }
 
@@ -336,7 +336,7 @@ export class AuthorizationService {
    * Get project permissions for organization roles
    */
   private getProjectPermissionsForOrgRole(
-    orgRole: OrganizationRole
+    orgRole: OrganizationRole,
   ): Permission[] {
     switch (orgRole) {
       case "OWNER":
@@ -355,7 +355,7 @@ export class AuthorizationService {
    */
   private checkOrganizationPermission(
     role: string,
-    action: Permission
+    action: Permission,
   ): boolean {
     const permissions =
       AuthorizationService.ORGANIZATION_PERMISSIONS[role as OrganizationRole] ||
@@ -378,13 +378,13 @@ export class AuthorizationService {
   async removeUserRoles(
     userId: string,
     organizationId?: string,
-    projectId?: string
+    projectId?: string,
   ): Promise<void> {
     try {
       if (organizationId) {
         // Remove organization role
         console.log(
-          `Removing user ${userId} from organization ${organizationId}`
+          `Removing user ${userId} from organization ${organizationId}`,
         );
       }
       if (projectId) {

packages/api/src/index.ts

@@ -17,7 +17,7 @@ app.use(
   cors({
     origin: config.cors.origin,
     credentials: true,
-  })
+  }),
 );
 
 // Rate limiting

packages/api/src/middleware/async.ts

@@ -1,5 +1,5 @@
-import { Request, Response, NextFunction } from 'express';
-import { AsyncHandler } from '../types';
+import { Request, Response, NextFunction } from "express";
+import { AsyncHandler } from "../types";
 
 export function asyncHandler(fn: AsyncHandler) {
   return (req: Request, res: Response, next: NextFunction): void => {

packages/api/src/middleware/auth.ts

@@ -11,7 +11,7 @@ export const authenticateUser = clerkRequireAuth({
 export async function mapAuthToUser(
   req: AuthenticatedRequest,
   res: Response,
-  next: NextFunction
+  next: NextFunction,
 ): Promise<void> {
   // Clerk middleware sets req.auth, we need to map it to req.user for our existing code
   const auth = getAuth(req);

packages/api/src/middleware/authorization.ts

@@ -18,7 +18,7 @@ export function requirePermission(options: AuthorizationOptions) {
   return async (
     req: AuthenticatedRequest,
     res: Response,
-    next: NextFunction
+    next: NextFunction,
   ): Promise<void> => {
     try {
       if (!req.user) {
@@ -36,21 +36,21 @@ export function requirePermission(options: AuthorizationOptions) {
           hasPermission = await authzService.canViewProject(
             userId,
             resourceId,
-            organizationId
+            organizationId,
           );
         } else {
           hasPermission = await authzService.canAccessProject(
             userId,
             resourceId,
             options.action,
-            organizationId
+            organizationId,
           );
         }
       } else if (options.resource === "organization" && organizationId) {
         hasPermission = await authzService.canAccessOrganization(
           userId,
           organizationId,
-          options.action
+          options.action,
         );
       }
 
@@ -130,7 +130,7 @@ export function requireProjectView() {
 export async function extractOrganizationContext(
   req: AuthenticatedRequest,
   res: Response,
-  next: NextFunction
+  next: NextFunction,
 ): Promise<void> {
   try {
     if (!req.user) {

packages/api/src/middleware/error.ts

@@ -1,42 +1,42 @@
-import { Request, Response, NextFunction } from 'express';
-import { AuthenticatedRequest, ApiError, ErrorHandler } from '../types';
-import { config } from '../config';
+import { Request, Response, NextFunction } from "express";
+import { AuthenticatedRequest, ApiError, ErrorHandler } from "../types";
+import { config } from "../config";
 
 export const errorHandler: ErrorHandler = (
   error: Error,
   req: AuthenticatedRequest,
   res: Response,
-  next: NextFunction
+  next: NextFunction,
 ): void => {
   let statusCode = 500;
-  let message = 'Internal server error';
+  let message = "Internal server error";
 
   if (error instanceof ApiError) {
     statusCode = error.statusCode;
     message = error.message;
-  } else if (error.name === 'ValidationError') {
+  } else if (error.name === "ValidationError") {
     statusCode = 400;
-    message = 'Validation error';
-  } else if (error.name === 'UnauthorizedError') {
+    message = "Validation error";
+  } else if (error.name === "UnauthorizedError") {
     statusCode = 401;
-    message = 'Unauthorized';
+    message = "Unauthorized";
   }
 
   // Log error in development
-  if (config.nodeEnv === 'development') {
-    console.error('Error:', error);
+  if (config.nodeEnv === "development") {
+    console.error("Error:", error);
   }
 
   res.status(statusCode).json({
     success: false,
     error: message,
-    ...(config.nodeEnv === 'development' && { stack: error.stack }),
+    ...(config.nodeEnv === "development" && { stack: error.stack }),
   });
 };
 
 export const notFoundHandler = (req: Request, res: Response): void => {
   res.status(404).json({
     success: false,
-    error: 'Route not found',
+    error: "Route not found",
   });
 };