@tscircuit/fake-snippets 0.0.109 → 0.0.111

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

@@ -125,8 +125,8 @@ export const getPackageFileIdFromFileDescriptor = async (
 
   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]
+    const packageName = package_name_with_version.split("@")[0]
+    const version = package_name_with_version.split("@")[1]
 
     // Find the package
     const pkg = ctx.db.packages.find((p: ZT.Package) => p.name === packageName)

package/fake-snippets-api/lib/public-mapping/public-map-org.ts

@@ -0,0 +1,33 @@
+import { z } from "zod"
+import * as ZT from "fake-snippets-api/lib/db/schema"
+
+export const publicMapOrg = (
+  internal_org: ZT.Organization & {
+    member_count: number
+    package_count: number
+    can_manage_org: boolean
+  },
+): z.infer<typeof ZT.publicOrgSchema> => {
+  const {
+    can_manage_org,
+    github_handle,
+    member_count,
+    package_count,
+    created_at,
+    is_personal_org,
+    org_display_name,
+    org_name,
+    ...org
+  } = internal_org
+  return {
+    org_id: org.org_id,
+    display_name: org_display_name ?? org_name,
+    owner_account_id: org.owner_account_id,
+    name: org_name,
+    member_count: Number(member_count) || 0,
+    package_count: Number(package_count) || 0,
+    is_personal_org: Boolean(is_personal_org),
+    created_at: String(created_at),
+    ...(can_manage_org ? { user_permissions: { can_manage_org: true } } : {}),
+  }
+}

package/fake-snippets-api/lib/public-mapping/public-map-package-build.ts

@@ -25,6 +25,16 @@ export const publicMapPackageBuild = (
       ? internalPackageBuild.circuit_json_build_logs
       : [],
     circuit_json_build_error: internalPackageBuild.circuit_json_build_error,
+    image_generation_in_progress:
+      internalPackageBuild.image_generation_in_progress,
+    image_generation_started_at:
+      internalPackageBuild.image_generation_started_at,
+    image_generation_completed_at:
+      internalPackageBuild.image_generation_completed_at,
+    image_generation_logs: options.include_logs
+      ? internalPackageBuild.image_generation_logs
+      : [],
+    image_generation_error: internalPackageBuild.image_generation_error,
     build_started_at: internalPackageBuild.build_started_at,
     build_completed_at: internalPackageBuild.build_completed_at,
     build_error: internalPackageBuild.build_error,

package/fake-snippets-api/lib/public-mapping/public-map-package-release.ts

@@ -24,6 +24,23 @@ export const publicMapPackageRelease = (
     circuit_json_build_logs: options.include_logs
       ? internal_package_release.circuit_json_build_logs
       : [],
+    image_generation_logs: options.include_logs
+      ? internal_package_release.image_generation_logs
+      : null,
+    image_generation_in_progress:
+      internal_package_release.image_generation_in_progress,
+    image_generation_started_at:
+      internal_package_release.image_generation_started_at ?? null,
+    image_generation_completed_at:
+      internal_package_release.image_generation_completed_at ?? null,
+    image_generation_is_stale:
+      internal_package_release.image_generation_is_stale,
+    image_generation_error:
+      internal_package_release.image_generation_error ?? null,
+    image_generation_error_last_updated_at:
+      internal_package_release.image_generation_error_last_updated_at ?? null,
+    image_generation_display_status:
+      internal_package_release.image_generation_display_status,
     is_pr_preview: Boolean(internal_package_release.is_pr_preview),
     github_pr_number: internal_package_release.github_pr_number,
     branch_name: internal_package_release.branch_name,

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

@@ -0,0 +1,52 @@
+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().optional(),
+    github_username: z.string().optional(),
+  }),
+  auth: "session",
+  jsonResponse: z.object({}),
+})(async (req, ctx) => {
+  const { org_id, account_id, github_username } = 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",
+    })
+  }
+
+  let account = ctx.db.accounts.find((acc) => acc.account_id === account_id)
+  if (!account) {
+    account = ctx.db.accounts.find(
+      (acc) => acc.github_username === github_username,
+    )
+  }
+
+  if (!account) {
+    return ctx.error(404, {
+      error_code: "account_not_found",
+      message: "Account not found",
+    })
+  }
+
+  ctx.db.addOrganizationAccount({
+    org_id,
+    account_id: account.account_id,
+  })
+
+  return ctx.json({})
+})

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

