@tscircuit/fake-snippets 0.0.121 → 0.0.123

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

@@ -1,70 +0,0 @@
-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({
-      package_id: z.string(),
-    })
-    .or(z.object({ name: z.string() })),
-  jsonResponse: z.object({
-    ok: z.boolean(),
-  }),
-})(async (req, ctx) => {
-  let packageId: string
-
-  // Get package ID either directly or by name
-  if ("package_id" in req.jsonBody) {
-    const body = req.jsonBody
-    packageId = body.package_id
-  } else {
-    // If name is provided, look up the package_id
-    const body = req.jsonBody
-    const packageData = ctx.db.packages.find((pkg) => pkg.name === body.name)
-
-    if (!packageData) {
-      return ctx.error(404, {
-        error_code: "package_not_found",
-        message: "Package not found",
-      })
-    }
-
-    packageId = packageData.package_id
-  }
-
-  // Check if package exists (extra check for ID-based lookup)
-  const pkg = ctx.db.packages.find((p) => p.package_id === packageId)
-
-  if (!pkg) {
-    return ctx.error(404, {
-      error_code: "package_not_found",
-      message: "Package not found",
-    })
-  }
-
-  // Check if already starred
-  const existing = ctx.db.accountPackages.find(
-    (ap) =>
-      ap.account_id === ctx.auth.account_id && ap.package_id === packageId,
-  )
-
-  if (!existing?.is_starred) {
-    return ctx.error(400, {
-      error_code: "not_starred",
-      message: "You have not starred this package",
-    })
-  }
-
-  // Update the package's star count
-  pkg.star_count = Math.max(0, (pkg.star_count || 0) - 1)
-
-  // Remove star by updating is_starred to false
-  existing.is_starred = false
-  existing.updated_at = new Date().toISOString()
-
-  return ctx.json({
-    ok: true,
-  })
-})

package/fake-snippets-api/routes/api/packages/search.ts

@@ -1,19 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-import { packageSchema } from "fake-snippets-api/lib/db/schema"
-
-export default withRouteSpec({
-  methods: ["POST"],
-  auth: "none",
-  jsonBody: z.object({
-    query: z.string(),
-  }),
-  jsonResponse: z.object({
-    ok: z.boolean(),
-    packages: z.array(packageSchema),
-  }),
-})(async (req, ctx) => {
-  const { query } = req.jsonBody
-  const packages = ctx.db.searchPackages(query)
-  return ctx.json({ packages, ok: true })
-})

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

@@ -1,112 +0,0 @@
-import { z } from "zod"
-import { packageSchema } from "../../../lib/db/schema"
-import { withRouteSpec } from "../../../lib/middleware/with-winter-spec"
-
-export default withRouteSpec({
-  methods: ["POST"],
-  auth: "session",
-  jsonBody: z
-    .object({
-      package_id: z.string(),
-      name: z
-        .string()
-        .regex(
-          /^[@a-zA-Z0-9-_\/]+$/,
-          "Package name can only contain letters, numbers, hyphens, underscores, and forward slashes",
-        )
-        .transform((name) => name.replace(/^@/, ""))
-        .optional(),
-      description: z.string().optional(),
-      website: z.string().optional(),
-      github_repo_full_name: z.string().nullable().optional(),
-      is_private: z.boolean().optional(),
-      is_unlisted: z.boolean().optional(),
-      default_view: z.enum(["files", "3d", "pcb", "schematic"]).optional(),
-      allow_pr_previews: z.boolean().optional(),
-    })
-    .transform((data) => ({
-      ...data,
-      is_unlisted: data.is_private ? true : data.is_unlisted,
-    })),
-  jsonResponse: z.object({
-    ok: z.boolean(),
-    package: packageSchema,
-  }),
-})(async (req, ctx) => {
-  const {
-    package_id,
-    name,
-    description,
-    website,
-    is_private,
-    is_unlisted,
-    github_repo_full_name,
-    default_view,
-    allow_pr_previews,
-  } = req.jsonBody
-
-  const packageIndex = ctx.db.packages.findIndex(
-    (p) => p.package_id === package_id,
-  )
-
-  if (packageIndex === -1) {
-    return ctx.error(404, {
-      error_code: "package_not_found",
-      message: "Package not found",
-    })
-  }
-
-  const existingPackage = ctx.db.packages[packageIndex]
-
-  // Check if user has permission to update the package
-  if (existingPackage.owner_github_username !== ctx.auth.github_username) {
-    return ctx.error(403, {
-      error_code: "forbidden",
-      message: "You don't have permission to update this package",
-    })
-  }
-
-  // Check for duplicate package name if name is being updated
-  if (name) {
-    const newFullName = `${ctx.auth.github_username}/${name}`
-    const duplicatePackage = ctx.db.packages.find(
-      (p) => p.name === newFullName && p.package_id !== package_id,
-    )
-    if (duplicatePackage) {
-      return ctx.error(400, {
-        error_code: "package_already_exists",
-        message: "A package with this name already exists",
-      })
-    }
-  }
-
-  const updatedPackage = ctx.db.updatePackage(package_id, {
-    name: name ? `${ctx.auth.github_username}/${name}` : existingPackage.name,
-    description: description ?? existingPackage.description,
-    unscoped_name: name ?? existingPackage.unscoped_name,
-    website: website ?? existingPackage.website,
-    github_repo_full_name:
-      github_repo_full_name === null
-        ? null
-        : (github_repo_full_name ?? existingPackage.github_repo_full_name),
-    is_private: is_private ?? existingPackage.is_private,
-    is_public:
-      is_private !== undefined ? !is_private : existingPackage.is_public,
-    is_unlisted: is_unlisted ?? existingPackage.is_unlisted,
-    default_view: default_view ?? existingPackage.default_view,
-    updated_at: new Date().toISOString(),
-    allow_pr_previews: allow_pr_previews ?? existingPackage.allow_pr_previews,
-  })
-
-  if (!updatedPackage) {
-    return ctx.error(500, {
-      error_code: "update_failed",
-      message: "Failed to update package",
-    })
-  }
-
-  return ctx.json({
-    ok: true,
-    package: updatedPackage,
-  })
-})

