@tscircuit/fake-snippets 0.0.121 → 0.0.122

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

@@ -1,165 +0,0 @@
-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({
-      // Accept either package_id or package_name to find the package to fork
-      package_id: z.string().optional(),
-      package_name: z.string().optional(),
-      // Optional parameters to customize the forked package
-      is_private: z.boolean().optional().default(false),
-      is_unlisted: z.boolean().optional().default(false),
-    })
-    .refine(
-      (data) =>
-        data.package_id !== undefined || data.package_name !== undefined,
-      {
-        message: "Either package_id or package_name must be provided",
-      },
-    )
-    .transform((data) => ({
-      ...data,
-      // If the package is private, it should be unlisted
-      is_unlisted: data.is_private ? true : data.is_unlisted,
-    })),
-  jsonResponse: z.object({
-    package: packageSchema,
-  }),
-})(async (req, ctx) => {
-  const { package_id, package_name, is_private, is_unlisted } = req.jsonBody
-
-  // Find the package to fork
-  let sourcePackage = null
-  if (package_id) {
-    sourcePackage = ctx.db.packages.find((pkg) => pkg.package_id === package_id)
-  } else if (package_name) {
-    sourcePackage = ctx.db.packages.find((pkg) => pkg.name === package_name)
-  }
-
-  if (!sourcePackage) {
-    return ctx.error(404, {
-      error_code: "package_not_found",
-      message: "The package to fork was not found",
-    })
-  }
-
-  if (sourcePackage.creator_account_id === ctx.auth.account_id) {
-    return ctx.error(400, {
-      error_code: "cannot_fork_own_package",
-      message: "You cannot fork your own package",
-    })
-  }
-
-  // Check if fork already exists (user already has a package with the same name)
-  const forkName = `${ctx.auth.github_username}/${sourcePackage.unscoped_name}`
-  const existingFork = ctx.db.packages.find(
-    (pkg) =>
-      pkg.creator_account_id === ctx.auth.account_id && pkg.name === forkName,
-  )
-
-  if (existingFork) {
-    return ctx.json({
-      package: publicMapPackage(existingFork),
-    })
-  }
-
-  // Find the latest release of the source package
-  const sourcePackageRelease = ctx.db.packageReleases.find(
-    (release) =>
-      release.package_id === sourcePackage.package_id &&
-      release.is_latest === true,
-  )
-
-  if (!sourcePackageRelease) {
-    return ctx.error(404, {
-      error_code: "source_package_release_not_found",
-      message: "The source package does not have any releases to fork",
-    })
-  }
-
-  // Get the files from the source package release
-  const sourceFiles = ctx.db.packageFiles.filter(
-    (file) =>
-      file.package_release_id === sourcePackageRelease.package_release_id,
-  )
-
-  if (sourceFiles.length === 0) {
-    return ctx.error(404, {
-      error_code: "source_package_files_not_found",
-      message: "The source package release does not have any files to fork",
-    })
-  }
-
-  // Create the forked package
-  const forkedPackage = ctx.db.addPackage({
-    name: forkName,
-    description: sourcePackage.description,
-    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,
-    website: null,
-    is_source_from_github: false,
-    created_at: new Date().toISOString(),
-    updated_at: new Date().toISOString(),
-    unscoped_name: sourcePackage.unscoped_name,
-    star_count: 0,
-    ai_description: sourcePackage.ai_description || "forked package",
-    is_private: is_private,
-    is_public: !is_private,
-    is_unlisted,
-    ai_usage_instructions: "forked package usage",
-    is_board: Boolean(sourcePackage.is_board),
-    is_package: true,
-    is_model: Boolean(sourcePackage.is_model),
-    is_footprint: Boolean(sourcePackage.is_footprint),
-    is_snippet: Boolean(sourcePackage.is_snippet),
-  })
-
-  if (!forkedPackage) {
-    return ctx.error(500, {
-      error_code: "failed_to_create_forked_package",
-      message: "Failed to create forked package",
-    })
-  }
-
-  // Create a new package release for the forked package
-  const forkedPackageRelease = ctx.db.addPackageRelease({
-    package_id: forkedPackage.package_id,
-    version: sourcePackageRelease.version,
-    is_locked: false,
-    is_latest: true,
-    created_at: new Date().toISOString(),
-    commit_sha: null,
-    license: sourcePackageRelease.license || null,
-    // Setting the transpiled as true on creation
-    has_transpiled: true,
-    transpilation_error: null,
-  })
-
-  // Update the forked package with release info
-  forkedPackage.latest_package_release_id =
-    forkedPackageRelease.package_release_id
-  forkedPackage.latest_version = forkedPackageRelease.version || null
-
-  // Copy all files from the source package release to the forked package release
-  for (const sourceFile of sourceFiles) {
-    ctx.db.addPackageFile({
-      package_release_id: forkedPackageRelease.package_release_id,
-      file_path: sourceFile.file_path,
-      content_text: sourceFile.content_text,
-      created_at: new Date().toISOString(),
-    })
-  }
-
-  return ctx.json({
-    package: publicMapPackage(forkedPackage),
-  })
-})

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

