@tscircuit/fake-snippets 0.0.1

package/bun-tests/fake-snippets-api/fixtures/get-circuit-json.ts

@@ -0,0 +1,148 @@
+import * as React from "react"
+import { getImportsFromCode } from "@tscircuit/prompt-benchmarks/code-runner-utils"
+import * as tscircuitCore from "@tscircuit/core"
+import * as jscadFiber from "jscad-fiber"
+import type { AnyCircuitElement } from "circuit-json"
+import { safeCompileTsx } from "@/hooks/use-compiled-tsx"
+import { evalCompiledJs } from "@/hooks/use-run-tsx/eval-compiled-js"
+import { constructCircuit } from "@/hooks/use-run-tsx/construct-circuit"
+
+type GenerateCircuitJson = {
+  code: string
+  type: "board" | "footprint" | "package" | "model"
+  compiled_js: string
+}
+
+// Keeping track of processed imports to avoid circular dependencies
+const processedImports = new Set<string>()
+
+async function processImport(
+  importName: string,
+  preSuppliedImports: Record<string, any>,
+  depth = 0,
+  code: string,
+  compiled_js: string,
+): Promise<void> {
+  if (!importName.startsWith("@tsci/")) return
+  if (preSuppliedImports[importName]) return
+  if (processedImports.has(importName)) return
+  if (depth > 5) {
+    throw new Error(
+      `Max depth for imports reached when processing ${importName}`,
+    )
+  }
+
+  processedImports.add(importName)
+
+  try {
+    // Process nested imports first
+    const nestedImports = getImportsFromCode(code)
+
+    // Filter out already processed imports and non-@tsci imports
+    const validNestedImports = nestedImports.filter(
+      (imp) =>
+        imp.startsWith("@tsci/") &&
+        !processedImports.has(imp) &&
+        !preSuppliedImports[imp],
+    )
+
+    // Process each valid nested import
+    for (const nestedImport of validNestedImports) {
+      await processImport(
+        nestedImport,
+        preSuppliedImports,
+        depth + 1,
+        code,
+        compiled_js,
+      )
+    }
+    // Set React in the global scope before evaluation
+    ;(globalThis as any).React = React
+    const exports = evalCompiledJs(compiled_js).exports
+
+    // Only set the import if we successfully evaluated it
+    if (exports) {
+      preSuppliedImports[importName] = exports
+    }
+  } catch (e) {
+    processedImports.delete(importName) // Clean up on error
+  }
+}
+
+export const generateCircuitJson = async ({
+  code,
+  type,
+  compiled_js,
+}: GenerateCircuitJson): Promise<AnyCircuitElement[]> => {
+  // Clear the processed imports set at the start of each generation
+  processedImports.clear()
+
+  // Set up pre-supplied imports
+  const preSuppliedImports: Record<string, any> = {
+    "@tscircuit/core": tscircuitCore,
+    react: React,
+    "jscad-fiber": jscadFiber,
+  }
+  ;(globalThis as any).React = React
+  ;(globalThis as any).createElement = React.createElement
+
+  try {
+    // Process all @tsci imports
+    const tsciImports = getImportsFromCode(code).filter((imp) =>
+      imp.startsWith("@tsci/"),
+    )
+    for (const importName of tsciImports) {
+      await processImport(importName, preSuppliedImports, 0, code, compiled_js)
+    }
+
+    // Create require function for imports
+    const __tscircuit_require = (name: string) => {
+      if (!preSuppliedImports[name]) {
+        throw new Error(
+          `Import "${name}" not found (available imports: ${Object.keys(preSuppliedImports).join(", ")})`,
+        )
+      }
+      return preSuppliedImports[name]
+    }
+    ;(globalThis as any).__tscircuit_require = __tscircuit_require
+
+    // Add a custom JSX runtime
+    ;(globalThis as any).jsx = React.createElement
+    ;(globalThis as any).jsxs = React.createElement
+
+    const { success, compiledTsx, error } = safeCompileTsx(code)
+    if (!success || !compiledTsx) {
+      throw new Error(
+        `Compile Error: ${error?.message || "Unknown compilation error"}`,
+      )
+    }
+
+    const module = evalCompiledJs(compiledTsx)
+    const componentExportKeys = Object.keys(module.exports).filter(
+      (key) => !key.startsWith("use"),
+    )
+
+    if (componentExportKeys.length > 1) {
+      throw new Error(
+        `Too many exports, only export one component. Exports: ${JSON.stringify(componentExportKeys)}`,
+      )
+    }
+
+    const primaryKey = componentExportKeys[0]
+
+    // Create the user element with explicit React scope
+    const UserElm = function (props: any) {
+      return React.createElement(module.exports[primaryKey], props)
+    }
+
+    // Construct and render the circuit
+    const circuit = constructCircuit({ UserElm, type })
+
+    // Wait for the circuit to settle
+    await circuit.renderUntilSettled()
+
+    return circuit.getCircuitJson() as AnyCircuitElement[]
+  } catch (e) {
+    throw new Error("Circuit generation failed!")
+  }
+}

