@tscircuit/fake-snippets 0.0.105 → 0.0.106

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

@@ -0,0 +1,70 @@
+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_build_id: z.string(),
+  }),
+  jsonResponse: z.object({
+    package_build: z.any(),
+  }),
+})(async (req, ctx) => {
+  const { package_build_id } = req.query
+
+  if (!package_build_id) {
+    return ctx.error(400, {
+      error_code: "invalid_request",
+      message: "package_build_id is required",
+    })
+  }
+
+  const packageBuild = ctx.db.packageBuilds.find(
+    (build) => build.package_build_id === package_build_id,
+  )
+
+  if (!packageBuild) {
+    return ctx.error(404, {
+      error_code: "package_build_not_found",
+      message: "Package build not found",
+    })
+  }
+
+  const packageRelease = ctx.db.packageReleases.find(
+    (pr) => pr.package_release_id === packageBuild.package_release_id,
+  )
+
+  if (!packageRelease) {
+    return ctx.error(404, {
+      error_code: "package_release_not_found",
+      message: "Package release not found",
+    })
+  }
+
+  const pkg = ctx.db.packages.find(
+    (p) => p.package_id === packageRelease.package_id,
+  )
+  if (!pkg) {
+    return ctx.error(404, {
+      error_code: "package_not_found",
+      message: "Package not found",
+    })
+  }
+
+  if (pkg.creator_account_id !== ctx.auth.account_id) {
+    return ctx.error(403, {
+      error_code: "unauthorized",
+      message: "You are not authorized to access this package build",
+    })
+  }
+
+  const publicBuild = publicMapPackageBuild(packageBuild, {
+    include_logs: true,
+  })
+
+  return ctx.json({
+    package_build: publicBuild,
+  })
+})

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

@@ -0,0 +1,109 @@
+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/fake-snippets-api/routes/api/package_builds/list.ts

@@ -0,0 +1,98 @@
+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_builds: z.array(z.any()),
+  }),
+})(async (req, ctx) => {
+  const { package_id, package_release_id } = req.query
+  console.log(ctx.db.packageBuilds)
+  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) {
+      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 publicBuilds = builds.map((build) =>
+    publicMapPackageBuild(build, {
+      include_logs: false,
+    }),
+  )
+
+  return ctx.json({
+    package_builds: publicBuilds,
+  })
+})

package/package.json

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

package/src/App.tsx

@@ -143,7 +143,8 @@ class ErrorBoundary extends React.Component<
     this.cleanup() // Clean up listeners before reload
     this.setState({ reloading: true })
     this.reloadTimeout = window.setTimeout(() => {
-      // window.location.reload()
+      if (window?.location.href.includes("localhost:")) return
+      window.location.reload()
     }, 500)
   }
 

package/src/components/ViewPackagePage/components/sidebar-releases-section.tsx

@@ -5,12 +5,9 @@ import { usePackageReleaseById } from "@/hooks/use-package-release"
 import { timeAgo } from "@/lib/utils/timeAgo"
 import { BuildStatus, BuildStep } from "./build-status"
 import type { PackageRelease } from "fake-snippets-api/lib/db/schema"
-import {
-  getBuildStatus,
-  getLatestBuildFromPackageRelease,
-  StatusIcon,
-} from "@/components/preview"
+import { getBuildStatus, StatusIcon } from "@/components/preview"
 import { PrefetchPageLink } from "@/components/PrefetchPageLink"
+import { useLatestPackageBuildByReleaseId } from "@/hooks/use-package-builds"
 
 function getTranspilationStatus(
   pr?: PackageRelease | null,
@@ -45,6 +42,9 @@ export default function SidebarReleasesSection() {
   const { data: packageRelease } = usePackageReleaseById(
     packageInfo?.latest_package_release_id,
   )
+  const { data: latestBuild } = useLatestPackageBuildByReleaseId(
+    packageRelease?.package_release_id,
+  )
 
   const buildSteps: BuildStep[] = [
     {
@@ -74,8 +74,9 @@ export default function SidebarReleasesSection() {
     )
   }
 
-  const latestBuild = getLatestBuildFromPackageRelease(packageRelease)
-  const { status, label } = getBuildStatus(latestBuild)
+  const { status, label } = latestBuild
+    ? getBuildStatus(latestBuild)
+    : { status: "pending", label: "pending" }
   return (
     <div className="mb-6">
       <h2 className="text-lg font-semibold mb-2">Releases</h2>