@tscircuit/fake-snippets 0.0.6 → 0.0.7

package/fake-snippets-api/lib/db/db-client.ts

@@ -18,6 +18,7 @@ import {
   packageSchema,
   Package,
   PackageRelease,
+  PackageFile,
 } from "./schema.ts"
 import { combine } from "zustand/middleware"
 import { seed as seedFn } from "./seed"
@@ -417,4 +418,16 @@ const initializer = combine(databaseSchema.parse({}), (set, get) => ({
       ),
     }))
   },
+  addPackageFile: (
+    packageFile: Omit<PackageFile, "package_file_id">,
+  ): PackageFile => {
+    const newPackageFile = {
+      package_file_id: `package_file_${Date.now()}`,
+      ...packageFile,
+    }
+    set((state) => ({
+      packageFiles: [...state.packageFiles, newPackageFile],
+    }))
+    return newPackageFile
+  },
 }))

package/fake-snippets-api/lib/package_file/get-package-file-id-from-file-descriptor.ts

@@ -0,0 +1,168 @@
+import { NotFoundError } from "winterspec/middleware"
+import * as ZT from "../db/schema"
+export const getPackageFileIdFromFileDescriptor = async (
+  descriptor:
+    | { 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 },
+  ctx: { db: any },
+): Promise<string> => {
+  if ("package_file_id" in descriptor) {
+    const packageFile = ctx.db.packageFiles.find(
+      (pf: ZT.PackageFile) => pf.package_file_id === descriptor.package_file_id,
+    )
+
+    if (!packageFile) {
+      throw new NotFoundError("Package file not found")
+    }
+
+    return descriptor.package_file_id
+  }
+
+  if ("package_release_id" in descriptor) {
+    const { package_release_id, file_path } = descriptor
+    const packageFile = ctx.db.packageFiles.find(
+      (pf: ZT.PackageFile) =>
+        pf.package_release_id === package_release_id &&
+        pf.file_path === file_path,
+    )
+
+    if (!packageFile) {
+      throw new NotFoundError("Package file not found")
+    }
+
+    return packageFile.package_file_id
+  }
+
+  if ("package_id" in descriptor) {
+    const { package_id, version, file_path } = descriptor
+
+    // Verify package exists
+    const pkg = ctx.db.packages.find(
+      (p: ZT.Package) => p.package_id === package_id,
+    )
+    if (!pkg) {
+      throw new NotFoundError("Package not found")
+    }
+
+    // Find the package release
+    let packageRelease
+    if (version) {
+      packageRelease = ctx.db.packageReleases.find(
+        (pr: ZT.PackageRelease) =>
+          pr.package_id === package_id && pr.version === version,
+      )
+    } else {
+      packageRelease = ctx.db.packageReleases.find(
+        (pr: ZT.PackageRelease) => pr.package_id === package_id && pr.is_latest,
+      )
+    }
+
+    if (!packageRelease) {
+      throw new NotFoundError("Package release not found")
+    }
+
+    // Find the file
+    const packageFile = ctx.db.packageFiles.find(
+      (pf: ZT.PackageFile) =>
+        pf.package_release_id === packageRelease.package_release_id &&
+        pf.file_path === file_path,
+    )
+
+    if (!packageFile) {
+      throw new NotFoundError("Package file not found")
+    }
+
+    return packageFile.package_file_id
+  }
+
+  if ("package_name" in descriptor) {
+    const { package_name, version, file_path } = descriptor
+
+    // Find the package first
+    const pkg = ctx.db.packages.find((p: ZT.Package) => p.name === package_name)
+    if (!pkg) {
+      throw new NotFoundError(`Package not found: ${package_name}`)
+    }
+
+    // Find the package release
+    let packageRelease
+    if (version) {
+      packageRelease = ctx.db.packageReleases.find(
+        (pr: ZT.PackageRelease) =>
+          pr.package_id === pkg.package_id && pr.version === version,
+      )
+    } else {
+      packageRelease = ctx.db.packageReleases.find(
+        (pr: ZT.PackageRelease) =>
+          pr.package_id === pkg.package_id && pr.is_latest,
+      )
+    }
+
+    if (!packageRelease) {
+      throw new NotFoundError("Package release not found")
+    }
+
+    // Find the file
+    const packageFile = ctx.db.packageFiles.find(
+      (pf: ZT.PackageFile) =>
+        pf.package_release_id === packageRelease.package_release_id &&
+        pf.file_path === file_path,
+    )
+
+    if (!packageFile) {
+      throw new NotFoundError("Package file not found")
+    }
+
+    return packageFile.package_file_id
+  }
+
+  if ("package_name_with_version" in descriptor) {
+    const { package_name_with_version, file_path } = descriptor
+    const packageName = package_name_with_version.split("@")[1]
+    const version = package_name_with_version.split("@")[2]
+
+    // Find the package
+    const pkg = ctx.db.packages.find((p: ZT.Package) => p.name === packageName)
+    if (!pkg) {
+      throw new NotFoundError(`Package not found: ${packageName}`)
+    }
+
+    // Find the package release
+    let packageRelease
+    if (!version || version === "latest") {
+      packageRelease = ctx.db.packageReleases.find(
+        (pr: ZT.PackageRelease) =>
+          pr.package_id === pkg.package_id && pr.is_latest,
+      )
+    } else {
+      packageRelease = ctx.db.packageReleases.find(
+        (pr: ZT.PackageRelease) =>
+          pr.package_id === pkg.package_id && pr.version === version,
+      )
+    }
+
+    if (!packageRelease) {
+      throw new NotFoundError(
+        `Package release not found for version: ${version || "latest"}`,
+      )
+    }
+
+    // Find the file
+    const packageFile = ctx.db.packageFiles.find(
+      (pf: ZT.PackageFile) =>
+        pf.package_release_id === packageRelease.package_release_id &&
+        pf.file_path === file_path,
+    )
+
+    if (!packageFile) {
+      throw new NotFoundError(`Package file not found: ${file_path}`)
+    }
+
+    return packageFile.package_file_id
+  }
+
+  throw new NotFoundError("Invalid package file descriptor")
+}