package/fake-snippets-api/routes/api/packages/update_ai_description.ts

@@ -1,37 +0,0 @@
-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({
-    package_id: z.string(),
-  }),
-  jsonResponse: z.object({
-    success: z.boolean(),
-  }),
-})(async (req, ctx) => {
-  const { package_id } = req.jsonBody
-
-  const package_info = ctx.db.getPackageById(package_id)
-  if (!package_info) {
-    return ctx.error(404, {
-      error_code: "package_not_found",
-      message: "Package not found",
-    })
-  }
-
-  if (package_info.owner_github_username !== ctx.auth.github_username) {
-    return ctx.error(403, {
-      error_code: "unauthorized",
-      message: "Only the package owner can update AI description",
-    })
-  }
-
-  ctx.db.updatePackage(package_id, {
-    ai_description: "New ai description",
-    ai_usage_instructions: "New ai usage instructions",
-  })
-
-  return ctx.json({ success: true })
-})

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

@@ -1,128 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-
-const PROXY_HEADERS = [
-  "X-Target-Url",
-  "X-Sender-Origin",
-  "X-Sender-Host",
-  "X-Sender-Referer",
-  "X-Sender-User-Agent",
-  "X-Sender-Cookie",
-]
-
-const ALLOWED_DOMAINS: Array<{ domain: string; routes?: string[] }> = [
-  { domain: "easyeda.com" },
-]
-
-function isAllowedDomain(url: string) {
-  try {
-    const { hostname, pathname, port } = new URL(url)
-    const allowedDomain = ALLOWED_DOMAINS.find(
-      (domain) => domain.domain === hostname,
-    )
-
-    if (allowedDomain) {
-      if (
-        !allowedDomain.routes ||
-        allowedDomain.routes.some((route) => pathname.startsWith(route))
-      ) {
-        return true
-      }
-    }
-
-    return hostname === "localhost" || (hostname === "127.0.0.1" && port)
-  } catch {
-    return false
-  }
-}
-
-export default withRouteSpec({
-  methods: ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"],
-  jsonResponse: z.any(),
-  auth: "session",
-})(async (req, ctx) => {
-  if (req.headers.get("X-proxied")) {
-    return ctx.json(
-      { error: "Recursive proxy calls are not allowed" },
-      { status: 403 },
-    )
-  }
-
-  const targetUrl = req.headers.get("X-Target-Url")
-
-  if (!targetUrl) {
-    return ctx.json(
-      { error: "X-Target-Url header is required" },
-      { status: 400 },
-    )
-  }
-
-  if (!isAllowedDomain(targetUrl)) {
-    return ctx.json({ error: "Domain not allowed" }, { status: 403 })
-  }
-
-  let body: string | undefined
-  if (["POST", "PUT", "PATCH"].includes(req.method)) {
-    body = await req.clone().text()
-  }
-
-  const headers = new Headers(req.headers)
-
-  const senderOrigin = req.headers.get("X-Sender-Origin")
-  if (senderOrigin) {
-    headers.set("Origin", senderOrigin)
-  }
-
-  const senderHost = req.headers.get("X-Sender-Host")
-  if (senderHost) {
-    const hostValue = senderHost.replace(/^https?:\/\//, "")
-    headers.set("Host", hostValue)
-    headers.set("authority", hostValue)
-  }
-
-  const senderReferer = req.headers.get("X-Sender-Referer")
-  if (senderReferer) {
-    headers.set("Referer", senderReferer)
-  }
-
-  const senderUserAgent = req.headers.get("X-Sender-User-Agent")
-  if (senderUserAgent) {
-    headers.set("User-Agent", senderUserAgent)
-  }
-
-  const senderCookie = req.headers.get("X-Sender-Cookie")
-  if (senderCookie) {
-    headers.set("Cookie", senderCookie)
-  }
-
-  for (const header of PROXY_HEADERS) {
-    headers.delete(header)
-  }
-
-  headers.delete("content-encoding")
-  headers.delete("accept-encoding")
-  headers.set("X-proxied", "true")
-
-  try {
-    const response = await fetch(targetUrl, {
-      method: req.method,
-      headers: headers,
-      body: ["GET", "HEAD"].includes(req.method) ? undefined : body,
-    })
-
-    const responseHeaders = new Headers(response.headers)
-    responseHeaders.delete("content-encoding")
-
-    return new Response(response.body, {
-      status: response.status,
-      statusText: response.statusText,
-      headers: responseHeaders,
-    })
-  } catch (error) {
-    console.error("Proxy error:", error)
-    return ctx.json(
-      { error: { message: "Failed to proxy request" } },
-      { status: 502 },
-    )
-  }
-})

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

@@ -1,62 +0,0 @@
-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
-
-  // Check if snippet exists (as a package)
-  const snippet = ctx.db.packages.find(
-    (pkg) => pkg.package_id === snippet_id && pkg.is_snippet === true,
-  )
-
-  if (!snippet) {
-    return ctx.error(404, {
-      error_code: "snippet_not_found",
-      message: "Snippet not found",
-    })
-  }
-
-  // Check if already starred
-  const existing = ctx.db.accountPackages.find(
-    (ap) =>
-      ap.account_id === ctx.auth.account_id && ap.package_id === snippet_id,
-  )
-
-  if (existing?.is_starred) {
-    return ctx.error(400, {
-      error_code: "already_starred",
-      message: "You have already starred this snippet",
-    })
-  }
-
-  // Update the package's star count
-  snippet.star_count = (snippet.star_count || 0) + 1
-
-  if (existing) {
-    // If record exists but is_starred is false, update to is_starred=true
-    existing.is_starred = true
-    existing.updated_at = new Date().toISOString()
-  } else {
-    // Add star by creating a new account_package record
-    ctx.db.addAccountPackage({
-      account_id: ctx.auth.account_id,
-      package_id: snippet_id,
-      is_starred: true,
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
-    })
-  }
-
-  return ctx.json({
-    ok: true,
-  })
-})

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

