alpic 0.0.0-dev.fc2d21b → 0.0.0-dev.fc7e119

package/dist/__tests__/mock-server.d.ts

@@ -0,0 +1,35 @@
+import { type RouterOutput } from "@alpic-ai/api";
+export type MockRuntimeLog = RouterOutput["environments"]["getLogs"]["v1"]["logs"][number];
+export type MockDeploymentLogPage = {
+    logs: {
+        timestamp?: Date;
+        content?: string;
+    }[];
+    hasMoreLogs: boolean;
+};
+export type ApiCall = {
+    method: string;
+    path: string;
+    timestamp: Date;
+    input?: unknown;
+    responseStatus?: number;
+};
+export declare class MockApiServer {
+    private server;
+    private app;
+    private port;
+    private mockData;
+    private callHistory;
+    constructor();
+    start(): Promise<string>;
+    private configureServer;
+    stop(): Promise<void>;
+    getCalls(method?: string, pathPattern?: string | RegExp): ApiCall[];
+    getLastCall(method?: string, pathPattern?: string | RegExp): ApiCall | undefined;
+    addEnvironmentVariables(environmentId: string, variables: RouterOutput["environmentVariables"]["list"]["v1"]): void;
+    setRuntimeLogs(environmentId: string, logs: MockRuntimeLog[]): void;
+    setRuntimeLogPages(environmentId: string, pages: MockRuntimeLog[][]): void;
+    addDeployments(deployments: RouterOutput["deployments"]["list"]["v1"]): void;
+    setDeploymentLogPages(deploymentId: string, pages: MockDeploymentLogPage[]): void;
+    addProject(project: RouterOutput["projects"]["get"]["v1"]): void;
+}

package/dist/__tests__/mock-server.js

