alpic 0.0.0-dev.ge4d40f3 → 0.0.0-dev.ge4e4833

package/dist/__tests__/mock-api.js

@@ -8,6 +8,32 @@ import { OpenAPIHandler } from "@orpc/openapi/node";
 import { implement, ORPCError } from "@orpc/server";
 import express, {} from "express";
 import { inc as semverInc } from "semver";
+function createEmptyMockData() {
+    return {
+        tunnelTicket: null,
+        teams: null,
+        projects: new Map(),
+        environments: new Map(),
+        deployments: new Map(),
+        environmentVariables: new Map(),
+        runtimeLogs: new Map(),
+        runtimeLogPages: new Map(),
+        deploymentLogPages: new Map(),
+        deploymentLogCallCounts: new Map(),
+        publishedServers: new Map(),
+        beaconGetResponses: [],
+        beaconGetCallCount: 0,
+        playgrounds: new Map(),
+        teamUsages: new Map(),
+        intents: new Map(),
+        feedbacks: new Map(),
+        intentCategories: new Map(),
+        intentCategoryCounter: 0,
+        submissions: new Map(),
+        submissionPrefills: new Map(),
+        telemetryDestinations: new Map(),
+    };
+}
 const __testDirname = dirname(fileURLToPath(import.meta.url));
 const FIXTURE_CERT_PATH = join(__testDirname, "fixtures", "certs", "localhost-cert.pem");
 const FIXTURE_KEY_PATH = join(__testDirname, "fixtures", "certs", "localhost-key.pem");
@@ -26,22 +52,7 @@ export class MockApiServer {
     callHistory = [];
     constructor() {
         this.app = express();
-        this.mockData = {
-            tunnelTicket: null,
-            teams: null,
-            projects: new Map(),
-            environments: new Map(),
-            deployments: new Map(),
-            environmentVariables: new Map(),
-            runtimeLogs: new Map(),
-            runtimeLogPages: new Map(),
-            deploymentLogPages: new Map(),
-            deploymentLogCallCounts: new Map(),
-            publishedServers: new Map(),
-            beaconGetResponses: [],
-            beaconGetCallCount: 0,
-            playgrounds: new Map(),
-        };
+        this.mockData = createEmptyMockData();
     }
     async start() {
         if (this.server) {
@@ -140,6 +151,15 @@ export class MockApiServer {
                         ];
                     }),
                 },
+                getUsage: {
+                    v1: implement(contract.teams.getUsage.v1).handler(async ({ input }) => {
+                        const usage = this.mockData.teamUsages.get(input.teamId);
+                        if (!usage) {
+                            throw new ORPCError("NOT_FOUND", { message: "Team usage not found" });
+                        }
+                        return usage;
+                    }),
+                },
             },
             analytics: {
                 get: {
@@ -172,6 +192,129 @@ export class MockApiServer {
                     }),
                 },
             },
