@tscircuit/fake-snippets 0.0.121 → 0.0.123

package/bun-tests/fake-snippets-api/routes/packages/create.test.ts

@@ -1,67 +0,0 @@
-import { getTestServer } from "bun-tests/fake-snippets-api/fixtures/get-test-server"
-import { test, expect } from "bun:test"
-
-test("create package", async () => {
-  const { axios } = await getTestServer()
-
-  const response = await axios.post("/api/packages/create", {
-    name: "testuser/TestPackage",
-    description: "Test Description",
-  })
-
-  expect(response.status).toBe(200)
-  expect(response.data.package.name).toBe("testuser/TestPackage")
-  expect(response.data.package.unscoped_name).toBe("TestPackage")
-  expect(response.data.package.description).toBe("Test Description")
-  expect(response.data.package.owner_github_username).toBe("testuser")
-  expect(response.data.package.description).toBe("Test Description")
-  expect(response.data.package.latest_package_release_id).toBeDefined()
-  expect(response.data.package.is_private).toBe(false)
-  expect(response.data.package.is_public).toBe(true)
-  expect(response.data.package.is_unlisted).toBe(false)
-})
-
-test("create package with private flag", async () => {
-  const { axios } = await getTestServer()
-
-  const response = await axios.post("/api/packages/create", {
-    name: "testuser/TestPackage",
-    description: "Test Description",
-    is_private: true,
-  })
-
-  expect(response.status).toBe(200)
-  expect(response.data.package.is_private).toBe(true)
-})
-
-test("create package under org", async () => {
-  const { jane_axios, seed } = await getTestServer()
-
-  const response = await jane_axios.post("/api/packages/create", {
-    is_private: true,
-    org_id: seed.organization.org_id,
-    description: "Test Description",
-  })
-
-  expect(response.status).toBe(200)
-  expect(response.data.package.owner_org_id).toBe(seed.organization.org_id)
-  expect(response.data.package.owner_github_username).toBe("jane")
-  expect(response.data.package.is_private).toBe(true)
-  expect(response.data.package.description).toBe("Test Description")
-})
-
-test("create package under non-existent org", async () => {
-  const { jane_axios, seed } = await getTestServer()
-
-  const response = await jane_axios.post(
-    "/api/packages/create",
-    {
-      org_id: "not-existent-org-id",
-    },
-    {
-      validateStatus: () => true,
-    },
-  )
-  expect(response.status).toBe(404)
-  expect(response.data.error.error_code).toBe("org_not_found")
-})

package/bun-tests/fake-snippets-api/routes/packages/delete.test.ts

@@ -1,74 +0,0 @@
-import { getTestServer } from "bun-tests/fake-snippets-api/fixtures/get-test-server"
-import { expect, test } from "bun:test"
-
-test("delete package", async () => {
-  const { axios, db } = await getTestServer()
-
-  // Add a test package
-  const createdPackage = await axios.post("/api/packages/create", {
-    name: "testuser/test-package",
-    description: "Test Description",
-  })
-
-  // Delete the package
-  const response = await axios.post("/api/packages/delete", {
-    package_id: createdPackage.data.package.package_id,
-  })
-
-  expect(response.status).toBe(200)
-  expect(response.data.ok).toBe(true)
-
-  // Verify the package was deleted from the database
-  const deletedPackage = db.getPackageById(
-    createdPackage.data.package.package_id,
-  )
-  expect(deletedPackage).toBeUndefined()
-
-  // List all the packages and verify the deleted package is not in the list
-  const listResponse = await axios.get("/api/packages/list")
-
-  expect(listResponse.status).toBe(200)
-  expect(listResponse.data.packages).toHaveLength(0)
-})
-
-test("delete non-existent package", async () => {
-  const { axios } = await getTestServer()
-
-  try {
-    await axios.post("/api/packages/delete", {
-      package_id: "non-existent-id",
-    })
-    // If the request doesn't throw an error, fail the test
-    expect(true).toBe(false)
-  } catch (error: any) {
-    expect(error.status).toBe(404)
-    expect(error.data.error.message).toBe("Package not found")
-  }
-})
-
-test("delete package without permission", async () => {
-  const { axios, db } = await getTestServer()
-
-  // Add a test package with a different owner org
-  const pkg = {
-    name: "test-package",
-    owner_org_id: "different-org", // Different from the personal_org_id in auth
-    created_at: "2023-01-01T00:00:00Z",
-    updated_at: "2023-01-01T00:00:00Z",
-    description: "Test Description",
-  }
-  const addedPackage: any = db.addPackage(pkg as any)
-
-  try {
-    await axios.post("/api/packages/delete", {
-      package_id: addedPackage.package_id,
-    })
-    // If the request doesn't throw an error, fail the test
-    expect(true).toBe(false)
-  } catch (error: any) {
-    expect(error.status).toBe(403)
-    expect(error.data.error.message).toBe(
-      "You don't have permission to delete this package",
-    )
-  }
-})