package/fake-snippets-api/lib/package_release/find-package-release-id.ts

@@ -0,0 +1,122 @@
+import { Package, PackageRelease } from "fake-snippets-api/lib/db/schema"
+
+export const findPackageReleaseId = async (
+  params:
+    | string
+    | {
+        package_release_id: string
+      }
+    | {
+        package_name: string
+        use_latest_version: true
+      }
+    | {
+        package_name_with_version: string
+      }
+    | {
+        package_release_id?: string | undefined
+        package_name_with_version?: string | undefined
+      },
+  ctx: { db: any },
+): Promise<string | null> => {
+  if (typeof params === "string") {
+    return findPackageReleaseIdFromPackageNameWithVersion(params, ctx.db)
+  }
+
+  if (
+    "package_name_with_version" in params &&
+    params.package_name_with_version
+  ) {
+    const { package_name_with_version } = params
+
+    if (package_name_with_version.endsWith("@latest")) {
+      const [packageName] = package_name_with_version.split("@")
+      return findPackageReleaseId(
+        {
+          package_name: packageName!,
+          use_latest_version: true,
+        },
+        ctx,
+      )
+    }
+    return findPackageReleaseIdFromPackageNameWithVersion(
+      package_name_with_version!,
+      ctx.db,
+    )
+  }
+
+  if ("package_release_id" in params && params.package_release_id) {
+    const packageRelease = ctx.db.packageReleases.find(
+      (pr: PackageRelease) =>
+        pr.package_release_id === params.package_release_id,
+    )
+    if (!packageRelease) {
+      return null
+    }
+    return params.package_release_id
+  }
+
+  if ("package_name" in params) {
+    const { package_name, use_latest_version } = params
+
+    if (!use_latest_version) {
+      throw new Error("use_latest_version must be true")
+    }
+
+    const pkg = ctx.db.packages.find(
+      (p: Package) => p.name === package_name.replace(/^@/, ""),
+    )
+    if (!pkg) {
+      return null
+    }
+
+    const packageRelease = ctx.db.packageReleases.find(
+      (pr: PackageRelease) => pr.package_id === pkg.package_id && pr.is_latest,
+    )
+
+    if (!packageRelease) {
+      return null
+    }
+
+    return packageRelease.package_release_id
+  }
+
+  return null
+}
+
+export const findPackageReleaseIdFromPackageNameWithVersion = (
+  packageNameWithVersion: string,
+  db: any,
+): string | null => {
+  if (!packageNameWithVersion) return null
+
+  const [packageName, version] = packageNameWithVersion
+    .replace(/^@/, "")
+    .split("@")
+
+  const pkg = db.packages.find((p: Package) => p.name === packageName)
+  if (!pkg) {
+    return null
+  }
+
+  let packageRelease
+
+  if (!version || version === "latest") {
+    packageRelease = db.packageReleases.find(
+      (pr: PackageRelease) => pr.package_id === pkg.package_id && pr.is_latest,
+    )
+  } else {
+    packageRelease = db.packageReleases.find(
+      (pr: PackageRelease) =>
+        pr.package_id === pkg.package_id && pr.version === version,
+    )
+  }
+
+  if (!packageRelease) {
+    return null
+  }
+
+  console.log("packageRelease", packageRelease)
+
+  return packageRelease.package_release_id
+}

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

