fix: endpoints

src/features/agents/agents.action.ts

@@ -1,5 +1,5 @@
 "use server";
-import {ActionError, userAction} from "@/lib/safe-actions/actions";
+import {action, ActionError, userAction} from "@/lib/safe-actions/actions";
 import {AgentSchema} from "@/features/agents/agents.schema";
 import {z} from "zod";
 import {eq, and, ne, count} from "drizzle-orm";
@@ -16,23 +16,59 @@ const verifySlugUniqueness = async (slug: string, agentId?: string) => {
     }
 };
 
+
+
+type CreateAgentInput = {
+    organizationId?: string;
+    data: z.infer<typeof AgentSchema>;
+};
+
+export async function createAgentService(input: CreateAgentInput) {
+    const slug = slugify(input.data.name);
+
+    await verifySlugUniqueness(slug);
+
+    const [createdAgent] = await db
+        .insert(drizzleDb.schemas.agent)
+        .values({
+            ...input.data,
+            slug,
+            organizationId: input.organizationId,
+        })
+        .returning();
+
+    if (createdAgent && input.organizationId) {
+        await db.insert(drizzleDb.schemas.organizationAgent).values({
+            organizationId: input.organizationId,
+            agentId: createdAgent.id,
+        });
+    }
+
+    return createdAgent;
+}
+
+
+
+
 export const createAgentAction = userAction.schema(
     z.object({
         organizationId: z.string().optional(),
         data: AgentSchema,
     })
 ).action(async ({parsedInput}) => {
-    const slug = slugify(parsedInput.data.name);
-    await verifySlugUniqueness(slug);
+    // const slug = slugify(parsedInput.data.name);
+    // await verifySlugUniqueness(slug);
+    //
+    // const [createdAgent] = await db.insert(drizzleDb.schemas.agent).values({...parsedInput.data, slug: slug, organizationId: parsedInput.organizationId}).returning();
+    //
+    // if (createdAgent && parsedInput.organizationId){
+    //         await db.insert(drizzleDb.schemas.organizationAgent).values({
+    //             organizationId: parsedInput.organizationId,
+    //             agentId: createdAgent.id,
+    //         });
+    // }
+    const createdAgent = await createAgentService(parsedInput);
 
-    const [createdAgent] = await db.insert(drizzleDb.schemas.agent).values({...parsedInput.data, slug: slug, organizationId: parsedInput.organizationId}).returning();
-
-    if (createdAgent && parsedInput.organizationId){
-            await db.insert(drizzleDb.schemas.organizationAgent).values({
-                organizationId: parsedInput.organizationId,
-                agentId: createdAgent.id,
-            });
-    }
 
     return {
         data: createdAgent,

src/hooks/acl/use-organization-acl.ts

@@ -1,7 +1,7 @@
 "use client";
 
-import type { MemberWithUser } from "@/db/schemas/organization";
 import { computeOrganizationPermissions } from "@/lib/acl/organization-acl";
+import {MemberWithUser} from "@/db/schema/03_organization";
 
 export const useOrganizationPermissions = (
 	activeMember: MemberWithUser | null,

src/hooks/acl/use-system-acl.ts

@@ -1,7 +1,7 @@
 "use client";
 
-import type { User } from "@/db/schemas/user";
 import { computeSystemPermissions } from "@/lib/acl/system-acl";
+import {User} from "@/db/schema/02_user";
 
 export const useSystemPermissions = (user: User | null) => {
 	return computeSystemPermissions(user);

src/lib/acl/organization-acl.ts

@@ -1,8 +1,9 @@
 import {MemberWithUser} from "@/db/schema/03_organization";
+import {OrganizationRole} from "@/lib/acl/role";
 
 
 export type OrganizationPermissions = {
-    role: string | null;
+    role: OrganizationRole | null;
     isOwner: boolean;
     isAdmin: boolean;
     isMember: boolean;
@@ -19,7 +20,7 @@ export type OrganizationPermissions = {
 export const computeOrganizationPermissions = (
     activeMember: MemberWithUser | null
 ): OrganizationPermissions => {
-    const role = activeMember?.role ?? null;
+    const role = (activeMember?.role as OrganizationRole) ?? null;
 
     const isOwner = role === "owner";
     const isAdmin = role === "admin";

src/lib/acl/system-acl.ts

@@ -1,5 +1,5 @@
-import type { User } from "@/db/schemas/user";
 import type { SystemRole } from "@/lib/acl/role";
+import {User} from "@/db/schema/02_user";
 
 export type SystemPermissions = {
 	role: SystemRole | null;

src/lib/api-v1/acl.ts

@@ -1,64 +0,0 @@
-import { db } from "@/db";
-import * as drizzleDb from "@/db";
-import { eq, inArray, and, or, isNull } from "drizzle-orm";
-
-export async function getAccessibleAgentIds(userId: string): Promise<string[]> {
-  const memberships = await db.query.member.findMany({
-    where: eq(drizzleDb.schemas.member.userId, userId),
-    columns: { organizationId: true },
-  });
-
-  if (memberships.length === 0) return [];
-
-  const orgIds = memberships.map((m) => m.organizationId);
-  const isActiveAgent = or(
-    eq(drizzleDb.schemas.agent.isArchived, false),
-    isNull(drizzleDb.schemas.agent.isArchived)
-  );
-
-  // Path 1: via organizationAgent junction table
-  const orgAgents = await db.query.organizationAgent.findMany({
-    where: inArray(drizzleDb.schemas.organizationAgent.organizationId, orgIds),
-    columns: { agentId: true },
-  });
-  const junctionAgentIds = orgAgents.map((oa) => oa.agentId);
-
-  // Path 2: via agent.organizationId direct FK
-  const directAgents = await db.query.agent.findMany({
-    where: and(
-      inArray(drizzleDb.schemas.agent.organizationId, orgIds),
-      isActiveAgent
-    ),
-    columns: { id: true },
-  });
-  const directAgentIds = directAgents.map((a) => a.id);
-
-  const allAgentIds = [...new Set([...junctionAgentIds, ...directAgentIds])];
-  if (allAgentIds.length === 0) return [];
-
-  // Filter junction-path agents by active status
-  const agents = await db.query.agent.findMany({
-    where: and(
-      inArray(drizzleDb.schemas.agent.id, allAgentIds),
-      isActiveAgent
-    ),
-    columns: { id: true },
-  });
-
-  return agents.map((a) => a.id);
-}
-
-export async function getAccessibleDatabaseIds(userId: string): Promise<string[]> {
-  const agentIds = await getAccessibleAgentIds(userId);
-  if (agentIds.length === 0) return [];
-
-  const databases = await db.query.database.findMany({
-    where: and(
-      inArray(drizzleDb.schemas.database.agentId, agentIds),
-      isNull(drizzleDb.schemas.database.deletedAt)
-    ),
-    columns: { id: true },
-  });
-
-  return databases.map((d) => d.id);
-}

src/lib/api-v1/middleware.ts

@@ -3,13 +3,13 @@ import { auth } from "@/lib/auth/auth";
 import * as drizzleDb from "@/db";
 import { eq } from "drizzle-orm";
 import { logger } from "@/lib/logger";
+import {computeOrganizationPermissions} from "@/lib/acl/organization-acl";
+import {db} from "@/db";
+import {computeSystemPermissions} from "@/lib/acl/system-acl";
+import {ApiKeyContext} from "@/lib/api-v1/types";
 
 const log = logger.child({ module: "api-v1/middleware" });
 
-export type ApiKeyContext = {
-  userId: string;
-  orgIds: string[];
-};
 
 type ApiKeyHandler = (
   req: Request,
@@ -56,13 +56,39 @@ export function withApiKey(handler: ApiKeyHandler) {
 
       const memberships = await drizzleDb.db.query.member.findMany({
         where: eq(drizzleDb.schemas.member.userId, userId),
-        columns: { organizationId: true },
+        with: {
+          user: true
+        }
       });
 
-      const orgIds = memberships.map((m) => m.organizationId);
+      const organizations = await Promise.all(
+          memberships.map(async (m) => {
+            return {
+              id: m.organizationId,
+              permissions:  computeOrganizationPermissions(m),
+            };
+          })
+      );
+
+      const userFetched = await db.query.user.findFirst({
+        where: eq(drizzleDb.schemas.user.id, userId),
+      })
+
+
+      if (!userFetched) {
+        throw new Error("Unable to find user")
+      }
+
+      const userPermissions = computeSystemPermissions(userFetched)
+
+      const user = {
+        id: userFetched.id,
+        permissions: userPermissions,
+      }
+
       const resolvedParams = context?.params ? await context.params : {};
 
-      return handler(req, { userId, orgIds }, resolvedParams);
+      return handler(req, { user, organizations }, resolvedParams);
     } catch (err) {
       log.error({ error: err }, "Error in withApiKey middleware");
       return NextResponse.json(

src/lib/api-v1/services/agents.ts

@@ -0,0 +1,73 @@
+import { db } from "@/db";
+import * as drizzleDb from "@/db";
+import { eq, inArray, and, or, isNull } from "drizzle-orm";
+import {ApiKeyContextUser} from "@/lib/api-v1/types";
+
+export async function getAccessibleAgentIds(
+    user: ApiKeyContextUser
+): Promise<string[]> {
+
+    const memberships = await db.query.member.findMany({
+        where: and(
+            eq(drizzleDb.schemas.member.userId, user.id),
+            or(
+                eq(drizzleDb.schemas.member.role, "admin"),
+                eq(drizzleDb.schemas.member.role, "owner")
+            )
+        ),
+        columns: { organizationId: true },
+    });
+
+    const orgIds = memberships.map((m) => m.organizationId);
+
+    if (orgIds.length === 0) {
+        return [];
+    }
+
+    const isActiveAgent = or(
+        eq(drizzleDb.schemas.agent.isArchived, false),
+        isNull(drizzleDb.schemas.agent.isArchived)
+    );
+
+    const orgAgents = await db.query.organizationAgent.findMany({
+        where: inArray(
+            drizzleDb.schemas.organizationAgent.organizationId,
+            orgIds
+        ),
+        columns: { agentId: true },
+    });
+
+    const junctionAgentIds = orgAgents.map((oa) => oa.agentId);
+
+    let directAgentIds: string[] = [];
+
+    if (user.permissions.isAdmin || user.permissions.isSuperAdmin) {
+        const directAgents = await db.query.agent.findMany({
+            where: isActiveAgent,
+            columns: { id: true },
+        });
+
+        directAgentIds = directAgents.map((a) => a.id);
+    }
+
+    const allAgentIds = [
+        ...new Set([
+            ...junctionAgentIds,
+            ...directAgentIds,
+        ]),
+    ];
+
+    if (allAgentIds.length === 0) {
+        return [];
+    }
+
+    const agents = await db.query.agent.findMany({
+        where: and(
+            inArray(drizzleDb.schemas.agent.id, allAgentIds),
+            isActiveAgent
+        ),
+        columns: { id: true },
+    });
+
+    return agents.map((a) => a.id);
+}

src/lib/api-v1/services/databases.ts

@@ -0,0 +1,21 @@
+import { db } from "@/db";
+import * as drizzleDb from "@/db";
+import { eq, inArray, and, or, isNull } from "drizzle-orm";
+import {getAccessibleAgentIds} from "@/lib/api-v1/services/agents";
+import {ApiKeyContextUser} from "@/lib/api-v1/types";
+
+
+export async function getAccessibleDatabaseIds(user: ApiKeyContextUser): Promise<string[]> {
+    const agentIds = await getAccessibleAgentIds(user);
+    if (agentIds.length === 0) return [];
+
+    const databases = await db.query.database.findMany({
+        where: and(
+            inArray(drizzleDb.schemas.database.agentId, agentIds),
+            isNull(drizzleDb.schemas.database.deletedAt)
+        ),
+        columns: { id: true },
+    });
+
+    return databases.map((d) => d.id);
+}

src/lib/api-v1/types.ts

@@ -0,0 +1,19 @@
+import {SystemPermissions} from "@/lib/acl/system-acl";
+import {OrganizationPermissions} from "@/lib/acl/organization-acl";
+
+
+
+export type ApiKeyContextUser = {
+        id: string;
+        permissions: SystemPermissions;
+};
+
+export type ApiKeyContextOrganizations = {
+    id: string;
+    permissions: OrganizationPermissions
+}[];
+
+export type ApiKeyContext = {
+    user: ApiKeyContextUser;
+    organizations: ApiKeyContextOrganizations
+};