@@ -1,184 +0,0 @@
-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(),
-    is_private: z.boolean().optional(),
-    is_public: z.boolean().optional(),
-    is_unlisted: z.boolean().optional(),
-  }),
-  jsonResponse: z.object({
-    ok: z.boolean(),
-    snippet: snippetSchema.optional(),
-  }),
-})(async (req, ctx) => {
-  let {
-    unscoped_name,
-    code = "",
-    snippet_type,
-    description = "",
-    compiled_js,
-    circuit_json,
-    dts,
-    is_private,
-    is_public,
-    is_unlisted,
-  } = req.jsonBody
-
-  const timestamp = Date.now()
-  const currentTime = new Date(timestamp).toISOString()
-
-  if (!unscoped_name) {
-    // Count snippets of this type for this user
-    const userSnippets = ctx.db.packages.filter(
-      (p) =>
-        p.owner_github_username === ctx.auth.github_username &&
-        p.is_snippet === true &&
-        ((p.is_board && snippet_type === "board") ||
-          (p.is_package && snippet_type === "package") ||
-          (p.is_model && snippet_type === "model") ||
-          (p.is_footprint && snippet_type === "footprint")),
-    )
-    unscoped_name = `untitled-${snippet_type}-${userSnippets.length + 1}`
-  }
-
-  const existingPackage = ctx.db.packages.find(
-    (pkg) =>
-      pkg.unscoped_name === unscoped_name &&
-      pkg.owner_github_username === ctx.auth.github_username,
-  )
-
-  if (existingPackage) {
-    return ctx.error(400, {
-      error_code: "snippet_already_exists",
-      message: "You have already forked this snippet in your account.",
-    })
-  }
-
-  try {
-    // Create the package directly (which will serve as our snippet)
-    const newPackage = ctx.db.addPackage({
-      creator_account_id: ctx.auth.account_id,
-      owner_org_id: ctx.auth.personal_org_id,
-      owner_github_username: ctx.auth.github_username,
-      is_source_from_github: false,
-      description: description,
-      name: `${ctx.auth.github_username}/${unscoped_name}`,
-      unscoped_name: unscoped_name,
-      latest_version: "0.0.1",
-      license: null,
-      star_count: 0,
-      created_at: currentTime,
-      updated_at: currentTime,
-      ai_description: null,
-      is_snippet: true,
-      is_board: snippet_type === "board",
-      is_package: snippet_type === "package",
-      is_model: snippet_type === "model",
-      is_footprint: snippet_type === "footprint",
-      snippet_type: snippet_type,
-      is_private: is_private || false,
-      is_public: is_public || true,
-      is_unlisted: is_unlisted || false,
-      latest_package_release_id: null,
-      ai_usage_instructions: "placeholder ai usage instructions",
-    })
-
-    const newPackageRelease = ctx.db.addPackageRelease({
-      package_id: newPackage.package_id,
-      version: "0.0.1",
-      is_latest: true,
-      is_locked: false,
-      created_at: currentTime,
-      // Setting the transpiled as true on creation
-      has_transpiled: true,
-      transpilation_error: null,
-    })
-
-    ctx.db.updatePackage(newPackage.package_id, {
-      latest_package_release_id: newPackageRelease.package_release_id,
-    })
-
-    // Add package files
-    // Add index.tsx file with the code content
-    ctx.db.addPackageFile({
-      package_release_id: newPackageRelease.package_release_id,
-      file_path: "index.tsx",
-      content_text: code,
-      created_at: currentTime,
-    })
-
-    // Add DTS file if provided
-    if (dts) {
-      ctx.db.addPackageFile({
-        package_release_id: newPackageRelease.package_release_id,
-        file_path: "/dist/index.d.ts",
-        content_text: dts,
-        created_at: currentTime,
-      })
-    }
-
-    // Add compiled JS if provided
-    if (compiled_js) {
-      ctx.db.addPackageFile({
-        package_release_id: newPackageRelease.package_release_id,
-        file_path: "/dist/index.js",
-        content_text: compiled_js,
-        created_at: currentTime,
-      })
-    }
-
-    // Add circuit JSON if provided
-    if (circuit_json) {
-      ctx.db.addPackageFile({
-        package_release_id: newPackageRelease.package_release_id,
-        file_path: "/dist/circuit.json",
-        content_text: JSON.stringify(circuit_json),
-        created_at: currentTime,
-      })
-    }
-
-    // Create the snippet response object
-    const snippetResponse = {
-      snippet_id: newPackage.package_id,
-      package_release_id: newPackageRelease.package_release_id,
-      name: newPackage.name,
-      unscoped_name: newPackage.unscoped_name,
-      owner_name: ctx.auth.github_username,
-      code,
-      dts,
-      compiled_js,
-      star_count: 0,
-      created_at: currentTime,
-      updated_at: currentTime,
-      snippet_type: snippet_type,
-      circuit_json: circuit_json || [],
-      description: description,
-      is_starred: false,
-      version: "0.0.1",
-      is_private: is_private || false,
-      is_public: is_public || true,
-      is_unlisted: is_unlisted || false,
-    }
-
-    return ctx.json({
-      ok: true,
-      snippet: snippetResponse,
-    })
-  } catch (error) {
-    return ctx.error(500, {
-      error_code: "snippet_creation_failed",
-      message: `Failed to create snippet: ${error}`,
-    })
-  }
-})

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

@@ -1,41 +0,0 @@
-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.packages.findIndex(
-    (s) => s.package_id === snippet_id,
-  )
-
-  if (snippetIndex === -1) {
-    return ctx.error(404, {
-      error_code: "snippet_not_found",
-      message: "Snippet not found",
-    })
-  }
-
-  const snippet = ctx.db.packages[snippetIndex]
-
-  if (snippet.creator_account_id !== ctx.auth.github_username) {
-    return ctx.error(403, {
-      error_code: "forbidden",
-      message: "You don't have permission to delete this snippet",
-    })
-  }
-
-  ctx.db.packages.splice(snippetIndex, 1)
-
-  return ctx.json({
-    ok: true,
-  })
-})