Skip to content

🪢 Open source agent evals & observability: Trace, evaluate, and improve LLM applications with one open platform.

72.5 KB
Raw Blame
import {
  makeZodVerifiedAPICall,
  makeAPICall,
} from "@/src/__tests__/test-utils";
import { z } from "zod";
import {
  createApiKey,
  createBasicAuthHeader,
} from "@langfuse/shared/src/server";
import { prisma } from "@langfuse/shared/src/db";
import { OrganizationId, SystemRoleId, UserId } from "@langfuse/shared/rbac";
import { randomUUID } from "crypto";
import { createMocks } from "node-mocks-http";
import { type NextApiRequest, type NextApiResponse } from "next";
import scimUsersRoute from "@/src/pages/api/public/scim/Users";
import scimUserRoute from "@/src/pages/api/public/scim/Users/[id]";
import { env } from "@/src/env.mjs";

vi.mock("@/src/env.mjs", async (importOriginal) => {
  const actual = await importOriginal<{ env: typeof env }>();
  return { ...actual, env: { ...actual.env } };
});

/** callScimRoute invokes a SCIM route handler in-process with an API key header. */
const callScimRoute = async (
  route: typeof scimUsersRoute,
  {
    method,
    authorization,
    userId,
    body,
  }: {
    method: "POST" | "PUT" | "PATCH" | "DELETE";
    authorization: string;
    userId?: string;
    body?: unknown;
  },
) => {
  const { req, res } = createMocks<NextApiRequest, NextApiResponse>({
    method,
    headers: { authorization },
    query: { id: userId },
    body: body as Record<string, unknown>,
  });
  await route(req, res);
  return { status: res.statusCode, body: String(res._getData()) };
};

// Schema for SCIM User response
const ScimUserSchema = z.object({
  schemas: z.array(z.string()),
  id: z.string(),
  userName: z.string(),
  name: z
    .object({
      formatted: z.string().nullable(),
    })
    .optional(),
  emails: z
    .array(
      z.object({
        primary: z.boolean(),
        value: z.string(),
        type: z.string(),
      }),
    )
    .optional(),
  meta: z.object({
    resourceType: z.string(),
    created: z.string().optional(),
    lastModified: z.string().optional(),
  }),
});

// Schema for SCIM Users list response
const ScimUsersListSchema = z.object({
  schemas: z.array(z.string()),
  totalResults: z.number(),
  startIndex: z.number(),
  itemsPerPage: z.number(),
  Resources: z.array(ScimUserSchema),
});

// Schema for SCIM Service Provider Config response
const ServiceProviderConfigSchema = z.object({
  schemas: z.array(z.string()),
  documentationUri: z.string(),
  patch: z.object({
    supported: z.boolean(),
  }),
  bulk: z.object({
    supported: z.boolean(),
    maxOperations: z.number(),
    maxPayloadSize: z.number(),
  }),
  filter: z.object({
    supported: z.boolean(),
    maxResults: z.number(),
  }),
  changePassword: z.object({
    supported: z.boolean(),
  }),
  sort: z.object({
    supported: z.boolean(),
  }),
  etag: z.object({
    supported: z.boolean(),
  }),
  authenticationSchemes: z.array(
    z.object({
      name: z.string(),
      description: z.string(),
      specUri: z.string(),
      type: z.string(),
      primary: z.boolean(),
    }),
  ),
  meta: z.object({
    resourceType: z.string(),
    location: z.string(),
  }),
});

// Schema for SCIM Schemas response
const SchemasResponseSchema = z.object({
  schemas: z.array(z.string()),
  totalResults: z.number(),
  Resources: z.array(
    z.object({
      id: z.string(),
      name: z.string(),
      description: z.string(),
      attributes: z.array(z.any()),
      meta: z.object({
        resourceType: z.string(),
        location: z.string(),
      }),
    }),
  ),
});

// Schema for SCIM Resource Types response
const ResourceTypesResponseSchema = z.object({
  schemas: z.array(z.string()),
  totalResults: z.number(),
  Resources: z.array(
    z.object({
      schemas: z.array(z.string()),
      id: z.string(),
      name: z.string(),
      endpoint: z.string(),
      description: z.string(),
      schema: z.string(),
      schemaExtensions: z.array(
        z.object({
          schema: z.string(),
          required: z.boolean(),
        }),
      ),
      meta: z.object({
        resourceType: z.string(),
        location: z.string(),
      }),
    }),
  ),
});

