@tscircuit/fake-snippets 0.0.6 → 0.0.8

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

@@ -1,25 +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,
+  type packageSchema,
+  snippetSchema,
 } from "./schema.ts"
-import { combine } from "zustand/middleware"
 import { seed as seedFn } from "./seed"
 
 export const createDatabase = ({ seed }: { seed?: boolean } = {}) => {
@@ -34,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],
@@ -179,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
@@ -201,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,
     }
   },
@@ -231,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
@@ -276,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] }
@@ -328,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,
@@ -342,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,
     )
   },
@@ -376,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: (
@@ -417,4 +413,16 @@ const initializer = combine(databaseSchema.parse({}), (set, get) => ({
       ),
     }))
   },
+  addPackageFile: (
+    packageFile: Omit<PackageFile, "package_file_id">,
+  ): PackageFile => {
+    const newPackageFile = {
+      package_file_id: `package_file_${Date.now()}`,
+      ...packageFile,
+    }
+    set((state) => ({
+      packageFiles: [...state.packageFiles, newPackageFile],
+    }))
+    return newPackageFile
+  },
 }))

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/package_file/get-package-file-id-from-file-descriptor.ts

@@ -0,0 +1,168 @@
+import { NotFoundError } from "winterspec/middleware"
+import * as ZT from "../db/schema"
+export const getPackageFileIdFromFileDescriptor = async (
+  descriptor:
+    | { package_file_id: string }
+    | { package_release_id: string; file_path: string }
+    | { package_id: string; version?: string; file_path: string }
+    | { package_name: string; version?: string; file_path: string }
+    | { package_name_with_version: string; file_path: string },
+  ctx: { db: any },
+): Promise<string> => {
+  if ("package_file_id" in descriptor) {
+    const packageFile = ctx.db.packageFiles.find(
+      (pf: ZT.PackageFile) => pf.package_file_id === descriptor.package_file_id,
+    )
+
+    if (!packageFile) {
+      throw new NotFoundError("Package file not found")
+    }
+
+    return descriptor.package_file_id
+  }
+
+  if ("package_release_id" in descriptor) {
+    const { package_release_id, file_path } = descriptor
+    const packageFile = ctx.db.packageFiles.find(
+      (pf: ZT.PackageFile) =>
+        pf.package_release_id === package_release_id &&
+        pf.file_path === file_path,
+    )
+
+    if (!packageFile) {
+      throw new NotFoundError("Package file not found")
+    }
+
+    return packageFile.package_file_id
+  }
+
+  if ("package_id" in descriptor) {
+    const { package_id, version, file_path } = descriptor
+
+    // Verify package exists
+    const pkg = ctx.db.packages.find(
+      (p: ZT.Package) => p.package_id === package_id,
+    )
+    if (!pkg) {
+      throw new NotFoundError("Package not found")
+    }
+
+    // Find the package release
+    let packageRelease
+    if (version) {
+      packageRelease = ctx.db.packageReleases.find(
+        (pr: ZT.PackageRelease) =>
+          pr.package_id === package_id && pr.version === version,
+      )
+    } else {
+      packageRelease = ctx.db.packageReleases.find(
+        (pr: ZT.PackageRelease) => pr.package_id === package_id && pr.is_latest,
+      )
+    }
+
+    if (!packageRelease) {
+      throw new NotFoundError("Package release not found")
+    }
+
+    // Find the file
+    const packageFile = ctx.db.packageFiles.find(
+      (pf: ZT.PackageFile) =>
+        pf.package_release_id === packageRelease.package_release_id &&
+        pf.file_path === file_path,
+    )
+
+    if (!packageFile) {
+      throw new NotFoundError("Package file not found")
+    }
+
+    return packageFile.package_file_id
+  }
+
+  if ("package_name" in descriptor) {
+    const { package_name, version, file_path } = descriptor
+
+    // Find the package first
+    const pkg = ctx.db.packages.find((p: ZT.Package) => p.name === package_name)
+    if (!pkg) {
+      throw new NotFoundError(`Package not found: ${package_name}`)
+    }
+
+    // Find the package release
+    let packageRelease
+    if (version) {
+      packageRelease = ctx.db.packageReleases.find(
+        (pr: ZT.PackageRelease) =>
+          pr.package_id === pkg.package_id && pr.version === version,
+      )
+    } else {
+      packageRelease = ctx.db.packageReleases.find(
+        (pr: ZT.PackageRelease) =>
+          pr.package_id === pkg.package_id && pr.is_latest,
+      )
+    }
+
+    if (!packageRelease) {
+      throw new NotFoundError("Package release not found")
+    }
+
+    // Find the file
+    const packageFile = ctx.db.packageFiles.find(
+      (pf: ZT.PackageFile) =>
+        pf.package_release_id === packageRelease.package_release_id &&
+        pf.file_path === file_path,
+    )
+
+    if (!packageFile) {
+      throw new NotFoundError("Package file not found")
+    }
+
+    return packageFile.package_file_id
+  }
+
+  if ("package_name_with_version" in descriptor) {
+    const { package_name_with_version, file_path } = descriptor
+    const packageName = package_name_with_version.split("@")[1]
+    const version = package_name_with_version.split("@")[2]
+
+    // Find the package
+    const pkg = ctx.db.packages.find((p: ZT.Package) => p.name === packageName)
+    if (!pkg) {
+      throw new NotFoundError(`Package not found: ${packageName}`)
+    }
+
+    // Find the package release
+    let packageRelease
+    if (!version || version === "latest") {
+      packageRelease = ctx.db.packageReleases.find(
+        (pr: ZT.PackageRelease) =>
+          pr.package_id === pkg.package_id && pr.is_latest,
+      )
+    } else {
+      packageRelease = ctx.db.packageReleases.find(
+        (pr: ZT.PackageRelease) =>
+          pr.package_id === pkg.package_id && pr.version === version,
+      )
+    }
+
+    if (!packageRelease) {
+      throw new NotFoundError(
+        `Package release not found for version: ${version || "latest"}`,
+      )
+    }
+
+    // Find the file
+    const packageFile = ctx.db.packageFiles.find(
+      (pf: ZT.PackageFile) =>
+        pf.package_release_id === packageRelease.package_release_id &&
+        pf.file_path === file_path,
+    )
+
+    if (!packageFile) {
+      throw new NotFoundError(`Package file not found: ${file_path}`)
+    }
+
+    return packageFile.package_file_id
+  }
+
+  throw new NotFoundError("Invalid package file descriptor")
+}

