@tscircuit/fake-snippets 0.0.3 → 0.0.5

package/.github/workflows/bundle-size-analysis.yml

@@ -20,7 +20,7 @@ jobs:
       - uses: actions/checkout@v4
       
       - name: Setup Bun
-        uses: oven-sh/setup-bun@v1
+        uses: oven-sh/setup-bun@v2
         with:
           bun-version: latest
 
@@ -33,7 +33,7 @@ jobs:
 
       - name: Save stats as artifact                                                                                      
         if: success()                                                                                                     
-        uses: actions/upload-artifact@v3                                                                                  
+        uses: actions/upload-artifact@v4                                                                                 
         with:                                                                                                             
           name: bundle-stats                                                                                              
           path: dist/stats.html                                                                                           

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

@@ -0,0 +1,131 @@
+import { getTestServer } from "bun-tests/fake-snippets-api/fixtures/get-test-server"
+import { expect, test } from "bun:test"
+
+test("create package release", async () => {
+  const { axios } = await getTestServer()
+
+  // First create a package
+  const packageResponse = await axios.post(
+    "/api/packages/create",
+    {
+      name: "test-package",
+      description: "Test Description",
+    },
+    {
+      headers: {
+        Authorization: "Bearer 1234",
+      },
+    },
+  )
+  expect(packageResponse.status).toBe(200)
+  const createdPackage = packageResponse.data.package
+
+  // Create a package release
+  const releaseResponse = await axios.post("/api/package_releases/create", {
+    package_id: createdPackage.package_id,
+    version: "1.0.0",
+    is_latest: true,
+  })
+
+  expect(releaseResponse.status).toBe(200)
+  expect(releaseResponse.data.ok).toBe(true)
+  expect(releaseResponse.data.package_release).toBeDefined()
+  expect(releaseResponse.data.package_release.package_id).toBe(
+    createdPackage.package_id,
+  )
+  expect(releaseResponse.data.package_release.version).toBe("1.0.0")
+  expect(releaseResponse.data.package_release.is_latest).toBe(true)
+  expect(releaseResponse.data.package_release.is_locked).toBe(false)
+})
+
+test("create package release using package_name_with_version", async () => {
+  const { axios } = await getTestServer()
+
+  // First create a package
+  const packageResponse = await axios.post(
+    "/api/packages/create",
+    {
+      name: "test-package-2",
+      description: "Test Description",
+    },
+    {
+      headers: {
+        Authorization: "Bearer 1234",
+      },
+    },
+  )
+  expect(packageResponse.status).toBe(200)
+  const createdPackage = packageResponse.data.package
+
+  // Create a package release using package_name_with_version
+  const releaseResponse = await axios.post("/api/package_releases/create", {
+    package_name_with_version: `${createdPackage.name}@2.0.0`,
+  })
+
+  expect(releaseResponse.status).toBe(200)
+  expect(releaseResponse.data.ok).toBe(true)
+  expect(releaseResponse.data.package_release).toBeDefined()
+  expect(releaseResponse.data.package_release.package_id).toBe(
+    createdPackage.package_id,
+  )
+  expect(releaseResponse.data.package_release.version).toBe("2.0.0")
+  expect(releaseResponse.data.package_release.is_latest).toBe(true)
+})
+
+test("create package release - version already exists", async () => {
+  const { axios } = await getTestServer()
+
+  // First create a package
+  const packageResponse = await axios.post(
+    "/api/packages/create",
+    {
+      name: "test-package-3",
+      description: "Test Description",
+    },
+    {
+      headers: {
+        Authorization: "Bearer 1234",
+      },
+    },
+  )
+  expect(packageResponse.status).toBe(200)
+  const createdPackage = packageResponse.data.package
+
+  // Create first release
+  await axios.post("/api/package_releases/create", {
+    package_id: createdPackage.package_id,
+    version: "1.0.0",
+  })
+
+  // Try to create release with same version
+  try {
+    await axios.post("/api/package_releases/create", {
+      package_id: createdPackage.package_id,
+      version: "1.0.0",
+    })
+    throw new Error("Expected request to fail")
+  } catch (error: any) {
+    expect(error.status).toBe(400)
+    expect(error.data.error.error_code).toBe("version_already_exists")
+    expect(error.data.error.message).toBe(
+      "Version 1.0.0 already exists for this package",
+    )
+  }
+})
+
+test("create package release - package not found", async () => {
+  const { axios } = await getTestServer()
+
+  try {
+    await axios.post("/api/package_releases/create", {
+      package_name_with_version: "non-existent-package@1.0.0",
+    })
+    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: non-existent-package",
+    )
+  }
+})

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

