@tscircuit/fake-snippets 0.0.3 → 0.0.5

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

@@ -0,0 +1,77 @@
+import { packageReleaseSchema } from "fake-snippets-api/lib/db/schema"
+import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
+import { publicMapPackageRelease } from "fake-snippets-api/lib/public-mapping/public-map-package-release"
+import { z } from "zod"
+
+export default withRouteSpec({
+  methods: ["POST"],
+  auth: "none",
+  jsonBody: z
+    .object({
+      package_id: z.string().optional(),
+      package_name: z.string().optional(),
+      is_latest: z.boolean().optional(),
+      version: z.string().optional(),
+      commit_sha: z.string().optional(),
+    })
+    .refine(({ package_id, package_name }) => {
+      if (package_id && package_name) {
+        return false
+      }
+      return true
+    }, "package_id and package_name are mutually exclusive")
+    .refine(({ package_id, package_name }) => {
+      if (!package_id && !package_name) {
+        return false
+      }
+      return true
+    }, "package_id or package_name is required"),
+  jsonResponse: z.object({
+    ok: z.boolean(),
+    package_releases: z.array(packageReleaseSchema),
+  }),
+})(async (req, ctx) => {
+  const { package_id, package_name, is_latest, version, commit_sha } =
+    req.jsonBody
+
+  if (!package_id && !package_name && !is_latest && !version && !commit_sha) {
+    return ctx.error(400, {
+      error_code: "invalid_query",
+      message:
+        "At least one of package_id, package_name, is_latest, version or commit_sha is required",
+    })
+  }
+
+  let releases = ctx.db.packageReleases
+
+  // Apply filters
+  if (package_id) {
+    releases = releases.filter((pr) => pr.package_id === package_id)
+  }
+
+  if (package_name) {
+    const pkg = ctx.db.packages.find((p) => p.name === package_name)
+    if (pkg) {
+      releases = releases.filter((pr) => pr.package_id === pkg.package_id)
+    } else {
+      releases = []
+    }
+  }
+
+  if (is_latest !== undefined) {
+    releases = releases.filter((pr) => pr.is_latest === is_latest)
+  }
+
+  if (version) {
+    releases = releases.filter((pr) => pr.version === version)
+  }
+
+  if (commit_sha) {
+    releases = releases.filter((pr) => pr.commit_sha === commit_sha)
+  }
+
+  return ctx.json({
+    ok: true,
+    package_releases: releases.map((pr) => publicMapPackageRelease(pr)),
+  })
+})

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

@@ -0,0 +1,96 @@
+import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
+import { z } from "zod"
+
+export default withRouteSpec({
+  methods: ["POST"],
+  auth: "none",
+  jsonBody: z.object({
+    package_release_id: z.string().optional(),
+    package_name_with_version: z.string().optional(),
+    is_locked: z.boolean().optional(),
+    is_latest: z.boolean().optional(),
+    license: z.string().optional(),
+  }),
+  jsonResponse: z.object({
+    ok: z.boolean(),
+  }),
+})(async (req, ctx) => {
+  const {
+    package_release_id,
+    package_name_with_version,
+    is_locked,
+    is_latest,
+    license,
+  } = req.jsonBody
+  let releaseId = package_release_id
+
+  // Handle package_name_with_version lookup
+  if (!releaseId && package_name_with_version) {
+    const [packageName, version] = package_name_with_version.split("@")
+    const pkg = ctx.db.packages.find((p) => p.name === packageName)
+    if (pkg) {
+      const release = ctx.db.packageReleases.find(
+        (pr) => pr.package_id === pkg.package_id && pr.version === version,
+      )
+      if (release) {
+        releaseId = release.package_release_id
+      }
+    }
+  }
+
+  if (!releaseId) {
+    return ctx.error(404, {
+      error_code: "package_release_not_found",
+      message: "Package release not found",
+    })
+  }
+
+  const delta = { is_locked, is_latest, license }
+  if (
+    Object.keys(delta).filter(
+      (k) => delta[k as keyof typeof delta] !== undefined,
+    ).length === 0
+  ) {
+    return ctx.error(400, {
+      error_code: "no_fields_provided",
+      message: "No fields provided to update",
+    })
+  }
+
+  const release = ctx.db.packageReleases.find(
+    (pr) => pr.package_release_id === releaseId,
+  )
+  if (!release) {
+    return ctx.error(404, {
+      error_code: "package_release_not_found",
+      message: "Package release not found",
+    })
+  }
+
+  // Handle is_latest updates
+  if (is_latest !== undefined && is_latest) {
+    ctx.db.packageReleases
+      .filter(
+        (pr) =>
+          pr.package_id === release.package_id &&
+          pr.package_release_id !== releaseId &&
+          pr.is_latest,
+      )
+      .forEach((pr) => {
+        pr.is_latest = false
+      })
+  }
+
+  // Update the release
+  Object.assign(release, {
+    ...(is_locked !== undefined && { is_locked }),
+    ...(is_latest !== undefined && { is_latest }),
+    ...(license !== undefined && { license }),
+  })
+
+  ctx.db.updatePackageRelease(release)
+
+  return ctx.json({
+    ok: true,
+  })
+})

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

