@tscircuit/fake-snippets 0.0.106 → 0.0.107

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

@@ -85,51 +85,3 @@ export const usePackageBuild = (packageBuildId: string | null) => {
     },
   )
 }
-
-export const useLatestPackageBuild = (
-  params: { package_id?: string; package_release_id?: string } | null,
-) => {
-  const axios = useAxios()
-
-  return useQuery<PackageBuild | null, Error & { status: number }>(
-    ["latestPackageBuild", params],
-    async () => {
-      if (!params || (!params.package_id && !params.package_release_id)) {
-        throw new Error(
-          "Either package_id or package_release_id must be provided",
-        )
-      }
-
-      const { data } = await axios.get<{ package_build: PackageBuild }>(
-        "/package_builds/latest",
-        {
-          params: {
-            ...(params.package_id ? { package_id: params.package_id } : {}),
-            ...(params.package_release_id
-              ? { package_release_id: params.package_release_id }
-              : {}),
-          },
-        },
-      )
-
-      return data.package_build
-    },
-    {
-      enabled: Boolean(
-        params && (params.package_id || params.package_release_id),
-      ),
-      retry: false,
-      refetchOnWindowFocus: false,
-    },
-  )
-}
-
-export const useLatestPackageBuildByPackageId = (packageId: string | null) => {
-  return useLatestPackageBuild(packageId ? { package_id: packageId } : null)
-}
-
-export const useLatestPackageBuildByReleaseId = (releaseId?: string | null) => {
-  return useLatestPackageBuild(
-    releaseId ? { package_release_id: releaseId } : null,
-  )
-}

package/src/hooks/use-package-release-by-id-or-version.ts

@@ -0,0 +1,36 @@
+import {
+  usePackageReleaseById,
+  usePackageReleaseByNameAndVersion,
+} from "./use-package-release"
+import { isUuid } from "@/lib/utils/isUuid"
+
+export const usePackageReleaseByIdOrVersion = (
+  releaseIdOrVersion: string | null,
+  packageName?: string | null,
+) => {
+  const isReleaseIdUuid = releaseIdOrVersion
+    ? isUuid(releaseIdOrVersion)
+    : false
+
+  // If it's a UUID, use the ID-based hook
+  const releaseByIdQuery = usePackageReleaseById(
+    isReleaseIdUuid ? releaseIdOrVersion : null,
+  )
+
+  // If it's not a UUID and we have a package name, construct the version-based query
+  const packageNameWithVersion =
+    !isReleaseIdUuid && packageName && releaseIdOrVersion
+      ? `${packageName}@${releaseIdOrVersion}`
+      : null
+
+  const releaseByVersionQuery = usePackageReleaseByNameAndVersion(
+    packageNameWithVersion,
+  )
+
+  // Return the appropriate query result
+  if (isReleaseIdUuid) {
+    return releaseByIdQuery
+  } else {
+    return releaseByVersionQuery
+  }
+}

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

@@ -90,3 +90,35 @@ export const useLatestPackageRelease = (
 
   return usePackageRelease(query)
 }
+
+export const usePackageReleasesByPackageId = (packageId: string | null) => {
+  const axios = useAxios()
+
+  return useQuery<PackageRelease[], Error & { status: number }>(
+    ["packageReleases", packageId],
+    async () => {
+      if (!packageId) {
+        throw new Error("package_id is required")
+      }
+
+      const { data } = await axios.post<{ package_releases: PackageRelease[] }>(
+        "/package_releases/list",
+        {
+          package_id: packageId,
+        },
+      )
+
+      if (!data.package_releases) {
+        return []
+      }
+
+      return data.package_releases
+    },
+    {
+      enabled: Boolean(packageId),
+      retry: false,
+      refetchOnWindowFocus: false,
+      staleTime: 0,
+    },
+  )
+}

package/src/lib/utils/isUuid.ts