@@ -1,111 +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"
-import {
-  fetchEasyEDAComponent,
-  convertRawEasyEdaToTs,
-  normalizeManufacturerPartNumber,
-  EasyEdaJsonSchema,
-} from "easyeda"
-
-export default withRouteSpec({
-  methods: ["POST"],
-  auth: "session",
-  jsonBody: z.object({
-    jlcpcb_part_number: z.string().min(1, "JLCPCB part number is required"),
-  }),
-  jsonResponse: z.object({
-    ok: z.boolean(),
-    package: packageSchema,
-  }),
-})(async (req, ctx) => {
-  const { jlcpcb_part_number } = req.jsonBody
-
-  try {
-    const rawEasyJson = await fetchEasyEDAComponent(jlcpcb_part_number)
-
-    if (!rawEasyJson) {
-      return ctx.error(404, {
-        error_code: "component_not_found",
-        message: `Component with JLCPCB part number ${jlcpcb_part_number} not found`,
-      })
-    }
-
-    const betterEasy = await EasyEdaJsonSchema.parse(rawEasyJson)
-
-    const tsxComponent = await convertRawEasyEdaToTs(rawEasyJson)
-
-    const componentName = normalizeManufacturerPartNumber(
-      betterEasy.dataStr.head.c_para["Manufacturer Part"] ?? "",
-    )
-      .replace(/[^a-zA-Z0-9-_]/g, "-")
-      .replace(/--/g, "-")
-
-    const packageName = `${ctx.auth.github_username}/${componentName}`
-
-    const existingPackage = ctx.db.packages.find((p) => p.name === packageName)
-
-    if (existingPackage) {
-      return ctx.error(409, {
-        error_code: "package_already_exists",
-        message: componentName,
-      })
-    }
-
-    const newPackage = {
-      name: packageName,
-      unscoped_name: componentName,
-      owner_name: ctx.auth.github_username,
-      code: tsxComponent,
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
-      description: `Generated from JLCPCB part number ${jlcpcb_part_number}`,
-      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_package_release_fs_sha: null,
-      latest_version: null,
-      license: null,
-      ai_description: "placeholder ai description",
-      ai_usage_instructions: "placeholder ai usage instructions",
-    }
-
-    const createdPackage = ctx.db.addPackage(newPackage)
-
-    const createdPackageRelease = ctx.db.addPackageRelease({
-      package_id: createdPackage.package_id,
-      version: "1.0.0",
-      created_at: new Date().toISOString(),
-      is_latest: true,
-      is_locked: false,
-    })
-
-    ctx.db.updatePackage(createdPackage.package_id, {
-      latest_package_release_id: createdPackageRelease.package_release_id,
-    })
-
-    ctx.db.addPackageFile({
-      package_release_id: createdPackageRelease.package_release_id,
-      file_path: "index.tsx",
-      content_text: String(tsxComponent),
-      created_at: new Date().toISOString(),
-    })
-
-    return ctx.json({
-      ok: true,
-      package: createdPackage as any,
-    })
-  } catch (error: any) {
-    if (String(error).includes("Component not found")) {
-      return ctx.error(404, {
-        error_code: "component_not_found",
-        message: `Component with JLCPCB part number ${jlcpcb_part_number} not found`,
-      })
-    }
-    return ctx.error(500, {
-      error_code: "package_generation_failed",
-      message: `Failed to generate package from JLCPCB part: ${error.message || String(error)}`,
-    })
-  }
-})

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