@@ -0,0 +1,58 @@
+import { packageSchema } from "fake-snippets-api/lib/db/schema"
+import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
+import { publicMapPackage } from "fake-snippets-api/lib/public-mapping/public-map-package"
+import { z } from "zod"
+
+export default withRouteSpec({
+  methods: ["POST"],
+  auth: "session",
+  jsonBody: z.object({
+    name: z
+      .string()
+      .regex(
+        /^[@a-zA-Z0-9-_\/]+$/,
+        "Package name can only contain letters, numbers, hyphens, underscores, and forward slashes",
+      )
+      .transform((name) => name.replace(/^@/, "")),
+    description: z.string().optional(),
+  }),
+  jsonResponse: z.object({
+    package: packageSchema.optional(),
+  }),
+})(async (req, ctx) => {
+  const { name, description } = req.jsonBody
+
+  const existingPackage = ctx.db.packages.find((pkg) => pkg.name === name)
+
+  if (existingPackage) {
+    throw ctx.error(400, {
+      error_code: "package_already_exists",
+      message: "A package with this name already exists",
+    })
+  }
+
+  const newPackage = ctx.db.addPackage({
+    name,
+    description: description ?? null,
+    creator_account_id: ctx.auth.account_id,
+    owner_org_id: ctx.auth.personal_org_id,
+    owner_github_username: ctx.auth.github_username,
+    latest_package_release_id: null,
+    latest_version: null,
+    license: null,
+    is_source_from_github: false,
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+    unscoped_name: name,
+    star_count: 0,
+    ai_description: name,
+  })
+
+  if (!newPackage) {
+    throw new Error("Failed to create package")
+  }
+
+  return ctx.json({
+    package: publicMapPackage(newPackage),
+  })
+})

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

@@ -0,0 +1,43 @@
+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({
+    ok: z.boolean(),
+  }),
+})(async (req, ctx) => {
+  const { package_id } = 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 pkg = ctx.db.packages[packageIndex]
+
+  console.log("pkg", pkg.owner_org_id, ctx.auth.personal_org_id)
+
+  if (pkg.owner_org_id !== ctx.auth.personal_org_id) {
+    return ctx.error(403, {
+      error_code: "forbidden",
+      message: "You don't have permission to delete this package",
+    })
+  }
+
+  ctx.db.packages.splice(packageIndex, 1)
+
+  return ctx.json({
+    ok: true,
+  })
+})

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