@@ -0,0 +1,48 @@
+import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
+import { z } from "zod"
+import { publicMapOrg } from "fake-snippets-api/lib/public-mapping/public-map-org"
+import { publicOrgSchema } from "fake-snippets-api/lib/db/schema"
+
+export default withRouteSpec({
+  methods: ["GET", "POST"],
+  commonParams: z.object({
+    name: z.string(),
+    github_handle: z.string().optional(),
+  }),
+  auth: "session",
+  jsonResponse: z.object({
+    org: publicOrgSchema,
+  }),
+})(async (req, ctx) => {
+  const { name, github_handle } = req.commonParams
+
+  const existing = ctx.db.getOrg({ org_name: name })
+
+  if (existing) {
+    return ctx.error(400, {
+      error_code: "org_already_exists",
+      message: "An organization with this name already exists",
+    })
+  }
+  const newOrg = {
+    owner_account_id: ctx.auth.account_id,
+    name: name,
+    created_at: new Date(),
+    can_manage_org: true,
+    ...(github_handle ? { github_handle } : {}),
+  }
+
+  const org = ctx.db.addOrganization(newOrg)
+
+  // Add the creator as a member of the organization
+  ctx.db.addOrganizationAccount({
+    org_id: org.org_id,
+    account_id: ctx.auth.account_id,
+    is_owner: true,
+  })
+
+  const fullOrg = ctx.db.getOrg({ org_id: org.org_id }, ctx.auth)
+  return ctx.json({
+    org: publicMapOrg(fullOrg!),
+  })
+})

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

@@ -0,0 +1,39 @@
+import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
+import { z } from "zod"
+import { publicMapOrg } from "fake-snippets-api/lib/public-mapping/public-map-org"
+import { publicOrgSchema } from "fake-snippets-api/lib/db/schema"
+
+export default withRouteSpec({
+  methods: ["GET", "POST"],
+  commonParams: z
+    .object({ org_id: z.string() })
+    .or(z.object({ org_name: z.string() }))
+    .or(z.object({ github_handle: z.string() })),
+  auth: "optional_session",
+  jsonResponse: z.object({
+    org: publicOrgSchema,
+  }),
+})(async (req, ctx) => {
+  const params = req.commonParams as {
+    org_id?: string
+    org_name?: string
+    github_handle?: string
+  }
+
+  const org = ctx.db.getOrg(
+    {
+      org_id: params.org_id,
+      org_name: params.org_name,
+      github_handle: params.github_handle,
+    },
+    ctx.auth,
+  )
+
+  if (!org) {
+    return ctx.error(404, {
+      error_code: "org_not_found",
+      message: "Organization not found",
+    })
+  }
+  return ctx.json({ org: publicMapOrg(org) })
+})

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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,60 @@
+import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
+import { z } from "zod"
+import { accountSchema } 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({
+    members: z.array(accountSchema),
+  }),
+})(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 ctx.db.getAccount(m.account_id)
+      return undefined
+    })
+    .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) {
+      fullMembers = [...members, owner]
+    }
+  }
+
+  return ctx.json({ members: fullMembers })
+})

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

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,118 @@
+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_files/get.ts

@@ -4,9 +4,9 @@ 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: ["POST"],
+  methods: ["GET"],
   auth: "none",
-  jsonBody: z
+  queryParams: z
     .object({
       package_file_id: z.string(),
     })
