@tscircuit/fake-snippets 0.0.3 → 0.0.4

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

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

@@ -0,0 +1,100 @@
+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 pkg = {
+    name: "test-package",
+    owner_org_id: "org-1234", // Changed to match the default auth context's personal_org_id
+    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)
+
+  // Delete the package
+  const response = await axios.post(
+    "/api/packages/delete",
+    {
+      package_id: addedPackage.package_id,
+    },
+    {
+      headers: {
+        Authorization: "Bearer 1234",
+      },
+    },
+  )
+
+  expect(response.status).toBe(200)
+  expect(response.data.ok).toBe(true)
+
+  // Verify the package was deleted from the database
+  const deletedPackage = db.getPackageById(addedPackage.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",
+      },
+      {
+        headers: {
+          Authorization: "Bearer 1234",
+        },
+      },
+    )
+    // 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,
+      },
+      {
+        headers: {
+          Authorization: "Bearer 1234",
+        },
+      },
+    )
+    // 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/get.test.ts

@@ -0,0 +1,59 @@
+import { getTestServer } from "bun-tests/fake-snippets-api/fixtures/get-test-server"
+import { expect, test } from "bun:test"
+import { packageSchema } from "fake-snippets-api/lib/db/schema"
+
+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: "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).toEqual(packageSchema.parse(createdPackage))
+})
+
+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"})',
+    )
+  }
+})

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

@@ -0,0 +1,167 @@
+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",
+      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",
+      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",
+      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", {
+    headers: {
+      Authorization: "Bearer 1234",
+    },
+  })
+  expect(authData.packages).toHaveLength(3) // Should return all packages when authenticated
+})
+
+test("list packages with is_writable filter", async () => {
+  const { axios, db } = await getTestServer()
+
+  // Add test packages
+  const packages = [
+    {
+      package_id: "pkg1",
+      name: "Package1",
+      unscoped_name: "Package1",
+      owner_github_username: "testuser", // Matches auth context github_username
+      creator_account_id: "account-1234", // Matches auth context account_id
+      created_at: "2023-01-01T00:00:00Z",
+      updated_at: "2023-01-01T00:00:00Z",
+      description: "Description 1",
+      ai_description: "AI Description 1",
+      owner_org_id: "org-1234", // Matches auth context personal_org_id
+      latest_version: "1.0.0",
+      license: "MIT",
+      is_source_from_github: true,
+      star_count: 0,
+    },
+    {
+      package_id: "pkg2",
+      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",
+      owner_org_id: "other-org",
+      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) {
+    db.addPackage(pkg as any)
+  }
+
+  // Test with is_writable filter (requires auth)
+  const { data: writableData } = await axios.get("/api/packages/list", {
+    params: { is_writable: true },
+    headers: {
+      Authorization: "Bearer 1234",
+    },
+  })
+  expect(writableData.packages).toHaveLength(1)
+  expect(writableData.packages[0].owner_org_id).toBe("org-1234")
+})