@@ -0,0 +1,36 @@
+import { packageSchema } from "fake-snippets-api/lib/db/schema"
+import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
+import { publicMapPackage } from "fake-snippets-api/lib/public-mapping/public-map-package"
+import { z } from "zod"
+
+export default withRouteSpec({
+  methods: ["GET", "POST"],
+  auth: "optional_session",
+  commonParams: z.object({
+    package_id: z.string().optional(),
+    name: z.string().optional(),
+  }),
+  jsonBody: z.any().optional(),
+  jsonResponse: z.object({
+    ok: z.boolean(),
+    package: packageSchema.optional(),
+  }),
+})(async (req, ctx) => {
+  const { package_id, name } = req.commonParams
+
+  const foundPackage =
+    (package_id && ctx.db.getPackageById(package_id)) ||
+    ctx.db.packages.find((p) => p.name === name)
+
+  if (!foundPackage) {
+    return ctx.error(404, {
+      error_code: "package_not_found",
+      message: `Package not found (searched using ${JSON.stringify(req.commonParams)})`,
+    })
+  }
+
+  return ctx.json({
+    ok: true,
+    package: publicMapPackage(foundPackage),
+  })
+})

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

@@ -0,0 +1,56 @@
+import { packageSchema } 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: ["GET", "POST"],
+  auth: "optional_session",
+  commonParams: z.object({
+    creator_account_id: z.string().optional(),
+    owner_github_username: z.string().optional(),
+    is_writable: z.boolean().optional(),
+    name: z.string().optional(),
+  }),
+  jsonResponse: z.object({
+    ok: z.boolean(),
+    packages: z.array(packageSchema),
+  }),
+})(async (req, ctx) => {
+  const { creator_account_id, owner_github_username, name, is_writable } =
+    req.commonParams
+
+  const auth = "auth" in ctx && ctx.auth ? ctx.auth : null
+
+  if (!auth && !is_writable && !creator_account_id && !owner_github_username) {
+    return ctx.error(400, {
+      error_code: "invalid_request",
+      message: "You must provide some filtering parameters or be logged in",
+    })
+  }
+
+  let packages = ctx.db.packages
+
+  // Apply filters
+  if (creator_account_id) {
+    packages = packages.filter(
+      (p) => p.creator_account_id === creator_account_id,
+    )
+  }
+  if (owner_github_username) {
+    packages = packages.filter(
+      (p) => p.owner_github_username === owner_github_username,
+    )
+  }
+  if (name) {
+    packages = packages.filter((p) => p.name === name)
+  }
+
+  if (is_writable && auth) {
+    packages = packages.filter((p) => p.owner_org_id === auth.personal_org_id)
+  }
+
+  return ctx.json({
+    ok: true,
+    packages,
+  })
+})

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

@@ -46,8 +46,10 @@ export default withRouteSpec({
     })
   }
 
