@tscircuit/fake-snippets 0.0.121 → 0.0.123

package/fake-snippets-api/routes/api/orgs/get_member.ts

@@ -1,67 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-import {
-  orgAccountSchema,
-  userPermissionsSchema,
-} from "fake-snippets-api/lib/db/schema"
-
-export default withRouteSpec({
-  methods: ["GET"],
-  commonParams: z.object({
-    org_id: z.string().optional(),
-    org_name: z.string().optional(),
-    account_id: z.string(),
-  }),
-  auth: "optional_session",
-  jsonResponse: z.object({
-    org_member: orgAccountSchema.merge(
-      z.object({ org_member_permissions: userPermissionsSchema.nullable() }),
-    ),
-  }),
-})(async (req, ctx) => {
-  const { org_id, org_name, account_id } = req.commonParams
-
-  const org = ctx.db.getOrg(
-    {
-      org_id,
-      org_name,
-    },
-    ctx.auth,
-  )
-
-  if (!org) {
-    return ctx.error(404, {
-      error_code: "org_not_found",
-      message: "Organization not found",
-    })
-  }
-
-  const memberOrgAccount = ctx.db.getOrganizationAccount({
-    org_id: org.org_id,
-    account_id: account_id,
-  })
-
-  const memberOrg = ctx.db.getOrg(
-    {
-      org_id,
-      org_name,
-    },
-    {
-      account_id: account_id!,
-    },
-  )
-
-  if (!memberOrgAccount) {
-    return ctx.error(404, {
-      error_code: "member_not_found",
-      message: "Member not found in organization",
-    })
-  }
-
-  return ctx.json({
-    org_member: {
-      ...memberOrgAccount,
-      org_member_permissions: memberOrg,
-    },
-  })
-})

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

@@ -1,31 +0,0 @@
-import { publicOrgSchema } from "fake-snippets-api/lib/db/schema"
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { publicMapOrg } from "fake-snippets-api/lib/public-mapping/public-map-org"
-import { z } from "zod"
-
-export default withRouteSpec({
-  methods: ["GET", "POST"],
-  auth: "optional_session",
-  commonParams: z.object({
-    github_handle: z.string().optional(),
-  }),
-  jsonResponse: z.object({
-    ok: z.boolean(),
-    orgs: z.array(publicOrgSchema),
-  }),
-})(async (req, ctx) => {
-  const { github_handle } = req.commonParams
-  const orgs = ctx.db.getOrgs(
-    {
-      owner_account_id: ctx.auth?.account_id,
-      github_handle,
-    },
-    {
-      account_id: ctx.auth?.account_id,
-    },
-  )
-  return ctx.json({
-    ok: true,
-    orgs: orgs.map((org) => publicMapOrg(org)),
-  })
-})

package/fake-snippets-api/routes/api/orgs/list_members.ts

@@ -1,106 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-import {
-  accountSchema,
-  userPermissionsSchema,
-} from "fake-snippets-api/lib/db/schema"
-
-export default withRouteSpec({
-  methods: ["GET", "POST"],
-  commonParams: z
-    .object({
-      org_id: z.string(),
-    })
-    .or(
-      z.object({
-        name: z.string(),
-      }),
-    ),
-  auth: "optional_session",
-  jsonResponse: z.object({
-    org_members: z.array(
-      accountSchema.omit({ shippingInfo: true }).extend({
-        joined_at: z.string(),
-        org_member_permissions: userPermissionsSchema,
-      }),
-    ),
-  }),
-})(async (req, ctx) => {
-  const params = req.commonParams as { org_id?: string; name?: string }
-
-  const org = ctx.db.getOrg(
-    {
-      org_id: params.org_id,
-      org_name: params.name,
-    },
-    ctx.auth,
-  )
-
-  if (!org) {
-    return ctx.error(404, {
-      error_code: "org_not_found",
-      message: "Organization not found",
-    })
-  }
-
-  const members = ctx.db.orgAccounts
-    .map((m) => {
-      if (m.org_id !== org.org_id) return undefined
-      const account = ctx.db.getAccount(m.account_id)
-      if (!account) return undefined
-      const memberOrg = ctx.db.getOrg(
-        {
-          org_id: org.org_id,
-          org_name: org.org_name,
-        },
-        {
-          account_id: account.account_id,
-        },
-      )
-
-      return {
-        ...account,
-        user_permissions: memberOrg,
-        joined_at: m.created_at,
-      }
-    })
-    .filter(
-      (member): member is NonNullable<typeof member> => member !== undefined,
-    )
-  const hasOwner = members.some((m) => m?.account_id === org.owner_account_id)
-  let fullMembers = members
-
-  if (!hasOwner) {
-    const owner = ctx.db.accounts.find(
-      (acc) => acc.account_id === org.owner_account_id,
-    )
-    if (owner) {
-      const memberOrg = ctx.db.getOrg(
-        {
-          org_id: org.org_id,
-          org_name: org.org_name,
-        },
-        {
-          account_id: owner.account_id,
-        },
-      )
-      fullMembers = [
-        ...members,
-        {
-          ...owner,
-          user_permissions: memberOrg,
-          joined_at: org.created_at,
-        },
-      ]
-    }
-  }
-  return ctx.json({
-    org_members: fullMembers.map((m) => ({
-      ...m,
-      org_member_permissions: m.user_permissions ?? {
-        can_manage_org: false,
-        can_manage_package: false,
-      },
-    })),
-  })
-})