package/bun-tests/fake-snippets-api/fixtures/get-test-server.ts

@@ -0,0 +1,96 @@
+import { afterEach } from "bun:test"
+import { tmpdir } from "node:os"
+import defaultAxios from "redaxios"
+import { startServer } from "./start-server"
+import { DbClient } from "fake-snippets-api/lib/db/db-client"
+
+let testNumber = 1
+
+interface TestFixture {
+  url: string
+  server: any
+  axios: typeof defaultAxios
+  db: DbClient
+  seed: ReturnType<typeof seedDatabase>
+}
+
+export const getTestServer = async (): Promise<TestFixture> => {
+  const port = 3000 + testNumber++
+  const testInstanceId = Math.random().toString(36).substring(2, 15)
+  const testDbName = `testdb${testInstanceId}`
+
+  const { server, db } = await startServer({
+    port,
+    testDbName,
+  })
+
+  const url = `http://127.0.0.1:${port}`
+  const seed = seedDatabase(db)
+  const axios = defaultAxios.create({
+    baseURL: url,
+    headers: {
+      Authorization: `Bearer ${seed.account.account_id}`,
+    },
+  })
+
+  afterEach(async () => {
+    if (server && typeof server.stop === "function") {
+      await server.stop()
+    }
+    // Here you might want to add logic to drop the test database
+  })
+
+  return {
+    url,
+    server,
+    axios,
+    db,
+    seed,
+  }
+}
+
+const seedDatabase = (db: DbClient) => {
+  const account = db.addAccount({
+    github_username: "testuser",
+    shippingInfo: {
+      firstName: "Test",
+      lastName: "User",
+      companyName: "Test Company",
+      address: "123 Test St",
+      apartment: "Apt 4B",
+      city: "Testville",
+      state: "NY",
+      zipCode: "10001",
+      country: "United States of America",
+      phone: "555-123-4567",
+    },
+  })
+  const order = db.addOrder({
+    account_id: account.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: [
+      {
+        type: "source_component",
+        ftype: "simple_resistor",
+        source_component_id: "source_component_1",
+        name: "R1",
+        resistance: "1k",
+      },
+    ],
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+  })
+
+  return { account, order }
+}

package/bun-tests/fake-snippets-api/fixtures/start-server.ts

@@ -0,0 +1,44 @@
+import {
+  createFetchHandlerFromDir,
+  createWinterSpecBundleFromDir,
+} from "winterspec/adapters/node"
+import { Request as EdgeRuntimeRequest } from "@edge-runtime/primitives"
+import { join } from "node:path"
+import os from "node:os"
+import type { Middleware } from "winterspec"
+import { createDatabase } from "fake-snippets-api/lib/db/db-client"
+
+export const startServer = async ({
+  port,
+  testDbName,
+}: { port: number; testDbName: string }) => {
+  const winterspecBundle = await createWinterSpecBundleFromDir(
+    join(import.meta.dir, "../../../fake-snippets-api/routes"),
+  )
+
+  const db = createDatabase()
+
+  const middleware: Middleware[] = [
+    async (req: any, ctx: any, next: any) => {
+      ;(ctx as any).db = db
+
+      return next(req, ctx)
+    },
+  ]
+
+  const server = Bun.serve({
+    fetch: (bunReq) => {
+      const req = new EdgeRuntimeRequest(bunReq.url, {
+        headers: bunReq.headers,
+        method: bunReq.method,
+        body: bunReq.body,
+      })
+      return winterspecBundle.makeRequest(req as any, {
+        middleware,
+      })
+    },
+    port,
+  })
+
+  return { server: { ...server, stop: () => server.stop() }, db }
+}

package/bun-tests/fake-snippets-api/routes/accounts/get_account_balance.test.ts