@@ -0,0 +1,89 @@
+import { getTestServer } from "bun-tests/fake-snippets-api/fixtures/get-test-server"
+import { expect, test } from "bun:test"
+import { packageReleaseSchema } from "fake-snippets-api/lib/db/schema"
+
+test("POST /api/package_releases/get - should return package release by package_release_id", async () => {
+  const { axios } = await getTestServer()
+
+  // First create a package with valid name format
+  const packageResponse = await axios.post("/api/packages/create", {
+    name: "@test/package-1",
+    description: "A test package",
+  })
+  expect(packageResponse.status).toBe(200)
+  const createdPackage = packageResponse.data.package
+
+  // Create a package release
+  const releaseResponse = await axios.post("/api/package_releases/create", {
+    package_id: createdPackage.package_id,
+    version: "1.0.0",
+    is_latest: true,
+  })
+  expect(releaseResponse.status).toBe(200)
+  const createdRelease = releaseResponse.data.package_release
+
+  // Get the created package release
+  const getResponse = await axios.post("/api/package_releases/get", {
+    package_release_id: createdRelease.package_release_id,
+  })
+
+  expect(getResponse.status).toBe(200)
+  const responseBody = getResponse.data
+  expect(responseBody.ok).toBe(true)
+  expect(responseBody.package_release).toEqual(
+    packageReleaseSchema.parse(createdRelease),
+  )
+})
+
+test("POST /api/package_releases/get - should return 404 if package release not found", async () => {
+  const { axios } = await getTestServer()
+
+  try {
+    await axios.post("/api/package_releases/get", {
+      package_release_id: "123e4567-e89b-12d3-a456-426614174000", // valid UUID format
+    })
+    throw new Error("Expected request to fail")
+  } catch (error: any) {
+    expect(error.status).toBe(404)
+    expect(error.data.error.error_code).toBe("package_release_not_found")
+    expect(error.data.error.message).toBe("Package release not found")
+  }
+})
+
+test("POST /api/package_releases/get - should find release by package_name_with_version", async () => {
+  const { axios } = await getTestServer()
+
+  // First create a package with valid name format
+  const packageResponse = await axios.post("/api/packages/create", {
+    name: "@test/package-2",
+    description: "Another test package",
+  })
+  expect(packageResponse.status).toBe(200)
+  const createdPackage = packageResponse.data.package
+
+  // Create a package release
+  const version = "2.0.0"
+  const releaseResponse = await axios.post("/api/package_releases/create", {
+    package_name_with_version: `${createdPackage.name}@${version}`,
+    is_latest: true,
+  })
+  expect(releaseResponse.status).toBe(200)
+  const createdRelease = releaseResponse.data.package_release
+
+  const listResponse = await axios.post("/api/package_releases/list", {
+    package_name: createdPackage.name,
+  })
+  console.log(listResponse.data)
+
+  // Get the release using package_name_with_version
+  const getResponse = await axios.post("/api/package_releases/get", {
+    package_release_id: createdRelease.package_release_id,
+  })
+
+  expect(getResponse.status).toBe(200)
+  const responseBody = getResponse.data
+  expect(responseBody.ok).toBe(true)
+  expect(responseBody.package_release).toEqual(
+    packageReleaseSchema.parse(createdRelease),
+  )
+})

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

