@tscircuit/fake-snippets 0.0.1

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

@@ -0,0 +1,50 @@
+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: ["PATCH"],
+  auth: "session",
+  jsonBody: z.object({
+    order_id: z.string(),
+    updates: z.object({
+      is_draft: z.boolean().optional(),
+      is_pending_validation_by_fab: z.boolean().optional(),
+      is_pending_review_by_fab: z.boolean().optional(),
+      is_validated_by_fab: z.boolean().optional(),
+      is_approved_by_fab_review: z.boolean().optional(),
+      is_approved_by_orderer: z.boolean().optional(),
+      is_in_production: z.boolean().optional(),
+      is_shipped: z.boolean().optional(),
+      is_cancelled: z.boolean().optional(),
+      should_be_blank_pcb: z.boolean().optional(),
+      should_include_stencil: z.boolean().optional(),
+      jlcpcb_order_params: z.record(z.any()).optional(),
+      circuit_json: z.array(z.record(z.any())).optional(),
+    }),
+  }),
+  jsonResponse: z.object({
+    order: orderSchema,
+  }),
+})(async (req, ctx) => {
+  const { order_id, updates } = req.jsonBody
+
+  const existingOrder = ctx.db.getOrderById(order_id)
+  if (!existingOrder) {
+    return ctx.error(404, {
+      error_code: "order_not_found",
+      message: "Order not found",
+    })
+  }
+
+  ctx.db.updateOrder(order_id, {
+    ...updates,
+    updated_at: new Date().toISOString(),
+  })
+
+  const updatedOrder = ctx.db.getOrderById(order_id)!
+
+  return ctx.json({
+    order: updatedOrder,
+  })
+})

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

@@ -0,0 +1,42 @@
+import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
+import { z } from "zod"
+import { accountSnippetSchema } from "fake-snippets-api/lib/db/schema"
+
+export default withRouteSpec({
+  methods: ["POST"],
+  auth: "session",
+  jsonBody: z.object({
+    snippet_id: z.string(),
+  }),
+  jsonResponse: z.object({
+    ok: z.boolean(),
+    account_snippet: accountSnippetSchema,
+  }),
+})(async (req, ctx) => {
+  const { snippet_id } = req.jsonBody
+
+  // Check if snippet exists
+  const snippet = ctx.db.getSnippetById(snippet_id)
+  if (!snippet) {
+    return ctx.error(404, {
+      error_code: "snippet_not_found",
+      message: "Snippet not found",
+    })
+  }
+
+  // Check if already starred
+  if (ctx.db.hasStarred(ctx.auth.account_id, snippet_id)) {
+    return ctx.error(400, {
+      error_code: "already_starred",
+      message: "You have already starred this snippet",
+    })
+  }
+
+  // Add star
+  const accountSnippet = ctx.db.addStar(ctx.auth.account_id, snippet_id)
+
+  return ctx.json({
+    ok: true,
+    account_snippet: accountSnippet,
+  })
+})

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

@@ -0,0 +1,55 @@
+import { snippetSchema } from "fake-snippets-api/lib/db/schema"
+import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
+import { z } from "zod"
+
+export default withRouteSpec({
+  methods: ["POST"],
+  auth: "session",
+  jsonBody: z.object({
+    unscoped_name: z.string().optional(),
+    code: z.string().optional(),
+    snippet_type: z.enum(["board", "package", "model", "footprint"]),
+    description: z.string().optional(),
+    compiled_js: z.string().optional(),
+    circuit_json: z.array(z.record(z.any())).optional().nullable(),
+    dts: z.string().optional(),
+  }),
+  jsonResponse: z.object({
+    ok: z.boolean(),
+    snippet: snippetSchema,
+  }),
+})(async (req, ctx) => {
+  let {
+    unscoped_name,
+    code = "",
+    snippet_type,
+    description = "",
+    compiled_js,
+    circuit_json,
+    dts,
+  } = req.jsonBody
+  if (!unscoped_name) {
+    unscoped_name = `untitled-${snippet_type}-${ctx.db.idCounter + 1}`
+  }
+  const newSnippet: z.input<typeof snippetSchema> = {
+    snippet_id: `snippet_${ctx.db.idCounter + 1}`,
+    name: `${ctx.auth.github_username}/${unscoped_name}`,
+    unscoped_name,
+    owner_name: ctx.auth.github_username,
+    code,
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+    snippet_type,
+    description,
+    compiled_js,
+    circuit_json,
+    dts,
+  }
+
+  ctx.db.addSnippet(newSnippet)
+
+  return ctx.json({
+    ok: true,
+    snippet: newSnippet as any,
+  })
+})

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

