@tscircuit/fake-snippets 0.0.1

package/fake-snippets-api/lib/middleware/with-ctx-error.ts

@@ -0,0 +1,26 @@
+import { Middleware } from "winterspec/middleware"
+
+export type CtxErrorFn = (
+  status: number,
+  error_payload: {
+    error_code: string
+    message: string
+  },
+) => Response
+
+export const withCtxError: Middleware<
+  {},
+  {
+    error: CtxErrorFn
+  }
+> = async (req, ctx, next) => {
+  ctx.error = (status, error_payload) => {
+    return new Response(JSON.stringify({ error: error_payload }), {
+      status,
+      headers: {
+        "Content-Type": "application/json",
+      },
+    })
+  }
+  return next(req, ctx)
+}

package/fake-snippets-api/lib/middleware/with-db.ts

@@ -0,0 +1,15 @@
+import type { DbClient } from "fake-snippets-api/lib/db/db-client"
+import { createDatabase } from "fake-snippets-api/lib/db/db-client"
+import type { Middleware } from "winterspec"
+
+export const withDb: Middleware<
+  {},
+  {
+    db: DbClient
+  }
+> = async (req, ctx, next) => {
+  if (!ctx.db) {
+    ctx.db = createDatabase()
+  }
+  return next(req, ctx)
+}

package/fake-snippets-api/lib/middleware/with-error-handling.ts

@@ -0,0 +1,24 @@
+import { Middleware } from "winterspec/middleware"
+import kleur from "kleur"
+
+export const withErrorHandling: Middleware<{}, {}> = async (req, ctx, next) => {
+  try {
+    return await next(req, ctx)
+  } catch (error: any) {
+    console.error(kleur.red("Intercepted error:"), error)
+    // If error is a Response, return it
+    if (error instanceof Response) {
+      return error
+    }
+    return (ctx as any).json(
+      {
+        ok: false,
+        error: {
+          message: error?.message,
+          error_code: error?.error_code ?? "internal_server_error",
+        },
+      },
+      { status: error?.status || 500 },
+    )
+  }
+}

package/fake-snippets-api/lib/middleware/with-optional-session-auth.ts

@@ -0,0 +1,34 @@
+import type { Middleware } from "winterspec/middleware"
+import { CtxErrorFn } from "./with-ctx-error"
+
+export const withOptionalSessionAuth: Middleware<
+  {
+    error: CtxErrorFn
+  },
+  {
+    auth?: {
+      type: "session"
+      account_id: string
+      personal_org_id: string
+      github_username: string
+      session_id: string
+    }
+  },
+  {}
+> = async (req, ctx, next) => {
+  if (req.method === "OPTIONS") return next(req, ctx)
+
+  const token = req.headers.get("authorization")?.split("Bearer ")?.[1]
+
+  if (token) {
+    ctx.auth = {
+      type: "session",
+      account_id: "account-1234",
+      personal_org_id: "org-1234",
+      github_username: "testuser",
+      session_id: "session-1234",
+    }
+  }
+
+  return next(req, ctx)
+}

package/fake-snippets-api/lib/middleware/with-request-logging.ts

