@tscircuit/fake-snippets 0.0.120 → 0.0.122

package/fake-snippets-api/lib/index.ts

@@ -1,3 +0,0 @@
-export * from "./db/db-client"
-export * from "./db/seed"
-export * from "./middleware/with-db"

package/fake-snippets-api/lib/middleware/with-ctx-error.ts

@@ -1,26 +0,0 @@
-import { Middleware } from "winterspec/middleware"
-
-export type CtxErrorFn = (
-  status: number,
-  error_payload: {
-    error_code: string
-    message: string
-  },
-) => Response
-
-export const withCtxError: Middleware<
-  {},
-  {
-    error: CtxErrorFn
-  }
-> = async (req, ctx, next) => {
-  ctx.error = (status, error_payload) => {
-    return new Response(JSON.stringify({ error: error_payload }), {
-      status,
-      headers: {
-        "Content-Type": "application/json",
-      },
-    })
-  }
-  return next(req, ctx)
-}

package/fake-snippets-api/lib/middleware/with-db.ts

@@ -1,15 +0,0 @@
-import type { DbClient } from "fake-snippets-api/lib/db/db-client"
-import { createDatabase } from "fake-snippets-api/lib/db/db-client"
-import type { Middleware } from "winterspec"
-
-export const withDb: Middleware<
-  {},
-  {
-    db: DbClient
-  }
-> = async (req, ctx, next) => {
-  if (!ctx.db) {
-    ctx.db = createDatabase()
-  }
-  return next(req, ctx)
-}

package/fake-snippets-api/lib/middleware/with-error-handling.ts

@@ -1,24 +0,0 @@
-import { Middleware } from "winterspec/middleware"
-import kleur from "kleur"
-
-export const withErrorHandling: Middleware<{}, {}> = async (req, ctx, next) => {
-  try {
-    return await next(req, ctx)
-  } catch (error: any) {
-    console.error(kleur.red("Intercepted error:"), error)
-    // If error is a Response, return it
-    if (error instanceof Response) {
-      return error
-    }
-    return (ctx as any).json(
-      {
-        ok: false,
-        error: {
-          message: error?.message,
-          error_code: error?.error_code ?? "internal_server_error",
-        },
-      },
-      { status: error?.status || 500 },
-    )
-  }
-}

package/fake-snippets-api/lib/middleware/with-optional-session-auth.ts

@@ -1,53 +0,0 @@
-import type { Middleware } from "winterspec/middleware"
-import type { CtxErrorFn } from "./with-ctx-error"
-
-export const withOptionalSessionAuth: Middleware<
-  {
-    error: CtxErrorFn
-    db: any
-  },
-  {
-    auth?: {
-      type: "session"
-      account_id: string
-      personal_org_id: string
-      github_username: string
-      session_id: string
-    }
-  },
-  {}
-> = async (req, ctx, next) => {
-  if (req.method === "OPTIONS") return next(req, ctx)
-
-  const token = req.headers.get("authorization")?.split("Bearer ")?.[1]
-
-  if (!token) {
-    return next(req, ctx)
-  }
-
-  if (process.env.BUN_TEST === "true" && ctx.db?.accounts) {
-    const account = ctx.db.accounts.find((acc: any) => acc.account_id === token)
-
-    if (account) {
-      ctx.auth = {
-        type: "session",
-        account_id: account.account_id,
-        personal_org_id: `org-${account.account_id}`,
-        github_username: account.github_username,
-        session_id: `session-${account.account_id}`,
-      }
-    }
-
-    return next(req, ctx)
-  }
-
-  ctx.auth = {
-    type: "session",
-    account_id: "account-1234",
-    personal_org_id: "org-1234",
-    github_username: "testuser",
-    session_id: "session-1234",
-  }
-
-  return next(req, ctx)
-}

package/fake-snippets-api/lib/middleware/with-request-logging.ts