package/bun-tests/fake-snippets-api/routes/packages/fork.test.ts

@@ -1,132 +0,0 @@
-import { getTestServer } from "bun-tests/fake-snippets-api/fixtures/get-test-server"
-import { test, expect } from "bun:test"
-
-test("POST /packages/fork - successful fork using package_id", async () => {
-  const { axios, jane_axios } = await getTestServer()
-
-  // user creates a package with files
-  const sourcePackage = await axios
-    .post("/api/packages/create", {
-      name: "testuser/test-package-for-fork",
-      description: "A package to be forked",
-    })
-    .then((r: any) => r.data.package)
-
-  // user creates a release
-  const sourceRelease = await axios
-    .post("/api/package_releases/create", {
-      package_id: sourcePackage.package_id,
-      version: "1.0.0",
-    })
-    .then((r: any) => r.data.package_release)
-
-  // user creates a file
-  await axios.post("/api/package_files/create", {
-    package_release_id: sourceRelease.package_release_id,
-    file_path: "index.tsx",
-    content_text: "console.log('Hello from original package');",
-  })
-
-  // Jane forks the package
-  const forkedPackageResponse = await jane_axios.post("/api/packages/fork", {
-    package_id: sourcePackage.package_id,
-    is_private: false,
-  })
-
-  const forkedPackage = forkedPackageResponse.data.package
-
-  // Verify fork was created successfully
-  expect(forkedPackage.name).toBe(`jane/${sourcePackage.unscoped_name}`)
-  expect(forkedPackage.description).toBe(sourcePackage.description)
-  expect(forkedPackage.is_private).toBe(false)
-
-  // List files from the forked package
-  const packageFilesResponse = await jane_axios.get("/api/package_files/list", {
-    params: {
-      package_name: forkedPackage.name,
-      use_latest_version: true,
-    },
-  })
-
-  const package_files = packageFilesResponse.data.package_files
-
-  expect(package_files.length).toBe(1)
-  expect(package_files[0].file_path).toBe("index.tsx")
-})
-
-test("POST /packages/fork - successful fork using package_name", async () => {
-  const { axios, jane_axios } = await getTestServer()
-
-  // Jane creates a package with files
-  const sourcePackage = await jane_axios
-    .post("/api/packages/create", {
-      name: "jane/test-package-for-name-fork",
-      description: "A package to be forked by name",
-    })
-    .then((r: any) => r.data.package)
-
-  // Create a release
-  const sourceRelease = await jane_axios
-    .post("/api/package_releases/create", {
-      package_id: sourcePackage.package_id,
-      version: "1.0.0",
-    })
-    .then((r: any) => r.data.package_release)
-
-  // Create a file
-  await jane_axios.post("/api/package_files/create", {
-    package_release_id: sourceRelease.package_release_id,
-    file_path: "index.tsx",
-    content_text: "console.log('Hello from name package');",
-  })
-
-  // user forks Jane's package using package_name
-  const forkedPackage = await axios
-    .post("/api/packages/fork", {
-      package_name: "jane/test-package-for-name-fork",
-      is_private: true,
-    })
-    .then((r: any) => r.data.package)
-
-  // Verify fork was created successfully with privacy settings
-  expect(forkedPackage.name).toBe(`testuser/${sourcePackage.unscoped_name}`)
-  expect(forkedPackage.is_private).toBe(true)
-  expect(forkedPackage.is_unlisted).toBe(true) // Should be unlisted since it's private
-})
-
-test("POST /packages/fork - error when package not found", async () => {
-  const { axios } = await getTestServer()
-
-  try {
-    await axios.post("/api/packages/fork", {
-      package_id: "00000000-0000-0000-0000-000000000000", // Non-existent ID
-    })
-    // If it doesn't throw, fail the test
-    expect(true).toBe(false)
-  } catch (error: any) {
-    expect(error.status).toBe(404)
-    expect(error.data.error.error_code).toBe("package_not_found")
-  }
-})
-
-test("POST /packages/fork - error when trying to fork own package", async () => {
-  const { jane_axios } = await getTestServer()
-
-  const sourcePackage = await jane_axios
-    .post("/api/packages/create", {
-      name: "jane/test-package-for-fork",
-      description: "A package to be forked",
-    })
-    .then((r: any) => r.data.package)
-
-  try {
-    await jane_axios.post("/api/packages/fork", {
-      package_id: sourcePackage.package_id,
-    })
-    // If it doesn't throw, fail the test
-    expect(true).toBe(false)
-  } catch (error: any) {
-    expect(error.status).toBe(400)
-    expect(error.data.error.error_code).toBe("cannot_fork_own_package")
-  }
-})