@@ -0,0 +1,157 @@
+import { getTestServer } from "bun-tests/fake-snippets-api/fixtures/get-test-server"
+import { expect, test } from "bun:test"
+
+test("list package releases", async () => {
+  const { axios, db } = await getTestServer()
+
+  // First create a test package
+  const packageResponse = await axios.post(
+    "/api/packages/create",
+    {
+      name: "test-package",
+      description: "Test Description",
+    },
+    {
+      headers: {
+        Authorization: "Bearer 1234",
+      },
+    },
+  )
+  const packageId = packageResponse.data.package.package_id
+
+  // Add some test package releases
+  const releases = [
+    {
+      package_id: packageId,
+      version: "1.0.0",
+      is_latest: false,
+      commit_sha: "abc123",
+      is_locked: false,
+      created_at: "2023-01-01T00:00:00Z",
+    },
+    {
+      package_id: packageId,
+      version: "1.1.0",
+      is_latest: false,
+      commit_sha: "def456",
+      is_locked: false,
+      created_at: "2023-01-02T00:00:00Z",
+    },
+    {
+      package_id: packageId,
+      version: "2.0.0",
+      is_latest: true,
+      commit_sha: "ghi789",
+      is_locked: false,
+      created_at: "2023-01-03T00:00:00Z",
+    },
+  ]
+
+  for (const release of releases) {
+    db.addPackageRelease(release as any)
+  }
+
+  // Test listing by package_id
+  const { data: packageIdData } = await axios.post(
+    "/api/package_releases/list",
+    {
+      package_id: packageId,
+    },
+  )
+  expect(packageIdData.ok).toBe(true)
+  expect(packageIdData.package_releases).toHaveLength(3)
+  expect(packageIdData.package_releases[0].package_id).toBe(packageId)
+
+  // Test listing by package_name
+  const { data: packageNameData } = await axios.post(
+    "/api/package_releases/list",
+    {
+      package_name: "test-package",
+    },
+  )
+  expect(packageNameData.ok).toBe(true)
+  expect(packageNameData.package_releases).toHaveLength(3)
+
+  // Test listing latest releases only
+  const { data: latestData } = await axios.post("/api/package_releases/list", {
+    package_id: packageId,
+    is_latest: true,
+  })
+  expect(latestData.ok).toBe(true)
+  expect(latestData.package_releases).toHaveLength(1)
+  expect(latestData.package_releases[0].version).toBe("2.0.0")
+  expect(latestData.package_releases[0].is_latest).toBe(true)
+
+  // Test listing by specific version
+  const { data: versionData } = await axios.post("/api/package_releases/list", {
+    package_id: packageId,
+    version: "1.0.0",
+  })
+  expect(versionData.ok).toBe(true)
+  expect(versionData.package_releases).toHaveLength(1)
+  expect(versionData.package_releases[0].version).toBe("1.0.0")
+
+  // Test listing by commit_sha
+  const { data: commitData } = await axios.post("/api/package_releases/list", {
+    package_id: packageId,
+    commit_sha: "abc123",
+  })
+  expect(commitData.ok).toBe(true)
+  expect(commitData.package_releases).toHaveLength(1)
+  expect(commitData.package_releases[0].commit_sha).toBe("abc123")
+})
+
+test("list package releases - validation errors", async () => {
+  const { axios } = await getTestServer()
+
+  // Test error when both package_id and package_name provided
+  try {
+    await axios.post("/api/package_releases/list", {
+      package_id: "some-id",
+      package_name: "some-name",
+    })
+    throw new Error("Expected request to fail")
+  } catch (error: any) {
+    expect(error.status).toBe(400)
+    expect(error.data.message).toContain(
+      "package_id and package_name are mutually exclusive",
+    )
+  }
+
+  // Test error when neither package_id nor package_name provided
+  try {
+    await axios.post("/api/package_releases/list", {
+      is_latest: true,
+    })
+    throw new Error("Expected request to fail")
+  } catch (error: any) {
+    expect(error.status).toBe(400)
+    expect(error.data.message).toContain(
+      "package_id or package_name is required",
+    )
+  }
+})
+
+test("list package releases - non-existent package", async () => {
+  const { axios } = await getTestServer()
+
+  // Test with non-existent package_name
+  const { data: nonExistentData } = await axios.post(
+    "/api/package_releases/list",
+    {
+      package_name: "non-existent-package",
+    },
+  )
+  expect(nonExistentData.ok).toBe(true)
+  expect(nonExistentData.package_releases).toHaveLength(0)
+
+  // Test with non-existent package_id
+  const { data: nonExistentIdData } = await axios.post(
+    "/api/package_releases/list",
+    {
+      package_id: "123e4567-e89b-12d3-a456-426614174000",
+    },
+  )
+  expect(nonExistentIdData.ok).toBe(true)
+  expect(nonExistentIdData.package_releases).toHaveLength(0)
+})

package/bun-tests/fake-snippets-api/routes/package_releases/update.test.ts

