@tscircuit/fake-snippets 0.0.108 → 0.0.110

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,46 @@
+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(),
+  }),
+  auth: "session",
+  jsonResponse: z.object({
+    org: publicOrgSchema,
+  }),
+})(async (req, ctx) => {
+  const { name } = req.commonParams
+
+  const existing = ctx.db.getOrg({ github_handle: 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,
+  }
+
+  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: "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,67 @@
+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: "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",
+    })
+  }
+
+  if (!org.can_manage_org) {
+    return ctx.error(403, {
+      error_code: "not_authorized",
+      message: "You do not have permission to manage this organization",
+    })
+  }
+
+  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,93 @@
+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(),
+      }),
+    ),
+  auth: "session",
+  jsonResponse: z.object({
+    org: publicOrgSchema,
+  }),
+})(async (req, ctx) => {
+  const { org_id, name, display_name } = req.commonParams as {
+    org_id: string
+    name?: string
+    display_name?: 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) {
+    return ctx.json({ org: publicMapOrg(org) })
+  }
+
+  if (name && name !== org.github_handle) {
+    // Validate duplicate name
+    const duplicate = ctx.db.getOrg({ github_handle: 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",
+      })
+    }
+  }
+
+  const updates: {
+    github_handle?: string
+    org_display_name?: string
+  } = {}
+
+  if (name) {
+    updates.github_handle = name
+  }
+
+  if (display_name !== undefined) {
+    const trimmedDisplayName = display_name.trim()
+    const fallbackDisplayName =
+      name ?? org.org_display_name ?? org.github_handle ?? ""
+    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,57 @@ 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.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
+  }
+
+  const existingPackage = ctx.db.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,
+            },
+          }
+        : {}),
     },
   })
 })

package/fake-snippets-api/routes/api/packages/images/[owner_github_username]/[unscoped_name]/[view_format].ts

@@ -4,8 +4,10 @@ import {
   convertCircuitJsonToPcbSvg,
   convertCircuitJsonToSchematicSvg,
 } from "circuit-to-svg"
+import { convertCircuitJsonToSimple3dSvg } from "circuit-json-to-simple-3d"
 import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
 import { z } from "zod"
+import { renderAsync } from "@resvg/resvg-js"
 
 // Define the view types and extensions
 const VIEW_TYPES = ["schematic", "pcb", "assembly", "3d"] as const
@@ -68,7 +70,8 @@ export default withRouteSpec({
   const circuit_json_file = ctx.db.packageFiles.find(
     (pf) =>
       pf.package_release_id === pkg_release.package_release_id &&
-      pf.file_path === "circuit.json",
+      (pf.file_path === "circuit.json" ||
+        pf.file_path === "/dist/circuit.json"),
   )
 
   if (!circuit_json_file?.content_text) {
@@ -82,7 +85,6 @@ export default withRouteSpec({
 
   // Convert circuit json to svg
   let svg = ""
-
   if (outputType === "schematic") {
     svg = convertCircuitJsonToSchematicSvg(circuit_json as AnyCircuitElement[])
   } else if (outputType === "pcb") {
@@ -90,13 +92,14 @@ export default withRouteSpec({
   } else if (outputType === "assembly") {
     svg = convertCircuitJsonToAssemblySvg(circuit_json as AnyCircuitElement[])
   } else if (outputType === "3d") {
-    // For 3D view, we'll return a simple SVG placeholder
-    svg = `<svg width="400" height="300" xmlns="http://www.w3.org/2000/svg">
-      <rect width="100%" height="100%" fill="#f0f0f0"/>
-      <text x="50%" y="50%" text-anchor="middle" fill="#666">3D Preview</text>
-    </svg>`
+    svg = await convertCircuitJsonToSimple3dSvg(circuit_json, {
+      background: {
+        color: "#fff",
+        opacity: 0.0,
+      },
+      defaultZoomMultiplier: 1.1,
+    })
   }
-
   if (format === "svg") {
     return new Response(svg, {
       headers: {
@@ -106,9 +109,8 @@ export default withRouteSpec({
     })
   }
 
-  // For PNG format, we'll return the SVG as PNG
-  // In a real implementation, this would use @resvg/resvg-js
-  return new Response(svg, {
+  const pngBuffer = await renderAsync(svg)
+  return new Response(pngBuffer.asPng().buffer as ArrayBuffer, {
     headers: {
       "Content-Type": "image/png",
       "Cache-Control": "public, max-age=86400, s-maxage=86400",

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

@@ -13,7 +13,16 @@ export default withRouteSpec({
   }),
   jsonResponse: z.object({
     ok: z.boolean(),
-    packages: z.array(packageSchema),
+    packages: z.array(
+      packageSchema.extend({
+        starred_at: z.string().nullable(),
+        user_permissions: z
+          .object({
+            can_manage_packages: z.boolean(),
+          })
+          .optional(),
+      }),
+    ),
   }),
 })(async (req, ctx) => {
   const { creator_account_id, owner_github_username, name, is_writable } =
@@ -28,6 +37,17 @@ export default withRouteSpec({
     })
   }
 
+  // Helper to check if user can manage a package
+  const canManagePackage = (pkg: any) => {
+    if (!auth) return false
+    // Check if user is a member of the package's owner org
+    const state = ctx.db.getState()
+    return state.orgAccounts.some(
+      (oa) =>
+        oa.account_id === auth.account_id && oa.org_id === pkg.owner_org_id,
+    )
+  }
+
   let packages = ctx.db.packages
 
   // Apply filters
@@ -46,7 +66,7 @@ export default withRouteSpec({
   }
 
   if (is_writable && auth) {
-    packages = packages.filter((p) => p.owner_org_id === auth.personal_org_id)
+    packages = packages.filter(canManagePackage)
   }
 
   // Get star timestamps for authenticated user
@@ -65,6 +85,13 @@ export default withRouteSpec({
       ...p,
       latest_package_release_id: p.latest_package_release_id || null,
       starred_at: starTimestamps.get(p.package_id) || null,
+      ...(auth
+        ? {
+            user_permissions: {
+              can_manage_packages: canManagePackage(p),
+            },
+          }
+        : {}),
     })),
   })
 })