@@ -1,54 +0,0 @@
-import { Middleware } from "winterspec/middleware"
-import kleur from "kleur"
-
-// ENABLE COLORS ALWAYS
-kleur.enabled = true
-
-const colorStatus = (status: number) => {
-  if (status >= 500) {
-    return kleur.red(status.toString())
-  }
-  if (status >= 400) {
-    return kleur.yellow(status.toString())
-  }
-  return kleur.green(status.toString())
-}
-
-export interface Logger {
-  error: (...args: any[]) => void
-  info: (...args: any[]) => void
-  warn: (...args: any[]) => void
-  debug: (...args: any[]) => void
-}
-
-export const withRequestLogging: Middleware<
-  {},
-  {
-    logger: Logger
-  }
-> = async (req, ctx, next) => {
-  if (!ctx.logger) {
-    ctx.logger = {
-      error: (...args: any[]) => console.error(...args),
-      info: (...args: any[]) => console.log(...args),
-      warn: (...args: any[]) => console.warn(...args),
-      debug: (...args: any[]) => console.log(...args),
-    }
-  }
-  try {
-    ctx.logger.info(kleur.blue(`> ${req.method} ${req.url}`))
-    const response = await next(req, ctx)
-    try {
-      const responseBody = await response.clone().text()
-      ctx.logger.info(
-        `< ${colorStatus(response.status)} ${kleur.gray(responseBody.slice(0, 40).replace(/(\r\n|\n|\r)/gm, ""))}`,
-      )
-    } catch (e) {
-      ctx.logger.info(`< ${colorStatus(response.status)}`)
-    }
-    return response
-  } catch (e: any) {
-    ctx.logger.info(kleur.red(`< ERROR ${e.toString().slice(0, 50)}...`))
-    throw e
-  }
-}

package/fake-snippets-api/lib/middleware/with-session-auth.ts

@@ -1,102 +0,0 @@
-import type { Middleware } from "winterspec/middleware"
-import type { CtxErrorFn } from "./with-ctx-error"
-import type { DbClient } from "../db/db-client"
-
-export const withSessionAuth: Middleware<
-  {
-    error: CtxErrorFn
-    db: DbClient
-  },
-  {
-    auth: {
-      type: "session"
-      account_id: string
-      personal_org_id: string
-      github_username: string
-      session_id: string
-      orgs: Array<{
-        org_id: string
-        name: string
-        user_permissions: {
-          can_manage_packages: boolean
-        }
-      }>
-    }
-  },
-  {}
-> = async (req, ctx, next) => {
-  if (req.method === "OPTIONS") return next(req, ctx)
-
-  const token = req.headers.get("authorization")?.split("Bearer ")?.[1]
-
-  // Only check database accounts when we're in a Bun test environment
-  if (process.env.BUN_TEST === "true" && ctx.db?.getState) {
-    const state = ctx.db.getState()
-    const account = state.accounts.find((acc: any) => acc.account_id === token)
-    if (account) {
-      // Fetch orgs for this account
-      const orgAccounts = state.orgAccounts.filter(
-        (oa: any) => oa.account_id === account.account_id,
-      )
-
-      const orgs = orgAccounts.map((oa: any) => {
-        const org = state.organizations.find((o: any) => o.org_id === oa.org_id)
-        return {
-          org_id: oa.org_id,
-          name:
-            org?.org_display_name ||
-            org?.org_name ||
-            org?.github_handle ||
-            oa.org_id,
-          user_permissions: { can_manage_packages: true },
-        }
-      })
-
-      ctx.auth = {
-        type: "session",
-        account_id: account.account_id,
-        personal_org_id: account.personal_org_id || `org-${account.account_id}`,
-        github_username: account.github_username,
-        session_id: `session-${account.account_id}`,
-        orgs:
-          orgs.length > 0
-            ? orgs
-            : [
-                {
-                  org_id:
-                    account.personal_org_id || `org-${account.account_id}`,
-                  name:
-                    account.github_username ||
-                    account.personal_org_id ||
-                    `org-${account.account_id}`,
-                  user_permissions: { can_manage_packages: true },
-                },
-              ],
-      }
-      return next(req, ctx)
-    }
-  }
-
-  // Fallback auth for non-test environments or when no token is found
-  const fallbackAccountId = "account-1234"
-  const fallbackOrgId = "org-1234"
-
-  const fallbackOrgs = [
-    {
-      org_id: fallbackOrgId,
-      name: "org-1234",
-      user_permissions: { can_manage_packages: true },
-    },
-  ]
-
-  ctx.auth = {
-    type: "session",
-    account_id: fallbackAccountId,
-    personal_org_id: fallbackOrgId,
-    github_username: "testuser",
-    session_id: "session-1234",
-    orgs: fallbackOrgs,
-  }
-
-  return next(req, ctx)
-}

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