package/fake-snippets-api/lib/package_release/find-package-release-id.ts

@@ -0,0 +1,122 @@
+import { Package, PackageRelease } from "fake-snippets-api/lib/db/schema"
+
+export const findPackageReleaseId = async (
+  params:
+    | string
+    | {
+        package_release_id: string
+      }
+    | {
+        package_name: string
+        use_latest_version: true
+      }
+    | {
+        package_name_with_version: string
+      }
+    | {
+        package_release_id?: string | undefined
+        package_name_with_version?: string | undefined
+      },
+  ctx: { db: any },
+): Promise<string | null> => {
+  if (typeof params === "string") {
+    return findPackageReleaseIdFromPackageNameWithVersion(params, ctx.db)
+  }
+
+  if (
+    "package_name_with_version" in params &&
+    params.package_name_with_version
+  ) {
+    const { package_name_with_version } = params
+
+    if (package_name_with_version.endsWith("@latest")) {
+      const [packageName] = package_name_with_version.split("@")
+      return findPackageReleaseId(
+        {
+          package_name: packageName!,
+          use_latest_version: true,
+        },
+        ctx,
+      )
+    }
+    return findPackageReleaseIdFromPackageNameWithVersion(
+      package_name_with_version!,
+      ctx.db,
+    )
+  }
+
+  if ("package_release_id" in params && params.package_release_id) {
+    const packageRelease = ctx.db.packageReleases.find(
+      (pr: PackageRelease) =>
+        pr.package_release_id === params.package_release_id,
+    )
+    if (!packageRelease) {
+      return null
+    }
+    return params.package_release_id
+  }
+
+  if ("package_name" in params) {
+    const { package_name, use_latest_version } = params
+
+    if (!use_latest_version) {
+      throw new Error("use_latest_version must be true")
+    }
+
+    const pkg = ctx.db.packages.find(
+      (p: Package) => p.name === package_name.replace(/^@/, ""),
+    )
+    if (!pkg) {
+      return null
+    }
+
+    const packageRelease = ctx.db.packageReleases.find(
+      (pr: PackageRelease) => pr.package_id === pkg.package_id && pr.is_latest,
+    )
+
+    if (!packageRelease) {
+      return null
+    }
+
+    return packageRelease.package_release_id
+  }
+
+  return null
+}
+
+export const findPackageReleaseIdFromPackageNameWithVersion = (
+  packageNameWithVersion: string,
+  db: any,
+): string | null => {
+  if (!packageNameWithVersion) return null
+
+  const [packageName, version] = packageNameWithVersion
+    .replace(/^@/, "")
+    .split("@")
+
+  const pkg = db.packages.find((p: Package) => p.name === packageName)
+  if (!pkg) {
+    return null
+  }
+
+  let packageRelease
+
+  if (!version || version === "latest") {
+    packageRelease = db.packageReleases.find(
+      (pr: PackageRelease) => pr.package_id === pkg.package_id && pr.is_latest,
+    )
+  } else {
+    packageRelease = db.packageReleases.find(
+      (pr: PackageRelease) =>
+        pr.package_id === pkg.package_id && pr.version === version,
+    )
+  }
+
+  if (!packageRelease) {
+    return null
+  }
+
+  console.log("packageRelease", packageRelease)
+
+  return packageRelease.package_release_id
+}

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,
   }
 }