chore: migrate Pezzo client logic to REST (#73)

* chore: move pezzo client logic to REST

* fix(ci): deps

* fix: formatting

Author: arielweinberger

apps/server/project.json

@@ -5,12 +5,7 @@
   "projectType": "application",
   "targets": {
     "build": {
-      "dependsOn": [
-        "prisma:generate",
-        "graphql:codegen:offline",
-        "^prebuild",
-        "prebuild"
-      ],
+      "dependsOn": ["prisma:generate", "^prebuild", "prebuild"],
       "executor": "@nrwl/webpack:webpack",
       "outputs": ["{options.outputPath}"],
       "defaultConfiguration": "production",
@@ -102,7 +97,7 @@
       }
     },
     "graphql:codegen:offline": {
-      "dependsOn": ["graphql:schema-generate"],
+      "dependsOn": ["prsima:generate", "graphql:schema-generate"],
       "executor": "nx:run-commands",
       "options": {
         "command": "OFFLINE=true npx graphql-codegen"

apps/server/src/app/auth/api-key-auth.guard.ts

@@ -0,0 +1,54 @@
+import {
+  CanActivate,
+  ExecutionContext,
+  Injectable,
+  Scope,
+  UnauthorizedException,
+} from "@nestjs/common";
+import { ApiKeysService } from "../identity/api-keys.service";
+import { PinoLogger } from "../logger/pino-logger";
+
+export enum AuthMethod {
+  ApiKey = "ApiKey",
+  BearerToken = "BearerToken",
+}
+
+@Injectable({ scope: Scope.REQUEST })
+export class ApiKeyAuthGuard implements CanActivate {
+  constructor(
+    private readonly apiKeysService: ApiKeysService,
+    private readonly logger: PinoLogger
+  ) {}
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const req = context.switchToHttp().getRequest();
+
+    if (!req.headers["x-api-key"]) {
+      throw new UnauthorizedException("Invalid Pezzo API Key");
+    }
+
+    return this.authorizeApiKey(req);
+  }
+
+  private async authorizeApiKey(req) {
+    this.logger.assign({ method: AuthMethod.ApiKey });
+    const keyValue = req.headers["x-api-key"];
+    const apiKey = await this.apiKeysService.getApiKey(keyValue);
+
+    if (!apiKey) {
+      throw new UnauthorizedException("Invalid Pezzo API Key");
+    }
+
+    const environment = apiKey.environment;
+
+    req.projectId = environment.projectId;
+    req.environmentId = environment.id;
+    req.authMethod = AuthMethod.ApiKey;
+    this.logger.assign({
+      environmentId: environment.id,
+      projectId: environment.projectId,
+    });
+
+    return true;
+  }
+}

apps/server/src/app/auth/auth.guard.ts

@@ -10,7 +10,6 @@ import { GqlExecutionContext } from "@nestjs/graphql";
 import ThirdPartyEmailPassword from "supertokens-node/recipe/thirdpartyemailpassword";
 import { UsersService } from "../identity/users.service";
 import { RequestUser } from "../identity/users.types";
-import { ApiKeysService } from "../identity/api-keys.service";
 import Session, { SessionContainer } from "supertokens-node/recipe/session";
 import { ProjectsService } from "../identity/projects.service";
 import { PinoLogger } from "../logger/pino-logger";
@@ -24,46 +23,14 @@ export enum AuthMethod {
 export class AuthGuard implements CanActivate {
   constructor(
     private readonly usersService: UsersService,
-    private readonly apiKeysService: ApiKeysService,
     private readonly projectsService: ProjectsService,
     private readonly logger: PinoLogger
   ) {}
 
   async canActivate(context: ExecutionContext): Promise<boolean> {
-    const gqlCtx = GqlExecutionContext.create(context);
-    const ctx = gqlCtx.getContext();
-    const req = ctx.req;
-    const res = ctx.res;
-
-    if (req.headers["x-api-key"]) {
-      return this.authorizeApiKey(req, res);
-    }
-
     return this.authorizeBearerToken(context);
   }
 
-  private async authorizeApiKey(req, _res) {
-    this.logger.assign({ method: AuthMethod.ApiKey });
-    const keyValue = req.headers["x-api-key"];
-    const apiKey = await this.apiKeysService.getApiKey(keyValue);
-
-    if (!apiKey) {
-      throw new UnauthorizedException("Invalid Pezzo API Key");
-    }
-
-    const environment = apiKey.environment;
-
-    req.projectId = environment.projectId;
-    req.environmentId = environment.id;
-    req.authMethod = AuthMethod.ApiKey;
-    this.logger.assign({
-      environmentId: environment.id,
-      projectId: environment.projectId,
-    });
-
-    return true;
-  }
-
   private async authorizeBearerToken(context: ExecutionContext) {
     const gqlCtx = GqlExecutionContext.create(context);
     const ctx = gqlCtx.getContext();

apps/server/src/app/auth/auth.module.ts

@@ -3,7 +3,6 @@ import {
   Module,
   NestModule,
   DynamicModule,
-  Global,
 } from "@nestjs/common";
 
 import { AuthMiddleware } from "./auth.middleware";

apps/server/src/app/prompts/dto/create-prompt-execution.dto.ts

@@ -0,0 +1,64 @@
+import { PromptExecutionStatus } from "@prisma/client";
+import {
+  IsDateString,
+  IsEnum,
+  IsNumber,
+  IsObject,
+  IsOptional,
+  IsString,
+} from "class-validator";
+
+export class CreatePromptExecutionDto {
+  @IsDateString()
+  timestamp: string;
+
+  @IsString()
+  environmentId: string;
+
+  @IsString()
+  promptVersionSha: string;
+
+  @IsEnum(PromptExecutionStatus)
+  status: PromptExecutionStatus;
+
+  @IsObject()
+  settings: Record<string, unknown>;
+
+  @IsObject()
+  variables: Record<string, unknown>;
+
+  @IsString()
+  content: string;
+
+  @IsString()
+  interpolatedContent: string;
+
+  @IsOptional()
+  @IsString()
+  result?: string;
+
+  @IsOptional()
+  @IsString()
+  error?: string;
+
+  @IsNumber()
+  duration: number;
+
+  @IsNumber()
+  completionCost: number;
+
+  @IsNumber()
+  completionTokens: number;
+
+  @IsNumber()
+  promptCost: number;
+
+  @IsNumber()
+  promptTokens: number;
+
+  @IsNumber()
+  totalTokens: number;
+
+  @IsNumber()
+  totalCost: number;
+}

apps/server/src/app/prompts/prompt-executions.resolver.ts

@@ -99,88 +99,6 @@ export class PromptExecutionsResolver {
     }
   }
 
-  @Mutation(() => PromptExecution)
-  async reportPromptExecutionWithApiKey(
-    @Args("data") data: PromptExecutionCreateInput,
-    @ApiKeyProjectId() projectId: string,
-    @ApiKeyEnvironmentId() environmentId: string
-  ) {
-    console.log("environmentId", environmentId);
-
-    this.logger.assign({ ...data }).info("Reporting prompt execution");
-    const promptId = data.prompt.connect.id;
-    const prompt = await this.promptsService.getPrompt(promptId);
-
-    if (!prompt) {
-      throw new NotFoundException();
-    }
-
-    if (prompt.projectId !== projectId) {
-      throw new ForbiddenException();
-    }
-
-    let execution: PromptExecution;
-
-    try {
-      execution = await this.prisma.promptExecution.create({
-        data: {
-          environmentId,
-          prompt: data.prompt,
-          promptVersionSha: data.promptVersionSha,
-          timestamp: data.timestamp,
-          status: data.status,
-          content: data.content,
-          interpolatedContent: data.interpolatedContent,
-          settings: data.settings,
-          result: data.result,
-          duration: data.duration,
-          promptTokens: data.promptTokens,
-          completionTokens: data.completionTokens,
-          totalTokens: data.totalTokens,
-          promptCost: data.promptCost,
-          completionCost: data.completionCost,
-          totalCost: data.totalCost,
-          error: data.error,
-          variables: data.variables,
-        },
-      });
-    } catch (error) {
-      this.logger.error({ error }, "Error reporting prompt execution");
-      throw new InternalServerErrorException();
-    }
-
-    this.analytics.track("PROMPT_EXECUTION:REPORTED", "api", {
-      projectId,
-      promptId,
-      executionId: execution.id,
-      integrationId: prompt.integrationId,
-      data: {
-        status: execution.status,
-        duration: execution.duration / 1000,
-      },
-    });
-
-    const writeClient = this.influxService.getWriteApi("primary", "primary");
-    const point = new Point("prompt_execution")
-      .tag("prompt_id", execution.promptId)
-      .tag("prompt_version_sha", execution.promptVersionSha)
-      .tag("project_id", prompt.projectId)
-      .tag("prompt_name", prompt.name)
-      .tag("prompt_integration_id", prompt.integrationId)
-      .stringField("status", execution.status)
-      .floatField("duration", execution.duration / 1000)
-      .floatField("prompt_cost", execution.promptCost)
-      .floatField("completion_cost", execution.completionCost)
-      .floatField("total_cost", execution.totalCost)
-      .intField("prompt_tokens", execution.promptTokens)
-      .intField("completion_tokens", execution.completionTokens)
-      .intField("total_tokens", execution.totalTokens);
-
-    writeClient.writePoint(point);
-    writeClient.flush();
-    return execution;
-  }
-
   @UseGuards(AuthGuard)
   @Mutation(() => PromptExecution)
   async testPrompt(