package/fake-snippets-api/routes/api/orgs/remove_member.ts

@@ -1,46 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-
-export default withRouteSpec({
-  methods: ["GET", "POST"],
-  commonParams: z.object({
-    org_id: z.string(),
-    account_id: z.string(),
-  }),
-  auth: "session",
-  jsonResponse: z.object({}),
-})(async (req, ctx) => {
-  const { org_id, account_id } = req.commonParams
-
-  const org = ctx.db.getOrg({ org_id }, ctx.auth)
-
-  if (!org) {
-    return ctx.error(404, {
-      error_code: "org_not_found",
-      message: "Organization not found",
-    })
-  }
-
-  if (!org.can_manage_org) {
-    return ctx.error(403, {
-      error_code: "not_authorized",
-      message: "You do not have permission to manage this organization",
-    })
-  }
-
-  const account = ctx.db.accounts.find((acc) => acc.account_id === account_id)
-
-  if (!account) {
-    return ctx.error(404, {
-      error_code: "account_not_found",
-      message: "Account not found",
-    })
-  }
-
-  ctx.db.removeOrganizationAccount({
-    org_id,
-    account_id,
-  })
-
-  return ctx.json({})
-})

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

@@ -1,118 +0,0 @@
-import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
-import { z } from "zod"
-import { publicOrgSchema } from "fake-snippets-api/lib/db/schema"
-import { publicMapOrg } from "fake-snippets-api/lib/public-mapping/public-map-org"
-
-export default withRouteSpec({
-  methods: ["POST", "PATCH"],
-  commonParams: z
-    .object({
-      org_id: z.string(),
-    })
-    .and(
-      z.object({
-        name: z.string().optional(),
-        display_name: z.string().optional(),
-        github_handle: z.string().trim().min(1).nullable().optional(),
-      }),
-    ),
-  auth: "session",
-  jsonResponse: z.object({
-    org: publicOrgSchema,
-  }),
-})(async (req, ctx) => {
-  const { org_id, name, display_name, github_handle } = req.commonParams as {
-    org_id: string
-    name?: string
-    display_name?: string
-    github_handle?: string
-  }
-
-  const org = ctx.db.getOrg({ org_id }, ctx.auth)
-
-  if (!org) {
-    return ctx.error(404, {
-      error_code: "org_not_found",
-      message: "Organization not found",
-    })
-  }
-
-  if (!org.can_manage_org) {
-    return ctx.error(403, {
-      error_code: "not_authorized",
-      message: "You do not have permission to manage this organization",
-    })
-  }
-
-  // No changes provided
-  if (!name && display_name === undefined && github_handle === null) {
-    return ctx.json({ org: publicMapOrg(org) })
-  }
-
-  if (name && name !== org.org_name) {
-    // Validate duplicate name
-    const duplicate = ctx.db.getOrg({ org_name: name })
-
-    if (duplicate && duplicate.org_id !== org_id) {
-      return ctx.error(400, {
-        error_code: "org_already_exists",
-        message: "An organization with this name already exists",
-      })
-    }
-  }
-  if (
-    github_handle !== undefined &&
-    github_handle !== org.github_handle &&
-    github_handle !== null
-  ) {
-    const duplicateHandle = ctx.db.getOrg({ github_handle })
-      ? ctx.db.getOrg({ github_handle })?.org_id != org_id
-      : false
-
-    if (duplicateHandle) {
-      return ctx.error(400, {
-        error_code: "org_github_handle_already_exists",
-        message: "An organization with this GitHub handle already exists",
-      })
-    }
-  }
-  const updates: {
-    org_name?: string
-    org_display_name?: string
-    github_handle?: string
-  } = {}
-
-  if (name) {
-    updates.github_handle = name
-    updates.org_name = name
-  }
-
-  if (github_handle !== undefined) {
-    updates.github_handle = github_handle
-  }
-
-  if (display_name !== undefined) {
-    const trimmedDisplayName = display_name.trim()
-    const handleForFallback =
-      github_handle !== undefined ? github_handle : org.github_handle
-    const fallbackDisplayName =
-      name ?? org.org_display_name ?? org.org_name ?? handleForFallback ?? ""
-    updates.org_display_name =
-      trimmedDisplayName.length > 0 ? trimmedDisplayName : fallbackDisplayName
-  }
-
-  const updated = ctx.db.updateOrganization(org_id, updates)
-
-  if (!updated) {
-    return ctx.error(500, {
-      error_code: "update_failed",
-      message: "Failed to update organization",
-    })
-  }
-
-  const updatedOrgWithPermissions = ctx.db.getOrg({ org_id }, ctx.auth)
-
-  return ctx.json({
-    org: publicMapOrg(updatedOrgWithPermissions!),
-  })
-})

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

@@ -1,70 +0,0 @@
-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/list.ts

@@ -1,97 +0,0 @@
-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
-  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/fake-snippets-api/routes/api/package_files/create.ts

@@ -1,135 +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: "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)
-
-  // Update fs_sha for the package release
-  ctx.db.updatePackageReleaseFsSha(packageReleaseId)
-
-  return ctx.json({
-    ok: true,
-    package_file: newPackageFile,
-  })
-})