@tscircuit/fake-snippets 0.0.7 → 0.0.9

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

@@ -1,26 +1,23 @@
-import { createStore, type StoreApi } from "zustand/vanilla"
-import { immer } from "zustand/middleware/immer"
-import { hoist, type HoistedStoreApi } from "zustand-hoist"
-import { z } from "zod"
+import type { z } from "zod"
+import { hoist } from "zustand-hoist"
+import { createStore } from "zustand/vanilla"
 
+import { combine } from "zustand/middleware"
 import {
+  type Account,
+  type AccountPackage,
+  type LoginPage,
+  type Order,
+  type OrderFile,
+  type Package,
+  type PackageFile,
+  type PackageRelease,
+  type Session,
+  type Snippet,
   databaseSchema,
-  Snippet,
-  Session,
-  LoginPage,
-  Account,
-  type DatabaseSchema,
-  snippetSchema,
-  Order,
-  OrderFile,
-  AccountSnippet,
-  packageReleaseSchema,
-  packageSchema,
-  Package,
-  PackageRelease,
-  PackageFile,
+  type packageSchema,
+  type snippetSchema,
 } from "./schema.ts"
-import { combine } from "zustand/middleware"
 import { seed as seedFn } from "./seed"
 
 export const createDatabase = ({ seed }: { seed?: boolean } = {}) => {
@@ -35,7 +32,7 @@ export type DbClient = ReturnType<typeof createDatabase>
 
 const initializer = combine(databaseSchema.parse({}), (set, get) => ({
   addOrder: (order: Omit<Order, "order_id">): Order => {
-    let newOrder = { order_id: `order_${get().idCounter + 1}`, ...order }
+    const newOrder = { order_id: `order_${get().idCounter + 1}`, ...order }
     set((state) => {
       return {
         orders: [...state.orders, newOrder],
@@ -89,50 +86,252 @@ const initializer = combine(databaseSchema.parse({}), (set, get) => ({
 
     return newAccount
   },
+  addAccountPackage: (
+    accountPackage: Omit<AccountPackage, "account_package_id">,
+  ): AccountPackage => {
+    const newAccountPackage = {
+      account_package_id: `ap_${get().idCounter + 1}`,
+      ...accountPackage,
+    }
+    set((state) => {
+      return {
+        accountPackages: [...state.accountPackages, newAccountPackage],
+        idCounter: state.idCounter + 1,
+      }
+    })
+    return newAccountPackage
+  },
+  getAccountPackageById: (
+    accountPackageId: string,
+  ): AccountPackage | undefined => {
+    const state = get()
+    return state.accountPackages.find(
+      (ap) => ap.account_package_id === accountPackageId,
+    )
+  },
+  updateAccountPackage: (
+    accountPackageId: string,
+    updates: Partial<AccountPackage>,
+  ): void => {
+    set((state) => ({
+      accountPackages: state.accountPackages.map((ap) =>
+        ap.account_package_id === accountPackageId ? { ...ap, ...updates } : ap,
+      ),
+    }))
+  },
+  deleteAccountPackage: (accountPackageId: string): boolean => {
+    let deleted = false
+    set((state) => {
+      const index = state.accountPackages.findIndex(
+        (ap) => ap.account_package_id === accountPackageId,
+      )
+      if (index !== -1) {
+        state.accountPackages.splice(index, 1)
+        deleted = true
+      }
+      return state
+    })
+    return deleted
+  },
   addSnippet: (
     snippet: Omit<
       z.input<typeof snippetSchema>,
       "snippet_id" | "package_release_id"
     >,
   ): Snippet => {
-    const newSnippetId = `snippet_${get().idCounter + 1}`
-    const newPackageRelease = packageReleaseSchema.parse({
-      package_release_id: `package_release_${get().idCounter + 1}`,
-      package_id: newSnippetId,
+    const timestamp = Date.now()
+    const currentTime = new Date(timestamp).toISOString()
+
+    const newState = get()
+    const nextId = newState.idCounter + 1
+
+    // Create the package that will serve as our snippet
+    const newPackage = {
+      package_id: `pkg_${nextId}`,
+      creator_account_id: snippet.owner_name, // Using owner_name as account_id since we don't have context
+      owner_org_id: "", // Empty string instead of null to match type
+      owner_github_username: snippet.owner_name,
+      is_source_from_github: false,
+      description: snippet.description || "",
+      name: `${snippet.owner_name}/${snippet.unscoped_name}`,
+      unscoped_name: snippet.unscoped_name,
+      latest_version: "0.0.1",
+      license: null,
+      star_count: 0,
+      created_at: currentTime,
+      updated_at: currentTime,
+      ai_description: null,
+      is_snippet: true,
+      is_board: snippet.snippet_type === "board",
+      is_package: snippet.snippet_type === "package",
+      is_model: snippet.snippet_type === "model",
+      is_footprint: snippet.snippet_type === "footprint",
+      snippet_type: snippet.snippet_type,
+      is_private: false,
+      is_public: true,
+      is_unlisted: false,
+      latest_package_release_id: `package_release_${nextId}`,
+    }
+
+    // Create package release
+    const newPackageRelease = {
+      package_release_id: `package_release_${nextId}`,
+      package_id: newPackage.package_id,
       version: "0.0.1",
-      is_locked: false,
       is_latest: true,
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
-    })
-    const newSnippet = snippetSchema.parse({
-      ...snippet,
-      snippet_id: newSnippetId,
+      is_locked: false,
+      created_at: currentTime,
+      updated_at: currentTime,
+    }
+
+    // Add all the files
+    const packageFiles: PackageFile[] = []
+    let fileIdCounter = nextId
+
+    // Add main code file
+    packageFiles.push({
+      package_file_id: `package_file_${fileIdCounter++}`,
       package_release_id: newPackageRelease.package_release_id,
+      file_path: "index.tsx",
+      content_text: snippet.code || "",
+      created_at: currentTime,
     })
-    set((state) => {
-      return {
-        snippets: [...state.snippets, newSnippet],
-        packageReleases: [...state.packageReleases, newPackageRelease],
-        idCounter: state.idCounter + 2,
-      }
-    })
-    return { ...newSnippet, snippet_id: newSnippetId }
+
+    // Add DTS file if provided
+    if (snippet.dts) {
+      packageFiles.push({
+        package_file_id: `package_file_${fileIdCounter++}`,
+        package_release_id: newPackageRelease.package_release_id,
+        file_path: "/dist/index.d.ts",
+        content_text: snippet.dts,
+        created_at: currentTime,
+      })
+    }
+
+    // Add compiled JS if provided
+    if (snippet.compiled_js) {
+      packageFiles.push({
+        package_file_id: `package_file_${fileIdCounter++}`,
+        package_release_id: newPackageRelease.package_release_id,
+        file_path: "/dist/index.js",
+        content_text: snippet.compiled_js,
+        created_at: currentTime,
+      })
+    }
+
+    // Add circuit JSON if provided
+    if (snippet.circuit_json && snippet.circuit_json.length > 0) {
+      packageFiles.push({
+        package_file_id: `package_file_${fileIdCounter++}`,
+        package_release_id: newPackageRelease.package_release_id,
+        file_path: "/dist/circuit.json",
+        content_text: JSON.stringify(snippet.circuit_json),
+        created_at: currentTime,
+      })
+    }
+
+    // Update the database state atomically
+    set((state) => ({
+      ...state,
+      packages: [...state.packages, newPackage],
+      packageReleases: [...state.packageReleases, newPackageRelease],
+      packageFiles: [...state.packageFiles, ...packageFiles],
+      idCounter: fileIdCounter,
+    }))
+
+    // Return in the same format as create endpoint
+    return {
+      snippet_id: newPackage.package_id,
+      package_release_id: newPackageRelease.package_release_id,
+      name: newPackage.name,
+      unscoped_name: newPackage.unscoped_name,
+      owner_name: snippet.owner_name,
+      code: snippet.code || "",
+      dts: snippet.dts,
+      compiled_js: snippet.compiled_js,
+      star_count: 0,
+      created_at: currentTime,
+      updated_at: currentTime,
+      snippet_type: snippet.snippet_type,
+      circuit_json: snippet.circuit_json || [],
+      description: snippet.description || "",
+      is_starred: false,
+      version: "0.0.1",
+    }
   },
   getNewestSnippets: (limit: number): Snippet[] => {
     const state = get()
-    return [...state.snippets]
+
+    // Get all packages that are snippets
+    const snippetPackages = state.packages
+      .filter((pkg) => pkg.is_snippet === true)
+      .map((pkg) => {
+        // Get the package release
+        const packageRelease = state.packageReleases.find(
+          (pr) =>
+            pr.package_release_id === pkg.latest_package_release_id &&
+            pr.is_latest === true,
+        )
+        if (!packageRelease) return null
+
+        // Get the package files
+        const packageFiles = state.packageFiles.filter(
+          (file) =>
+            file.package_release_id === packageRelease.package_release_id,
+        )
+
+        // Get the code file
+        const codeFile = packageFiles.find(
+          (file) =>
+            file.file_path === "index.ts" || file.file_path === "index.tsx",
+        )
+
+        // Check if starred
+        const isStarred = state.accountPackages.some(
+          (ap) => ap.package_id === pkg.package_id && ap.is_starred,
+        )
+
+        // Convert to snippet format
+        return {
+          snippet_id: pkg.package_id,
+          package_release_id: pkg.latest_package_release_id || "",
+          unscoped_name: pkg.unscoped_name,
+          name: pkg.name,
+          owner_name: pkg.owner_github_username || "",
+          description: pkg.description || "",
+          snippet_type: pkg.snippet_type || "board",
+          code: codeFile?.content_text || "",
+          dts:
+            packageFiles.find((file) => file.file_path === "/dist/index.d.ts")
+              ?.content_text || "",
+          compiled_js:
+            packageFiles.find((file) => file.file_path === "/dist/index.js")
+              ?.content_text || "",
+          created_at: pkg.created_at,
+          updated_at: pkg.updated_at,
+          star_count: pkg.star_count || 0,
+          is_starred: isStarred,
+          version: pkg.latest_version || "0.0.1",
+          circuit_json:
+            packageFiles
+              .filter((file) => file.file_path === "/dist/circuit.json")
+              .flatMap((file) => JSON.parse(file.content_text || "[]")) || [],
+        }
+      })
+      .filter(
+        (snippet): snippet is NonNullable<typeof snippet> => snippet !== null,
+      )
       .map((snippet) => ({
         ...snippet,
-        star_count: state.accountSnippets.filter(
-          (as) => as.snippet_id === snippet.snippet_id && as.has_starred,
-        ).length,
+        description: snippet.description || "",
       }))
       .sort(
         (a, b) =>
           new Date(b.created_at).getTime() - new Date(a.created_at).getTime(),
       )
       .slice(0, limit)
+
+    return snippetPackages
   },
   getTrendingSnippets: (limit: number, since: string): Snippet[] => {
     const state = get()
@@ -140,32 +339,68 @@ const initializer = combine(databaseSchema.parse({}), (set, get) => ({
 
     // Get star counts within time period
     const recentStars = new Map<string, number>()
-    state.accountSnippets.forEach((as) => {
-      if (as.has_starred && new Date(as.created_at).getTime() >= sinceDate) {
+    state.accountPackages.forEach((ap) => {
+      if (ap.is_starred && new Date(ap.created_at).getTime() >= sinceDate) {
         recentStars.set(
-          as.snippet_id,
-          (recentStars.get(as.snippet_id) || 0) + 1,
+          ap.package_id,
+          (recentStars.get(ap.package_id) || 0) + 1,
         )
       }
     })
 
-    return [...state.snippets]
-      .map((snippet) => ({
-        ...snippet,
-        star_count: recentStars.get(snippet.snippet_id) || 0,
+    const packagesWithStarCount = [...state.packages]
+      .map((pkg) => ({
+        ...pkg,
+        star_count: recentStars.get(pkg.package_id) || 0,
       }))
       .sort((a, b) => b.star_count - a.star_count)
       .slice(0, limit)
+
+    const trendingSnippets = packagesWithStarCount
+      .map((pkg) => {
+        const packageRelease = state.packageReleases.find(
+          (pr) =>
+            pr.package_release_id === pkg.latest_package_release_id &&
+            pr.is_latest === true,
+        )
+        if (!packageRelease) return null
+
+        const packageFiles = state.packageFiles.filter(
+          (file) =>
+            file.package_release_id === packageRelease.package_release_id,
+        )
+
+        const codeFile = packageFiles.find(
+          (file) =>
+            file.file_path === "index.ts" || file.file_path === "index.tsx",
+        )
+
+        return {
+          snippet_id: pkg.package_id,
+          package_release_id: pkg.latest_package_release_id || "",
+          unscoped_name: pkg.unscoped_name,
+          name: pkg.name,
+          owner_name: pkg.owner_github_username || "",
+          code: codeFile ? codeFile.content_text || "" : "",
+          created_at: pkg.created_at,
+          updated_at: pkg.updated_at,
+          snippet_type: pkg.is_snippet ? "board" : "package",
+          star_count: pkg.star_count,
+        }
+      })
+      .filter((snippet) => snippet !== null)
+
+    return trendingSnippets as Snippet[]
   },
-  getSnippetsByAuthor: (authorName?: string): Snippet[] => {
+  getPackagesByAuthor: (authorName?: string): Package[] => {
     const state = get()
-    const snippets = authorName
-      ? state.snippets.filter((snippet) => snippet.owner_name === authorName)
-      : state.snippets
-    return snippets.map((snippet) => ({
-      ...snippet,
-      star_count: state.accountSnippets.filter(
-        (as) => as.snippet_id === snippet.snippet_id && as.has_starred,
+    const packages = authorName
+      ? state.packages.filter((pkg) => pkg.owner_github_username === authorName)
+      : state.packages
+    return packages.map((pkg) => ({
+      ...pkg,
+      star_count: state.accountPackages.filter(
+        (ap) => ap.package_id === pkg.package_id && ap.is_starred,
       ).length,
     }))
   },
@@ -174,68 +409,398 @@ const initializer = combine(databaseSchema.parse({}), (set, get) => ({
     snippetName: string,
   ): Snippet | undefined => {
     const state = get()
-    return state.snippets.find(
-      (snippet) =>
-        snippet.owner_name === authorName && snippet.name === snippetName,
+    // Look for the package that represents this snippet with case-insensitive matching
+    const _package = state.packages.find(
+      (pkg) =>
+        pkg.owner_github_username?.toLowerCase() === authorName.toLowerCase() &&
+        pkg.name.toLowerCase() === snippetName.toLowerCase() &&
+        pkg.is_snippet === true,
+    )
+    if (!_package) return undefined
+
+    // Get the package release
+    const packageRelease = state.packageReleases.find(
+      (pr) =>
+        pr.package_release_id === _package.latest_package_release_id &&
+        pr.is_latest === true,
     )
+    if (!packageRelease) return undefined
+
+    // Get the package files
+    const packageFiles = state.packageFiles.filter(
+      (file) => file.package_release_id === packageRelease.package_release_id,
+    )
+
+    // Get the code file (index.ts or index.tsx)
+    const codeFile = packageFiles.find(
+      (file) => file.file_path === "index.ts" || file.file_path === "index.tsx",
+    )
+
+    // Map the package data to match the Snippet structure
+    return {
+      snippet_id: _package.package_id,
+      package_release_id: _package.latest_package_release_id || "",
+      unscoped_name: _package.unscoped_name,
+      name: _package.name,
+      owner_name: _package.owner_github_username || "",
+      description: _package.description || "",
+      snippet_type: _package.snippet_type || "board",
+      code: codeFile?.content_text || "",
+      dts:
+        packageFiles.find((file) => file.file_path === "/dist/index.d.ts")
+          ?.content_text || "",
+      compiled_js:
+        packageFiles.find((file) => file.file_path === "/dist/index.js")
+          ?.content_text || "",
+      created_at: _package.created_at,
+      updated_at: _package.updated_at,
+      star_count: _package.star_count || 0,
+      is_starred: false,
+      version: _package.latest_version || "0.0.1",
+      circuit_json: packageFiles.find(
+        (file) => file.file_path === "/dist/circuit.json",
+      )?.content_text
+        ? JSON.parse(
+            packageFiles.find((file) => file.file_path === "/dist/circuit.json")
+              ?.content_text || "[]",
+          )
+        : [],
+    }
   },
   updateSnippet: (
-    snippet_id: string,
+    snippetId: string,
     updates: Partial<Snippet>,
   ): Snippet | undefined => {
-    let updatedSnippet: Snippet | undefined
     set((state) => {
-      const snippetIndex = state.snippets.findIndex(
-        (snippet) => snippet.snippet_id === snippet_id,
+      const packageIndex = state.packages.findIndex(
+        (pkg) => pkg.package_id === snippetId && pkg.is_snippet === true,
       )
-      if (snippetIndex === -1) {
+      if (packageIndex === -1) {
         return state
       }
-      const updatedSnippets = [...state.snippets]
-      updatedSnippet = {
-        ...updatedSnippets[snippetIndex],
-        ...updates,
-        updated_at: updates.updated_at || new Date().toISOString(),
+
+      const timestamp = Date.now()
+      const currentTime = new Date(timestamp).toISOString()
+
+      // Update the package
+      const updatedPackages = [...state.packages]
+      const currentPackage = updatedPackages[packageIndex]
+      updatedPackages[packageIndex] = {
+        ...currentPackage,
+        description: updates.description || currentPackage.description,
+        updated_at: currentTime,
+      }
+
+      // Get the current package release
+      const packageRelease = state.packageReleases.find(
+        (pr) =>
+          pr.package_release_id === currentPackage.latest_package_release_id,
+      )
+      if (!packageRelease) return state
+
+      // Update package files if code/dts/js changed
+      const updatedFiles = [...state.packageFiles]
+      const packageFiles = updatedFiles.filter(
+        (file) => file.package_release_id === packageRelease.package_release_id,
+      )
+
+      if (updates.code !== undefined) {
+        const codeFileIndex = packageFiles.findIndex(
+          (file) =>
+            file.file_path === "index.tsx" || file.file_path === "index.ts",
+        )
+        if (codeFileIndex >= 0) {
+          updatedFiles[codeFileIndex] = {
+            ...packageFiles[codeFileIndex],
+            content_text: updates.code,
+            created_at: currentTime,
+          }
+        } else {
+          updatedFiles.push({
+            package_file_id: `package_file_${timestamp}`,
+            package_release_id: packageRelease.package_release_id,
+            file_path: "index.tsx",
+            content_text: updates.code,
+            created_at: currentTime,
+          })
+        }
+      }
+
+      if (updates.dts !== undefined) {
+        const dtsFileIndex = packageFiles.findIndex(
+          (file) => file.file_path === "/dist/index.d.ts",
+        )
+        if (dtsFileIndex >= 0) {
+          updatedFiles[dtsFileIndex] = {
+            ...packageFiles[dtsFileIndex],
+            content_text: updates.dts,
+            created_at: currentTime,
+          }
+        } else {
+          updatedFiles.push({
+            package_file_id: `package_file_${timestamp}`,
+            package_release_id: packageRelease.package_release_id,
+            file_path: "/dist/index.d.ts",
+            content_text: updates.dts,
+            created_at: currentTime,
+          })
+        }
+      }
+
+      if (updates.compiled_js !== undefined) {
+        const jsFileIndex = packageFiles.findIndex(
+          (file) => file.file_path === "/dist/index.js",
+        )
+        if (jsFileIndex >= 0) {
+          updatedFiles[jsFileIndex] = {
+            ...packageFiles[jsFileIndex],
+            content_text: updates.compiled_js,
+            created_at: currentTime,
+          }
+        } else {
+          updatedFiles.push({
+            package_file_id: `package_file_${timestamp}`,
+            package_release_id: packageRelease.package_release_id,
+            file_path: "/dist/index.js",
+            content_text: updates.compiled_js,
+            created_at: currentTime,
+          })
+        }
+      }
+
+      // Update circuit JSON if provided
+      if (updates.circuit_json !== undefined) {
+        const circuitFileIndex = packageFiles.findIndex(
+          (file) => file.file_path === "/dist/circuit.json",
+        )
+        if (circuitFileIndex >= 0) {
+          updatedFiles[circuitFileIndex] = {
+            ...packageFiles[circuitFileIndex],
+            content_text: JSON.stringify(updates.circuit_json),
+            created_at: new Date().toISOString(),
+          }
+        }
+      }
+
+      // Return updated state
+      return {
+        ...state,
+        packages: updatedPackages,
+        packageFiles: updatedFiles,
       }
-      updatedSnippets[snippetIndex] = updatedSnippet
-      return { ...state, snippets: updatedSnippets }
     })
-    return updatedSnippet
+
+    // Get the updated snippet to return
+    const updatedPackage = get().packages.find(
+      (pkg) => pkg.package_id === snippetId,
+    )
+    if (!updatedPackage) return undefined
+
+    const packageRelease = get().packageReleases.find(
+      (pr) =>
+        pr.package_release_id === updatedPackage.latest_package_release_id,
+    )
+    if (!packageRelease) return undefined
+
+    const packageFiles = get().packageFiles.filter(
+      (file) => file.package_release_id === packageRelease.package_release_id,
+    )
+
+    const codeFile = packageFiles.find(
+      (file) => file.file_path === "index.ts" || file.file_path === "index.tsx",
+    )
+    const dtsFile = packageFiles.find(
+      (file) => file.file_path === "/dist/index.d.ts",
+    )
+    const jsFile = packageFiles.find(
+      (file) => file.file_path === "/dist/index.js",
+    )
+    const circuitFile = packageFiles.find(
+      (file) => file.file_path === "/dist/circuit.json",
+    )
+
+    // Return in snippet format
+    return {
+      snippet_id: updatedPackage.package_id,
+      package_release_id: updatedPackage.latest_package_release_id || "",
+      unscoped_name: updatedPackage.unscoped_name,
+      name: updatedPackage.name,
+      owner_name: updatedPackage.owner_github_username || "",
+      description: updatedPackage.description || "",
+      snippet_type: updatedPackage.snippet_type || "board",
+      code: codeFile?.content_text || "",
+      dts: dtsFile?.content_text || "",
+      compiled_js: jsFile?.content_text || "",
+      created_at: updatedPackage.created_at,
+      updated_at: updatedPackage.updated_at,
+      star_count: updatedPackage.star_count || 0,
+      is_starred: false,
+      version: updatedPackage.latest_version || "0.0.1",
+      circuit_json: circuitFile
+        ? JSON.parse(circuitFile.content_text || "[]")
+        : [],
+    }
   },
-  getSnippetById: (snippet_id: string): Snippet | undefined => {
+  getSnippetById: (snippetId: string): Snippet | undefined => {
     const state = get()
-    const snippet = state.snippets.find(
-      (snippet) => snippet.snippet_id === snippet_id,
+    // Look for the package that represents this snippet
+    const _package = state.packages.find(
+      (pkg) => pkg.package_id === snippetId && pkg.is_snippet === true,
+    )
+    if (!_package) return undefined
+
+    // Get the package release
+    const packageRelease = state.packageReleases.find(
+      (pr) =>
+        pr.package_release_id === _package.latest_package_release_id &&
+        pr.is_latest === true,
+    )
+    if (!packageRelease) return undefined
+
+    // Get the package files
+    const packageFiles = state.packageFiles.filter(
+      (file) => file.package_release_id === packageRelease.package_release_id,
+    )
+
+    // Get the code file (index.ts or index.tsx)
+    const codeFile = packageFiles.find(
+      (file) => file.file_path === "index.ts" || file.file_path === "index.tsx",
     )
-    if (!snippet) return undefined
+
+    // Check if the current user has starred this snippet
+    const isStarred = state.accountPackages.some(
+      (ap) => ap.package_id === snippetId && ap.is_starred,
+    )
+
+    // Map the package data to match the Snippet structure
     return {
-      ...snippet,
-      star_count: state.accountSnippets.filter(
-        (as) => as.snippet_id === snippet_id && as.has_starred,
-      ).length,
+      snippet_id: _package.package_id,
+      package_release_id: _package.latest_package_release_id || "",
+      unscoped_name: _package.unscoped_name,
+      name: _package.name,
+      owner_name: _package.owner_github_username || "",
+      description: _package.description || "",
+      snippet_type: _package.snippet_type || "board",
+      code: codeFile?.content_text || "",
+      dts:
+        packageFiles.find((file) => file.file_path === "/dist/index.d.ts")
+          ?.content_text || "",
+      compiled_js:
+        packageFiles.find((file) => file.file_path === "/dist/index.js")
+          ?.content_text || "",
+      created_at: _package.created_at,
+      updated_at: _package.updated_at,
+      star_count: _package.star_count || 0,
+      is_starred: isStarred,
+      version: _package.latest_version || "0.0.1",
+      circuit_json: packageFiles.find(
+        (file) => file.file_path === "/dist/circuit.json",
+      )?.content_text
+        ? JSON.parse(
+            packageFiles.find((file) => file.file_path === "/dist/circuit.json")
+              ?.content_text || "[]",
+          )
+        : [],
     }
   },
   searchSnippets: (query: string): Snippet[] => {
     const state = get()
     const lowercaseQuery = query.toLowerCase()
-    return state.snippets
-      .filter(
-        (snippet) =>
-          snippet.name.toLowerCase().includes(lowercaseQuery) ||
-          snippet.description?.toLowerCase().includes(lowercaseQuery) ||
-          snippet.code.toLowerCase().includes(lowercaseQuery),
-      )
-      .map((snippet) => ({
-        ...snippet,
-        star_count: state.accountSnippets.filter(
-          (as) => as.snippet_id === snippet.snippet_id && as.has_starred,
-        ).length,
-      }))
+
+    // Get all packages that are snippets
+    const packages = state.packages.filter((pkg) => pkg.is_snippet === true)
+
+    // Find packages that match by name or description
+    const matchingPackagesByMetadata = packages.filter(
+      (pkg) =>
+        pkg.name.toLowerCase().includes(lowercaseQuery) ||
+        pkg.description?.toLowerCase().includes(lowercaseQuery),
+    )
+
+    // Find packages that match by code content in any file
+    const matchingFilesByContent = state.packageFiles.filter(
+      (file) =>
+        file.content_text?.toLowerCase().includes(lowercaseQuery) ?? false,
+    )
+
+    // Get the packages for matching files
+    const matchingPackagesByContent = matchingFilesByContent
+      .map((file) => {
+        // Find the package release for this file
+        const packageRelease = state.packageReleases.find(
+          (pr) => pr.package_release_id === file.package_release_id,
+        )
+        if (!packageRelease) return null
+
+        // Find the package for this release
+        return packages.find(
+          (pkg) =>
+            pkg.latest_package_release_id === packageRelease.package_release_id,
+        )
+      })
+      .filter((pkg): pkg is NonNullable<typeof pkg> => pkg !== null)
+
+    // Combine both sets of matching packages and remove duplicates
+    const matchingPackages = [
+      ...new Set([...matchingPackagesByMetadata, ...matchingPackagesByContent]),
+    ]
+
+    // Convert matching packages to snippet format
+    return matchingPackages
+      .map((pkg) => {
+        const packageRelease = state.packageReleases.find(
+          (pr) =>
+            pr.package_release_id === pkg.latest_package_release_id &&
+            pr.is_latest === true,
+        )
+        if (!packageRelease) return null
+
+        const packageFiles = state.packageFiles.filter(
+          (file) =>
+            file.package_release_id === packageRelease.package_release_id,
+        )
+
+        const codeFile = packageFiles.find(
+          (file) =>
+            file.file_path === "index.ts" || file.file_path === "index.tsx",
+        )
+
+        const isStarred = state.accountPackages.some(
+          (ap) => ap.package_id === pkg.package_id && ap.is_starred,
+        )
+
+        return {
+          snippet_id: pkg.package_id,
+          package_release_id: pkg.latest_package_release_id || "",
+          unscoped_name: pkg.unscoped_name,
+          name: pkg.name,
+          owner_name: pkg.owner_github_username || "",
+          description: pkg.description || "",
+          snippet_type: pkg.snippet_type || "board",
+          code: codeFile?.content_text || "",
+          dts:
+            packageFiles.find((file) => file.file_path === "/dist/index.d.ts")
+              ?.content_text || "",
+          compiled_js:
+            packageFiles.find((file) => file.file_path === "/dist/index.js")
+              ?.content_text || "",
+          created_at: pkg.created_at,
+          updated_at: pkg.updated_at,
+          star_count: pkg.star_count || 0,
+          is_starred: isStarred,
+          version: pkg.latest_version || "0.0.1",
+          circuit_json:
+            packageFiles
+              .filter((file) => file.file_path === "/dist/circuit.json")
+              .flatMap((file) => JSON.parse(file.content_text || "[]")) || [],
+        } as Snippet
+      })
+      .filter((snippet): snippet is Snippet => snippet !== null)
   },
-  deleteSnippet: (snippet_id: string): boolean => {
+  deleteSnippet: (snippetId: string): boolean => {
     let deleted = false
     set((state) => {
-      const index = state.snippets.findIndex((s) => s.snippet_id === snippet_id)
+      const index = state.snippets.findIndex((s) => s.snippet_id === snippetId)
       if (index !== -1) {
         state.snippets.splice(index, 1)
         deleted = true
@@ -277,32 +842,29 @@ const initializer = combine(databaseSchema.parse({}), (set, get) => ({
     }))
     return newLoginPage
   },
-  getLoginPage: (login_page_id: string): LoginPage | undefined => {
+  getLoginPage: (loginPageId: string): LoginPage | undefined => {
     const state = get()
-    return state.loginPages.find((lp) => lp.login_page_id === login_page_id)
+    return state.loginPages.find((lp) => lp.login_page_id === loginPageId)
   },
-  updateLoginPage: (
-    login_page_id: string,
-    updates: Partial<LoginPage>,
-  ): void => {
+  updateLoginPage: (loginPageId: string, updates: Partial<LoginPage>): void => {
     set((state) => ({
       loginPages: state.loginPages.map((lp) =>
-        lp.login_page_id === login_page_id ? { ...lp, ...updates } : lp,
+        lp.login_page_id === loginPageId ? { ...lp, ...updates } : lp,
       ),
     }))
   },
-  getAccount: (account_id: string): Account | undefined => {
+  getAccount: (accountId: string): Account | undefined => {
     const state = get()
-    return state.accounts.find((account) => account.account_id === account_id)
+    return state.accounts.find((account) => account.account_id === accountId)
   },
   updateAccount: (
-    account_id: string,
+    accountId: string,
     updates: Partial<Account>,
   ): Account | undefined => {
     let updatedAccount: Account | undefined
     set((state) => {
       const accountIndex = state.accounts.findIndex(
-        (account) => account.account_id === account_id,
+        (account) => account.account_id === accountId,
       )
       if (accountIndex !== -1) {
         updatedAccount = { ...state.accounts[accountIndex] }
@@ -329,72 +891,112 @@ const initializer = combine(databaseSchema.parse({}), (set, get) => ({
     }))
     return newSession
   },
-  addStar: (account_id: string, snippet_id: string): AccountSnippet => {
+  addStar: (accountId: string, packageId: string): AccountPackage => {
     const now = new Date().toISOString()
-    const accountSnippet = {
-      account_id,
-      snippet_id,
-      has_starred: true,
+    const accountPackage = {
+      account_package_id: `ap_${Date.now()}`,
+      account_id: accountId,
+      package_id: packageId,
+      is_starred: true,
       created_at: now,
       updated_at: now,
     }
-    set((state) => ({
-      accountSnippets: [...state.accountSnippets, accountSnippet],
-    }))
-    return accountSnippet
+
+    // Update the package's star count
+    set((state) => {
+      // Find the package and increment its star count
+      const packageIndex = state.packages.findIndex(
+        (pkg) => pkg.package_id === packageId,
+      )
+      if (packageIndex >= 0) {
+        const updatedPackages = [...state.packages]
+        updatedPackages[packageIndex] = {
+          ...updatedPackages[packageIndex],
+          star_count: (updatedPackages[packageIndex].star_count || 0) + 1,
+        }
+
+        return {
+          packages: updatedPackages,
+          accountPackages: [...state.accountPackages, accountPackage],
+        }
+      }
+
+      return {
+        accountPackages: [...state.accountPackages, accountPackage],
+      }
+    })
+
+    return accountPackage
   },
-  removeStar: (account_id: string, snippet_id: string): void => {
-    set((state) => ({
-      accountSnippets: state.accountSnippets.filter(
-        (as) => !(as.account_id === account_id && as.snippet_id === snippet_id),
-      ),
-    }))
+  removeStar: (accountId: string, packageId: string): void => {
+    set((state) => {
+      // Find the package and decrement its star count
+      const packageIndex = state.packages.findIndex(
+        (pkg) => pkg.package_id === packageId,
+      )
+
+      if (packageIndex >= 0) {
+        const updatedPackages = [...state.packages]
+        updatedPackages[packageIndex] = {
+          ...updatedPackages[packageIndex],
+          star_count: Math.max(
+            0,
+            (updatedPackages[packageIndex].star_count || 0) - 1,
+          ),
+        }
+
+        return {
+          packages: updatedPackages,
+          accountPackages: state.accountPackages.filter(
+            (ap) =>
+              !(ap.account_id === accountId && ap.package_id === packageId),
+          ),
+        }
+      }
+
+      return {
+        accountPackages: state.accountPackages.filter(
+          (ap) => !(ap.account_id === accountId && ap.package_id === packageId),
+        ),
+      }
+    })
   },
-  hasStarred: (account_id: string, snippet_id: string): boolean => {
+  hasStarred: (accountId: string, packageId: string): boolean => {
     const state = get()
-    return state.accountSnippets.some(
-      (as) =>
-        as.account_id === account_id &&
-        as.snippet_id === snippet_id &&
-        as.has_starred,
+    return state.accountPackages.some(
+      (ap) =>
+        ap.account_id === accountId &&
+        ap.package_id === packageId &&
+        ap.is_starred,
     )
   },
   addPackage: (
     _package: Omit<z.input<typeof packageSchema>, "package_id">,
   ): Package => {
+    const timestamp = Date.now()
     const newPackage = {
-      package_id: `package_${Date.now()}`,
+      package_id: `package_${timestamp}`,
       ..._package,
     }
-    const packageRelease = packageReleaseSchema.parse({
-      package_release_id: `package_release_${Date.now()}`,
-      package_id: newPackage.package_id,
-      version: "0.0.1",
-      is_locked: false,
-      is_latest: true,
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
-    })
-    newPackage.latest_package_release_id = packageRelease.package_release_id
     set((state) => ({
-      packages: [...state.packages, newPackage],
+      packages: [...state.packages, newPackage as Package],
     }))
-    return newPackage
+    return newPackage as Package
   },
-  getPackageById: (package_id: string): Package | undefined => {
+  getPackageById: (packageId: string): Package | undefined => {
     const state = get()
-    const pkg = state.packages.find((pkg) => pkg.package_id === package_id)
+    const pkg = state.packages.find((pkg) => pkg.package_id === packageId)
     if (!pkg) return undefined
     return {
       ...pkg,
     }
   },
   getPackageReleaseById: (
-    package_release_id: string,
+    packageReleaseId: string,
   ): PackageRelease | undefined => {
     const state = get()
     return state.packageReleases.find(
-      (pr) => pr.package_release_id === package_release_id,
+      (pr) => pr.package_release_id === packageReleaseId,
     )
   },
   addPackageRelease: (
@@ -430,4 +1032,16 @@ const initializer = combine(databaseSchema.parse({}), (set, get) => ({
     }))
     return newPackageFile
   },
+  getStarCount: (packageId: string): number => {
+    const state = get()
+    return state.accountPackages.filter(
+      (ap) => ap.package_id === packageId && ap.is_starred,
+    ).length
+  },
+  getPackageFilesByReleaseId: (packageReleaseId: string): PackageFile[] => {
+    const state = get()
+    return state.packageFiles.filter(
+      (pf) => pf.package_release_id === packageReleaseId,
+    )
+  },
 }))