portabase/src/features/agents/agents.action.ts

"use server";
import {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";
import {db} from "@/db";
import * as drizzleDb from "@/db";
import {slugify} from "@/utils/slugify";
import {getHealthLast12hLogs} from "@/db/services/healthcheck";

const verifySlugUniqueness = async (slug: string, agentId?: string) => {
    const conditions = agentId ? and(eq(drizzleDb.schemas.agent.slug, slug), ne(drizzleDb.schemas.agent.id, agentId)) : eq(drizzleDb.schemas.agent.slug, slug);
    const [countResult] = await db.select({count: count()}).from(drizzleDb.schemas.agent).where(conditions);
    if (countResult.count > 0) {
        throw new ActionError("Slug already exists");
    }
};

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 [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,
    };
});

export const updateAgentAction = userAction
    .schema(
        z.object({
            id: z.string(),
            data: AgentSchema,
        })
    )
    .action(async ({parsedInput}) => {
        const slug = slugify(parsedInput.data.name);
        await verifySlugUniqueness(slug, parsedInput.id);

        const [updatedAgent] = await db.update(drizzleDb.schemas.agent).set({
            ...parsedInput.data,
            slug: slug
        }).where(eq(drizzleDb.schemas.agent.id, parsedInput.id)).returning();

        return {
            data: updatedAgent,
        };
    });

export const getAgentAction = userAction.schema(z.string()).action(async ({parsedInput}) => {
    const agent = await db.query.agent.findFirst({
        where: eq(drizzleDb.schemas.agent.id, parsedInput),
        with: {
            databases: true
        }
    });

    return {
        data: agent,
        health: agent ? await getHealthLast12hLogs({ id: agent.id }) : []
    };
});