feat(project): port complete project schema (#1942)

Author: tejaskash

src/core/project/index.tsx

@@ -1 +1,3 @@
 export { FsProjectManager } from "./manager";
+export { ProjectNameSchema, ProjectSpecSchema } from "./schema";
+export type { ProjectRuntime, ProjectSpec } from "./schema";

src/core/project/schema.ts

@@ -0,0 +1,6 @@
+export {
+  AgentCoreProjectSpecSchema as ProjectSpecSchema,
+  ProjectNameSchema,
+} from "./schema/project";
+export type { AgentCoreProjectSpec as ProjectSpec } from "./schema/project";
+export type { AgentEnvSpec as ProjectRuntime } from "./schema/runtime";

src/core/project/schema/ab-test.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "bun:test";
+import { ABTestSchema } from "./ab-test";
+const configurationBundle = { bundleArn: "arn:bundle", bundleVersion: "1" };
+const base = {
+  name: "Experiment",
+  gatewayRef: "{{gateway:main}}",
+  variants: [
+    { name: "C", weight: 50, variantConfiguration: { configurationBundle } },
+    { name: "T1", weight: 50, variantConfiguration: { configurationBundle } },
+  ],
+  evaluationConfig: { onlineEvaluationConfigArn: "arn:evaluation" },
+};
+describe("ABTestSchema custom validation", () => {
+  it("requires one control and one treatment variant", () => {
+    const result = ABTestSchema.safeParse({
+      ...base,
+      variants: base.variants.map((variant) => ({ ...variant, name: "C" })),
+    });
+    expect(result.success).toBe(false);
+  });
+  it("requires variant weights to sum to 100", () => {
+    const result = ABTestSchema.safeParse({
+      ...base,
+      variants: [
+        { ...base.variants[0], weight: 60 },
+        { ...base.variants[1], weight: 60 },
+      ],
+    });
+    expect(result.success).toBe(false);
+  });
+  it("binds variant configuration to the selected mode", () => {
+    const targetBased = ABTestSchema.safeParse({
+      ...base,
+      mode: "target-based",
+      variants: [
+        { name: "C", weight: 50, variantConfiguration: { target: { targetName: "control" } } },
+        { name: "T1", weight: 50, variantConfiguration: { target: { targetName: "treatment" } } },
+      ],
+    });
+    expect(targetBased.success).toBe(true);
+    expect(ABTestSchema.safeParse({ ...base, mode: "target-based" }).success).toBe(false);
+  });
+});

src/core/project/schema/ab-test.ts

@@ -0,0 +1,111 @@
+import { z } from "zod";
+export const ABTestNameSchema = z
+  .string()
+  .min(1, "Name is required")
+  .max(48)
+  .regex(
+    /^[a-zA-Z][a-zA-Z0-9_]{0,47}$/,
+    "Must begin with a letter and contain only alphanumeric characters and underscores (max 48 chars)",
+  );
+export const ABTestDescriptionSchema = z.string().min(1).max(200).optional();
+export const ABTestModeSchema = z
+  .enum(["config-bundle", "target-based"])
+  .optional()
+  .default("config-bundle");
+export type ABTestMode = z.infer<typeof ABTestModeSchema>;
+export const VariantNameSchema = z.enum(["C", "T1"]);
+export const VariantWeightSchema = z.number().int().min(1).max(100);
+export const ConfigurationBundleRefSchema = z.object({
+  bundleArn: z.string().min(1),
+  bundleVersion: z.string().min(1),
+});
+export type ConfigurationBundleRef = z.infer<typeof ConfigurationBundleRefSchema>;
+export const TargetRefSchema = z.object({
+  targetName: z.string().min(1).max(100),
+});
+export type TargetRef = z.infer<typeof TargetRefSchema>;
+const ConfigBundleVariantConfigSchema = z.object({
+  configurationBundle: ConfigurationBundleRefSchema,
+  target: z.never().optional(),
+});
+const TargetVariantConfigSchema = z.object({
+  configurationBundle: z.never().optional(),
+  target: TargetRefSchema,
+});
+export const VariantConfigurationSchema = z.union([
+  ConfigBundleVariantConfigSchema,
+  TargetVariantConfigSchema,
+]);
+export type VariantConfiguration = z.infer<typeof VariantConfigurationSchema>;
+export const ABTestVariantSchema = z.object({
+  name: VariantNameSchema,
+  weight: VariantWeightSchema,
+  variantConfiguration: VariantConfigurationSchema,
+});
+export type ABTestVariant = z.infer<typeof ABTestVariantSchema>;
+export const PerVariantOnlineEvaluationConfigSchema = z.object({
+  treatmentName: VariantNameSchema,
+  onlineEvaluationConfigArn: z.string().min(1),
+});
+export type PerVariantOnlineEvaluationConfig = z.infer<
+  typeof PerVariantOnlineEvaluationConfigSchema
+>;
+export const ABTestEvaluationConfigSchema = z.union([
+  z.object({ onlineEvaluationConfigArn: z.string().min(1) }),
+  z.object({
+    perVariantOnlineEvaluationConfig: z.array(PerVariantOnlineEvaluationConfigSchema).length(2),
+  }),
+]);
+export type ABTestEvaluationConfig = z.infer<typeof ABTestEvaluationConfigSchema>;
+export const GatewayFilterSchema = z.object({
+  targetPaths: z.array(z.string().min(1).max(500)).max(1),
+});
+export type GatewayFilter = z.infer<typeof GatewayFilterSchema>;
+export const TrafficRouteOnHeaderSchema = z.object({
+  headerName: z.string().min(1),
+});
+export const TrafficAllocationConfigSchema = z.object({
+  routeOnHeader: TrafficRouteOnHeaderSchema,
+});
+export type TrafficAllocationConfig = z.infer<typeof TrafficAllocationConfigSchema>;
+export const ABTestSchema = z
+  .object({
+    name: ABTestNameSchema,
+    description: ABTestDescriptionSchema,
+    mode: ABTestModeSchema,
+    gatewayRef: z.string().min(1),
+    roleArn: z.string().min(1).optional(),
+    variants: z.array(ABTestVariantSchema).length(2),
+    evaluationConfig: ABTestEvaluationConfigSchema,
+    gatewayFilter: GatewayFilterSchema.optional(),
+    enableOnCreate: z.boolean().optional(),
+    promoted: z.boolean().optional(),
+  })
+  .refine(
+    (data) => {
+      const names = data.variants.map((v) => v.name);
+      return names.includes("C") && names.includes("T1");
+    },
+    {
+      message: "Variants must include exactly one control (C) and one treatment (T1)",
+      path: ["variants"],
+    },
+  )
+  .refine((data) => data.variants.reduce((sum, v) => sum + v.weight, 0) === 100, {
+    message: "Variant weights must sum to 100",
+    path: ["variants"],
+  })
+  .refine(
+    (data) => {
+      if (data.mode === "target-based") {
+        return data.variants.every((v) => v.variantConfiguration.target != null);
+      }
+      return data.variants.every((v) => v.variantConfiguration.configurationBundle != null);
+    },
+    {
+      message:
+        "Target-based mode requires target on each variant; config-bundle mode requires configurationBundle",
+      path: ["variants"],
+    },
+  );
+export type ABTest = z.infer<typeof ABTestSchema>;

src/core/project/schema/auth.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, it } from "bun:test";
+import {
+  ClaimMatchValueSchema,
+  CustomClaimValidationSchema,
+  CustomJwtAuthorizerConfigSchema,
+  PrivateEndpointSchema,
+} from "./auth";
+const lattice = {
+  selfManagedLatticeResource: {
+    resourceConfigurationIdentifier: "rcfg-0123456789abcdef0",
+  },
+};
+const vpc = {
+  managedVpcResource: {
+    vpcIdentifier: "vpc-0123456789abcdef0",
+    subnetIds: ["subnet-0123456789abcdef0"],
+    endpointIpAddressType: "IPV4" as const,
+  },
+};
+describe("auth custom validation", () => {
+  it("requires exactly one claim match value representation", () => {
+    expect(ClaimMatchValueSchema.safeParse({ matchValueString: "admin" }).success).toBe(true);
+    expect(
+      ClaimMatchValueSchema.safeParse({
+        matchValueString: "admin",
+        matchValueStringList: ["admin"],
+      }).success,
+    ).toBe(false);
+    expect(ClaimMatchValueSchema.safeParse({}).success).toBe(false);
+  });
+  it("rejects reserved custom claim names", () => {
+    expect(
+      CustomClaimValidationSchema.safeParse({
+        inboundTokenClaimName: "client_id",
+        inboundTokenClaimValueType: "STRING",
+        authorizingClaimMatchValue: {
+          claimMatchOperator: "EQUALS",
+          claimMatchValue: { matchValueString: "user" },
+        },
+      }).success,
+    ).toBe(false);
+  });
+  it("requires exactly one private endpoint arm", () => {
+    expect(PrivateEndpointSchema.safeParse(lattice).success).toBe(true);
+    expect(PrivateEndpointSchema.safeParse(vpc).success).toBe(true);
+    expect(PrivateEndpointSchema.safeParse({ ...lattice, ...vpc }).success).toBe(false);
+    expect(PrivateEndpointSchema.safeParse({}).success).toBe(false);
+  });
+  it("requires override arms to match the base endpoint and domains to be unique", () => {
+    const base = {
+      discoveryUrl: "https://example.com/.well-known/openid-configuration",
+      allowedAudience: ["audience"],
+      privateEndpoint: lattice,
+    };
+    expect(
+      CustomJwtAuthorizerConfigSchema.safeParse({
+        ...base,
+        privateEndpointOverrides: [{ domain: "example.com", privateEndpoint: vpc }],
+      }).success,
+    ).toBe(false);
+    expect(
+      CustomJwtAuthorizerConfigSchema.safeParse({
+        ...base,
+        privateEndpointOverrides: [
+          { domain: "example.com", privateEndpoint: lattice },
+          { domain: "example.com", privateEndpoint: lattice },
+        ],
+      }).success,
+    ).toBe(false);
+  });
+  it("does not allow endpoint overrides without a base endpoint", () => {
+    const result = CustomJwtAuthorizerConfigSchema.safeParse({
+      discoveryUrl: "https://example.com/.well-known/openid-configuration",
+      allowedAudience: ["audience"],
+      privateEndpointOverrides: [{ domain: "example.com", privateEndpoint: lattice }],
+    });
+    expect(result.success).toBe(false);
+  });
+});