@tscircuit/fake-snippets 0.0.3 → 0.0.5

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

@@ -14,6 +14,10 @@ import {
   Order,
   OrderFile,
   AccountSnippet,
+  packageReleaseSchema,
+  packageSchema,
+  Package,
+  PackageRelease,
 } from "./schema.ts"
 import { combine } from "zustand/middleware"
 import { seed as seedFn } from "./seed"
@@ -85,17 +89,31 @@ const initializer = combine(databaseSchema.parse({}), (set, get) => ({
     return newAccount
   },
   addSnippet: (
-    snippet: Omit<z.input<typeof snippetSchema>, "snippet_id">,
+    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,
+      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,
+      package_release_id: newPackageRelease.package_release_id,
     })
     set((state) => {
       return {
         snippets: [...state.snippets, newSnippet],
-        idCounter: state.idCounter + 1,
+        packageReleases: [...state.packageReleases, newPackageRelease],
+        idCounter: state.idCounter + 2,
       }
     })
     return { ...newSnippet, snippet_id: newSnippetId }
@@ -340,4 +358,63 @@ const initializer = combine(databaseSchema.parse({}), (set, get) => ({
         as.has_starred,
     )
   },
+  addPackage: (
+    _package: Omit<z.input<typeof packageSchema>, "package_id">,
+  ): Package => {
+    const newPackage = {
+      package_id: `package_${Date.now()}`,
+      ..._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],
+    }))
+    return newPackage
+  },
+  getPackageById: (package_id: string): Package | undefined => {
+    const state = get()
+    const pkg = state.packages.find((pkg) => pkg.package_id === package_id)
+    if (!pkg) return undefined
+    return {
+      ...pkg,
+    }
+  },
+  getPackageReleaseById: (
+    package_release_id: string,
+  ): PackageRelease | undefined => {
+    const state = get()
+    return state.packageReleases.find(
+      (pr) => pr.package_release_id === package_release_id,
+    )
+  },
+  addPackageRelease: (
+    packageRelease: Omit<PackageRelease, "package_release_id">,
+  ): PackageRelease => {
+    const newPackageRelease = {
+      package_release_id: `package_release_${Date.now()}`,
+      ...packageRelease,
+    }
+    set((state) => ({
+      packageReleases: [...state.packageReleases, newPackageRelease],
+    }))
+    return newPackageRelease
+  },
+  updatePackageRelease: (packageRelease: PackageRelease): void => {
+    set((state) => ({
+      packageReleases: state.packageReleases.map((pr) =>
+        pr.package_release_id === packageRelease.package_release_id
+          ? packageRelease
+          : pr,
+      ),
+    }))
+  },
 }))

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