package/bun-tests/fake-snippets-api/routes/packages/get.test.ts

@@ -1,112 +0,0 @@
-import { getTestServer } from "bun-tests/fake-snippets-api/fixtures/get-test-server"
-import { expect, test } from "bun:test"
-
-test("GET /api/packages/get - should return package by package_id", async () => {
-  const { axios } = await getTestServer()
-
-  // Create a new package using the /create endpoint
-  const newPackageData = {
-    name: "testuser/test-package",
-    description: "A test package",
-    creator_account_id: "test_account_id",
-    owner_org_id: "test_org_id",
-    owner_github_username: "test_github_username",
-    latest_package_release_id: null,
-    latest_version: null,
-    license: null,
-    is_source_from_github: false,
-    created_at: new Date().toISOString(),
-    updated_at: new Date().toISOString(),
-    unscoped_name: "test-package",
-    star_count: 0,
-    ai_description: "test-package",
-  }
-
-  const createResponse = await axios.post(
-    "/api/packages/create",
-    newPackageData,
-  )
-  expect(createResponse.status).toBe(200)
-  const createdPackage = createResponse.data.package
-
-  // Get the created package using the /get endpoint
-  const getResponse = await axios.get("/api/packages/get", {
-    params: { package_id: createdPackage.package_id },
-  })
-
-  expect(getResponse.status).toBe(200)
-  const responseBody = getResponse.data
-  expect(responseBody.ok).toBe(true)
-  expect(responseBody.package).toBeDefined()
-  expect(responseBody.package.latest_pcb_preview_image_url).toBeDefined()
-  expect(responseBody.package.latest_sch_preview_image_url).toBeDefined()
-  expect(responseBody.package.latest_cad_preview_image_url).toBeDefined()
-})
-
-test("GET /api/packages/get - should return 404 if package not found", async () => {
-  const { axios } = await getTestServer()
-
-  try {
-    await axios.get("/api/packages/get", {
-      params: { package_id: "non_existent_package_id" },
-    })
-    throw new Error("Expected request to fail")
-  } catch (error: any) {
-    expect(error.status).toBe(404)
-    expect(error.data.error.error_code).toBe("package_not_found")
-    expect(error.data.error.message).toBe(
-      'Package not found (searched using {"package_id":"non_existent_package_id"})',
-    )
-  }
-})
-
-test("GET /api/packages/get - should return package by name", async () => {
-  const { axios } = await getTestServer()
-
-  await axios.post("/api/packages/create", {
-    name: "testuser/test-package",
-    description: "A test package",
-    creator_account_id: "test_account_id",
-    owner_org_id: "test_org_id",
-    owner_github_username: "test_github_username",
-  })
-
-  const getResponse = await axios.get("/api/packages/get", {
-    params: { name: "testuser/test-package" },
-  })
-
-  expect(getResponse.status).toBe(200)
-  const responseBody = getResponse.data
-  expect(responseBody.ok).toBe(true)
-  expect(responseBody.package).toBeDefined()
-})
-
-test("GET /api/packages/get - returns user_permissions when authenticated", async () => {
-  const { axios, jane_axios, unauthenticatedAxios } = await getTestServer()
-
-  const createResponse = await axios.post("/api/packages/create", {
-    name: "testuser/auth-package",
-    description: "desc",
-  })
-
-  const pkg = createResponse.data.package
-
-  const ownerResponse = await axios.get("/api/packages/get", {
-    params: { package_id: pkg.package_id },
-  })
-  expect(ownerResponse.data.package.user_permissions).toEqual({
-    can_manage_packages: true,
-  })
-
-  const otherResponse = await jane_axios.get("/api/packages/get", {
-    params: { package_id: pkg.package_id },
-  })
-  expect(otherResponse.data.package.user_permissions).toEqual({
-    can_manage_packages: false,
-  })
-
-  const unauthResponse = await unauthenticatedAxios.get("/api/packages/get", {
-    params: { package_id: pkg.package_id },
-  })
-  expect(unauthResponse.data.package.user_permissions).toBeUndefined()
-})

package/bun-tests/fake-snippets-api/routes/packages/images.test.ts

