@tscircuit/fake-snippets 0.0.7 → 0.0.8

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

@@ -1,26 +1,24 @@
-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 AccountSnippet,
+  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,
+  snippetSchema,
 } from "./schema.ts"
-import { combine } from "zustand/middleware"
 import { seed as seedFn } from "./seed"
 
 export const createDatabase = ({ seed }: { seed?: boolean } = {}) => {
@@ -35,7 +33,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],
@@ -180,13 +178,13 @@ const initializer = combine(databaseSchema.parse({}), (set, get) => ({
     )
   },
   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,
+        (snippet) => snippet.snippet_id === snippetId,
       )
       if (snippetIndex === -1) {
         return state
@@ -202,16 +200,16 @@ const initializer = combine(databaseSchema.parse({}), (set, get) => ({
     })
     return updatedSnippet
   },
-  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,
+      (snippet) => snippet.snippet_id === snippetId,
     )
     if (!snippet) return undefined
     return {
       ...snippet,
       star_count: state.accountSnippets.filter(
-        (as) => as.snippet_id === snippet_id && as.has_starred,
+        (as) => as.snippet_id === snippetId && as.has_starred,
       ).length,
     }
   },
@@ -232,10 +230,10 @@ const initializer = combine(databaseSchema.parse({}), (set, get) => ({
         ).length,
       }))
   },
-  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 +275,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,11 +324,11 @@ const initializer = combine(databaseSchema.parse({}), (set, get) => ({
     }))
     return newSession
   },
