@tscircuit/fake-snippets 0.0.24 → 0.0.26

package/fake-snippets-api/routes/api/_fake/move_orders_forward.ts

@@ -3,66 +3,63 @@ import { z } from "zod"
 import { orderSteps } from "fake-snippets-api/utils/order-steps"
 
 export default withRouteSpec({
-  methods: ["POST"],
+  methods: ["GET"],
   auth: "session",
-  jsonBody: z.object({
-    order_id: z.string(),
-  }),
   jsonResponse: z.object({
     success: z.boolean(),
-    current_step: z.string().nullable(),
   }),
 })(async (req, ctx) => {
-  const { order_id } = req.jsonBody
+  // Get all orders that aren't finished
+  const orders = ctx.db.orders.filter((order) => !order.is_finished)
+  const updatedOrders = []
 
-  const orderState = ctx.db.getJlcpcbOrderStatesByOrderId(order_id)
-  if (!orderState) {
-    return ctx.error(404, {
-      error_code: "order_state_not_found",
-      message: "Order state not found",
-    })
-  }
+  for (const order of orders) {
+    const orderState = ctx.db.getJlcpcbOrderStatesByOrderId(order.order_id)
+    if (!orderState) continue
 
-  // Find the next step to complete
-  let nextStepIndex = -1
-  for (let i = 0; i < orderSteps.length; i++) {
-    const step = orderSteps[i]
-    if (!orderState[step]) {
-      nextStepIndex = i
-      break
+    // Find the next step to complete
+    let nextStepIndex = -1
+    for (let i = 0; i < orderSteps.length; i++) {
+      const step = orderSteps[i]
+      if (!orderState[step]) {
+        nextStepIndex = i
+        break
+      }
     }
-  }
 
-  // If all steps are completed or no next step found
-  if (nextStepIndex === -1) {
-    return ctx.json({
-      success: true,
-      current_step: null,
-    })
-  }
+    // If all steps are completed or no next step found
+    if (nextStepIndex === -1) {
+      updatedOrders.push({
+        order_id: order.order_id,
+        current_step: null,
+      })
+      continue
+    }
 
-  // Update the next step to true
-  const nextStep = orderSteps[nextStepIndex]
-  const updates = {
-    [nextStep]: true,
-    current_step: nextStep,
-  }
+    // Update the next step to true
+    const nextStep = orderSteps[nextStepIndex]
+    const updates = {
+      [nextStep]: true,
+      current_step: nextStep,
+    }
 
-  // If this is the last step, also update the order status
-  if (nextStepIndex === orderSteps.length - 1) {
-    const order = ctx.db.getOrderById(order_id)
-    if (order) {
-      ctx.db.updateOrder(order_id, {
+    // If this is the last step, also update the order status
+    if (nextStepIndex === orderSteps.length - 1) {
+      ctx.db.updateOrder(order.order_id, {
         is_finished: true,
         completed_at: new Date().toISOString(),
       })
     }
-  }
 
-  ctx.db.updateJlcpcbOrderState(order_id, updates)
+    ctx.db.updateJlcpcbOrderState(order.order_id, updates)
+
+    updatedOrders.push({
+      order_id: order.order_id,
+      current_step: nextStep,
+    })
+  }
 
   return ctx.json({
     success: true,
-    current_step: nextStep,
   })
 })

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

@@ -5,27 +5,7 @@ import {
 } from "fake-snippets-api/lib/db/schema"
 import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
 import { z } from "zod"
-
-export const simulateScenarios = [
-  "are_gerbers_generated",
-  "are_gerbers_uploaded",
-  "is_gerber_analyzed",
-  "are_initial_costs_calculated",
-  "is_pcb_added_to_cart",
-  "is_bom_uploaded",
-  "is_pnp_uploaded",
-  "is_bom_pnp_analyzed",
-  "is_bom_parsing_complete",
-  "are_components_available",
-  "is_patch_map_generated",
-  "is_json_merge_file_created",
-  "is_dfm_result_generated",
-  "are_files_downloaded",
-  "are_product_categories_fetched",
-  "are_final_costs_calculated",
-  "is_json_merge_file_updated",
-  "is_added_to_cart",
-] as const
+import { orderSteps as simulateScenarios } from "fake-snippets-api/utils/order-steps"
 
 const defaultOrderState = {
   are_gerbers_uploaded: false,

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

@@ -76,6 +76,14 @@ export default withRouteSpec({
     commit_sha: commit_sha ?? null,
   })
 
+  // Update the package's latest_package_release_id if this is the latest release
+  if (is_latest) {
+    ctx.db.updatePackage(package_id, {
+      latest_package_release_id: newPackageRelease.package_release_id,
+      latest_version: version,
+    })
+  }
+
   return ctx.json({
     ok: true,
     package_release: publicMapPackageRelease(newPackageRelease),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/fake-snippets",
-  "version": "0.0.24",
+  "version": "0.0.26",
   "type": "module",
   "repository": {
     "type": "git",

package/src/App.tsx

@@ -70,6 +70,7 @@ const UserProfilePage = lazyImport(() => import("@/pages/user-profile"))
 const ViewOrderPage = lazyImport(() => import("@/pages/view-order"))
 const ViewSnippetPage = lazyImport(() => import("@/pages/view-snippet"))
 const DevLoginPage = lazyImport(() => import("@/pages/dev-login"))
+const BetaPage = lazyImport(() => import("@/pages/beta"))
 
 class ErrorBoundary extends React.Component<
   { children: React.ReactNode },
@@ -99,6 +100,7 @@ function App() {
         <Suspense fallback={<FullPageLoader />}>
           <Switch>
             <Route path="/" component={LandingPage} />
+            <Route path="/beta" component={BetaPage} />
             <Route path="/editor" component={EditorPage} />
             <Route path="/quickstart" component={QuickstartPage} />
             <Route path="/dashboard" component={DashboardPage} />

package/src/components/OptimizedImage.tsx

@@ -28,6 +28,7 @@ interface OptimizedImageProps
   src: string
   alt: string
   priority?: boolean
+  fallbackSrc?: string
 }
 
 const getImageSizes = (src: string) => {
@@ -51,10 +52,12 @@ export function OptimizedImage({
   alt,
   className,
   priority = false,
+  fallbackSrc = "/assets/fallback-image.svg",
   ...props
 }: OptimizedImageProps) {
+  const [currentSrc, setCurrentSrc] = useState(src)
   const [imageLoading, setImageLoading] = useState(true)
-  const { srcSet, sizes } = getImageSizes(src)
+  const { srcSet, sizes } = getImageSizes(currentSrc)
 
   useEffect(() => {
     if (priority) {
@@ -75,7 +78,7 @@ export function OptimizedImage({
 
   return (
     <img
-      src={src}
+      src={currentSrc}
       srcSet={srcSet}
       sizes={sizes}
       alt={alt}
@@ -86,8 +89,9 @@ export function OptimizedImage({
         imageLoading ? "animate-pulse bg-gray-200" : ""
       } object-contain`}
       onLoad={() => setImageLoading(false)}
-      onError={(e) => {
-        console.error("Image failed to load:", e)
+      onError={() => {
+        console.error("Image failed to load:", currentSrc)
+        setCurrentSrc(fallbackSrc)
         setImageLoading(false)
       }}
       {...props}

package/src/hooks/use-create-package-files-mutation.ts

@@ -0,0 +1,76 @@
+import type { PackageFile } from "fake-snippets-api/lib/db/schema"
+import { useMutation } from "react-query"
+import { useAxios } from "./use-axios"
+
+export const useCreatePackageFilesMutation = ({
+  onSuccess,
+}: { onSuccess?: (packageFile: PackageFile) => void } = {}) => {
+  const axios = useAxios()
+
+  return useMutation(
+    ["createPackageFiles"],
+    async ({
+      file_path,
+      content_text,
+      content_base64,
+      content_mimetype,
+      package_release_id,
+      package_name_with_version,
+      is_release_tarball = false,
+      npm_pack_output,
+    }: {
+      file_path: string
+      content_text?: string
+      content_base64?: string
+      content_mimetype?: string
+      package_release_id?: string
+      package_name_with_version?: string
+      is_release_tarball?: boolean
+      npm_pack_output?: any
+    }) => {
+      // Validate that either content_text or content_base64 is provided, but not both
+      if (
+        (!content_text && !content_base64) ||
+        (content_text && content_base64)
+      ) {
+        throw new Error(
+          "Must provide either content_text or content_base64, but not both",
+        )
+      }
+
+      // Validate that either package_release_id or package_name_with_version is provided
+      if (!package_release_id && !package_name_with_version) {
+        throw new Error(
+          "Must provide either package_release_id or package_name_with_version",
+        )
+      }
+
+      const {
+        data: { package_file: newPackageFile },
+      } = await axios.post("/package_files/create", {
+        file_path,
+        content_text,
+        content_base64,
+        content_mimetype,
+        package_release_id,
+        package_name_with_version,
+        is_release_tarball,
+        npm_pack_output,
+      })
+
+      if (!newPackageFile) {
+        throw new Error("Failed to create package file")
+      }
+
+      return newPackageFile
+    },
+    {
+      onSuccess: (packageFile: PackageFile) => {
+        onSuccess?.(packageFile)
+      },
+      onError: (error: any) => {
+        console.error("Error creating package file:", error)
+      },
+    },
+  )
+}

package/src/hooks/use-create-package-mutation.ts

@@ -0,0 +1,60 @@
+import type { Package } from "fake-snippets-api/lib/db/schema"
+import { useMutation } from "react-query"
+import { useAxios } from "./use-axios"
+import { useGlobalStore } from "./use-global-store"
+import { useUrlParams } from "./use-url-params"
+
+export const useCreatePackageMutation = ({
+  onSuccess,
+}: { onSuccess?: (pkg: Package) => void } = {}) => {
+  const urlParams = useUrlParams()
+  const templateName = urlParams.template
+  const axios = useAxios()
+  const session = useGlobalStore((s) => s.session)
+
+  return useMutation(
+    ["createPackage"],
+    async ({
+      name,
+      description,
+      is_private,
+      is_unlisted,
+    }: {
+      name: string
+      description?: string
+      is_private?: boolean
+      is_unlisted?: boolean
+    }) => {
+      if (!session) throw new Error("No session")
+
+      const {
+        data: { package: newPackage },
+      } = await axios.post("/packages/create", {
+        name,
+        description,
+        is_private,
+        is_unlisted,
+      })
+
+      if (!newPackage) {
+        throw new Error("Failed to create package")
+      }
+
+      return newPackage
+    },
+    {
+      onSuccess: (pkg: Package) => {
+        const url = new URL(window.location.href)
+        url.searchParams.set("package_id", pkg.package_id)
+        url.searchParams.delete("template")
+        url.searchParams.delete("should_create_package")
+        window.history.pushState({}, "", url.toString())
+        onSuccess?.(pkg)
+        window.dispatchEvent(new Event("popstate"))
+      },
+      onError: (error: any) => {
+        console.error("Error creating package:", error)
+      },
+    },
+  )
+}

package/src/hooks/use-create-package-release-mutation.ts

@@ -0,0 +1,57 @@
+import type { PackageRelease } from "fake-snippets-api/lib/db/schema"
+import { useMutation } from "react-query"
+import { useAxios } from "./use-axios"
+
+export const useCreatePackageReleaseMutation = ({
+  onSuccess,
+}: { onSuccess?: (packageRelease: PackageRelease) => void } = {}) => {
+  const axios = useAxios()
+
+  return useMutation(
+    ["createPackageRelease"],
+    async ({
+      package_id,
+      version,
+      is_latest = true,
+      commit_sha,
+      package_name_with_version,
+    }: {
+      package_id?: string
+      version?: string
+      is_latest?: boolean
+      commit_sha?: string
+      package_name_with_version?: string
+    }) => {
+      // Validate that either package_id + version or package_name_with_version is provided
+      if (!package_name_with_version && (!package_id || !version)) {
+        throw new Error(
+          "Must provide either package_id + version or package_name_with_version",
+        )
+      }
+
+      const {
+        data: { package_release: newPackageRelease },
+      } = await axios.post("/package_releases/create", {
+        package_id,
+        version,
+        is_latest,
+        commit_sha,
+        package_name_with_version,
+      })
+
+      if (!newPackageRelease) {
+        throw new Error("Failed to create package release")
+      }
+
+      return newPackageRelease
+    },
+    {
+      onSuccess: (packageRelease: PackageRelease) => {
+        onSuccess?.(packageRelease)
+      },
+      onError: (error: any) => {
+        console.error("Error creating package release:", error)
+      },
+    },
+  )
+}

package/src/hooks/use-fork-package-mutation.ts

@@ -0,0 +1,103 @@
+import {
+  Package,
+  PackageFile,
+  PackageRelease,
+} from "fake-snippets-api/lib/db/schema"
+import { useMutation } from "react-query"
+import { useAxios } from "./use-axios"
+import { useGlobalStore } from "./use-global-store"
+import { useToast } from "./use-toast"
+import { useCreatePackageMutation } from "./use-create-package-mutation"
+import { useCreatePackageReleaseMutation } from "./use-create-package-release-mutation"
+import { useCreatePackageFilesMutation } from "./use-create-package-files-mutation"
+
+export const useForkPackageMutation = ({
+  onSuccess,
+}: {
+  onSuccess?: (forkedPackage: Package) => void
+} = {}) => {
+  const axios = useAxios()
+  const session = useGlobalStore((s) => s.session)
+  const { toast } = useToast()
+
+  const { mutateAsync: createPackage } = useCreatePackageMutation()
+  const { mutateAsync: createRelease } = useCreatePackageReleaseMutation()
+  const { mutateAsync: createFile } = useCreatePackageFilesMutation()
+
+  return useMutation(
+    ["forkPackage"],
+    async (packageId: string) => {
+      if (!session) throw new Error("No session")
+
+      // Step 1: Fetch source package data
+      const { data: packageData } = await axios.get("/packages/get", {
+        params: { package_id: packageId },
+      })
+      const sourcePackage: Package = packageData.package
+      if (!sourcePackage) throw new Error("Source package not found")
+
+      console.log("sourcePackage", sourcePackage)
+      // Step 2: Fetch latest release
+      const { data: releaseData } = await axios.post("/package_releases/get", {
+        package_release_id: sourcePackage.latest_package_release_id,
+      })
+      const sourceRelease: PackageRelease = releaseData.package_release
+      if (!sourceRelease) throw new Error("Source release not found")
+
+      // Step 3: Fetch all files for the release
+      const { data: filesData } = await axios.post("/package_files/list", {
+        package_release_id: sourceRelease.package_release_id,
+      })
+      const sourceFiles: PackageFile[] = filesData.package_files
+      if (!sourceFiles?.length) throw new Error("No source files found")
+
+      // Step 4: Create new package
+      const newPackage = await createPackage({
+        name: `@${session.github_username}/${sourcePackage.unscoped_name}`,
+        description: `Fork of ${sourcePackage.name}`,
+        is_private: false,
+        is_unlisted: false,
+      })
+
+      // Step 5: Create new release
+      const newRelease = await createRelease({
+        package_id: newPackage.package_id,
+        version: sourceRelease.version ?? undefined,
+        is_latest: true,
+      })
+
+      // Step 6: Create all files
+      const newFiles = await Promise.all(
+        sourceFiles.map((file: PackageFile) =>
+          createFile({
+            package_release_id: newRelease.package_release_id,
+            file_path: file.file_path,
+            content_text: file.content_text ?? undefined,
+          }),
+        ),
+      )
+
+      return {
+        package: newPackage,
+        release: newRelease,
+        files: newFiles,
+      }
+    },
+    {
+      onSuccess: (result) => {
+        toast({
+          title: "Package Forked",
+          description: `Successfully forked package to @${session?.github_username}/${result.package.unscoped_name}`,
+        })
+        onSuccess?.(result.package)
+      },
+      onError: (error: any) => {
+        toast({
+          title: "Error",
+          description: "Failed to fork package. Please try again.",
+          variant: "destructive",
+        })
+      },
+    },
+  )
+}

package/src/hooks/use-package-by-package-id.ts

@@ -0,0 +1,23 @@
+import { useQuery } from "react-query"
+import { useAxios } from "@/hooks/use-axios"
+import type { Package } from "fake-snippets-api/lib/db/schema"
+
+export const usePackageById = (packageId: string | null) => {
+  const axios = useAxios()
+  return useQuery<Package, Error & { status: number }>(
+    ["package", packageId],
+    async () => {
+      if (!packageId) return
+      const { data } = await axios.get("/packages/get", {
+        params: {
+          package_id: packageId,
+        },
+      })
+      return data.package
+    },
+    {
+      retry: false,
+      enabled: Boolean(packageId),
+    },
+  )
+}

package/src/hooks/use-package-by-package-name.ts

@@ -0,0 +1,23 @@
+import { useQuery } from "react-query"
+import { useAxios } from "@/hooks/use-axios"
+import type { Package } from "fake-snippets-api/lib/db/schema"
+
+export const usePackageByName = (packageName: string | null) => {
+  const axios = useAxios()
+  return useQuery<Package, Error & { status: number }>(
+    ["package", packageName],
+    async () => {
+      if (!packageName) return
+      const { data } = await axios.get("/packages/get", {
+        params: {
+          name: packageName,
+        },
+      })
+      return data.package
+    },
+    {
+      retry: false,
+      enabled: Boolean(packageName),
+    },
+  )
+}

package/src/hooks/use-package-files.ts

@@ -0,0 +1,84 @@
+import { PackageFile } from "fake-snippets-api/lib/db/schema"
+import { useQuery } from "react-query"
+import { useAxios } from "./use-axios"
+
+type PackageFileQuery =
+  | {
+      package_file_id: string
+    }
+  | {
+      package_release_id: string
+      file_path: string
+    }
+  | {
+      package_id: string
+      version?: string
+      file_path: string
+    }
+  | {
+      package_name: string
+      version?: string
+      file_path: string
+    }
+  | {
+      package_name_with_version: string
+      file_path: string
+    }
+
+export const usePackageFile = (query: PackageFileQuery | null) => {
+  const axios = useAxios()
+
+  return useQuery<PackageFile, Error & { status: number }>(
+    ["packageFile", query],
+    async () => {
+      if (!query) return
+
+      const { data } = await axios.post("/package_files/get", query)
+
+      if (!data.package_file) {
+        throw new Error("Package file not found")
+      }
+
+      return data.package_file
+    },
+    {
+      retry: false,
+      enabled: Boolean(query),
+    },
+  )
+}
+
+// Convenience hooks for common use cases
+export const usePackageFileById = (packageFileId: string | null) => {
+  return usePackageFile(
+    packageFileId ? { package_file_id: packageFileId } : null,
+  )
+}
+
+export const usePackageFileByPath = (
+  packageNameWithVersion: string | null,
+  filePath: string | null,
+) => {
+  return usePackageFile(
+    packageNameWithVersion && filePath
+      ? {
+          package_name_with_version: packageNameWithVersion,
+          file_path: filePath,
+        }
+      : null,
+  )
+}
+
+export const usePackageFileByRelease = (
+  packageReleaseId: string | null,
+  filePath: string | null,
+) => {
+  return usePackageFile(
+    packageReleaseId && filePath
+      ? {
+          package_release_id: packageReleaseId,
+          file_path: filePath,
+        }
+      : null,
+  )
+}