feat: add the package_release fake for registry (#633)

* feat: add the package_release fake for registry

* format fix

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",
+    )
+  }
+})

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

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)
+})