@@ -1,24 +0,0 @@
-import { createWithWinterSpec } from "winterspec"
-import { withDb } from "./with-db"
-import { createWithDefaultExceptionHandling } from "winterspec/middleware"
-import { withCtxError } from "./with-ctx-error"
-import { withSessionAuth } from "./with-session-auth"
-import { withOptionalSessionAuth } from "./with-optional-session-auth"
-import { withErrorHandling } from "./with-error-handling"
-import { withRequestLogging } from "./with-request-logging"
-
-export const withRouteSpec = createWithWinterSpec({
-  apiName: "tscircuit Snippets API",
-  productionServerUrl: "https://snippets.tscircuit.com/api",
-  beforeAuthMiddleware: [withRequestLogging, withErrorHandling, withCtxError],
-  authMiddleware: {
-    session: withSessionAuth,
-    optional_session: withOptionalSessionAuth,
-  },
-  afterAuthMiddleware: [
-    withDb,
-    createWithDefaultExceptionHandling({
-      includeStackTraceInResponse: true,
-    }),
-  ],
-})

package/fake-snippets-api/lib/package_file/generate-fs-sha.ts

@@ -1,20 +0,0 @@
-import md5 from "md5"
-import type { PackageFile } from "../db/schema"
-
-/**
- * Generate an MD5 hash from package files content
- * Uses the same format as existing tests: creates a map of file_path -> content_text
- * and generates an MD5 hash of the JSON stringified map
- */
-export function generateFsSha(packageFiles: PackageFile[]): string {
-  const fsMap: Record<string, string> = {}
-
-  packageFiles
-    .filter((file) => file.content_text) // Only include files with content
-    .forEach((file) => {
-      fsMap[file.file_path] = file.content_text || ""
-    })
-
-  const hash = md5(JSON.stringify(fsMap))
-  return `md5-${hash}`
-}

package/fake-snippets-api/lib/package_file/get-package-file-id-from-file-descriptor.ts

@@ -1,173 +0,0 @@
-import { NotFoundError } from "winterspec/middleware"
-import * as ZT from "../db/schema"
-import { normalizeProjectFilePath } from "fake-snippets-api/utils/normalizeProjectFilePath"
-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 &&
-        normalizeProjectFilePath(pf.file_path) ===
-          normalizeProjectFilePath(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 &&
-        normalizeProjectFilePath(pf.file_path) ===
-          normalizeProjectFilePath(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 &&
-        normalizeProjectFilePath(pf.file_path) ===
-          normalizeProjectFilePath(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("@")[0]
-    const version = package_name_with_version.split("@")[1]
-
-    // 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 &&
-        normalizeProjectFilePath(pf.file_path) ===
-          normalizeProjectFilePath(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

@@ -1,120 +0,0 @@
-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
-  }
-
-  return packageRelease.package_release_id
-}

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

@@ -1,34 +0,0 @@
-import { z } from "zod"
-import * as ZT from "fake-snippets-api/lib/db/schema"
-
-export const publicMapOrg = (
-  internal_org: ZT.Organization & {
-    member_count: number
-    package_count: number
-    can_manage_org: boolean
-  },
-): z.infer<typeof ZT.publicOrgSchema> => {
-  const {
-    can_manage_org,
-    github_handle,
-    member_count,
-    package_count,
-    created_at,
-    is_personal_org,
-    org_display_name,
-    org_name,
-    ...org
-  } = internal_org
-  return {
-    org_id: org.org_id,
-    display_name: org_display_name ?? org_name,
-    owner_account_id: org.owner_account_id,
-    name: org_name,
-    member_count: Number(member_count) || 0,
-    package_count: Number(package_count) || 0,
-    is_personal_org: Boolean(is_personal_org),
-    created_at: String(created_at),
-    ...(github_handle ? { github_handle } : {}),
-    ...(can_manage_org ? { user_permissions: { can_manage_org: true } } : {}),
-  }
-}