@@ -0,0 +1,41 @@
+import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
+import { z } from "zod"
+
+export default withRouteSpec({
+  methods: ["POST"],
+  auth: "session",
+  jsonBody: z.object({
+    snippet_id: z.string(),
+  }),
+  jsonResponse: z.object({
+    ok: z.boolean(),
+  }),
+})(async (req, ctx) => {
+  const { snippet_id } = req.jsonBody
+
+  const snippetIndex = ctx.db.snippets.findIndex(
+    (s) => s.snippet_id === snippet_id,
+  )
+
+  if (snippetIndex === -1) {
+    return ctx.error(404, {
+      error_code: "snippet_not_found",
+      message: "Snippet not found",
+    })
+  }
+
+  const snippet = ctx.db.snippets[snippetIndex]
+
+  if (snippet.owner_name !== ctx.auth.github_username) {
+    return ctx.error(403, {
+      error_code: "forbidden",
+      message: "You don't have permission to delete this snippet",
+    })
+  }
+
+  ctx.db.snippets.splice(snippetIndex, 1)
+
+  return ctx.json({
+    ok: true,
+  })
+})

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

@@ -0,0 +1,148 @@
+import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
+import { z } from "zod"
+
+export default withRouteSpec({
+  methods: ["GET"],
+  auth: "none",
+  queryParams: z.object({
+    jsdelivr_resolve: z
+      .enum(["true", "false"])
+      .optional()
+      .transform((v) => v === "true"),
+    jsdelivr_path: z.string(),
+  }),
+  jsonResponse: z.any(),
+})(async (req, ctx) => {
+  const { jsdelivr_path, jsdelivr_resolve } = req.query
+
+  // Parse the file path
+  const [owner, packageWithVersion, ...rest] = jsdelivr_path.split("/")
+  const [packageName, version] = packageWithVersion.split("@")
+  const fileName = rest.join("/")
+
+  // Find the snippet
+  const snippet = ctx.db.snippets.find(
+    (s) => s.owner_name === owner && s.unscoped_name === packageName,
+  )
+
+  if (!snippet) {
+    return ctx.error(404, {
+      error_code: "snippet_not_found",
+      message: "Snippet not found",
+    })
+  }
+
+  if (!fileName && !jsdelivr_resolve) {
+    return new Response(
+      JSON.stringify({
+        tags: {
+          latest: "0.0.1",
+        },
+        versions: ["0.0.1"],
+      }),
+      {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      },
+    )
+  } else if (!fileName && jsdelivr_resolve) {
+    return new Response(
+      JSON.stringify({
+        version: "0.0.1",
+      }),
+      {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      },
+    )
+  }
+
+  // If no fileName is provided, return the directory listing
+  if (!fileName || fileName === "flat") {
+    const files = [
+      {
+        type: "file",
+        name: "index.ts",
+        hash: "placeholder_hash",
+        time: snippet.updated_at,
+        size: snippet.code.length,
+      },
+      {
+        type: "file",
+        name: "index.d.ts",
+        hash: "placeholder_hash",
+        time: snippet.updated_at,
+        size: (snippet.dts || "").length,
+      },
+      {
+        type: "file",
+        name: "package.json",
+        hash: "placeholder_hash",
+        time: snippet.updated_at,
+        size: JSON.stringify({
+          name: `@tsci/${owner}.${packageName}`,
+          version: version || "0.0.1",
+          main: "index.ts",
+          types: "index.d.ts",
+        }).length,
+      },
+    ]
+
+    const response = {
+      default: "/index.ts",
+      files:
+        fileName === "flat"
+          ? files.map((f) => ({
+              name: `/${f.name}`,
+              hash: f.hash,
+              time: f.time,
+              size: f.size,
+            }))
+          : [
+              {
+                type: "directory",
+                name: ".",
+                files: files,
+              },
+            ],
+    }
+
+    return new Response(JSON.stringify(response, null, 2), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    })
+  }
+
+  // Handle file downloads
+  let content: string
+  switch (fileName) {
+    case "index.ts":
+      content = snippet.code
+      break
+    case "index.d.ts":
+      content = snippet.dts || ""
+      break
+    case "package.json":
+      content = JSON.stringify(
+        {
+          name: `@tsci/${owner}.${packageName}`,
+          version: version || "0.0.1",
+          main: "index.ts",
+          types: "index.d.ts",
+        },
+        null,
+        2,
+      )
+      break
+    default:
+      return ctx.error(404, {
+        error_code: "file_not_found",
+        message: "Requested file not found",
+      })
+  }
+
+  return new Response(content, {
+    status: 200,
+    headers: { "Content-Type": "text/plain" },
+  })
+})

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

