Add bruno

server/auth/limits.ts

@@ -0,0 +1,40 @@
+import { db } from '@server/db';
+import { limitsTable } from '@server/db/schema';
+import { and, eq } from 'drizzle-orm';
+import createHttpError from 'http-errors';
+import HttpCode from '@server/types/HttpCode';
+
+interface CheckLimitOptions {
+  orgId: number;
+  limitName: string;
+  currentValue: number;
+  increment?: number;
+}
+
+export async function checkOrgLimit({ orgId, limitName, currentValue, increment = 0 }: CheckLimitOptions): Promise<boolean> {
+  try {
+    const limit = await db.select()
+      .from(limitsTable)
+      .where(
+        and(
+          eq(limitsTable.orgId, orgId),
+          eq(limitsTable.name, limitName)
+        )
+      )
+      .limit(1);
+
+    if (limit.length === 0) {
+      throw createHttpError(HttpCode.NOT_FOUND, `Limit "${limitName}" not found for organization`);
+    }
+
+    const limitValue = limit[0].value;
+
+    // Check if the current value plus the increment is within the limit
+    return (currentValue + increment) <= limitValue;
+  } catch (error) {
+    if (error instanceof Error) {
+      throw createHttpError(HttpCode.INTERNAL_SERVER_ERROR, `Error checking limit: ${error.message}`);
+    }
+    throw createHttpError(HttpCode.INTERNAL_SERVER_ERROR, 'Unknown error occurred while checking limit');
+  }
+}

server/db/schema.ts

@@ -202,6 +202,14 @@ export const userResources = sqliteTable("userResources", {
         .references(() => resources.resourceId, { onDelete: "cascade" }),
 });
 
+export const limitsTable = sqliteTable("limits", {
+    limitId: integer("limitId").primaryKey({ autoIncrement: true }),
+    orgId: integer("orgId").references(() => orgs.orgId, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    value: integer("value").notNull(),
+    description: text("description"),
+});
+
 // Define the model types for type inference
 export type Org = InferSelectModel<typeof orgs>;
 export type User = InferSelectModel<typeof users>;
@@ -223,4 +231,5 @@ export type UserAction = InferSelectModel<typeof userActions>;
 export type RoleSite = InferSelectModel<typeof roleSites>;
 export type UserSite = InferSelectModel<typeof userSites>;
 export type RoleResource = InferSelectModel<typeof roleResources>;
-export type UserResource = InferSelectModel<typeof userResources>;
+export type UserResource = InferSelectModel<typeof userResources>;
+export type Limit = InferSelectModel<typeof limitsTable>;

server/routers/target/listTargets.ts

@@ -73,8 +73,7 @@ export async function listTargets(req: Request, res: Response, next: NextFunctio
     const totalCountResult = await countQuery;
     const totalCount = totalCountResult[0].count;
 
-    return res.status(HttpCode.OK).send(
-      response(res, {
+    return response(res, {
         data: {
           targets: targetsList,
           pagination: {
@@ -88,8 +87,9 @@ export async function listTargets(req: Request, res: Response, next: NextFunctio
         message: "Targets retrieved successfully",
         status: HttpCode.OK,
       })
-    );
   } catch (error) {
-    next(error);
+    console.log(error);
+    
+    return next(createHttpError(HttpCode.INTERNAL_SERVER_ERROR, "sadfdf"));
   }
 }