+            intents: {
+                list: {
+                    v1: implement(contract.intents.list.v1).handler(async ({ input }) => {
+                        if (!this.mockData.environments.has(input.environmentId)) {
+                            throw new ORPCError("NOT_FOUND", { message: "Environment not found" });
+                        }
+                        let intents = this.mockData.intents.get(input.environmentId) ?? [];
+                        if (input.search) {
+                            const search = input.search.toLowerCase();
+                            intents = intents.filter((intent) => intent.message.toLowerCase().includes(search) ||
+                                intent.toolName.toLowerCase().includes(search) ||
+                                intent.categories.some(({ name }) => name.toLowerCase().includes(search)));
+                        }
+                        if (input.tools) {
+                            intents = intents.filter(({ toolName }) => input.tools?.includes(toolName));
+                        }
+                        if (input.clientIds) {
+                            intents = intents.filter(({ clientId }) => clientId !== null && input.clientIds?.includes(clientId));
+                        }
+                        if (input.categoryIds) {
+                            intents = intents.filter(({ categories }) => categories.some(({ id }) => input.categoryIds?.includes(id)));
+                        }
+                        intents = [...intents].sort((left, right) => input.sortDir === "asc"
+                            ? left.createdAt.getTime() - right.createdAt.getTime()
+                            : right.createdAt.getTime() - left.createdAt.getTime());
+                        return {
+                            intents: intents.slice(input.offset, input.offset + input.limit),
+                            totalCount: intents.length,
+                        };
+                    }),
+                },
+            },
+            intentCategories: {
+                list: {
+                    v1: implement(contract.intentCategories.list.v1).handler(async ({ input }) => {
+                        const categories = this.requireMockEnvironmentCategories(input.environmentId);
+                        return categories.map(({ linkedIntentIds, ...category }) => ({
+                            ...category,
+                            intentCount: linkedIntentIds.size,
+                        }));
+                    }),
+                },
+                create: {
+                    v1: implement(contract.intentCategories.create.v1).handler(async ({ input }) => {
+                        const categories = this.requireMockEnvironmentCategories(input.environmentId);
+                        this.requireMockIntents(input.environmentId, input.intentIds ?? [], "BAD_REQUEST");
+                        const { linkedIntentIds, ...category } = {
+                            id: `cat-mock-${++this.mockData.intentCategoryCounter}`,
+                            createdAt: new Date("2026-08-13T00:00:00.000Z"),
+                            environmentId: input.environmentId,
+                            name: input.name,
+                            color: input.color ?? "gray",
+                            linkedIntentIds: new Set(input.intentIds ?? []),
+                        };
+                        categories.push({ ...category, linkedIntentIds });
+                        return category;
+                    }),
+                },
+                update: {
+                    v1: implement(contract.intentCategories.update.v1).handler(async ({ input }) => {
+                        const category = this.requireMockIntentCategory(input.environmentId, input.categoryId);
+                        category.name = input.name ?? category.name;
+                        category.color = input.color ?? category.color;
+                        const { linkedIntentIds, ...updated } = category;
+                        return updated;
+                    }),
+                },
+                delete: {
+                    v1: implement(contract.intentCategories.delete.v1).handler(async ({ input }) => {
+                        const category = this.requireMockIntentCategory(input.environmentId, input.categoryId);
+                        this.mockData.intentCategories.set(input.environmentId, (this.mockData.intentCategories.get(input.environmentId) ?? []).filter(({ id }) => id !== category.id));
+                        this.removeCategoryFromIntents(input.environmentId, category.id, null);
+                        return { success: true };
+                    }),
+                },
+                link: {
+                    v1: implement(contract.intentCategories.link.v1).handler(async ({ input }) => {
+                        const category = this.requireMockIntentCategory(input.environmentId, input.categoryId);
+                        this.requireMockIntents(input.environmentId, input.intentIds, "NOT_FOUND");
+                        for (const intentId of input.intentIds) {
+                            category.linkedIntentIds.add(intentId);
+                        }
+                        for (const intent of this.mockData.intents.get(input.environmentId) ?? []) {
+                            const isLinked = intent.intentIds.some((intentId) => category.linkedIntentIds.has(intentId));
+                            if (isLinked && !intent.categories.some(({ id }) => id === category.id)) {
+                                intent.categories.push({ id: category.id, name: category.name, color: category.color });
+                            }
+                        }
+                        return { success: true };
+                    }),
+                },
+                unlink: {
+                    v1: implement(contract.intentCategories.unlink.v1).handler(async ({ input }) => {
+                        const category = this.requireMockIntentCategory(input.environmentId, input.categoryId);
+                        for (const intentId of input.intentIds) {
+                            category.linkedIntentIds.delete(intentId);
+                        }
+                        this.removeCategoryFromIntents(input.environmentId, category.id, category.linkedIntentIds);
+                        return { success: true };
+                    }),
+                },
+            },
+            feedbacks: {
+                list: {
+                    v1: implement(contract.feedbacks.list.v1).handler(async ({ input }) => {
+                        if (!this.mockData.environments.has(input.environmentId)) {
+                            throw new ORPCError("NOT_FOUND", { message: "Environment not found" });
+                        }
+                        let feedbacks = this.mockData.feedbacks.get(input.environmentId) ?? [];
+                        if (input.search) {
+                            const search = input.search.toLowerCase();
+                            feedbacks = feedbacks.filter((feedback) => feedback.content.toLowerCase().includes(search) || feedback.source.toLowerCase().includes(search));
+                        }
+                        if (input.clientIds) {
+                            feedbacks = feedbacks.filter(({ clientId }) => clientId !== null && input.clientIds?.includes(clientId));
+                        }
+                        return {
+                            feedbacks: feedbacks.slice(input.offset, input.offset + input.limit),
+                            totalCount: feedbacks.length,
+                        };
+                    }),
+                },
+            },
             projects: {
                 list: {
                     v1: implement(contract.projects.list.v1).handler(async ({ input }) => {
@@ -355,6 +498,30 @@ export class MockApiServer {
                         return environment;
                     }),
                 },
+                delete: {
+                    v1: implement(contract.environments.delete.v1).handler(async ({ input }) => {
+                        const environment = this.mockData.environments.get(input.environmentId);
+                        if (!environment) {
+                            throw new ORPCError("NOT_FOUND", {
+                                message: "Environment not found",
+                            });
+                        }
+                        const project = this.mockData.projects.get(environment.projectId);
+                        if (project?.productionEnvironment?.id === input.environmentId) {
+                            throw new ORPCError("BAD_REQUEST", {
+                                message: "Cannot delete the production environment of the project",
+                            });
+                        }
+                        this.mockData.environments.delete(input.environmentId);
+                        if (project) {
+                            this.mockData.projects.set(environment.projectId, {
+                                ...project,
+                                environments: project.environments.filter((env) => env.id !== input.environmentId),
+                            });
+                        }
+                        return { success: true };
+                    }),
+                },
                 getLogs: {
                     v1: implement(contract.environments.getLogs.v1).handler(async ({ input }) => {
                         const environment = this.mockData.environments.get(input.environmentId);
@@ -422,6 +589,80 @@ export class MockApiServer {
                     }),
                 },
             },
+            telemetryDestinations: {
+                list: {
+                    v1: implement(contract.telemetryDestinations.list.v1).handler(async ({ input }) => {
+                        if (!this.mockData.environments.has(input.environmentId)) {
+                            throw new ORPCError("NOT_FOUND", { message: "Environment not found" });
+                        }
+                        return this.mockData.telemetryDestinations.get(input.environmentId) ?? [];
+                    }),
+                },
+                create: {
+                    v1: implement(contract.telemetryDestinations.create.v1).handler(async ({ input }) => {
+                        if (!this.mockData.environments.has(input.environmentId)) {
+                            throw new ORPCError("NOT_FOUND", { message: "Environment not found" });
+                        }
+                        const destination = {
+                            id: randomUUID(),
+                            signal: input.signal,
+                            endpoint: input.endpoint,
+                            protocol: input.protocol,
+                            status: "active",
+                            lastFailureReason: null,
+                            isScopedToIntentionalRequestsOnly: input.signal === "traces" && input.isScopedToIntentionalRequestsOnly,
+                            headers: input.headers.map((header) => header.isSecret
+                                ? { id: randomUUID(), name: header.name, value: null, isSecret: true }
+                                : { id: randomUUID(), name: header.name, value: header.value, isSecret: false }),
+                        };
+                        this.mockData.telemetryDestinations.set(input.environmentId, [
+                            ...(this.mockData.telemetryDestinations.get(input.environmentId) ?? []),
+                            destination,
+                        ]);
+                        return destination;
+                    }),
+                },
+                update: {
+                    v1: implement(contract.telemetryDestinations.update.v1).handler(async ({ input }) => {
+                        const destinations = this.mockData.telemetryDestinations.get(input.environmentId) ?? [];
+                        const current = destinations.find(({ id }) => id === input.destinationId);
+                        if (current === undefined) {
+                            throw new ORPCError("NOT_FOUND", { message: "Telemetry destination not found" });
+                        }
+                        const updated = {
+                            ...current,
+                            endpoint: input.endpoint ?? current.endpoint,
+                            protocol: input.protocol ?? current.protocol,
+                            isScopedToIntentionalRequestsOnly: current.signal === "traces"
+                                ? (input.isScopedToIntentionalRequestsOnly ?? current.isScopedToIntentionalRequestsOnly)
+                                : false,
+                            headers: input.headers?.map((header) => {
+                                const previous = header.id === undefined ? undefined : current.headers.find(({ id }) => id === header.id);
+                                const id = header.id ?? randomUUID();
+                                if (header.isSecret) {
+                                    return { id, name: header.name, value: null, isSecret: true };
+                                }
+                                const value = header.value ?? previous?.value;
+                                if (value === undefined || value === null) {
+                                    throw new ORPCError("BAD_REQUEST", { message: `Enter a value for the ${header.name} header` });
+                                }
+                                return { id, name: header.name, value, isSecret: false };
+                            }) ?? current.headers,
+                        };
+                        this.mockData.telemetryDestinations.set(input.environmentId, destinations.map((destination) => (destination.id === updated.id ? updated : destination)));
+                        return updated;
+                    }),
+                },
+                delete: {
+                    v1: implement(contract.telemetryDestinations.delete.v1).handler(async ({ input }) => {
+                        if (!this.mockData.environments.has(input.environmentId)) {
+                            throw new ORPCError("NOT_FOUND", { message: "Environment not found" });
+                        }
+                        this.mockData.telemetryDestinations.set(input.environmentId, (this.mockData.telemetryDestinations.get(input.environmentId) ?? []).filter(({ id }) => id !== input.destinationId));
+                        return { success: true };
+                    }),
+                },
+            },
             environmentVariables: {
                 list: {
                     v1: implement(contract.environmentVariables.list.v1).handler(async ({ input }) => {
@@ -640,6 +881,73 @@ export class MockApiServer {
                     }),
                 },
             },
+            submissions: {
+                create: {
+                    v1: implement(contract.submissions.create.v1).handler(async ({ input }) => {
+                        const environment = this.mockData.environments.get(input.environmentId);
+                        if (!environment) {
+                            throw new ORPCError("NOT_FOUND", { message: "Environment not found" });
+                        }
+                        const formData = this.mockData.submissionPrefills.get(input.platform) ?? {};
+                        const now = new Date();
+                        const submission = {
+                            id: `sub-${randomUUID()}`,
+                            environmentId: input.environmentId,
+                            platform: input.platform,
+                            formData,
+                            prefillSnapshot: formData,
+                            auditId: "audit-1",
+                            urlVerification: null,
+                            createdAt: now,
+                            updatedAt: now,
+                        };
+                        this.mockData.submissions.set(submission.id, submission);
+                        return submission;
+                    }),
+                },
+                list: {
+                    v1: implement(contract.submissions.list.v1).handler(async ({ input }) => {
+                        const project = this.mockData.projects.get(input.projectId);
+                        if (!project) {
+                            throw new ORPCError("NOT_FOUND", { message: "Project not found" });
+                        }
+                        const environmentIds = new Set(project.environments.map((environment) => environment.id));
+                        let submissions = [...this.mockData.submissions.values()].filter((submission) => environmentIds.has(submission.environmentId));
+                        if (input.environmentId) {
+                            submissions = submissions.filter((submission) => submission.environmentId === input.environmentId);
+                        }
+                        if (input.platform) {
+                            submissions = submissions.filter((submission) => submission.platform === input.platform);
+                        }
+                        return submissions;
+                    }),
+                },
+                get: {
+                    v1: implement(contract.submissions.get.v1).handler(async ({ input }) => {
+                        const submission = this.mockData.submissions.get(input.submissionId);
+                        if (!submission) {
+                            throw new ORPCError("NOT_FOUND", { message: "Submission not found" });
+                        }
+                        return submission;
+                    }),
+                },
+                update: {
+                    v1: implement(contract.submissions.update.v1).handler(async ({ input }) => {
+                        const submission = this.mockData.submissions.get(input.submissionId);
+                        if (!submission) {
+                            throw new ORPCError("NOT_FOUND", { message: "Submission not found" });
+                        }
+                        if (submission.platform !== input.platform) {
+                            throw new ORPCError("BAD_REQUEST", {
+                                message: `Platform mismatch: submission ${submission.id} is ${submission.platform}, payload claims ${input.platform}`,
+                            });
+                        }
+                        const updated = { ...submission, formData: input.formData, updatedAt: new Date() };
+                        this.mockData.submissions.set(submission.id, updated);
+                        return updated;
+                    }),
+                },
+            },
             deployments: {
                 list: {
                     v1: implement(contract.deployments.list.v1).handler(async ({ input }) => {
@@ -748,22 +1056,7 @@ export class MockApiServer {
     }
     reset() {
         this.callHistory = [];
-        this.mockData = {
-            tunnelTicket: null,
-            teams: null,
-            projects: new Map(),
-            environments: new Map(),
-            deployments: new Map(),
-            environmentVariables: new Map(),
-            runtimeLogs: new Map(),
-            runtimeLogPages: new Map(),
-            deploymentLogPages: new Map(),
-            deploymentLogCallCounts: new Map(),
-            publishedServers: new Map(),
-            beaconGetResponses: [],
-            beaconGetCallCount: 0,
-            playgrounds: new Map(),
-        };
+        this.mockData = createEmptyMockData();
     }
     async stop() {
         return new Promise((resolve, reject) => {
@@ -834,6 +1127,9 @@ export class MockApiServer {
             hasStripeAccount: false,
         }));
     }
+    setTeamUsage(usage) {
+        this.mockData.teamUsages.set(usage.teamId, usage);
+    }
     addEnvironmentVariables(environmentId, variables) {
         this.mockData.environmentVariables.set(environmentId, variables);
     }
@@ -867,6 +1163,53 @@ export class MockApiServer {
     setPlayground(environmentId, playground) {
         this.mockData.playgrounds.set(environmentId, playground);
     }
+    setIntents(environmentId, intents) {
+        this.mockData.intents.set(environmentId, intents);
+    }
+    setIntentCategories(environmentId, categories) {
+        this.mockData.intentCategories.set(environmentId, categories.map((category) => ({ ...category, linkedIntentIds: new Set(category.linkedIntentIds ?? []) })));
+    }
+    setTelemetryDestinations(environmentId, destinations) {
+        this.mockData.telemetryDestinations.set(environmentId, destinations);
+    }
+    requireMockEnvironmentCategories(environmentId) {
+        if (!this.mockData.environments.has(environmentId)) {
+            throw new ORPCError("NOT_FOUND", { message: "Environment not found" });
+        }
+        const categories = this.mockData.intentCategories.get(environmentId) ?? [];
+        this.mockData.intentCategories.set(environmentId, categories);
+        return categories;
+    }
+    requireMockIntentCategory(environmentId, categoryId) {
+        const category = this.requireMockEnvironmentCategories(environmentId).find(({ id }) => id === categoryId);
+        if (!category) {
+            throw new ORPCError("NOT_FOUND", { message: "Intent category not found" });
+        }
+        return category;
+    }
+    requireMockIntents(environmentId, intentIds, errorCode) {
+        const knownIntentIds = new Set((this.mockData.intents.get(environmentId) ?? []).flatMap((intent) => intent.intentIds));
+        if (intentIds.some((intentId) => !knownIntentIds.has(intentId))) {
+            throw new ORPCError(errorCode, { message: "One or more intents not found" });
+        }
+    }
+    removeCategoryFromIntents(environmentId, categoryId, remainingIntentIds) {
+        for (const intent of this.mockData.intents.get(environmentId) ?? []) {
+            const stillLinked = remainingIntentIds !== null && intent.intentIds.some((intentId) => remainingIntentIds.has(intentId));
+            if (!stillLinked) {
+                intent.categories = intent.categories.filter(({ id }) => id !== categoryId);
+            }
+        }
+    }
+    setFeedbacks(environmentId, feedbacks) {
+        this.mockData.feedbacks.set(environmentId, feedbacks);
+    }
+    addSubmission(submission) {
+        this.mockData.submissions.set(submission.id, submission);
+    }
+    setSubmissionPrefill(platform, formData) {
+        this.mockData.submissionPrefills.set(platform, formData);
+    }
     addProject(project) {
         this.mockData.projects.set(project.id, project);
         if (project.productionEnvironment) {