@@ -0,0 +1,54 @@
+import { Middleware } from "winterspec/middleware"
+import kleur from "kleur"
+
+// ENABLE COLORS ALWAYS
+kleur.enabled = true
+
+const colorStatus = (status: number) => {
+  if (status >= 500) {
+    return kleur.red(status.toString())
+  }
+  if (status >= 400) {
+    return kleur.yellow(status.toString())
+  }
+  return kleur.green(status.toString())
+}
+
+export interface Logger {
+  error: (...args: any[]) => void
+  info: (...args: any[]) => void
+  warn: (...args: any[]) => void
+  debug: (...args: any[]) => void
+}
+
+export const withRequestLogging: Middleware<
+  {},
+  {
+    logger: Logger
+  }
+> = async (req, ctx, next) => {
+  if (!ctx.logger) {
+    ctx.logger = {
+      error: (...args: any[]) => console.error(...args),
+      info: (...args: any[]) => console.log(...args),
+      warn: (...args: any[]) => console.warn(...args),
+      debug: (...args: any[]) => console.log(...args),
+    }
+  }
+  try {
+    ctx.logger.info(kleur.blue(`> ${req.method} ${req.url}`))
+    const response = await next(req, ctx)
+    try {
+      const responseBody = await response.clone().text()
+      ctx.logger.info(
+        `< ${colorStatus(response.status)} ${kleur.gray(responseBody.slice(0, 40).replace(/(\r\n|\n|\r)/gm, ""))}`,
+      )
+    } catch (e) {
+      ctx.logger.info(`< ${colorStatus(response.status)}`)
+    }
+    return response
+  } catch (e: any) {
+    ctx.logger.info(kleur.red(`< ERROR ${e.toString().slice(0, 50)}...`))
+    throw e
+  }
+}

package/fake-snippets-api/lib/middleware/with-session-auth.ts

@@ -0,0 +1,39 @@
+import type { Middleware } from "winterspec/middleware"
+import { CtxErrorFn } from "./with-ctx-error"
+
+export const withSessionAuth: Middleware<
+  {
+    error: CtxErrorFn
+  },
+  {
+    auth: {
+      type: "session"
+      account_id: string
+      personal_org_id: string
+      github_username: string
+      session_id: string
+    }
+  },
+  {}
+> = async (req, ctx, next) => {
+  if (req.method === "OPTIONS") return next(req, ctx)
+
+  const token = req.headers.get("authorization")?.split("Bearer ")?.[1]
+
+  if (!token) {
+    return ctx.error(401, {
+      error_code: "no_token",
+      message: "No token provided",
+    })
+  }
+
+  ctx.auth = {
+    type: "session",
+    account_id: "account-1234",
+    personal_org_id: "org-1234",
+    github_username: "testuser",
+    session_id: "session-1234",
+  }
+
+  return next(req, ctx)
+}

package/fake-snippets-api/lib/middleware/with-winter-spec.ts

@@ -0,0 +1,24 @@
+import { createWithWinterSpec } from "winterspec"
+import { withDb } from "./with-db"
+import { createWithDefaultExceptionHandling } from "winterspec/middleware"
+import { withCtxError } from "./with-ctx-error"
+import { withSessionAuth } from "./with-session-auth"
+import { withOptionalSessionAuth } from "./with-optional-session-auth"
+import { withErrorHandling } from "./with-error-handling"
+import { withRequestLogging } from "./with-request-logging"
+
+export const withRouteSpec = createWithWinterSpec({
+  apiName: "tscircuit Snippets API",
+  productionServerUrl: "https://snippets.tscircuit.com/api",
+  beforeAuthMiddleware: [withRequestLogging, withErrorHandling, withCtxError],
+  authMiddleware: {
+    session: withSessionAuth,
+    optional_session: withOptionalSessionAuth,
+  },
+  afterAuthMiddleware: [
+    withDb,
+    createWithDefaultExceptionHandling({
+      includeStackTraceInResponse: true,
+    }),
+  ],
+})

package/fake-snippets-api/next-env.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/basic-features/typescript for more information.

package/fake-snippets-api/routes/api/accounts/get.ts

@@ -0,0 +1,21 @@
+import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
+import { z } from "zod"
+import { accountSchema } from "fake-snippets-api/lib/db/schema"
+
+export default withRouteSpec({
+  methods: ["GET"],
+  auth: "session",
+  jsonResponse: z.object({
+    account: accountSchema,
+  }),
+})(async (req, ctx) => {
+  const account = ctx.db.getAccount(ctx.auth.account_id)
+  if (!account) {
+    return ctx.error(404, {
+      error_code: "account_not_found",
+      message: "Account not found",
+    })
+  }
+
+  return ctx.json({ account })
+})

