@tscircuit/fake-snippets 0.0.7 → 0.0.9

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

@@ -91,6 +91,7 @@ export const orderFileSchema = z.object({
 })
 export type OrderFile = z.infer<typeof orderFileSchema>
 
+// TODO: Remove this schema after migration to accountPackages is complete
 export const accountSnippetSchema = z.object({
   account_id: z.string(),
   snippet_id: z.string(),
@@ -100,6 +101,16 @@ export const accountSnippetSchema = z.object({
 })
 export type AccountSnippet = z.infer<typeof accountSnippetSchema>
 
+export const accountPackageSchema = z.object({
+  account_package_id: z.string(),
+  account_id: z.string(),
+  package_id: z.string(),
+  is_starred: z.boolean(),
+  created_at: z.string(),
+  updated_at: z.string(),
+})
+export type AccountPackage = z.infer<typeof accountPackageSchema>
+
 export const packageReleaseSchema = z.object({
   package_release_id: z.string(),
   package_id: z.string(),
@@ -124,18 +135,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>
@@ -163,5 +183,6 @@ export const databaseSchema = z.object({
   orders: z.array(orderSchema).default([]),
   orderFiles: z.array(orderFileSchema).default([]),
   accountSnippets: z.array(accountSnippetSchema).default([]),
+  accountPackages: z.array(accountPackageSchema).default([]),
 })
 export type DatabaseSchema = z.infer<typeof databaseSchema>

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

@@ -17,6 +17,11 @@ 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,
@@ -27,5 +32,8 @@ export const publicMapPackage = (internal_package: {
     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/packages/list.ts

@@ -51,6 +51,9 @@ export default withRouteSpec({
 
   return ctx.json({
     ok: true,
-    packages,
+    packages: packages.map((p) => ({
+      ...p,
+      latest_package_release_id: p.latest_package_release_id || null,
+    })),
   })
 })

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

@@ -1,6 +1,5 @@
 import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
 import { z } from "zod"
-import { accountSnippetSchema } from "fake-snippets-api/lib/db/schema"
 
 export default withRouteSpec({
   methods: ["POST"],
@@ -10,13 +9,15 @@ export default withRouteSpec({
   }),
   jsonResponse: z.object({
     ok: z.boolean(),
-    account_snippet: accountSnippetSchema,
   }),
 })(async (req, ctx) => {
   const { snippet_id } = req.jsonBody
 
-  // Check if snippet exists
-  const snippet = ctx.db.getSnippetById(snippet_id)
+  // Check if snippet exists (as a package)
+  const snippet = ctx.db.packages.find(
+    (pkg) => pkg.package_id === snippet_id && pkg.is_snippet === true,
+  )
+
   if (!snippet) {
     return ctx.error(404, {
       error_code: "snippet_not_found",
@@ -25,18 +26,39 @@ export default withRouteSpec({
   }
 
   // Check if already starred
-  if (ctx.db.hasStarred(ctx.auth.account_id, snippet_id)) {
+  const existing = ctx.db.accountPackages.find(
+    (ap) =>
+      ap.account_id === ctx.auth.account_id && ap.package_id === snippet_id,
+  )
+
+  if (existing?.is_starred) {
     return ctx.error(400, {
       error_code: "already_starred",
       message: "You have already starred this snippet",
     })
   }
 
-  // Add star
-  const accountSnippet = ctx.db.addStar(ctx.auth.account_id, snippet_id)
+  // Update the package's star count
+  snippet.star_count = (snippet.star_count || 0) + 1
+
+  if (existing) {
+    // If record exists but is_starred is false, update to is_starred=true
+    existing.is_starred = true
+    existing.updated_at = new Date().toISOString()
+  } else {
+    // Add star by creating a new account_package record
+    const newAccountPackage = {
+      account_package_id: `ap_${Math.random().toString(36).substring(2, 15)}`,
+      account_id: ctx.auth.account_id,
+      package_id: snippet_id,
+      is_starred: true,
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString(),
+    }
+    ctx.db.addAccountPackage(newAccountPackage)
+  }
 
   return ctx.json({
     ok: true,
-    account_snippet: accountSnippet,
   })
 })

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

@@ -29,51 +29,145 @@ export default withRouteSpec({
     dts,
   } = req.jsonBody
 
+  const timestamp = Date.now()
+  const currentTime = new Date(timestamp).toISOString()
+
   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_${timestamp}`,
+      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: currentTime,
+      updated_at: currentTime,
+      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: `package_release_${timestamp}`,
+    }
+
+    ctx.db.addPackage(newPackage)
+
+    const newPackageRelease = {
+      package_release_id: `package_release_${timestamp}`,
+      package_id: newPackage.package_id,
+      version: "0.0.1",
+      is_latest: true,
+      is_locked: false,
+      created_at: currentTime,
+    }
+
+    ctx.db.addPackageRelease(newPackageRelease)
+
+    // 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: currentTime,
+    })
+
+    // 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: currentTime,
+      })
+    }
+
+    // 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: currentTime,
+      })
+    }
+
+    // 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: currentTime,
+      })
+    }
+
+    // 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: currentTime,
+      updated_at: currentTime,
+      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/fake-snippets-api/routes/api/snippets/delete.ts

@@ -13,8 +13,8 @@ export default withRouteSpec({
 })(async (req, ctx) => {
   const { snippet_id } = req.jsonBody
 
-  const snippetIndex = ctx.db.snippets.findIndex(
-    (s) => s.snippet_id === snippet_id,
+  const snippetIndex = ctx.db.packages.findIndex(
+    (s) => s.package_id === snippet_id,
   )
 
   if (snippetIndex === -1) {
@@ -24,16 +24,16 @@ export default withRouteSpec({
     })
   }
 
-  const snippet = ctx.db.snippets[snippetIndex]
+  const snippet = ctx.db.packages[snippetIndex]
 
-  if (snippet.owner_name !== ctx.auth.github_username) {
+  if (snippet.creator_account_id !== ctx.auth.github_username) {
     return ctx.error(403, {
       error_code: "forbidden",
       message: "You don't have permission to delete this snippet",
     })
   }
 
-  ctx.db.snippets.splice(snippetIndex, 1)
+  ctx.db.packages.splice(snippetIndex, 1)
 
   return ctx.json({
     ok: true,

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

@@ -21,11 +21,19 @@ export default withRouteSpec({
   const fileName = rest.join("/")
 
   // Find the snippet
-  const snippet = ctx.db.snippets.find(
-    (s) => s.owner_name === owner && s.unscoped_name === packageName,
+  const _package = ctx.db.packages.find(
+    (s) => s.owner_github_username === owner && s.unscoped_name === packageName,
   )
 
-  if (!snippet) {
+  const packageRelease = ctx.db.packageReleases.find(
+    (p) => p.package_id === _package?.package_id,
+  )
+
+  const packageFiles = ctx.db.packageFiles.filter(
+    (p) => p.package_release_id === packageRelease?.package_release_id,
+  )
+
+  if (!_package) {
     return ctx.error(404, {
       error_code: "snippet_not_found",
       message: "Snippet not found",
@@ -64,21 +72,23 @@ export default withRouteSpec({
         type: "file",
         name: "index.ts",
         hash: "placeholder_hash",
-        time: snippet.updated_at,
-        size: snippet.code.length,
+        time: packageRelease?.created_at,
+        size: packageFiles.find((f) => f.file_path === "index.ts")?.content_text
+          ?.length,
       },
       {
         type: "file",
         name: "index.d.ts",
         hash: "placeholder_hash",
-        time: snippet.updated_at,
-        size: (snippet.dts || "").length,
+        time: packageRelease?.created_at,
+        size: packageFiles.find((f) => f.file_path === "index.d.ts")
+          ?.content_text?.length,
       },
       {
         type: "file",
         name: "package.json",
         hash: "placeholder_hash",
-        time: snippet.updated_at,
+        time: packageRelease?.created_at,
         size: JSON.stringify({
           name: `@tsci/${owner}.${packageName}`,
           version: version || "0.0.1",
@@ -117,10 +127,14 @@ export default withRouteSpec({
   let content: string
   switch (fileName) {
     case "index.ts":
-      content = snippet.code
+      content =
+        packageFiles.find((f) => f.file_path === "index.tsx")?.content_text ||
+        ""
       break
     case "index.d.ts":
-      content = snippet.dts || ""
+      content =
+        packageFiles.find((f) => f.file_path === "/dist/index.d.ts")
+          ?.content_text || ""
       break
     case "package.json":
       content = JSON.stringify(

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

@@ -1,6 +1,6 @@
+import { snippetSchema } from "fake-snippets-api/lib/db/schema"
 import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
 import { z } from "zod"
-import { snippetSchema } from "fake-snippets-api/lib/db/schema"
 
 export default withRouteSpec({
   methods: ["GET", "POST"],
@@ -19,16 +19,50 @@ export default withRouteSpec({
 })(async (req, ctx) => {
   const { snippet_id, name, owner_name, unscoped_name } = req.commonParams
 
-  const foundSnippet =
-    (snippet_id && ctx.db.getSnippetById(snippet_id)) ||
-    ctx.db.snippets.find((s) => {
-      if (name && s.name !== name) return false
-      if (owner_name && s.owner_name !== owner_name) return false
-      if (unscoped_name && s.unscoped_name !== unscoped_name) return false
-      return true
+  // First try to find by snippet_id
+  if (snippet_id) {
+    const foundSnippet = ctx.db.getSnippetById(snippet_id)
+    if (foundSnippet) {
+      if (ctx.auth) {
+        foundSnippet.is_starred = ctx.db.hasStarred(
+          ctx.auth.account_id,
+          foundSnippet.snippet_id,
+        )
+      }
+      return ctx.json({
+        ok: true,
+        snippet: foundSnippet,
+      })
+    }
+  }
+
+  // If not found by ID, try to find by other parameters
+  const foundPackage = ctx.db.packages.find((pkg) => {
+    if (!pkg.is_snippet) return false
+    if (name && pkg.name.toLowerCase() !== name.toLowerCase()) return false
+    if (
+      owner_name &&
+      pkg.owner_github_username?.toLowerCase() !== owner_name.toLowerCase()
+    )
+      return false
+    if (
+      unscoped_name &&
+      pkg.unscoped_name.toLowerCase() !== unscoped_name.toLowerCase()
+    )
+      return false
+    return true
+  })
+
+  if (!foundPackage) {
+    return ctx.error(404, {
+      error_code: "snippet_not_found",
+      message: `Snippet not found (searched using ${JSON.stringify(req.commonParams)})`,
     })
+  }
 
-  if (!foundSnippet) {
+  // Convert package to snippet format
+  const snippet = ctx.db.getSnippetById(foundPackage.package_id)
+  if (!snippet) {
     return ctx.error(404, {
       error_code: "snippet_not_found",
       message: `Snippet not found (searched using ${JSON.stringify(req.commonParams)})`,
@@ -36,15 +70,14 @@ export default withRouteSpec({
   }
 
   if (ctx.auth) {
-    const starred = ctx.db.hasStarred(
+    snippet.is_starred = ctx.db.hasStarred(
       ctx.auth.account_id,
-      foundSnippet.snippet_id,
+      snippet.snippet_id,
     )
-    foundSnippet.is_starred = starred
   }
 
   return ctx.json({
     ok: true,
-    snippet: foundSnippet,
+    snippet,
   })
 })

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

@@ -17,10 +17,45 @@ export default withRouteSpec({
 })(async (req, ctx) => {
   const { owner_name, unscoped_name } = req.commonParams
 
-  const snippets = ctx.db
-    .getSnippetsByAuthor(owner_name)
+  const packages = ctx.db
+    .getPackagesByAuthor(owner_name)
     .filter((s) => !unscoped_name || s.unscoped_name === unscoped_name)
 
+  const snippets = packages.map((pkg) => {
+    const packageRelease = ctx.db.getPackageReleaseById(
+      pkg.latest_package_release_id || "",
+    )
+    const packageFiles = ctx.db.getPackageFilesByReleaseId(
+      packageRelease?.package_release_id || "",
+    )
+    const codeFile = packageFiles.find(
+      (file) => file.file_path === "index.ts" || file.file_path === "index.tsx",
+    )
+    const starCount = ctx.db.getStarCount(pkg.package_id)
+
+    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: starCount,
+      is_starred: false,
+      version: pkg.latest_version || "0.0.1",
+    }
+  })
+
   return ctx.json({
     ok: true,
     snippets,

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

@@ -33,20 +33,39 @@ export default withRouteSpec({
     manual_edits_json_content,
   } = req.jsonBody
 
-  const snippetIndex = ctx.db.snippets.findIndex(
-    (s) => s.snippet_id === snippet_id,
+  const packageIndex = ctx.db.packages.findIndex(
+    (s) => s.package_id === snippet_id,
   )
 
-  if (snippetIndex === -1) {
+  if (packageIndex === -1) {
     return ctx.error(404, {
       error_code: "snippet_not_found",
       message: "Snippet not found",
     })
   }
 
-  const snippet = ctx.db.snippets[snippetIndex]
+  const _package = ctx.db.packages[packageIndex]
+  const packageRelease = ctx.db.packageReleases.find(
+    (r) => r.package_release_id === _package.latest_package_release_id,
+  )
+  const packageFiles = ctx.db.packageFiles.filter(
+    (f) => f.package_release_id === packageRelease?.package_release_id,
+  )
+  const codeFile = packageFiles.find(
+    (f) => f.file_path === "index.tsx" || f.file_path === "index.ts",
+  )
+  const dtsFile = packageFiles.find((f) => f.file_path === "/dist/index.d.ts")
+  const compiledJsFile = packageFiles.find(
+    (f) => f.file_path === "/dist/index.js",
+  )
+  const manualEditsJsonFile = packageFiles.find(
+    (f) => f.file_path === "manual-edits.json",
+  )
+  const circuitJsonFile = packageFiles.find(
+    (f) => f.file_path === "/dist/circuit.json",
+  )
 
-  if (snippet.owner_name !== ctx.auth.github_username) {
+  if (_package.creator_account_id !== ctx.auth.account_id) {
     return ctx.error(403, {
       error_code: "forbidden",
       message: "You don't have permission to update this snippet",
@@ -54,21 +73,24 @@ export default withRouteSpec({
   }
 
   const updatedSnippet = ctx.db.updateSnippet(snippet_id, {
-    code: code ?? snippet.code,
-    description: description ?? snippet.description,
-    unscoped_name: unscoped_name ?? snippet.unscoped_name,
+    code: code ?? codeFile?.content_text ?? "",
+    description: description ?? _package.description ?? "",
+    unscoped_name: unscoped_name ?? _package.unscoped_name,
     name: unscoped_name
       ? `${ctx.auth.github_username}/${unscoped_name}`
-      : snippet.name,
-    dts: dts ?? snippet.dts,
-    compiled_js: compiled_js !== undefined ? compiled_js : snippet.compiled_js,
+      : _package.name,
+    dts: dts ?? dtsFile?.content_text ?? "",
+    compiled_js: compiled_js ?? compiledJsFile?.content_text ?? "",
     manual_edits_json_content:
       manual_edits_json_content !== undefined
         ? manual_edits_json_content
-        : snippet.manual_edits_json_content,
+        : (manualEditsJsonFile?.content_text ?? ""),
     circuit_json:
-      circuit_json !== undefined ? circuit_json : snippet.circuit_json,
-    snippet_type: snippet_type ?? snippet.snippet_type,
+      circuit_json ??
+      (circuitJsonFile?.content_text
+        ? JSON.parse(circuitJsonFile.content_text)
+        : []),
+    snippet_type: snippet_type ?? _package.snippet_type,
     updated_at: new Date().toISOString(),
   })