@tscircuit/fake-snippets 0.0.120 → 0.0.122

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

@@ -1,137 +0,0 @@
-import * as zt from "fake-snippets-api/lib/db/schema"
-import { publicMapPackageRelease } from "fake-snippets-api/lib/public-mapping/public-map-package-release"
-import { withRouteSpec } from "fake-snippets-api/lib/with-winter-spec"
-import { z } from "zod"
-
-export default withRouteSpec({
-  methods: ["POST"],
-  auth: "none",
-  commonParams: z.object({
-    include_logs: z.boolean().optional().default(false),
-    include_ai_review: z.boolean().optional().default(false),
-  }),
-  jsonBody: z.object({
-    package_release_id: z.string().optional(),
-    package_name_with_version: z.string().optional(),
-    package_name: z.string().optional(),
-    package_id: z.string().optional(),
-    is_latest: z.boolean().optional(),
-  }),
-  jsonResponse: z.object({
-    ok: z.boolean(),
-    package_release: zt.packageReleaseSchema,
-  }),
-})(async (req, ctx) => {
-  const {
-    package_release_id,
-    package_name_with_version,
-    package_name,
-    package_id,
-    is_latest,
-  } = req.jsonBody
-
-  // Handle package_name with is_latest
-  if (package_name && is_latest === true) {
-    const pkg = ctx.db.packages.find((x) => x.name === package_name)
-
-    if (!pkg) {
-      return ctx.error(404, {
-        error_code: "package_not_found",
-        message: "Package not found",
-      })
-    }
-
-    // Sort releases by version to find the latest one
-    const packageReleases = ctx.db.packageReleases
-      .filter((x) => x.package_id === pkg.package_id)
-      .sort((a, b) => {
-        return (
-          new Date(b.created_at).getTime() - new Date(a.created_at).getTime()
-        )
-      })
-
-    if (packageReleases.length === 0) {
-      return ctx.error(404, {
-        error_code: "package_release_not_found",
-        message: "No releases found for this package",
-      })
-    }
-
-    return ctx.json({
-      ok: true,
-      package_release: publicMapPackageRelease(packageReleases[0], {
-        include_ai_review: req.commonParams?.include_ai_review,
-        db: ctx.db,
-      }),
-    })
-  }
-
-  // Handle package_id with is_latest
-  if (package_id && is_latest === true) {
-    // Sort releases by version to find the latest one
-    const packageReleases = ctx.db.packageReleases
-      .filter((x) => x.package_id === package_id)
-      .sort((a, b) => {
-        return (
-          new Date(b.created_at).getTime() - new Date(a.created_at).getTime()
-        )
-      })
-
-    if (packageReleases.length === 0) {
-      return ctx.error(404, {
-        error_code: "package_release_not_found",
-        message: "No releases found for this package",
-      })
-    }
-
-    return ctx.json({
-      ok: true,
-      package_release: publicMapPackageRelease(packageReleases[0], {
-        include_ai_review: req.commonParams?.include_ai_review,
-        db: ctx.db,
-      }),
-    })
-  }
-
-  if (package_name_with_version && !package_release_id) {
-    const [packageName, parsedVersion] = package_name_with_version.split("@")
-    const pkg = ctx.db.packages.find((x) => x.name === packageName)
-    const pkgRelease = ctx.db.packageReleases.find((x) => {
-      return x.version == parsedVersion && x.package_id == pkg?.package_id
-    })
-
-    if (!pkgRelease) {
-      return ctx.error(404, {
-        error_code: "package_release_not_found",
-        message: "Package release not found",
-      })
-    }
-
-    return ctx.json({
-      ok: true,
-      package_release: publicMapPackageRelease(pkgRelease, {
-        include_ai_review: req.commonParams?.include_ai_review,
-        db: ctx.db,
-      }),
-    })
-  }
-
-  const foundRelease =
-    package_release_id && ctx.db.getPackageReleaseById(package_release_id)
-
-  if (!foundRelease) {
-    return ctx.error(404, {
-      error_code: "package_release_not_found",
-      message: "Package release not found",
-    })
-  }
-
-  return ctx.json({
-    ok: true,
-    package_release: publicMapPackageRelease(foundRelease, {
-      include_logs: req.commonParams?.include_logs,
-      include_ai_review: req.commonParams?.include_ai_review,
-      db: ctx.db,
-    }),
-  })
-})

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