@@ -0,0 +1,132 @@
+import * as zt from "fake-snippets-api/lib/db/schema"
+import { findPackageReleaseId } from "fake-snippets-api/lib/package_release/find-package-release-id"
+import { withRouteSpec } from "fake-snippets-api/lib/with-winter-spec"
+import { z } from "zod"
+
+const routeSpec = {
+  methods: ["POST"],
+  auth: "none",
+  jsonBody: z
+    .object({
+      file_path: z.string(),
+      is_release_tarball: z.boolean().optional().default(false),
+      content_mimetype: z.string().optional(),
+      content_text: z.string().optional(),
+      content_base64: z.string().optional(),
+      package_release_id: z.string().optional(),
+      package_name_with_version: z.string().optional(),
+      npm_pack_output: z.any().optional(),
+    })
+    .refine((v) => {
+      if (v.package_release_id) return true
+      if (v.package_name_with_version) return true
+      return false
+    }, "Must specify either package_release_id or package_name_with_version")
+    .refine((v) => {
+      if (v.package_release_id && v.package_name_with_version) return false
+      return true
+    }, "Cannot specify both package_release_id and package_name_with_version")
+    .refine((v) => {
+      if (v.content_base64 && v.content_text) return false
+      if (!v.content_base64 && !v.content_text) return false
+      return true
+    }, "Either content_base64 or content_text is required"),
+  jsonResponse: z.object({
+    ok: z.boolean(),
+    package_file: zt.packageFileSchema,
+  }),
+} as const
+
+export default withRouteSpec(routeSpec)(async (req, ctx) => {
+  const {
+    file_path,
+    content_mimetype: providedContentMimetype,
+    content_base64,
+    content_text,
+    is_release_tarball,
+    npm_pack_output,
+  } = req.jsonBody
+
+  if (is_release_tarball && !npm_pack_output) {
+    return ctx.error(400, {
+      error_code: "missing_options",
+      message: "npm_pack_output is required for release tarballs",
+    })
+  }
+
+  if (!is_release_tarball && npm_pack_output) {
+    return ctx.error(404, {
+      error_code: "invalid_options",
+      message: "npm_pack_output is only valid for release tarballs",
+    })
+  }
+
+  let packageReleaseId = req.jsonBody.package_release_id
+
+  if (!packageReleaseId && req.jsonBody.package_name_with_version) {
+    const foundPackageReleaseId = await findPackageReleaseId(
+      req.jsonBody.package_name_with_version,
+      ctx,
+    )
+    if (foundPackageReleaseId) {
+      packageReleaseId = foundPackageReleaseId
+    }
+  }
+
+  if (!packageReleaseId) {
+    return ctx.error(404, {
+      error_code: "package_release_not_found",
+      message: "Package release not found",
+    })
+  }
+
+  // Verify the package release exists
+  const packageRelease = ctx.db.packageReleases.find(
+    (pr) => pr.package_release_id === packageReleaseId,
+  )
+
+  if (!packageRelease) {
+    return ctx.error(404, {
+      error_code: "package_release_not_found",
+      message: "Package release not found",
+    })
+  }
+
+  // Determine content mimetype
+  const contentMimetype =
+    providedContentMimetype ||
+    (file_path.endsWith(".ts") || file_path.endsWith(".tsx")
+      ? "text/typescript"
+      : null) ||
+    (file_path.endsWith(".js") ? "application/javascript" : null) ||
+    (file_path.endsWith(".json") ? "application/json" : null) ||
+    (file_path.endsWith(".md") ? "text/markdown" : null) ||
+    (file_path.endsWith(".html") ? "text/html" : null) ||
+    (file_path.endsWith(".css") ? "text/css" : null) ||
+    "application/octet-stream"
+
+  // Create the package file
+  const newPackageFile = {
+    package_file_id: crypto.randomUUID(),
+    package_release_id: packageReleaseId,
+    file_path,
+    content_text:
+      content_text ||
+      (content_base64
+        ? Buffer.from(content_base64, "base64").toString()
+        : null),
+    content_mimetype: contentMimetype,
+    is_directory: false,
+    is_release_tarball: is_release_tarball || false,
+    npm_pack_output: npm_pack_output || null,
+    created_at: new Date().toISOString(),
+  }
+
+  // Add to the test database
+  ctx.db.addPackageFile(newPackageFile)
+
+  return ctx.json({
+    ok: true,
+    package_file: newPackageFile,
+  })
+})