@@ -0,0 +1,18 @@
+import { getTestServer } from "bun-tests/fake-snippets-api/fixtures/get-test-server"
+import { test, expect } from "bun:test"
+
+test("get account balance", async () => {
+  const { axios } = await getTestServer()
+
+  const response = await axios.get("/api/accounts/get_account_balance", {
+    headers: {
+      Authorization: "Bearer 1234",
+    },
+  })
+
+  expect(response.status).toBe(200)
+  expect(response.data.account_balance).toBeDefined()
+  expect(typeof response.data.account_balance.monthly_ai_budget_used_usd).toBe(
+    "number",
+  )
+})

package/bun-tests/fake-snippets-api/routes/health.test.ts

@@ -0,0 +1,9 @@
+import { it, expect } from "bun:test"
+import { getTestServer } from "bun-tests/fake-snippets-api/fixtures/get-test-server"
+
+it("GET /health should return ok", async () => {
+  const { axios, url } = await getTestServer()
+  const res = await axios.get("/api/health")
+  expect(res.status).toBe(200)
+  expect(res.data).toEqual({ ok: true })
+})

package/bun-tests/fake-snippets-api/routes/order_files/get.test.ts

@@ -0,0 +1,48 @@
+import { getTestServer } from "bun-tests/fake-snippets-api/fixtures/get-test-server"
+import { test, expect } from "bun:test"
+
+test("get order file", async () => {
+  const {
+    axios,
+    seed: {
+      order: { order_id },
+    },
+  } = await getTestServer()
+
+  const fileContent = "test file content"
+  const fileContentBase64 = Buffer.from(fileContent).toString("base64")
+
+  const uploadResponse = await axios.post("/api/order_files/upload", {
+    order_id,
+    content_base64: fileContentBase64,
+    is_gerbers_zip: false,
+  })
+
+  const orderFileId = uploadResponse.data.order_file.order_file_id
+
+  const response = await axios.get("/api/order_files/get", {
+    params: { order_file_id: orderFileId },
+  })
+
+  expect(response.status).toBe(200)
+  expect(response.data.order_file).toBeDefined()
+  expect(response.data.order_file.order_file_id).toBe(orderFileId)
+  expect(response.data.order_file.order_id).toBe(order_id)
+  expect(response.data.order_file.content_type).toBe("base64")
+  expect(response.data.order_file.is_gerbers_zip).toBe(false)
+})
+
+test("get non-existent order file", async () => {
+  const { axios } = await getTestServer()
+
+  try {
+    await axios.get("/api/order_files/get", {
+      params: { order_file_id: "non-existent-id" },
+    })
+
+    expect(true).toBe(false)
+  } catch (error: any) {
+    expect(error.status).toBe(404)
+    expect(error.data.error.message).toBe("Order file not found")
+  }
+})

package/bun-tests/fake-snippets-api/routes/order_files/upload.test.ts

@@ -0,0 +1,77 @@
+import { getTestServer } from "bun-tests/fake-snippets-api/fixtures/get-test-server"
+import { test, expect } from "bun:test"
+
+test("upload order file", async () => {
+  const {
+    axios,
+    seed: {
+      order: { order_id },
+    },
+  } = await getTestServer()
+
+  const fileContent = "test file content"
+  const fileContentBase64 = Buffer.from(fileContent).toString("base64")
+
+  const response = await axios.post("/api/order_files/upload", {
+    order_id,
+    content_base64: fileContentBase64,
+    is_gerbers_zip: false,
+  })
+
+  expect(response.status).toBe(200)
+  expect(response.data.order_file).toBeDefined()
+  expect(response.data.order_file.order_id).toBe(order_id)
+  expect(response.data.order_file.file_content).toBeDefined()
+  expect(response.data.order_file.content_type).toBe("base64")
+  expect(response.data.order_file.is_gerbers_zip).toBe(false)
+  expect(response.data.order_file.uploaded_at).toBeDefined()
+})
+
+test("upload order file with for_provider", async () => {
+  const { axios, db } = await getTestServer()
+
+  const orderResponse = await axios.post("/api/orders/create", {
+    circuit_json: [{ test: "circuit data" }],
+  })
+
+  const orderId = orderResponse.data.order.order_id
+
+  const fileContent = "test file content for provider"
+  const fileContentBase64 = Buffer.from(fileContent).toString("base64")
+
+  const response = await axios.post("/api/order_files/upload", {
+    order_id: orderId,
+    content_base64: fileContentBase64,
+    is_gerbers_zip: true,
+    for_provider: "jlcpcb",
+  })
+
+  expect(response.status).toBe(200)
+  expect(response.data.order_file).toBeDefined()
+  expect(response.data.order_file.order_id).toBe(orderId)
+  expect(response.data.order_file.file_content).toBeDefined()
+  expect(response.data.order_file.content_type).toBe("base64")
+  expect(response.data.order_file.is_gerbers_zip).toBe(true)
+  expect(response.data.order_file.for_provider).toBe("jlcpcb")
+  expect(response.data.order_file.uploaded_at).toBeDefined()
+})
+
+test("upload order file for non-existent order", async () => {
+  const { axios } = await getTestServer()
+
+  const fileContent = "test file content"
+  const fileContentBase64 = Buffer.from(fileContent).toString("base64")
+
+  try {
+    await axios.post("/api/order_files/upload", {
+      order_id: "non-existent-order-id",
+      content_base64: fileContentBase64,
+      is_gerbers_zip: false,
+    })
+    // If the request doesn't throw an error, fail the test
+    expect(true).toBe(false)
+  } catch (error: any) {
+    expect(error.status).toBe(404)
+    expect(error.data.error.message).toBe("Order not found")
+  }
+})

