feat: Target routes

apps/webservice/src/app/api/v1/target-providers/[providerId]/set/route.ts

@@ -61,7 +61,7 @@ export const PATCH = request()
       .then(takeFirstOrNull);
 
     const provider = query?.target_provider;
-    if (!provider)
+    if (provider == null)
       return NextResponse.json(
         { error: "Provider not found" },
         { status: 404 },

apps/webservice/src/app/api/v1/targets/[targetId]/route.ts

@@ -0,0 +1,49 @@
+import { NextResponse } from "next/server";
+
+import { eq } from "@ctrlplane/db";
+import * as schema from "@ctrlplane/db/schema";
+import { Permission } from "@ctrlplane/validators/auth";
+
+import { authn, authz } from "~/app/api/v1/auth";
+import { request } from "~/app/api/v1/middleware";
+
+function transformMetadata(
+  metadata: Array<{ key: string; value: string }>,
+): Record<string, string> {
+  return metadata.reduce<Record<string, string>>((acc, m) => {
+    acc[m.key] = m.value;
+    return acc;
+  }, {});
+}
+
+export const GET = request()
+  .use(authn)
+  .use(
+    authz(({ can, extra }) => {
+      return can
+        .perform(Permission.TargetGet)
+        .on({ type: "target", id: extra.params.targetId });
+    }),
+  )
+  .handle(async ({ db }, { params }: { params: { targetId: string } }) => {
+    const { targetId } = params;
+
+    const target = await db.query.target.findFirst({
+      where: eq(schema.target.id, targetId),
+      with: {
+        metadata: true,
+        variables: true,
+        provider: true,
+      },
+    });
+
+    if (!target)
+      return NextResponse.json({ error: "Target not found" }, { status: 404 });
+
+    const metadata = transformMetadata(target.metadata);
+
+    return NextResponse.json({
+      ...target,
+      metadata,
+    });
+  });

apps/webservice/src/app/api/v1/targets/[targetId]/set/route.ts

@@ -0,0 +1,48 @@
+import type { z } from "zod";
+import { NextResponse } from "next/server";
+
+import { eq } from "@ctrlplane/db";
+import { db } from "@ctrlplane/db/client";
+import * as schema from "@ctrlplane/db/schema";
+import { upsertTargets } from "@ctrlplane/job-dispatch";
+import { Permission } from "@ctrlplane/validators/auth";
+
+import { authn, authz } from "~/app/api/v1/auth";
+import { parseBody } from "~/app/api/v1/body-parser";
+import { request } from "~/app/api/v1/middleware";
+import { bodySchema } from "~/app/api/v1/targets/workspaces/[workspaceId]/route";
+
+export const PATCH = request()
+  .use(authn)
+  .use(parseBody(bodySchema))
+  .use(
+    authz(({ can, extra }) => {
+      return can
+        .perform(Permission.TargetUpdate)
+        .on({ type: "target", id: extra.params.targetId });
+    }),
+  )
+  .handle<
+    { body: z.infer<typeof bodySchema> },
+    { params: { targetId: string } }
+  >(async (ctx, { params }) => {
+    const { body } = ctx;
+
+    console.log(body);
+    console.log(params.targetId);
+
+    const existingTarget = await db.query.target.findFirst({
+      where: eq(schema.target.id, params.targetId),
+    });
+
+    if (existingTarget == null)
+      return NextResponse.json({ error: "Target not found" }, { status: 404 });
+
+    const targetData = {
+      ...existingTarget,
+      ...body.target,
+    };
+
+    const target = await upsertTargets(db, [targetData]);
+    return NextResponse.json(target);
+  });

apps/webservice/src/app/api/v1/targets/workspaces/[workspaceId]/route.ts

@@ -0,0 +1,61 @@
+import { NextResponse } from "next/server";
+import { z } from "zod";
+
+import { db } from "@ctrlplane/db/client";
+import * as schema from "@ctrlplane/db/schema";
+import { upsertTargets } from "@ctrlplane/job-dispatch";
+import { Permission } from "@ctrlplane/validators/auth";
+
+import { authn, authz } from "~/app/api/v1/auth";
+import { parseBody } from "~/app/api/v1/body-parser";
+import { request } from "~/app/api/v1/middleware";
+
+export const bodySchema = z.object({
+  target: schema.createTarget.extend({
+    metadata: z.record(z.string()).optional(),
+    variables: z
+      .array(
+        z.object({
+          key: z.string(),
+          value: z.union([z.string(), z.number(), z.boolean(), z.null()]),
+          sensitive: z.boolean(),
+        }),
+      )
+      .optional()
+      .refine(
+        (vars) =>
+          vars == null || new Set(vars.map((v) => v.key)).size === vars.length,
+        "Duplicate variable keys are not allowed",
+      ),
+  }),
+});
+
+export const POST = request()
+  .use(authn)
+  .use(parseBody(bodySchema))
+  .use(
+    authz(({ can, extra }) => {
+      return can
+        .perform(Permission.TargetCreate)
+        .on({ type: "workspace", id: extra.params.workspaceId });
+    }),
+  )
+  .handle<
+    { body: z.infer<typeof bodySchema> },
+    { params: { workspaceId: string } }
+  >(async (ctx, { params }) => {
+    const { body } = ctx;
+
+    const targetData = {
+      ...body.target,
+      workspaceId: params.workspaceId,
+      variables: body.target.variables?.map((v) => ({
+        ...v,
+        value: v.value ?? null,
+      })),
+    };
+
+    const target = await upsertTargets(db, [targetData]);
+
+    return NextResponse.json(target);
+  });