feature: api run prompt endpoint

apps/gateway/.eslintrc.json

@@ -2,5 +2,8 @@
   "extends": ["./node_modules/@latitude-data/eslint-config/library.js"],
   "env": {
     "node": true
+  },
+  "rules": {
+    "no-constant-condition": "off"
   }
 }

apps/gateway/package.json

@@ -3,7 +3,7 @@
   "type": "module",
   "scripts": {
     "build": "tsc --build tsconfig.prod.json --verbose",
-    "dev": "tsx watch src",
+    "dev": "tsx watch src/server",
     "lint": "eslint src/",
     "prettier": "prettier --write \"**/*.{ts,tsx,md}\"",
     "start": "node -r module-alias/register ./dist --env=production",
@@ -13,9 +13,12 @@
   },
   "dependencies": {
     "@hono/node-server": "^1.12.0",
+    "@hono/zod-validator": "^0.2.2",
     "@latitude-data/core": "workspace:^",
     "@latitude-data/env": "workspace:^",
-    "hono": "^4.5.3"
+    "@t3-oss/env-core": "^0.10.1",
+    "hono": "^4.5.3",
+    "zod": "^3.23.8"
   },
   "devDependencies": {
     "@latitude-data/eslint-config": "workspace:^",

apps/gateway/src/common/env.ts

@@ -0,0 +1,26 @@
+import '@latitude-data/env'
+
+import { createEnv } from '@t3-oss/env-core'
+import { z } from 'zod'
+
+let env
+if (process.env.NODE_ENV === 'development') {
+  env = await import('./env/development').then((r) => r.default)
+} else if (process.env.NODE_ENV === 'test') {
+  env = await import('./env/test').then((r) => r.default)
+} else {
+  env = process.env as {
+    GATEWAY_PORT: string
+    GATEWAY_HOST: string
+  }
+}
+
+export default createEnv({
+  skipValidation:
+    process.env.BUILDING_CONTAINER == 'true' || process.env.NODE_ENV === 'test',
+  server: {
+    GATEWAY_PORT: z.string().optional().default('8787'),
+    GATEWAY_HOST: z.string().optional().default('localhost'),
+  },
+  runtimeEnv: env,
+})

apps/gateway/src/common/env/development.ts

@@ -0,0 +1,4 @@
+export default {
+  GATEWAY_PORT: '8787',
+  GATEWAY_HOST: 'localhost',
+}

apps/gateway/src/common/env/test.ts

@@ -0,0 +1,6 @@
+import devEnv from './development'
+
+export default {
+  ...devEnv,
+  GATEWAY_PORT: '8788',
+}

apps/gateway/src/common/routes.ts

@@ -7,6 +7,7 @@ const ROUTES = {
       Documents: {
         Base: '/projects/:projectId/commits/:commitUuid/documents',
         Get: '/:documentPath{.+}',
+        Run: '/run',
       },
     },
   },

apps/gateway/src/index.ts

@@ -1,6 +1,3 @@
-import '@latitude-data/env'
-
-import { serve } from '@hono/node-server'
 import { Hono } from 'hono'
 import { logger } from 'hono/logger'
 import jetPaths from 'jet-paths'
@@ -24,16 +21,4 @@ app.route(jetPaths(ROUTES).Api.V1.Documents.Base, documentsRouter)
 // Must be the last one!
 app.use(errorHandlerMiddleware())
 
-serve(
-  {
-    fetch: app.fetch,
-    overrideGlobalObjects: undefined,
-    port: parseInt(process.env.GATEWAY_PORT || '4000', 10),
-    hostname: process.env.GATEWAY_HOSTNAME || 'localhost',
-  },
-  (info) => {
-    console.log(`Listening on http://localhost:${info.port}`)
-  },
-)
-
 export default app

apps/gateway/src/middlewares/auth.ts

@@ -3,7 +3,6 @@ import {
   unsafelyGetApiKeyByToken,
 } from '@latitude-data/core'
 import type { Workspace } from '@latitude-data/core/browser'
