@tscircuit/fake-snippets 0.0.120 → 0.0.122

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

@@ -1,194 +0,0 @@
-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: "session",
-  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 === undefined) 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(
-      { package_name_with_version: 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",
-    })
-  }
-
-  // Get the package to check permissions
-  const existingPackage = ctx.db.packages.find(
-    (p) => p.package_id === packageRelease.package_id,
-  )
-
-  if (!existingPackage) {
-    return ctx.error(404, {
-      error_code: "package_not_found",
-      message: "Package not found",
-    })
-  }
-
-  // Check if user has permission to create/update the file
-  if (existingPackage.creator_account_id !== ctx.auth.account_id) {
-    return ctx.error(403, {
-      error_code: "forbidden",
-      message: "You don't have permission to modify files in this package",
-    })
-  }
-
-  // Check if file exists
-  const exisitingFile = ctx.db.packageFiles.find(
-    (pf) =>
-      pf.package_release_id === packageReleaseId && pf.file_path === file_path,
-  )
-
-  // 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"
-
-  if (exisitingFile) {
-    const package_file = ctx.db.updatePackageFile(
-      exisitingFile.package_file_id,
-      {
-        content_text:
-          content_text ??
-          (content_base64
-            ? Buffer.from(content_base64, "base64").toString()
-            : null),
-        content_mimetype: contentMimetype,
-        is_release_tarball: is_release_tarball || false,
-        npm_pack_output: npm_pack_output || null,
-      },
-    )
-
-    // Update fs_sha for the package release
-    ctx.db.updatePackageReleaseFsSha(packageReleaseId)
-
-    return ctx.json({
-      ok: true,
-      package_file,
-    })
-  }
-
-  if (
-    !req.jsonBody.package_release_id &&
-    !req.jsonBody.package_name_with_version
-  )
-    return ctx.error(400, {
-      error_code: "missing_options",
-      message:
-        "Must specify either package_release_id or package_name_with_version",
-    })
-  // 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)
-
-  // Update fs_sha for the package release
-  ctx.db.updatePackageReleaseFsSha(packageReleaseId)
-
-  return ctx.json({
-    ok: true,
-    package_file: newPackageFile,
-  })
-})

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

@@ -1,109 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-import { findPackageReleaseId } from "fake-snippets-api/lib/package_release/find-package-release-id"
-
-export default withRouteSpec({
-  methods: ["POST"],
-  auth: "session",
-  jsonBody: z
-    .object({
-      package_release_id: z.string().optional(),
-      package_name_with_version: z.string().optional(),
-      file_path: z.string(),
-    })
-    .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"),
-  jsonResponse: z.object({
-    ok: z.boolean(),
-  }),
-})(async (req, ctx) => {
-  const { file_path } = req.jsonBody
-
-  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",
-    })
-  }
-
-  // Get the package release to check permissions
-  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",
-    })
-  }
-
-  // Get the package to check permissions
-  const existingpackage = ctx.db.packages.find(
-    (p) => p.package_id === packageRelease.package_id,
-  )
-
-  if (!existingpackage) {
-    return ctx.error(404, {
-      error_code: "package_not_found",
-      message: "Package not found",
-    })
-  }
-
-  // Check if user has permission to delete the file
-  if (existingpackage.creator_account_id !== ctx.auth.account_id) {
-    return ctx.error(403, {
-      error_code: "forbidden",
-      message: "You don't have permission to delete files in this package",
-    })
-  }
-
-  // Find the file
-  const packageFile = ctx.db.packageFiles.find(
-    (f) =>
-      f.file_path === file_path && f.package_release_id === packageReleaseId,
-  )
-
-  if (!packageFile) {
-    return ctx.error(404, {
-      error_code: "file_not_found",
-      message: "Package file not found",
-    })
-  }
-
-  // Delete the file using deletePackageFile method
-  const deleted = ctx.db.deletePackageFile(packageFile.package_file_id)
-
-  if (!deleted) {
-    return ctx.error(500, {
-      error_code: "file_deletion_failed",
-      message: "Failed to delete package file",
-    })
-  }
-
-  // Update fs_sha for the package release
-  ctx.db.updatePackageReleaseFsSha(packageReleaseId)
-
-  return ctx.json({
-    ok: true,
-  })
-})

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