describe("SCIM API", () => {
  // Test variables
  const orgId = "seed-org-id";
  const orgApiKey = `pk-lf-org-${randomUUID().substring(0, 8)}`;
  const orgSecretKey = `sk-lf-org-${randomUUID().substring(0, 8)}`;
  const projectApiKey = "pk-lf-1234567890";
  const projectSecretKey = "sk-lf-1234567890";
  const invalidApiKey = "pk-lf-invalid";
  const invalidSecretKey = "sk-lf-invalid";
  let testUserId: string;

  beforeAll(async () => {
    const keyCreator = await prisma.user.create({
      data: { email: `apikey-creator-${randomUUID()}@example.com` },
    });
    await createApiKey(prisma, {
      tenant: OrganizationId(orgId),
      scope: OrganizationId(orgId),
      role: SystemRoleId("LEGACY_ORGANIZATION_API_KEY"),
      createdBy: UserId(keyCreator.id),
      predefinedKeys: {
        publicKey: orgApiKey,
        secretKey: orgSecretKey,
      },
    });
  });

  describe("GET /api/public/scim/ServiceProviderConfig", () => {
    it("should return service provider configuration with valid organization API key", async () => {
      const response = await makeZodVerifiedAPICall(
        ServiceProviderConfigSchema,
        "GET",
        "/api/public/scim/ServiceProviderConfig",
        undefined,
        createBasicAuthHeader(orgApiKey, orgSecretKey),
        200,
      );

      expect(response.status).toBe(200);
      expect(response.body.schemas).toContain(
        "urn:ietf:params:scim:schemas:core:2.0:ServiceProviderConfig",
      );
      expect(response.body.patch.supported).toBe(false);
      expect(response.body.filter.supported).toBe(true);
    });

    it("should return 401 when invalid API keys are provided", async () => {
      const result = await makeAPICall<{ detail: string }>(
        "GET",
        "/api/public/scim/ServiceProviderConfig",
        undefined,
        createBasicAuthHeader(invalidApiKey, invalidSecretKey),
      );
      expect(result.status).toBe(401);
      expect(result.body.detail).toBeDefined();
    });

    it("should return 403 when using project API key instead of organization API key", async () => {
      const result = await makeAPICall<{ detail: string }>(
        "GET",
        "/api/public/scim/ServiceProviderConfig",
        undefined,
        createBasicAuthHeader(projectApiKey, projectSecretKey),
      );
      expect(result.status).toBe(403);
    });

    it("should return 405 for non-GET methods", async () => {
      const result = await makeAPICall<{ detail: string }>(
        "POST",
        "/api/public/scim/ServiceProviderConfig",
        {},
        createBasicAuthHeader(orgApiKey, orgSecretKey),
      );
      expect(result.status).toBe(405);
      expect(result.body.detail).toContain("Method not allowed");
    });
  });

  describe("GET /api/public/scim/Schemas", () => {
    it("should return schemas with valid organization API key", async () => {
      const response = await makeZodVerifiedAPICall(
        SchemasResponseSchema,
        "GET",
        "/api/public/scim/Schemas",
        undefined,
        createBasicAuthHeader(orgApiKey, orgSecretKey),
        200,
      );

      expect(response.status).toBe(200);
      expect(response.body.schemas).toContain(
        "urn:ietf:params:scim:api:messages:2.0:ListResponse",
      );
      expect(response.body.Resources.length).toBeGreaterThan(0);
      // RFC 7644 3.4.2: `totalResults` must match what was actually returned.
      expect(response.body.totalResults).toBe(response.body.Resources.length);
      expect(response.body.Resources[0].id).toContain(
        "urn:ietf:params:scim:schemas:core:2.0:User",
      );
      // `password` must not be advertised: schema discovery is how a SCIM
      // client learns the attribute is unsupported.
      const attributeNames = response.body.Resources[0].attributes.map(
        (attribute) => (attribute as { name: string }).name,
      );
      expect(attributeNames).not.toContain("password");
    });

    it("should return 401 when invalid API keys are provided", async () => {
      const result = await makeAPICall<{ detail: string }>(
        "GET",
        "/api/public/scim/Schemas",
        undefined,
        createBasicAuthHeader(invalidApiKey, invalidSecretKey),
      );
      expect(result.status).toBe(401);
      expect(result.body.detail).toBeDefined();
    });

    it("should return 403 when using project API key instead of organization API key", async () => {
      const result = await makeAPICall<{ detail: string }>(
        "GET",
        "/api/public/scim/Schemas",
        undefined,
        createBasicAuthHeader(projectApiKey, projectSecretKey),
      );
      expect(result.status).toBe(403);
    });

    it("should return 405 for non-GET methods", async () => {
      const result = await makeAPICall<{ detail: string }>(
        "POST",
        "/api/public/scim/Schemas",
        {},
        createBasicAuthHeader(orgApiKey, orgSecretKey),
      );
      expect(result.status).toBe(405);
      expect(result.body.detail).toContain("Method not allowed");
    });
  });

  describe("GET /api/public/scim/ResourceTypes", () => {
    it("should return resource types with valid organization API key", async () => {
      const response = await makeZodVerifiedAPICall(
        ResourceTypesResponseSchema,
        "GET",
        "/api/public/scim/ResourceTypes",
        undefined,
        createBasicAuthHeader(orgApiKey, orgSecretKey),
        200,
      );

      expect(response.status).toBe(200);
      expect(response.body.schemas).toContain(
        "urn:ietf:params:scim:api:messages:2.0:ListResponse",
      );
      expect(response.body.Resources.length).toBeGreaterThan(0);
      expect(response.body.Resources[0].id).toBe("User");
      expect(response.body.Resources[0].endpoint).toBe(
        "/api/public/scim/Users",
      );
    });

    it("should return 401 when invalid API keys are provided", async () => {
      const result = await makeAPICall<{ detail: string }>(
        "GET",
        "/api/public/scim/ResourceTypes",
        undefined,
        createBasicAuthHeader(invalidApiKey, invalidSecretKey),
      );
      expect(result.status).toBe(401);
      expect(result.body.detail).toBeDefined();
    });

    it("should return 403 when using project API key instead of organization API key", async () => {
      const result = await makeAPICall<{ detail: string }>(
        "GET",
        "/api/public/scim/ResourceTypes",
        undefined,
        createBasicAuthHeader(projectApiKey, projectSecretKey),
      );
      expect(result.status).toBe(403);
    });

    it("should return 405 for non-GET methods", async () => {
      const result = await makeAPICall<{ detail: string }>(
        "POST",
        "/api/public/scim/ResourceTypes",
        {},
        createBasicAuthHeader(orgApiKey, orgSecretKey),
      );
      expect(result.status).toBe(405);
      expect(result.body.detail).toContain("Method not allowed");
    });
  });

  describe("SCIM Users API", () => {
    // Clean up test users after each test
    afterEach(async () => {
      if (testUserId) {
        await prisma.user.deleteMany({
          where: {
            id: testUserId,
          },
        });
        testUserId = "";
      }
    });

    describe("GET /api/public/scim/Users", () => {
      it("should return users with valid organization API key", async () => {
        const response = await makeZodVerifiedAPICall(
          ScimUsersListSchema,
          "GET",
          "/api/public/scim/Users",
          undefined,
          createBasicAuthHeader(orgApiKey, orgSecretKey),
          200,
        );

        expect(response.status).toBe(200);
        expect(response.body.schemas).toContain(
          "urn:ietf:params:scim:api:messages:2.0:ListResponse",
        );
        expect(response.body.totalResults).toBeGreaterThanOrEqual(0);
        expect(response.body.startIndex).toBe(1);
      });

      it("should support filtering by userName", async () => {
        // First create a test user
        const uniqueEmail = `test.user.${randomUUID().substring(0, 8)}@example.com`;
        const createResponse = await makeAPICall<{ id: string }>(
          "POST",
          "/api/public/scim/Users",
          {
            userName: uniqueEmail,
            name: {
              formatted: "Test User",
            },
            emails: [
              {
                primary: true,
                value: uniqueEmail,
                type: "work",
              },
            ],
            active: true,
          },
          createBasicAuthHeader(orgApiKey, orgSecretKey),
        );

        expect(createResponse.status).toBe(201);
        testUserId = createResponse.body.id;

        // Now filter for this user
        const response = await makeZodVerifiedAPICall(
          ScimUsersListSchema,
          "GET",
          `/api/public/scim/Users?filter=userName eq "${uniqueEmail}"`,
          undefined,
          createBasicAuthHeader(orgApiKey, orgSecretKey),
          200,
        );

        expect(response.status).toBe(200);
        expect(response.body.totalResults).toBe(1);
        expect(response.body.Resources[0].userName).toBe(uniqueEmail);
      });

      it("should return 401 when invalid API keys are provided", async () => {
        const result = await makeAPICall<{ detail: string }>(
          "GET",
          "/api/public/scim/Users",
          undefined,
          createBasicAuthHeader(invalidApiKey, invalidSecretKey),
        );
        expect(result.status).toBe(401);
        expect(result.body.detail).toBeDefined();
      });

      it("should return 403 when using project API key instead of organization API key", async () => {
        const result = await makeAPICall<{ detail: string }>(
          "GET",
          "/api/public/scim/Users",
          undefined,
          createBasicAuthHeader(projectApiKey, projectSecretKey),
        );
        expect(result.status).toBe(403);
      });

      it("should return 405 for non-GET/POST methods", async () => {
        const result = await makeAPICall<{ detail: string }>(
          "PUT",
          "/api/public/scim/Users",
          {},
          createBasicAuthHeader(orgApiKey, orgSecretKey),
        );
        expect(result.status).toBe(405);
        expect(result.body.detail).toContain("Method not allowed");
      });
    });

    describe("POST /api/public/scim/Users", () => {
      it("should create a new user with valid organization API key", async () => {
        const uniqueEmail = `test.user.${randomUUID().substring(0, 8)}@example.com`;
        const response = await makeZodVerifiedAPICall(
          ScimUserSchema,
          "POST",
          "/api/public/scim/Users",
          {
            userName: uniqueEmail,
            name: {
              formatted: "Test User",
            },
            emails: [
              {
                primary: true,
                value: uniqueEmail,
                type: "work",
              },
            ],
            active: true,
          },
          createBasicAuthHeader(orgApiKey, orgSecretKey),
          201,
        );

        expect(response.status).toBe(201);
        expect(response.body.userName).toBe(uniqueEmail);
        expect(response.body.name!.formatted).toBe("Test User");
        expect(response.body.emails![0].value).toBe(uniqueEmail);

        testUserId = response.body.id;

        // Verify the user was actually created in the database
        const user = await prisma.user.findUnique({
          where: { id: testUserId },
        });
        expect(user).not.toBeNull();
        expect(user?.email).toBe(uniqueEmail);
        expect(user?.name).toBe("Test User");
      });

      it("accepts a password attribute but never sets a credential", async () => {
        const uniqueEmail = `test.user.${randomUUID().substring(0, 8)}@example.com`;
        const password = `password-${randomUUID().substring(0, 8)}`;
        const response = await makeZodVerifiedAPICall(
          ScimUserSchema,
          "POST",
          "/api/public/scim/Users",
          {
            userName: uniqueEmail,
            name: {
              formatted: "Test User With Password",
            },
            emails: [
              {
                primary: true,
                value: uniqueEmail,
                type: "work",
              },
            ],
            active: true,
            password: password,
          },
          createBasicAuthHeader(orgApiKey, orgSecretKey),
          201,
        );

        expect(response.status).toBe(201);
        expect(response.body.userName).toBe(uniqueEmail);
        expect(response.body.name!.formatted).toBe("Test User With Password");
        expect(response.body.emails![0].value).toBe(uniqueEmail);
        // Password should not be returned in the response
        expect(
          (response.body as unknown as { password?: string }).password,
        ).toBeUndefined();

        testUserId = response.body.id;

        // Verify the user was actually created in the database
        const user = await prisma.user.findUnique({
          where: { id: testUserId },
        });
        expect(user).not.toBeNull();
        expect(user?.email).toBe(uniqueEmail);
        expect(user?.name).toBe("Test User With Password");
        // The password attribute is ignored, so the account has no usable
        // credential and cannot be signed into with the supplied value. Okta
        // sends a placeholder password on every create, so the request must
        // still succeed rather than 4xx.
        expect(user?.password).toBeNull();
      });

      it("should return 400 when userName is missing", async () => {
        const result = await makeAPICall<{ detail: string }>(
          "POST",
          "/api/public/scim/Users",
          {
            name: {
              formatted: "Test User",
            },
          },
          createBasicAuthHeader(orgApiKey, orgSecretKey),
        );
        expect(result.status).toBe(400);
        expect(result.body.detail).toContain("userName is required");
      });

      it("should create a new user with specified role", async () => {
        const uniqueEmail = `test.user.${randomUUID().substring(0, 8)}@example.com`;
        const response = await makeZodVerifiedAPICall(
          ScimUserSchema,
          "POST",
          "/api/public/scim/Users",
          {
            userName: uniqueEmail,
            name: {
              formatted: "Test User With Role",
            },
            emails: [
              {
                primary: true,
                value: uniqueEmail,
                type: "work",
              },
            ],
            active: true,
            roles: ["ADMIN"],
          },
          createBasicAuthHeader(orgApiKey, orgSecretKey),
          201,
        );

        expect(response.status).toBe(201);
        expect(response.body.userName).toBe(uniqueEmail);
        expect(response.body.name!.formatted).toBe("Test User With Role");

        testUserId = response.body.id;

        // Verify the user was created with the specified role
        const orgMemberships = await prisma.organizationMembership.findMany({
          where: { userId: testUserId, orgId: orgId },
        });
        expect(orgMemberships.length).toBe(1);
        expect(orgMemberships[0].role).toBe("ADMIN");
      });

      it("should write an audit log entry when creating a user", async () => {
        const uniqueEmail = `test.user.${randomUUID().substring(0, 8)}@example.com`;
        const response = await makeAPICall<{ id: string }>(
          "POST",
          "/api/public/scim/Users",
          {
            userName: uniqueEmail,
            name: {
              formatted: "Audited User",
            },
            roles: ["MEMBER"],
          },
          createBasicAuthHeader(orgApiKey, orgSecretKey),
        );

        expect(response.status).toBe(201);
        testUserId = response.body.id;

        const orgMembership = await prisma.organizationMembership.findFirst({
          where: { userId: testUserId, orgId: orgId },
        });
        expect(orgMembership).not.toBeNull();

        const auditLogs = await prisma.auditLog.findMany({
          where: {
            resourceType: "orgMembership",
            resourceId: orgMembership!.id,
            action: "create",
            orgId: orgId,
          },
        });
        expect(auditLogs.length).toBe(1);
        expect(auditLogs[0].apiKeyId).not.toBeNull();
        expect(auditLogs[0].userId).toBeNull();
        expect(auditLogs[0].after).toContain(orgMembership!.id);
      });

      it("should return 409 when user with the same userName already exists", async () => {
        const uniqueEmail = `test.user.${randomUUID().substring(0, 8)}@example.com`;

        // First create a user
        const createResponse = await makeAPICall<{ id: string }>(
          "POST",
          "/api/public/scim/Users",
          {
            userName: uniqueEmail,
            name: {
              formatted: "Test User",
            },
          },
          createBasicAuthHeader(orgApiKey, orgSecretKey),
        );
        expect(createResponse.status).toBe(201);
        testUserId = createResponse.body.id;

        // Try to create another user with the same userName
        const duplicateResult = await makeAPICall<{ detail: string }>(
          "POST",
          "/api/public/scim/Users",
          {
            userName: uniqueEmail,
            name: {
              formatted: "Another User",
            },
          },
          createBasicAuthHeader(orgApiKey, orgSecretKey),
        );
        expect(duplicateResult.status).toBe(409);
        expect(duplicateResult.body.detail).toContain("already exists");
      });

      it("should return 409 when userName differs only by email case", async () => {
        const localPart = `Mixed.Case.${randomUUID().substring(0, 8)}`;
        const mixedCaseEmail = `${localPart}@Example.com`;
        const lowerCaseEmail = `${localPart.toLowerCase()}@example.com`;

        // Create with mixed-case userName
        const createResponse = await makeAPICall<{ id: string }>(
          "POST",
          "/api/public/scim/Users",
          {
            userName: mixedCaseEmail,
            name: {
              formatted: "Test User",
            },
          },
          createBasicAuthHeader(orgApiKey, orgSecretKey),
        );
        expect(createResponse.status).toBe(201);
        testUserId = createResponse.body.id;

        // The stored user email should be lowercased
        const storedUser = await prisma.user.findUnique({
          where: { id: testUserId },
        });
        expect(storedUser?.email).toBe(lowerCaseEmail);

        // Re-POST with a case-variant userName: must be detected as duplicate
        const duplicateResult = await makeAPICall<{ detail: string }>(
          "POST",
          "/api/public/scim/Users",
          {
            userName: lowerCaseEmail,
            name: {
              formatted: "Another User",
            },
          },
          createBasicAuthHeader(orgApiKey, orgSecretKey),
        );
        expect(duplicateResult.status).toBe(409);
        expect(duplicateResult.body.detail).toContain("already exists");

        // No duplicate org membership should have been created
        const orgMemberships = await prisma.organizationMembership.findMany({
          where: { userId: testUserId, orgId },
        });
        expect(orgMemberships.length).toBe(1);
      });
    });

    describe("GET /api/public/scim/Users/{id}", () => {
      beforeEach(async () => {
        // Create a test user
        const uniqueEmail = `test.user.${randomUUID().substring(0, 8)}@example.com`;
        const user = await prisma.user.create({
          data: {
            email: uniqueEmail,
            name: "Test User",
          },
        });
        await prisma.organizationMembership.create({
          data: {
            userId: user.id,
            orgId: orgId,
            role: "NONE",
          },
        });

        testUserId = user.id;
      });

      it("should return a specific user with valid organization API key", async () => {
        const response = await makeZodVerifiedAPICall(
          ScimUserSchema,
          "GET",
          `/api/public/scim/Users/${testUserId}`,
          undefined,
          createBasicAuthHeader(orgApiKey, orgSecretKey),
          200,
        );

        expect(response.status).toBe(200);
        expect(response.body.id).toBe(testUserId);
        expect(response.body.name!.formatted).toBe("Test User");
      });

      it("should return 404 when user does not exist", async () => {
        const nonExistentUserId = randomUUID();
        const result = await makeAPICall<{ detail: string }>(
          "GET",
          `/api/public/scim/Users/${nonExistentUserId}`,
          undefined,
          createBasicAuthHeader(orgApiKey, orgSecretKey),
        );
        expect(result.status).toBe(404);
        expect(result.body.detail).toContain("User not found");
      });
    });

    describe("PUT /api/public/scim/Users/{id}", () => {
      beforeEach(async () => {
        // Create a test user
        const uniqueEmail = `test.user.${randomUUID().substring(0, 8)}@example.com`;
        const user = await prisma.user.create({
          data: {
            email: uniqueEmail,
            name: "Test User",
          },
        });
        await prisma.organizationMembership.create({
          data: {
            userId: user.id,
            orgId: orgId,
            role: "NONE",
          },
        });
        testUserId = user.id;
      });

      it("should deactivate a user when active is false", async () => {
        const response = await makeZodVerifiedAPICall(
          ScimUserSchema,
          "PUT",
          `/api/public/scim/Users/${testUserId}`,
          {
            schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"],
            id: testUserId,
            userName: "[email protected]",
            active: false,
          },
          createBasicAuthHeader(orgApiKey, orgSecretKey),
          200,
        );

        expect(response.status).toBe(200);
        expect(response.body.id).toBe(testUserId);

        // Verify the user was removed from the organization
        const orgMemberships = await prisma.organizationMembership.findMany({
          where: { userId: testUserId, orgId: orgId },
        });
        expect(orgMemberships.length).toBe(0);
      });

      it("should reactivate a user when active is true", async () => {
        // First deactivate the user
        await prisma.organizationMembership.deleteMany({
          where: { userId: testUserId, orgId: orgId },
        });

        const response = await makeZodVerifiedAPICall(
          ScimUserSchema,
          "PUT",
          `/api/public/scim/Users/${testUserId}`,
          {
            schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"],
            id: testUserId,
            userName: "[email protected]",
            active: true,
          },
          createBasicAuthHeader(orgApiKey, orgSecretKey),
          200,
        );

        expect(response.status).toBe(200);
        expect(response.body.id).toBe(testUserId);

        // Verify the user was re-added to the organization with default role
        const orgMemberships = await prisma.organizationMembership.findMany({
          where: { userId: testUserId, orgId: orgId },
        });
        expect(orgMemberships.length).toBe(1);
        expect(orgMemberships[0].role).toBe("NONE");
      });

      it("should reactivate a user with specified role", async () => {
        // First deactivate the user
        await prisma.organizationMembership.deleteMany({
          where: { userId: testUserId, orgId: orgId },
        });

        const response = await makeZodVerifiedAPICall(
          ScimUserSchema,
          "PUT",
          `/api/public/scim/Users/${testUserId}`,
          {
            schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"],
            id: testUserId,
            userName: "[email protected]",
            active: true,
            roles: ["MEMBER"],
          },
          createBasicAuthHeader(orgApiKey, orgSecretKey),
          200,
        );

        expect(response.status).toBe(200);
        expect(response.body.id).toBe(testUserId);

        // Verify the user was re-added to the organization with specified role
        const orgMemberships = await prisma.organizationMembership.findMany({
          where: { userId: testUserId, orgId: orgId },
        });
        expect(orgMemberships.length).toBe(1);
        expect(orgMemberships[0].role).toBe("MEMBER");
      });

      it("should create the membership with NONE when no roles are provided (PUT active:true)", async () => {
        await prisma.organizationMembership.deleteMany({
          where: { userId: testUserId, orgId: orgId },
        });

        const response = await makeAPICall(
          "PUT",
          `/api/public/scim/Users/${testUserId}`,
          {
            schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"],
            id: testUserId,
            userName: "[email protected]",
            active: true,
          },
          createBasicAuthHeader(orgApiKey, orgSecretKey),
        );
        expect(response.status).toBe(200);

        const membership = await prisma.organizationMembership.findFirst({
          where: { userId: testUserId, orgId: orgId },
        });
        expect(membership).not.toBeNull();
        expect(membership!.role).toBe("NONE");

        // Provisioning a new membership writes a create audit entry.
        const auditLogs = await prisma.auditLog.findMany({
          where: {
            resourceType: "orgMembership",
            resourceId: membership!.id,
            action: "create",
            orgId: orgId,
          },
        });
        expect(auditLogs.length).toBe(1);
        expect(auditLogs[0].apiKeyId).not.toBeNull();
        expect(auditLogs[0].userId).toBeNull();
        expect(auditLogs[0].after).toContain(membership!.id);
      });

      it("should NOT modify an existing member's role when no roles are provided (PUT active:true, no downgrade)", async () => {
        // Simulate a real, elevated member (the role someone set in-app or via
        // the create flow).
        await prisma.organizationMembership.updateMany({
          where: { userId: testUserId, orgId: orgId },
          data: { role: "MEMBER" },
        });
        const before = await prisma.organizationMembership.findFirst({
          where: { userId: testUserId, orgId: orgId },
        });
        expect(before?.role).toBe("MEMBER");

        // A periodic IdP full-sync re-sends active:true WITHOUT roles — it must
        // not touch the existing role.
        const response = await makeZodVerifiedAPICall(
          ScimUserSchema,
          "PUT",
          `/api/public/scim/Users/${testUserId}`,
          {
            schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"],
            id: testUserId,
            userName: "[email protected]",
            active: true,
          },
          createBasicAuthHeader(orgApiKey, orgSecretKey),
          200,
        );
        expect(response.status).toBe(200);

        const after = await prisma.organizationMembership.findMany({
          where: { userId: testUserId, orgId: orgId },
        });
        expect(after.length).toBe(1);
        expect(after[0].role).toBe("MEMBER");
        expect(after[0].id).toBe(before!.id);

        // No-op must not write an audit log entry.
        const auditLogs = await prisma.auditLog.findMany({
          where: {
            resourceType: "orgMembership",
            resourceId: before!.id,
            orgId: orgId,
          },
        });
        expect(auditLogs.length).toBe(0);
      });

      it("should update an existing member's role when active is omitted (Okta profile push)", async () => {
        const before = await prisma.organizationMembership.findFirst({
          where: { userId: testUserId, orgId: orgId },
        });

        const response = await makeZodVerifiedAPICall(
          ScimUserSchema,
          "PUT",
          `/api/public/scim/Users/${testUserId}`,
          {
            schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"],
            id: testUserId,
            userName: "[email protected]",
            roles: ["ADMIN"],
          },
          createBasicAuthHeader(orgApiKey, orgSecretKey),
          200,
        );
        expect(response.status).toBe(200);

        const after = await prisma.organizationMembership.findFirst({
          where: { userId: testUserId, orgId: orgId },
        });
        expect(after!.id).toBe(before!.id);
        expect(after!.role).toBe("ADMIN");

        const auditLogs = await prisma.auditLog.findMany({
          where: {
            resourceType: "orgMembership",
            resourceId: before!.id,
            action: "update",
            orgId: orgId,
          },
        });
        expect(auditLogs.length).toBe(1);
      });

      it("should leave an existing member untouched when both active and roles are omitted", async () => {
        await prisma.organizationMembership.updateMany({
          where: { userId: testUserId, orgId: orgId },
          data: { role: "MEMBER" },
        });

        const response = await makeAPICall(
          "PUT",
          `/api/public/scim/Users/${testUserId}`,
          {
            schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"],
            id: testUserId,
            userName: "[email protected]",
          },
          createBasicAuthHeader(orgApiKey, orgSecretKey),
        );
        expect(response.status).toBe(200);

        const after = await prisma.organizationMembership.findMany({
          where: { userId: testUserId, orgId: orgId },
        });
        expect(after.length).toBe(1);
        expect(after[0].role).toBe("MEMBER");
      });

      it("should write a delete audit log when PUT active:false deprovisions a membership", async () => {
        const before = await prisma.organizationMembership.findFirst({
          where: { userId: testUserId, orgId: orgId },
        });
        expect(before).not.toBeNull();

        const response = await makeAPICall(
          "PUT",
          `/api/public/scim/Users/${testUserId}`,
          {
            schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"],
            id: testUserId,
            userName: "[email protected]",
            active: false,
          },
          createBasicAuthHeader(orgApiKey, orgSecretKey),
        );
        expect(response.status).toBe(200);

        const remaining = await prisma.organizationMembership.findMany({
          where: { userId: testUserId, orgId: orgId },
        });
        expect(remaining.length).toBe(0);

        const auditLogs = await prisma.auditLog.findMany({
          where: {
            resourceType: "orgMembership",
            resourceId: before!.id,
            action: "delete",
            orgId: orgId,
          },
        });
        expect(auditLogs.length).toBe(1);
        expect(auditLogs[0].apiKeyId).not.toBeNull();
        expect(auditLogs[0].before).toContain(before!.id);
      });

      it("should return 400 when SCIM schema is missing", async () => {
        const result = await makeAPICall<{ detail: string }>(
          "PUT",
          `/api/public/scim/Users/${testUserId}`,
          {
            id: testUserId,
            userName: "[email protected]",
            active: false,
          },
          createBasicAuthHeader(orgApiKey, orgSecretKey),
        );
        expect(result.status).toBe(400);
        expect(result.body.detail).toContain("schemas");
      });

      it("should return 404 when user does not exist", async () => {
        const nonExistentUserId = randomUUID();
        const result = await makeAPICall<{ detail: string }>(
          "PUT",
          `/api/public/scim/Users/${nonExistentUserId}`,
          {
            schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"],
            id: nonExistentUserId,
            userName: "[email protected]",
            active: false,
          },
          createBasicAuthHeader(orgApiKey, orgSecretKey),
        );
        expect(result.status).toBe(404);
        expect(result.body.detail).toContain("User not found");
      });
    });

    describe("DELETE /api/public/scim/Users/{id}", () => {
      beforeEach(async () => {
        // Create a test user
        const uniqueEmail = `test.user.${randomUUID().substring(0, 8)}@example.com`;
        const user = await prisma.user.create({
          data: {
            email: uniqueEmail,
            name: "Test User",
          },
        });
        await prisma.organizationMembership.create({
          data: {
            userId: user.id,
            orgId: orgId,
            role: "NONE",
          },
        });
        testUserId = user.id;
      });

      it("should delete a user with valid organization API key", async () => {
        try {
          await makeAPICall(
            "DELETE",
            `/api/public/scim/Users/${testUserId}`,
            undefined,
            createBasicAuthHeader(orgApiKey, orgSecretKey),
          );
        } catch (_e) {
          // ignore
        }

        const orgMemberships = await prisma.organizationMembership.findMany({
          where: { id: testUserId },
        });
        expect(orgMemberships.length).toBe(0);
      });

      it("should write a delete audit log when DELETE removes a membership", async () => {
        const before = await prisma.organizationMembership.findFirst({
          where: { userId: testUserId, orgId: orgId },
        });
        expect(before).not.toBeNull();

        try {
          await makeAPICall(
            "DELETE",
            `/api/public/scim/Users/${testUserId}`,
            undefined,
            createBasicAuthHeader(orgApiKey, orgSecretKey),
          );
        } catch (_e) {
          // ignore
        }

        const auditLogs = await prisma.auditLog.findMany({
          where: {
            resourceType: "orgMembership",
            resourceId: before!.id,
            action: "delete",
            orgId: orgId,
          },
        });
        expect(auditLogs.length).toBe(1);
        expect(auditLogs[0].apiKeyId).not.toBeNull();
        expect(auditLogs[0].before).toContain(before!.id);
      });

      it("should capture cascade-deleted project memberships in the delete audit before payload", async () => {
        // Seeded project that belongs to seed-org-id.
        const seededProjectId = "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a";
        const orgMembership =
          await prisma.organizationMembership.findFirstOrThrow({
            where: { userId: testUserId, orgId: orgId },
          });
        // Give the user project-level access. This row is cascade-deleted when
        // the org membership is removed, so the audit before payload is the
        // only place it can be preserved.
        await prisma.projectMembership.create({
          data: {
            orgMembershipId: orgMembership.id,
            projectId: seededProjectId,
            userId: testUserId,
            role: "VIEWER",
          },
        });

        try {
          await makeAPICall(
            "DELETE",
            `/api/public/scim/Users/${testUserId}`,
            undefined,
            createBasicAuthHeader(orgApiKey, orgSecretKey),
          );
        } catch (_e) {
          // ignore
        }

        // The cascaded project membership is gone from the DB...
        const remainingProjectMemberships =
          await prisma.projectMembership.findMany({
            where: { userId: testUserId },
          });
        expect(remainingProjectMemberships.length).toBe(0);

        // ...but recoverable from the delete audit before payload.
        const auditLog = await prisma.auditLog.findFirst({
          where: {
            resourceType: "orgMembership",
            resourceId: orgMembership.id,
            action: "delete",
            orgId: orgId,
          },
        });
        expect(auditLog).not.toBeNull();
        expect(auditLog!.before).toContain("ProjectMemberships");
        expect(auditLog!.before).toContain(seededProjectId);
      });

      it("should return 404 when user does not exist", async () => {
        const nonExistentUserId = randomUUID();
        const result = await makeAPICall<{ detail: string }>(
          "DELETE",
          `/api/public/scim/Users/${nonExistentUserId}`,
          undefined,
          createBasicAuthHeader(orgApiKey, orgSecretKey),
        );
        expect(result.status).toBe(404);
        expect(result.body.detail).toContain("User not found");
      });
    });

    describe("PATCH /api/public/scim/Users/{id}", () => {
      const patchAuth = () => createBasicAuthHeader(orgApiKey, orgSecretKey);
      const provisionOp = {
        schemas: ["urn:ietf:params:scim:api:messages:2.0:PatchOp"],
        Operations: [{ op: "replace", value: { active: true } }],
      };
      const deprovisionOp = {
        schemas: ["urn:ietf:params:scim:api:messages:2.0:PatchOp"],
        Operations: [{ op: "replace", value: { active: false } }],
      };

      beforeEach(async () => {
        const uniqueEmail = `test.user.${randomUUID().substring(0, 8)}@example.com`;
        const user = await prisma.user.create({
          data: { email: uniqueEmail, name: "Test User" },
        });
        await prisma.organizationMembership.create({
          data: { userId: user.id, orgId: orgId, role: "NONE" },
        });
        testUserId = user.id;
      });

      it("should not modify an existing member's role on PATCH active:true (no-op, no audit)", async () => {
        await prisma.organizationMembership.updateMany({
          where: { userId: testUserId, orgId: orgId },
          data: { role: "MEMBER" },
        });
        const before = await prisma.organizationMembership.findFirst({
          where: { userId: testUserId, orgId: orgId },
        });

        const result = await makeAPICall(
          "PATCH",
          `/api/public/scim/Users/${testUserId}`,
          provisionOp,
          patchAuth(),
        );
        expect(result.status).toBe(200);

        const after = await prisma.organizationMembership.findMany({
          where: { userId: testUserId, orgId: orgId },
        });
        expect(after.length).toBe(1);
        expect(after[0].role).toBe("MEMBER");

        const auditLogs = await prisma.auditLog.findMany({
          where: {
            resourceType: "orgMembership",
            resourceId: before!.id,
            orgId: orgId,
          },
        });
        expect(auditLogs.length).toBe(0);
      });

      it("should write a create audit log when PATCH active:true provisions a missing membership", async () => {
        await prisma.organizationMembership.deleteMany({
          where: { userId: testUserId, orgId: orgId },
        });

        const result = await makeAPICall(
          "PATCH",
          `/api/public/scim/Users/${testUserId}`,
          provisionOp,
          patchAuth(),
        );
        expect(result.status).toBe(200);

        const membership = await prisma.organizationMembership.findFirst({
          where: { userId: testUserId, orgId: orgId },
        });
        expect(membership).not.toBeNull();
        expect(membership!.role).toBe("NONE");

        const auditLogs = await prisma.auditLog.findMany({
          where: {
            resourceType: "orgMembership",
            resourceId: membership!.id,
            action: "create",
            orgId: orgId,
          },
        });
        expect(auditLogs.length).toBe(1);
        expect(auditLogs[0].apiKeyId).not.toBeNull();
      });

      it("should write a delete audit log when PATCH active:false deprovisions a membership", async () => {
        const before = await prisma.organizationMembership.findFirst({
          where: { userId: testUserId, orgId: orgId },
        });
        expect(before).not.toBeNull();

        const result = await makeAPICall(
          "PATCH",
          `/api/public/scim/Users/${testUserId}`,
          deprovisionOp,
          patchAuth(),
        );
        // PATCH ends by delegating to handleGet, so after a successful
        // deprovision the user is no longer a member and the endpoint responds
        // 404. The deprovision (and its audit log) still happened — asserted
        // below. (PUT active:false returns 200 instead; this PATCH quirk is
        // pre-existing and out of scope here.)
        expect(result.status).toBe(404);

        const remaining = await prisma.organizationMembership.findMany({
          where: { userId: testUserId, orgId: orgId },
        });
        expect(remaining.length).toBe(0);

        const auditLogs = await prisma.auditLog.findMany({
          where: {
            resourceType: "orgMembership",
            resourceId: before!.id,
            action: "delete",
            orgId: orgId,
          },
        });
        expect(auditLogs.length).toBe(1);
        expect(auditLogs[0].before).toContain(before!.id);
      });
    });

    describe("Last OWNER protection", () => {
      // Each scenario needs a fresh organization with exactly one OWNER so we
      // can exercise the guard without interfering with the seeded OWNER on
      // `seed-org-id`.
      let scopedOrgId: string;
      let scopedOwnerUserId: string;
      let scopedOrgPublicKey: string;
      let scopedOrgSecretKey: string;
      const originalMode = env.API_AUTH_MIGRATION;

      beforeEach(async () => {
        Object.assign(env, { API_AUTH_MIGRATION: "enforce" });
        const org = await prisma.organization.create({
          data: {
            name: `scim-last-owner-${randomUUID().substring(0, 8)}`,
            // Team plan carries the `admin-api` entitlement that gates SCIM, so
            // these requests reach the last-OWNER guard rather than the plan
            // check.
            cloudConfig: { plan: "Team" },
          },
        });
        scopedOrgId = org.id;

        const owner = await prisma.user.create({
          data: {
            email: `owner.${randomUUID().substring(0, 8)}@example.com`,
            name: "Sole Owner",
          },
        });
        scopedOwnerUserId = owner.id;
        await prisma.organizationMembership.create({
          data: { userId: owner.id, orgId: scopedOrgId, role: "OWNER" },
        });

        scopedOrgPublicKey = `pk-lf-org-${randomUUID().substring(0, 8)}`;
        scopedOrgSecretKey = `sk-lf-org-${randomUUID().substring(0, 8)}`;
        await createApiKey(prisma, {
          tenant: OrganizationId(scopedOrgId),
          scope: OrganizationId(scopedOrgId),
          role: SystemRoleId("LEGACY_ORGANIZATION_API_KEY"),
          createdBy: UserId(owner.id),
          predefinedKeys: {
            publicKey: scopedOrgPublicKey,
            secretKey: scopedOrgSecretKey,
          },
        });
      });

      afterEach(async () => {
        Object.assign(env, { API_AUTH_MIGRATION: originalMode });
        await prisma.user.deleteMany({ where: { id: scopedOwnerUserId } });
        await prisma.organization.deleteMany({ where: { id: scopedOrgId } });
      });

      it("DELETE rejects removing the only remaining OWNER", async () => {
        const result = await callScimRoute(scimUserRoute, {
          method: "DELETE",
          authorization: createBasicAuthHeader(
            scopedOrgPublicKey,
            scopedOrgSecretKey,
          ),
          userId: scopedOwnerUserId,
        });

        expect(result.status).toBe(403);
        expect(result.body.toLowerCase()).toContain("last owner");

        const remaining = await prisma.organizationMembership.findMany({
          where: { userId: scopedOwnerUserId, orgId: scopedOrgId },
        });
        expect(remaining.length).toBe(1);
        expect(remaining[0].role).toBe("OWNER");
      });

      it("PUT active:false rejects removing the only remaining OWNER", async () => {
        const result = await callScimRoute(scimUserRoute, {
          method: "PUT",
          authorization: createBasicAuthHeader(
            scopedOrgPublicKey,
            scopedOrgSecretKey,
          ),
          userId: scopedOwnerUserId,
          body: {
            schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"],
            id: scopedOwnerUserId,
            userName: "[email protected]",
            active: false,
          },
        });

        expect(result.status).toBe(403);
        expect(result.body.toLowerCase()).toContain("last owner");

        const remaining = await prisma.organizationMembership.findMany({
          where: { userId: scopedOwnerUserId, orgId: scopedOrgId },
        });
        expect(remaining.length).toBe(1);
        expect(remaining[0].role).toBe("OWNER");
      });

      it("PATCH active:false rejects removing the only remaining OWNER", async () => {
        const result = await callScimRoute(scimUserRoute, {
          method: "PATCH",
          authorization: createBasicAuthHeader(
            scopedOrgPublicKey,
            scopedOrgSecretKey,
          ),
          userId: scopedOwnerUserId,
          body: {
            schemas: ["urn:ietf:params:scim:api:messages:2.0:PatchOp"],
            Operations: [{ op: "replace", value: { active: false } }],
          },
        });

        expect(result.status).toBe(403);
        expect(result.body.toLowerCase()).toContain("last owner");

        const remaining = await prisma.organizationMembership.findMany({
          where: { userId: scopedOwnerUserId, orgId: scopedOrgId },
        });
        expect(remaining.length).toBe(1);
        expect(remaining[0].role).toBe("OWNER");
      });

      it("PUT active:true with a lower role rejects demoting the only remaining OWNER", async () => {
        const result = await callScimRoute(scimUserRoute, {
          method: "PUT",
          authorization: createBasicAuthHeader(
            scopedOrgPublicKey,
            scopedOrgSecretKey,
          ),
          userId: scopedOwnerUserId,
          body: {
            schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"],
            id: scopedOwnerUserId,
            userName: "[email protected]",
            active: true,
            roles: ["MEMBER"],
          },
        });

        expect(result.status).toBe(403);
        expect(result.body.toLowerCase()).toContain("last owner");

        const remaining = await prisma.organizationMembership.findMany({
          where: { userId: scopedOwnerUserId, orgId: scopedOrgId },
        });
        expect(remaining.length).toBe(1);
        expect(remaining[0].role).toBe("OWNER");
      });

      it("PUT active:true with a lower role allows demoting an OWNER when another OWNER remains", async () => {
        const secondOwner = await prisma.user.create({
          data: {
            email: `owner2.${randomUUID().substring(0, 8)}@example.com`,
            name: "Second Owner",
          },
        });
        await prisma.organizationMembership.create({
          data: {
            userId: secondOwner.id,
            orgId: scopedOrgId,
            role: "OWNER",
          },
        });

        try {
          const result = await callScimRoute(scimUserRoute, {
            method: "PUT",
            authorization: createBasicAuthHeader(
              scopedOrgPublicKey,
              scopedOrgSecretKey,
            ),
            userId: scopedOwnerUserId,
            body: {
              schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"],
              id: scopedOwnerUserId,
              userName: "[email protected]",
              active: true,
              roles: ["MEMBER"],
            },
          });
          expect(result.status).toBe(200);

          const demoted = await prisma.organizationMembership.findFirst({
            where: { userId: scopedOwnerUserId, orgId: scopedOrgId },
          });
          expect(demoted?.role).toBe("MEMBER");
        } finally {
          await prisma.organizationMembership.deleteMany({
            where: { userId: secondOwner.id, orgId: scopedOrgId },
          });
          await prisma.user.deleteMany({ where: { id: secondOwner.id } });
        }
      });

      it("DELETE allows removing an OWNER when another OWNER remains", async () => {
        const secondOwner = await prisma.user.create({
          data: {
            email: `owner2.${randomUUID().substring(0, 8)}@example.com`,
            name: "Second Owner",
          },
        });
        await prisma.organizationMembership.create({
          data: {
            userId: secondOwner.id,
            orgId: scopedOrgId,
            role: "OWNER",
          },
        });

        try {
          const result = await callScimRoute(scimUserRoute, {
            method: "DELETE",
            authorization: createBasicAuthHeader(
              scopedOrgPublicKey,
              scopedOrgSecretKey,
            ),
            userId: secondOwner.id,
          });
          expect(result.status).toBe(204);

          const memberships = await prisma.organizationMembership.findMany({
            where: { userId: secondOwner.id, orgId: scopedOrgId },
          });
          expect(memberships.length).toBe(0);
        } finally {
          await prisma.user.deleteMany({ where: { id: secondOwner.id } });
        }
      });
    });
  });

  describe("Cross-organization isolation (Users/{id})", () => {
    const createdUserIds: string[] = [];

    // A user that exists on the instance but is NOT a member of the caller's
    // organization (seed-org-id) — i.e. a user belonging to some other org.
    const createNonMemberUser = async () => {
      const user = await prisma.user.create({
        data: {
          email: `outsider.${randomUUID().substring(0, 8)}@othercorp.example`,
          name: "Outside Org User",
        },
      });
      createdUserIds.push(user.id);
      return user;
    };

    afterEach(async () => {
      if (createdUserIds.length > 0) {
        await prisma.organizationMembership.deleteMany({
          where: { userId: { in: createdUserIds } },
        });
        await prisma.user.deleteMany({
          where: { id: { in: createdUserIds } },
        });
        createdUserIds.length = 0;
      }
    });

    it("GET on an out-of-org user is a 404", async () => {
      const outsider = await createNonMemberUser();

      const nonMember = await makeAPICall<{
        detail: string;
        userName?: string;
        name?: unknown;
        emails?: unknown;
        meta?: unknown;
      }>(
        "GET",
        `/api/public/scim/Users/${outsider.id}`,
        undefined,
        createBasicAuthHeader(orgApiKey, orgSecretKey),
      );

      expect(nonMember.status).toBe(404);
      // None of the out-of-org user's attributes may cross the org boundary.
      expect(nonMember.body.userName).toBeUndefined();
      expect(nonMember.body.name).toBeUndefined();
      expect(nonMember.body.emails).toBeUndefined();
      expect(nonMember.body.meta).toBeUndefined();
    });

    it("PUT with active omitted returns 404 for an out-of-org user", async () => {
      const outsider = await createNonMemberUser();

      const result = await makeAPICall<{ detail: string; userName?: string }>(
        "PUT",
        `/api/public/scim/Users/${outsider.id}`,
        {
          schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"],
          roles: ["ADMIN"],
        },
        createBasicAuthHeader(orgApiKey, orgSecretKey),
      );

      expect(result.status).toBe(404);
      expect(result.body.userName).toBeUndefined();
      expect(result.body.detail).toContain("User not found");

      // No membership was created as a side effect.
      const memberships = await prisma.organizationMembership.findMany({
        where: { userId: outsider.id, orgId },
      });
      expect(memberships.length).toBe(0);
    });

    it("PUT active:false on an out-of-org user is a 404, not a silent noop", async () => {
      const outsider = await createNonMemberUser();

      const result = await makeAPICall<{ detail: string; userName?: string }>(
        "PUT",
        `/api/public/scim/Users/${outsider.id}`,
        {
          schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"],
          active: false,
        },
        createBasicAuthHeader(orgApiKey, orgSecretKey),
      );

      expect(result.status).toBe(404);
      expect(result.body.userName).toBeUndefined();
    });

    it("PUT active:true provisions a user who is not yet a member", async () => {
      const outsider = await createNonMemberUser();

      const result = await makeZodVerifiedAPICall(
        ScimUserSchema,
        "PUT",
        `/api/public/scim/Users/${outsider.id}`,
        {
          schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"],
          active: true,
          roles: ["MEMBER"],
        },
        createBasicAuthHeader(orgApiKey, orgSecretKey),
        200,
      );

      expect(result.status).toBe(200);
      const memberships = await prisma.organizationMembership.findMany({
        where: { userId: outsider.id, orgId },
      });
      expect(memberships.length).toBe(1);
      expect(memberships[0].role).toBe("MEMBER");
    });

    it("DELETE on an out-of-org user is a 404", async () => {
      const outsider = await createNonMemberUser();

      const result = await makeAPICall<{ detail: string }>(
        "DELETE",
        `/api/public/scim/Users/${outsider.id}`,
        undefined,
        createBasicAuthHeader(orgApiKey, orgSecretKey),
      );

      expect(result.status).toBe(404);
    });
  });

  // SCIM provisioning is gated behind the `admin-api` entitlement, matching the
  // sibling organization admin REST endpoints (memberships, projects, apiKeys).
  // Plans without that entitlement (e.g. Hobby) must be rejected before any
  // user account is created or any membership is mutated.
  describe("Entitlement gating (admin-api)", () => {
    const PLAN_DETAIL = "This feature is not available on your current plan.";

    let hobbyOrgId: string;
    let hobbyPublicKey: string;
    let hobbySecretKey: string;

    let teamOrgId: string;
    let teamPublicKey: string;
    let teamSecretKey: string;

    beforeAll(async () => {
      // Hobby has no `admin-api` entitlement → SCIM must be blocked.
      const hobbyOrg = await prisma.organization.create({
        data: {
          name: `scim-gate-hobby-${randomUUID().substring(0, 8)}`,
          cloudConfig: { plan: "Hobby" },
        },
      });
      hobbyOrgId = hobbyOrg.id;
      hobbyPublicKey = `pk-lf-org-${randomUUID().substring(0, 8)}`;
      hobbySecretKey = `sk-lf-org-${randomUUID().substring(0, 8)}`;
      const hobbyKeyCreator = await prisma.user.create({
        data: { email: `apikey-creator-${randomUUID()}@example.com` },
      });
      await createApiKey(prisma, {
        tenant: OrganizationId(hobbyOrgId),
        scope: OrganizationId(hobbyOrgId),
        role: SystemRoleId("LEGACY_ORGANIZATION_API_KEY"),
        createdBy: UserId(hobbyKeyCreator.id),
        predefinedKeys: {
          publicKey: hobbyPublicKey,
          secretKey: hobbySecretKey,
        },
      });

      // Team carries `admin-api` → positive control that the gate does not
      // over-block entitled plans.
      const teamOrg = await prisma.organization.create({
        data: {
          name: `scim-gate-team-${randomUUID().substring(0, 8)}`,
          cloudConfig: { plan: "Team" },
        },
      });
      teamOrgId = teamOrg.id;
      teamPublicKey = `pk-lf-org-${randomUUID().substring(0, 8)}`;
      teamSecretKey = `sk-lf-org-${randomUUID().substring(0, 8)}`;
      const teamKeyCreator = await prisma.user.create({
        data: { email: `apikey-creator-${randomUUID()}@example.com` },
      });
      await createApiKey(prisma, {
        tenant: OrganizationId(teamOrgId),
        scope: OrganizationId(teamOrgId),
        role: SystemRoleId("LEGACY_ORGANIZATION_API_KEY"),
        createdBy: UserId(teamKeyCreator.id),
        predefinedKeys: {
          publicKey: teamPublicKey,
          secretKey: teamSecretKey,
        },
      });
    });

    afterAll(async () => {
      await prisma.organization.deleteMany({
        where: { id: { in: [hobbyOrgId, teamOrgId] } },
      });
    });

    it("POST /Users is rejected on a plan without admin-api and creates no account", async () => {
      const uniqueEmail = `scim.gate.${randomUUID().substring(0, 8)}@example.com`;
      const result = await makeAPICall<{ detail: string }>(
        "POST",
        "/api/public/scim/Users",
        {
          schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"],
          userName: uniqueEmail,
          name: { formatted: "Backdoor" },
          password: "Backdoor2026!",
          roles: ["OWNER"],
          active: true,
        },
        createBasicAuthHeader(hobbyPublicKey, hobbySecretKey),
      );

      expect(result.status).toBe(403);
      expect(result.body.detail).toBe(PLAN_DETAIL);

      // The blocked request must not have created the user account.
      const user = await prisma.user.findUnique({
        where: { email: uniqueEmail.toLowerCase() },
      });
      expect(user).toBeNull();
    });

    it("GET /Users is rejected on a plan without admin-api", async () => {
      const result = await makeAPICall<{ detail: string }>(
        "GET",
        "/api/public/scim/Users",
        undefined,
        createBasicAuthHeader(hobbyPublicKey, hobbySecretKey),
      );

      expect(result.status).toBe(403);
      expect(result.body.detail).toBe(PLAN_DETAIL);
    });

    it("PUT /Users/{id} is rejected on a plan without admin-api (before user lookup)", async () => {
      const result = await makeAPICall<{ detail: string }>(
        "PUT",
        `/api/public/scim/Users/${randomUUID()}`,
        {
          schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"],
          userName: "[email protected]",
          active: true,
          roles: ["OWNER"],
        },
        createBasicAuthHeader(hobbyPublicKey, hobbySecretKey),
      );

      expect(result.status).toBe(403);
      expect(result.body.detail).toBe(PLAN_DETAIL);
    });

    it("DELETE /Users/{id} is rejected on a plan without admin-api", async () => {
      const result = await makeAPICall<{ detail: string }>(
        "DELETE",
        `/api/public/scim/Users/${randomUUID()}`,
        undefined,
        createBasicAuthHeader(hobbyPublicKey, hobbySecretKey),
      );

      expect(result.status).toBe(403);
      expect(result.body.detail).toBe(PLAN_DETAIL);
    });

    it("POST /Users still succeeds on a plan with admin-api", async () => {
      const uniqueEmail = `scim.gate.ok.${randomUUID().substring(0, 8)}@example.com`;
      const result = await makeAPICall<{ userName: string }>(
        "POST",
        "/api/public/scim/Users",
        {
          schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"],
          userName: uniqueEmail,
          name: { formatted: "Allowed User" },
          active: true,
        },
        createBasicAuthHeader(teamPublicKey, teamSecretKey),
      );

      expect(result.status).toBe(201);
      expect(result.body.userName).toBe(uniqueEmail);

      // Cleanup the account created by the positive-control request.
      await prisma.user.deleteMany({
        where: { email: uniqueEmail.toLowerCase() },
      });
    });
  });
});

