feat: sync api to prod, org.org_name (#1769)

* feat: sync api to prod, org.org_name

* f

* Update create.test.ts

* Enhance organization handling in API and tests

- Added `github_handle` to the organization seeding in `get-test-server.ts`.
- Updated test description for clarity in `update.test.ts`.
- Improved organization name handling in package creation logic in `create.ts` by allowing `org_name` as a fallback for `owner_github_username`.

Author: ArnavK-09

bun-tests/fake-snippets-api/fixtures/get-test-server.ts

@@ -126,6 +126,7 @@ const seedDatabase = (db: DbClient) => {
   // Seed a organization for account2
   const organization = db.addOrganization({
     name: "jane",
+    github_handle: "jane",
     owner_account_id: account2.account_id,
   })
 

bun-tests/fake-snippets-api/routes/orgs/create.test.ts

@@ -23,8 +23,8 @@ test("POST /api/orgs/create - should create a new org for the user", async () =>
 test("POST /api/orgs/create - should reject duplicate org names", async () => {
   const { axios, seed } = await getTestServer()
   try {
-    const orgResponse = await axios.post("/api/orgs/create", {
-      name: seed.organization.github_handle,
+    await axios.post("/api/orgs/create", {
+      name: seed.organization.org_name,
     })
     throw new Error("Expected request to fail")
   } catch (error: any) {

bun-tests/fake-snippets-api/routes/orgs/update.test.ts

@@ -97,3 +97,55 @@ test("POST /api/orgs/update - should reject duplicate name", async () => {
     )
   }
 })
+
+test("POST /api/orgs/update - should update github_handle when owner", async () => {
+  const { axios, db } = await getTestServer()
+
+  const createResponse = await axios.post("/api/orgs/create", {
+    name: "handle-owner",
+  })
+  const org = createResponse.data.org
+
+  const updateResponse = await axios.post("/api/orgs/update", {
+    org_id: org.org_id,
+    github_handle: "handle-owner",
+  })
+
+  expect(updateResponse.status).toBe(200)
+
+  const state = db.getState()
+  const updatedOrg = state.organizations.find(
+    (o: any) => o.org_id === org.org_id,
+  )
+  expect(updatedOrg?.github_handle).toBe("handle-owner")
+})
+
+test("POST /api/orgs/update - should reject duplicate github_handle", async () => {
+  const { axios } = await getTestServer()
+
+  const orgAResponse = await axios.post("/api/orgs/create", {
+    name: "dup-handle-a",
+  })
+  const orgA = orgAResponse.data.org
+
+  await axios.post("/api/orgs/update", {
+    org_id: orgA.org_id,
+    github_handle: "duplicate-handle",
+  })
+
+  const orgBResponse = await axios.post("/api/orgs/create", {
+    name: "dup-handle-b",
+  })
+  const orgB = orgBResponse.data.org
+
+  try {
+    await axios.post("/api/orgs/update", {
+      org_id: orgB.org_id,
+      github_handle: "duplicate-handle",
+    })
+    throw new Error("Expected request to fail")
+  } catch (error: any) {
+    expect(error.status).toBe(400)
+    expect(error.data.error.error_code).toBe("org_github_handle_already_exists")
+  }
+})

fake-snippets-api/lib/db/db-client.ts

@@ -178,11 +178,13 @@ const initializer = combine(databaseSchema.parse({}), (set, get) => ({
     return state.orderFiles.find((file) => file.order_file_id === orderFileId)
   },
   addAccount: (
-    account: Omit<Account, "account_id"> & Partial<Pick<Account, "account_id">>,
+    account: Omit<Account, "account_id" | "is_tscircuit_staff"> &
+      Partial<Pick<Account, "account_id" | "is_tscircuit_staff">>,
   ) => {
     const newAccount = {
       account_id: account.account_id || `account_${get().idCounter + 1}`,
       ...account,
+      is_tscircuit_staff: Boolean(account.is_tscircuit_staff),
     }
 
     set((state) => {
@@ -1549,10 +1551,12 @@ const initializer = combine(databaseSchema.parse({}), (set, get) => ({
     org_id?: string
     is_personal_org?: boolean
     owner_account_id: string
+    github_handle?: string
   }) => {
     const newOrganization: Organization = {
+      org_name: organization.name,
       org_id: organization.org_id || `org_${get().idCounter + 1}`,
-      github_handle: organization.name,
+      github_handle: organization.github_handle,
       is_personal_org: organization.is_personal_org || false,
       created_at: new Date().toISOString(),
       ...organization,
@@ -1630,7 +1634,7 @@ const initializer = combine(databaseSchema.parse({}), (set, get) => ({
       orgs = orgs.filter((org) => org.org_id === filters.org_id)
     }
     if (filters?.org_name) {
-      orgs = orgs.filter((org) => org.github_handle === filters.org_name)
+      orgs = orgs.filter((org) => org.org_name === filters.org_name)
     }
     // if (filters?.org_name && auth?.account_id) {
     //   const account = get().accounts.find(x => x.account_id == auth?.account_id)

fake-snippets-api/lib/db/schema.ts

@@ -67,12 +67,12 @@ export const shippingInfoSchema = z.object({
   country: z.string(),
   phone: z.string(),
 })
-
 export const accountSchema = z.object({
   account_id: z.string(),
   github_username: z.string(),
   shippingInfo: shippingInfoSchema.optional(),
   personal_org_id: z.string().optional(),
+  is_tscircuit_staff: z.boolean().default(false),
 })
 export type Account = z.infer<typeof accountSchema>
 
@@ -401,11 +401,12 @@ export type PackageBuild = z.infer<typeof packageBuildSchema>
 
 export const orgSchema = z.object({
   org_id: z.string(),
-  github_handle: z.string(),
+  github_handle: z.string().optional(),
   owner_account_id: z.string(),
   is_personal_org: z.boolean().default(false),
   created_at: z.string().datetime(),
   org_display_name: z.string().optional(),
+  org_name: z.string(),
 })
 export type Organization = z.infer<typeof orgSchema>
 

fake-snippets-api/lib/middleware/with-session-auth.ts

@@ -1,10 +1,11 @@
 import type { Middleware } from "winterspec/middleware"
 import type { CtxErrorFn } from "./with-ctx-error"
+import type { DbClient } from "../db/db-client"
 
 export const withSessionAuth: Middleware<
   {
     error: CtxErrorFn
-    db: any
+    db: DbClient
   },
   {
     auth: {
@@ -13,6 +14,13 @@ export const withSessionAuth: Middleware<
       personal_org_id: string
       github_username: string
       session_id: string
+      orgs: Array<{
+        org_id: string
+        name: string
+        user_permissions: {
+          can_manage_packages: boolean
+        }
+      }>
     }
   },
   {}
@@ -22,28 +30,72 @@ export const withSessionAuth: Middleware<
   const token = req.headers.get("authorization")?.split("Bearer ")?.[1]
 
   // Only check database accounts when we're in a Bun test environment
-  if (process.env.BUN_TEST === "true" && ctx.db?.accounts) {
-    const account = ctx.db.accounts.find((acc: any) => acc.account_id === token)
-
+  if (process.env.BUN_TEST === "true" && ctx.db?.getState) {
+    const state = ctx.db.getState()
+    const account = state.accounts.find((acc: any) => acc.account_id === token)
     if (account) {
+      // Fetch orgs for this account
+      const orgAccounts = state.orgAccounts.filter(
+        (oa: any) => oa.account_id === account.account_id,
+      )
+
+      const orgs = orgAccounts.map((oa: any) => {
+        const org = state.organizations.find((o: any) => o.org_id === oa.org_id)
+        return {
+          org_id: oa.org_id,
+          name:
+            org?.org_display_name ||
+            org?.org_name ||
+            org?.github_handle ||
+            oa.org_id,
+          user_permissions: { can_manage_packages: true },
+        }
+      })
+
       ctx.auth = {
         type: "session",
         account_id: account.account_id,
         personal_org_id: account.personal_org_id || `org-${account.account_id}`,
         github_username: account.github_username,
         session_id: `session-${account.account_id}`,
+        orgs:
+          orgs.length > 0
+            ? orgs
+            : [
+                {
+                  org_id:
+                    account.personal_org_id || `org-${account.account_id}`,
+                  name:
+                    account.github_username ||
+                    account.personal_org_id ||
+                    `org-${account.account_id}`,
+                  user_permissions: { can_manage_packages: true },
+                },
+              ],
       }
       return next(req, ctx)
     }
   }
 
-  // For all other environments or if account not found in test, use hardcoded auth
+  // Fallback auth for non-test environments or when no token is found
+  const fallbackAccountId = "account-1234"
+  const fallbackOrgId = "org-1234"
+
+  const fallbackOrgs = [
+    {
+      org_id: fallbackOrgId,
+      name: "org-1234",
+      user_permissions: { can_manage_packages: true },
+    },
+  ]
+
   ctx.auth = {
     type: "session",
-    account_id: "account-1234",
-    personal_org_id: "org-1234",
+    account_id: fallbackAccountId,
+    personal_org_id: fallbackOrgId,
     github_username: "testuser",
     session_id: "session-1234",
+    orgs: fallbackOrgs,
   }
 
   return next(req, ctx)

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

@@ -16,13 +16,14 @@ export const publicMapOrg = (
     created_at,
     is_personal_org,
     org_display_name,
+    org_name,
     ...org
   } = internal_org
   return {
     org_id: org.org_id,
-    display_name: org_display_name ?? github_handle ?? "",
+    display_name: org_display_name ?? org_name,
     owner_account_id: org.owner_account_id,
-    name: github_handle,
+    name: org_name,
     member_count: Number(member_count) || 0,
     package_count: Number(package_count) || 0,
     is_personal_org: Boolean(is_personal_org),

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

@@ -7,15 +7,16 @@ 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 } = req.commonParams
+  const { name, github_handle } = req.commonParams
 
-  const existing = ctx.db.getOrg({ github_handle: name })
+  const existing = ctx.db.getOrg({ org_name: name })
 
   if (existing) {
     return ctx.error(400, {
@@ -28,6 +29,7 @@ export default withRouteSpec({
     name: name,
     created_at: new Date(),
     can_manage_org: true,
+    ...(github_handle ? { github_handle } : {}),
   }
 
   const org = ctx.db.addOrganization(newOrg)

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

@@ -13,17 +13,19 @@ export default withRouteSpec({
       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 } = req.commonParams as {
+  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)
@@ -43,13 +45,13 @@ export default withRouteSpec({
   }
 
   // No changes provided
-  if (!name && display_name === undefined) {
+  if (!name && display_name === undefined && github_handle === null) {
     return ctx.json({ org: publicMapOrg(org) })
   }
 
-  if (name && name !== org.github_handle) {
+  if (name && name !== org.org_name) {
     // Validate duplicate name
-    const duplicate = ctx.db.getOrg({ github_handle: name })
+    const duplicate = ctx.db.getOrg({ org_name: name })
 
     if (duplicate && duplicate.org_id !== org_id) {
       return ctx.error(400, {
@@ -58,20 +60,43 @@ export default withRouteSpec({
       })
     }
   }
+  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: {
-    github_handle?: string
+    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.github_handle ?? ""
+      name ?? org.org_display_name ?? org.org_name ?? handleForFallback ?? ""
     updates.org_display_name =
       trimmedDisplayName.length > 0 ? trimmedDisplayName : fallbackDisplayName
   }

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

@@ -66,6 +66,7 @@ export default withRouteSpec({
       .find(
         (o) =>
           o.org_display_name?.toLowerCase() === requested_owner_lower ||
+          o.org_name?.toLowerCase() === requested_owner_lower ||
           o.github_handle?.toLowerCase() === requested_owner_lower,
       )
 
@@ -78,10 +79,12 @@ export default withRouteSpec({
     }
 
     owner_org_id = memberOrg.org_id
-    owner_github_username = memberOrg.github_handle
+    owner_github_username = memberOrg.github_handle || memberOrg.org_name
   }
 
-  const existingPackage = ctx.db.packages.find((pkg) => pkg.name === final_name)
+  const existingPackage = ctx.db
+    .getState()
+    .packages.find((pkg) => pkg.name === final_name)
 
   if (existingPackage) {
     throw ctx.error(400, {