@@ -0,0 +1,55 @@
+import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
+import { z } from "zod"
+import { snippetSchema } from "fake-snippets-api/lib/db/schema"
+import { fetchEasyEDAComponent, convertRawEasyEdaToTs } from "easyeda"
+
+export default withRouteSpec({
+  methods: ["POST"],
+  auth: "session",
+  jsonBody: z.object({
+    jlcpcb_part_number: z.string(),
+  }),
+  jsonResponse: z.object({
+    snippet: snippetSchema,
+  }),
+})(async (req, ctx) => {
+  const { jlcpcb_part_number } = req.jsonBody
+
+  try {
+    // Fetch the EasyEDA component data
+    const rawEasyJson = await fetchEasyEDAComponent(jlcpcb_part_number).catch(
+      (e) => {
+        throw new Error(`Error in fetchEasyEDAComponent: ${e.toString()}`)
+      },
+    )
+
+    // Convert to TypeScript React component
+    const tsxComponent = await convertRawEasyEdaToTs(rawEasyJson).catch((e) => {
+      throw new Error(`Error in convertRawEasyEdaToTs ${e.toString()}`)
+    })
+
+    // Create a new snippet
+    const newSnippet = {
+      snippet_id: `snippet_${ctx.db.idCounter + 1}`,
+      name: `${ctx.auth.github_username}/${jlcpcb_part_number}`,
+      unscoped_name: jlcpcb_part_number,
+      owner_name: ctx.auth.github_username,
+      code: tsxComponent,
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString(),
+      snippet_type: "package",
+      description: `Generated from JLCPCB part number ${jlcpcb_part_number}`,
+    }
+
+    ctx.db.addSnippet(newSnippet as any)
+
+    return ctx.json({
+      snippet: newSnippet as any,
+    })
+  } catch (error: any) {
+    return ctx.error(500, {
+      error_code: "jlcpcb_generation_failed",
+      message: `Failed to generate snippet from JLCPCB part: ${error.message}\n\n${error.stack}`,
+    })
+  }
+})

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

@@ -0,0 +1,50 @@
+import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
+import { z } from "zod"
+import { snippetSchema } from "fake-snippets-api/lib/db/schema"
+
+export default withRouteSpec({
+  methods: ["GET", "POST"],
+  auth: "optional_session",
+  commonParams: z.object({
+    snippet_id: z.string().optional(),
+    name: z.string().optional(),
+    owner_name: z.string().optional(),
+    unscoped_name: z.string().optional(),
+  }),
+  jsonBody: z.any().optional(),
+  jsonResponse: z.object({
+    ok: z.boolean(),
+    snippet: snippetSchema,
+  }),
+})(async (req, ctx) => {
+  const { snippet_id, name, owner_name, unscoped_name } = req.commonParams
+
+  const foundSnippet =
+    (snippet_id && ctx.db.getSnippetById(snippet_id)) ||
+    ctx.db.snippets.find((s) => {
+      if (name && s.name !== name) return false
+      if (owner_name && s.owner_name !== owner_name) return false
+      if (unscoped_name && s.unscoped_name !== unscoped_name) return false
+      return true
+    })
+
+  if (!foundSnippet) {
+    return ctx.error(404, {
+      error_code: "snippet_not_found",
+      message: `Snippet not found (searched using ${JSON.stringify(req.commonParams)})`,
+    })
+  }
+
+  if (ctx.auth) {
+    const starred = ctx.db.hasStarred(
+      ctx.auth.account_id,
+      foundSnippet.snippet_id,
+    )
+    foundSnippet.is_starred = starred
+  }
+
+  return ctx.json({
+    ok: true,
+    snippet: foundSnippet,
+  })
+})

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