-import { Context } from 'hono'
 import { bearerAuth } from 'hono/bearer-auth'
 
 declare module 'hono' {
@@ -14,7 +13,7 @@ declare module 'hono' {
 
 const authMiddleware = () =>
   bearerAuth({
-    verifyToken: async (token: string, c: Context) => {
+    verifyToken: async (token: string, c) => {
       const apiKeyResult = await unsafelyGetApiKeyByToken({ token })
       if (apiKeyResult.error) return false
 

apps/gateway/src/routes/api/v1/projects/:projectId/commits/:commitUuid/documents/handlers/_shared.ts

@@ -0,0 +1,45 @@
+import {
+  CommitsRepository,
+  DocumentVersionsRepository,
+  ProjectsRepository,
+} from '@latitude-data/core'
+import type { Workspace } from '@latitude-data/core/browser'
+
+const toDocumentPath = (path: string) => {
+  if (path.startsWith('/')) {
+    return path
+  }
+
+  return `/${path}`
+}
+
+export const getData = async ({
+  workspace,
+  projectId,
+  commitUuid,
+  documentPath,
+}: {
+  workspace: Workspace
+  projectId: number
+  commitUuid: string
+  documentPath: string
+}) => {
+  const projectsScope = new ProjectsRepository(workspace.id)
+  const commitsScope = new CommitsRepository(workspace.id)
+  const docsScope = new DocumentVersionsRepository(workspace.id)
+
+  const project = await projectsScope
+    .getProjectById(projectId)
+    .then((r) => r.unwrap())
+  const commit = await commitsScope
+    .getCommitByUuid({ project, uuid: commitUuid })
+    .then((r) => r.unwrap())
+  const document = await docsScope
+    .getDocumentByPath({
+      commit,
+      path: toDocumentPath(documentPath),
+    })
+    .then((r) => r.unwrap())
+
+  return { project, commit, document }
+}

apps/gateway/src/routes/api/v1/projects/:projectId/commits/:commitUuid/documents/handlers/get.ts

@@ -0,0 +1,19 @@
+import { createFactory } from 'hono/factory'
+
+import { getData } from './_shared'
+
+const factory = createFactory()
+
+export const getHandler = factory.createHandlers(async (c) => {
+  const workspace = c.get('workspace')
+  const { projectId, commitUuid, documentPath } = c.req.param()
+
+  const { document } = await getData({
+    workspace,
+    projectId: Number(projectId!),
+    commitUuid: commitUuid!,
+    documentPath: documentPath!,
+  })
+
+  return c.json(document)
+})

apps/gateway/src/routes/api/v1/projects/:projectId/commits/:commitUuid/documents/handlers/run.test.ts

@@ -0,0 +1,144 @@
+import {
+  apiKeys,
+  ChainEventTypes,
+  database,
+  factories,
+  LATITUDE_EVENT,
+  mergeCommit,
+  Result,
+} from '@latitude-data/core'
+import app from '$/index'
+import { eq } from 'drizzle-orm'
+import { describe, expect, it, vi } from 'vitest'
+
+const mocks = vi.hoisted(() => ({
+  streamText: vi.fn(),
+}))
+
+vi.mock('@latitude-data/core', async (importOriginal) => {
+  const original = (await importOriginal()) as typeof importOriginal
+
+  return {
+    ...original,
+    streamText: mocks.streamText,
+  }
+})
+
+describe('POST /run', () => {
+  describe('unauthorized', () => {
+    it('fails', async () => {
+      const res = await app.request(
+        '/api/v1/projects/1/commits/asldkfjhsadl/documents/run',
+        {
+          method: 'POST',
+          body: JSON.stringify({
+            documentPath: '/path/to/document',
+          }),
+        },
+      )
+
+      expect(res.status).toBe(401)
+    })
+  })
+
+  describe('authorized', () => {
+    it('succeeds', async () => {
+      const stream = new ReadableStream({
+        start(controller) {
+          controller.enqueue({
+            event: LATITUDE_EVENT,
+            data: {
+              type: ChainEventTypes.Complete,
+              response: {
+                text: 'Hello',
+                usage: {},
+              },
+            },
+          })
+
+          controller.close()
+        },
+      })
+
+      const response = new Promise((resolve) => {
+        resolve({ text: 'Hello', usage: {} })
+      })
+
+      mocks.streamText.mockReturnValue(
+        new Promise((resolve) => {
+          resolve(
+            Result.ok({
+              stream,
+              response,
+            }),
+          )
+        }),
+      )
+
+      const { workspace, user, project } = await factories.createProject()
+      const apikey = await database.query.apiKeys.findFirst({
+        where: eq(apiKeys.workspaceId, workspace.id),
+      })
+      const path = '/path/to/document'
+      const { commit } = await factories.createDraft({
+        project,
+        user,
+      })
+      const document = await factories.createDocumentVersion({
+        commit,
+        path,
+        content: `
+          ---
+            provider: openai
+            model: gpt-4o
+          ---
+
+          Ignore all the rest and just return "Hello".
+        `,
+      })
+
+      await mergeCommit(commit).then((r) => r.unwrap())
+
+      const route = `/api/v1/projects/${project!.id}/commits/${commit!.uuid}/documents/run`
+      const body = JSON.stringify({
+        documentPath: document.documentVersion.path,
+        parameters: {},
+      })
+      const res = await app.request(route, {
+        method: 'POST',
+        body,
+        headers: {
+          Authorization: `Bearer ${apikey!.token}`,
+          'Content-Type': 'application/json',
+        },
+      })
+
+      expect(res.status).toBe(200)
+      expect(res.body).toBeInstanceOf(ReadableStream)
+
+      const responseStream = res.body as ReadableStream
+      const reader = responseStream.getReader()
+
+      let done = false
+      let value
+      while (!done) {
+        const { done: _done, value: _value } = await reader.read()
+        done = _done
+        if (_value) value = new TextDecoder().decode(_value)
+      }
+
+      expect(done).toBe(true)
+      expect(JSON.parse(value!)).toEqual({
+        event: LATITUDE_EVENT,
+        data: {
+          type: ChainEventTypes.Complete,
+          response: {
+            text: 'Hello',
+            usage: {},
+          },
+        },
+        id: '0',
+      })
+    })
+  })
+})

apps/gateway/src/routes/api/v1/projects/:projectId/commits/:commitUuid/documents/handlers/run.ts

@@ -0,0 +1,60 @@
+import { zValidator } from '@hono/zod-validator'
+import { streamText } from '@latitude-data/core'
+import { Factory } from 'hono/factory'
+import { SSEStreamingApi, streamSSE } from 'hono/streaming'
+import { z } from 'zod'
+
+import { getData } from './_shared'
+
+const factory = new Factory()
+
+const runSchema = z.object({
+  documentPath: z.string(),
+  parameters: z.record(z.any()).optional().default({}),
+})
+
+export const runHandler = factory.createHandlers(
+  zValidator('json', runSchema),
+  async (c) => {
+    return streamSSE(c, async (stream) => {
+      const { projectId, commitUuid } = c.req.param()
+      const { documentPath, parameters } = c.req.valid('json')
+
+      const workspace = c.get('workspace')
+
+      const { document } = await getData({
+        workspace,
+        projectId: Number(projectId!),
+        commitUuid: commitUuid!,
+        documentPath: documentPath!,
+      })
+
+      const result = await streamText({
+        document,
+        parameters,
+      }).then((r) => r.unwrap())
+
+      await pipeToStream(stream, result.stream)
+    })
+  },
+)
+
+async function pipeToStream(
+  stream: SSEStreamingApi,
+  readableStream: ReadableStream,
+) {
+  let id = 0
+  const reader = readableStream.getReader()
+
+  while (true) {
+    const { done, value } = await reader.read()
+    if (done) break
+
+    stream.write(
+      JSON.stringify({
+        ...value,
+        id: String(id++),
+      }),
+    )
+  }
+}