@@ -1,87 +0,0 @@
-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"
-
-const routeSpec = {
-  methods: ["GET", "POST"],
-  auth: "none",
-  queryParams: z
-    .object({
-      package_file_id: z.string(),
-    })
-    .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
-
-export default withRouteSpec(routeSpec)(async (req, ctx) => {
-  let packageFileId: string | undefined
-  const params = req.query
-
-  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
-
-    const packageReleaseId = await findPackageReleaseId(
-      package_name_with_version,
-      ctx,
-    )
-
-    if (!packageReleaseId) {
-      return ctx.error(404, {
-        error_code: "not_found",
-        message: "Package release not found",
-      })
-    }
-
-    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 (!packageFileId) {
-    return ctx.error(400, {
-      error_code: "bad_request",
-      message: "Could not determine package_file_id",
-    })
-  }
-
-  const packageFile = ctx.db.packageFiles.find(
-    (pf) => pf.package_file_id === packageFileId,
-  )
-
-  if (!packageFile) {
-    return ctx.error(404, {
-      error_code: "not_found",
-      message: "Package file not found",
-    })
-  }
-
-  const contentType = "text/plain"
-
-  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(packageFile.content_text, { headers })
-})

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

@@ -1,68 +0,0 @@
-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 { getPackageFileIdFromFileDescriptor } from "fake-snippets-api/lib/package_file/get-package-file-id-from-file-descriptor"
-
-const routeSpec = {
-  methods: ["GET"],
-  auth: "none",
-  queryParams: z
-    .object({
-      package_file_id: z.string(),
-    })
-    .or(
-      z.object({
-        package_release_id: z.string(),
-        file_path: z.string(),
-      }),
-    )
-    .or(
-      z.object({
-        package_id: z.string(),
-        version: z.string().optional(),
-        file_path: z.string(),
-      }),
-    )
-    .or(
-      z.object({
-        package_name: z.string(),
-        version: z.string().optional(),
-        file_path: z.string(),
-      }),
-    )
-    .or(
-      z.object({
-        package_name_with_version: z.string(),
-        file_path: z.string(),
-      }),
-    ),
-  jsonResponse: z
-    .object({
-      ok: z.boolean(),
-      package_file: ZT.packageFileSchema.optional(),
-    })
-    .or(ZT.errorResponseSchema),
-} as const
-
-export default withRouteSpec(routeSpec)(async (req, ctx) => {
-  const packageFileId = await getPackageFileIdFromFileDescriptor(req.query, 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: {
-      ...packageFile,
-      created_at: packageFile.created_at.toString(),
-    },
-  })
-})

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

@@ -1,54 +0,0 @@
-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: ["GET"],
-  auth: "none",
-  queryParams: z
-    .object({
-      package_release_id: z.string(),
-    })
-    .or(
-      z.object({
-        package_name: z.string(),
-        use_latest_version: z.preprocess(
-          (val) => (val === "true" ? true : val),
-          z.literal(true),
-        ),
-      }),
-    )
-    .or(
-      z.object({
-        package_name_with_version: z.string(),
-      }),
-    ),
-  jsonResponse: z.object({
-    ok: z.boolean(),
-    package_files: z.array(ZT.packageFileSchema),
-  }),
-} as const
-
-export default withRouteSpec(routeSpec)(async (req, ctx) => {
-  const packageReleaseId = await findPackageReleaseId(req.query, ctx)
-
-  if (!packageReleaseId) {
-    return ctx.error(404, {
-      error_code: "package_release_not_found",
-      message: "Package release not found",
-    })
-  }
-
-  // Omit the content_text field
-  const packageFiles = ctx.db.packageFiles
-    .filter((file) => file.package_release_id === packageReleaseId)
-    .map(({ content_text, ...file }) => ({
-      ...file,
-    }))
-
-  return ctx.json({
-    ok: true,
-    package_files: packageFiles,
-  })
-})

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

@@ -1,109 +0,0 @@
-import { packageReleaseSchema } from "fake-snippets-api/lib/db/schema"
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { publicMapPackageRelease } from "fake-snippets-api/lib/public-mapping/public-map-package-release"
-import { z } from "zod"
-
-export default withRouteSpec({
-  methods: ["POST"],
-  auth: "none",
-  jsonBody: z.object({
-    package_id: z.string().optional(),
-    package_name: z.string().optional(),
-    version: z.string().optional(),
-    is_latest: z.boolean().optional(),
-    commit_sha: z.string().optional(),
-    package_name_with_version: z.string().optional(),
-  }),
-  jsonResponse: z.object({
-    ok: z.boolean(),
-    package_release: packageReleaseSchema,
-  }),
-})(async (req, ctx) => {
-  let {
-    package_id,
-    package_name,
-    is_latest = true,
-    version,
-    commit_sha,
-    package_name_with_version,
-  } = req.jsonBody
-
-  if (package_name_with_version && !package_id) {
-    const [packageName, parsedVersion] = package_name_with_version.split("@")
-    const pkg = ctx.db.packages.find((p) => p.name === packageName)
-
-    if (!pkg) {
-      return ctx.error(404, {
-        error_code: "package_not_found",
-        message: `Package not found: ${packageName}`,
-      })
-    }
-
-    package_id = pkg.package_id
-    version = parsedVersion
-  }
-
-  if (!package_id && package_name) {
-    const pkg = ctx.db.packages.find((p) => p.name === package_name)
-    if (!pkg) {
-      return ctx.error(404, {
-        error_code: "package_not_found",
-        message: `Package not found: ${package_name}`,
-      })
-    }
-    package_id = pkg.package_id
-  }
-
-  if (!package_id || !version) {
-    return ctx.error(400, {
-      error_code: "missing_options",
-      message: "package_id or package_name and version are required",
-    })
-  }
-
-  // Check if version already exists
-  const existingRelease = ctx.db.packageReleases.find(
-    (pr) => pr.package_id === package_id && pr.version === version,
-  )
-
-  if (existingRelease) {
-    return ctx.error(400, {
-      error_code: "version_already_exists",
-      message: `Version ${version} already exists for this package`,
-    })
-  }
-
-  // Update previous latest if needed
-  if (is_latest) {
-    ctx.db.packageReleases
-      .filter((pr) => pr.package_id === package_id && pr.is_latest)
-      .forEach((pr) => (pr.is_latest = false))
-  }
-
-  const newPackageRelease = ctx.db.addPackageRelease({
-    package_id,
-    is_latest,
-    version,
-    is_locked: false,
-    created_at: new Date().toISOString(),
-    commit_sha: commit_sha ?? null,
-    circuit_json_build_error: null,
-    circuit_json_build_error_last_updated_at: null,
-    // Setting the transpiled as true on creation
-    has_transpiled: true,
-    transpilation_error: 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, { db: ctx.db }),
-  })
-})