@@ -0,0 +1,5 @@
+export function isUuid(value: string): boolean {
+  const uuidRegex =
+    /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
+  return uuidRegex.test(value) || value.startsWith("package_release_")
+}

package/src/pages/preview-build.tsx

@@ -7,7 +7,7 @@ import { TreeView, TreeDataItem } from "@/components/ui/tree-view"
 import { cn } from "@/lib/utils"
 import { PrefetchPageLink } from "@/components/PrefetchPageLink"
 import NotFoundPage from "./404"
-import { getBuildStatus, MOCK_DEPLOYMENTS } from "@/components/preview"
+import { getBuildStatus, MOCK_PACKAGE_BUILDS } from "@/components/preview"
 
 const MOCK_DEPLOYMENT_FILES: Record<
   string,
@@ -189,8 +189,8 @@ export default function PreviewBuildPage() {
   const buildFsMap = getBuildFsMap(buildId)
 
   const build = buildId
-    ? MOCK_DEPLOYMENTS.find((d) => d.package_build_id === buildId)
-    : MOCK_DEPLOYMENTS[0]
+    ? MOCK_PACKAGE_BUILDS.find((d) => d.package_build_id === buildId)
+    : MOCK_PACKAGE_BUILDS[0]
 
   if (!build) {
     return <NotFoundPage heading="Build Not Found" />

package/src/pages/release-builds.tsx

@@ -0,0 +1,107 @@
+import { useParams } from "wouter"
+import NotFoundPage from "./404"
+import { usePackageByName } from "@/hooks/use-package-by-package-name"
+import { usePackageReleaseByIdOrVersion } from "@/hooks/use-package-release-by-id-or-version"
+import { usePackageBuildsByReleaseId } from "@/hooks/use-package-builds"
+import { BuildsList } from "@/components/preview/BuildsList"
+import Header from "@/components/Header"
+import { useLocation } from "wouter"
+import { PackageBreadcrumb } from "@/components/PackageBreadcrumb"
+import { PackageBuild } from "fake-snippets-api/lib/db/schema"
+
+export default function ReleaseBuildsPage() {
+  const params = useParams<{
+    author: string
+    packageName: string
+    releaseId: string
+  }>()
+
+  const packageName =
+    params?.author && params?.packageName
+      ? `${params.author}/${params.packageName}`
+      : null
+
+  const [, setLocation] = useLocation()
+
+  const {
+    data: pkg,
+    isLoading: isLoadingPackage,
+    error: packageError,
+  } = usePackageByName(packageName)
+
+  const {
+    data: packageRelease,
+    isLoading: isLoadingRelease,
+    error: releaseError,
+  } = usePackageReleaseByIdOrVersion(params?.releaseId ?? null, packageName)
+
+  const {
+    data: builds,
+    isLoading: isLoadingBuilds,
+    error: buildsError,
+  } = usePackageBuildsByReleaseId(params?.releaseId ?? null)
+
+  const handleSelectBuild = (build: PackageBuild) => {
+    setLocation(`/build/${build.package_build_id}`)
+  }
+
+  if (isLoadingPackage || isLoadingRelease || isLoadingBuilds) {
+    return null
+  }
+
+  if (packageError?.status === 404 || !pkg) {
+    return <NotFoundPage heading="Package Not Found" />
+  }
+
+  if (releaseError?.status === 404 || !packageRelease) {
+    return <NotFoundPage heading="Release Not Found" />
+  }
+
+  if (buildsError?.status === 404 || !builds?.length) {
+    return <NotFoundPage heading="No Builds Found for Release" />
+  }
+
+  return (
+    <>
+      <Header />
+      <div className="min-h-screen bg-white">
+        <div className="bg-gray-50 border-b py-10">
+          <div className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8">
+            <PackageBreadcrumb
+              author={params?.author || ""}
+              packageName={packageName || ""}
+              unscopedName={pkg.unscoped_name}
+              currentPage="builds"
+              releaseVersion={
+                packageRelease.version ||
+                `v${packageRelease.package_release_id.slice(-6)}`
+              }
+            />
+            <div className="flex items-center gap-4">
+              <div>
+                <h1 className="text-3xl font-bold text-gray-900">
+                  {pkg.name} - Release Builds
+                </h1>
+                <p className="text-gray-600 mt-2">
+                  All builds for release {packageRelease.package_release_id}
+                </p>
+              </div>
+            </div>
+          </div>
+        </div>
+
+        <div className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-8">
+          <div className="space-y-6">
+            <div className="flex items-center justify-between">
+              <h2 className="text-2xl font-bold text-gray-900">All Builds</h2>
+              <p className="text-sm text-gray-600">
+                {builds?.length} build{builds?.length !== 1 ? "s" : ""} found
+              </p>
+            </div>
+            {pkg && <BuildsList pkg={pkg} />}
+          </div>
+        </div>
+      </div>
+    </>
+  )
+}

package/src/pages/release-detail.tsx

@@ -0,0 +1,118 @@
+import { useParams } from "wouter"
+import NotFoundPage from "./404"
+import { usePackageByName } from "@/hooks/use-package-by-package-name"
+import { usePackageReleaseByIdOrVersion } from "@/hooks/use-package-release-by-id-or-version"
+import { usePackageBuild } from "@/hooks/use-package-builds"
+import { ConnectedRepoOverview } from "@/components/preview/ConnectedRepoOverview"
+import Header from "@/components/Header"
+import { Badge } from "@/components/ui/badge"
+import { Button } from "@/components/ui/button"
+import { Calendar, GitBranch, Hash, Copy, Check } from "lucide-react"
+import { useState } from "react"
+import { formatTimeAgo } from "@/lib/utils/formatTimeAgo"
+import { PackageBreadcrumb } from "@/components/PackageBreadcrumb"
+
+export default function ReleaseDetailPage() {
+  const params = useParams<{
+    author: string
+    packageName: string
+    releaseId?: string
+    packageReleaseId?: string
+  }>()
+
+  const packageName =
+    params?.author && params?.packageName
+      ? `${params.author}/${params.packageName}`
+      : null
+
+  const [copied, setCopied] = useState(false)
+
+  const {
+    data: pkg,
+    isLoading: isLoadingPackage,
+    error: packageError,
+  } = usePackageByName(packageName)
+
+  const releaseIdOrVersion =
+    params?.releaseId ?? params?.packageReleaseId ?? null
+
+  const {
+    data: packageRelease,
+    isLoading: isLoadingRelease,
+    error: releaseError,
+  } = usePackageReleaseByIdOrVersion(releaseIdOrVersion, packageName)
+
+  const {
+    data: latestBuild,
+    isLoading: isLoadingBuild,
+    error: buildError,
+  } = usePackageBuild(packageRelease?.latest_package_build_id ?? null)
+
+  if (isLoadingPackage || isLoadingRelease || isLoadingBuild) {
+    return null
+  }
+
+  if (packageError?.status === 404 || !pkg) {
+    return <NotFoundPage heading="Package Not Found" />
+  }
+
+  if (releaseError?.status === 404 || !packageRelease) {
+    return <NotFoundPage heading="Release Not Found" />
+  }
+
+  if (buildError?.status === 404 || !latestBuild) {
+    return <NotFoundPage heading="No Builds Found for Release" />
+  }
+
+  return (
+    <>
+      <Header />
+      <div className="min-h-screen bg-white">
+        {/* Page Header */}
+        <div className="bg-gray-50 border-b py-6">
+          <div className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8">
+            {/* Breadcrumb */}
+            <PackageBreadcrumb
+              author={pkg.owner_github_username || ""}
+              packageName={pkg.name}
+              unscopedName={pkg.unscoped_name}
+              releaseVersion={
+                packageRelease.version ||
+                `v${packageRelease.package_release_id.slice(-6)}`
+              }
+            />
+
+            {/* Header Content */}
+            <div className="flex flex-col lg:flex-row lg:items-start lg:justify-between gap-2">
+              <div className="flex-1">
+                <div className="flex items-center gap-4 text-sm text-gray-600">
+                  {packageRelease.is_pr_preview && (
+                    <div className="flex items-center gap-1">
+                      <GitBranch className="w-4 h-4" />
+                      <Badge variant="outline" className="text-xs">
+                        PR #{packageRelease.github_pr_number}
+                      </Badge>
+                    </div>
+                  )}
+                  <div className="flex items-center gap-1">
+                    <Calendar className="w-4 h-4" />
+                    <span>
+                      Created {formatTimeAgo(packageRelease.created_at)}
+                    </span>
+                  </div>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+
+        {/* Main Content */}
+        <ConnectedRepoOverview
+          build={latestBuild}
+          pkg={pkg}
+          packageRelease={packageRelease}
+        />
+      </div>
+    </>
+  )
+}

package/src/pages/releases.tsx

@@ -0,0 +1,51 @@
+import { useParams } from "wouter"
+import NotFoundPage from "./404"
+import { useLatestPackageRelease } from "@/hooks/use-package-release"
+import { usePackageBuild } from "@/hooks/use-package-builds"
+import { usePackageByName } from "@/hooks/use-package-by-package-name"
+import { PackageReleasesDashboard } from "@/components/preview/PackageReleasesDashboard"
+
+export default function ReleasesPage() {
+  const params = useParams<{ author: string; packageName: string }>()
+  const packageName =
+    params?.author && params?.packageName
+      ? `${params.author}/${params.packageName}`
+      : null
+
+  const {
+    data: pkg,
+    isLoading: isLoadingPackage,
+    error: packageError,
+  } = usePackageByName(packageName)
+
+  const {
+    data: latestRelease,
+    isLoading: isLoadingRelease,
+    error: releaseError,
+  } = useLatestPackageRelease(pkg?.package_id ?? null)
+
+  // Get the latest build for the latest release to show status and metadata
+  const {
+    data: latestBuild,
+    isLoading: isLoadingBuild,
+    error: buildError,
+  } = usePackageBuild(latestRelease?.latest_package_build_id ?? null)
+
+  if (isLoadingPackage || isLoadingRelease || isLoadingBuild) {
+    return null
+  }
+
+  if (packageError?.status === 404 || !pkg) {
+    return <NotFoundPage heading="Package Not Found" />
+  }
+
+  if (releaseError?.status === 404 || !latestRelease) {
+    return <NotFoundPage heading="No Releases Found" />
+  }
+
+  // If there's no build, we still want to show the releases page
+  // The PackageReleasesDashboard will handle the case where latestBuild is null
+  return (
+    <PackageReleasesDashboard latestBuild={latestBuild ?? null} pkg={pkg} />
+  )
+}

package/fake-snippets-api/routes/api/package_builds/latest.ts

@@ -1,109 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-import { publicMapPackageBuild } from "fake-snippets-api/lib/public-mapping/public-map-package-build"
-
-export default withRouteSpec({
-  methods: ["GET"],
-  auth: "session",
-  queryParams: z.object({
-    package_id: z.string().optional(),
-    package_release_id: z.string().optional(),
-  }),
-  jsonResponse: z.object({
-    package_build: z.any().nullable(),
-  }),
-})(async (req, ctx) => {
-  const { package_id, package_release_id } = req.query
-
-  if (!package_id && !package_release_id) {
-    return ctx.error(400, {
-      error_code: "invalid_request",
-      message: "Either package_id or package_release_id must be provided",
-    })
-  }
-
-  let targetPackageId = package_id
-
-  if (package_release_id) {
-    const packageRelease = ctx.db.packageReleases.find(
-      (pr) => pr.package_release_id === package_release_id,
-    )
-    if (!packageRelease) {
-      return ctx.error(404, {
-        error_code: "package_release_not_found",
-        message: "Package release not found",
-      })
-    }
-    targetPackageId = packageRelease.package_id
-  }
-
-  if (targetPackageId) {
-    const pkg = ctx.db.packages.find((p) => p.package_id === targetPackageId)
-    if (!pkg) {
-      return ctx.error(404, {
-        error_code: "package_not_found",
-        message: "Package not found",
-      })
-    }
-    if (pkg.creator_account_id !== ctx.auth.account_id) {
-      console.log(
-        pkg.creator_account_id !== ctx.auth.account_id,
-        pkg.creator_account_id,
-        ctx.auth.account_id,
-      )
-      return ctx.error(403, {
-        error_code: "unauthorized",
-        message: "You are not authorized to access this package",
-      })
-    }
-  }
-
-  let builds = ctx.db.packageBuilds
-
-  if (package_id) {
-    const packageReleases = ctx.db.packageReleases.filter(
-      (x) => x.package_id === package_id,
-    )
-    if (packageReleases.length === 0) {
-      return ctx.error(404, {
-        error_code: "package_not_found",
-        message: "Package not found",
-      })
-    }
-
-    const packageReleaseIds = packageReleases
-      .filter((pr) => pr.package_id === package_id)
-      .map((pr) => pr.package_release_id)
-
-    builds = builds.filter((build) =>
-      packageReleaseIds.includes(build.package_release_id),
-    )
-  }
-
-  if (package_release_id) {
-    builds = builds.filter(
-      (build) => build.package_release_id === package_release_id,
-    )
-  }
-
-  builds = builds.sort(
-    (a, b) =>
-      new Date(b.created_at).getTime() - new Date(a.created_at).getTime(),
-  )
-
-  const latestBuild = builds[0] || null
-
-  if (!latestBuild) {
-    return ctx.json({
-      package_build: null,
-    })
-  }
-
-  const publicBuild = publicMapPackageBuild(latestBuild, {
-    include_logs: true,
-  })
-
-  return ctx.json({
-    package_build: publicBuild,
-  })
-})

package/src/pages/view-connected-repo.tsx

@@ -1,49 +0,0 @@
-import { useParams } from "wouter"
-import NotFoundPage from "./404"
-import { ConnectedRepoDashboard } from "@/components/preview"
-import { usePackageBuild } from "@/hooks/use-package-builds"
-import { usePackageReleaseById } from "@/hooks/use-package-release"
-import { usePackageById } from "@/hooks/use-package-by-package-id"
-
-export default function ViewConnectedRepoOverview() {
-  const params = useParams<{ buildId: string }>()
-  const {
-    data: packageBuild,
-    isLoading: isLoadingBuild,
-    error: buildError,
-  } = usePackageBuild(params?.buildId)
-  const {
-    data: packageRelease,
-    isLoading: isLoadingRelease,
-    error: releaseError,
-  } = usePackageReleaseById(packageBuild?.package_release_id)
-  const {
-    data: buildPackage,
-    isLoading: isLoadingPackage,
-    error: packageError,
-  } = usePackageById(String(packageRelease?.package_id))
-
-  if (isLoadingBuild || isLoadingRelease || isLoadingPackage) {
-    return null
-  }
-
-  if (buildError?.status === 404 || !packageBuild) {
-    return <NotFoundPage heading="Build Not Found" />
-  }
-
-  if (releaseError?.status === 404 || !packageRelease) {
-    return <NotFoundPage heading="Package Release Not Found" />
-  }
-
-  if (packageError?.status === 404 || !buildPackage) {
-    return <NotFoundPage heading="Package Not Found" />
-  }
-
-  return (
-    <ConnectedRepoDashboard
-      latestBuild={packageBuild}
-      pkg={buildPackage}
-      packageRelease={packageRelease}
-    />
-  )
-}