@@ -45,10 +45,7 @@ const routeSpec = {
 } as const
 
 export default withRouteSpec(routeSpec)(async (req, ctx) => {
-  const packageFileId = await getPackageFileIdFromFileDescriptor(
-    req.jsonBody,
-    ctx,
-  )
+  const packageFileId = await getPackageFileIdFromFileDescriptor(req.query, ctx)
 
   const packageFile = ctx.db.packageFiles.find(
     (pf: ZT.PackageFile) => pf.package_file_id === packageFileId,

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

@@ -4,16 +4,19 @@ 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"],
+  methods: ["GET"],
   auth: "none",
-  jsonBody: z
+  queryParams: z
     .object({
       package_release_id: z.string(),
     })
     .or(
       z.object({
         package_name: z.string(),
-        use_latest_version: z.literal(true),
+        use_latest_version: z.preprocess(
+          (val) => (val === "true" ? true : val),
+          z.literal(true),
+        ),
       }),
     )
     .or(
@@ -28,7 +31,7 @@ const routeSpec = {
 } as const
 
 export default withRouteSpec(routeSpec)(async (req, ctx) => {
-  const packageReleaseId = await findPackageReleaseId(req.jsonBody, ctx)
+  const packageReleaseId = await findPackageReleaseId(req.query, ctx)
 
   if (!packageReleaseId) {
     return ctx.error(404, {

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

@@ -25,16 +25,17 @@ export default withRouteSpec({
 })(async (req, ctx) => {
   const { name, description, is_private, is_unlisted } = req.jsonBody
 
-  const existingPackage = ctx.db.packages.find((pkg) => pkg.name === name)
+  let owner_segment = name?.split("/")[0]
+  let unscoped_name = name?.split("/")[1]
 
-  if (existingPackage) {
+  if (name && !unscoped_name) {
     throw ctx.error(400, {
-      error_code: "package_already_exists",
-      message: "A package with this name already exists",
+      error_code: "invalid_package_name",
+      message:
+        "Package name must include an author segment (e.g. author/package_name)",
     })
   }
 
-  let unscoped_name = name?.includes("/") ? name?.split("/")[1] : name
   if (!unscoped_name) {
     const state = ctx.db.getState()
     const count = state.packages.filter(
@@ -44,14 +45,60 @@ export default withRouteSpec({
     unscoped_name = `untitled-package-${count}`
   }
 
+  if (!owner_segment) {
+    owner_segment = 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) {
+      throw 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) {
+    throw ctx.error(400, {
+      error_code: "package_already_exists",
+      message: "A package with this name already exists",
+    })
+  }
+
   const newPackage = ctx.db.addPackage({
-    name: name?.includes("/")
-      ? name
-      : `${ctx.auth.github_username}/${String(unscoped_name)}`,
+    name: final_name,
     description: description ?? null,
     creator_account_id: ctx.auth.account_id,
-    owner_org_id: ctx.auth.personal_org_id,
-    owner_github_username: ctx.auth.github_username,
+    owner_org_id,
+    owner_github_username,
     latest_package_release_id: null,
     latest_package_release_fs_sha: null,
     latest_version: null,

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

@@ -16,6 +16,11 @@ export default withRouteSpec({
     package: packageSchema
       .extend({
         is_starred: z.boolean(),
+        user_permissions: z
+          .object({
+            can_manage_packages: z.boolean(),
+          })
+          .optional(),
       })
       .optional(),
   }),
@@ -46,6 +51,17 @@ export default withRouteSpec({
     })
   }
 
+  // Check if user can manage the package
+  const canManagePackage =
+    auth &&
+    ctx.db
+      .getState()
+      .orgAccounts.some(
+        (org_account) =>
+          org_account.account_id === auth.account_id &&
+          org_account.org_id === foundPackage.owner_org_id,
+      )
+
   return ctx.json({
     ok: true,
     package: {
@@ -53,6 +69,13 @@ export default withRouteSpec({
       is_starred: auth
         ? ctx.db.hasStarred(auth.account_id, foundPackage.package_id)
         : false,
+      ...(auth
+        ? {
+            user_permissions: {
+              can_manage_packages: canManagePackage ?? false,
+            },
+          }
+        : {}),
     },
   })
 })