@@ -1,85 +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",
-  commonParams: z.object({
-    include_ai_review: z.boolean().optional().default(false),
-  }),
-  jsonBody: z
-    .object({
-      package_id: z.string().optional(),
-      package_name: z.string().optional(),
-      is_latest: z.boolean().optional(),
-      version: z.string().optional(),
-      commit_sha: z.string().optional(),
-    })
-    .refine(({ package_id, package_name }) => {
-      if (package_id && package_name) {
-        return false
-      }
-      return true
-    }, "package_id and package_name are mutually exclusive")
-    .refine(({ package_id, package_name }) => {
-      if (!package_id && !package_name) {
-        return false
-      }
-      return true
-    }, "package_id or package_name is required"),
-  jsonResponse: z.object({
-    ok: z.boolean(),
-    package_releases: z.array(packageReleaseSchema),
-  }),
-})(async (req, ctx) => {
-  const { package_id, package_name, is_latest, version, commit_sha } =
-    req.jsonBody
-
-  if (!package_id && !package_name && !is_latest && !version && !commit_sha) {
-    return ctx.error(400, {
-      error_code: "invalid_query",
-      message:
-        "At least one of package_id, package_name, is_latest, version or commit_sha is required",
-    })
-  }
-
-  let releases = ctx.db.packageReleases
-
-  // Apply filters
-  if (package_id) {
-    releases = releases.filter((pr) => pr.package_id === package_id)
-  }
-
-  if (package_name) {
-    const pkg = ctx.db.packages.find((p) => p.name === package_name)
-    if (pkg) {
-      releases = releases.filter((pr) => pr.package_id === pkg.package_id)
-    } else {
-      releases = []
-    }
-  }
-
-  if (is_latest !== undefined) {
-    releases = releases.filter((pr) => pr.is_latest === is_latest)
-  }
-
-  if (version) {
-    releases = releases.filter((pr) => pr.version === version)
-  }
-
-  if (commit_sha) {
-    releases = releases.filter((pr) => pr.commit_sha === commit_sha)
-  }
-
-  return ctx.json({
-    ok: true,
-    package_releases: releases.map((pr) =>
-      publicMapPackageRelease(pr, {
-        include_ai_review: req.commonParams?.include_ai_review,
-        db: ctx.db,
-      }),
-    ),
-  })
-})

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

@@ -1,66 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-import Debug from "debug"
-
-const debug = Debug("fake-snippets-api:rebuild-package")
-
-export default withRouteSpec({
-  methods: ["POST"],
-  auth: "session",
-  jsonBody: z.object({
-    package_release_id: z.string(),
-    rebuild_transpilation: z.boolean().default(true),
-    rebuild_circuit_json: z.boolean().default(true),
-  }),
-  jsonResponse: z.object({
-    ok: z.boolean(),
-  }),
-})(async (req, ctx) => {
-  const { package_release_id, rebuild_transpilation, rebuild_circuit_json } =
-    req.jsonBody
-
-  debug("jsonBody", req.jsonBody)
-  // Get the package release info for logging
-  const release = ctx.db.getPackageReleaseById(package_release_id)
-
-  if (!release) {
-    return ctx.error(404, {
-      error_code: "package_release_not_found",
-      message: "Package release not found",
-    })
-  }
-
-  const packageInfo = ctx.db.getPackageById(release.package_id)
-
-  if (!packageInfo) {
-    return ctx.error(404, {
-      error_code: "package_not_found",
-      message: "Package not found",
-    })
-  }
-
-  if (packageInfo.owner_org_id !== ctx.auth.personal_org_id) {
-    return ctx.error(403, {
-      error_code: "forbidden",
-      message: "You do not have permission to rebuild this package release",
-    })
-  }
-
-  debug(
-    `Rebuilding package release ${package_release_id} for ${packageInfo.name}@${release.version}`,
-  )
-
-  // Trigger transpilation if requested
-  if (rebuild_transpilation) {
-    debug("Resetting transpilation state")
-  }
-
-  // Set circuit JSON build state to pending for worker pickup if requested
-  if (rebuild_circuit_json) {
-    debug("Resetting circuit JSON build state")
-  }
-
-  return ctx.json({
-    ok: true,
-  })
-})

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