package/bun-tests/fake-snippets-api/routes/orders/create.test.ts

@@ -0,0 +1,19 @@
+import { getTestServer } from "bun-tests/fake-snippets-api/fixtures/get-test-server"
+import { test, expect } from "bun:test"
+
+test("create order", async () => {
+  const {
+    axios,
+    seed: { order },
+  } = await getTestServer()
+
+  const response = await axios.post("/api/orders/create", {
+    circuit_json: order.circuit_json,
+  })
+
+  expect(response.status).toBe(200)
+  expect(response.data.order).toBeDefined()
+  expect(response.data.order.account_id).toBe("account-1234")
+  expect(response.data.order.is_draft).toBe(true)
+  expect(response.data.order.circuit_json).toEqual(order.circuit_json)
+})

package/bun-tests/fake-snippets-api/routes/orders/get.test.ts

@@ -0,0 +1,38 @@
+import { getTestServer } from "bun-tests/fake-snippets-api/fixtures/get-test-server"
+import { test, expect } from "bun:test"
+
+test("get order", async () => {
+  const {
+    axios,
+    seed: { order, account },
+  } = await getTestServer()
+
+  const orderId = order.order_id
+
+  // Get the seeded order
+  const response = await axios.get("/api/orders/get", {
+    params: { order_id: orderId },
+  })
+
+  expect(response.status).toBe(200)
+  expect(response.data.order).toBeDefined()
+  expect(response.data.order.order_id).toBe(orderId)
+  expect(response.data.order.account_id).toBe(account.account_id)
+  expect(response.data.order.is_draft).toBe(true)
+})
+
+test("get non-existent order", async () => {
+  const { axios } = await getTestServer()
+
+  try {
+    await axios.get("/api/orders/get", {
+      params: { order_id: "non-existent-id" },
+    })
+
+    // If the request doesn't throw an error, fail the test
+    expect(true).toBe(false)
+  } catch (error: any) {
+    expect(error.status).toBe(404)
+    expect(error.data.error.message).toBe("Order not found")
+  }
+})

package/bun-tests/fake-snippets-api/routes/orders/list.test.ts

@@ -0,0 +1,30 @@
+import { getTestServer } from "bun-tests/fake-snippets-api/fixtures/get-test-server"
+import { test, expect } from "bun:test"
+
+test("list orders", async () => {
+  const {
+    axios,
+    seed: { order },
+  } = await getTestServer()
+
+  await axios.post("/api/orders/create", {
+    circuit_json: order.circuit_json,
+  })
+
+  const response = await axios.get("/api/orders/list")
+
+  expect(response.status).toBe(200)
+  expect(response.data.orders).toBeDefined()
+  expect(response.data.orders).toHaveLength(1)
+  expect(response.data.orders[0].circuit_json).toEqual(order.circuit_json)
+})
+
+test("list orders with empty result", async () => {
+  const { axios } = await getTestServer()
+
+  const response = await axios.get("/api/orders/list")
+
+  expect(response.status).toBe(200)
+  expect(response.data.orders).toBeDefined()
+  expect(response.data.orders).toHaveLength(0)
+})

package/bun-tests/fake-snippets-api/routes/orders/update.test.ts

