feat: add batch.serial, batch.defaultTag (#35)

qiwi · Dec 21, 2021 · 4c90812 · 4c90812
1 parent 3ddbebd
commit 4c90812
Show file tree

Hide file tree

Showing 18 changed files with 123 additions and 33 deletions.
diff --git a/package.json b/package.json
@@ -10,10 +10,11 @@
     "clean": "lerna run clean",
     "build": "lerna run build --stream --concurrency 2",
     "uglify": "lerna run uglify --stream --concurrency 2",
+    "lint": "lerna run lint",
     "bootstrap": "lerna bootstrap",
     "jest": "jest --runInBand --detectOpenHandles --forceExit",
     "test:report": "yarn test && yarn coveralls:push",
-    "test": "yarn jest",
+    "test": "yarn lint && yarn jest",
     "test:concurrent": "lerna run test --concurrency 2 --stream --no-prefix && yarn coverage:merge",
     "coverage:merge": "node scripts/js/coverage-merge.js",
     "coveralls:push": "cat ./coverage/lcov.info | coveralls || echo 'coveralls push failed :(' && exit 0",

diff --git a/packages/cli-api/.eslintrc.js b/packages/cli-api/.eslintrc.js
@@ -2,6 +2,5 @@ module.exports = {
   extends: [
     'eslint-config-qiwi',
     'prettier',
-    'prettier/@typescript-eslint',
   ],
 };
diff --git a/packages/cli-api/src/main/ts/executors/deprecate.ts b/packages/cli-api/src/main/ts/executors/deprecate.ts
@@ -8,7 +8,7 @@ export const performDeprecation: TActionPerformer = async (
   config: TDeprecationConfig,
   batchClient
 ): Promise<void> => {
-  const data = await batchClient.deprecate(config.data, config.batch?.skipErrors)
+  const data = await batchClient.deprecate(config.data, config.batch?.skipErrors, config.batch?.serial)
 
   const { successful, failed } = parseResults<IDeprecatePackageParams, TDeprecateResult>(config.data, data)
   const successfulResults = successful.map((item) => item.opts)

diff --git a/packages/cli-api/src/main/ts/executors/get.ts b/packages/cli-api/src/main/ts/executors/get.ts
@@ -18,7 +18,7 @@ export const performGet = async (
   config: TGetConfig,
   batchClient: INpmRegClientBatchWrapper
 ): Promise<void> => {
-  const data = await batchClient.getPackument(config.data, config.batch?.skipErrors)
+  const data = await batchClient.getPackument(config.data, config.batch?.skipErrors, config.batch?.serial)
 
   const { successful, failed } = parseResults<string, TGetPackumentResult>(config.data, data, isFailed)
   const successfulPackages = successful.map((item) => ({ name: item.opts }))

diff --git a/packages/cli-api/src/main/ts/executors/publish.ts b/packages/cli-api/src/main/ts/executors/publish.ts
@@ -11,7 +11,7 @@ export const performPublish: TActionPerformer = async (
   config: TPublishConfig,
   batchClient
 ): Promise<void> => {
-  const data = await batchClient.publish(config.data, config.batch?.skipErrors)
+  const data = await batchClient.publish(config.data, config.batch?.skipErrors, config.batch?.serial)
 
   const { successful, failed } = parseResults<TTarballOpts, TPublishResult>(config.data, data)
   const successfulPackages = successful.map(item => item.opts)

diff --git a/packages/cli-api/src/main/ts/executors/setLatest.ts b/packages/cli-api/src/main/ts/executors/setLatest.ts
@@ -14,7 +14,7 @@ export const performSetLatest: TActionPerformer = async (
   config: TSetLatestConfig,
   batchClient
 ): Promise<void> => {
-  const data = await batchClient.setLatestTag(config.data, config.batch?.skipErrors)
+  const data = await batchClient.setLatestTag(config.data, config.batch?.skipErrors, config.batch?.serial)
 
   const { successful, failed } = parseResults<TSetLatestTagOpts, TSetLatestTagResult>(
     config.data, data, res => res.value !== undefined

diff --git a/packages/cli-api/src/main/ts/interfaces.ts b/packages/cli-api/src/main/ts/interfaces.ts
@@ -21,6 +21,8 @@ export interface IBaseConfig<T = any> {
     jsonOutput?: boolean,
     path?: string,
     printOnlyFailed?: boolean,
+    defaultTag?: string,
+    serial?: boolean,
   },
   data: T,
 }

diff --git a/packages/cli-api/src/main/ts/runner.ts b/packages/cli-api/src/main/ts/runner.ts
@@ -20,7 +20,7 @@ export const run = (configString: string): Promise<void> => {
   const wrapper = npmRegClientWrapperFactory(
     validatedConfig,
     ['publish', 'get', 'distTags.add'],
-    new RegClient({ defaultTag: 'latest-npm-batch-published' })
+    new RegClient({ defaultTag: validatedConfig.batch?.defaultTag || 'latest-npm-batch-published' })
   )
   const batchWrapper = npmRegClientBatchWrapperFactory(wrapper)
   switch (validatedConfig.action) {

diff --git a/packages/cli-api/src/test/ts/executors/get.ts b/packages/cli-api/src/test/ts/executors/get.ts
@@ -31,7 +31,7 @@ describe('performGet', () => {
 
     await performGet(config, npmClientMock as any)
 
-    expect(npmClientMock.getPackument).toHaveBeenCalledWith(config.data, true)
+    expect(npmClientMock.getPackument).toHaveBeenCalledWith(config.data, true, undefined)
     expect(printResultsJsonSpy).toHaveBeenCalledWith({
       failedPackages: [],
       successfulPackages: [],

diff --git a/packages/cli-api/src/test/ts/executors/publish.ts b/packages/cli-api/src/test/ts/executors/publish.ts
@@ -31,7 +31,7 @@ describe('performPublish', () => {
 
     await performPublish(config, npmClientMock as any)
 
-    expect(npmClientMock.publish).toHaveBeenCalledWith(config.data, undefined)
+    expect(npmClientMock.publish).toHaveBeenCalledWith(config.data, undefined, undefined)
     expect(printResultsJsonSpy).toHaveBeenCalledWith({ successfulPackages: [], failedPackages: [] })
   })
 

diff --git a/packages/cli-api/src/test/ts/executors/setLatest.ts b/packages/cli-api/src/test/ts/executors/setLatest.ts
@@ -29,7 +29,7 @@ describe('performSettingLatest', () => {
 
     await performSetLatest(config, npmClientMock as any)
 
-    expect(npmClientMock.setLatestTag).toHaveBeenCalledWith(config.data, undefined)
+    expect(npmClientMock.setLatestTag).toHaveBeenCalledWith(config.data, undefined, undefined)
     expect(printResultsJsonSpy).toHaveBeenCalledWith({ successfulPackages: [], failedPackages: [] })
   })
 

diff --git a/packages/cli-pipe/.eslintrc.js b/packages/cli-pipe/.eslintrc.js
@@ -2,6 +2,5 @@ module.exports = {
   extends: [
     'eslint-config-qiwi',
     'prettier',
-    'prettier/@typescript-eslint',
   ],
 };
diff --git a/packages/cli/.eslintrc.js b/packages/cli/.eslintrc.js
@@ -2,6 +2,5 @@ module.exports = {
   extends: [
     'eslint-config-qiwi',
     'prettier',
-    'prettier/@typescript-eslint',
   ],
 };
diff --git a/packages/cli/README.md b/packages/cli/README.md
@@ -342,3 +342,24 @@ Flag `printOnlyFailed` prints only info about failed packages
     ...
 }
 ```
+`defaultTag` overrides the same option in [npm registry client](https://github.com/npm/npm-registry-client#configuration). Defaults to `latest-npm-batch-published`.
+```text
+{
+    ...
+    "batch": {
+        "defaultTag": "latest"
+    },
+    ...
+}
+```
+If you want batch actions to be performed sequentially set `serial` to true.
+This can be helpful for allowing npm to set dist-tag `latest` while publishing with `defaultTag === 'latest'`. 
+```text
+{
+    ...
+    "batch": {
+        "serial": true
+    },
+    ...
+}
+```
diff --git a/packages/client/.eslintrc.js b/packages/client/.eslintrc.js
@@ -2,6 +2,5 @@ module.exports = {
   extends: [
     'eslint-config-qiwi',
     'prettier',
-    'prettier/@typescript-eslint',
   ],
 };
diff --git a/packages/client/src/main/ts/batchWrapper.ts b/packages/client/src/main/ts/batchWrapper.ts
@@ -17,60 +17,102 @@ export class NpmRegClientBatchWrapper implements INpmRegClientBatchWrapper {
 
   getPackument(
     packageNames: string[],
-    skipErrors?: boolean
+    skipErrors?: boolean,
+    serial?: boolean,
   ): Promise<TBatchResult<TGetPackumentResult>[]> {
     return NpmRegClientBatchWrapper.performBatchActions(
       packageNames,
       (packageName) => this.npmClient.getPackument(packageName),
-      skipErrors
+      skipErrors,
+      serial,
     )
   }
 
   deprecate(
     params: Array<IDeprecatePackageParams>,
-    skipErrors?: boolean
-  ): Promise<TBatchResult<TDeprecateResult>[]> {
+    skipErrors?: boolean,
+    serial?: boolean,
+): Promise<TBatchResult<TDeprecateResult>[]> {
     return NpmRegClientBatchWrapper.performBatchActions(
       params,
       ({ packageName, version, message }) => this.npmClient.deprecate(packageName, version, message),
-      skipErrors
+      skipErrors,
+      serial,
     )
   }
 
   unDeprecate(
     params: Array<IPackageParams>,
-    skipErrors?: boolean
+    skipErrors?: boolean,
+    serial?: boolean,
   ): Promise<TBatchResult<TDeprecateResult>[]> {
-    return this.deprecate(params.map(item => ({ ...item, message: '' })), skipErrors)
+    return this.deprecate(params.map(item => ({ ...item, message: '' })), skipErrors, serial)
   }
 
   publish(
     opts: TTarballOpts[],
-    skipErrors?: boolean
+    skipErrors?: boolean,
+    serial?: boolean,
   ): Promise<TBatchResult<TPublishResult>[]> {
     return NpmRegClientBatchWrapper.performBatchActions(
       opts,
       (opt) => this.npmClient.publish(opt),
-      skipErrors
+      skipErrors,
+      serial,
     )
   }
 
   setLatestTag(
     opts: TSetLatestTagOpts[],
-    skipErrors?: boolean
+    skipErrors?: boolean,
+    serial?: boolean,
   ): Promise<TBatchResult<TSetLatestTagResult>[]> {
     return NpmRegClientBatchWrapper.performBatchActions<TSetLatestTagResult>(
       opts,
       (opt) => this.npmClient.setLatestTag(opt),
-      skipErrors
+      skipErrors,
+      serial,
     )
   }
 
+  static async performSerialBatchActions<T>(
+    params: Array<any>,
+    actionFactory: (...args: any[]) => Promise<T>,
+    skipErrors?: boolean,
+  ): Promise<TBatchResult<T>[]> {
+    const results: TBatchResult<T>[] = []
+
+    for (const opts of params) {
+      try {
+        results.push({
+          status: 'fulfilled',
+          value: await actionFactory(opts),
+        })
+      } catch (e) {
+        if (!skipErrors) {
+          throw e
+        }
+
+        results.push({
+          status: 'rejected',
+          reason: e
+        })
+      }
+    }
+
+    return results
+  }
+
   static performBatchActions<T>(
     params: Array<any>,
     actionFactory: (...args: any[]) => Promise<T>,
-    skipErrors?: boolean
+    skipErrors?: boolean,
+    serial?: boolean
   ): Promise<TBatchResult<T>[]> {
+    if (serial) {
+      return NpmRegClientBatchWrapper.performSerialBatchActions(params, actionFactory, skipErrors)
+    }
+
     const actions = params.map(actionFactory)
     if (skipErrors) {
       return Promise.allSettled(actions)

diff --git a/packages/client/src/main/ts/interfaces.ts b/packages/client/src/main/ts/interfaces.ts
@@ -34,34 +34,39 @@ export type TDeprecateResult = TNpmRegistryClientResult
 
 export type TPublishResult = TNpmRegistryClientResult
 
-export type TGetPackumentResult = TNpmRegistryClientResult | Packument
+export type TGetPackumentResult = Packument
 
 export type TSetLatestTagResult = TNpmRegistryClientResult
 
 export interface INpmRegClientBatchWrapper {
   getPackument(
     params: Array<string>,
-    skipErrors?: boolean
+    skipErrors?: boolean,
+    serial?: boolean,
   ): Promise<TBatchResult<TGetPackumentResult>[]>
 
   deprecate(
     params: Array<IDeprecatePackageParams>,
-    skipErrors?: boolean
+    skipErrors?: boolean,
+    serial?: boolean,
   ): Promise<TBatchResult<TDeprecateResult>[]>
 
   unDeprecate(
     params: Array<IPackageParams>,
-    skipErrors?: boolean
+    skipErrors?: boolean,
+    serial?: boolean,
   ): Promise<TBatchResult<TDeprecateResult>[]>
 
   publish(
     opts: TTarballOpts[],
-    skipErrors?: boolean
+    skipErrors?: boolean,
+    serial?: boolean,
   ): Promise<TBatchResult<TPublishResult>[]>
 
   setLatestTag(
     opts: TSetLatestTagOpts[],
-    skipErrors?: boolean
+    skipErrors?: boolean,
+    serial?: boolean,
   ): Promise<TBatchResult<TSetLatestTagResult>[]>
 }
 

diff --git a/packages/client/src/test/ts/batchWrapper.ts b/packages/client/src/test/ts/batchWrapper.ts
@@ -57,6 +57,29 @@ describe('NpmRegClientBatchWrapper', () => {
     })
   })
 
+  describe('performSerialBatchActions', () => {
+    it('returns array of PromiseSettledResults', async () => {
+      const results = await NpmRegClientBatchWrapper.performSerialBatchActions(
+        [1, 2, 3],
+        (value) => Promise.resolve(value)
+      )
+      expect(results).toEqual([
+        {
+          status: 'fulfilled',
+          value: 1,
+        },
+        {
+          status: 'fulfilled',
+          value: 2,
+        },
+        {
+          status: 'fulfilled',
+          value: 3,
+        },
+      ])
+    })
+  })
+
   describe('batch methods', () => {
     const batchMethods = [
       'deprecate',
@@ -72,8 +95,8 @@ describe('NpmRegClientBatchWrapper', () => {
         const performBatchActionsSpy = jest.spyOn(NpmRegClientBatchWrapper, 'performBatchActions')
           .mockImplementation(() => Promise.resolve([]))
         // @ts-ignore
-        await batchWrapper[method]([], true)
-        expect(performBatchActionsSpy).toHaveBeenCalledWith([], expect.any(Function), true)
+        await batchWrapper[method]([], true, false)
+        expect(performBatchActionsSpy).toHaveBeenCalledWith([], expect.any(Function), true, false)
       })
     )
   })