package/fake-snippets-api/routes/api/accounts/get_account_balance.ts

@@ -0,0 +1,22 @@
+import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
+import { z } from "zod"
+
+export default withRouteSpec({
+  methods: ["GET"],
+  auth: "session",
+  jsonResponse: z.object({
+    account_balance: z.object({
+      monthly_ai_budget_used_usd: z.number(),
+    }),
+  }),
+})(async (req, ctx) => {
+  // For this example, we'll return a mock balance
+  // In a real implementation, you would fetch this from a database or external service
+  const mockBalance = {
+    monthly_ai_budget_used_usd: 2.5,
+  }
+
+  return ctx.json({
+    account_balance: mockBalance,
+  })
+})

package/fake-snippets-api/routes/api/accounts/update.ts

@@ -0,0 +1,32 @@
+import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
+import { z } from "zod"
+import {
+  accountSchema,
+  shippingInfoSchema,
+} from "fake-snippets-api/lib/db/schema"
+
+export default withRouteSpec({
+  methods: ["POST"],
+  auth: "session",
+  jsonBody: z.object({
+    shippingInfo: shippingInfoSchema,
+  }),
+  jsonResponse: z.object({
+    account: accountSchema,
+  }),
+})(async (req, ctx) => {
+  const { shippingInfo } = req.jsonBody
+
+  const updatedAccount = ctx.db.updateAccount(ctx.auth.account_id, {
+    shippingInfo,
+  })
+
+  if (!updatedAccount) {
+    return ctx.error(404, {
+      error_code: "account_not_found",
+      message: "Account not found",
+    })
+  }
+
+  return ctx.json({ account: updatedAccount })
+})

package/fake-snippets-api/routes/api/ai/[...anyroute].ts

@@ -0,0 +1,31 @@
+/**
+ * Forward request to anthropic
+ */
+export default async (req: Request) => {
+  const url = new URL(req.url)
+  const anthropicApiKey = process.env.ANTHROPIC_API_KEY
+
+  if (!anthropicApiKey) {
+    return new Response("Anthropic API key is not set", { status: 500 })
+  }
+
+  const anthropicUrl =
+    "https://api.anthropic.com" + url.pathname.replace(/^\/api\/ai/, "")
+
+  const headers = new Headers(req.headers)
+  headers.set("x-api-key", `${anthropicApiKey}`)
+
+  console.log("sending request to anthropic")
+  const response = await fetch(anthropicUrl, {
+    method: req.method,
+    headers: headers,
+    body: req.body,
+    // @ts-ignore
+    duplex: "half",
+  }).then((r) => r.json())
+
+  return new Response(JSON.stringify(response), {
+    status: 200,
+    headers: { "Content-Type": "application/json" },
+  })
+}

package/fake-snippets-api/routes/api/ai.ts

@@ -0,0 +1,2 @@
+import ai from "./ai/[...anyroute]"
+export default ai

package/fake-snippets-api/routes/api/aistream/[...anyroute].ts

@@ -0,0 +1,65 @@
+import { ReadableStream } from "stream/web"
+
+export default async (req: Request) => {
+  const url = new URL(req.url)
+  const anthropicApiKey = process.env.ANTHROPIC_API_KEY
+
+  if (!anthropicApiKey) {
+    return new Response("Anthropic API key is not set", { status: 500 })
+  }
+
+  const anthropicUrl =
+    "https://api.anthropic.com" + url.pathname.replace(/^\/api\/ai/, "")
+
+  const headers = new Headers(req.headers)
+  headers.set("x-api-key", `${anthropicApiKey}`)
+  headers.set("Accept", "text/event-stream")
+  headers.set("Cache-Control", "no-cache")
+  headers.set("Connection", "keep-alive")
+
+  console.log("sending request to anthropic")
+  const response = await fetch(anthropicUrl, {
+    method: req.method,
+    headers: headers,
+    body: req.body,
+    // @ts-ignore
+    duplex: "half",
+  })
+
+  // Check if the response is successful
+  if (!response.ok) {
+    return new Response(
+      `Anthropic API returned an error: ${response.status} ${response.statusText}`,
+      {
+        status: response.status,
+      },
+    )
+  }
+
+  // Create a ReadableStream to process the response
+  const stream = new ReadableStream({
+    async start(controller) {
+      const reader = response.body!.getReader()
+
+      try {
+        while (true) {
+          const { done, value } = await reader.read()
+          if (done) break
+          controller.enqueue(value)
+        }
+      } finally {
+        reader.releaseLock()
+        controller.close()
+      }
+    },
+  })
+
+  // Return a streaming response
+  return new Response(stream as any, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+    },
+  })
+}