describe("SCIM ownership boundary", () => {
  let orgId: string;
  let ownerId: string;
  let secondOwnerId: string;
  let memberId: string;
  let adminAuth: string;
  let ownerAuth: string;
  const createdEmails: string[] = [];
  const originalMode = env.API_AUTH_MIGRATION;

  beforeEach(async () => {
    Object.assign(env, { API_AUTH_MIGRATION: "enforce" });
    const org = await prisma.organization.create({
      data: { name: randomUUID(), cloudConfig: { plan: "Team" } },
    });
    orgId = org.id;
    const [owner, secondOwner, member] = await Promise.all(
      (["OWNER", "OWNER", "MEMBER"] as const).map((role) =>
        prisma.user.create({
          data: {
            email: `${randomUUID()}@example.com`,
            organizationMemberships: { create: { orgId, role } },
          },
        }),
      ),
    );
    ownerId = owner!.id;
    secondOwnerId = secondOwner!.id;
    memberId = member!.id;
    const [adminKey, ownerKey] = await Promise.all(
      (["ADMIN", "LEGACY_ORGANIZATION_API_KEY"] as const).map((role) =>
        createApiKey(prisma, {
          tenant: OrganizationId(orgId),
          scope: OrganizationId(orgId),
          role: SystemRoleId(role),
          createdBy: UserId(ownerId),
        }),
      ),
    );
    adminAuth = createBasicAuthHeader(adminKey!.publicKey, adminKey!.secretKey);
    ownerAuth = createBasicAuthHeader(ownerKey!.publicKey, ownerKey!.secretKey);
  });

  afterEach(async () => {
    Object.assign(env, { API_AUTH_MIGRATION: originalMode });
    await prisma.auditLog.deleteMany({ where: { orgId } });
    await prisma.organization.delete({ where: { id: orgId } });
    await prisma.user.deleteMany({
      where: {
        OR: [
          { id: { in: [ownerId, secondOwnerId, memberId] } },
          { email: { in: createdEmails.splice(0) } },
        ],
      },
    });
  });

  const call = async (
    route: typeof scimUsersRoute,
    method: "POST" | "PUT" | "PATCH" | "DELETE",
    body?: unknown,
    userId?: string,
  ) =>
    (
      await callScimRoute(route, {
        method,
        authorization: adminAuth,
        userId,
        body,
      })
    ).status;
  const putUser = (userId: string, roles: string[]) =>
    call(
      scimUserRoute,
      "PUT",
      {
        schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"],
        active: true,
        roles,
      },
      userId,
    );
  const roleOf = async (userId: string) =>
    (
      await prisma.organizationMembership.findUnique({
        where: { orgId_userId: { orgId, userId } },
      })
    )?.role;

  it("rejects an ADMIN key creating an OWNER via POST", async () => {
    const email = `${randomUUID()}@example.com`;
    createdEmails.push(email);
    const status = await call(scimUsersRoute, "POST", {
      schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"],
      userName: email,
      roles: ["OWNER"],
    });
    expect(status).toBe(403);
    expect(
      await prisma.organizationMembership.count({
        where: { orgId, user: { email } },
      }),
    ).toBe(0);
  });

  it("rejects ownership changes without an authorization context", async () => {
    Object.assign(env, { API_AUTH_MIGRATION: "legacy" });
    const legacyKey = await createApiKey(prisma, {
      tenant: OrganizationId(orgId),
      scope: OrganizationId(orgId),
      role: SystemRoleId("LEGACY_ORGANIZATION_API_KEY"),
      createdBy: UserId(ownerId),
    });
    const { status } = await callScimRoute(scimUserRoute, {
      method: "PUT",
      authorization: createBasicAuthHeader(
        legacyKey.publicKey,
        legacyKey.secretKey,
      ),
      userId: ownerId,
      body: {
        schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"],
        active: true,
        roles: ["MEMBER"],
      },
    });
    expect(status).toBe(403);
    expect(await roleOf(ownerId)).toBe("OWNER");
  });

  it("rejects an ADMIN key demoting an OWNER via PUT", async () => {
    expect(await putUser(ownerId, ["MEMBER"])).toBe(403);
    expect(await roleOf(ownerId)).toBe("OWNER");
  });

  it("rejects an ADMIN key promoting a member to OWNER via PUT", async () => {
    expect(await putUser(memberId, ["OWNER"])).toBe(403);
    expect(await roleOf(memberId)).toBe("MEMBER");
  });

  it("rejects an ADMIN key provisioning a non-member as OWNER via PUT", async () => {
    const outsider = await prisma.user.create({
      data: { email: `${randomUUID()}@example.com` },
    });
    createdEmails.push(outsider.email!);
    expect(await putUser(outsider.id, ["OWNER"])).toBe(403);
    expect(await roleOf(outsider.id)).toBeUndefined();
  });

  it.each([
    ["DELETE", undefined],
    [
      "PATCH",
      {
        schemas: ["urn:ietf:params:scim:api:messages:2.0:PatchOp"],
        Operations: [{ op: "replace", value: { active: false } }],
      },
    ],
    [
      "PUT",
      {
        schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"],
        active: false,
      },
    ],
  ] as const)(
    "rejects an ADMIN key deprovisioning an OWNER via %s",
    async (method, body) => {
      expect(await call(scimUserRoute, method, body, ownerId)).toBe(403);
      expect(await roleOf(ownerId)).toBe("OWNER");
    },
  );

  it("lets a key with ownership permission grant OWNER via POST and PUT", async () => {
    const email = `${randomUUID()}@example.com`;
    createdEmails.push(email);
    const created = await callScimRoute(scimUsersRoute, {
      method: "POST",
      authorization: ownerAuth,
      body: {
        schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"],
        userName: email,
        roles: ["OWNER"],
      },
    });
    expect(created.status).toBe(201);
    expect(
      await prisma.organizationMembership.findFirst({
        where: { orgId, user: { email } },
      }),
    ).toMatchObject({ role: "OWNER" });

    const promoted = await callScimRoute(scimUserRoute, {
      method: "PUT",
      authorization: ownerAuth,
      userId: memberId,
      body: {
        schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"],
        active: true,
        roles: ["OWNER"],
      },
    });
    expect(promoted.status).toBe(200);
    expect(await roleOf(memberId)).toBe("OWNER");
  });

  it("lets an ADMIN key manage non-owner members", async () => {
    const email = `${randomUUID()}@example.com`;
    createdEmails.push(email);
    expect(
      await call(scimUsersRoute, "POST", {
        schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"],
        userName: email,
        roles: ["ADMIN"],
      }),
    ).toBe(201);
    expect(await putUser(memberId, ["ADMIN"])).toBe(200);
    expect(await roleOf(memberId)).toBe("ADMIN");
    expect(await call(scimUserRoute, "DELETE", undefined, memberId)).toBe(204);
    expect(await roleOf(memberId)).toBeUndefined();
  });

  describe("gateway key revocation", () => {
    const createBoundGatewayKey = (userId: string) =>
      createApiKey(prisma, {
        tenant: OrganizationId(orgId),
        scope: UserId(userId),
        role: SystemRoleId("AI_GATEWAY"),
        createdBy: UserId(userId),
      });
    const keyExists = async (apiKeyId: string) =>
      (await prisma.apiKey.count({ where: { id: apiKeyId } })) === 1;

    it("revokes the gateway keys of a user removed via DELETE", async () => {
      const key = await createBoundGatewayKey(memberId);

      expect(await call(scimUserRoute, "DELETE", undefined, memberId)).toBe(
        204,
      );

      expect(await keyExists(key.id)).toBe(false);
    });

    it.each([
      ["MEMBER", true],
      ["VIEWER", false],
      ["NONE", false],
    ])(
      "keeps gateway keys of an OWNER moved to %s only while the role can invoke the gateway",
      async (role, kept) => {
        const key = await createBoundGatewayKey(ownerId);

        const response = await callScimRoute(scimUserRoute, {
          method: "PUT",
          authorization: ownerAuth,
          userId: ownerId,
          body: {
            schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"],
            active: true,
            roles: [role],
          },
        });

        expect(response.status).toBe(200);
        expect(await roleOf(ownerId)).toBe(role);
        expect(await keyExists(key.id)).toBe(kept);
      },
    );
  });

  describe("AI_GATEWAY role", () => {
    const originalGatewayAvailability = {
      NODE_ENV: env.NODE_ENV,
      LANGFUSE_AI_GATEWAY_ENABLED: env.LANGFUSE_AI_GATEWAY_ENABLED,
      NEXT_PUBLIC_PREVIEW_PR_URL: env.NEXT_PUBLIC_PREVIEW_PR_URL,
      LANGFUSE_AI_GATEWAY_ORGANIZATION_ID_ALLOWLIST:
        env.LANGFUSE_AI_GATEWAY_ORGANIZATION_ID_ALLOWLIST,
    };

    // Only the org allowlist enables the gateway in these tests.
    beforeEach(() => {
      Object.assign(env, {
        NODE_ENV: "test",
        LANGFUSE_AI_GATEWAY_ENABLED: "false",
        NEXT_PUBLIC_PREVIEW_PR_URL: undefined,
        LANGFUSE_AI_GATEWAY_ORGANIZATION_ID_ALLOWLIST: [],
      });
    });

    afterEach(() => {
      Object.assign(env, originalGatewayAvailability);
    });

    it("rejects creating an AI_GATEWAY user via POST while the AI Gateway is off", async () => {
      const email = `${randomUUID()}@example.com`;
      createdEmails.push(email);

      const status = await call(scimUsersRoute, "POST", {
        schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"],
        userName: email,
        roles: ["AI_GATEWAY"],
      });

      expect(status).toBe(403);
      expect(
        await prisma.organizationMembership.count({
          where: { orgId, user: { email } },
        }),
      ).toBe(0);
    });

    it("rejects moving a member to AI_GATEWAY via PUT while the AI Gateway is off", async () => {
      expect(await putUser(memberId, ["AI_GATEWAY"])).toBe(403);

      expect(await roleOf(memberId)).toBe("MEMBER");
    });

    it("keeps an existing AI_GATEWAY member through a sync while the AI Gateway is off", async () => {
      await prisma.organizationMembership.update({
        where: { orgId_userId: { orgId, userId: memberId } },
        data: { role: "AI_GATEWAY" },
      });

      expect(await putUser(memberId, ["AI_GATEWAY"])).toBe(200);

      expect(await roleOf(memberId)).toBe("AI_GATEWAY");
    });

    it("moves a member to AI_GATEWAY via PUT while the AI Gateway is on for the org", async () => {
      Object.assign(env, {
        LANGFUSE_AI_GATEWAY_ORGANIZATION_ID_ALLOWLIST: [orgId],
      });

      expect(await putUser(memberId, ["AI_GATEWAY"])).toBe(200);

      expect(await roleOf(memberId)).toBe("AI_GATEWAY");
    });
  });
});