Not currently supported in GHES (#95)

Add a new boolean parameter to action `delete-only-untagged-versions`. When true, only versions that do not have any tags will be deleted.

.github/workflows/test.yml

@@ -7,6 +7,9 @@ on: # rebuild any PRs and main branch changes
       - main
       - 'releases/*'
 
+permissions:
+  packages: write
+  
 jobs:
 
   package: # make sure build/ci work properly
@@ -15,6 +18,9 @@ jobs:
     steps:
     - uses: actions/checkout@v2
       name: Checkout Delete Package Versions Repo
+    - uses: actions/setup-node@v3
+      with:
+        node-version: 16
     - run: npm install
       name: NPM Install
     - run: npm run pack
@@ -26,9 +32,12 @@ jobs:
     steps:
     - uses: actions/checkout@v2
       name: Checkout Delete Package Versions Repo
+    - uses: actions/setup-node@v3
+      with:
+        node-version: 16
     - uses: ./
       name: Smoke Test Delete Package Versions Action
       with:
-        package-name: 'com.github.actions.test-package'
+        package-name: 'action-ci-test-package'
+        package-type: 'npm'
         num-old-versions-to-delete: 0
-        min-versions-to-keep: 0

.licenses/npm/@octokit/rest.dep.yml

@@ -1,6 +1,6 @@
 ---
 name: "@octokit/rest"
-version: 16.43.1
+version: 19.0.5
 type: npm
 summary: GitHub REST API client for Node.js
 homepage: https://github.com/octokit/rest.js#readme

README.md

@@ -1,8 +1,6 @@
 # Delete Package Versions
 
-This action deletes versions of a package from [GitHub Packages](https://github.com/features/packages). This action will only delete a maximum of 99 versions in one run.
-
-_This action does currently not support deleting packages from the GitHub Container Registry. As the npm registry is about to be migrated to the same new architecture as GHCR, this action won't work for npm soon too (see [#74](https://github.com/actions/delete-package-versions/issues/74))._
+This action deletes versions of a package from [GitHub Packages](https://github.com/features/packages). This action will only delete a maximum of 100 versions in one run.
 
 ### What It Can Do
 
@@ -10,8 +8,8 @@ _This action does currently not support deleting packages from the GitHub Contai
 * Delete all package versions except n most recent versions
 * Delete oldest version(s)
 * Ignore version(s) from deletion through regex
-* Delete version(s) of a package that is hosted in the same repo that is executing the workflow
-* Delete version(s) of a package that is hosted in a different repo than the one executing the workflow
+* Delete version(s) of a package that is hosted from a repo having access to package
+* Delete version(s) of a package that is hosted from a repo not having access to package
 * Delete a single version
 * Delete multiple versions
 * Delete specific version(s)
@@ -19,40 +17,38 @@ _This action does currently not support deleting packages from the GitHub Contai
 # Usage
 
 ```yaml
-- uses: actions/delete-package-versions@v3
+- uses: actions/delete-package-versions@v4
   with:
   # Can be a single package version id, or a comma separated list of package version ids.
   # Defaults to an empty string.
   package-version-ids:
 
-  # Owner of the repo hosting the package.
+  # Owner of the package.
   # Defaults to the owner of the repo executing the workflow.
-  # Required if deleting a version from a package hosted in a different repo than the one executing the workflow.
+  # Required if deleting a version from a package hosted in a different org than the one executing the workflow.
   owner:
 
-  # Repo hosting the package.
-  # Defaults to the repo executing the workflow.
-  # Required if deleting a version from a package hosted in a different repo than the one executing the workflow.
-  repo:
-
   # Name of the package.
-  # Defaults to an empty string.
-  # Required if `package-version-ids` input is not given.
+  # Required
   package-name:
 
+  # Type of the package. Can be one of container, maven, npm, nuget, or rubygems.
+  # Required
+  package-type:
+
   # The number of old versions to delete starting from the oldest version.
   # Defaults to 1.
   num-old-versions-to-delete:
 
   # The number of latest versions to keep.
-  # This cannot be specified with `num-old-versions-to-delete`. By default, `num-old-versions-to-delete` takes precedence over `min-versions-to-keep`.
+  # This cannot be specified with `num-old-versions-to-delete`. By default, `min-versions-to-keep` takes precedence over `num-old-versions-to-delete`.
   # When set to 0, all deletable versions will be deleted.
   # When set greater than 0, all deletable package versions except the specified number will be deleted.
   min-versions-to-keep:
 
   # The package versions to exclude from deletion.
   # Takes regex for the version name as input.
-  # By default nothing is ignored.
+  # By default nothing is ignored. This is ignored when `delete-only-pre-release-versions` is true
   ignore-versions:
 
   # If true it will delete only the pre-release versions.
@@ -62,9 +58,16 @@ _This action does currently not support deleting packages from the GitHub Contai
   # Cannot be used with `num-old-versions-to-delete` and `ignore-versions`.
   delete-only-pre-release-versions:
 
+  # If true it will delete only the untagged versions in case of container package.
+  # Does not work for other package types and will be ignored.
+  # Defaults to false.
+  delete-only-untagged-versions:
+
   # The token used to authenticate with GitHub Packages.
   # Defaults to github.token.
-  # Required if deleting a version from a package hosted in a different repo than the one executing the workflow.
+  # Required if the repo running the workflow does not have access to delete the package.
+  #   For rubygems and maven package, repo has access if package is hosted in the same repo as the workflow.
+  #   For container, npm and nuget package, repo has access if assigned **Admin** role under Package Settings > Manage Actions Access.
   #   If `package-version-ids` is given the token only needs the delete packages scope.
   #   If `package-version-ids` is not given the token needs the delete packages scope and the read packages scope
   token:
@@ -72,7 +75,7 @@ _This action does currently not support deleting packages from the GitHub Contai
 
 # Valid Input Combinations
 
-`owner`, `repo`, `package-name` and `token` can be used with the following combinations in a workflow - 
+`owner`, `package-name`, `package-type` and `token` can be used with the following combinations in a workflow - 
 
   - `num-old-versions-to-delete`
   - `min-versions-to-keep` 
@@ -84,45 +87,51 @@ _This action does currently not support deleting packages from the GitHub Contai
 
 # Scenarios
 
-  - [Delete all pre-release versions except y latest pre-release package versions](#delete-all-pre-release-versions-except-y-latest-pre-release-package-versions)
-  - [Delete all except y latest versions while ignoring particular package versions](#delete-all-except-y-latest-versions-while-ignoring-particular-package-versions)
-  - [Delete oldest x number of versions while ignoring particular package versions](#delete-oldest-x-number-of-versions-while-ignoring-particular-package-versions)
-  - [Delete all except y latest versions of a package](#delete-all-except-y-latest-versions-of-a-package)
-  - [Delete oldest x number of versions of a package](#delete-oldest-x-number-of-versions-of-a-package)
-  - [Delete oldest version of a package](#delete-oldest-version-of-a-package)
-  - [Delete a specific version of a package](#delete-a-specific-version-of-a-package)
-  - [Delete multiple specific versions of a package](#delete-multiple-specific-versions-of-a-package)
-  
+- [Delete Package Versions](#delete-package-versions)
+    - [What It Can Do](#what-it-can-do)
+- [Usage](#usage)
+- [Valid Input Combinations](#valid-input-combinations)
+- [Scenarios](#scenarios)
+    - [Delete all pre-release versions except y latest pre-release package versions](#delete-all-pre-release-versions-except-y-latest-pre-release-package-versions)
+    - [Delete all untagged container versions except y latest untagged versions](#delete-all-untagged-container-versions-except-y-latest-untagged-versions)
+    - [Delete all except y latest versions while ignoring particular package versions](#delete-all-except-y-latest-versions-while-ignoring-particular-package-versions)
+    - [Delete oldest x number of versions while ignoring particular package versions](#delete-oldest-x-number-of-versions-while-ignoring-particular-package-versions)
+    - [Delete all except y latest versions of a package](#delete-all-except-y-latest-versions-of-a-package)
+    - [Delete oldest x number of versions of a package](#delete-oldest-x-number-of-versions-of-a-package)
+    - [Delete oldest version of a package](#delete-oldest-version-of-a-package)
+    - [Delete a specific version of a package](#delete-a-specific-version-of-a-package)
+    - [Delete multiple specific versions of a package](#delete-multiple-specific-versions-of-a-package)
+- [License](#license)
+
 
   ### Delete all pre-release versions except y latest pre-release package versions
 
-  To delete all pre release versions except y latest pre-release package versions in the same repo as the workflow the __package-name__, __min-versions-to-keep__ and __delete-only-pre-release-versions__ inputs are required.
+  To delete all pre release versions except y latest pre-release package versions, the __package-name__, __min-versions-to-keep__ and __delete-only-pre-release-versions__ inputs are required.
 
   __Example__
 
-  Delete all pre-release package versions except latest 10 in the same repo as the workflow
+  Delete all pre-release package versions except latest 10
 
   ```yaml
-  - uses: actions/delete-package-versions@v3
+  - uses: actions/delete-package-versions@v4
     with: 
       package-name: 'test-package'
+      package-type: 'npm'
       min-versions-to-keep: 10
       delete-only-pre-release-versions: "true"
   ```
-  To delete all pre release versions except y latest pre-release package versions in a different repo than the workflow the __owner__, __repo__, __package-name__, __token__, __min-versions-to-keep__ and __delete-only-pre-release-versions__ inputs are required.
-
-  The [token][token] needs the delete packages and read packages scope. It is recommended [to store the token as a secret][secret]. In this example the [token][token] was stored as a secret named __GITHUB_PAT__.
+  To delete all pre release versions except y latest pre-release package versions from a repo not having access to package, the __owner__, __package-name__, __token__, __min-versions-to-keep__ and __delete-only-pre-release-versions__ inputs are required.
 
   __Example__
 
-  Delete all pre-release package versions except latest 10 in a different repo than the workflow
+  Delete all pre-release package versions except latest 10 from a repo not having access to package
 
   ```yaml
-  - uses: actions/delete-package-versions@v3
+  - uses: actions/delete-package-versions@v4
     with: 
       owner: 'github'
-      repo: 'packages'
       package-name: 'test-package'
+      package-type: 'npm'
       token: ${{ secrets.GITHUB_PAT }}
       min-versions-to-keep: 10
       delete-only-pre-release-versions: "true"
@@ -130,36 +139,56 @@ _This action does currently not support deleting packages from the GitHub Contai
 
   <br>
 
-  ### Delete all except y latest versions while ignoring particular package versions
+  ### Delete all untagged container versions except y latest untagged versions
 
-  To delete all except y latest versions while ignoring particular package versions in the same repo as the workflow the __package-name__, __min-versions-to-keep__ and __ignore-versions__ inputs are required.
+  To delete all untagged versions of a container package except y latest untagged versions, the __package-name__, __package-type__, __min-versions-to-keep__ and __delete-only-untagged-versions__ inputs are required. __package-type__ must be container for this scenario.
 
   __Example__
 
-  Delete all except latest 3 package versions excluding major versions as per semver in the same repo as the workflow
+  Delete all untagged versions except latest 10
 
   ```yaml
-  - uses: actions/delete-package-versions@v3
+  - uses: actions/delete-package-versions@v4
     with: 
       package-name: 'test-package'
+      package-type: 'container'
+      min-versions-to-keep: 10
+      delete-only-untagged-versions: 'true'
+  ```
+
+  <br>
+
+  ### Delete all except y latest versions while ignoring particular package versions
+
+  To delete all except y latest versions while ignoring particular package versions, the __package-name__, __min-versions-to-keep__ and __ignore-versions__ inputs are required.
+
+  __Example__
+
+  Delete all except latest 3 package versions excluding major versions as per semver
+
+  ```yaml
+  - uses: actions/delete-package-versions@v4
+    with: 
+      package-name: 'test-package'
+      package-type: 'npm'
       min-versions-to-keep: 3
       ignore-versions: '^(0|[1-9]\\d*)\\.0\\.0$'
   ```
 
-  To delete all except y latest versions while ignoring particular package versions in a different repo than the workflow the __owner__, __repo__, __package-name__, __token__, __min-versions-to-keep__ and __ignore-versions__ inputs are required.
+  To delete all except y latest versions while ignoring particular package versions from a repo not having access to package, the __owner__, __package-name__, __token__, __min-versions-to-keep__ and __ignore-versions__ inputs are required.
 
   The [token][token] needs the delete packages and read packages scope. It is recommended [to store the token as a secret][secret]. In this example the [token][token] was stored as a secret named __GITHUB_PAT__.
 
   __Example__
 
-  Delete all except latest 3 package versions excluding major versions as per semver in a different repo than the workflow
+  Delete all except latest 3 package versions excluding major versions as per semver from a repo not having access to package
 
   ```yaml
-  - uses: actions/delete-package-versions@v3
+  - uses: actions/delete-package-versions@v4
     with: 
       owner: 'github'
-      repo: 'packages'
       package-name: 'test-package'
+      package-type: 'npm'
       token: ${{ secrets.GITHUB_PAT }}
       min-versions-to-keep: 3
       ignore-versions: '^(0|[1-9]\\d*)\\.0\\.0$'
@@ -169,38 +198,37 @@ _This action does currently not support deleting packages from the GitHub Contai
 
   ### Delete oldest x number of versions while ignoring particular package versions
 
-  To delete oldest x number of versions while ignoring all the major package versions in the same repo as the workflow the __package-name__, __num-oldest-versions-to-delete__ and __ignore-versions__ inputs are required.
+  To delete oldest x number of versions while ignoring all the major package versions, the __package-name__, __num-oldest-versions-to-delete__ and __ignore-versions__ inputs are required.
 
   There is a possibility if the oldest x number of versions contain ignored package versions, actual package versions to get deleted will be less than x.
 
   __Example__
 
-  Delete 3 oldest versions excluding major versions as per semver is the same repo as the workflow
+  Delete 3 oldest versions excluding major versions as per semver
 
   ```yaml
-  - uses: actions/delete-package-versions@v3
+  - uses: actions/delete-package-versions@v4
     with: 
       package-name: 'test-package'
+      package-type: 'npm'
       num-old-versions-to-delete: 3
       ignore-versions: '^(0|[1-9]\\d*)\\.0\\.0$'
   ```
 
-  To delete oldest x number of versions while ignoring all the major package versions in a different repo than the workflow the __owner__, __repo__, __package-name__, __token__, __num-oldest-versions-to-delete__ and __ignore-versions__ inputs are required.
+  To delete oldest x number of versions while ignoring all the major package versions from a repo not having access to package, the __owner__, __package-name__, __token__, __num-oldest-versions-to-delete__ and __ignore-versions__ inputs are required.
 
   There is a possibility if the oldest x number of versions contain ignored package versions, actual package versions to get deleted will be less than x.
 
-  The [token][token] needs the delete packages and read packages scope. It is recommended [to store the token as a secret][secret]. In this example the [token][token] was stored as a secret named __GITHUB_PAT__.
-
   __Example__
 
-  Delete 3 oldest versions excluding major versions as per semver is a different repo than the workflow
+  Delete 3 oldest versions excluding major versions as per semver from a repo not having access to package
 
   ```yaml
-  - uses: actions/delete-package-versions@v3
+  - uses: actions/delete-package-versions@v4
     with: 
       owner: 'github'
-      repo: 'packages'
       package-name: 'test-package'
+      package-type: 'npm'
       token: ${{ secrets.PAT }}
       num-old-versions-to-delete: 3
       ignore-versions: '^(0|[1-9]\\d*)\\.0\\.0$'
@@ -210,33 +238,34 @@ _This action does currently not support deleting packages from the GitHub Contai
 
   ### Delete all except y latest versions of a package
 
-  To delete all except y latest versions of a package hosted in the same repo as the workflow the __package-name__ and __min-versions-to-keep__ inputs are required.
+  To delete all except y latest versions of a package hosted, the __package-name__ and __min-versions-to-keep__ inputs are required.
 
   __Example__
 
-  Delete all except latest 2 versions of a package hosted in the same repo as the workflow
+  Delete all except latest 2 versions of a package hosted
 
   ```yaml
-  - uses: actions/delete-package-versions@v3
+  - uses: actions/delete-package-versions@v4
     with:
       package-name: 'test-package'
+      package-type: 'npm'
       min-versions-to-keep: 2
   ```
 
-  To delete all except y latest versions of a package hosted in a repo other than the workflow the __owner__, __repo__, __package-name__, __token__ and __min-versions-to-keep__ inputs are required.
+  To delete all except y latest versions of a package hosted from a repo not having access to package, the __owner__, __package-name__, __token__ and __min-versions-to-keep__ inputs are required.
 
   The [token][token] needs the delete packages and read packages scope. It is recommended [to store the token as a secret][secret]. In this example the [token][token] was stored as a secret named __GITHUB_PAT__.
 
   __Example__
 
-  Delete all except latest 2 versions of a package hosted in a repo other than the workflow
+  Delete all except latest 2 versions of a package hosted from a repo not having access to package
 
   ```yaml
-  - uses: actions/delete-package-versions@v3
+  - uses: actions/delete-package-versions@v4
     with:
       owner: 'github'
-      repo: 'packages'
       package-name: 'test-package'
+      package-type: 'npm'
       token: ${{ secrets.PAT }}
       min-versions-to-keep: 2
   ```
@@ -245,33 +274,34 @@ _This action does currently not support deleting packages from the GitHub Contai
 
   ### Delete oldest x number of versions of a package
 
-  To delete the oldest x number of versions of a package hosted in the same repo as the workflow the __package-name__, and __num-old-versions-to-delete__ inputs are required.
+  To delete the oldest x number of versions of a package hosted, the __package-name__, and __num-old-versions-to-delete__ inputs are required.
 
   __Example__
 
-  Delete the oldest 3 version of a package hosted in the same repo as the workflow
+  Delete the oldest 3 version of a package hosted
 
   ```yaml
-  - uses: actions/delete-package-versions@v3
+  - uses: actions/delete-package-versions@v4
     with:
       package-name: 'test-package'
+      package-type: 'npm'
       num-old-versions-to-delete: 3
   ```
 
-  To delete the oldest x number of versions of a package hosted in a different repo than the workflow the __owner__, __repo__, __package-name__, __token__ and __num-old-versions-to-delete__ inputs are required.
+  To delete the oldest x number of versions of a package hosted from a repo not having access to package, the __owner__, __package-name__, __token__ and __num-old-versions-to-delete__ inputs are required.
 
   The [token][token] needs the delete packages and read packages scope. It is recommended [to store the token as a secret][secret]. In this example the [token][token] was stored as a secret named __GITHUB_PAT__.
 
   __Example__
 
-  Delete the oldest 3 version of a package hosted in a different repo than the one executing the workflow
+  Delete the oldest 3 version of a package hosted from a repo not having access to package
 
   ```yaml
-  - uses: actions/delete-package-versions@v3
+  - uses: actions/delete-package-versions@v4
     with:
       owner: 'github'
-      repo: 'packages'
       package-name: 'test-package'
+      package-type: 'npm'
       num-old-versions-to-delete: 3
       token: ${{ secrets.GITHUB_PAT }}
   ```
@@ -280,28 +310,27 @@ _This action does currently not support deleting packages from the GitHub Contai
 
   ### Delete oldest version of a package
 
-  To delete the oldest version of a package that is hosted in the same repo as the workflow the __package-name__ input is required.
+  To delete the oldest version of a package that is hosted, the __package-name__ input is required.
 
   __Example__
 
   ```yaml
-  - uses: actions/delete-package-versions@v3
+  - uses: actions/delete-package-versions@v4
     with:
       package-name: 'test-package'
+      package-type: 'npm'
   ```
 
-  To delete the oldest version of a package that is hosted in a different repo than the workflow the __owner__, __repo__, __package-name__, __token__ inputs are required.
-
-  The [token][token] needs the delete packages and read packages scope. It is recommended [to store the token as a secret][secret]. In this example the [token][token] was stored as a secret named __GITHUB_PAT__.
+  To delete the oldest version of a package that is hosted from a repo not having access to package, the __owner__, __package-name__, __token__ inputs are required.
 
   __Example__
 
   ```yaml
-  - uses: actions/delete-package-versions@v3
+  - uses: actions/delete-package-versions@v4
     with:
       owner: 'github'
-      repo: 'packages'
       package-name: 'test-package'
+      package-type: 'npm'
       token: ${{ secrets.PAT }}
   ```
 
@@ -309,30 +338,32 @@ _This action does currently not support deleting packages from the GitHub Contai
 
   ### Delete a specific version of a package
 
-  To delete a specific version of a package that is hosted in the same repo as the workflow the __package-version-ids__ input is required.
+  To delete a specific version of a package that is hosted, the __package-version-ids__ input is required.
 
-  Package version ids can be retrieved via the [GitHub GraphQL API][api]
+  Package version ids can be retrieved via the [GitHub REST API][api]
 
   __Example__
 
   ```yaml
-  - uses: actions/delete-package-versions@v3
+  - uses: actions/delete-package-versions@v4
     with:
       package-version-ids: 'MDE0OlBhY2thZ2VWZXJzaW9uOTcyMDY3'
+      package-name: 'test-package'
+      package-type: 'npm'
   ```
 
-  To delete a specific version of a package that is hosted in a different repo than the workflow the __package-version-ids__ and __token__ inputs are required.
+  To delete a specific version of a package that is hosted from a repo not having access to package, the __package-version-ids__ and __token__ inputs are required.
 
-  The [token][token] needs the delete packages and read packages scope. It is recommended [to store the token as a secret][secret]. In this example the [token][token] was stored as a secret named __GITHUB_PAT__.
-
-  Package version ids can be retrieved via the [GitHub GraphQL API][api]
+  Package version ids can be retrieved via the [GitHub REST API][api]
 
   __Example__
 
   ```yaml
-  - uses: actions/delete-package-versions@v3
+  - uses: actions/delete-package-versions@v4
     with:
       package-version-ids: 'MDE0OlBhY2thZ2VWZXJzaW9uOTcyMDY3'
+      package-name: 'test-package'
+      package-type: 'npm'
       token: ${{ secrets.PAT }}
   ```
 
@@ -340,30 +371,32 @@ _This action does currently not support deleting packages from the GitHub Contai
 
   ### Delete multiple specific versions of a package
 
-  To delete multiple specific versions of a package that is hosted in the same repo as the workflow the __package-version-ids__ input is required.
+  To delete multiple specific versions of a package that is hosted, the __package-version-ids__ input is required.
 
-  The __package-version-ids__ input should be a comma separated string of package version ids. Package version ids can be retrieved via the [GitHub GraphQL API][api].
+  The __package-version-ids__ input should be a comma separated string of package version ids. Package version ids can be retrieved via the [GitHub REST API][api].
 
   __Example__
 
   ```yaml
-  - uses: actions/delete-package-versions@v3
+  - uses: actions/delete-package-versions@v4
     with:
       package-version-ids: 'MDE0OlBhY2thZ2VWZXJzaW9uOTcyMDY3, MDE0OlBhY2thZ2VWZXJzaW9uOTcyMzQ5, MDE0OlBhY2thZ2VWZXJzaW9uOTcyMzUw'
+      package-name: 'test-package'
+      package-type: 'npm'
   ```
 
-  To delete multiple specific versions of a package that is hosted in a repo other than the workflow the __package-version-ids__, __token__ inputs are required.
+  To delete multiple specific versions of a package that is hosted from a repo not having access to package, the __package-version-ids__, __token__ inputs are required.
 
-  The __package-version-ids__ input should be a comma separated string of package version ids. Package version ids can be retrieved via the [GitHub GraphQL API][api].
-
-  The [token][token] needs the delete packages and read packages scope. It is recommended [to store the token as a secret][secret]. In this example the [token][token] was stored as a secret named __GITHUB_PAT__.
+  The __package-version-ids__ input should be a comma separated string of package version ids. Package version ids can be retrieved via the [GitHub REST API][api].
 
   __Example__
 
   ```yaml
-  - uses: actions/delete-package-versions@v3
+  - uses: actions/delete-package-versions@v4
     with:
       package-version-ids: 'MDE0OlBhY2thZ2VWZXJzaW9uOTcyMDY3, MDE0OlBhY2thZ2VWZXJzaW9uOTcyMzQ5, MDE0OlBhY2thZ2VWZXJzaW9uOTcyMzUw'
+      package-name: 'test-package'
+      package-type: 'npm'
       token: ${{ secrets.PAT }}
   ```
 
@@ -371,7 +404,6 @@ _This action does currently not support deleting packages from the GitHub Contai
 
 The scripts and documentation in this project are released under the [MIT License](https://github.com/actions/delete-package-versions/blob/main/LICENSE)
 
-[api]: https://developer.github.com/v4/previews/#github-packages
+[api]: https://docs.github.com/en/rest/packages
 [token]: https://help.github.com/en/packages/publishing-and-managing-packages/about-github-packages#about-tokens
 [secret]: https://help.github.com/en/actions/configuring-and-managing-workflows/creating-and-storing-encrypted-secrets
-

__tests__/delete.test.ts

@@ -1,46 +1,347 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import {rest} from 'msw'
+import {setupServer} from 'msw/node'
 import {Input, InputParams} from '../src/input'
-import {deleteVersions, finalIds} from '../src/delete'
+import {deleteVersions, finalIds, RATE_LIMIT} from '../src/delete'
+import {getMockedVersionsResponse} from './version/rest.mock'
+import {RestEndpointMethodTypes} from '@octokit/plugin-rest-endpoint-methods/dist-types/generated/parameters-and-response-types'
 
-describe.skip('index tests -- call graphql', () => {
-  it('finalIds test -- get oldest version', done => {
-    const numVersions = 1
+type GetVersionsResponseData =
+  RestEndpointMethodTypes['packages']['getAllPackageVersionsForPackageOwnedByUser']['response']['data']
 
-    finalIds(getInput({numOldVersionsToDelete: numVersions})).subscribe(ids => {
-      expect(ids.length).toBe(numVersions)
-      done()
-    })
+describe('index tests -- call rest', () => {
+  let server = setupServer()
+
+  beforeEach(() => {
+    server = setupServer()
+    server.listen()
   })
 
-  it.skip('finalIds test -- get oldest 3 versions', done => {
-    const numVersions = 3
-    finalIds(getInput({numOldVersionsToDelete: numVersions})).subscribe(ids => {
-      expect(ids.length).toBe(numVersions)
-      done()
-    })
+  afterEach(() => {
+    server.close()
   })
 
-  it.skip('finalIds test -- get oldest 110 versions', done => {
-    const numVersions = 110
-
-    finalIds(getInput({numOldVersionsToDelete: numVersions})).subscribe(ids => {
-      expect(ids.length).toBe(99), async () => done()
-    })
-  })
-
-  it('finalIds test -- supplied package version id', done => {
-    const suppliedIds = [
-      'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
-      'BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB',
-      'CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC'
-    ]
-
+  it('finalIds test - supplied package version id', done => {
+    const suppliedIds = ['123', '456', '789']
     finalIds(getInput({packageVersionIds: suppliedIds})).subscribe(ids => {
-      expect(ids).toBe(suppliedIds)
+      expect(ids).toStrictEqual(suppliedIds)
       done()
     })
   })
 
-  it('deleteVersions test -- missing token', done => {
+  it('finalIDs test - success', done => {
+    const numVersions = 10
+    let apiCalled = 0
+
+    const versions = getMockedVersionsResponse(numVersions)
+
+    server.use(
+      rest.get(
+        'https://api.github.com/users/test-owner/packages/npm/test-package/versions',
+        (req, res, ctx) => {
+          apiCalled++
+          return res(ctx.status(200), ctx.json(versions))
+        }
+      )
+    )
+
+    finalIds(getInput()).subscribe(ids => {
+      expect(apiCalled).toBe(1)
+      expect(ids.length).toBe(numVersions)
+      for (let i = 0; i < numVersions; i++) {
+        expect(ids[i]).toBe(versions[i].id.toString())
+      }
+      done()
+    })
+  })
+
+  it('finalIDs test - success - GHES', done => {
+    process.env.GITHUB_API_URL = 'https://github.someghesinstance.com/api/v3'
+
+    const numVersions = 10
+    let apiCalled = 0
+
+    const versions = getMockedVersionsResponse(numVersions)
+
+    server.use(
+      rest.get(
+        'https://github.someghesinstance.com/api/v3/users/test-owner/packages/npm/test-package/versions',
+        (req, res, ctx) => {
+          apiCalled++
+          return res(ctx.status(200), ctx.json(versions))
+        }
+      )
+    )
+
+    finalIds(getInput()).subscribe(ids => {
+      expect(apiCalled).toBe(1)
+      expect(ids.length).toBe(numVersions)
+      for (let i = 0; i < numVersions; i++) {
+        expect(ids[i]).toBe(versions[i].id.toString())
+      }
+
+      delete process.env.GITHUB_API_URL
+      done()
+    })
+  })
+
+  it('finalIDs test - success - pagination', done => {
+    const numVersions = RATE_LIMIT * 2
+    let apiCalled = 0
+
+    const versions = getMockedVersionsResponse(numVersions)
+
+    const firstPage = versions.slice(0, RATE_LIMIT)
+    const secondPage = versions.slice(RATE_LIMIT)
+
+    server.use(
+      rest.get(
+        'https://api.github.com/users/test-owner/packages/npm/test-package/versions',
+        (req, res, ctx) => {
+          apiCalled++
+          const page = req.url.searchParams.get('page')
+          if (page === '1') {
+            return res(ctx.status(200), ctx.json(firstPage))
+          } else if (page === '2') {
+            return res(ctx.status(200), ctx.json(secondPage))
+          } else {
+            return res(ctx.status(200), ctx.json([]))
+          }
+        }
+      )
+    )
+
+    finalIds(getInput()).subscribe(ids => {
+      expect(apiCalled).toBe(3) // 2 full pages + 1 empty page
+      // never returns more than RATE_LIMIT versions
+      expect(ids.length).toBe(RATE_LIMIT)
+      for (let i = 0; i < RATE_LIMIT; i++) {
+        expect(ids[i]).toBe(versions[i].id.toString())
+      }
+      done()
+    })
+  })
+
+  it('finalIDs test - success - sorting accross pages', done => {
+    const numVersions = RATE_LIMIT * 2
+    let apiCalled = 0
+
+    // versions is in ascending order of created_at
+    const versions = getMockedVersionsResponse(numVersions)
+
+    // return newer versions on first page to test sorting
+    const firstPage = versions.slice(RATE_LIMIT).reverse()
+    const secondPage = versions.slice(0, RATE_LIMIT).reverse()
+
+    server.use(
+      rest.get(
+        'https://api.github.com/users/test-owner/packages/npm/test-package/versions',
+        (req, res, ctx) => {
+          apiCalled++
+          const page = req.url.searchParams.get('page')
+          if (page === '1') {
+            return res(ctx.status(200), ctx.json(firstPage))
+          } else if (page === '2') {
+            return res(ctx.status(200), ctx.json(secondPage))
+          } else {
+            return res(ctx.status(200), ctx.json([]))
+          }
+        }
+      )
+    )
+
+    finalIds(getInput()).subscribe(ids => {
+      expect(apiCalled).toBe(3) // 2 full pages + 1 empty page
+      expect(ids.length).toBe(RATE_LIMIT)
+      for (let i = 0; i < RATE_LIMIT; i++) {
+        expect(ids[i]).toBe(versions[i].id.toString())
+      }
+      done()
+    })
+  })
+
+  it('finalIds test - do not delete more than numOldVersionsToDelete', done => {
+    const numVersions = 50
+    let apiCalled = 0
+
+    const versions = getMockedVersionsResponse(numVersions)
+
+    server.use(
+      rest.get(
+        'https://api.github.com/users/test-owner/packages/npm/test-package/versions',
+        (req, res, ctx) => {
+          apiCalled++
+          return res(ctx.status(200), ctx.json(versions))
+        }
+      )
+    )
+
+    const numOldVersionsToDelete = 10
+
+    finalIds(getInput({numOldVersionsToDelete})).subscribe(ids => {
+      expect(apiCalled).toBe(1)
+      expect(ids.length).toBe(numOldVersionsToDelete)
+      for (let i = 0; i < numOldVersionsToDelete; i++) {
+        expect(ids[i]).toBe(versions[i].id.toString())
+      }
+      done()
+    })
+  })
+
+  it('finalIds test - keep minVersionsToKeep', done => {
+    const numVersions = 50
+    let apiCalled = 0
+
+    const versions = getMockedVersionsResponse(numVersions)
+
+    server.use(
+      rest.get(
+        'https://api.github.com/users/test-owner/packages/npm/test-package/versions',
+        (req, res, ctx) => {
+          apiCalled++
+          return res(ctx.status(200), ctx.json(versions))
+        }
+      )
+    )
+
+    const minVersionsToKeep = 10
+
+    finalIds(getInput({minVersionsToKeep})).subscribe(ids => {
+      expect(apiCalled).toBe(1)
+      expect(ids.length).toBe(numVersions - minVersionsToKeep)
+      for (let i = 0; i < numVersions - minVersionsToKeep; i++) {
+        expect(ids[i]).toBe(versions[i].id.toString())
+      }
+      done()
+    })
+  })
+
+  it('finalIds test - delete only prerelease versions with minVersionsToKeep', done => {
+    const numVersions = 50
+    let apiCalled = 0
+
+    const versions = getMockedVersionsResponse(numVersions)
+    // make half versions prerelease
+    for (let i = 0; i < numVersions; i++) {
+      if (i % 2 === 0) {
+        versions[i].name += '-alpha'
+      }
+    }
+
+    server.use(
+      rest.get(
+        'https://api.github.com/users/test-owner/packages/npm/test-package/versions',
+        (req, res, ctx) => {
+          apiCalled++
+          return res(ctx.status(200), ctx.json(versions))
+        }
+      )
+    )
+
+    const toDelete = numVersions / 2 - 10
+
+    finalIds(
+      getInput({
+        ignoreVersions: RegExp('^(0|[1-9]\\d*)((\\.(0|[1-9]\\d*))*)$'),
+        minVersionsToKeep: 10
+      })
+    ).subscribe(ids => {
+      expect(apiCalled).toBe(1)
+      expect(ids.length).toBe(toDelete)
+      for (let i = 0; i < toDelete; i++) {
+        expect(ids[i]).toBe(versions[i * 2].id.toString())
+      }
+      done()
+    })
+  })
+
+  it('finalIds test - delete only untagged versions with minVersionsToKeep', done => {
+    const numVersions = 50
+    const numTaggedVersions = 20
+    const numUntaggedVersions = numVersions - numTaggedVersions
+
+    const taggedVersions = getMockedVersionsResponse(
+      numTaggedVersions,
+      0,
+      'container',
+      true
+    )
+    const untaggedVersions = getMockedVersionsResponse(
+      numUntaggedVersions,
+      numTaggedVersions,
+      'container',
+      false
+    )
+    const versions = taggedVersions.concat(untaggedVersions)
+
+    let apiCalled = 0
+
+    server.use(
+      rest.get(
+        'https://api.github.com/users/test-owner/packages/container/test-package/versions',
+        (req, res, ctx) => {
+          apiCalled++
+          return res(ctx.status(200), ctx.json(versions))
+        }
+      )
+    )
+
+    finalIds(
+      getInput({
+        minVersionsToKeep: 10,
+        deleteUntaggedVersions: 'true',
+        packageType: 'container'
+      })
+    ).subscribe(ids => {
+      expect(apiCalled).toBe(1)
+      expect(ids.length).toBe(numUntaggedVersions - 10)
+      for (let i = 0; i < numUntaggedVersions - 10; i++) {
+        expect(ids[i]).toBe(untaggedVersions[i].id.toString())
+      }
+      done()
+    })
+  })
+
+  it('finalIds test - no versions deleted if API error even once', done => {
+    const numVersions = RATE_LIMIT * 2
+    let apiCalled = 0
+
+    const versions = getMockedVersionsResponse(numVersions)
+
+    const firstPage = versions.slice(0, RATE_LIMIT)
+    const secondPage = versions.slice(RATE_LIMIT)
+
+    server.use(
+      rest.get(
+        'https://api.github.com/users/test-owner/packages/npm/test-package/versions',
+        (req, res, ctx) => {
+          apiCalled++
+          const page = req.url.searchParams.get('page')
+          if (page === '1') {
+            return res(ctx.status(200), ctx.json(firstPage))
+          } else if (page === '2') {
+            return res(ctx.status(500), ctx.json([]))
+          } else {
+            return res(ctx.status(200), ctx.json([]))
+          }
+        }
+      )
+    )
+
+    finalIds(getInput()).subscribe(
+      () => {
+        done.fail('should not complete')
+      },
+      err => {
+        expect(apiCalled).toBe(2) // 1 full page + 1 error page
+        expect(err).toBeTruthy()
+        expect(err).toContain('get versions API failed.')
+        done()
+      }
+    )
+  })
+
+  it('deleteVersions test - missing token', done => {
     deleteVersions(getInput({token: ''})).subscribe({
       error: err => {
         expect(err).toBeTruthy()
@@ -50,7 +351,7 @@ describe.skip('index tests -- call graphql', () => {
     })
   })
 
-  it('deleteVersions test -- missing packageName', done => {
+  it('deleteVersions test - missing packageName', done => {
     deleteVersions(getInput({packageName: ''})).subscribe({
       error: err => {
         expect(err).toBeTruthy()
@@ -60,41 +361,123 @@ describe.skip('index tests -- call graphql', () => {
     })
   })
 
-  it.skip('deleteVersions test -- delete oldest version', done => {
-    deleteVersions(getInput({numOldVersionsToDelete: 1})).subscribe(
-      isSuccess => {
-        expect(isSuccess)
+  it('deleteVersions test - missing packageType', done => {
+    deleteVersions(getInput({packageType: ''})).subscribe({
+      error: err => {
+        expect(err).toBeTruthy()
+        done()
       },
-      async () => done()
-    )
+      complete: async () => done.fail('no error thrown')
+    })
   })
 
-  it.skip('deleteVersions test -- delete 3 oldest versions', done => {
-    deleteVersions(getInput({numOldVersionsToDelete: 3})).subscribe(
-      isSuccess => {
-        expect(isSuccess)
-      },
-      async () => done()
-    )
+  it('deleteVersions test - zero numOldVersionsToDelete', done => {
+    deleteVersions(getInput({numOldVersionsToDelete: 0})).subscribe(result => {
+      expect(result).toBe(true)
+      done()
+    })
   })
 
-  it.skip('deleteVersions test -- keep 5 versions', done => {
-    deleteVersions(getInput({minVersionsToKeep: 100})).subscribe(isSuccess => {
-      expect(isSuccess).toBe(true)
-    }),
-      async () => done()
+  it('deleteVersions test - success complete flow', done => {
+    const numVersions = 10
+    let getApiCalled = 0
+    let deleteApiCalled = 0
+
+    const versions = getMockedVersionsResponse(numVersions)
+    const versionsDeleted: string[] = []
+
+    server.use(
+      rest.get(
+        'https://api.github.com/users/test-owner/packages/npm/test-package/versions',
+        (req, res, ctx) => {
+          getApiCalled++
+          return res(ctx.status(200), ctx.json(versions))
+        }
+      )
+    )
+
+    server.use(
+      rest.delete(
+        'https://api.github.com/users/test-owner/packages/npm/test-package/versions/:versionId',
+        (req, res, ctx) => {
+          deleteApiCalled++
+          versionsDeleted.push(req.params.versionId as string)
+          return res(ctx.status(204))
+        }
+      )
+    )
+
+    deleteVersions(getInput())
+      .subscribe(result => {
+        expect(result).toBe(true)
+      })
+      .add(() => {
+        expect(getApiCalled).toBe(1)
+        expect(deleteApiCalled).toBe(numVersions)
+        for (let i = 0; i < numVersions; i++) {
+          expect(versionsDeleted[i]).toBe(versions[i].id.toString())
+        }
+        done()
+      })
+  })
+
+  it('deleteVersions test - success complete flow - GHES', done => {
+    process.env.GITHUB_API_URL = 'https://github.someghesinstance.com/api/v3'
+
+    const numVersions = 10
+    let getApiCalled = 0
+    let deleteApiCalled = 0
+
+    const versions = getMockedVersionsResponse(numVersions)
+    const versionsDeleted: string[] = []
+
+    server.use(
+      rest.get(
+        'https://github.someghesinstance.com/api/v3/users/test-owner/packages/npm/test-package/versions',
+        (req, res, ctx) => {
+          getApiCalled++
+          return res(ctx.status(200), ctx.json(versions))
+        }
+      )
+    )
+
+    server.use(
+      rest.delete(
+        'https://github.someghesinstance.com/api/v3/users/test-owner/packages/npm/test-package/versions/:versionId',
+        (req, res, ctx) => {
+          deleteApiCalled++
+          versionsDeleted.push(req.params.versionId as string)
+          return res(ctx.status(204))
+        }
+      )
+    )
+
+    deleteVersions(getInput())
+      .subscribe(result => {
+        expect(result).toBe(true)
+      })
+      .add(() => {
+        expect(getApiCalled).toBe(1)
+        expect(deleteApiCalled).toBe(numVersions)
+        for (let i = 0; i < numVersions; i++) {
+          expect(versionsDeleted[i]).toBe(versions[i].id.toString())
+        }
+
+        delete process.env.GITHUB_API_URL
+        done()
+      })
   })
 })
 
 const defaultInput: InputParams = {
   packageVersionIds: [],
-  owner: 'namratajha',
-  repo: 'only-pkg',
-  packageName: 'only-pkg',
-  numOldVersionsToDelete: 1,
+  owner: 'test-owner',
+  packageName: 'test-package',
+  packageType: 'npm',
+  numOldVersionsToDelete: RATE_LIMIT,
   minVersionsToKeep: -1,
   ignoreVersions: RegExp('^$'),
-  token: process.env.GITHUB_TOKEN as string
+  token: 'test-token'
 }
 
 function getInput(params?: InputParams): Input {

__tests__/version/delete-version.test.ts

@@ -1,25 +1,179 @@
+import {rest} from 'msw'
+import {setupServer} from 'msw/node'
 import {deletePackageVersion, deletePackageVersions} from '../../src/version'
 
-const githubToken = process.env.GITHUB_TOKEN as string
+describe('delete tests - mock rest', () => {
+  let server = setupServer()
 
-describe.skip('delete tests', () => {
-  it('deletePackageVersion', async () => {
-    const response = await deletePackageVersion(
-      'PV_lADOGReZt84AEI7FzgDSHEI',
-      githubToken
-    ).toPromise()
-    expect(response).toBe(true)
+  beforeEach(() => {
+    server = setupServer()
+    server.listen()
   })
 
-  it('deletePackageVersions', async () => {
-    const response = await deletePackageVersions(
-      [
-        'PV_lADOGReZt84AEI7FzgDSHDs',
-        'PV_lADOGReZt84AEI7FzgDSHDY',
-        'PV_lADOGReZt84AEI7FzgDSHC8'
-      ],
-      githubToken
-    ).toPromise()
-    expect(response).toBe(true)
+  afterEach(() => {
+    server.close()
+  })
+
+  it('deletePackageVersion', done => {
+    server.use(
+      rest.delete(
+        'https://api.github.com/users/test-owner/packages/npm/test-package/versions/123',
+        (req, res, ctx) => {
+          return res(ctx.status(204))
+        }
+      )
+    )
+
+    deletePackageVersion(
+      '123',
+      'test-owner',
+      'test-package',
+      'npm',
+      'test-token'
+    ).subscribe(result => {
+      expect(result).toBe(true)
+      done()
+    })
+  })
+
+  it('deletePackageVersions', done => {
+    let success = 0
+
+    server.use(
+      rest.delete(
+        'https://api.github.com/users/test-owner/packages/npm/test-package/versions/*',
+        (req, res, ctx) => {
+          return res(ctx.status(204))
+        }
+      )
+    )
+
+    deletePackageVersions(
+      ['123', '456', '789'],
+      'test-owner',
+      'test-package',
+      'npm',
+      'test-token'
+    )
+      .subscribe(
+        result => {
+          expect(result).toBe(true)
+          success++
+        },
+        err => {
+          // should not get here
+          done.fail(err)
+        }
+      )
+      .add(() => {
+        expect(success).toBe(3)
+        done()
+      })
+  })
+
+  it('deletePackageVersions - GHES', done => {
+    process.env.GITHUB_API_URL = 'https://github.someghesinstance.com/api/v3'
+
+    let success = 0
+
+    server.use(
+      rest.delete(
+        'https://github.someghesinstance.com/api/v3/users/test-owner/packages/npm/test-package/versions/*',
+        (req, res, ctx) => {
+          return res(ctx.status(204))
+        }
+      )
+    )
+
+    deletePackageVersions(
+      ['123', '456', '789'],
+      'test-owner',
+      'test-package',
+      'npm',
+      'test-token'
+    )
+      .subscribe(
+        result => {
+          expect(result).toBe(true)
+          success++
+        },
+        err => {
+          // should not get here
+          done.fail(err)
+        }
+      )
+      .add(() => {
+        expect(success).toBe(3)
+
+        delete process.env.GITHUB_API_URL
+        done()
+      })
+  })
+
+  it('deletePackageVersion - API error', done => {
+    server.use(
+      rest.delete(
+        'https://api.github.com/users/test-owner/packages/npm/test-package/versions/123',
+        (req, res, ctx) => {
+          return res(ctx.status(500))
+        }
+      )
+    )
+
+    deletePackageVersion(
+      '123',
+      'test-owner',
+      'test-package',
+      'npm',
+      'test-token'
+    ).subscribe(
+      () => {
+        done.fail('should not get here.')
+      },
+      err => {
+        expect(err).toContain('delete version API failed.')
+        done()
+      }
+    )
+  })
+
+  it('deletePackageVersions - API error for some versions', done => {
+    let success = 0
+    let failed = 0
+
+    server.use(
+      rest.delete(
+        'https://api.github.com/users/test-owner/packages/npm/test-package/versions/:versionId',
+        (req, res, ctx) => {
+          if (req.params.versionId === '456') {
+            return res(ctx.status(500))
+          }
+          return res(ctx.status(204))
+        }
+      )
+    )
+
+    deletePackageVersions(
+      ['123', '456', '789'],
+      'test-owner',
+      'test-package',
+      'npm',
+      'test-token'
+    )
+      .subscribe(
+        result => {
+          expect(result).toBe(true)
+          success++
+        },
+        err => {
+          expect(err).toContain('delete version API failed.')
+          failed++
+        }
+      )
+      .add(() => {
+        expect(success).toBe(2)
+        expect(failed).toBe(1)
+        done()
+      })
   })
 })

__tests__/version/get-version.test.ts

@@ -1,68 +1,200 @@
-import {mockOldestQueryResponse} from './graphql.mock'
+import {rest} from 'msw'
+import {setupServer} from 'msw/node'
 import {
   getOldestVersions as _getOldestVersions,
-  QueryInfo
+  RestQueryInfo
 } from '../../src/version'
 import {Observable} from 'rxjs'
+import {getMockedVersionsResponse} from './rest.mock'
+import {RATE_LIMIT} from '../../src/delete'
 
-describe.skip('get versions tests -- call graphql', () => {
-  it('getOldestVersions -- succeeds', done => {
-    const numVersions = 1
-    getOldestVersions({numVersions}).subscribe(result => {
-      expect(result.versions.length).toBe(numVersions)
-      done()
-    })
+describe('get versions tests -- mock rest', () => {
+  let server = setupServer()
+
+  beforeEach(() => {
+    server = setupServer()
+    server.listen()
   })
 
-  it('getOldestVersions -- fails for invalid repo', done => {
-    getOldestVersions({repo: 'actions-testin'}).subscribe({
-      error: err => {
-        expect(err).toBeTruthy()
-        done()
-      },
-      complete: async () => done.fail('no error thrown')
-    })
+  afterEach(() => {
+    server.close()
   })
-})
 
-describe('get versions tests -- mock graphql', () => {
   it('getOldestVersions -- success', done => {
-    const numVersions = 5
-    mockOldestQueryResponse(numVersions)
+    const numVersions = RATE_LIMIT
+    const resp = getMockedVersionsResponse(numVersions)
+
+    server.use(
+      rest.get(
+        'https://api.github.com/users/test-owner/packages/npm/test-package/versions',
+        (req, res, ctx) => {
+          return res(ctx.status(200), ctx.json(resp))
+        }
+      )
+    )
 
     getOldestVersions({numVersions}).subscribe(result => {
       expect(result.versions.length).toBe(numVersions)
+      for (let i = 0; i < numVersions; i++) {
+        expect(result.versions[i].id).toBe(resp[i].id)
+        expect(result.versions[i].version).toBe(resp[i].name)
+        expect(result.versions[i].created_at).toBe(resp[i].created_at)
+      }
+      expect(result.paginate).toBe(true)
+      expect(result.totalCount).toBe(numVersions)
       done()
     })
   })
+
+  it('getOldestVersions -- success - GHES', done => {
+    const numVersions = RATE_LIMIT
+    const resp = getMockedVersionsResponse(numVersions)
+
+    // set GITHUB_API_URL to a different base url
+    process.env.GITHUB_API_URL = 'https://github.someghesinstance.com/api/v3'
+
+    server.use(
+      rest.get(
+        'https://github.someghesinstance.com/api/v3/users/test-owner/packages/npm/test-package/versions',
+        (req, res, ctx) => {
+          return res(ctx.status(200), ctx.json(resp))
+        }
+      )
+    )
+
+    getOldestVersions({numVersions}).subscribe(result => {
+      expect(result.versions.length).toBe(numVersions)
+      for (let i = 0; i < numVersions; i++) {
+        expect(result.versions[i].id).toBe(resp[i].id)
+        expect(result.versions[i].version).toBe(resp[i].name)
+        expect(result.versions[i].created_at).toBe(resp[i].created_at)
+      }
+      expect(result.paginate).toBe(true)
+      expect(result.totalCount).toBe(numVersions)
+
+      delete process.env.GITHUB_API_URL
+      done()
+    })
+  })
+
+  it('getOldestVersions -- success - container tagged versions', done => {
+    const numVersions = 6
+    const numTaggedVersions = 3
+    const numUntaggedVersions = numVersions - numTaggedVersions
+
+    const respTagged = getMockedVersionsResponse(
+      numTaggedVersions,
+      0,
+      'container',
+      true
+    )
+    const respUntagged = getMockedVersionsResponse(
+      numUntaggedVersions,
+      numTaggedVersions,
+      'container',
+      false
+    )
+    const resp = respTagged.concat(respUntagged)
+
+    server.use(
+      rest.get(
+        'https://api.github.com/users/test-owner/packages/container/test-package/versions',
+        (req, res, ctx) => {
+          return res(ctx.status(200), ctx.json(resp))
+        }
+      )
+    )
+
+    getOldestVersions({numVersions, packageType: 'container'}).subscribe(
+      result => {
+        expect(result.versions.length).toBe(numVersions)
+        for (let i = 0; i < numVersions; i++) {
+          expect(result.versions[i].id).toBe(resp[i].id)
+          expect(result.versions[i].version).toBe(resp[i].name)
+          expect(result.versions[i].created_at).toBe(resp[i].created_at)
+          if (i < numTaggedVersions) {
+            expect(result.versions[i].tagged).toBe(true)
+          } else {
+            expect(result.versions[i].tagged).toBe(false)
+          }
+        }
+        expect(result.paginate).toBe(true)
+        expect(result.totalCount).toBe(numVersions)
+        done()
+      }
+    )
+  })
+
+  it('getOldestVersions -- paginate is false when fetched versions is less than page size', done => {
+    const numVersions = 5
+
+    server.use(
+      rest.get(
+        'https://api.github.com/users/test-owner/packages/npm/test-package/versions',
+        (req, res, ctx) => {
+          return res(
+            ctx.status(200),
+            ctx.json(getMockedVersionsResponse(numVersions))
+          )
+        }
+      )
+    )
+
+    // In the call numVersions is set to RATE_LIMIT, but the response has only 5 versions.
+    getOldestVersions().subscribe(result => {
+      expect(result.paginate).toBe(false)
+      done()
+    })
+  })
+
+  it('getOldestVersions -- API error', done => {
+    server.use(
+      rest.get(
+        'https://api.github.com/users/test-owner/packages/npm/test-package/versions',
+        (req, res, ctx) => {
+          return res(ctx.status(500))
+        }
+      )
+    )
+
+    getOldestVersions().subscribe(
+      () => {
+        done.fail('should not get here.')
+      },
+      err => {
+        expect(err).toContain('get versions API failed.')
+        done()
+      }
+    )
+  })
 })
 
 interface Params {
   owner?: string
-  repo?: string
   packageName?: string
+  packageType?: string
   numVersions?: number
-  startCursor?: string
+  page?: number
   token?: string
 }
 
 const defaultParams = {
-  owner: 'namratajha',
-  repo: 'test-repo',
-  packageName: 'test-repo',
-  numVersions: 1,
-  startCursor: '',
-  token: process.env.GITHUB_TOKEN as string
+  owner: 'test-owner',
+  packageName: 'test-package',
+  packageType: 'npm',
+  numVersions: RATE_LIMIT,
+  page: 1,
+  token: 'test-token'
 }
 
-function getOldestVersions(params?: Params): Observable<QueryInfo> {
+function getOldestVersions(params?: Params): Observable<RestQueryInfo> {
   const p: Required<Params> = {...defaultParams, ...params}
   return _getOldestVersions(
     p.owner,
-    p.repo,
     p.packageName,
+    p.packageType,
     p.numVersions,
-    p.startCursor,
+    p.page,
     p.token
   )
 }

__tests__/version/graphql.mock.ts

@@ -1,55 +0,0 @@
-import {
-  GraphQlQueryResponseData,
-  RequestParameters
-} from '@octokit/graphql/dist-types/types'
-
-import * as Graphql from '../../src/version/graphql'
-import {GetVersionsQueryResponse} from '../../src/version'
-
-export function getMockedOldestQueryResponse(
-  numVersions: number
-): GetVersionsQueryResponse {
-  const versions = []
-  numVersions = numVersions < 100 ? numVersions : numVersions
-  for (let i = 1; i <= numVersions; ++i) {
-    versions.push({
-      node: {
-        id: i.toString(),
-        version: `${i}.0.0`
-      }
-    })
-  }
-
-  return {
-    repository: {
-      packages: {
-        edges: [
-          {
-            node: {
-              name: 'test',
-              versions: {
-                totalCount: 200,
-                edges: versions.reverse(),
-                pageInfo: {
-                  startCursor: 'AAA',
-                  hasPreviousPage: false
-                }
-              }
-            }
-          }
-        ]
-      }
-    }
-  }
-}
-
-export function mockOldestQueryResponse(numVersions: number): void {
-  const response = new Promise<GetVersionsQueryResponse>(resolve => {
-    resolve(getMockedOldestQueryResponse(numVersions))
-  }) as Promise<GraphQlQueryResponseData>
-  jest
-    .spyOn(Graphql, 'graphql')
-    .mockImplementation(
-      (token: string, query: string, parameters: RequestParameters) => response
-    )
-}

__tests__/version/rest.mock.ts

@@ -0,0 +1,45 @@
+import {RestEndpointMethodTypes} from '@octokit/plugin-rest-endpoint-methods/dist-types/generated/parameters-and-response-types'
+
+type GetVersionsResponseData =
+  RestEndpointMethodTypes['packages']['getAllPackageVersionsForPackageOwnedByUser']['response']['data']
+type PackageType =
+  RestEndpointMethodTypes['packages']['getAllPackageVersionsForPackageOwnedByUser']['parameters']['package_type']
+
+export function getMockedVersionsResponse(
+  numVersions: number,
+  offset = 0,
+  packageType = 'npm',
+  tagged = false
+): GetVersionsResponseData {
+  const versions: GetVersionsResponseData = []
+  for (let i = 1 + offset; i <= numVersions + offset; ++i) {
+    const created_at = new Date()
+    created_at.setUTCFullYear(2000 + Number(i), 1, 1)
+    let version = {
+      id: i,
+      name: `${i}.0.0`,
+      url: '',
+      created_at: created_at.toUTCString(),
+      package_html_url: '',
+      updated_at: '',
+      metadata: {
+        package_type: packageType as PackageType
+      }
+    } as GetVersionsResponseData[0]
+
+    if (packageType === 'container' && tagged) {
+      version = {
+        ...version,
+        metadata: {
+          package_type: packageType as PackageType,
+          container: {
+            tags: [`latest${i}`] as string[]
+          }
+        }
+      }
+    }
+
+    versions.push(version)
+  }
+  return versions
+}

action.yml

@@ -15,17 +15,15 @@ inputs:
       Defaults to the owner of the repo running the action.
     required: false
 
-  repo:
-    description: >
-      Repo containing the package version to delete.
-      Defaults to the repo running the action.
-    required: false
-
   package-name:
     description: >
       Name of the package containing the version to delete.
-      Required if dynamically deleting oldest versions.
-    required: false
+    required: true
+
+  package-type:
+    description: >
+      Type of package. Can be one of container, maven, npm, nuget, or rubygems.
+    required: true
 
   num-old-versions-to-delete:
     description: >
@@ -57,6 +55,13 @@ inputs:
     required: false
     default: "false"
 
+  delete-only-untagged-versions:
+    description: >
+      Deletes only untagged versions in case of a container package. Does not work for other package types.
+      By default this is set to false
+    required: false
+    default: "false"
+
   token:
     description: >
       Token with the necessary scopes to delete package versions.

package.json

@@ -27,21 +27,22 @@
   "dependencies": {
     "@actions/core": "^1.9.1",
     "@actions/github": "^2.1.1",
+    "@octokit/rest": "^19.0.5",
     "rxjs": "^6.5.4"
   },
   "devDependencies": {
-    "@types/jest": "^27.4.0",
-    "@types/node": "^12.7.12",
-    "@typescript-eslint/parser": "^2.8.0",
-    "@vercel/ncc": "^0.31.1",
-    "eslint": "^8.9.0",
-    "eslint-plugin-github": "^4.3.5",
-    "eslint-plugin-jest": "^22.21.0",
-    "jest": "^27.3.1",
-    "jest-circus": "^27.3.1",
-    "js-yaml": "^3.13.1",
-    "prettier": "^1.19.1",
-    "ts-jest": "^27.0.7",
-    "typescript": "^3.6.4"
+    "@types/jest": "^27.5.2",
+    "@types/node": "^18.11.18",
+    "@typescript-eslint/parser": "^5.47.1",
+    "@vercel/ncc": "^0.36.0",
+    "eslint": "^8.30.0",
+    "eslint-plugin-github": "^4.6.0",
+    "eslint-plugin-jest": "^27.1.7",
+    "jest": "^29.3.1",
+    "jest-circus": "^29.3.1",
+    "js-yaml": "^4.1.0",
+    "msw": "^0.49.2",
+    "prettier": "^2.8.1",
+    "ts-jest": "^29.0.3"
   }
 }

src/delete.ts

@@ -1,127 +1,98 @@
+/* eslint-disable i18n-text/no-en */
+
 import {Input} from './input'
 import {EMPTY, Observable, of, throwError} from 'rxjs'
-import {deletePackageVersions, getOldestVersions, VersionInfo} from './version'
-import {concatMap, map, expand, tap} from 'rxjs/operators'
+import {reduce, concatMap, map, expand, tap} from 'rxjs/operators'
+import {
+  deletePackageVersions,
+  getOldestVersions,
+  RestVersionInfo
+} from './version'
 
-const RATE_LIMIT = 99
+export const RATE_LIMIT = 100
 let totalCount = 0
 
 export function getVersionIds(
   owner: string,
-  repo: string,
   packageName: string,
+  packageType: string,
   numVersions: number,
-  cursor: string,
+  page: number,
   token: string
-): Observable<VersionInfo[]> {
+): Observable<RestVersionInfo[]> {
   return getOldestVersions(
     owner,
-    repo,
     packageName,
+    packageType,
     numVersions,
-    cursor,
+    page,
     token
   ).pipe(
     expand(value =>
       value.paginate
         ? getOldestVersions(
             owner,
-            repo,
             packageName,
+            packageType,
             numVersions,
-            value.cursor,
+            value.page + 1,
             token
           )
         : EMPTY
     ),
-    tap(
-      value => (totalCount = totalCount === 0 ? value.totalCount : totalCount)
-    ),
-    map(value => value.versions)
+    tap(value => (totalCount = totalCount + value.totalCount)),
+    reduce((acc, value) => acc.concat(value.versions), [] as RestVersionInfo[])
   )
 }
 
 export function finalIds(input: Input): Observable<string[]> {
   if (input.packageVersionIds.length > 0) {
-    return of(input.packageVersionIds)
+    const toDelete = Math.min(input.packageVersionIds.length, RATE_LIMIT)
+    return of(input.packageVersionIds.slice(0, toDelete))
   }
   if (input.hasOldestVersionQueryInfo()) {
-    if (input.minVersionsToKeep < 0) {
-      // This code block is when num-old-versions-to-delete is specified.
-      // Setting input.numOldVersionsToDelete is set as minimum of input.numOldVersionsToDelete and RATE_LIMIT
-      input.numOldVersionsToDelete =
-        input.numOldVersionsToDelete < RATE_LIMIT
-          ? input.numOldVersionsToDelete
-          : RATE_LIMIT
-      return getVersionIds(
-        input.owner,
-        input.repo,
-        input.packageName,
-        RATE_LIMIT,
-        '',
-        input.token
-      ).pipe(
-        // This code block executes on batches of 100 versions starting from oldest
-        map(value => {
-          /* 
+    return getVersionIds(
+      input.owner,
+      input.packageName,
+      input.packageType,
+      RATE_LIMIT,
+      1,
+      input.token
+    ).pipe(
+      // This code block executes on all versions of a package starting from oldest
+      map(value => {
+        // we need to delete oldest versions first
+        value.sort((a, b) => {
+          return (
+            new Date(a.created_at).getTime() - new Date(b.created_at).getTime()
+          )
+        })
+        /* 
           Here first filter out the versions that are to be ignored.
-          Then update input.numOldeVersionsToDelete to the no of versions deleted from the next 100 versions batch.
+          Then compute number of versions to delete (toDelete) based on the inputs.
           */
-          value = value.filter(info => !input.ignoreVersions.test(info.version))
-          const temp = input.numOldVersionsToDelete
-          input.numOldVersionsToDelete =
-            input.numOldVersionsToDelete - value.length <= 0
-              ? 0
-              : input.numOldVersionsToDelete - value.length
-          return value.map(info => info.id).slice(0, temp)
-        })
-      )
-    } else {
-      // This code block is when min-versions-to-keep is specified.
-      return getVersionIds(
-        input.owner,
-        input.repo,
-        input.packageName,
-        RATE_LIMIT,
-        '',
-        input.token
-      ).pipe(
-        // This code block executes on batches of 100 versions starting from oldest
-        map(value => {
-          /* 
-          Here totalCount is the total no of versions in the package.
-          First we update totalCount by removing no of ignored versions from it and also filter them out from value.
-          toDelete is the no of versions that need to be deleted and input.numDeleted is the total no of versions deleted before this batch.
-          We calculate this from total no of versions in the package, the min no of versions to keep and the no of versions we have deleted in earlier batch.
-          Then we update toDelete to not exceed the length of current batch of versions.
-          Now toDelete holds the no of versions to be deleted from the current batch of versions.
-          */
-          totalCount =
-            totalCount -
-            value.filter(info => input.ignoreVersions.test(info.version)).length
-          value = value.filter(info => !input.ignoreVersions.test(info.version))
-          let toDelete = totalCount - input.minVersionsToKeep - input.numDeleted
-          toDelete = toDelete > value.length ? value.length : toDelete
-          //Checking here if we have any versions to delete and whether we are within the RATE_LIMIT.
-          if (toDelete > 0 && input.numDeleted < RATE_LIMIT) {
-            /* 
-            Checking here if we can delete all the versions left in the current batch.
-            input.numDeleted + toDelete should not exceed RATE_LIMIT.
-            If it is exceeding we only delete the no of versions from this batch that are allowed within the RATE_LIMIT.
-            i.e. diff between RATE_LIMIT and versions deleted till now (input.numDeleted) 
-            input.numDeleted is updated accordingly.
-            */
-            if (input.numDeleted + toDelete > RATE_LIMIT) {
-              toDelete = RATE_LIMIT - input.numDeleted
-              input.numDeleted = RATE_LIMIT
-            } else {
-              input.numDeleted = input.numDeleted + toDelete
-            }
-            return value.map(info => info.id).slice(0, toDelete)
-          } else return []
-        })
-      )
-    }
+        value = value.filter(info => !input.ignoreVersions.test(info.version))
+
+        if (input.deleteUntaggedVersions === 'true') {
+          value = value.filter(info => !info.tagged)
+        }
+
+        let toDelete = 0
+        if (input.minVersionsToKeep < 0) {
+          toDelete = Math.min(
+            value.length,
+            Math.min(input.numOldVersionsToDelete, RATE_LIMIT)
+          )
+        } else {
+          toDelete = Math.min(
+            value.length - input.minVersionsToKeep,
+            RATE_LIMIT
+          )
+        }
+        if (toDelete < 0) return []
+        return value.map(info => info.id.toString()).slice(0, toDelete)
+      })
+    )
   }
   return throwError(
     "Could not get packageVersionIds. Explicitly specify using the 'package-version-ids' input"
@@ -146,5 +117,15 @@ export function deleteVersions(input: Input): Observable<boolean> {
 
   const result = finalIds(input)
 
-  return result.pipe(concatMap(ids => deletePackageVersions(ids, input.token)))
+  return result.pipe(
+    concatMap(ids =>
+      deletePackageVersions(
+        ids,
+        input.owner,
+        input.packageName,
+        input.packageType,
+        input.token
+      )
+    )
+  )
 }

src/input.ts

@@ -1,58 +1,61 @@
 export interface InputParams {
   packageVersionIds?: string[]
   owner?: string
-  repo?: string
   packageName?: string
+  packageType?: string
   numOldVersionsToDelete?: number
   minVersionsToKeep?: number
   ignoreVersions?: RegExp
   token?: string
   deletePreReleaseVersions?: string
+  deleteUntaggedVersions?: string
 }
 
 const defaultParams = {
   packageVersionIds: [],
   owner: '',
-  repo: '',
   packageName: '',
+  packageType: '',
   numOldVersionsToDelete: 0,
   minVersionsToKeep: 0,
   ignoreVersions: new RegExp(''),
   deletePreReleaseVersions: '',
-  token: ''
+  token: '',
+  deleteUntaggedVersions: ''
 }
 
 export class Input {
   packageVersionIds: string[]
   owner: string
-  repo: string
   packageName: string
+  packageType: string
   numOldVersionsToDelete: number
   minVersionsToKeep: number
   ignoreVersions: RegExp
   deletePreReleaseVersions: string
   token: string
   numDeleted: number
+  deleteUntaggedVersions: string
 
   constructor(params?: InputParams) {
     const validatedParams: Required<InputParams> = {...defaultParams, ...params}
 
     this.packageVersionIds = validatedParams.packageVersionIds
     this.owner = validatedParams.owner
-    this.repo = validatedParams.repo
     this.packageName = validatedParams.packageName
+    this.packageType = validatedParams.packageType
     this.numOldVersionsToDelete = validatedParams.numOldVersionsToDelete
     this.minVersionsToKeep = validatedParams.minVersionsToKeep
     this.ignoreVersions = validatedParams.ignoreVersions
     this.deletePreReleaseVersions = validatedParams.deletePreReleaseVersions
     this.token = validatedParams.token
     this.numDeleted = 0
+    this.deleteUntaggedVersions = validatedParams.deleteUntaggedVersions
   }
 
   hasOldestVersionQueryInfo(): boolean {
     return !!(
       this.owner &&
-      this.repo &&
       this.packageName &&
       this.numOldVersionsToDelete >= 0 &&
       this.token
@@ -67,12 +70,20 @@ export class Input {
       return false
     }
 
+    if (this.packageType === '' || this.packageName === '') {
+      return false
+    }
+
     if (this.deletePreReleaseVersions === 'true') {
       this.minVersionsToKeep =
         this.minVersionsToKeep > 0 ? this.minVersionsToKeep : 0
       this.ignoreVersions = new RegExp('^(0|[1-9]\\d*)((\\.(0|[1-9]\\d*))*)$')
     }
 
+    if (this.packageType.toLowerCase() !== 'container') {
+      this.deleteUntaggedVersions = 'false'
+    }
+
     if (this.minVersionsToKeep >= 0) {
       this.numOldVersionsToDelete = 0
     }

src/main.ts

@@ -11,15 +11,18 @@ function getActionInput(): Input {
       ? getInput('package-version-ids').split(',')
       : [],
     owner: getInput('owner') ? getInput('owner') : context.repo.owner,
-    repo: getInput('repo') ? getInput('repo') : context.repo.repo,
     packageName: getInput('package-name'),
+    packageType: getInput('package-type'),
     numOldVersionsToDelete: Number(getInput('num-old-versions-to-delete')),
     minVersionsToKeep: Number(getInput('min-versions-to-keep')),
     ignoreVersions: RegExp(getInput('ignore-versions')),
     deletePreReleaseVersions: getInput(
       'delete-only-pre-release-versions'
     ).toLowerCase(),
-    token: getInput('token')
+    token: getInput('token'),
+    deleteUntaggedVersions: getInput(
+      'delete-only-untagged-versions'
+    ).toLowerCase()
   })
 }
 
@@ -29,7 +32,10 @@ function run(): Observable<boolean> {
       catchError(err => throwError(err))
     )
   } catch (error) {
-    return throwError(error.message)
+    if (error instanceof Error) {
+      return throwError(error.message)
+    }
+    return throwError(error)
   }
 }
 

src/version/delete-version.ts

@@ -1,50 +1,52 @@
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 import {from, Observable, merge, throwError, of} from 'rxjs'
 import {catchError, map, tap} from 'rxjs/operators'
-import {graphql} from './graphql'
+import {Octokit} from '@octokit/rest'
+import {RestEndpointMethodTypes} from '@octokit/plugin-rest-endpoint-methods/dist-types/generated/parameters-and-response-types'
 
 let deleted = 0
-
-export interface DeletePackageVersionMutationResponse {
-  deletePackageVersion: {
-    success: boolean
-  }
-}
-
-const mutation = `
-  mutation deletePackageVersion($packageVersionId: ID!) {
-      deletePackageVersion(input: {packageVersionId: $packageVersionId}) {
-          success
-      }
-  }`
+type PackageType =
+  RestEndpointMethodTypes['packages']['getAllPackageVersionsForPackageOwnedByUser']['parameters']['package_type']
 
 export function deletePackageVersion(
   packageVersionId: string,
+  owner: string,
+  packageName: string,
+  packageType: string,
   token: string
 ): Observable<boolean> {
+  const octokit = new Octokit({
+    auth: token,
+    baseUrl: process.env.GITHUB_API_URL || 'https://api.github.com'
+  })
+  const package_version_id = +packageVersionId
+  const package_type: PackageType = packageType as PackageType
   deleted += 1
+
   return from(
-    graphql(token, mutation, {
-      packageVersionId,
-      headers: {
-        Accept: 'application/vnd.github.package-deletes-preview+json'
-      }
-    }) as Promise<DeletePackageVersionMutationResponse>
+    octokit.rest.packages.deletePackageVersionForUser({
+      package_type,
+      package_name: packageName,
+      username: owner,
+      package_version_id
+    })
   ).pipe(
     catchError(err => {
-      const msg = 'delete version mutation failed.'
+      const msg = 'delete version API failed.'
       return throwError(
         err.errors && err.errors.length > 0
           ? `${msg} ${err.errors[0].message}`
           : `${msg} ${err.message} \n${deleted - 1} versions deleted till now.`
       )
     }),
-    map(response => response.deletePackageVersion.success)
+    map(response => response.status === 204)
   )
 }
 
 export function deletePackageVersions(
   packageVersionIds: string[],
+  owner: string,
+  packageName: string,
+  packageType: string,
   token: string
 ): Observable<boolean> {
   if (packageVersionIds.length === 0) {
@@ -52,7 +54,7 @@ export function deletePackageVersions(
   }
 
   const deletes = packageVersionIds.map(id =>
-    deletePackageVersion(id, token).pipe(
+    deletePackageVersion(id, owner, packageName, packageType, token).pipe(
       tap(result => {
         if (!result) {
           console.log(`version with id: ${id}, not deleted`)

src/version/get-versions.ts

@@ -1,193 +1,83 @@
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-import {GraphQlQueryResponse} from '@octokit/graphql/dist-types/types'
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-import {Observable, from, throwError} from 'rxjs'
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import {from, Observable, merge, throwError, of} from 'rxjs'
 import {catchError, map} from 'rxjs/operators'
-import {graphql} from './graphql'
+import {Octokit} from '@octokit/rest'
+import {RestEndpointMethodTypes} from '@octokit/plugin-rest-endpoint-methods/dist-types/generated/parameters-and-response-types'
 
-export interface VersionInfo {
-  id: string
+export interface RestVersionInfo {
+  id: number
   version: string
+  created_at: string
+  tagged: boolean
 }
 
-export interface QueryInfo {
-  versions: VersionInfo[]
-  cursor: string
+export interface RestQueryInfo {
+  versions: RestVersionInfo[]
+  page: number
   paginate: boolean
   totalCount: number
 }
 
-export interface GetVersionsQueryResponse {
-  repository: {
-    packages: {
-      edges: {
-        node: {
-          name: string
-          versions: {
-            totalCount: number
-            edges: {node: VersionInfo}[]
-            pageInfo: {
-              startCursor: string
-              hasPreviousPage: boolean
-            }
-          }
-        }
-      }[]
-    }
-  }
-}
-
-const query = `
-  query getVersions($owner: String!, $repo: String!, $package: String!, $last: Int!) {
-    repository(owner: $owner, name: $repo) {
-      packages(first: 1, names: [$package]) {
-        edges {
-          node {
-            name
-            versions(last: $last) {
-              totalCount
-              edges {
-                node {
-                  id
-                  version
-                }
-              }
-              pageInfo {
-                startCursor
-                hasPreviousPage
-              }
-            }
-          }
-        }
-      }
-    }
-  }`
-
-const Paginatequery = `
-  query getVersions($owner: String!, $repo: String!, $package: String!, $last: Int!, $before: String!) {
-    repository(owner: $owner, name: $repo) {
-      packages(first: 1, names: [$package]) {
-        edges {
-          node {
-            name
-            versions(last: $last, before: $before) {
-              totalCount
-              edges {
-                node {
-                  id
-                  version
-                }
-              }
-              pageInfo{
-                startCursor
-                hasPreviousPage
-              }
-            }
-          }
-        }
-      }
-    }
-  }`
-
-export function queryForOldestVersions(
-  owner: string,
-  repo: string,
-  packageName: string,
-  numVersions: number,
-  startCursor: string,
-  token: string
-): Observable<GetVersionsQueryResponse> {
-  if (startCursor === '') {
-    return from(
-      graphql(token, query, {
-        owner,
-        repo,
-        package: packageName,
-        last: numVersions,
-        headers: {
-          Accept: 'application/vnd.github.packages-preview+json'
-        }
-      }) as Promise<GetVersionsQueryResponse>
-    ).pipe(
-      catchError((err: GraphQlQueryResponse<unknown>) => {
-        const msg = 'query for oldest version failed.'
-        return throwError(
-          err.errors && err.errors.length > 0
-            ? `${msg} ${err.errors[0].message}`
-            : `${msg} verify input parameters are correct`
-        )
-      })
-    )
-  } else {
-    return from(
-      graphql(token, Paginatequery, {
-        owner,
-        repo,
-        package: packageName,
-        last: numVersions,
-        before: startCursor,
-        headers: {
-          Accept: 'application/vnd.github.packages-preview+json'
-        }
-      }) as Promise<GetVersionsQueryResponse>
-    ).pipe(
-      catchError((err: GraphQlQueryResponse<unknown>) => {
-        const msg = 'query for oldest version failed.'
-        return throwError(
-          err.errors && err.errors.length > 0
-            ? `${msg} ${err.errors[0].message}`
-            : `${msg} verify input parameters are correct`
-        )
-      })
-    )
-  }
-}
+type PackageType =
+  RestEndpointMethodTypes['packages']['getAllPackageVersionsForPackageOwnedByUser']['parameters']['package_type']
+type GetVersionsResponse =
+  RestEndpointMethodTypes['packages']['getAllPackageVersionsForPackageOwnedByUser']['response']['data']
 
 export function getOldestVersions(
   owner: string,
-  repo: string,
   packageName: string,
+  packageType: string,
   numVersions: number,
-  startCursor: string,
+  page: number,
   token: string
-): Observable<QueryInfo> {
-  return queryForOldestVersions(
-    owner,
-    repo,
-    packageName,
-    numVersions,
-    startCursor,
-    token
+): Observable<RestQueryInfo> {
+  const octokit = new Octokit({
+    auth: token,
+    baseUrl: process.env.GITHUB_API_URL || 'https://api.github.com'
+  })
+  const package_type: PackageType = packageType as PackageType
+
+  return from(
+    octokit.rest.packages.getAllPackageVersionsForPackageOwnedByUser({
+      package_type,
+      package_name: packageName,
+      username: owner,
+      per_page: numVersions,
+      page
+    })
   ).pipe(
-    map(result => {
-      let r: QueryInfo
-      if (result.repository.packages.edges.length < 1) {
-        console.log(
-          `package: ${packageName} not found for owner: ${owner} in repo: ${repo}`
-        )
-        r = {
-          versions: [] as VersionInfo[],
-          cursor: '',
-          paginate: false,
-          totalCount: 0
-        }
-        return r
+    catchError(err => {
+      const msg = 'get versions API failed.'
+      return throwError(
+        err.errors && err.errors.length > 0
+          ? `${msg} ${err.errors[0].message}`
+          : `${msg} ${err.message}`
+      )
+    }),
+    map(response => {
+      const resp = {
+        versions: response.data.map((version: GetVersionsResponse[0]) => {
+          let tagged = false
+          if (
+            package_type === 'container' &&
+            version.metadata &&
+            version.metadata.container
+          ) {
+            tagged = version.metadata.container.tags.length > 0
+          }
+
+          return {
+            id: version.id,
+            version: version.name,
+            created_at: version.created_at,
+            tagged
+          }
+        }),
+        page,
+        paginate: response.data.length === numVersions,
+        totalCount: response.data.length
       }
-
-      const versions = result.repository.packages.edges[0].node.versions.edges
-      const pages = result.repository.packages.edges[0].node.versions.pageInfo
-      const count = result.repository.packages.edges[0].node.versions.totalCount
-
-      r = {
-        versions: versions
-          .map(value => ({id: value.node.id, version: value.node.version}))
-          .reverse(),
-        cursor: pages.startCursor,
-        paginate: pages.hasPreviousPage,
-        totalCount: count
-      }
-
-      return r
+      return resp
     })
   )
 }

src/version/graphql.ts

@@ -1,20 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import {GitHub} from '@actions/github'
-import {GraphQlQueryResponseData} from '@octokit/graphql/dist-types/types'
-import {RequestParameters} from '@octokit/types/dist-types/RequestParameters'
-
-/**
- * Sends a GraphQL query request based on endpoint options
- *
- * @param {string} token Auth token
- * @param {string} query GraphQL query. Example: `'query { viewer { login } }'`.
- * @param {object} parameters URL, query or body parameters, as well as `headers`, `mediaType.{format|previews}`, `request`, or `baseUrl`.
- */
-export async function graphql(
-  token: string,
-  query: string,
-  parameters: RequestParameters
-): Promise<GraphQlQueryResponseData> {
-  const github = new GitHub(token)
-  return await github.graphql(query, parameters)
-}