package/fake-snippets-api/routes/api/health.ts

@@ -0,0 +1,9 @@
+import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
+import { z } from "zod"
+
+export default withRouteSpec({
+  methods: ["GET"],
+  jsonResponse: z.object({ ok: z.boolean() }),
+})(async (req: any, ctx: any) => {
+  return ctx.json({ ok: true })
+})

package/fake-snippets-api/routes/api/internal/sessions/create_without_auth.ts

@@ -0,0 +1,63 @@
+import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
+import { z } from "zod"
+import ms from "ms"
+import { SignJWT } from "jose"
+
+export default withRouteSpec({
+  methods: ["POST"],
+  auth: "none",
+  jsonBody: z
+    .object({
+      account_id: z.string(),
+    })
+    .or(
+      z.object({
+        github_username: z.string(),
+      }),
+    ),
+  jsonResponse: z.object({
+    session: z.object({
+      session_id: z.string(),
+      account_id: z.string(),
+      expires_at: z.string(),
+      is_cli_session: z.boolean(),
+      token: z.string(),
+    }),
+  }),
+})(async (req, ctx) => {
+  let account
+  if ("account_id" in req.jsonBody) {
+    account = ctx.db.getAccount(req.jsonBody.account_id)
+  } else {
+    account = ctx.db.getAccount(req.jsonBody.github_username)
+  }
+
+  if (!account) {
+    return ctx.error(404, {
+      error_code: "account_not_found",
+      message: "Account not found",
+    })
+  }
+
+  const new_session = ctx.db.createSession({
+    expires_at: new Date(Date.now() + ms("60 day")).toISOString(),
+    account_id: account.account_id,
+    is_cli_session: false,
+  })
+
+  const token = await new SignJWT({
+    account_id: account.account_id,
+    session_id: new_session.session_id,
+    github_username: account.github_username,
+  })
+    .setProtectedHeader({ alg: "HS256" })
+    .setExpirationTime(new Date(Date.now() + ms("60 day")).toISOString())
+    .sign(new TextEncoder().encode(process.env.JWT_SECRET || ""))
+
+  return ctx.json({
+    session: {
+      ...new_session,
+      token,
+    },
+  })
+})

package/fake-snippets-api/routes/api/order_files/get.ts

@@ -0,0 +1,28 @@
+import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
+import { z } from "zod"
+import { orderFileSchema } from "fake-snippets-api/lib/db/schema"
+
+export default withRouteSpec({
+  methods: ["GET"],
+  auth: "session",
+  queryParams: z.object({
+    order_file_id: z.string(),
+  }),
+  jsonResponse: z.object({
+    order_file: orderFileSchema,
+  }),
+})(async (req, ctx) => {
+  const { order_file_id } = req.query
+
+  const orderFile = ctx.db.getOrderFileById(order_file_id)
+  if (!orderFile) {
+    return ctx.error(404, {
+      error_code: "order_file_not_found",
+      message: "Order file not found",
+    })
+  }
+
+  return ctx.json({
+    order_file: orderFile,
+  })
+})

package/fake-snippets-api/routes/api/order_files/upload.ts

