Add constraint on delete-only-untagged-versions

Improve `delete-only-untagged-versions` flag and minor bug fix

.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,6 +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 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
 
@@ -8,8 +8,8 @@ This action deletes versions of a package from [GitHub Packages](https://github.
 * 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)
@@ -17,22 +17,22 @@ This action deletes versions of a package from [GitHub Packages](https://github.
 # 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:
 
   # Name of the package.
   # Required
   package-name:
 
-  # Type of the package.
+  # Type of the package. Can be one of container, maven, npm, nuget, or rubygems.
   # Required
   package-type:
 
@@ -41,14 +41,14 @@ This action deletes versions of a package from [GitHub Packages](https://github.
   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.
@@ -58,9 +58,19 @@ This action deletes versions of a package from [GitHub Packages](https://github.
   # 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.
+  # The number of untagged versions to keep can be set by using `min-versions-to-keep` value with this.
+  # When `min-versions-to-keep` is 0, all untagged versions get deleted.
+  # Defaults to false.
+  # Cannot be used with `num-old-versions-to-delete`.
+  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:
@@ -77,45 +87,52 @@ This action deletes versions of a package from [GitHub Packages](https://github.
   - `num-old-versions-to-delete` + `ignore-versions`
   - `min-versions-to-keep` + `ignore-versions`
   - `min-versions-to-keep` + `delete-only-pre-release-versions`
+  - `delete-only-untagged-versions`
+  - `min-versions-to-keep` + `delete-only-untagged-versions`
 
 # 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__, __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'
       package-name: 'test-package'
@@ -127,16 +144,35 @@ This action deletes versions of a package from [GitHub Packages](https://github.
 
   <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'
@@ -144,16 +180,16 @@ This action deletes versions of a package from [GitHub Packages](https://github.
       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__, __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'
       package-name: 'test-package'
@@ -167,16 +203,16 @@ This action deletes versions of a package from [GitHub Packages](https://github.
 
   ### 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'
@@ -184,18 +220,16 @@ This action deletes versions of a package from [GitHub Packages](https://github.
       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__, __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'
       package-name: 'test-package'
@@ -209,30 +243,30 @@ This action deletes versions of a package from [GitHub Packages](https://github.
 
   ### 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__, __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'
       package-name: 'test-package'
@@ -245,30 +279,30 @@ This action deletes versions of a package from [GitHub Packages](https://github.
 
   ### 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__, __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'
       package-name: 'test-package'
@@ -281,25 +315,23 @@ This action deletes versions of a package from [GitHub Packages](https://github.
 
   ### 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__, __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'
       package-name: 'test-package'
@@ -311,30 +343,28 @@ This action deletes versions of a package from [GitHub Packages](https://github.
 
   ### 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'
@@ -346,30 +376,28 @@ This action deletes versions of a package from [GitHub Packages](https://github.
 
   ### 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'
@@ -381,7 +409,6 @@ This action deletes versions of a package from [GitHub Packages](https://github.
 
 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,40 +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',
-  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

@@ -0,0 +1,179 @@
+import {rest} from 'msw'
+import {setupServer} from 'msw/node'
+import {deletePackageVersion, deletePackageVersions} from '../../src/version'
+
+describe('delete tests - mock rest', () => {
+  let server = setupServer()
+
+  beforeEach(() => {
+    server = setupServer()
+    server.listen()
+  })
+
+  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

@@ -0,0 +1,200 @@
+import {rest} from 'msw'
+import {setupServer} from 'msw/node'
+import {
+  getOldestVersions as _getOldestVersions,
+  RestQueryInfo
+} from '../../src/version'
+import {Observable} from 'rxjs'
+import {getMockedVersionsResponse} from './rest.mock'
+import {RATE_LIMIT} from '../../src/delete'
+
+describe('get versions tests -- mock rest', () => {
+  let server = setupServer()
+
+  beforeEach(() => {
+    server = setupServer()
+    server.listen()
+  })
+
+  afterEach(() => {
+    server.close()
+  })
+
+  it('getOldestVersions -- success', done => {
+    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
+  packageName?: string
+  packageType?: string
+  numVersions?: number
+  page?: number
+  token?: string
+}
+
+const defaultParams = {
+  owner: 'test-owner',
+  packageName: 'test-package',
+  packageType: 'npm',
+  numVersions: RATE_LIMIT,
+  page: 1,
+  token: 'test-token'
+}
+
+function getOldestVersions(params?: Params): Observable<RestQueryInfo> {
+  const p: Required<Params> = {...defaultParams, ...params}
+  return _getOldestVersions(
+    p.owner,
+    p.packageName,
+    p.packageType,
+    p.numVersions,
+    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,12 +15,6 @@ 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.
@@ -28,7 +22,7 @@ inputs:
 
   package-type:
     description: >
-      Type of the package containing the version to delete.
+      Type of package. Can be one of container, maven, npm, nuget, or rubygems.
     required: true
 
   num-old-versions-to-delete:
@@ -61,6 +55,15 @@ 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.
+      The number of untagged versions to keep can be specified by min-versions-to-keep.
+      When this is set num-old-versions-to-delete will not be taken into account.
+      By default this is set to false
+    required: false
+    default: "false"
+
   token:
     description: >
       Token with the necessary scopes to delete package versions.

package.json

@@ -31,18 +31,18 @@
     "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,16 +1,15 @@
 /* eslint-disable i18n-text/no-en */
-/* eslint-disable @typescript-eslint/no-unused-vars */
+
 import {Input} from './input'
 import {EMPTY, Observable, of, throwError} from 'rxjs'
-import {reduce} from 'rxjs/operators'
+import {reduce, concatMap, map, expand, tap} from 'rxjs/operators'
 import {
   deletePackageVersions,
   getOldestVersions,
   RestVersionInfo
 } from './version'
-import {concatMap, map, expand, tap} from 'rxjs/operators'
 
-const RATE_LIMIT = 99
+export const RATE_LIMIT = 100
 let totalCount = 0
 
 export function getVersionIds(
@@ -48,7 +47,8 @@ export function getVersionIds(
 
 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()) {
     return getVersionIds(
@@ -63,15 +63,23 @@ export function finalIds(input: Input): Observable<string[]> {
       map(value => {
         // we need to delete oldest versions first
         value.sort((a, b) => {
+          if (a.created_at === b.created_at) {
+            return a.id - b.id
+          }
           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))
+
+        if (input.deleteUntaggedVersions === 'true') {
+          value = value.filter(info => !info.tagged)
+        }
+
         let toDelete = 0
         if (input.minVersionsToKeep < 0) {
           toDelete = Math.min(

src/input.ts

@@ -8,6 +8,7 @@ export interface InputParams {
   ignoreVersions?: RegExp
   token?: string
   deletePreReleaseVersions?: string
+  deleteUntaggedVersions?: string
 }
 
 const defaultParams = {
@@ -19,7 +20,8 @@ const defaultParams = {
   minVersionsToKeep: 0,
   ignoreVersions: new RegExp(''),
   deletePreReleaseVersions: '',
-  token: ''
+  token: '',
+  deleteUntaggedVersions: ''
 }
 
 export class Input {
@@ -33,6 +35,7 @@ export class Input {
   deletePreReleaseVersions: string
   token: string
   numDeleted: number
+  deleteUntaggedVersions: string
 
   constructor(params?: InputParams) {
     const validatedParams: Required<InputParams> = {...defaultParams, ...params}
@@ -47,6 +50,7 @@ export class Input {
     this.deletePreReleaseVersions = validatedParams.deletePreReleaseVersions
     this.token = validatedParams.token
     this.numDeleted = 0
+    this.deleteUntaggedVersions = validatedParams.deleteUntaggedVersions
   }
 
   hasOldestVersionQueryInfo(): boolean {
@@ -59,9 +63,15 @@ export class Input {
   }
 
   checkInput(): boolean {
+    if (this.packageType.toLowerCase() !== 'container') {
+      this.deleteUntaggedVersions = 'false'
+    }
+
     if (
       this.numOldVersionsToDelete > 1 &&
-      (this.minVersionsToKeep >= 0 || this.deletePreReleaseVersions === 'true')
+      (this.minVersionsToKeep >= 0 ||
+        this.deletePreReleaseVersions === 'true' ||
+        this.deleteUntaggedVersions === 'true')
     ) {
       return false
     }
@@ -76,6 +86,11 @@ export class Input {
       this.ignoreVersions = new RegExp('^(0|[1-9]\\d*)((\\.(0|[1-9]\\d*))*)$')
     }
 
+    if (this.deleteUntaggedVersions === 'true') {
+      this.minVersionsToKeep =
+        this.minVersionsToKeep > 0 ? this.minVersionsToKeep : 0
+    }
+
     if (this.minVersionsToKeep >= 0) {
       this.numOldVersionsToDelete = 0
     }

src/main.ts

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
 import {getInput, setFailed} from '@actions/core'
 import {context} from '@actions/github'
 import {Input} from './input'
@@ -20,7 +19,10 @@ function getActionInput(): Input {
     deletePreReleaseVersions: getInput(
       'delete-only-pre-release-versions'
     ).toLowerCase(),
-    token: getInput('token')
+    token: getInput('token'),
+    deleteUntaggedVersions: getInput(
+      'delete-only-untagged-versions'
+    ).toLowerCase()
   })
 }
 

src/octokit-provider.ts

@@ -1,24 +0,0 @@
-import * as github from '@actions/github'
-
-// Centralize all Octokit references by re-exporting
-export {Octokit} from '@octokit/rest'
-
-export interface OctokitOptions {
-  baseUrl?: string
-  userAgent?: string
-}
-
-export function getOctokit(
-  authToken: string,
-  opts: OctokitOptions
-): github.GitHub {
-  const options: OctokitOptions = {
-    baseUrl: 'https://api.github.com'
-  }
-
-  if (opts.userAgent) {
-    options.userAgent = opts.userAgent
-  }
-
-  return new github.GitHub(authToken, options)
-}

src/version/delete-version.ts

@@ -1,11 +1,11 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
 import {from, Observable, merge, throwError, of} from 'rxjs'
 import {catchError, map, tap} from 'rxjs/operators'
 import {Octokit} from '@octokit/rest'
 import {RestEndpointMethodTypes} from '@octokit/plugin-rest-endpoint-methods/dist-types/generated/parameters-and-response-types'
 
 let deleted = 0
-type PackageType = RestEndpointMethodTypes['packages']['getAllPackageVersionsForPackageOwnedByUser']['parameters']['package_type']
+type PackageType =
+  RestEndpointMethodTypes['packages']['getAllPackageVersionsForPackageOwnedByUser']['parameters']['package_type']
 
 export function deletePackageVersion(
   packageVersionId: string,
@@ -15,7 +15,8 @@ export function deletePackageVersion(
   token: string
 ): Observable<boolean> {
   const octokit = new Octokit({
-    auth: token
+    auth: token,
+    baseUrl: process.env.GITHUB_API_URL || 'https://api.github.com'
   })
   const package_version_id = +packageVersionId
   const package_type: PackageType = packageType as PackageType

src/version/get-versions.ts

@@ -8,6 +8,7 @@ export interface RestVersionInfo {
   id: number
   version: string
   created_at: string
+  tagged: boolean
 }
 
 export interface RestQueryInfo {
@@ -17,8 +18,10 @@ export interface RestQueryInfo {
   totalCount: number
 }
 
-type PackageType = RestEndpointMethodTypes['packages']['getAllPackageVersionsForPackageOwnedByUser']['parameters']['package_type']
-type GetVersionsResponse = RestEndpointMethodTypes['packages']['getAllPackageVersionsForPackageOwnedByUser']['response']['data']
+type PackageType =
+  RestEndpointMethodTypes['packages']['getAllPackageVersionsForPackageOwnedByUser']['parameters']['package_type']
+type GetVersionsResponse =
+  RestEndpointMethodTypes['packages']['getAllPackageVersionsForPackageOwnedByUser']['response']['data']
 
 export function getOldestVersions(
   owner: string,
@@ -29,7 +32,8 @@ export function getOldestVersions(
   token: string
 ): Observable<RestQueryInfo> {
   const octokit = new Octokit({
-    auth: token
+    auth: token,
+    baseUrl: process.env.GITHUB_API_URL || 'https://api.github.com'
   })
   const package_type: PackageType = packageType as PackageType
 
@@ -53,10 +57,20 @@ export function getOldestVersions(
     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
+            created_at: version.created_at,
+            tagged
           }
         }),
         page,

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