@@ -1,122 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-
-export default withRouteSpec({
-  methods: ["POST"],
-  auth: "none",
-  jsonBody: z.object({
-    package_release_id: z.string().optional(),
-    package_name_with_version: z.string().optional(),
-    is_locked: z.boolean().optional(),
-    is_latest: z.boolean().optional(),
-    license: z.string().optional(),
-    fs_sha: z.string().optional(),
-    ready_to_build: z.boolean().optional(),
-    ai_review_requested: z.boolean().optional(),
-  }),
-  jsonResponse: z.object({
-    ok: z.boolean(),
-  }),
-})(async (req, ctx) => {
-  const {
-    package_release_id,
-    package_name_with_version,
-    is_locked,
-    is_latest,
-    license,
-    fs_sha,
-    ready_to_build,
-    ai_review_requested,
-  } = req.jsonBody
-  let releaseId = package_release_id
-
-  // Handle package_name_with_version lookup
-  if (!releaseId && package_name_with_version) {
-    const [packageName, version] = package_name_with_version.split("@")
-    const pkg = ctx.db.packages.find((p) => p.name === packageName)
-    if (pkg) {
-      const release = ctx.db.packageReleases.find(
-        (pr) => pr.package_id === pkg.package_id && pr.version === version,
-      )
-      if (release) {
-        releaseId = release.package_release_id
-      }
-    }
-  }
-
-  if (!releaseId) {
-    return ctx.error(404, {
-      error_code: "package_release_not_found",
-      message: "Package release not found",
-    })
-  }
-
-  const delta = {
-    is_locked,
-    is_latest,
-    license,
-    fs_sha,
-    ready_to_build,
-    ai_review_requested,
-  }
-  if (
-    Object.keys(delta).filter(
-      (k) => delta[k as keyof typeof delta] !== undefined,
-    ).length === 0
-  ) {
-    return ctx.error(400, {
-      error_code: "no_fields_provided",
-      message: "No fields provided to update",
-    })
-  }
-
-  const release = ctx.db.packageReleases.find(
-    (pr) => pr.package_release_id === releaseId,
-  )
-  if (!release) {
-    return ctx.error(404, {
-      error_code: "package_release_not_found",
-      message: "Package release not found",
-    })
-  }
-
-  // Create updated release object
-  const updatedRelease = {
-    ...release,
-    ...(is_locked !== undefined && { is_locked }),
-    ...(is_latest !== undefined && { is_latest }),
-    ...(license !== undefined && { license }),
-    ...(fs_sha !== undefined && { fs_sha }),
-    ...(ready_to_build !== undefined && { ready_to_build }),
-    ...(ai_review_requested !== undefined && { ai_review_requested }),
-    ...(ai_review_requested === true && {
-      ai_review_text: "Placeholder AI Review Text",
-    }),
-  }
-
-  // Handle is_latest updates atomically
-  if (is_latest !== undefined && is_latest) {
-    // Get all releases for this package that are currently marked as latest
-    const otherLatestReleases = ctx.db.packageReleases.filter(
-      (pr) =>
-        pr.package_id === release.package_id &&
-        pr.package_release_id !== releaseId &&
-        pr.is_latest,
-    )
-
-    // Update all releases in a single operation
-    for (const latestRelease of otherLatestReleases) {
-      ctx.db.updatePackageRelease({
-        ...latestRelease,
-        is_latest: false,
-      })
-    }
-  }
-
-  // Update the target release
-  ctx.db.updatePackageRelease(updatedRelease)
-
-  return ctx.json({
-    ok: true,
-  })
-})