@@ -1,72 +0,0 @@
-import { getTestServer } from "bun-tests/fake-snippets-api/fixtures/get-test-server"
-import { expect, test } from "bun:test"
-import md5 from "md5"
-test("get schematic svg of a package", async () => {
-  const { axios, db } = await getTestServer()
-
-  // create a package
-  const pkg = await axios.post("/api/packages/create", {
-    name: "testuser/TestPackage",
-    description: "Test Description",
-  })
-
-  // create a package release
-  const pkg_release = await axios.post("/api/package_releases/create", {
-    package_id: pkg.data.package.package_id,
-    version: "1.0.0",
-    is_latest: true,
-  })
-
-  const circuit_json = [
-    {
-      type: "pcb_board",
-      pcb_board_id: "pcb_board_0",
-      center: {
-        x: 0,
-        y: 0,
-      },
-      thickness: 1.4,
-      num_layers: 4,
-      width: 30,
-      height: 30,
-    },
-  ]
-  // create a package file
-  const pkg_file = await axios.post("/api/package_files/create", {
-    package_release_id: pkg_release.data.package_release.package_release_id,
-    file_path: "circuit.json",
-    content_text: JSON.stringify(circuit_json),
-  })
-
-  // create fsMap by getting all the files in the package with the file_path and content_text
-  const fsMap = new Map<string, string>()
-  // list all the files in the package
-  const files = await axios.get("/api/package_files/list", {
-    params: {
-      package_release_id: pkg_release.data.package_release.package_release_id,
-    },
-  })
-  for (const file of files.data.package_files) {
-    fsMap.set(file.file_path, file.content_text)
-  }
-
-  const fsMapHash = md5(JSON.stringify(fsMap))
-
-  // update the package release with the fsMapHash
-  await axios.post("/api/package_releases/update", {
-    package_release_id: pkg_release.data.package_release.package_release_id,
-    fs_sha: `md5-${fsMapHash}`,
-  })
-
-  const response = await axios.get(
-    `/api/packages/images/${pkg.data.package.owner_github_username}/${pkg.data.package.unscoped_name}/schematic.svg`,
-    {
-      params: {
-        fs_sha: `md5-${fsMapHash}`,
-      },
-    },
-  )
-
-  expect(response.status).toBe(200)
-  expect(response.data).toContain("<svg")
-})

package/bun-tests/fake-snippets-api/routes/packages/list-1.test.ts