-  addStar: (account_id: string, snippet_id: string): AccountSnippet => {
+  addStar: (accountId: string, snippetId: string): AccountSnippet => {
     const now = new Date().toISOString()
     const accountSnippet = {
-      account_id,
-      snippet_id,
+      account_id: accountId,
+      snippet_id: snippetId,
       has_starred: true,
       created_at: now,
       updated_at: now,
@@ -343,19 +338,19 @@ const initializer = combine(databaseSchema.parse({}), (set, get) => ({
     }))
     return accountSnippet
   },
-  removeStar: (account_id: string, snippet_id: string): void => {
+  removeStar: (accountId: string, snippetId: string): void => {
     set((state) => ({
       accountSnippets: state.accountSnippets.filter(
-        (as) => !(as.account_id === account_id && as.snippet_id === snippet_id),
+        (as) => !(as.account_id === accountId && as.snippet_id === snippetId),
       ),
     }))
   },
-  hasStarred: (account_id: string, snippet_id: string): boolean => {
+  hasStarred: (accountId: string, snippetId: string): boolean => {
     const state = get()
     return state.accountSnippets.some(
       (as) =>
-        as.account_id === account_id &&
-        as.snippet_id === snippet_id &&
+        as.account_id === accountId &&
+        as.snippet_id === snippetId &&
         as.has_starred,
     )
   },
@@ -377,24 +372,24 @@ const initializer = combine(databaseSchema.parse({}), (set, get) => ({
     })
     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: (

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

@@ -124,18 +124,27 @@ export type PackageFile = z.infer<typeof packageFileSchema>
 export const packageSchema = z.object({
   package_id: z.string(),
   creator_account_id: z.string(),
-  latest_package_release_id: z.string().nullable(),
-  latest_version: z.string().nullable(),
-  license: z.string().nullable(),
   owner_org_id: z.string(),
   owner_github_username: z.string().nullable(),
-  is_source_from_github: z.boolean(),
-  description: z.string().nullable(),
   name: z.string(),
   unscoped_name: z.string(),
-  star_count: z.number(),
+  description: z.string().nullable(),
   created_at: z.string().datetime(),
   updated_at: z.string().datetime(),
+  is_snippet: z.boolean().default(false),
+  is_board: z.boolean().default(false),
+  is_package: z.boolean().default(false),
+  is_model: z.boolean().default(false),
+  is_footprint: z.boolean().default(false),
+  is_private: z.boolean().nullable().default(false),
+  is_public: z.boolean().nullable().default(true),
+  is_unlisted: z.boolean().nullable().default(false),
+  is_source_from_github: z.boolean().default(false),
+  snippet_type: z.enum(["board", "package", "model", "footprint"]).optional(),
+  latest_package_release_id: z.string().nullable(),
+  latest_version: z.string().nullable(),
+  license: z.string().nullable(),
+  star_count: z.number().default(0),
   ai_description: z.string().nullable(),
 })
 export type Package = z.infer<typeof packageSchema>

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

@@ -17,15 +17,22 @@ export const publicMapPackage = (internal_package: {
   updated_at: string
   created_at: string
   ai_description: string | null
+  is_snippet: boolean
+  is_board: boolean
+  is_package: boolean
+  is_model: boolean
+  is_footprint: boolean
 }): ZT.Package => {
   return {
     ...internal_package,
-    latest_package_release_id:
-      internal_package.latest_package_release_id ?? null,
+    latest_package_release_id: internal_package.latest_package_release_id ?? "",
     latest_version: internal_package.latest_version ?? null,
     license: internal_package.latest_license ?? null,
     star_count: internal_package.star_count ?? 0,
     created_at: internal_package.created_at,
     updated_at: internal_package.updated_at,
+    is_private: false,
+    is_public: true,
+    is_unlisted: false,
   }
 }

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

@@ -30,50 +30,144 @@ export default withRouteSpec({
   } = req.jsonBody
 
   if (!unscoped_name) {
-    unscoped_name = `untitled-${snippet_type}-${ctx.db.idCounter + 1}`
+    // Count snippets of this type for this user
+    const userSnippets = ctx.db.packages.filter(
+      (p) =>
+        p.owner_github_username === ctx.auth.github_username &&
+        p.is_snippet === true &&
+        ((p.is_board && snippet_type === "board") ||
+          (p.is_package && snippet_type === "package") ||
+          (p.is_model && snippet_type === "model") ||
+          (p.is_footprint && snippet_type === "footprint")),
+    )
+    unscoped_name = `untitled-${snippet_type}-${userSnippets.length + 1}`
   }
 
-  const existingSnippet = ctx.db.snippets.find(
-    (snippet) =>
-      snippet.unscoped_name === unscoped_name &&
-      snippet.owner_name === ctx.auth.github_username,
+  const existingPackage = ctx.db.packages.find(
+    (pkg) =>
+      pkg.unscoped_name === unscoped_name &&
+      pkg.owner_github_username === ctx.auth.github_username,
   )
 
-  if (existingSnippet) {
+  if (existingPackage) {
     return ctx.error(400, {
       error_code: "snippet_already_exists",
       message: "You have already forked this snippet in your account.",
     })
   }
 
-  let newSnippet: Omit<
-    z.input<typeof snippetSchema>,
-    "snippet_id" | "package_release_id"
-  > = {
-    name: `${ctx.auth.github_username}/${unscoped_name}`,
-    unscoped_name,
-    owner_name: ctx.auth.github_username,
-    code,
-    created_at: new Date().toISOString(),
-    updated_at: new Date().toISOString(),
-    snippet_type,
-    description,
-    compiled_js,
-    circuit_json,
-    dts,
-  }
-
   try {
-    newSnippet = ctx.db.addSnippet(newSnippet)
+    // Create the package directly (which will serve as our snippet)
+    const newPackage = {
+      package_id: `pkg_${Date.now()}`,
+      creator_account_id: ctx.auth.account_id,
+      owner_org_id: ctx.auth.personal_org_id,
+      owner_github_username: ctx.auth.github_username,
+      is_source_from_github: false,
+      description: description,
+      name: `${ctx.auth.github_username}/${unscoped_name}`,
+      unscoped_name: unscoped_name,
+      latest_version: "0.0.1",
+      license: null,
+      star_count: 0,
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString(),
+      ai_description: null,
+      is_snippet: true,
+      is_board: snippet_type === "board",
+      is_package: snippet_type === "package",
+      is_model: snippet_type === "model",
+      is_footprint: snippet_type === "footprint",
+      snippet_type: snippet_type,
+      is_private: false,
+      is_public: true,
+      is_unlisted: false,
+      latest_package_release_id: "",
+    }
+
+    ctx.db.addPackage(newPackage)
+
+    const newPackageRelease = {
+      package_release_id: `package_release_${Date.now()}`,
+      package_id: newPackage.package_id,
+      version: "0.0.1",
+      is_latest: true,
+      is_locked: false,
+      created_at: newPackage.created_at,
+    }
+
+    ctx.db.addPackageRelease(newPackageRelease)
+
+    // Update the package with the release ID
+    newPackage.latest_package_release_id = newPackageRelease.package_release_id
+
+    // Add package files
+    // Add index.tsx file with the code content
+    ctx.db.addPackageFile({
+      package_release_id: newPackageRelease.package_release_id,
+      file_path: "index.tsx",
+      content_text: code,
+      created_at: new Date().toISOString(),
+    })
+
+    // Add DTS file if provided
+    if (dts) {
+      ctx.db.addPackageFile({
+        package_release_id: newPackageRelease.package_release_id,
+        file_path: "/dist/index.d.ts",
+        content_text: dts,
+        created_at: new Date().toISOString(),
+      })
+    }
+
+    // Add compiled JS if provided
+    if (compiled_js) {
+      ctx.db.addPackageFile({
+        package_release_id: newPackageRelease.package_release_id,
+        file_path: "/dist/index.js",
+        content_text: compiled_js,
+        created_at: new Date().toISOString(),
+      })
+    }
+
+    // Add circuit JSON if provided
+    if (circuit_json) {
+      ctx.db.addPackageFile({
+        package_release_id: newPackageRelease.package_release_id,
+        file_path: "/dist/circuit.json",
+        content_text: JSON.stringify(circuit_json),
+        created_at: new Date().toISOString(),
+      })
+    }
+
+    // Create the snippet response object
+    const snippetResponse = {
+      snippet_id: newPackage.package_id,
+      package_release_id: newPackageRelease.package_release_id,
+      name: newPackage.name,
+      unscoped_name: newPackage.unscoped_name,
+      owner_name: ctx.auth.github_username,
+      code,
+      dts,
+      compiled_js,
+      star_count: 0,
+      created_at: newPackage.created_at,
+      updated_at: newPackage.updated_at,
+      snippet_type: snippet_type,
+      circuit_json: circuit_json,
+      description: description,
+      is_starred: false,
+      version: "0.0.1",
+    }
+
+    return ctx.json({
+      ok: true,
+      snippet: snippetResponse,
+    })
   } catch (error) {
     return ctx.error(500, {
       error_code: "snippet_creation_failed",
       message: `Failed to create snippet: ${error}`,
     })
   }
-
-  return ctx.json({
-    ok: true,
-    snippet: newSnippet as any,
-  })
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/fake-snippets",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "type": "module",
   "repository": {
     "type": "git",
@@ -146,6 +146,7 @@
     "@vitejs/plugin-react": "^4.3.1",
     "autoprefixer": "^10.4.20",
     "circuit-to-svg": "^0.0.101",
+    "get-port": "^7.1.0",
     "globals": "^15.9.0",
     "postcss": "^8.4.47",
     "prismjs": "^1.29.0",