@@ -0,0 +1,189 @@
+import { getTestServer } from "bun-tests/fake-snippets-api/fixtures/get-test-server"
+import { expect, test } from "bun:test"
+
+test("update package release", async () => {
+  const { axios, db } = await getTestServer()
+
+  // First create a package
+  const packageResponse = await axios.post(
+    "/api/packages/create",
+    {
+      name: "test-package",
+      description: "Test Description",
+    },
+    {
+      headers: {
+        Authorization: "Bearer 1234",
+      },
+    },
+  )
+  const packageId = packageResponse.data.package.package_id
+
+  // Create a package release
+  const releaseResponse = await axios.post("/api/package_releases/create", {
+    package_id: packageId,
+    version: "1.0.0",
+    is_latest: true,
+  })
+  const release = releaseResponse.data.package_release
+
+  // Update the package release
+  const response = await axios.post("/api/package_releases/update", {
+    package_release_id: release.package_release_id,
+    is_locked: true,
+    license: "MIT",
+  })
+
+  expect(response.status).toBe(200)
+  expect(response.data.ok).toBe(true)
+
+  // Verify the release was updated
+  const updatedRelease = db.packageReleases.find(
+    (pr) => pr.package_release_id === release.package_release_id,
+  )
+  expect(updatedRelease?.is_locked).toBe(true)
+  expect(updatedRelease?.license).toBe("MIT")
+})
+
+test("update package release using package_name_with_version", async () => {
+  const { axios, db } = await getTestServer()
+
+  // First create a package
+  const packageResponse = await axios.post(
+    "/api/packages/create",
+    {
+      name: "test-package-2",
+      description: "Test Description",
+    },
+    {
+      headers: {
+        Authorization: "Bearer 1234",
+      },
+    },
+  )
+  const packageName = packageResponse.data.package.name
+  const version = "2.0.0"
+
+  // Create a package release
+  await axios.post("/api/package_releases/create", {
+    package_id: packageResponse.data.package.package_id,
+    version,
+    is_latest: true,
+  })
+
+  // Update using package_name_with_version
+  const response = await axios.post("/api/package_releases/update", {
+    package_name_with_version: `${packageName}@${version}`,
+    is_locked: true,
+  })
+
+  expect(response.status).toBe(200)
+  expect(response.data.ok).toBe(true)
+
+  // Verify the release was updated
+  const updatedRelease = db.packageReleases.find((pr) => pr.version === version)
+  expect(updatedRelease?.is_locked).toBe(true)
+})
+
+test("update package release - handle is_latest flag", async () => {
+  const { axios, db } = await getTestServer()
+
+  // Create a package
+  const packageResponse = await axios.post(
+    "/api/packages/create",
+    {
+      name: "test-package-3",
+      description: "Test Description",
+    },
+    {
+      headers: {
+        Authorization: "Bearer 1234",
+      },
+    },
+  )
+  const packageId = packageResponse.data.package.package_id
+
+  // Create two releases
+  const release1 = await axios.post("/api/package_releases/create", {
+    package_id: packageId,
+    version: "1.0.0",
+    is_latest: true,
+  })
+  const release2 = await axios.post("/api/package_releases/create", {
+    package_id: packageId,
+    version: "2.0.0",
+    is_latest: false,
+  })
+
+  // Update second release to be latest
+  await axios.post("/api/package_releases/update", {
+    package_release_id: release2.data.package_release.package_release_id,
+    is_latest: true,
+  })
+
+  // Verify first release is no longer latest
+  const firstRelease = db.packageReleases.find(
+    (pr) =>
+      pr.package_release_id ===
+      release1.data.package_release.package_release_id,
+  )
+  expect(firstRelease?.is_latest).toBe(false)
+
+  // Verify second release is now latest
+  const secondRelease = db.packageReleases.find(
+    (pr) =>
+      pr.package_release_id ===
+      release2.data.package_release.package_release_id,
+  )
+  expect(secondRelease?.is_latest).toBe(true)
+})
+
+test("update non-existent package release", async () => {
+  const { axios } = await getTestServer()
+
+  try {
+    await axios.post("/api/package_releases/update", {
+      package_release_id: "123e4567-e89b-12d3-a456-426614174000",
+      is_locked: true,
+    })
+    throw new Error("Expected request to fail")
+  } catch (error: any) {
+    expect(error.status).toBe(404)
+    expect(error.data.error.error_code).toBe("package_release_not_found")
+    expect(error.data.error.message).toBe("Package release not found")
+  }
+})
+
+test("update package release - no fields provided", async () => {
+  const { axios } = await getTestServer()
+
+  // Create a package and release first
+  const packageResponse = await axios.post(
+    "/api/packages/create",
+    {
+      name: "test-package-4",
+      description: "Test Description",
+    },
+    {
+      headers: {
+        Authorization: "Bearer 1234",
+      },
+    },
+  )
+  const releaseResponse = await axios.post("/api/package_releases/create", {
+    package_id: packageResponse.data.package.package_id,
+    version: "1.0.0",
+  })
+
+  try {
+    await axios.post("/api/package_releases/update", {
+      package_release_id:
+        releaseResponse.data.package_release.package_release_id,
+    })
+    throw new Error("Expected request to fail")
+  } catch (error: any) {
+    expect(error.status).toBe(400)
+    expect(error.data.error.error_code).toBe("no_fields_provided")
+    expect(error.data.error.message).toBe("No fields provided to update")
+  }
+})

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

@@ -0,0 +1,26 @@
+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: "TestPackage",
+      description: "Test Description",
+    },
+    {
+      headers: {
+        Authorization: "Bearer 1234",
+      },
+    },
+  )
+
+  expect(response.status).toBe(200)
+  expect(response.data.package.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()
+})