package/fake-snippets-api/routes/api/packages/add_star.ts

@@ -1,84 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-
-export default withRouteSpec({
-  methods: ["POST"],
-  auth: "session",
-  jsonBody: z
-    .object({
-      package_id: z.string(),
-    })
-    .or(z.object({ name: z.string() })),
-  jsonResponse: z.object({
-    ok: z.boolean(),
-  }),
-})(async (req, ctx) => {
-  let packageId: string
-
-  // Get package ID either directly or by name
-  if ("package_id" in req.jsonBody) {
-    const body = req.jsonBody
-    packageId = body.package_id
-  } else {
-    // If name is provided, look up the package_id
-    const body = req.jsonBody
-    const packageData = ctx.db.packages.find((pkg) => pkg.name === body.name)
-
-    if (!packageData) {
-      return ctx.error(404, {
-        error_code: "package_not_found",
-        message: "Package not found",
-      })
-    }
-
-    packageId = packageData.package_id
-  }
-
-  // Check if package exists (extra check for ID-based lookup)
-  const pkg = ctx.db.packages.find((p) => p.package_id === packageId)
-
-  if (!pkg) {
-    return ctx.error(404, {
-      error_code: "package_not_found",
-      message: "Package not found",
-    })
-  }
-
-  // Check if already starred
-  const existing = ctx.db.accountPackages.find(
-    (ap) =>
-      ap.account_id === ctx.auth.account_id && ap.package_id === packageId,
-  )
-
-  if (existing?.is_starred) {
-    return ctx.error(400, {
-      error_code: "already_starred",
-      message: "You have already starred this package",
-    })
-  }
-
-  // Update the package's star count
-  pkg.star_count = (pkg.star_count || 0) + 1
-
-  if (existing) {
-    // If record exists but is_starred is false, update to is_starred=true
-    existing.is_starred = true
-    existing.updated_at = new Date().toISOString()
-  } else {
-    // Add star by creating a new account_package record
-    const newTimestamp = new Date().toISOString()
-    const newAccountPackage = {
-      account_package_id: `ap_${Date.now()}`,
-      account_id: ctx.auth.account_id,
-      package_id: packageId,
-      is_starred: true,
-      created_at: newTimestamp,
-      updated_at: newTimestamp,
-    }
-    ctx.db.addAccountPackage(newAccountPackage)
-  }
-
-  return ctx.json({
-    ok: true,
-  })
-})

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

