@tscircuit/fake-snippets 0.0.6 → 0.0.8

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 })
 })

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

@@ -1,24 +1,24 @@
 import { withRouteSpec } from "fake-snippets-api/lib/with-winter-spec"
 import { z } from "zod"
 import * as ZT from "fake-snippets-api/lib/db/schema"
-import { NotFoundError } from "winterspec/middleware"
+import { getPackageFileIdFromFileDescriptor } from "fake-snippets-api/lib/package_file/get-package-file-id-from-file-descriptor"
 
 const routeSpec = {
   methods: ["POST"],
   auth: "none",
   jsonBody: z
     .object({
-      package_file_id: z.string().uuid(),
+      package_file_id: z.string(),
     })
     .or(
       z.object({
-        package_release_id: z.string().uuid(),
+        package_release_id: z.string(),
         file_path: z.string(),
       }),
     )
     .or(
       z.object({
-        package_id: z.string().uuid(),
+        package_id: z.string(),
         version: z.string().optional(),
         file_path: z.string(),
       }),
@@ -45,8 +45,27 @@ const routeSpec = {
 } as const
 
 export default withRouteSpec(routeSpec)(async (req, ctx) => {
+  const packageFileId = await getPackageFileIdFromFileDescriptor(
+    req.jsonBody,
+    ctx,
+  )
+
+  const packageFile = ctx.db.packageFiles.find(
+    (pf: ZT.PackageFile) => pf.package_file_id === packageFileId,
+  )
+
+  if (!packageFile) {
+    return ctx.error(404, {
+      error_code: "package_file_not_found",
+      message: "Package file not found",
+    })
+  }
+
   return ctx.json({
     ok: true,
-    package_file: undefined,
+    package_file: {
+      ...packageFile,
+      created_at: packageFile.created_at.toString(),
+    },
   })
 })

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

@@ -1,13 +1,14 @@
 import { withRouteSpec } from "fake-snippets-api/lib/with-winter-spec"
 import { z } from "zod"
 import * as ZT from "fake-snippets-api/lib/db/schema"
+import { findPackageReleaseId } from "fake-snippets-api/lib/package_release/find-package-release-id"
 
 const routeSpec = {
   methods: ["POST"],
   auth: "none",
   jsonBody: z
     .object({
-      package_release_id: z.string().uuid(),
+      package_release_id: z.string(),
     })
     .or(
       z.object({
@@ -27,34 +28,21 @@ const routeSpec = {
 } as const
 
 export default withRouteSpec(routeSpec)(async (req, ctx) => {
-  // const package_release_id = await findPackageReleaseId(req.jsonBody, ctx)
-  // if (!package_release_id) {
-  //   return ctx.error(404, {
-  //     error_code: "package_release_not_found",
-  //     message: "Package release not found",
-  //   })
-  // }
-  // const package_files = await ctx.db
-  //   .selectFrom("main.package_file")
-  //   .select([
-  //     "package_file_id",
-  //     "package_release_id",
-  //     "content_mimetype",
-  //     "file_path",
-  //     "created_at",
-  //   ])
-  //   .where("package_release_id", "=", package_release_id)
-  //   .where("file_path", "not like", ".tscircuit-internal/%")
-  //   .execute()
-  // return ctx.json({
-  //   ok: true,
-  //   package_files: package_files.map((pf) => ({
-  //     ...pf,
-  //     created_at: pf.created_at.toISOString(),
-  //   })),
-  // })
+  const packageReleaseId = await findPackageReleaseId(req.jsonBody, ctx)
+
+  if (!packageReleaseId) {
+    return ctx.error(404, {
+      error_code: "package_release_not_found",
+      message: "Package release not found",
+    })
+  }
+
+  const packageFiles = ctx.db.packageFiles.filter(
+    (file) => file.package_release_id === packageReleaseId,
+  )
+
   return ctx.json({
     ok: true,
-    package_files: [],
+    package_files: packageFiles,
   })
 })

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

@@ -30,50 +30,144 @@ export default withRouteSpec({
   } = req.jsonBody
 
   if (!unscoped_name) {
-    unscoped_name = `untitled-${snippet_type}-${ctx.db.idCounter + 1}`
+    // Count snippets of this type for this user
+    const userSnippets = ctx.db.packages.filter(
+      (p) =>
+        p.owner_github_username === ctx.auth.github_username &&
+        p.is_snippet === true &&
+        ((p.is_board && snippet_type === "board") ||
+          (p.is_package && snippet_type === "package") ||
+          (p.is_model && snippet_type === "model") ||
+          (p.is_footprint && snippet_type === "footprint")),
+    )
+    unscoped_name = `untitled-${snippet_type}-${userSnippets.length + 1}`
   }
 
-  const existingSnippet = ctx.db.snippets.find(
-    (snippet) =>
-      snippet.unscoped_name === unscoped_name &&
-      snippet.owner_name === ctx.auth.github_username,
+  const existingPackage = ctx.db.packages.find(
+    (pkg) =>
+      pkg.unscoped_name === unscoped_name &&
+      pkg.owner_github_username === ctx.auth.github_username,
   )
 
-  if (existingSnippet) {
+  if (existingPackage) {
     return ctx.error(400, {
       error_code: "snippet_already_exists",
       message: "You have already forked this snippet in your account.",
     })
   }
 
-  let newSnippet: Omit<
-    z.input<typeof snippetSchema>,
-    "snippet_id" | "package_release_id"
-  > = {
-    name: `${ctx.auth.github_username}/${unscoped_name}`,
-    unscoped_name,
-    owner_name: ctx.auth.github_username,
-    code,
-    created_at: new Date().toISOString(),
-    updated_at: new Date().toISOString(),
-    snippet_type,
-    description,
-    compiled_js,
-    circuit_json,
-    dts,
-  }
-
   try {
-    newSnippet = ctx.db.addSnippet(newSnippet)
+    // Create the package directly (which will serve as our snippet)
+    const newPackage = {
+      package_id: `pkg_${Date.now()}`,
+      creator_account_id: ctx.auth.account_id,
+      owner_org_id: ctx.auth.personal_org_id,
+      owner_github_username: ctx.auth.github_username,
+      is_source_from_github: false,
+      description: description,
+      name: `${ctx.auth.github_username}/${unscoped_name}`,
+      unscoped_name: unscoped_name,
+      latest_version: "0.0.1",
+      license: null,
+      star_count: 0,
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString(),
+      ai_description: null,
+      is_snippet: true,
+      is_board: snippet_type === "board",
+      is_package: snippet_type === "package",
+      is_model: snippet_type === "model",
+      is_footprint: snippet_type === "footprint",
+      snippet_type: snippet_type,
+      is_private: false,
+      is_public: true,
+      is_unlisted: false,
+      latest_package_release_id: "",
+    }
+
+    ctx.db.addPackage(newPackage)
+
+    const newPackageRelease = {
+      package_release_id: `package_release_${Date.now()}`,
+      package_id: newPackage.package_id,
+      version: "0.0.1",
+      is_latest: true,
+      is_locked: false,
+      created_at: newPackage.created_at,
+    }
+
+    ctx.db.addPackageRelease(newPackageRelease)
+
+    // Update the package with the release ID
+    newPackage.latest_package_release_id = newPackageRelease.package_release_id
+
+    // Add package files
+    // Add index.tsx file with the code content
+    ctx.db.addPackageFile({
+      package_release_id: newPackageRelease.package_release_id,
+      file_path: "index.tsx",
+      content_text: code,
+      created_at: new Date().toISOString(),
+    })
+
+    // Add DTS file if provided
+    if (dts) {
+      ctx.db.addPackageFile({
+        package_release_id: newPackageRelease.package_release_id,
+        file_path: "/dist/index.d.ts",
+        content_text: dts,
+        created_at: new Date().toISOString(),
+      })
+    }
+
+    // Add compiled JS if provided
+    if (compiled_js) {
+      ctx.db.addPackageFile({
+        package_release_id: newPackageRelease.package_release_id,
+        file_path: "/dist/index.js",
+        content_text: compiled_js,
+        created_at: new Date().toISOString(),
+      })
+    }
+
+    // Add circuit JSON if provided
+    if (circuit_json) {
+      ctx.db.addPackageFile({
+        package_release_id: newPackageRelease.package_release_id,
+        file_path: "/dist/circuit.json",
+        content_text: JSON.stringify(circuit_json),
+        created_at: new Date().toISOString(),
+      })
+    }
+
+    // Create the snippet response object
+    const snippetResponse = {
+      snippet_id: newPackage.package_id,
+      package_release_id: newPackageRelease.package_release_id,
+      name: newPackage.name,
+      unscoped_name: newPackage.unscoped_name,
+      owner_name: ctx.auth.github_username,
+      code,
+      dts,
+      compiled_js,
+      star_count: 0,
+      created_at: newPackage.created_at,
+      updated_at: newPackage.updated_at,
+      snippet_type: snippet_type,
+      circuit_json: circuit_json,
+      description: description,
+      is_starred: false,
+      version: "0.0.1",
+    }
+
+    return ctx.json({
+      ok: true,
+      snippet: snippetResponse,
+    })
   } catch (error) {
     return ctx.error(500, {
       error_code: "snippet_creation_failed",
       message: `Failed to create snippet: ${error}`,
     })
   }
-
-  return ctx.json({
-    ok: true,
-    snippet: newSnippet as any,
-  })
 })