-  const newSnippet: z.input<typeof snippetSchema> = {
-    snippet_id: `snippet_${ctx.db.idCounter + 1}`,
+  let newSnippet: Omit<
+    z.input<typeof snippetSchema>,
+    "snippet_id" | "package_release_id"
+  > = {
     name: `${ctx.auth.github_username}/${unscoped_name}`,
     unscoped_name,
     owner_name: ctx.auth.github_username,
@@ -62,7 +64,7 @@ export default withRouteSpec({
   }
 
   try {
-    ctx.db.addSnippet(newSnippet)
+    newSnippet = ctx.db.addSnippet(newSnippet)
   } catch (error) {
     return ctx.error(500, {
       error_code: "snippet_creation_failed",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/fake-snippets",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "type": "module",
   "repository": {
     "type": "git",
@@ -61,13 +61,13 @@
     "@radix-ui/react-toggle": "^1.1.0",
     "@radix-ui/react-toggle-group": "^1.1.0",
     "@radix-ui/react-tooltip": "^1.1.2",
-    "@tscircuit/3d-viewer": "^0.0.96",
-    "@tscircuit/footprinter": "^0.0.99",
+    "@tscircuit/3d-viewer": "^0.0.113",
+    "@tscircuit/footprinter": "^0.0.102",
     "@tscircuit/layout": "^0.0.29",
     "@tscircuit/math-utils": "^0.0.10",
     "@tscircuit/mm": "^0.0.8",
     "@tscircuit/pcb-viewer": "^1.11.12",
-    "@tscircuit/props": "^0.0.129",
+    "@tscircuit/props": "^0.0.138",
     "@tscircuit/schematic-viewer": "^1.4.3",
     "@types/file-saver": "^2.0.7",
     "@types/ms": "^0.7.34",
@@ -76,18 +76,19 @@
     "@valtown/codemirror-ts": "^2.2.0",
     "@vercel/analytics": "^1.4.1",
     "change-case": "^5.4.4",
-    "circuit-json": "^0.0.130",
+    "circuit-json": "^0.0.135",
     "circuit-json-to-bom-csv": "^0.0.6",
     "circuit-json-to-gerber": "^0.0.16",
     "circuit-json-to-pnp-csv": "^0.0.6",
-    "circuit-json-to-readable-netlist": "^0.0.5",
+    "circuit-json-to-tscircuit": "^0.0.4",
+    "circuit-json-to-readable-netlist": "^0.0.7",
     "class-variance-authority": "^0.7.0",
     "clsx": "^2.1.1",
     "cmdk": "^1.0.4",
     "codemirror": "^6.0.1",
     "country-list": "^2.3.0",
     "date-fns": "^4.1.0",
-    "dsn-converter": "^0.0.57",
+    "dsn-converter": "^0.0.60",
     "easyeda": "^0.0.62",
     "embla-carousel-react": "^8.3.0",
     "extract-codefence": "^0.0.4",
@@ -129,11 +130,13 @@
     "@babel/standalone": "^7.26.2",
     "@biomejs/biome": "^1.9.2",
     "@playwright/test": "^1.48.0",
-    "@tscircuit/core": "^0.0.269",
-    "@tscircuit/prompt-benchmarks": "^0.0.20",
+    "@tscircuit/core": "^0.0.296",
+    "@tscircuit/prompt-benchmarks": "^0.0.28",
+    "@tscircuit/runframe": "^0.0.139",
     "@types/babel__standalone": "^7.1.7",
     "@types/bun": "^1.1.10",
     "@types/country-list": "^2.1.4",
+    "@types/node": "^22.13.0",
     "@types/prismjs": "^1.26.4",
     "@types/react": "^18.3.9",
     "@types/react-dom": "^18.3.0",

package/playwright-tests/circuit-json-import.spec.ts

@@ -0,0 +1,133 @@
+import { test, expect } from "@playwright/test"
+import { exampleCircuitJson } from "./exampleCircuitJson"
+
+async function loginToSite(page) {
+  const loginButton = page.getByRole("button", { name: "Log in" })
+  if (await loginButton.isVisible()) {
+    await loginButton.click()
+    await page.waitForLoadState("networkidle")
+  }
+}
+
+test.beforeEach(async ({ page }) => {
+  await page.goto("http://127.0.0.1:5177/quickstart")
+  await page.waitForTimeout(3000)
+  await loginToSite(page).catch(() => {})
+})
+
+test("should open and close the Circuit Json Import Dialog", async ({
+  page,
+}) => {
+  const importButton = page.locator('button:has-text("Import Circuit JSON")')
+  await importButton.click()
+
+  const dialog = page.getByRole("dialog")
+  await expect(dialog).toBeVisible()
+
+  const closeButton = dialog.getByRole("button", { name: "Close" })
+  await closeButton.click()
+
+  await expect(dialog).not.toBeVisible()
+})
+
+test("should handle valid Circuit JSON input", async ({ page }) => {
+  const importButton = page.getByRole("button", { name: "Import Circuit JSON" })
+  await importButton.click()
+  const textarea = page.locator(
+    'textarea[placeholder="Paste the Circuit JSON."]',
+  )
+  await textarea.fill(JSON.stringify(exampleCircuitJson))
+
+  const importDialogButton = page.getByRole("button", { name: "Import" })
+  await importDialogButton.click()
+
+  const successToast = page.locator(
+    'div.text-sm.font-semibold:has-text("Import Successful")',
+  )
+  await successToast.waitFor({ state: "visible", timeout: 5000 })
+  await expect(successToast).toBeVisible()
+})
+
+test("should handle valid Circuit JSON file upload", async ({ page }) => {
+  const importButton = page.locator('button:has-text("Import Circuit JSON")')
+  await importButton.click()
+
+  const fileInput = page.locator('input[type="file"]')
+
+  await fileInput.setInputFiles({
+    name: "circuit.json",
+    mimeType: "application/json",
+    // @ts-expect-error didnt add node types to tsconfig
+    buffer: Buffer.from(JSON.stringify(exampleCircuitJson)),
+  })
+
+  const importDialogButton = page.getByRole("button", { name: "Import" })
+  await importDialogButton.click()
+  const successToast = page.locator(
+    'div.text-sm.font-semibold:has-text("Import Successful")',
+  )
+  await successToast.waitFor({ state: "visible", timeout: 5000 })
+  await expect(successToast).toBeVisible()
+})
+
+test("should handle invalid Circuit JSON input", async ({ page }) => {
+  const importButton = page.locator('button:has-text("Import Circuit JSON")')
+  await importButton.click()
+
+  const textarea = page.locator(
+    'textarea[placeholder="Paste the Circuit JSON."]',
+  )
+  await textarea.fill("invalid json content")
+
+  const importDialogButton = page.getByRole("button", { name: "Import" })
+  await importDialogButton.click()
+
+  const errorToast = page.locator(
+    'div.text-sm.font-semibold:has-text("Invalid Input")',
+  )
+  await errorToast.waitFor({ state: "visible", timeout: 5000 })
+  await expect(errorToast).toBeVisible()
+})
+
+test("should handle invalid Circuit JSON file upload", async ({ page }) => {
+  const importButton = page.locator('button:has-text("Import Circuit JSON")')
+  await importButton.click()
+
+  const fileInput = page.locator('input[type="file"]')
+  await fileInput.setInputFiles({
+    name: "circuit.json",
+    mimeType: "application/json",
+    // @ts-expect-error didnt add node types to tsconfig
+    buffer: Buffer.from(JSON.stringify({})),
+  })
+
+  const importDialogButton = page.getByRole("button", { name: "Import" })
+  await importDialogButton.click()
+
+  const errorToast = page.locator(
+    'div.text-sm.font-semibold:has-text("Import Failed")',
+  )
+  await errorToast.waitFor({ state: "visible", timeout: 5000 })
+  await expect(errorToast).toBeVisible()
+})
+
+test("should handle non-JSON file upload", async ({ page }) => {
+  const importButton = page.locator('button:has-text("Import Circuit JSON")')
+  await importButton.click()
+
+  const fileInput = page.locator('input[type="file"]')
+  await fileInput.setInputFiles({
+    name: "circuit.txt",
+    mimeType: "application/text",
+    // @ts-expect-error didnt add node types to tsconfig
+    buffer: Buffer.from(""),
+  })
+
+  const importDialogButton = page.getByRole("button", { name: "Import" })
+  await importDialogButton.click()
+
+  const errorToast = page.locator(
+    'div.pb-4 > p:has-text("Please select a valid JSON file.")',
+  )
+  await expect(errorToast).toBeVisible()
+})

package/playwright-tests/cmd-click.spec.ts

@@ -3,7 +3,7 @@ import { test, expect } from "@playwright/test"
 test("Editor handles imports with underlining and cmd+click", async ({
   page,
 }) => {
-  await page.goto("http://127.0.0.1:5177/editor?snippet_id=snippet_5")
+  await page.goto("http://127.0.0.1:5177/editor?snippet_id=snippet_3")
 
   await page.waitForLoadState("networkidle")
 

package/playwright-tests/editor-page.spec.ts

@@ -8,7 +8,7 @@ test("Editor loads snippet correctly", async ({ page }) => {
   await page.waitForLoadState("networkidle")
 
   // Check for specific text that should be present
-  await expect(page.getByText("SquareWaveModule")).toBeVisible()
+  await expect(page.getByText("A555Timer", { exact: true })).toBeVisible()
 
   // Take a snapshot
   await expect(page).toHaveScreenshot("editor-with-snippet.png")