@@ -1,136 +0,0 @@
-import { packageSchema } from "fake-snippets-api/lib/db/schema"
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { publicMapPackage } from "fake-snippets-api/lib/public-mapping/public-map-package"
-import { z } from "zod"
-
-export default withRouteSpec({
-  methods: ["POST"],
-  auth: "session",
-  jsonBody: z.object({
-    name: z
-      .string()
-      .regex(
-        /^[@a-zA-Z0-9-_\/]+$/,
-        "Package name can only contain letters, numbers, hyphens, underscores, and forward slashes",
-      )
-      .transform((name) => name.replace(/^@/, ""))
-      .optional(),
-    description: z.string().optional(),
-    is_private: z.boolean().optional().default(false),
-    is_unlisted: z.boolean().optional().default(false),
-    org_id: z.string().optional(),
-  }),
-  jsonResponse: z.object({
-    package: packageSchema.optional(),
-  }),
-})(async (req, ctx) => {
-  const { name, description, is_private, is_unlisted, org_id } = req.jsonBody
-  let owner_segment = name?.split("/")[0]
-  let unscoped_name = name?.split("/")[1]
-
-  if (name && !unscoped_name) {
-    return ctx.error(400, {
-      error_code: "invalid_package_name",
-      message:
-        "Package name must include an author segment (e.g. author/package_name)",
-    })
-  }
-  const org = ctx.db.getOrg({ org_id })
-  if (Boolean(org_id) && !Boolean(org))
-    return ctx.error(404, {
-      error_code: "org_not_found",
-      message: "Organization not found",
-    })
-
-  if (!unscoped_name) {
-    const state = ctx.db.getState()
-
-    const count = org_id
-      ? state.packages.filter((pkg) => pkg.owner_org_id === org_id).length
-      : state.packages.filter(
-          (pkg) => pkg.creator_account_id === ctx.auth.account_id,
-        ).length
-
-    unscoped_name = `untitled-package-${count}`
-  }
-
-  if (!owner_segment) {
-    owner_segment = org_id ? org!.org_name : ctx.auth.github_username
-  }
-
-  const final_name = name ?? `${owner_segment}/${unscoped_name}`
-
-  const requested_owner_lower = owner_segment.toLowerCase()
-  const personal_owner_lower = ctx.auth.github_username.toLowerCase()
-
-  let owner_org_id = ctx.auth.personal_org_id
-  let owner_github_username = ctx.auth.github_username
-
-  if (requested_owner_lower !== personal_owner_lower) {
-    const state = ctx.db.getState()
-    const memberOrg = state.orgAccounts
-      .filter((oa) => oa.account_id === ctx.auth.account_id)
-      .map((oa) => state.organizations.find((o) => o.org_id === oa.org_id))
-      .filter((o): o is NonNullable<typeof o> => o !== undefined)
-      .find(
-        (o) =>
-          o.org_display_name?.toLowerCase() === requested_owner_lower ||
-          o.org_name?.toLowerCase() === requested_owner_lower ||
-          o.github_handle?.toLowerCase() === requested_owner_lower,
-      )
-
-    if (!memberOrg) {
-      return ctx.error(403, {
-        error_code: "forbidden",
-        message:
-          "You must be a member of the organization to create a package under it",
-      })
-    }
-
-    owner_org_id = memberOrg.org_id
-    owner_github_username = memberOrg.github_handle || memberOrg.org_name
-  }
-
-  const existingPackage = ctx.db
-    .getState()
-    .packages.find((pkg) => pkg.name === final_name)
-
-  if (existingPackage) {
-    return ctx.error(400, {
-      error_code: "package_already_exists",
-      message: "A package with this name already exists",
-    })
-  }
-
-  const newPackage = ctx.db.addPackage({
-    name: final_name,
-    description: description ?? null,
-    creator_account_id: ctx.auth.account_id,
-    owner_org_id,
-    owner_github_username,
-    latest_package_release_id: null,
-    latest_package_release_fs_sha: null,
-    latest_version: null,
-    license: null,
-    website: null,
-    is_source_from_github: false,
-    created_at: new Date().toISOString(),
-    updated_at: new Date().toISOString(),
-    unscoped_name,
-    star_count: 0,
-    ai_description: "placeholder ai description",
-    is_private: is_private ?? false,
-    is_public: is_private === true ? false : true,
-    is_unlisted: is_private === true ? true : (is_unlisted ?? false),
-    ai_usage_instructions: "placeholder ai usage instructions",
-    default_view: "files",
-  })
-
-  if (!newPackage) {
-    throw new Error("Failed to create package")
-  }
-
-  return ctx.json({
-    package: publicMapPackage(newPackage),
-  })
-})

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

@@ -1,41 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-
-export default withRouteSpec({
-  methods: ["POST"],
-  auth: "session",
-  jsonBody: z.object({
-    package_id: z.string(),
-  }),
-  jsonResponse: z.object({
-    ok: z.boolean(),
-  }),
-})(async (req, ctx) => {
-  const { package_id } = req.jsonBody
-
-  const packageIndex = ctx.db.packages.findIndex(
-    (p) => p.package_id === package_id,
-  )
-
-  if (packageIndex === -1) {
-    return ctx.error(404, {
-      error_code: "package_not_found",
-      message: "Package not found",
-    })
-  }
-
-  const pkg = ctx.db.packages[packageIndex]
-
-  if (pkg.owner_github_username !== ctx.auth.github_username) {
-    return ctx.error(403, {
-      error_code: "forbidden",
-      message: "You don't have permission to delete this package",
-    })
-  }
-
-  ctx.db.packages.splice(packageIndex, 1)
-
-  return ctx.json({
-    ok: true,
-  })
-})