fix: Ephemeral envs init

apps/jobs/package.json

@@ -18,6 +18,8 @@
     "@ctrlplane/logger": "workspace:*",
     "@ctrlplane/validators": "workspace:*",
     "cron": "^3.1.7",
+    "lodash": "^4.17.21",
+    "ts-is-present": "^1.2.2",
     "zod": "catalog:"
   },
   "devDependencies": {

apps/jobs/src/ephemeral-env-checker/index.ts

@@ -0,0 +1,60 @@
+import _ from "lodash";
+import { isPresent } from "ts-is-present";
+
+import { and, eq, inArray, isNotNull, lte } from "@ctrlplane/db";
+import { db } from "@ctrlplane/db/client";
+import * as SCHEMA from "@ctrlplane/db/schema";
+
+type QueryRow = {
+  environment: SCHEMA.Environment;
+  deployment: SCHEMA.Deployment;
+};
+
+const groupByEnvironment = (rows: QueryRow[]) =>
+  _.chain(rows)
+    .groupBy((e) => e.environment.id)
+    .map((env) => ({
+      ...env[0]!.environment,
+      deployments: env.map((e) => e.deployment),
+    }))
+    .value();
+
+export const run = async () => {
+  const ephemeralEnvironments = await db
+    .select()
+    .from(SCHEMA.environment)
+    .innerJoin(
+      SCHEMA.deployment,
+      eq(SCHEMA.deployment.systemId, SCHEMA.environment.systemId),
+    )
+    .where(
+      and(
+        isNotNull(SCHEMA.environment.expiresAt),
+        lte(SCHEMA.environment.expiresAt, new Date()),
+      ),
+    )
+    .then(groupByEnvironment);
+  if (ephemeralEnvironments.length === 0) return;
+
+  const targetPromises = ephemeralEnvironments
+    .filter((env) => isPresent(env.targetFilter))
+    .map(async (env) => {
+      const targets = await db
+        .select()
+        .from(SCHEMA.target)
+        .where(SCHEMA.targetMatchesMetadata(db, env.targetFilter));
+
+      return { environmentId: env.id, targets };
+    });
+  const associatedTargets = await Promise.all(targetPromises);
+
+  for (const { environmentId, targets } of associatedTargets)
+    console.log(
+      `[${targets.length}] targets are associated with ephemeral environment [${environmentId}]`,
+    );
+
+  const envIds = ephemeralEnvironments.map((env) => env.id);
+  await db
+    .delete(SCHEMA.environment)
+    .where(inArray(SCHEMA.environment.id, envIds));
+};

apps/jobs/src/index.ts

@@ -15,13 +15,18 @@ import { z } from "zod";
 
 import { logger } from "@ctrlplane/logger";
 
+import { run as ephemeralEnvChecker } from "./ephemeral-env-checker/index.js";
 import { run as jobPolicyChecker } from "./policy-checker/index.js";
 
 const jobs: Record<string, { run: () => Promise<void>; schedule: string }> = {
   "policy-checker": {
     run: jobPolicyChecker,
     schedule: "* * * * *", // Default: Every minute
   },
+  "ephemeral-env-checker": {
+    run: ephemeralEnvChecker,
+    schedule: "* * * * *", // Default: Every minute
+  },
 };
 
 const jobSchema = z.object({

apps/webservice/src/app/[workspaceSlug]/_components/environment-drawer/EnvironmentDrawer.tsx

@@ -50,6 +50,7 @@ export const EnvironmentDrawer: React.FC = () => {
   const environmentQ = api.environment.byId.useQuery(environmentId ?? "", {
     enabled: isOpen,
   });
+  const environmentQError = environmentQ.error;
   const environment = environmentQ.data;
 
   const { workspaceSlug } = useParams<{ workspaceSlug: string }>();
@@ -75,17 +76,24 @@ export const EnvironmentDrawer: React.FC = () => {
         showBar={false}
         className="left-auto right-0 top-0 mt-0 h-screen w-2/3 max-w-6xl overflow-auto rounded-none focus-visible:outline-none"
       >
-        <DrawerTitle className="flex items-center gap-2 border-b p-6">
-          <div className="flex-shrink-0 rounded bg-green-500/20 p-1 text-green-400">
-            <IconPlant className="h-4 w-4" />
+        <DrawerTitle className="flex flex-col gap-2 border-b p-6">
+          <div className="flex items-center gap-2">
+            <div className="flex-shrink-0 rounded bg-green-500/20 p-1 text-green-400">
+              <IconPlant className="h-4 w-4" />
+            </div>
+            {environment?.name}
+            {environment != null && (
+              <EnvironmentDropdownMenu environment={environment}>
+                <Button variant="ghost" size="icon" className="h-6 w-6">
+                  <IconDotsVertical className="h-4 w-4" />
+                </Button>
+              </EnvironmentDropdownMenu>
+            )}
           </div>
-          {environment?.name}
-          {environment != null && (
-            <EnvironmentDropdownMenu environment={environment}>
-              <Button variant="ghost" size="icon" className="h-6 w-6">
-                <IconDotsVertical className="h-4 w-4" />
-              </Button>
-            </EnvironmentDropdownMenu>
+          {environmentQError != null && (
+            <div className="text-xs text-red-500">
+              {environmentQError.message}
+            </div>
           )}
         </DrawerTitle>
 

apps/webservice/src/app/[workspaceSlug]/_components/environment-drawer/Overview.tsx

@@ -1,7 +1,9 @@
 import type * as SCHEMA from "@ctrlplane/db/schema";
+import { addDays, addHours, addMinutes, format } from "date-fns";
 import { z } from "zod";
 
 import { Button } from "@ctrlplane/ui/button";
+import { Checkbox } from "@ctrlplane/ui/checkbox";
 import {
   Form,
   FormControl,
@@ -11,34 +13,94 @@ import {
   useForm,
 } from "@ctrlplane/ui/form";
 import { Input } from "@ctrlplane/ui/input";
+import { Label } from "@ctrlplane/ui/label";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@ctrlplane/ui/select";
 import { Textarea } from "@ctrlplane/ui/textarea";
 
 import { api } from "~/trpc/react";
 
 const schema = z.object({
   name: z.string().min(1).max(100),
   description: z.string().max(1000).nullable(),
+  durationNumber: z.number().min(0).nullable(),
+  durationUnit: z.enum(["minutes", "hours", "days"]).nullable(),
+  removeExpiration: z.boolean(),
 });
 
 type OverviewProps = {
   environment: SCHEMA.Environment;
 };
 
+const getExpiresAt = (
+  expiresAt: Date | null,
+  durationNumber: number,
+  durationUnit: "minutes" | "hours" | "days",
+) => {
+  const currExpiresAt = expiresAt ?? new Date();
+  if (durationUnit === "minutes")
+    return addMinutes(currExpiresAt, durationNumber);
+  if (durationUnit === "hours") return addHours(currExpiresAt, durationNumber);
+  return addDays(currExpiresAt, durationNumber);
+};
+
 export const Overview: React.FC<OverviewProps> = ({ environment }) => {
-  const form = useForm({ schema, defaultValues: environment });
+  const defaultValues = {
+    ...environment,
+    durationNumber: null,
+    durationUnit: "hours" as const,
+    removeExpiration: false,
+  };
+  const form = useForm({ schema, defaultValues });
   const update = api.environment.update.useMutation();
   const envOverride = api.job.trigger.create.byEnvId.useMutation();
 
   const utils = api.useUtils();
 
   const { id, systemId } = environment;
-  const onSubmit = form.handleSubmit((data) =>
+  const onSubmit = form.handleSubmit((data) => {
+    const { durationNumber, durationUnit, removeExpiration } = data;
+    const expiresAt = removeExpiration
+      ? null
+      : durationNumber != null && durationUnit != null
+        ? getExpiresAt(environment.expiresAt, durationNumber, durationUnit)
+        : environment.expiresAt;
+
+    const envData = { ...data, expiresAt };
+
+    const resetValues = {
+      ...data,
+      durationNumber: null,
+      removeExpiration: false,
+    };
     update
-      .mutateAsync({ id, data })
-      .then(() => form.reset(data))
+      .mutateAsync({ id, data: envData })
+      .then(() => form.reset(resetValues))
       .then(() => utils.environment.bySystemId.invalidate(systemId))
-      .then(() => utils.environment.byId.invalidate(id)),
-  );
+      .then(() => utils.environment.byId.invalidate(id));
+  });
+
+  const currExpiresAt = environment.expiresAt;
+  const { durationNumber, durationUnit, removeExpiration } = form.watch();
+
+  const currentExpiration =
+    currExpiresAt != null
+      ? format(currExpiresAt, "MMM d, yyyy h:mm a")
+      : "never";
+
+  const newExpiration = removeExpiration
+    ? "never"
+    : durationNumber != null && durationUnit != null
+      ? format(
+          getExpiresAt(currExpiresAt, durationNumber, durationUnit),
+          "MMM d, yyyy h:mm a",
+        )
+      : null;
 
   return (
     <Form {...form}>
@@ -72,6 +134,89 @@ export const Overview: React.FC<OverviewProps> = ({ environment }) => {
           )}
         />
 
+        <div className="space-y-4">
+          <Label>Environment expiration</Label>
+          <div className="flex flex-col gap-1 text-sm text-muted-foreground">
+            <span>Current expiration: {currentExpiration}</span>
+            <span>New expiration: {newExpiration ?? "No change"}</span>
+          </div>
+
+          <div className="flex items-center gap-2 text-sm">
+            {currExpiresAt == null && <span>Environment expires in: </span>}
+            {currExpiresAt != null && <span>Extend expiration by: </span>}
+            <FormField
+              control={form.control}
+              name="durationNumber"
+              render={({ field: { value, onChange } }) => (
+                <FormItem className="w-16">
+                  <FormControl>
+                    <Input
+                      type="number"
+                      value={value ?? ""}
+                      className="appearance-none [&::-webkit-inner-spin-button]:appearance-none [&::-webkit-outer-spin-button]:appearance-none"
+                      onChange={(e) => {
+                        const num = e.target.valueAsNumber;
+                        if (Number.isNaN(num)) {
+                          onChange(null);
+                          return;
+                        }
+                        onChange(num);
+                      }}
+                    />
+                  </FormControl>
+                </FormItem>
+              )}
+            />
+            <FormField
+              control={form.control}
+              name="durationUnit"
+              render={({ field: { value, onChange } }) => (
+                <FormItem className="w-24">
+                  <FormControl>
+                    <Select
+                      value={value ?? undefined}
+                      onValueChange={onChange}
+                      defaultValue="hours"
+                    >
+                      <SelectTrigger>
+                        <SelectValue placeholder="Select duration unit..." />
+                      </SelectTrigger>
+                      <SelectContent>
+                        <SelectItem value="minutes">Minutes</SelectItem>
+                        <SelectItem value="hours">Hours</SelectItem>
+                        <SelectItem value="days">Days</SelectItem>
+                      </SelectContent>
+                    </Select>
+                  </FormControl>
+                </FormItem>
+              )}
+            />
+          </div>
+
+          <FormField
+            control={form.control}
+            name="removeExpiration"
+            render={({ field: { value, onChange } }) => (
+              <FormItem>
+                <FormControl>
+                  <div className="flex items-center gap-2">
+                    <Checkbox
+                      checked={value}
+                      onCheckedChange={(v) => {
+                        onChange(v);
+                        if (v) form.setValue("durationNumber", null);
+                      }}
+                    />
+                    <label htmlFor="removeExpiration" className="text-sm">
+                      Remove expiration
+                    </label>
+                  </div>
+                </FormControl>
+              </FormItem>
+            )}
+          />
+        </div>
+
         <div className="flex items-center gap-2">
           <Button
             type="submit"

apps/webservice/src/app/api/v1/environments/route.ts

@@ -1,16 +1,20 @@
 import type { PermissionChecker } from "@ctrlplane/auth/utils";
 import type { User } from "@ctrlplane/db/schema";
-import type { z } from "zod";
 import { NextResponse } from "next/server";
+import { isPresent } from "ts-is-present";
+import { z } from "zod";
 
+import { takeFirst } from "@ctrlplane/db";
 import * as schema from "@ctrlplane/db/schema";
 import { Permission } from "@ctrlplane/validators/auth";
 
 import { authn, authz } from "../auth";
 import { parseBody } from "../body-parser";
 import { request } from "../middleware";
 
-const body = schema.createEnvironment;
+const body = schema.createEnvironment.extend({
+  expiresAt: z.coerce.date().optional(),
+});
 
 export const POST = request()
   .use(authn)
@@ -23,12 +27,17 @@ export const POST = request()
     ),
   )
   .handle<{ user: User; can: PermissionChecker; body: z.infer<typeof body> }>(
-    async (ctx) => {
-      const environment = await ctx.db
+    async (ctx) =>
+      ctx.db
         .insert(schema.environment)
-        .values(ctx.body)
-        .returning();
-
-      return NextResponse.json({ environment });
-    },
+        .values({
+          ...ctx.body,
+          expiresAt: isPresent(ctx.body.expiresAt)
+            ? new Date(ctx.body.expiresAt)
+            : undefined,
+        })
+        .returning()
+        .then(takeFirst)
+        .then((environment) => NextResponse.json({ environment }))
+        .catch((error) => NextResponse.json({ error }, { status: 500 })),
   );

apps/webservice/src/app/api/v1/job-agents/[agentId]/jobs/running/route.ts

@@ -1,7 +1,7 @@
 import type { NextRequest } from "next/server";
 import { NextResponse } from "next/server";
 
-import { and, eq, isNull, notInArray } from "@ctrlplane/db";
+import { and, eq, notInArray } from "@ctrlplane/db";
 import { db } from "@ctrlplane/db/client";
 import {
   deployment,
@@ -40,7 +40,6 @@ export const GET = async (
           "completed",
           "invalid_job_agent",
         ]),
-        isNull(environment.deletedAt),
       ),
     )
     .then((rows) =>