@@ -0,0 +1,65 @@
+import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
+import { z } from "zod"
+import {
+  convertCircuitJsonToSchematicSvg,
+  convertCircuitJsonToPcbSvg,
+} from "circuit-to-svg"
+import { AnyCircuitElement } from "circuit-json"
+
+export default withRouteSpec({
+  methods: ["GET"],
+  auth: "none",
+  queryParams: z.object({
+    snippetId: z.string(),
+    image_of: z.enum(["schematic", "pcb"]),
+    format: z.enum(["svg"]),
+  }),
+  jsonResponse: z.object({
+    ok: z.boolean(),
+    svg: z.string(),
+  }),
+})(async (req, ctx) => {
+  const { snippetId, image_of, format } = req.query
+
+  const snippet = ctx.db.getSnippetById(snippetId)
+
+  // check if the snippet exists
+  if (!snippet) {
+    return ctx.error(404, {
+      error_code: "snippet_not_found",
+      message: "Snippet not found",
+    })
+  }
+
+  // Check if the format is valid
+  if (format !== "svg") {
+    return ctx.error(400, {
+      error_code: "invalid_format",
+      message: "Format must be 'svg'",
+    })
+  }
+
+  if (image_of === "schematic") {
+    const circuitJson = snippet.circuit_json as AnyCircuitElement[]
+    const svg = convertCircuitJsonToSchematicSvg(circuitJson)
+    return ctx.json({
+      ok: true,
+      svg,
+    })
+  }
+
+  if (image_of === "pcb") {
+    const svg = convertCircuitJsonToPcbSvg(
+      snippet.circuit_json as AnyCircuitElement[],
+    )
+    return ctx.json({
+      ok: true,
+      svg,
+    })
+  }
+
+  return ctx.error(400, {
+    error_code: "INVALID_REQUEST_TYPE",
+    message: "Request type must be either 'schematic' or 'pcb'",
+  })
+})

package/fake-snippets-api/routes/api/snippets/images/[author]/[snippet_name]/[typeFormat].ts

@@ -0,0 +1,74 @@
+import { AnyCircuitElement } from "circuit-json"
+import {
+  convertCircuitJsonToPcbSvg,
+  convertCircuitJsonToSchematicSvg,
+} from "circuit-to-svg"
+import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
+import { z } from "zod"
+
+export default withRouteSpec({
+  methods: ["GET"],
+  auth: "none",
+  routeParams: z.object({
+    author: z.string(),
+    snippet_name: z.string(),
+    typeFormat: z.string(),
+  }),
+  rawResponse: true,
+})(async (req, ctx) => {
+  const { author, snippet_name, typeFormat } = req.routeParams
+
+  // Get the snippet
+  const name = author + "/" + snippet_name
+  const snippet = ctx.db.getSnippetByAuthorAndName(author, name)
+
+  // If snippet is not found, return 404
+  if (!snippet) {
+    return ctx.error(404, {
+      error_code: "snippet_not_found",
+      message: "Snippet not found",
+    })
+  }
+
+  // Check if the format is valid
+  const format = typeFormat.split(".")[1]
+  if (format !== "svg") {
+    return ctx.error(400, {
+      error_code: "invalid_format",
+      message: "Format must be 'svg'",
+    })
+  }
+
+  // Check if the type is valid
+  const type = typeFormat.split(".")[0]
+  if (type !== "schematic" && type !== "pcb") {
+    return ctx.error(400, {
+      error_code: "invalid_type",
+      message: "Type must be 'schematic' or 'pcb'",
+    })
+  }
+
+  // Convert circuit json to svg
+  let svg: string
+  if (type === "schematic") {
+    svg = convertCircuitJsonToSchematicSvg(
+      snippet.circuit_json as AnyCircuitElement[],
+    )
+  } else if (type === "pcb") {
+    svg = convertCircuitJsonToPcbSvg(
+      snippet.circuit_json as AnyCircuitElement[],
+    )
+  } else {
+    return ctx.error(500, {
+      error_code: "unknown_error",
+      message: "Unknown error",
+    })
+  }
+
+  return new Response(svg, {
+    headers: {
+      "Content-Type": "image/svg+xml",
+      "Cache-Control": "public, max-age=31536000",
+    },
+  })
+})

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

