@tscircuit/fake-snippets 0.0.109 → 0.0.111

package/fake-snippets-api/lib/db/autoload-dev-packages.ts

@@ -16,7 +16,7 @@ const extractTsciDependencies = (
 }
 
 const registryApi = axios.create({
-  baseURL: "https://registry-api.tscircuit.com",
+  baseURL: "https://api.tscircuit.com",
   headers: {
     Accept: "application/json",
     "Content-Type": "application/json",
@@ -25,7 +25,7 @@ const registryApi = axios.create({
 
 const fetchPackageFromRegistry = async (owner: string, name: string) => {
   const fullName = `${owner}/${name}`
-  console.log(`Fetching package ${fullName}...`)
+  console.log(`[autoload-dev-pkgs] 📦 Fetching package ${fullName}...`)
 
   let packageData
   try {
@@ -46,35 +46,42 @@ const fetchPackageFromRegistry = async (owner: string, name: string) => {
     })
     releaseData = response.data
   } catch (e) {
-    console.error(`Failed to fetch release data for ${fullName}:`, e)
+    console.error(
+      `[autoload-dev-pkgs] ❌ Failed to fetch release data for ${fullName}:`,
+      e,
+    )
     throw e
   }
 
   let filesData
   try {
-    const response = await registryApi.post("/package_files/list", {
-      package_release_id: releaseData.package_release.package_release_id,
-    })
+    const response = await registryApi.post(
+      `package_files/list?package_release_id=${releaseData.package_release.package_release_id}`,
+      {},
+    )
     filesData = response.data
 
     // Fetch content_text for each file individually
     for (const file of filesData.package_files) {
       try {
-        const fileResponse = await registryApi.post("/package_files/get", {
-          package_release_id: releaseData.package_release.package_release_id,
-          file_path: file.file_path,
-        })
+        const fileResponse = await registryApi.post(
+          `/package_files/get?package_file_id=${file.package_file_id}`,
+          {},
+        )
         file.content_text = fileResponse.data.package_file.content_text
       } catch (e) {
         console.error(
-          `Failed to fetch content for file ${file.file_path} in package ${fullName}:`,
+          `[autoload-dev-pkgs] ❌ Failed to fetch content for file ${file.file_path} in package ${fullName}:`,
           e,
         )
         throw e
       }
     }
   } catch (e) {
-    console.error(`Failed to fetch files data for ${fullName}:`, e)
+    console.error(
+      `[autoload-dev-pkgs] ❌ Failed to fetch files data for ${fullName}:`,
+      e,
+    )
     throw e
   }
 
@@ -100,7 +107,7 @@ const loadPackageWithDependencies = async (
   try {
     result = await fetchPackageFromRegistry(owner, name)
   } catch (e) {
-    console.error(`✗ Failed to load ${packageKey}`)
+    console.error(`[autoload-dev-pkgs] ❌ Failed to load ${packageKey}`)
     return false
   }
 
@@ -108,7 +115,7 @@ const loadPackageWithDependencies = async (
 
   // Check if package already exists
   if (db.getPackageById(pkg.package_id)) {
-    console.log(`✓ Package ${packageKey} already exists`)
+    console.log(`[autoload-dev-pkgs] ⚡ Package ${packageKey} already exists`)
     return true
   }
 
@@ -142,7 +149,7 @@ const loadPackageWithDependencies = async (
   }
 
   loadedPackages.add(packageKey)
-  console.log(`✓ Loaded ${packageKey}`)
+  console.log(`[autoload-dev-pkgs] 📦 Loaded ${packageKey}`)
 
   // Load dependencies
   const mainFile = files.find(
@@ -165,7 +172,7 @@ const loadPackageWithDependencies = async (
     if (!depLoaded) {
       allDepsLoaded = false
       console.warn(
-        `⚠️ Failed to load dependency ${dep.owner}/${dep.name} for ${packageKey}`,
+        `[autoload-dev-pkgs] ⚠️ Failed to load dependency ${dep.owner}/${dep.name} for ${packageKey}`,
       )
     }
   }
@@ -180,7 +187,7 @@ export const loadAutoloadPackages = async (db: DbClient) => {
     "autoload-packages.json",
   )
   if (!fs.existsSync(autoloadPath)) {
-    console.error("No autoload-packages.json found")
+    console.error("[autoload-dev-pkgs] ❌ No autoload-packages.json found")
     return
   }
 
@@ -203,9 +210,13 @@ export const loadAutoloadPackages = async (db: DbClient) => {
     }
   }
 
-  console.log(`\nPackage loading complete:`)
-  console.log(`✓ Successfully loaded: ${successCount} packages`)
+  console.log(`\n[autoload-dev-pkgs] 📋 Package loading complete:`)
+  console.log(
+    `[autoload-dev-pkgs] ✅ Successfully loaded: ${successCount} packages`,
+  )
   if (failureCount > 0) {
-    console.log(`✗ Failed to load: ${failureCount} packages`)
+    console.log(
+      `[autoload-dev-pkgs] ❌ Failed to load: ${failureCount} packages`,
+    )
   }
 }

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

@@ -17,6 +17,7 @@ import {
   type PackageRelease,
   packageReleaseSchema,
   type PackageBuild,
+  packageBuildSchema,
   type AiReview,
   aiReviewSchema,
   type Datasheet,
@@ -26,6 +27,8 @@ import {
   databaseSchema,
   type packageSchema,
   type snippetSchema,
+  Organization,
+  OrgAccount,
 } from "./schema.ts"
 import { seed as seedFn } from "./seed"
 import { generateFsSha } from "../package_file/generate-fs-sha"
@@ -175,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) => {
@@ -1489,12 +1494,12 @@ const initializer = combine(databaseSchema.parse({}), (set, get) => ({
     return updated
   },
   addPackageBuild: (
-    packageBuild: Omit<PackageBuild, "package_build_id">,
+    packageBuild: Omit<z.input<typeof packageBuildSchema>, "package_build_id">,
   ): PackageBuild => {
-    const newPackageBuild = {
+    const newPackageBuild = packageBuildSchema.parse({
       package_build_id: crypto.randomUUID(),
       ...packageBuild,
-    }
+    })
     set((state) => ({
       packageBuilds: [...state.packageBuilds, newPackageBuild],
       // Automatically update the package release to reference this as the latest build
@@ -1541,4 +1546,214 @@ const initializer = combine(databaseSchema.parse({}), (set, get) => ({
     })
     return updated
   },
+  addOrganization: (organization: {
+    name: string
+    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.github_handle,
+      is_personal_org: organization.is_personal_org || false,
+      created_at: new Date().toISOString(),
+      ...organization,
+    }
+    set((state) => ({
+      idCounter: state.idCounter + 1,
+      organizations: [...state.organizations, newOrganization as Organization],
+      // Add the creator as a member of the new org by setting their personal_org_id
+      accounts: state.accounts.map((account) =>
+        account.account_id === organization.owner_account_id
+          ? { ...account, personal_org_id: newOrganization.org_id }
+          : account,
+      ),
+    }))
+    return newOrganization
+  },
+  getOrgs: (
+    filters?: {
+      owner_account_id?: string
+      github_handle?: string
+      name?: string
+    },
+    auth?: { account_id?: string },
+  ) => {
+    let orgs = get().organizations
+    if (filters?.owner_account_id) {
+      orgs = orgs.filter(
+        (org) => org.owner_account_id === filters.owner_account_id,
+      )
+    }
+    if (filters?.github_handle) {
+      orgs = orgs.filter((org) => {
+        const account = get().accounts.find(
+          (account) => account.account_id === org.owner_account_id,
+        )
+        return account?.github_username === filters.github_handle
+      })
+    }
+    if (filters?.name) {
+      orgs = orgs.filter((org) => org.github_handle === filters.name)
+    }
+
+    return orgs.map((org) => {
+      const member_count = get().accounts.filter(
+        (account) => account.personal_org_id === org.org_id,
+      ).length
+
+      const package_count = get().packages.filter(
+        (pkg) => pkg.owner_org_id === org.org_id,
+      ).length
+
+      const can_manage_org = auth
+        ? org.owner_account_id === auth.account_id
+        : false
+
+      return {
+        ...org,
+        member_count,
+        package_count,
+        can_manage_org,
+      }
+    })
+  },
+  getOrg: (
+    filters: {
+      org_id?: string
+      org_name?: string
+      github_handle?: string
+    },
+    auth?: { account_id: string },
+  ) => {
+    let orgs = get().organizations
+
+    if (filters?.org_id) {
+      orgs = orgs.filter((org) => org.org_id === filters.org_id)
+    }
+    if (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)
+    //   orgs = orgs.filter((org) => org.github_handle === account?.github_username)
+    // }
+    if (filters?.github_handle) {
+      orgs = orgs.filter((org) => org.github_handle === filters.github_handle)
+    }
+
+    if (orgs.length === 0) {
+      return null
+    }
+
+    const org = orgs[0]
+
+    const member_count = get().accounts.filter(
+      (account) => account.personal_org_id === org.org_id,
+    ).length
+
+    const package_count = get().packages.filter(
+      (pkg) => pkg.owner_org_id === org.org_id,
+    ).length
+
+    const can_manage_org = auth
+      ? org.owner_account_id === auth.account_id
+      : false
+
+    return {
+      ...org,
+      member_count,
+      package_count,
+      can_manage_org,
+    }
+  },
+  addOrganizationAccount: (organizationAccount: {
+    org_id: string
+    account_id: string
+    is_owner?: boolean
+  }) => {
+    const newOrgAccount: OrgAccount = {
+      org_account_id: `org_account_${get().idCounter + 1}`,
+      org_id: organizationAccount.org_id,
+      account_id: organizationAccount.account_id,
+      is_owner: organizationAccount.is_owner || false,
+      created_at: new Date().toISOString(),
+    }
+    set((state) => ({
+      orgAccounts: [...state.orgAccounts, newOrgAccount],
+      idCounter: state.idCounter + 1,
+    }))
+    return newOrgAccount
+  },
+  getOrganizationAccount: (filters: {
+    org_id?: string
+    account_id?: string
+  }): OrgAccount | undefined => {
+    const state = get()
+    return state.orgAccounts.find((orgAccount) => {
+      if (filters.org_id && orgAccount.org_id !== filters.org_id) {
+        return false
+      }
+      if (filters.account_id && orgAccount.account_id !== filters.account_id) {
+        return false
+      }
+      return true
+    })
+  },
+  getOrganizationAccounts: (filters?: {
+    org_id?: string
+    account_id?: string
+  }): OrgAccount[] => {
+    const state = get()
+    return state.orgAccounts.filter((orgAccount) => {
+      if (filters?.org_id && orgAccount.org_id !== filters.org_id) {
+        return false
+      }
+      if (filters?.account_id && orgAccount.account_id !== filters.account_id) {
+        return false
+      }
+      return true
+    })
+  },
+  removeOrganizationAccount: (filters: {
+    org_id: string
+    account_id: string
+  }): boolean => {
+    let removed = false
+    set((state) => {
+      const index = state.orgAccounts.findIndex(
+        (orgAccount) =>
+          orgAccount.org_id === filters.org_id &&
+          orgAccount.account_id === filters.account_id,
+      )
+      if (index !== -1) {
+        state.orgAccounts.splice(index, 1)
+        removed = true
+      }
+      return state
+    })
+    return removed
+  },
+  updateOrganization: (
+    orgId: string,
+    updates: Partial<Organization>,
+  ): Organization | undefined => {
+    let updatedOrg: Organization | undefined
+    set((state) => {
+      const orgIndex = state.organizations.findIndex(
+        (org) => org.org_id === orgId,
+      )
+      if (orgIndex === -1) return state
+      const updatedOrganizations = [...state.organizations]
+      updatedOrganizations[orgIndex] = {
+        ...updatedOrganizations[orgIndex],
+        ...updates,
+      }
+      updatedOrg = updatedOrganizations[orgIndex]
+      return { ...state, organizations: updatedOrganizations }
+    })
+    return updatedOrg
+  },
 }))

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

@@ -67,11 +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>
 
@@ -244,6 +245,22 @@ export const packageReleaseSchema = z.object({
   circuit_json_build_logs: z.array(z.any()).default([]),
   circuit_json_build_is_stale: z.boolean().default(false),
 
+  // Image Generation Process
+  image_generation_display_status: z
+    .enum(["pending", "building", "complete", "error"])
+    .default("pending"),
+  image_generation_in_progress: z.boolean().default(false),
+  image_generation_started_at: z.string().datetime().nullable().optional(),
+  image_generation_completed_at: z.string().datetime().nullable().optional(),
+  image_generation_logs: z.array(z.any()).nullable().default(null),
+  image_generation_is_stale: z.boolean().default(false),
+  image_generation_error: z.string().nullable().optional(),
+  image_generation_error_last_updated_at: z
+    .string()
+    .datetime()
+    .nullable()
+    .optional(),
+
   // AI Review
   ai_review_text: z.string().nullable().default(null).optional(),
   ai_review_started_at: z.string().datetime().nullable().optional(),
@@ -367,6 +384,11 @@ export const packageBuildSchema = z.object({
   circuit_json_build_completed_at: z.string().datetime().nullable().optional(),
   circuit_json_build_logs: z.array(z.any()).default([]),
   circuit_json_build_error: z.string().nullable().optional(),
+  image_generation_in_progress: z.boolean().default(false),
+  image_generation_started_at: z.string().datetime().nullable().optional(),
+  image_generation_completed_at: z.string().datetime().nullable().optional(),
+  image_generation_logs: z.array(z.any()).default([]),
+  image_generation_error: z.string().nullable().optional(),
   build_in_progress: z.boolean().default(false),
   build_started_at: z.string().datetime().nullable().optional(),
   build_completed_at: z.string().datetime().nullable().optional(),
@@ -377,6 +399,44 @@ export const packageBuildSchema = z.object({
 })
 export type PackageBuild = z.infer<typeof packageBuildSchema>
 
+export const orgSchema = z.object({
+  org_id: 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>
+
+export const orgAccountSchema = z.object({
+  org_account_id: z.string(),
+  org_id: z.string(),
+  account_id: z.string(),
+  is_owner: z.boolean().default(false),
+  created_at: z.string().datetime(),
+})
+export type OrgAccount = z.infer<typeof orgAccountSchema>
+
+export const publicOrgSchema = z.object({
+  org_id: z.string(), //.uuid(),
+  owner_account_id: z.string(), //.uuid(),
+  name: z.string().nullable(),
+  member_count: z.number(),
+  is_personal_org: z.boolean(),
+  display_name: z.string().optional(),
+  package_count: z.number(),
+  created_at: z.string(),
+  user_permissions: z
+    .object({
+      can_manage_org: z.boolean().optional(),
+      can_manage_package: z.boolean().optional(),
+    })
+    .optional(),
+})
+export type PublicOrgSchema = z.infer<typeof publicOrgSchema>
+
 export const databaseSchema = z.object({
   idCounter: z.number().default(0),
   snippets: z.array(snippetSchema).default([]),
@@ -387,6 +447,8 @@ export const databaseSchema = z.object({
   accounts: z.array(accountSchema).default([]),
   packages: z.array(packageSchema).default([]),
   orders: z.array(orderSchema).default([]),
+  organizations: z.array(orgSchema).default([]),
+  orgAccounts: z.array(orgAccountSchema).default([]),
   orderFiles: z.array(orderFileSchema).default([]),
   accountSnippets: z.array(accountSnippetSchema).default([]),
   accountPackages: z.array(accountPackageSchema).default([]),

package/fake-snippets-api/lib/db/seed.ts

@@ -1733,4 +1733,104 @@ export const SquareWaveModule = () => (
     started_at: null,
     completed_at: null,
   })
+
+  const testOrg = db.addOrganization({
+    name: "test-organization",
+    owner_account_id: account_id,
+  })
+
+  // Add org member
+  db.addOrganizationAccount({
+    org_id: testOrg.org_id,
+    account_id: account_id,
+    is_owner: true,
+  })
+
+  const { package_release_id: orgPackageReleaseId } = db.addSnippet({
+    name: "test-organization/test-package",
+    unscoped_name: "test-package",
+    owner_name: "test-organization",
+    code: `
+export const TestComponent = ({ name }: { name: string }) => (
+  <resistor name={name} resistance="10k" />
+)
+`.trim(),
+    dts: `
+declare module "@tsci/test-organization.test-package" {
+  export const TestComponent: ({ name }: {
+    name: string;
+  }) => any;
+}
+`.trim(),
+    compiled_js: `
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TestComponent = void 0;
+const TestComponent = ({
+  name
+}) => /*#__PURE__*/React.createElement("resistor", {
+  name: name,
+  resistance: "10k"
+});
+exports.TestComponent = TestComponent;
+    `.trim(),
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+    snippet_type: "package",
+    description: "Test package for organization",
+    circuit_json: [
+      {
+        type: "source_component",
+        source_component_id: "source_component_0",
+        ftype: "simple_resistor",
+        name: "R1",
+        resistance: "10k",
+      },
+    ],
+  })
+
+  // Add successful build for org package
+  const orgPackageBuild = db.addPackageBuild({
+    package_release_id: orgPackageReleaseId,
+    created_at: new Date().toISOString(),
+    transpilation_in_progress: false,
+    transpilation_started_at: new Date(Date.now() - 5000).toISOString(),
+    transpilation_completed_at: new Date(Date.now() - 3000).toISOString(),
+    transpilation_logs: [
+      "[INFO] Starting transpilation...",
+      "[SUCCESS] Transpilation completed successfully",
+    ],
+    transpilation_error: null,
+    circuit_json_build_in_progress: false,
+    circuit_json_build_started_at: new Date(Date.now() - 3000).toISOString(),
+    circuit_json_build_completed_at: new Date(Date.now() - 1000).toISOString(),
+    circuit_json_build_logs: [
+      "[INFO] Starting circuit JSON build...",
+      "[SUCCESS] Circuit JSON build completed",
+    ],
+    circuit_json_build_error: null,
+    build_in_progress: false,
+    build_started_at: new Date(Date.now() - 10000).toISOString(),
+    build_completed_at: new Date().toISOString(),
+    build_error: null,
+    build_error_last_updated_at: new Date().toISOString(),
+    preview_url: "http://localhost:3000/preview/org_package_build",
+    build_logs: "Build completed successfully",
+  })
+
+  // Update the org package release with the build ID
+  const orgRelease = db.getPackageReleaseById(orgPackageReleaseId)!
+  db.updatePackageRelease({
+    ...orgRelease,
+    latest_package_build_id: orgPackageBuild.package_build_id,
+  })
+
+  db.addOrganization({
+    name: "testuser",
+    owner_account_id: account_id,
+    is_personal_org: true,
+  })
 }

package/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: `org-${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)