@@ -0,0 +1,646 @@
+import * as https from "node:https";
+import { OpenAPIHandler } from "@orpc/openapi/node";
+import { ORPCError, implement } from "@orpc/server";
+import express, {} from "express";
+import { randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { contract } from "@alpic-ai/api";
+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");
+function getTlsAssets() {
+    return {
+        key: readFileSync(FIXTURE_KEY_PATH, "utf8"),
+        cert: readFileSync(FIXTURE_CERT_PATH, "utf8"),
+        certPath: FIXTURE_CERT_PATH,
+    };
+}
+export class MockApiServer {
+    server = null;
+    app;
+    port = null;
+    mockData;
+    callHistory = [];
+    constructor() {
+        this.app = express();
+        this.mockData = {
+            projects: new Map(),
+            environments: new Map(),
+            deployments: new Map(),
+            environmentVariables: new Map(),
+            runtimeLogs: new Map(),
+            runtimeLogPages: new Map(),
+            deploymentLogPages: new Map(),
+            deploymentLogCallCounts: new Map(),
+        };
+    }
+    async start() {
+        if (this.server) {
+            throw new Error("Server is already running");
+        }
+        this.configureServer();
+        const tlsAssets = getTlsAssets();
+        process.env.NODE_EXTRA_CA_CERTS = tlsAssets.certPath;
+        const httpsOptions = { key: tlsAssets.key, cert: tlsAssets.cert };
+        return new Promise((resolve) => {
+            this.server = https.createServer(httpsOptions, this.app).listen(0, "127.0.0.1", () => {
+                if (!this.server) {
+                    throw new Error("Server is not running");
+                }
+                const address = this.server.address();
+                this.port = address.port;
+                const url = `https://127.0.0.1:${this.port}`;
+                resolve(url);
+            });
+        });
+    }
+    configureServer() {
+        this.app.put("/__mock__upload/:token", express.raw({ type: "*/*", limit: "50mb" }), async (req, res) => {
+            const apiCall = {
+                method: req.method,
+                path: req.path,
+                timestamp: new Date(),
+                input: { token: req.params.token, size: req.body.length },
+                responseStatus: 200,
+            };
+            this.callHistory.push(apiCall);
+            res.status(200).end();
+        });
+        this.app.use(express.json());
+        this.app.get("/.well-known/oauth-protected-resource", (_req, res) => {
+            const base = `https://127.0.0.1:${this.port}`;
+            res.status(200).json({
+                resource: "https://api.alpic.ai",
+                authorization_servers: [base],
+                bearer_methods_supported: ["header"],
+                scopes_supported: ["openid", "email", "profile"],
+                resource_documentation: "https://docs.alpic.ai",
+            });
+        });
+        this.app.get("/.well-known/openid-configuration", (_req, res) => {
+            const base = `https://127.0.0.1:${this.port}`;
+            res.status(200).json({
+                issuer: base,
+                userinfo_endpoint: `${base}/oauth2/userInfo`,
+                authorization_endpoint: `${base}/oauth2/authorize`,
+                token_endpoint: `${base}/oauth2/token`,
+                jwks_uri: `${base}/.well-known/jwks.json`,
+            });
+        });
+        this.app.get("/oauth2/userInfo", (req, res) => {
+            const auth = req.headers.authorization;
+            if (!auth?.startsWith("Bearer ")) {
+                res.status(401).json({ error: "Missing or invalid Authorization" });
+                return;
+            }
+            res.status(200).json({
+                sub: "test-sub",
+                email_verified: "true",
+                identities: [],
+                name: "Test User",
+                email: "test@example.com",
+                picture: "",
+                username: "testuser",
+            });
+        });
+        const router = implement(contract).router({
+            tunnels: {
+                getTicket: {
+                    v1: implement(contract.tunnels.getTicket.v1).handler(async () => {
+                        return {
+                            subdomain: "cool-mongoose-123",
+                            ticket: "mock-ticket",
+                            tunnelHost: "tunnel.alpic.dev",
+                        };
+                    }),
+                },
+            },
+            teams: {
+                list: {
+                    v1: implement(contract.teams.list.v1).handler(async () => {
+                        return [
+                            {
+                                id: "mock-team-id",
+                                name: "Mock Team",
+                                createdAt: new Date(),
+                                hasStripeAccount: false,
+                            },
+                        ];
+                    }),
+                },
+            },
+            analytics: {
+                get: {
+                    v1: implement(contract.analytics.get.v1).handler(async ({ input }) => {
+                        const project = this.mockData.projects.get(input.projectId);
+                        if (!project) {
+                            throw new ORPCError("NOT_FOUND", { message: "Project not found" });
+                        }
+                        const emptyTimeSeries = {
+                            sessions_count: [],
+                            requests_count: [],
+                            requests_latency_mean: [],
+                            tool_errors: [],
+                            mcp_errors: [],
+                            output_token_mean: [],
+                            task_count: [],
+                        };
+                        return {
+                            metadata: {
+                                startTimestamp: input.startTimestamp,
+                                endTimestamp: input.endTimestamp,
+                                timeZone: input.timeZone,
+                                startDate: new Date(input.startTimestamp),
+                                interval: "1h",
+                            },
+                            timeSeries: emptyTimeSeries,
+                        };
+                    }),
+                },
+            },
+            projects: {
+                list: {
+                    v1: implement(contract.projects.list.v1).handler(async () => {
+                        return Array.from(this.mockData.projects.values()).map((project) => ({
+                            id: project.id,
+                            name: project.name,
+                            teamId: project.teamId,
+                            environments: project.environments,
+                            productionEnvironment: project.productionEnvironment,
+                            sourceRepository: project.sourceRepository,
+                            runtime: project.runtime,
+                            transport: project.transport,
+                            rootDirectory: project.rootDirectory,
+                            buildCommand: project.buildCommand,
+                            buildOutputDir: project.buildOutputDir,
+                            installCommand: project.installCommand,
+                            startCommand: project.startCommand,
+                            createdAt: project.createdAt,
+                        }));
+                    }),
+                },
+                get: {
+                    v1: implement(contract.projects.get.v1).handler(async ({ input }) => {
+                        const project = this.mockData.projects.get(input.projectId);
+                        if (!project) {
+                            throw new ORPCError("NOT_FOUND", { message: "Project not found" });
+                        }
+                        return project;
+                    }),
+                },
+                create: {
+                    v1: implement(contract.projects.create.v1).handler(async ({ input }) => {
+                        const projectId = randomUUID();
+                        const teamId = "mock-team-id";
+                        const productionEnvId = randomUUID();
+                        const productionEnvName = "production";
+                        const project = {
+                            id: projectId,
+                            name: input.name,
+                            teamId,
+                            environments: [],
+                            productionEnvironment: {
+                                id: productionEnvId,
+                                name: productionEnvName,
+                            },
+                            sourceRepository: input.sourceRepository ?? null,
+                            runtime: input.runtime,
+                            transport: input.transport ?? null,
+                            rootDirectory: input.rootDirectory ?? null,
+                            buildCommand: input.settings?.buildCommand ?? null,
+                            buildOutputDir: input.settings?.buildOutputDir ?? null,
+                            installCommand: input.settings?.installCommand ?? null,
+                            startCommand: input.settings?.startCommand ?? null,
+                            createdAt: new Date(),
+                        };
+                        const environment = {
+                            id: productionEnvId,
+                            name: productionEnvName,
+                            sourceBranch: null,
+                            mcpServerUrl: `https://mcp-${projectId}.alpic.ai`,
+                            domains: [`https://mcp-${projectId}.alpic.ai`],
+                            createdAt: new Date(),
+                            projectId,
+                        };
+                        this.mockData.environments.set(productionEnvId, environment);
+                        const fullProject = {
+                            ...project,
+                            productionEnvironment: {
+                                id: productionEnvId,
+                                name: productionEnvName,
+                                mcpServerUrl: `https://mcp-${projectId}.alpic.ai`,
+                                domains: [],
+                                latestDeployment: null,
+                            },
+                            environments: [
+                                {
+                                    id: productionEnvId,
+                                    name: productionEnvName,
+                                    sourceBranch: null,
+                                    mcpServerUrl: `https://mcp-${projectId}.alpic.ai`,
+                                    createdAt: new Date(),
+                                    projectId,
+                                    latestDeployment: null,
+                                },
+                            ],
+                        };
+                        this.mockData.projects.set(projectId, fullProject);
+                        return project;
+                    }),
+                },
+                update: {
+                    v1: implement(contract.projects.update.v1).handler(async ({ input }) => {
+                        const project = this.mockData.projects.get(input.projectId);
+                        if (!project) {
+                            throw new ORPCError("NOT_FOUND", { message: "Project not found" });
+                        }
+                        if (input.sourceRepository !== undefined) {
+                            project.sourceRepository = input.sourceRepository;
+                        }
+                        this.mockData.projects.set(input.projectId, project);
+                        return project;
+                    }),
+                },
+                delete: {
+                    v1: implement(contract.projects.delete.v1).handler(async ({ input }) => {
+                        const project = this.mockData.projects.get(input.projectId);
+                        if (!project) {
+                            throw new ORPCError("NOT_FOUND", { message: "Project not found" });
+                        }
+                        this.mockData.projects.delete(input.projectId);
+                        return { success: true };
+                    }),
+                },
+            },
+            environments: {
+                create: {
+                    v1: implement(contract.environments.create.v1).handler(async ({ input }) => {
+                        const project = this.mockData.projects.get(input.projectId);
+                        if (!project) {
+                            throw new ORPCError("NOT_FOUND", { message: "Project not found" });
+                        }
+                        const environmentId = randomUUID();
+                        const mcpServerUrl = `https://mcp-${environmentId}.alpic.ai`;
+                        const createdAt = new Date();
+                        const environment = {
+                            id: environmentId,
+                            name: input.name,
+                            sourceBranch: input.sourceBranch,
+                            mcpServerUrl,
+                            domains: [mcpServerUrl],
+                            createdAt,
+                            projectId: input.projectId,
+                        };
+                        this.mockData.environments.set(environmentId, environment);
+                        this.mockData.projects.set(input.projectId, {
+                            ...project,
+                            environments: [
+                                ...project.environments,
+                                {
+                                    id: environmentId,
+                                    name: input.name,
+                                    sourceBranch: input.sourceBranch,
+                                    mcpServerUrl,
+                                    createdAt,
+                                    projectId: input.projectId,
+                                    latestDeployment: null,
+                                },
+                            ],
+                        });
+                        return {
+                            id: environmentId,
+                            name: input.name,
+                            sourceBranch: input.sourceBranch,
+                            createdAt,
+                            projectId: input.projectId,
+                            urls: [mcpServerUrl],
+                        };
+                    }),
+                },
+                get: {
+                    v1: implement(contract.environments.get.v1).handler(async ({ input }) => {
+                        const environment = this.mockData.environments.get(input.environmentId);
+                        if (!environment) {
+                            throw new ORPCError("NOT_FOUND", { message: "Environment not found" });
+                        }
+                        return environment;
+                    }),
+                },
+                getLogs: {
+                    v1: implement(contract.environments.getLogs.v1).handler(async ({ input }) => {
+                        const environment = this.mockData.environments.get(input.environmentId);
+                        if (!environment) {
+                            throw new ORPCError("NOT_FOUND", { message: "Environment not found" });
+                        }
+                        const pagedLogs = this.mockData.runtimeLogPages.get(input.environmentId);
+                        const pageIndex = input.nextToken === undefined ? 0 : Number.parseInt(input.nextToken, 10);
+                        const allLogs = pagedLogs === undefined
+                            ? (this.mockData.runtimeLogs.get(input.environmentId) ?? [])
+                            : (pagedLogs[pageIndex] ?? []);
+                        const logs = input.level === undefined
+                            ? allLogs
+                            : allLogs.filter((log) => input.level.includes(log.type));
+                        const nextToken = pagedLogs === undefined || pageIndex + 1 >= pagedLogs.length ? null : String(pageIndex + 1);
+                        return { logs, nextToken };
+                    }),
+                },
+                deploy: {
+                    v1: implement(contract.environments.deploy.v1).handler(async ({ input }) => {
+                        const environment = this.mockData.environments.get(input.environmentId);
+                        if (!environment) {
+                            throw new ORPCError("NOT_FOUND", { message: "Environment not found" });
+                        }
+                        const deploymentId = randomUUID();
+                        const deployment = {
+                            id: deploymentId,
+                            status: "ongoing",
+                            environmentId: environment.id,
+                            environmentName: environment.name,
+                            isCurrent: false,
+                            sourceRef: environment.sourceBranch,
+                            sourceCommitId: randomUUID().slice(0, 7),
+                            sourceCommitMessage: "Mock deployment",
+                            authorUsername: "test-user",
+                            authorAvatarUrl: null,
+                            startedAt: new Date(),
+                            completedAt: null,
+                            deploymentPageUrl: "https://app.alpic.ai/deployments/mock",
+                        };
+                        this.mockData.deployments.set(deploymentId, deployment);
+                        return deployment;
+                    }),
+                },
+            },
+            environmentVariables: {
+                list: {
+                    v1: implement(contract.environmentVariables.list.v1).handler(async ({ input }) => {
+                        const environment = this.mockData.environments.get(input.environmentId);
+                        if (!environment) {
+                            throw new ORPCError("NOT_FOUND", { message: "Environment not found" });
+                        }
+                        return this.mockData.environmentVariables.get(input.environmentId) ?? [];
+                    }),
+                },
+                create: {
+                    v1: implement(contract.environmentVariables.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 existing = this.mockData.environmentVariables.get(input.environmentId) ?? [];
+                        const newVars = input.environmentVariables.map((variable) => ({
+                            id: randomUUID(),
+                            key: variable.key,
+                            value: variable.value,
+                            isSecret: variable.isSecret,
+                            createdAt: new Date(),
+                        }));
+                        for (const newVar of newVars) {
+                            if (existing.some((existingVar) => existingVar.key === newVar.key)) {
+                                throw new ORPCError("BAD_REQUEST", {
+                                    message: `Environment variable "${newVar.key}" already exists`,
+                                });
+                            }
+                        }
+                        this.mockData.environmentVariables.set(input.environmentId, [...existing, ...newVars]);
+                        return { success: true };
+                    }),
+                },
+                update: {
+                    v1: implement(contract.environmentVariables.update.v1).handler(async ({ input }) => {
+                        for (const [environmentId, variables] of this.mockData.environmentVariables.entries()) {
+                            const index = variables.findIndex((variable) => variable.id === input.environmentVariableId);
+                            if (index !== -1) {
+                                const updated = variables.map((variable, i) => i === index
+                                    ? { ...variable, key: input.key, value: input.value ?? variable.value, isSecret: input.isSecret }
+                                    : variable);
+                                this.mockData.environmentVariables.set(environmentId, updated);
+                                return { success: true };
+                            }
+                        }
+                        throw new ORPCError("NOT_FOUND", { message: "Environment variable not found" });
+                    }),
+                },
+                delete: {
+                    v1: implement(contract.environmentVariables.delete.v1).handler(async ({ input }) => {
+                        for (const [environmentId, variables] of this.mockData.environmentVariables.entries()) {
+                            const index = variables.findIndex((variable) => variable.id === input.environmentVariableId);
+                            if (index !== -1) {
+                                this.mockData.environmentVariables.set(environmentId, variables.filter((_, i) => i !== index));
+                                return { success: true };
+                            }
+                        }
+                        throw new ORPCError("NOT_FOUND", { message: "Environment variable not found" });
+                    }),
+                },
+            },
+            deployments: {
+                list: {
+                    v1: implement(contract.deployments.list.v1).handler(async ({ input }) => {
+                        const project = this.mockData.projects.get(input.projectId);
+                        if (!project) {
+                            throw new ORPCError("NOT_FOUND", { message: "Project not found" });
+                        }
+                        let deployments = Array.from(this.mockData.deployments.values());
+                        if (input.environmentId) {
+                            deployments = deployments.filter((deployment) => deployment.environmentId === input.environmentId);
+                        }
+                        if (input.status?.length) {
+                            deployments = deployments.filter((deployment) => input.status.includes(deployment.status));
+                        }
+                        return deployments.map((deployment) => ({
+                            ...deployment,
+                            isCurrent: deployment.status === "deployed",
+                        }));
+                    }),
+                },
+                get: {
+                    v1: implement(contract.deployments.get.v1).handler(async ({ input }) => {
+                        const deployment = this.mockData.deployments.get(input.deploymentId);
+                        if (!deployment) {
+                            throw new ORPCError("NOT_FOUND", { message: "Deployment not found" });
+                        }
+                        if (deployment.status === "ongoing") {
+                            const updatedDeployment = {
+                                ...deployment,
+                                status: "deployed",
+                                completedAt: new Date(),
+                                deploymentPageUrl: deployment.deploymentPageUrl ?? null,
+                            };
+                            this.mockData.deployments.set(input.deploymentId, updatedDeployment);
+                            return updatedDeployment;
+                        }
+                        return deployment;
+                    }),
+                },
+                getLogs: {
+                    v1: implement(contract.deployments.getLogs.v1).handler(async ({ input }) => {
+                        const deployment = this.mockData.deployments.get(input.deploymentId);
+                        if (!deployment) {
+                            throw new ORPCError("NOT_FOUND", { message: "Deployment not found" });
+                        }
+                        const pages = this.mockData.deploymentLogPages.get(input.deploymentId);
+                        if (pages !== undefined) {
+                            const callCount = this.mockData.deploymentLogCallCounts.get(input.deploymentId) ?? 0;
+                            const pageIndex = Math.min(callCount, pages.length - 1);
+                            this.mockData.deploymentLogCallCounts.set(input.deploymentId, callCount + 1);
+                            return pages[pageIndex] ?? { logs: [], hasMoreLogs: false };
+                        }
+                        return {
+                            logs: [{ timestamp: new Date(), content: "Mock log entry" }],
+                            hasMoreLogs: false,
+                        };
+                    }),
+                },
+                uploadArtifact: {
+                    v1: implement(contract.deployments.uploadArtifact.v1).handler(async () => {
+                        const token = randomUUID();
+                        const baseUrl = `https://127.0.0.1:${this.port}`;
+                        const uploadUrl = `${baseUrl}/__mock__upload/${token}`;
+                        return {
+                            uploadUrl,
+                            token,
+                            expiresAt: new Date(Date.now() + 3600000),
+                        };
+                    }),
+                },
+            },
+        });
+        const handler = new OpenAPIHandler(router);
+        this.app.use(async (req, res) => {
+            const apiCall = {
+                method: req.method,
+                path: req.path,
+                timestamp: new Date(),
+            };
+            if (req.method === "GET") {
+                if (Object.keys(req.query).length > 0) {
+                    apiCall.input = req.query;
+                }
+            }
+            else if (req.body) {
+                apiCall.input = req.body;
+            }
+            const result = await handler.handle(req, res, {
+                context: {},
+            });
+            if (!result.matched) {
+                apiCall.responseStatus = 404;
+                this.callHistory.push(apiCall);
+                res.status(404).json({ error: "Not found" });
+                return;
+            }
+            apiCall.responseStatus = res.statusCode || 200;
+            this.callHistory.push(apiCall);
+        });
+    }
+    async stop() {
+        return new Promise((resolve, reject) => {
+            if (!this.server) {
+                resolve();
+                return;
+            }
+            this.server.close((error) => {
+                if (error) {
+                    console.error("[MOCK] Error stopping server:", error);
+                    reject(error);
+                }
+                else {
+                    this.server = null;
+                    resolve();
+                }
+            });
+        });
+    }
+    getCalls(method, pathPattern) {
+        return this.callHistory.filter((call) => {
+            if (method && call.method !== method)
+                return false;
+            if (pathPattern) {
+                if (typeof pathPattern === "string") {
+                    if (!call.path.includes(pathPattern))
+                        return false;
+                }
+                else {
+                    if (!pathPattern.test(call.path))
+                        return false;
+                }
+            }
+            return true;
+        });
+    }
+    getLastCall(method, pathPattern) {
+        for (let i = this.callHistory.length - 1; i >= 0; i--) {
+            const call = this.callHistory[i];
+            if (!call)
+                continue;
+            if (method && call.method !== method)
+                continue;
+            if (pathPattern) {
+                if (typeof pathPattern === "string") {
+                    if (!call.path.includes(pathPattern))
+                        continue;
+                }
+                else {
+                    if (!pathPattern.test(call.path))
+                        continue;
+                }
+            }
+            return call;
+        }
+        return undefined;
+    }
+    addEnvironmentVariables(environmentId, variables) {
+        this.mockData.environmentVariables.set(environmentId, variables);
+    }
+    setRuntimeLogs(environmentId, logs) {
+        this.mockData.runtimeLogs.set(environmentId, logs);
+        this.mockData.runtimeLogPages.delete(environmentId);
+    }
+    setRuntimeLogPages(environmentId, pages) {
+        this.mockData.runtimeLogPages.set(environmentId, pages);
+        this.mockData.runtimeLogs.delete(environmentId);
+    }
+    addDeployments(deployments) {
+        for (const deployment of deployments) {
+            this.mockData.deployments.set(deployment.id, {
+                ...deployment,
+                deploymentPageUrl: null,
+            });
+        }
+    }
+    setDeploymentLogPages(deploymentId, pages) {
+        this.mockData.deploymentLogPages.set(deploymentId, pages);
+        this.mockData.deploymentLogCallCounts.set(deploymentId, 0);
+    }
+    addProject(project) {
+        this.mockData.projects.set(project.id, project);
+        if (project.productionEnvironment) {
+            const env = {
+                id: project.productionEnvironment.id,
+                name: project.productionEnvironment.name,
+                sourceBranch: null,
+                mcpServerUrl: project.productionEnvironment.mcpServerUrl,
+                domains: [project.productionEnvironment.mcpServerUrl],
+                createdAt: new Date(),
+                projectId: project.id,
+            };
+            this.mockData.environments.set(env.id, env);
+        }
+        for (const env of project.environments) {
+            const fullEnv = {
+                id: env.id,
+                name: env.name,
+                sourceBranch: env.sourceBranch,
+                mcpServerUrl: env.mcpServerUrl,
+                domains: [env.mcpServerUrl],
+                createdAt: env.createdAt,
+                projectId: project.id,
+            };
+            this.mockData.environments.set(env.id, fullEnv);
+        }
+    }
+}
+//# sourceMappingURL=mock-server.js.map