@@ -0,0 +1,28 @@
+import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
+import { z } from "zod"
+import { snippetSchema } from "fake-snippets-api/lib/db/schema"
+
+export default withRouteSpec({
+  methods: ["GET", "POST"],
+  auth: "none",
+  commonParams: z.object({
+    owner_name: z.string().optional(),
+    unscoped_name: z.string().optional(),
+  }),
+  jsonBody: z.any().optional(),
+  jsonResponse: z.object({
+    ok: z.boolean(),
+    snippets: z.array(snippetSchema),
+  }),
+})(async (req, ctx) => {
+  const { owner_name, unscoped_name } = req.commonParams
+
+  const snippets = ctx.db
+    .getSnippetsByAuthor(owner_name)
+    .filter((s) => !unscoped_name || s.unscoped_name === unscoped_name)
+
+  return ctx.json({
+    ok: true,
+    snippets,
+  })
+})

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

@@ -0,0 +1,13 @@
+import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
+import { z } from "zod"
+import { snippetSchema } from "fake-snippets-api/lib/db/schema"
+
+export default withRouteSpec({
+  methods: ["GET"],
+  jsonResponse: z.object({
+    snippets: z.array(snippetSchema),
+  }),
+})(async (req, ctx) => {
+  const newestSnippets = ctx.db.getNewestSnippets(20)
+  return ctx.json({ snippets: newestSnippets })
+})

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

@@ -0,0 +1,21 @@
+import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
+import { z } from "zod"
+import { snippetSchema } from "fake-snippets-api/lib/db/schema"
+
+export default withRouteSpec({
+  methods: ["GET"],
+  auth: "none",
+  jsonResponse: z.object({
+    snippets: z.array(snippetSchema),
+  }),
+})(async (req, ctx) => {
+  // Get trending snippets from last 7 days
+  const sevenDaysAgo = new Date()
+  sevenDaysAgo.setDate(sevenDaysAgo.getDate() - 7)
+
+  const trendingSnippets = ctx.db.getTrendingSnippets(
+    20,
+    sevenDaysAgo.toISOString(),
+  )
+  return ctx.json({ snippets: trendingSnippets })
+})

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

@@ -0,0 +1,42 @@
+import { accountSnippetSchema } from "fake-snippets-api/lib/db/schema"
+import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
+import { z } from "zod"
+
+export default withRouteSpec({
+  methods: ["POST"],
+  auth: "session",
+  jsonBody: z.object({
+    snippet_id: z.string(),
+  }),
+  jsonResponse: z.object({
+    ok: z.boolean(),
+    is_starred: z.boolean(),
+  }),
+})(async (req, ctx) => {
+  const { snippet_id } = req.jsonBody
+
+  // Check if snippet exists
+  const snippet = ctx.db.getSnippetById(snippet_id)
+  if (!snippet) {
+    return ctx.error(404, {
+      error_code: "snippet_not_found",
+      message: "Snippet not found",
+    })
+  }
+
+  // check if not already starred
+  if (!ctx.db.hasStarred(ctx.auth.account_id, snippet_id)) {
+    return ctx.error(400, {
+      error_code: "not_starred",
+      message: "You have not starred this snippet",
+    })
+  }
+
+  // Remove star
+  ctx.db.removeStar(ctx.auth.account_id, snippet_id)
+
+  return ctx.json({
+    ok: true,
+    is_starred: false,
+  })
+})