@@ -1,81 +0,0 @@
-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
-      .extend({
-        is_starred: z.boolean(),
-        user_permissions: z
-          .object({
-            can_manage_packages: z.boolean(),
-          })
-          .optional(),
-      })
-      .optional(),
-  }),
-})(async (req, ctx) => {
-  const { package_id, name } = req.commonParams
-  const auth = "auth" in ctx && ctx.auth ? ctx.auth : null
-
-  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)})`,
-    })
-  }
-
-  if (
-    foundPackage.is_private &&
-    auth?.github_username !== foundPackage.owner_github_username
-  ) {
-    return ctx.error(404, {
-      error_code: "package_not_found",
-      message: `Package not found (searched using ${JSON.stringify(
-        req.commonParams,
-      )})`,
-    })
-  }
-
-  // Check if user can manage the package
-  const canManagePackage =
-    auth &&
-    ctx.db
-      .getState()
-      .orgAccounts.some(
-        (org_account) =>
-          org_account.account_id === auth.account_id &&
-          org_account.org_id === foundPackage.owner_org_id,
-      )
-
-  return ctx.json({
-    ok: true,
-    package: {
-      ...publicMapPackage(foundPackage),
-      is_starred: auth
-        ? ctx.db.hasStarred(auth.account_id, foundPackage.package_id)
-        : false,
-      ...(auth
-        ? {
-            user_permissions: {
-              can_manage_packages: canManagePackage ?? false,
-            },
-          }
-        : {}),
-    },
-  })
-})

package/fake-snippets-api/routes/api/packages/images/[owner_github_username]/[unscoped_name]/[view_format].ts

@@ -1,119 +0,0 @@
-import { AnyCircuitElement } from "circuit-json"
-import {
-  convertCircuitJsonToAssemblySvg,
-  convertCircuitJsonToPcbSvg,
-  convertCircuitJsonToSchematicSvg,
-} from "circuit-to-svg"
-import { convertCircuitJsonToSimple3dSvg } from "circuit-json-to-simple-3d"
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-import { renderAsync } from "@resvg/resvg-js"
-
-// Define the view types and extensions
-const VIEW_TYPES = ["schematic", "pcb", "assembly", "3d"] as const
-const EXTENSIONS = ["svg", "png"] as const
-
-// Create a regex pattern for the view format that includes optional width suffix
-const viewFormatPattern = new RegExp(
-  `^(${VIEW_TYPES.join("|")})-?(\\d+w)?\\.(${EXTENSIONS.join("|")})$`,
-)
-
-export default withRouteSpec({
-  methods: ["GET"],
-  auth: "none",
-  routeParams: z.object({
-    owner_github_username: z.string(),
-    unscoped_name: z.string(),
-    view_format: z.string().regex(viewFormatPattern, {
-      message: `Invalid view format. Must be one of: ${VIEW_TYPES.join(", ")} with optional width suffix (e.g. -800w).${EXTENSIONS.join(" or ")}`,
-    }),
-  }),
-  queryParams: z.object({
-    fs_sha: z.string().optional(),
-  }),
-  rawResponse: true,
-})(async (req, ctx) => {
-  const { owner_github_username, unscoped_name, view_format } = req.routeParams
-  const { fs_sha } = req.query
-
-  // Parse the view format
-  const [outputType, format] = view_format.split(".")
-
-  // Get the package
-  const pkg = ctx.db.packages.find(
-    (p) =>
-      p.owner_github_username === owner_github_username &&
-      p.unscoped_name === unscoped_name,
-  )
-
-  // If package is not found, return 404
-  if (!pkg) {
-    return ctx.error(404, {
-      error_code: "package_not_found",
-      message: "Package not found",
-    })
-  }
-
-  // Get the package release for the given hash value
-  const pkg_release = ctx.db.packageReleases.find(
-    (pr) => pr.package_id === pkg.package_id && pr.fs_sha === fs_sha,
-  )
-
-  if (!pkg_release) {
-    return ctx.error(404, {
-      error_code: "package_release_not_found",
-      message: "Package release not found",
-    })
-  }
-
-  // Get the circuit JSON from the package files
-  const circuit_json_file = ctx.db.packageFiles.find(
-    (pf) =>
-      pf.package_release_id === pkg_release.package_release_id &&
-      (pf.file_path === "circuit.json" ||
-        pf.file_path === "/dist/circuit.json"),
-  )
-
-  if (!circuit_json_file?.content_text) {
-    return ctx.error(404, {
-      error_code: "circuit_json_not_found",
-      message: "Circuit JSON not found for package",
-    })
-  }
-
-  const circuit_json = JSON.parse(circuit_json_file.content_text)
-
-  // Convert circuit json to svg
-  let svg = ""
-  if (outputType === "schematic") {
-    svg = convertCircuitJsonToSchematicSvg(circuit_json as AnyCircuitElement[])
-  } else if (outputType === "pcb") {
-    svg = convertCircuitJsonToPcbSvg(circuit_json as AnyCircuitElement[])
-  } else if (outputType === "assembly") {
-    svg = convertCircuitJsonToAssemblySvg(circuit_json as AnyCircuitElement[])
-  } else if (outputType === "3d") {
-    svg = await convertCircuitJsonToSimple3dSvg(circuit_json, {
-      background: {
-        color: "#fff",
-        opacity: 0.0,
-      },
-      defaultZoomMultiplier: 1.1,
-    })
-  }
-  if (format === "svg") {
-    return new Response(svg, {
-      headers: {
-        "Content-Type": "image/svg+xml",
-        "Cache-Control": "public, max-age=86400, s-maxage=86400",
-      },
-    })
-  }
-
-  const pngBuffer = await renderAsync(svg)
-  return new Response(pngBuffer.asPng().buffer as ArrayBuffer, {
-    headers: {
-      "Content-Type": "image/png",
-      "Cache-Control": "public, max-age=86400, s-maxage=86400",
-    },
-  })
-})

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

@@ -1,105 +0,0 @@
-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(),
-    limit: z.number().int().min(1).optional(),
-  }),
-  jsonResponse: z.object({
-    ok: z.boolean(),
-    packages: z.array(
-      packageSchema.extend({
-        starred_at: z.string().nullable(),
-        user_permissions: z
-          .object({
-            can_manage_packages: z.boolean(),
-          })
-          .optional(),
-      }),
-    ),
-  }),
-})(async (req, ctx) => {
-  const {
-    creator_account_id,
-    owner_github_username,
-    name,
-    is_writable,
-    limit,
-  } = 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",
-    })
-  }
-
-  // Helper to check if user can manage a package
-  const canManagePackage = (pkg: any) => {
-    if (!auth) return false
-    // Check if user is a member of the package's owner org
-    const state = ctx.db.getState()
-    return state.orgAccounts.some(
-      (oa) =>
-        oa.account_id === auth.account_id && oa.org_id === pkg.owner_org_id,
-    )
-  }
-
-  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 (limit) {
-    packages = packages.slice(0, limit)
-  }
-  if (is_writable && auth) {
-    packages = packages.filter(canManagePackage)
-  }
-
-  // Get star timestamps for authenticated user
-  const starTimestamps = new Map<string, string>()
-  if (auth) {
-    ctx.db.accountPackages
-      .filter((ap) => ap.account_id === auth.account_id && ap.is_starred)
-      .forEach((ap) => {
-        starTimestamps.set(ap.package_id, ap.updated_at)
-      })
-  }
-
-  return ctx.json({
-    ok: true,
-    packages: packages.map((p) => ({
-      ...p,
-      latest_package_release_id: p.latest_package_release_id || null,
-      starred_at: starTimestamps.get(p.package_id) || null,
-      ...(auth
-        ? {
-            user_permissions: {
-              can_manage_packages: canManagePackage(p),
-            },
-          }
-        : {}),
-    })),
-  })
-})

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

@@ -1,29 +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"
-import { publicMapPackage } from "fake-snippets-api/lib/public-mapping/public-map-package"
-
-export default withRouteSpec({
-  methods: ["GET"],
-  auth: "none",
-  queryParams: z.object({
-    limit: z.string().regex(/^\d+$/).transform(Number).optional(),
-  }),
-  jsonResponse: z.object({
-    packages: z.array(packageSchema),
-  }),
-})(async (req, ctx) => {
-  const limit = req.query.limit || 50
-
-  // Get all packages that are not snippets
-  const packages = ctx.db.packages
-    .filter((pkg) => !pkg.is_snippet)
-    .sort(
-      (a, b) =>
-        new Date(b.created_at).getTime() - new Date(a.created_at).getTime(),
-    )
-    .slice(0, limit)
-    .map((pkg) => publicMapPackage(pkg))
-
-  return ctx.json({ packages })
-})

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

@@ -1,43 +0,0 @@
-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: "none",
-  commonParams: z.object({}),
-  jsonResponse: z.object({
-    ok: z.boolean(),
-    packages: z.array(packageSchema),
-  }),
-})(async (req, ctx) => {
-  // Get all packages and their star counts
-  const packagesWithStars = ctx.db.packages.map((pkg) => {
-    const starCount = ctx.db.accountPackages.filter(
-      (ap) => ap.package_id === pkg.package_id && ap.is_starred,
-    ).length
-
-    return {
-      ...pkg,
-      star_count: starCount,
-    }
-  })
-
-  // Filter out packages with no stars and sort by star count
-  const trendingPackages = ctx.db.packages
-    .filter((p) => p.star_count > 0)
-    .sort((a, b) => b.star_count - a.star_count)
-    .slice(0, 50)
-
-  // Randomize the order of the packages, then pick the first 10
-  const randomizedPackages = trendingPackages.sort(() => Math.random() - 0.5)
-  const selectedPackages = randomizedPackages.slice(0, 10)
-
-  return ctx.json({
-    ok: true,
-    packages: selectedPackages.map((p) => ({
-      ...p,
-      latest_package_release_id: p.latest_package_release_id || null,
-    })),
-  })
-})