@@ -2,6 +2,7 @@ import { z } from "zod"
 
 export const snippetSchema = z.object({
   snippet_id: z.string(),
+  package_release_id: z.string(),
   name: z.string(),
   unscoped_name: z.string(),
   owner_name: z.string(),
@@ -99,12 +100,66 @@ export const accountSnippetSchema = z.object({
 })
 export type AccountSnippet = z.infer<typeof accountSnippetSchema>
 
+export const packageReleaseSchema = z.object({
+  package_release_id: z.string(),
+  package_id: z.string(),
+  version: z.string().nullable(),
+  is_locked: z.boolean(),
+  is_latest: z.boolean(),
+  created_at: z.string().datetime(),
+  commit_sha: z.string().nullable().optional(),
+  license: z.string().nullable().optional(),
+})
+export type PackageRelease = z.infer<typeof packageReleaseSchema>
+
+export const packageFileSchema = z.object({
+  package_file_id: z.string(),
+  package_release_id: z.string(),
+  file_path: z.string(),
+  content_text: z.string().nullable().optional(),
+  created_at: z.string().datetime(),
+})
+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(),
+  created_at: z.string().datetime(),
+  updated_at: z.string().datetime(),
+  ai_description: z.string().nullable(),
+})
+export type Package = z.infer<typeof packageSchema>
+
+export const errorSchema = z
+  .object({
+    error_code: z.string(),
+    message: z.string(),
+  })
+  .passthrough()
+
+export const errorResponseSchema = z.object({
+  error: errorSchema,
+})
+
 export const databaseSchema = z.object({
   idCounter: z.number().default(0),
   snippets: z.array(snippetSchema).default([]),
+  packageReleases: z.array(packageReleaseSchema).default([]),
+  packageFiles: z.array(packageFileSchema).default([]),
   sessions: z.array(sessionSchema).default([]),
   loginPages: z.array(loginPageSchema).default([]),
   accounts: z.array(accountSchema).default([]),
+  packages: z.array(packageSchema).default([]),
   orders: z.array(orderSchema).default([]),
   orderFiles: z.array(orderFileSchema).default([]),
   accountSnippets: z.array(accountSnippetSchema).default([]),

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

@@ -0,0 +1,10 @@
+import * as ZT from "fake-snippets-api/lib/db/schema"
+
+export const publicMapPackageRelease = (
+  internal_package_release: ZT.PackageRelease,
+): ZT.PackageRelease => {
+  return {
+    ...internal_package_release,
+    created_at: internal_package_release.created_at,
+  }
+}

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

@@ -0,0 +1,31 @@
+import { z } from "zod"
+import * as ZT from "fake-snippets-api/lib/db/schema"
+
+export const publicMapPackage = (internal_package: {
+  package_id: string
+  creator_account_id: string
+  owner_org_id: string
+  owner_github_username: string | null
+  is_source_from_github: boolean
+  description: string | null
+  latest_version?: string | null
+  latest_license?: string | null
+  latest_package_release_id?: string | null
+  star_count?: number | null
+  name: string
+  unscoped_name: string
+  updated_at: string
+  created_at: string
+  ai_description: string | null
+}): ZT.Package => {
+  return {
+    ...internal_package,
+    latest_package_release_id:
+      internal_package.latest_package_release_id ?? null,
+    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,
+  }
+}

package/fake-snippets-api/lib/with-winter-spec.ts

@@ -0,0 +1 @@
+export * from "./middleware/with-winter-spec"

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

@@ -0,0 +1,170 @@
+import { withRouteSpec } from "fake-snippets-api/lib/with-winter-spec"
+import { z } from "zod"
+
+export default withRouteSpec({
+  methods: ["GET"],
+  auth: "none",
+  queryParams: z.object({
+    jsdelivr_resolve: z
+      .enum(["true", "false"])
+      .optional()
+      .transform((v) => v === "true"),
+    jsdelivr_path: z.string(),
+  }),
+  jsonResponse: z.any(),
+})(async (req, ctx) => {
+  const { jsdelivr_path, jsdelivr_resolve } = req.query
+
+  // Parse the file path
+  const [owner, packageWithVersion, ...rest] = jsdelivr_path.split("/")
+  if (!packageWithVersion) {
+    return ctx.error(400, {
+      error_code: "invalid_path",
+      message: "Invalid path",
+    })
+  }
+  const [packageName, version] = packageWithVersion.split("@")
+  const fileName = rest.join("/")
+
+  // Find the snippet
+  // const snippet =
+
+  // if (!snippet) {
+  //   return ctx.error(404, {
+  //     error_code: "snippet_not_found",
+  //     message: "Snippet not found",
+  //   })
+  // }
+
+  // if (!fileName && !jsdelivr_resolve) {
+  //   return new Response(
+  //     JSON.stringify({
+  //       tags: {
+  //         latest: "0.0.1",
+  //       },
+  //       versions: ["0.0.1"],
+  //     }),
+  //     {
+  //       status: 200,
+  //       headers: { "Content-Type": "application/json" },
+  //     },
+  //   )
+  // }
+
+  // if (!fileName && jsdelivr_resolve) {
+  //   return new Response(
+  //     JSON.stringify({
+  //       version: "0.0.1",
+  //     }),
+  //     {
+  //       status: 200,
+  //       headers: { "Content-Type": "application/json" },
+  //     },
+  //   )
+  // }
+
+  // const latestRelease = await ctx.db
+  //   .selectFrom("main.package_release")
+  //   .where("package_id", "=", snippet.snippet_id)
+  //   .where("is_latest", "=", true)
+  //   .selectAll()
+  //   .executeTakeFirst()
+
+  // const dtsFile = await ctx.db
+  //   .selectFrom("main.package_file")
+  //   .where("package_release_id", "=", latestRelease!.package_release_id)
+  //   .where("file_path", "=", "/dist/index.d.ts")
+  //   .select("content_text")
+  //   .executeTakeFirst()
+
+  // // If no fileName is provided, return the directory listing
+  // if (!fileName || fileName === "flat") {
+  //   const files = [
+  //     {
+  //       type: "file",
+  //       name: "index.ts",
+  //       hash: "placeholder_hash",
+  //       time: snippet.updated_at,
+  //       size: snippet.code?.length ?? 0,
+  //     },
+  //     {
+  //       type: "file",
+  //       name: "index.d.ts",
+  //       hash: "placeholder_hash",
+  //       time: snippet.updated_at,
+  //       size: dtsFile?.content_text?.length ?? 0,
+  //     },
+  //     {
+  //       type: "file",
+  //       name: "package.json",
+  //       hash: "placeholder_hash",
+  //       time: snippet.updated_at,
+  //       size: JSON.stringify({
+  //         name: `@tsci/${owner}.${packageName}`,
+  //         version: version || "0.0.1",
+  //         main: "index.ts",
+  //         types: "index.d.ts",
+  //       }).length,
+  //     },
+  //   ]
+
+  //   const response = {
+  //     default: "/index.ts",
+  //     files:
+  //       fileName === "flat"
+  //         ? files.map((f) => ({
+  //             name: `/${f.name}`,
+  //             hash: f.hash,
+  //             time: f.time,
+  //             size: f.size,
+  //           }))
+  //         : [
+  //             {
+  //               type: "directory",
+  //               name: ".",
+  //               files: files,
+  //             },
+  //           ],
+  //   }
+
+  //   return new Response(JSON.stringify(response, null, 2), {
+  //     status: 200,
+  //     headers: { "Content-Type": "application/json" },
+  //   })
+  // }
+
+  // // Handle file downloads
+  // let content: string
+  // switch (fileName) {
+  //   case "index.ts":
+  //     content = snippet.code ?? ""
+  //     break
+  //   case "index.d.ts":
+  //     content = dtsFile?.content_text ?? ""
+  //     break
+  //   case "package.json":
+  //     content = JSON.stringify(
+  //       {
+  //         name: `@tsci/${owner}.${packageName}`,
+  //         version: version || "0.0.1",
+  //         main: "index.ts",
+  //         types: "index.d.ts",
+  //       },
+  //       null,
+  //       2,
+  //     )
+  //     break
+  //   default:
+  //     return ctx.error(404, {
+  //       error_code: "file_not_found",
+  //       message: "Requested file not found",
+  //     })
+  // }
+
+  const content = "TODO"
+
+  return new Response(content, {
+    status: 200,
+    headers: { "Content-Type": "text/plain" },
+  })
+})

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

@@ -0,0 +1,52 @@
+import { withRouteSpec } from "fake-snippets-api/lib/with-winter-spec"
+import { z } from "zod"
+import * as ZT from "fake-snippets-api/lib/db/schema"
+import { NotFoundError } from "winterspec/middleware"
+
+const routeSpec = {
+  methods: ["POST"],
+  auth: "none",
+  jsonBody: z
+    .object({
+      package_file_id: z.string().uuid(),
+    })
+    .or(
+      z.object({
+        package_release_id: z.string().uuid(),
+        file_path: z.string(),
+      }),
+    )
+    .or(
+      z.object({
+        package_id: z.string().uuid(),
+        version: z.string().optional(),
+        file_path: z.string(),
+      }),
+    )
+    .or(
+      z.object({
+        package_name: z.string(),
+        version: z.string().optional(),
+        file_path: z.string(),
+      }),
+    )
+    .or(
+      z.object({
+        package_name_with_version: z.string(),
+        file_path: z.string(),
+      }),
+    ),
+  jsonResponse: z
+    .object({
+      ok: z.boolean(),
+      package_file: ZT.packageFileSchema.optional(),
+    })
+    .or(ZT.errorResponseSchema),
+} as const
+
+export default withRouteSpec(routeSpec)(async (req, ctx) => {
+  return ctx.json({
+    ok: true,
+    package_file: undefined,
+  })
+})

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

@@ -0,0 +1,60 @@
+import { withRouteSpec } from "fake-snippets-api/lib/with-winter-spec"
+import { z } from "zod"
+import * as ZT from "fake-snippets-api/lib/db/schema"
+
+const routeSpec = {
+  methods: ["POST"],
+  auth: "none",
+  jsonBody: z
+    .object({
+      package_release_id: z.string().uuid(),
+    })
+    .or(
+      z.object({
+        package_name: z.string(),
+        use_latest_version: z.literal(true),
+      }),
+    )
+    .or(
+      z.object({
+        package_name_with_version: z.string(),
+      }),
+    ),
+  jsonResponse: z.object({
+    ok: z.boolean(),
+    package_files: z.array(ZT.packageFileSchema),
+  }),
+} as const
+
+export default withRouteSpec(routeSpec)(async (req, ctx) => {
+  // const package_release_id = await findPackageReleaseId(req.jsonBody, ctx)
+  // if (!package_release_id) {
+  //   return ctx.error(404, {
+  //     error_code: "package_release_not_found",
+  //     message: "Package release not found",
+  //   })
+  // }
+  // const package_files = await ctx.db
+  //   .selectFrom("main.package_file")
+  //   .select([
+  //     "package_file_id",
+  //     "package_release_id",
+  //     "content_mimetype",
+  //     "file_path",
+  //     "created_at",
+  //   ])
+  //   .where("package_release_id", "=", package_release_id)
+  //   .where("file_path", "not like", ".tscircuit-internal/%")
+  //   .execute()
+  // return ctx.json({
+  //   ok: true,
+  //   package_files: package_files.map((pf) => ({
+  //     ...pf,
+  //     created_at: pf.created_at.toISOString(),
+  //   })),
+  // })
+  return ctx.json({
+    ok: true,
+    package_files: [],
+  })
+})

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

@@ -0,0 +1,83 @@
+import { packageReleaseSchema } from "fake-snippets-api/lib/db/schema"
+import { withRouteSpec } from "fake-snippets-api/lib/middleware/with-winter-spec"
+import { publicMapPackageRelease } from "fake-snippets-api/lib/public-mapping/public-map-package-release"
+import { z } from "zod"
+
+export default withRouteSpec({
+  methods: ["POST"],
+  auth: "none",
+  jsonBody: z.object({
+    package_id: z.string().optional(),
+    version: z.string().optional(),
+    is_latest: z.boolean().optional(),
+    commit_sha: z.string().optional(),
+    package_name_with_version: z.string().optional(),
+  }),
+  jsonResponse: z.object({
+    ok: z.boolean(),
+    package_release: packageReleaseSchema,
+  }),
+})(async (req, ctx) => {
+  let {
+    package_id,
+    is_latest = true,
+    version,
+    commit_sha,
+    package_name_with_version,
+  } = req.jsonBody
+
+  if (package_name_with_version && !version && !package_id) {
+    const [packageName, parsedVersion] = package_name_with_version.split("@")
+    const pkg = ctx.db.packages.find((p) => p.name === packageName)
+
+    if (!pkg) {
+      return ctx.error(404, {
+        error_code: "package_not_found",
+        message: `Package not found: ${packageName}`,
+      })
+    }
+
+    package_id = pkg.package_id
+    version = parsedVersion
+  }
+
+  if (!package_id || !version) {
+    return ctx.error(400, {
+      error_code: "missing_options",
+      message: "package_id and version are required",
+    })
+  }
+
+  // Check if version already exists
+  const existingRelease = ctx.db.packageReleases.find(
+    (pr) => pr.package_id === package_id && pr.version === version,
+  )
+
+  if (existingRelease) {
+    return ctx.error(400, {
+      error_code: "version_already_exists",
+      message: `Version ${version} already exists for this package`,
+    })
+  }
+
+  // Update previous latest if needed
+  if (is_latest) {
+    ctx.db.packageReleases
+      .filter((pr) => pr.package_id === package_id && pr.is_latest)
+      .forEach((pr) => (pr.is_latest = false))
+  }
+
+  const newPackageRelease = ctx.db.addPackageRelease({
+    package_id,
+    is_latest,
+    version,
+    is_locked: false,
+    created_at: new Date().toISOString(),
+    commit_sha: commit_sha ?? null,
+  })
+
+  return ctx.json({
+    ok: true,
+    package_release: publicMapPackageRelease(newPackageRelease),
+  })
+})

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

@@ -0,0 +1,34 @@
+import * as zt from "fake-snippets-api/lib/db/schema"
+import { publicMapPackageRelease } from "fake-snippets-api/lib/public-mapping/public-map-package-release"
+import { withRouteSpec } from "fake-snippets-api/lib/with-winter-spec"
+import { z } from "zod"
+
+export default withRouteSpec({
+  methods: ["POST"],
+  auth: "none",
+  jsonBody: z.object({
+    package_release_id: z.string().optional(),
+    package_name_with_version: z.string().optional(),
+  }),
+  jsonResponse: z.object({
+    ok: z.boolean(),
+    package_release: zt.packageReleaseSchema,
+  }),
+})(async (req, ctx) => {
+  const { package_release_id } = req.jsonBody
+
+  const foundRelease =
+    package_release_id && ctx.db.getPackageReleaseById(package_release_id)
+
+  if (!foundRelease) {
+    return ctx.error(404, {
+      error_code: "package_release_not_found",
+      message: "Package release not found",
+    })
+  }
+
+  return ctx.json({
+    ok: true,
+    package_release: publicMapPackageRelease(foundRelease),
+  })
+})