@@ -0,0 +1,46 @@
+import { getTestServer } from "bun-tests/fake-snippets-api/fixtures/get-test-server"
+import { test, expect } from "bun:test"
+
+test("update order", async () => {
+  const {
+    axios,
+    seed: {
+      order: { order_id },
+    },
+  } = await getTestServer()
+
+  const response = await axios.patch("/api/orders/update", {
+    order_id,
+    updates: {
+      is_draft: false,
+      is_pending_validation_by_fab: true,
+      jlcpcb_order_params: { param1: "value1" },
+    },
+  })
+
+  expect(response.status).toBe(200)
+  expect(response.data.order).toBeDefined()
+  expect(response.data.order.order_id).toBe(order_id)
+  expect(response.data.order.is_draft).toBe(false)
+  expect(response.data.order.is_pending_validation_by_fab).toBe(true)
+  expect(response.data.order.jlcpcb_order_params).toEqual({ param1: "value1" })
+})
+
+test("update non-existent order", async () => {
+  const { axios } = await getTestServer()
+
+  try {
+    await axios.patch("/api/orders/update", {
+      order_id: "non-existent-id",
+      updates: {
+        is_draft: false,
+      },
+    })
+
+    // If the request doesn't throw an error, fail the test
+    expect(true).toBe(false)
+  } catch (error: any) {
+    expect(error.status).toBe(404)
+    expect(error.data.error.message).toBe("Order not found")
+  }
+})

package/bun-tests/fake-snippets-api/routes/snippets/add_star.test.ts

@@ -0,0 +1,114 @@
+import { getTestServer } from "bun-tests/fake-snippets-api/fixtures/get-test-server"
+import { test, expect } from "bun:test"
+
+test("add star to snippet", async () => {
+  const { axios, db } = await getTestServer()
+
+  // Add a test snippet
+  const snippet = {
+    unscoped_name: "TestSnippet",
+    owner_name: "otheruser",
+    code: "Test Content",
+    created_at: "2023-01-01T00:00:00Z",
+    updated_at: "2023-01-01T00:00:00Z",
+    name: "otheruser/TestSnippet",
+    snippet_type: "package",
+    description: "Test Description",
+  }
+  const addedSnippet = db.addSnippet(snippet as any)!
+
+  // Star the snippet
+  const response = await axios.post(
+    "/api/snippets/add_star",
+    {
+      snippet_id: addedSnippet.snippet_id,
+    },
+    {
+      headers: {
+        Authorization: "Bearer 1234",
+      },
+    },
+  )
+
+  expect(response.status).toBe(200)
+  expect(response.data.ok).toBe(true)
+  expect(response.data.account_snippet).toBeDefined()
+  expect(response.data.account_snippet.snippet_id).toBe(addedSnippet.snippet_id)
+  expect(response.data.account_snippet.has_starred).toBe(true)
+
+  // Verify star was added in database
+  expect(db.hasStarred("account-1234", addedSnippet.snippet_id)).toBe(true)
+})
+
+test("add star to non-existent snippet", async () => {
+  const { axios } = await getTestServer()
+
+  try {
+    await axios.post(
+      "/api/snippets/add_star",
+      {
+        snippet_id: "non-existent-id",
+      },
+      {
+        headers: {
+          Authorization: "Bearer 1234",
+        },
+      },
+    )
+    expect(true).toBe(false) // Should not reach here
+  } catch (error: any) {
+    expect(error.status).toBe(404)
+    expect(error.data.error.message).toBe("Snippet not found")
+  }
+})
+
+test("add star to already starred snippet", async () => {
+  const { axios, db } = await getTestServer()
+
+  // Add a test snippet
+  const snippet = {
+    unscoped_name: "TestSnippet",
+    owner_name: "otheruser",
+    code: "Test Content",
+    created_at: "2023-01-01T00:00:00Z",
+    updated_at: "2023-01-01T00:00:00Z",
+    name: "otheruser/TestSnippet",
+    snippet_type: "package",
+    description: "Test Description",
+  }
+  const addedSnippet = db.addSnippet(snippet as any)
+
+  // Star the snippet first time
+  await axios.post(
+    "/api/snippets/add_star",
+    {
+      snippet_id: addedSnippet.snippet_id,
+    },
+    {
+      headers: {
+        Authorization: "Bearer 1234",
+      },
+    },
+  )
+
+  // Try to star again
+  try {
+    await axios.post(
+      "/api/snippets/add_star",
+      {
+        snippet_id: addedSnippet.snippet_id,
+      },
+      {
+        headers: {
+          Authorization: "Bearer 1234",
+        },
+      },
+    )
+    expect(true).toBe(false) // Should not reach here
+  } catch (error: any) {
+    expect(error.status).toBe(400)
+    expect(error.data.error.message).toBe(
+      "You have already starred this snippet",
+    )
+  }
+})