package/fake-snippets-api/routes/api/package_files/download.ts

@@ -1,170 +1,87 @@
+import { getPackageFileIdFromFileDescriptor } from "fake-snippets-api/lib/package_file/get-package-file-id-from-file-descriptor"
+import { findPackageReleaseId } from "fake-snippets-api/lib/package_release/find-package-release-id"
 import { withRouteSpec } from "fake-snippets-api/lib/with-winter-spec"
 import { z } from "zod"
 
-export default withRouteSpec({
-  methods: ["GET"],
+const routeSpec = {
+  methods: ["GET", "POST"],
   auth: "none",
-  queryParams: z.object({
-    jsdelivr_resolve: z
-      .enum(["true", "false"])
-      .optional()
-      .transform((v) => v === "true"),
-    jsdelivr_path: z.string(),
-  }),
-  jsonResponse: z.any(),
-})(async (req, ctx) => {
-  const { jsdelivr_path, jsdelivr_resolve } = req.query
-
-  // Parse the file path
-  const [owner, packageWithVersion, ...rest] = jsdelivr_path.split("/")
-  if (!packageWithVersion) {
-    return ctx.error(400, {
-      error_code: "invalid_path",
-      message: "Invalid path",
+  queryParams: z
+    .object({
+      package_file_id: z.string(),
     })
-  }
-  const [packageName, version] = packageWithVersion.split("@")
-  const fileName = rest.join("/")
+    .or(
+      z.object({
+        package_name_with_version: z.string(),
+        file_path: z.string(),
+      }),
+    ),
+  jsonResponse: z.any(), // Using any because we're returning binary data
+} as const
 
-  // Find the snippet
-  // const snippet =
+export default withRouteSpec(routeSpec)(async (req, ctx) => {
+  let packageFileId: string | undefined
+  const params = req.query
 
-  // if (!snippet) {
-  //   return ctx.error(404, {
-  //     error_code: "snippet_not_found",
-  //     message: "Snippet not found",
-  //   })
-  // }
+  if ("package_file_id" in params) {
+    packageFileId = params.package_file_id
+  } else if ("package_name_with_version" in params) {
+    const { package_name_with_version, file_path } = params
 
-  // if (!fileName && !jsdelivr_resolve) {
-  //   return new Response(
-  //     JSON.stringify({
-  //       tags: {
-  //         latest: "0.0.1",
-  //       },
-  //       versions: ["0.0.1"],
-  //     }),
-  //     {
-  //       status: 200,
-  //       headers: { "Content-Type": "application/json" },
-  //     },
-  //   )
-  // }
+    const packageReleaseId = await findPackageReleaseId(
+      package_name_with_version,
+      ctx,
+    )
 
-  // if (!fileName && jsdelivr_resolve) {
-  //   return new Response(
-  //     JSON.stringify({
-  //       version: "0.0.1",
-  //     }),
-  //     {
-  //       status: 200,
-  //       headers: { "Content-Type": "application/json" },
-  //     },
-  //   )
-  // }
+    if (!packageReleaseId) {
+      return ctx.error(404, {
+        error_code: "not_found",
+        message: "Package release not found",
+      })
+    }
 
-  // const latestRelease = await ctx.db
-  //   .selectFrom("main.package_release")
-  //   .where("package_id", "=", snippet.snippet_id)
-  //   .where("is_latest", "=", true)
-  //   .selectAll()
-  //   .executeTakeFirst()
-
-  // const dtsFile = await ctx.db
-  //   .selectFrom("main.package_file")
-  //   .where("package_release_id", "=", latestRelease!.package_release_id)
-  //   .where("file_path", "=", "/dist/index.d.ts")
-  //   .select("content_text")
-  //   .executeTakeFirst()
+    try {
+      packageFileId = await getPackageFileIdFromFileDescriptor(
+        {
+          package_release_id: packageReleaseId,
+          file_path: file_path,
+        },
+        ctx,
+      )
+    } catch (error) {
+      return ctx.error(404, {
+        error_code: "not_found",
+        message: "Package file not found",
+      })
+    }
+  }
 
-  // // If no fileName is provided, return the directory listing
-  // if (!fileName || fileName === "flat") {
-  //   const files = [
-  //     {
-  //       type: "file",
-  //       name: "index.ts",
-  //       hash: "placeholder_hash",
-  //       time: snippet.updated_at,
-  //       size: snippet.code?.length ?? 0,
-  //     },
-  //     {
-  //       type: "file",
-  //       name: "index.d.ts",
-  //       hash: "placeholder_hash",
-  //       time: snippet.updated_at,
-  //       size: dtsFile?.content_text?.length ?? 0,
-  //     },
-  //     {
-  //       type: "file",
-  //       name: "package.json",
-  //       hash: "placeholder_hash",
-  //       time: snippet.updated_at,
-  //       size: JSON.stringify({
-  //         name: `@tsci/${owner}.${packageName}`,
-  //         version: version || "0.0.1",
-  //         main: "index.ts",
-  //         types: "index.d.ts",
-  //       }).length,
-  //     },
-  //   ]
+  if (!packageFileId) {
+    return ctx.error(400, {
+      error_code: "bad_request",
+      message: "Could not determine package_file_id",
+    })
+  }
 
-  //   const response = {
-  //     default: "/index.ts",
-  //     files:
-  //       fileName === "flat"
-  //         ? files.map((f) => ({
-  //             name: `/${f.name}`,
-  //             hash: f.hash,
-  //             time: f.time,
-  //             size: f.size,
-  //           }))
-  //         : [
-  //             {
-  //               type: "directory",
-  //               name: ".",
-  //               files: files,
-  //             },
-  //           ],
-  //   }
+  const packageFile = ctx.db.packageFiles.find(
+    (pf) => pf.package_file_id === packageFileId,
+  )
 
-  //   return new Response(JSON.stringify(response, null, 2), {
-  //     status: 200,
-  //     headers: { "Content-Type": "application/json" },
-  //   })
-  // }
+  if (!packageFile) {
+    return ctx.error(404, {
+      error_code: "not_found",
+      message: "Package file not found",
+    })
+  }
 
-  // // Handle file downloads
-  // let content: string
-  // switch (fileName) {
-  //   case "index.ts":
-  //     content = snippet.code ?? ""
-  //     break
-  //   case "index.d.ts":
-  //     content = dtsFile?.content_text ?? ""
-  //     break
-  //   case "package.json":
-  //     content = JSON.stringify(
-  //       {
-  //         name: `@tsci/${owner}.${packageName}`,
-  //         version: version || "0.0.1",
-  //         main: "index.ts",
-  //         types: "index.d.ts",
-  //       },
-  //       null,
-  //       2,
-  //     )
-  //     break
-  //   default:
-  //     return ctx.error(404, {
-  //       error_code: "file_not_found",
-  //       message: "Requested file not found",
-  //     })
-  // }
+  const contentType = "text/plain"
 
-  const content = "TODO"
+  const headers = {
+    "Content-Type": contentType,
+    "Content-Disposition": `attachment; filename="${packageFile.file_path.split("/").pop()}"`,
+    "Cache-Control": "public, max-age=86400, stale-while-revalidate=604800",
+    Expires: new Date(Date.now() + 86400000).toUTCString(),
+  }
 
-  return new Response(content, {
-    status: 200,
-    headers: { "Content-Type": "text/plain" },
-  })
+  return new Response(packageFile.content_text, { headers })
 })