@@ -1,145 +0,0 @@
-import { getTestServer } from "bun-tests/fake-snippets-api/fixtures/get-test-server"
-import { expect, test } from "bun:test"
-
-test("list packages", async () => {
-  const { axios, db } = await getTestServer()
-
-  // Add some test packages
-  const packages = [
-    {
-      name: "Package1",
-      unscoped_name: "Package1",
-      owner_github_username: "user1",
-      creator_account_id: "creator1",
-      created_at: "2023-01-01T00:00:00Z",
-      updated_at: "2023-01-01T00:00:00Z",
-      description: "Description 1",
-      ai_description: "AI Description 1",
-      ai_usage_instructions: "Usage instructions 1",
-      owner_org_id: "org1",
-      latest_version: "1.0.0",
-      license: "MIT",
-      is_source_from_github: true,
-      star_count: 0,
-    },
-    {
-      name: "Package2",
-      unscoped_name: "Package2",
-      owner_github_username: "user2",
-      creator_account_id: "creator2",
-      created_at: "2023-01-02T00:00:00Z",
-      updated_at: "2023-01-02T00:00:00Z",
-      description: "Description 2",
-      ai_description: "AI Description 2",
-      ai_usage_instructions: "Usage instructions 2",
-      owner_org_id: "org2",
-      latest_version: "1.0.0",
-      license: "MIT",
-      is_source_from_github: true,
-      star_count: 0,
-    },
-    {
-      name: "Package3",
-      unscoped_name: "Package3",
-      owner_github_username: "user1",
-      creator_account_id: "creator1",
-      created_at: "2023-01-03T00:00:00Z",
-      updated_at: "2023-01-03T00:00:00Z",
-      description: "Description 3",
-      ai_description: "AI Description 3",
-      ai_usage_instructions: "Usage instructions 3",
-      owner_org_id: "org1",
-      latest_version: "1.0.0",
-      license: "MIT",
-      is_source_from_github: true,
-      star_count: 0,
-    },
-  ]
-
-  for (const pkg of packages) {
-    db.addPackage(pkg as any)
-  }
-
-  // Test with no parameters (should return all packages)
-  const { data: allData } = await axios.get("/api/packages/list")
-  expect(allData.ok).toBe(true)
-  expect(allData.packages).toHaveLength(3)
-
-  // Test with owner_github_username parameter
-  const { data: user1Data } = await axios.get("/api/packages/list", {
-    params: { owner_github_username: "user1" },
-  })
-  expect(user1Data.packages).toHaveLength(2)
-  expect(
-    user1Data.packages.every(
-      (pkg: { owner_github_username: string }) =>
-        pkg.owner_github_username === "user1",
-    ),
-  ).toBe(true)
-
-  // Test with creator_account_id parameter
-  const { data: creator1Data } = await axios.get("/api/packages/list", {
-    params: { creator_account_id: "creator1" },
-  })
-  expect(creator1Data.packages).toHaveLength(2)
-  expect(
-    creator1Data.packages.every(
-      (pkg: { creator_account_id: string }) =>
-        pkg.creator_account_id === "creator1",
-    ),
-  ).toBe(true)
-
-  // Test with name parameter (must include another filter parameter)
-  const { data: nameData } = await axios.get("/api/packages/list", {
-    params: {
-      name: "Package1",
-      owner_github_username: "user1",
-    },
-  })
-  expect(nameData.packages).toHaveLength(1)
-  expect(nameData.packages[0].name).toBe("Package1")
-
-  // Test with non-existent owner
-  const { data: nonExistentData } = await axios.get("/api/packages/list", {
-    params: { owner_github_username: "nonexistentuser" },
-  })
-  expect(nonExistentData.packages).toHaveLength(0)
-
-  // Test with authenticated request
-  const { data: authData } = await axios.get("/api/packages/list")
-  expect(authData.packages).toHaveLength(3) // Should return all packages when authenticated
-})
-
-test("list packages includes user_permissions when session provided", async () => {
-  const { axios, jane_axios, unauthenticatedAxios } = await getTestServer()
-
-  const pkg1 = (
-    await axios.post("/api/packages/create", {
-      name: "testuser/ownerpkg",
-      description: "", // minimal
-    })
-  ).data.package
-
-  const pkg2 = (
-    await jane_axios.post("/api/packages/create", {
-      name: "jane/otherpkg",
-      description: "",
-    })
-  ).data.package
-
-  const { data: listData } = await axios.get("/api/packages/list")
-  const ownerPkg = listData.packages.find(
-    (p: any) => p.package_id === pkg1.package_id,
-  )
-  const otherPkg = listData.packages.find(
-    (p: any) => p.package_id === pkg2.package_id,
-  )
-  expect(ownerPkg.user_permissions).toEqual({ can_manage_packages: true })
-  expect(otherPkg.user_permissions).toEqual({ can_manage_packages: false })
-
-  const { data: unauthData } = await unauthenticatedAxios.get(
-    "/api/packages/list",
-    { params: { owner_github_username: "testuser" } },
-  )
-  expect(unauthData.packages[0].user_permissions).toBeUndefined()
-})

package/bun-tests/fake-snippets-api/routes/packages/list-2.test.ts

@@ -1,48 +0,0 @@
-import { getTestServer } from "bun-tests/fake-snippets-api/fixtures/get-test-server"
-import { expect, test } from "bun:test"
-test("list packages with is_writable filter", async () => {
-  const { axios, db } = await getTestServer()
-
-  // Add test packages
-  const packages = [
-    {
-      package_id: "pkg1",
-      name: "testuser/testPackage1",
-      unscoped_name: "testPackage1",
-      created_at: "2023-01-01T00:00:00Z",
-      updated_at: "2023-01-01T00:00:00Z",
-      description: "Description 1",
-      ai_description: "AI Description 1",
-      ai_usage_instructions: "Usage instructions 1",
-      latest_version: "1.0.0",
-      license: "MIT",
-      is_source_from_github: true,
-      star_count: 0,
-    },
-    {
-      package_id: "pkg2",
-      name: "testuser/testPackage2",
-      unscoped_name: "testPackage2",
-      created_at: "2023-01-02T00:00:00Z",
-      updated_at: "2023-01-02T00:00:00Z",
-      description: "Description 2",
-      ai_description: "AI Description 2",
-      ai_usage_instructions: "Usage instructions 2",
-      latest_version: "1.0.0",
-      license: "MIT",
-      is_source_from_github: true,
-      star_count: 0,
-    },
-  ]
-
-  // Add only these test packages
-  for (const pkg of packages) {
-    await axios.post("/api/packages/create", pkg)
-  }
-
-  // Test with is_writable filter (requires auth)
-  const { data: writableData } = await axios.get("/api/packages/list", {
-    params: { is_writable: true },
-  })
-  expect(writableData.packages).toHaveLength(2)
-})