@@ -0,0 +1,43 @@
+import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
+import { z } from "zod"
+import { orderFileSchema } from "fake-snippets-api/lib/db/schema"
+
+export default withRouteSpec({
+  methods: ["POST"],
+  auth: "session",
+  jsonBody: z.object({
+    order_id: z.string(),
+    content_base64: z.string(),
+    is_gerbers_zip: z.boolean().optional(),
+    for_provider: z.string().optional(),
+  }),
+  jsonResponse: z.object({
+    order_file: orderFileSchema,
+  }),
+})(async (req, ctx) => {
+  const { order_id, content_base64, is_gerbers_zip, for_provider } =
+    req.jsonBody
+
+  const order = ctx.db.getOrderById(order_id)
+  if (!order) {
+    return ctx.error(404, {
+      error_code: "order_not_found",
+      message: "Order not found",
+    })
+  }
+
+  const newOrderFile = {
+    order_id,
+    is_gerbers_zip: is_gerbers_zip || false,
+    file_content: Buffer.from(content_base64, "base64"),
+    content_type: "base64",
+    for_provider: for_provider || null,
+    uploaded_at: new Date().toISOString(),
+  }
+
+  const orderFile = ctx.db.addOrderFile(newOrderFile)
+
+  return ctx.json({
+    order_file: orderFile,
+  })
+})

package/fake-snippets-api/routes/api/orders/create.ts

@@ -0,0 +1,41 @@
+import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
+import { z } from "zod"
+import { orderSchema } from "fake-snippets-api/lib/db/schema"
+
+export default withRouteSpec({
+  methods: ["POST"],
+  auth: "session",
+  jsonBody: z.object({
+    circuit_json: z.array(z.record(z.any())),
+  }),
+  jsonResponse: z.object({
+    order: orderSchema,
+  }),
+})(async (req, ctx) => {
+  const { circuit_json } = req.jsonBody
+
+  const newOrder = {
+    account_id: ctx.auth.account_id,
+    is_draft: true,
+    is_pending_validation_by_fab: false,
+    is_pending_review_by_fab: false,
+    is_validated_by_fab: false,
+    is_approved_by_fab_review: false,
+    is_approved_by_orderer: false,
+    is_in_production: false,
+    is_shipped: false,
+    is_cancelled: false,
+    should_be_blank_pcb: false,
+    should_include_stencil: false,
+    jlcpcb_order_params: {},
+    circuit_json,
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+  }
+
+  const order = ctx.db.addOrder(newOrder)
+
+  return ctx.json({
+    order,
+  })
+})

package/fake-snippets-api/routes/api/orders/get.ts

@@ -0,0 +1,28 @@
+import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
+import { z } from "zod"
+import { orderSchema } from "fake-snippets-api/lib/db/schema"
+
+export default withRouteSpec({
+  methods: ["GET"],
+  auth: "session",
+  queryParams: z.object({
+    order_id: z.string(),
+  }),
+  jsonResponse: z.object({
+    order: orderSchema,
+  }),
+})(async (req, ctx) => {
+  const { order_id } = req.query
+
+  const order = ctx.db.getOrderById(order_id)
+  if (!order) {
+    return ctx.error(404, {
+      error_code: "order_not_found",
+      message: "Order not found",
+    })
+  }
+
+  return ctx.json({
+    order,
+  })
+})

package/fake-snippets-api/routes/api/orders/list.ts

@@ -0,0 +1,15 @@
+import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
+import { z } from "zod"
+import { orderSchema } from "fake-snippets-api/lib/db/schema"
+
+export default withRouteSpec({
+  methods: ["GET"],
+  auth: "session",
+  jsonResponse: z.object({
+    orders: z.array(orderSchema),
+  }),
+})(async (req, ctx) => {
+  return ctx.json({
+    orders: ctx.db.orders.filter((o) => o.account_id === ctx.auth.account_id),
+  })
+})