chrome-webstore-upload 4.0.3 → 5.0.0

package/distribution/errors.js

@@ -22,18 +22,10 @@ function parseErrorMessage(response) {
             return error.message.replace(/^Publish condition not met: /, '');
         }
     }
-    // Handle item errors in ItemResource: { itemError: [{ error_code: "...", error_detail: "..." }] }
-    const itemResource = response;
-    if (itemResource.itemError && Array.isArray(itemResource.itemError) && itemResource.itemError.length > 0) {
-        const errorDetails = itemResource.itemError.map(error => error.error_detail).join('; ');
-        return errorDetails;
-    }
     return 'Unknown error';
 }
 export function throwIfNotOk(request, response) {
-    // Check for upload failure even on HTTP 200
-    const itemResource = response;
-    if (!request.ok || itemResource.uploadState === 'FAILURE') {
+    if (!request.ok) {
         const message = parseErrorMessage(response);
         const error = new CWSError(message);
         error.cause = response;

package/distribution/index.d.ts

@@ -1,26 +1,27 @@
 import { type ReadStream } from 'node:fs';
-import type { APIClientOptions, ItemResource, PublishResponse } from './types.js';
+import type { APIClientOptions, ItemResource, ItemStatusResponse, PublishResponse, PublishType } from './types.js';
 export declare const refreshTokenURI = "https://www.googleapis.com/oauth2/v4/token";
-export type { APIClientOptions, ItemResource, PublishResponse } from './types.js';
+export type { APIClientOptions, ItemResource, ItemStatusResponse, PublishResponse, PublishType, } from './types.js';
 export { CWSError } from './errors.js';
 declare class APIClient {
     extensionId: string;
+    publisherId: string;
     clientId: string;
     refreshToken: string;
     clientSecret: string | undefined;
     constructor(options: APIClientOptions);
     uploadExisting(streamOrPath: ReadStream | ReadableStream | string, token?: string | Promise<string>, maxAwaitInProgressResponseSeconds?: number): Promise<ItemResource>;
-    publish(target?: string, token?: string | Promise<string>, deployPercentage?: number | undefined): Promise<PublishResponse>;
-    get(projection?: string, token?: string | Promise<string>): Promise<ItemResource>;
+    publish(publishType?: PublishType | 'default' | 'trustedTesters', token?: string | Promise<string>, deployPercentage?: number | undefined): Promise<PublishResponse>;
+    setDeployPercentage(deployPercentage: number, token?: string | Promise<string>): Promise<void>;
+    get(token?: string | Promise<string>): Promise<ItemStatusResponse>;
     fetchToken(): Promise<string>;
     _waitUploadSuccess(response: ItemResource, maxAwaitInProgressResponseSeconds: number): Promise<ItemResource>;
+    _normalizePublishType(target: PublishType | 'default' | 'trustedTesters'): PublishType;
     _headers(token: string): {
         Authorization: string;
-        'x-goog-api-version': string;
     };
     _uploadHeaders(token: string, fileName: string): {
         Authorization: string;
-        'x-goog-api-version': string;
         'X-Goog-Upload-Protocol': string;
         'X-Goog-Upload-File-Name': string;
     };

package/distribution/index.js

@@ -4,19 +4,14 @@
 import fs from 'node:fs';
 import { throwIfNotOk } from './errors.js';
 import zipStreamFromDirectory from './zip-dir.js';
-const rootURI = 'https://www.googleapis.com';
+const rootURI = 'https://chromewebstore.googleapis.com';
 export const refreshTokenURI = 'https://www.googleapis.com/oauth2/v4/token';
-const uploadExistingURI = (id) => `${rootURI}/upload/chromewebstore/v1.1/items/${id}`;
-const publishURI = ({ extensionId, target = 'default', deployPercentage }) => {
-    const url = new URL(`${rootURI}/chromewebstore/v1.1/items/${extensionId}/publish`);
-    url.searchParams.set('publishTarget', target);
-    if (deployPercentage !== undefined) {
-        url.searchParams.set('deployPercentage', String(deployPercentage));
-    }
-    return url.href;
-};
-const getURI = (id, projection) => `${rootURI}/chromewebstore/v1.1/items/${id}?projection=${projection}`;
-const requiredFields = ['extensionId', 'clientId', 'refreshToken'];
+const itemName = (publisherId, extensionId) => `publishers/${publisherId}/items/${extensionId}`;
+const uploadExistingURI = (publisherId, extensionId) => `${rootURI}/upload/v2/${itemName(publisherId, extensionId)}:upload`;
+const publishURI = (publisherId, extensionId) => `${rootURI}/v2/${itemName(publisherId, extensionId)}:publish`;
+const fetchStatusURI = (publisherId, extensionId) => `${rootURI}/v2/${itemName(publisherId, extensionId)}:fetchStatus`;
+const setDeployPercentageURI = (publisherId, extensionId) => `${rootURI}/v2/${itemName(publisherId, extensionId)}:setPublishedDeployPercentage`;
+const requiredFields = ['extensionId', 'publisherId', 'clientId', 'refreshToken'];
 const retryIntervalSeconds = 2;
 async function getStreamFromPath(filepath) {
     const stats = await fs.promises.stat(filepath);
@@ -27,6 +22,7 @@ async function getStreamFromPath(filepath) {
 export { CWSError } from './errors.js';
 class APIClient {
     extensionId;
+    publisherId;
     clientId;
     refreshToken;
     clientSecret;
@@ -43,6 +39,7 @@ class APIClient {
             }
         }
         this.extensionId = options.extensionId;
+        this.publisherId = options.publisherId;
         this.clientId = options.clientId;
         this.refreshToken = options.refreshToken;
         this.clientSecret = options.clientSecret;
@@ -56,9 +53,9 @@ class APIClient {
         const readStream = typeof streamOrPath === 'string'
             ? await getStreamFromPath(streamOrPath)
             : streamOrPath;
-        const { extensionId } = this;
-        const request = await fetch(uploadExistingURI(extensionId), {
-            method: 'PUT',
+        const { extensionId, publisherId } = this;
+        const request = await fetch(uploadExistingURI(publisherId, extensionId), {
+            method: 'POST',
             headers: this._uploadHeaders(await token, fileName),
             // @ts-expect-error Node extension? 🤷‍♂️ Required https://github.com/nodejs/node/issues/46221
             duplex: 'half',
@@ -69,19 +66,42 @@ class APIClient {
         throwIfNotOk(request, response);
         return this._waitUploadSuccess(response, maxAwaitInProgressResponseSeconds);
     }
-    async publish(target = 'default', token = this.fetchToken(), deployPercentage = undefined) {
-        const { extensionId } = this;
-        const request = await fetch(publishURI({ extensionId, target, deployPercentage }), {
+    async publish(publishType = 'DEFAULT_PUBLISH', token = this.fetchToken(), deployPercentage = undefined) {
+        const { extensionId, publisherId } = this;
+        const body = {
+            publishType: this._normalizePublishType(publishType),
+        };
+        if (deployPercentage !== undefined) {
+            body.deployInfos = [{ deployPercentage }];
+        }
+        const request = await fetch(publishURI(publisherId, extensionId), {
             method: 'POST',
-            headers: this._headers(await token),
+            headers: {
+                ...this._headers(await token),
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(body),
         });
         const response = await request.json();
         throwIfNotOk(request, response);
         return response;
     }
-    async get(projection = 'DRAFT', token = this.fetchToken()) {
-        const { extensionId } = this;
-        const request = await fetch(getURI(extensionId, projection), {
+    async setDeployPercentage(deployPercentage, token = this.fetchToken()) {
+        const { extensionId, publisherId } = this;
+        const request = await fetch(setDeployPercentageURI(publisherId, extensionId), {
+            method: 'POST',
+            headers: {
+                ...this._headers(await token),
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ deployPercentage }),
+        });
+        const response = await request.json();
+        throwIfNotOk(request, response);
+    }
+    async get(token = this.fetchToken()) {
+        const { extensionId, publisherId } = this;
+        const request = await fetch(fetchStatusURI(publisherId, extensionId), {
             method: 'GET',
             headers: this._headers(await token),
         });
@@ -112,7 +132,7 @@ class APIClient {
         return response.access_token;
     }
     async _waitUploadSuccess(response, maxAwaitInProgressResponseSeconds) {
-        if (response.uploadState !== 'IN_PROGRESS' || maxAwaitInProgressResponseSeconds < retryIntervalSeconds) {
+        if (response.uploadState !== 'UPLOAD_IN_PROGRESS' || maxAwaitInProgressResponseSeconds < retryIntervalSeconds) {
             return response;
         }
         // Wait before checking again
@@ -120,12 +140,27 @@ class APIClient {
             setTimeout(resolve, retryIntervalSeconds * 1000);
         });
         // Retry fetching the item resource
-        return this._waitUploadSuccess(await this.get('DRAFT'), maxAwaitInProgressResponseSeconds - retryIntervalSeconds);
+        const statusResponse = await this.get();
+        const retryResponse = {
+            crxVersion: response.crxVersion,
+            itemId: response.itemId,
+            name: response.name,
+            uploadState: statusResponse.lastAsyncUploadState,
+        };
+        return this._waitUploadSuccess(retryResponse, maxAwaitInProgressResponseSeconds - retryIntervalSeconds);
+    }
+    _normalizePublishType(target) {
+        if (target === 'default') {
+            return 'DEFAULT_PUBLISH';
+        }
+        if (target === 'trustedTesters') {
+            return 'TRUSTED_TESTERS';
+        }
+        return target;
     }
     _headers(token) {
         return {
             Authorization: `Bearer ${token}`,
-            'x-goog-api-version': '2',
         };
     }
     _uploadHeaders(token, fileName) {

package/distribution/types.d.ts

@@ -1,22 +1,28 @@
 export type APIClientOptions = {
     extensionId: string;
+    publisherId: string;
     clientId: string;
     refreshToken: string;
     clientSecret: string | undefined;
 };
 export type ItemResource = {
-    kind: 'chromewebstore#item';
-    id: string;
-    publicKey: string;
-    uploadState: 'FAILURE' | 'IN_PROGRESS' | 'NOT_FOUND' | 'SUCCESS';
-    itemError: Array<{
-        error_code: string;
-        error_detail: string;
-    }>;
+    crxVersion: string;
+    itemId: string;
+    name: string;
+    uploadState: string;
 };
+export type PublishType = 'PUBLISH_TYPE_UNSPECIFIED' | 'DEFAULT_PUBLISH' | 'TRUSTED_TESTERS' | 'STAGED_PUBLISH';
 export type PublishResponse = {
-    kind: 'chromewebstore#item';
-    item_id: string;
-    status: Array<'OK' | 'NOT_AUTHORIZED' | 'INVALID_DEVELOPER' | 'DEVELOPER_NO_OWNERSHIP' | 'DEVELOPER_SUSPENDED' | 'ITEM_NOT_FOUND' | 'ITEM_PENDING_REVIEW' | 'ITEM_TAKEN_DOWN' | 'PUBLISHER_SUSPENDED'>;
-    statusDetail: string[];
+    itemId: string;
+    name: string;
+    state: string;
+};
+export type ItemStatusResponse = {
+    itemId: string;
+    lastAsyncUploadState: string;
+    name: string;
+    publicKey: string;
+    publishedItemRevisionStatus: unknown;
+    submittedItemRevisionStatus: unknown;
+    takenDown: boolean;
 };

package/distribution/zip-dir.js

@@ -1,10 +1,12 @@
 import { readdir } from 'node:fs/promises';
-import { basename, join } from 'node:path';
+import { join, relative } from 'node:path';
 import { isNotJunk } from 'junk';
 import yazl from 'yazl';
 export default async function zipStreamFromDirectory(directory) {
-    const allFiles = await readdir(directory, { recursive: true });
-    const files = allFiles.filter(file => isNotJunk(basename(file)));
+    const entries = await readdir(directory, { recursive: true, withFileTypes: true });
+    const files = entries
+        .filter(entry => entry.isFile() && isNotJunk(entry.name))
+        .map(entry => relative(directory, join(entry.parentPath, entry.name)));
     if (!files.includes('manifest.json')) {
         throw new Error(`manifest.json was not found in ${directory}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chrome-webstore-upload",
-  "version": "4.0.3",
+  "version": "5.0.0",
   "description": "Upload Chrome Extensions to the Chrome Web Store",
   "keywords": [
     "chrome",

package/readme.md

@@ -14,6 +14,8 @@ npm install --save-dev chrome-webstore-upload
 
 You will need a Google API `clientId`, `clientSecret` and `refreshToken`. Use [the guide]( https://github.com/fregante/chrome-webstore-upload-keys).
 
+You also need your Chrome Web Store `publisherId` (your developer account identifier, not the extension ID). You can find it in the Chrome Web Store Developer Dashboard URL when logged in.
+
 ## Usage
 
 All methods return a  promise.
@@ -25,6 +27,7 @@ import chromeWebstoreUpload from 'chrome-webstore-upload';
 
 const store = chromeWebstoreUpload({
   extensionId: 'ecnglinljpjkbgmdpeiglonddahpbkeb',
+  publisherId: 'your-publisher-id',
   clientId: 'xxxxxxxxxx',
   clientSecret: 'xxxxxxxxxx',
   refreshToken: 'xxxxxxxxxx',
@@ -44,7 +47,7 @@ const token = 'xxxx'; // optional. One will be fetched if not provided
 const maxAwaitInProgressResponseSeconds = 60; // optional. If the API response is IN_PROGRESS, this method will wait until it becomes successful, or until the specified timeout
 const response = await store.uploadExisting(myZipFile, token, maxAwaitInProgressResponseSeconds);
 // response is a Resource Representation
-// https://developer.chrome.com/webstore/webstore_api/items#resource
+// https://developer.chrome.com/docs/webstore/api/reference/rest/v2/publishers.items/upload
 ```
 
 ```javascript
@@ -63,22 +66,32 @@ const response = await store.uploadExisting('./path/to/extension.crx', token, ma
 ### Publish extension
 
 ```javascript
-const target = 'default'; // optional. Can also be 'trustedTesters'
+const publishType = 'DEFAULT_PUBLISH'; // optional. Can also be 'TRUSTED_TESTERS' or 'STAGED_PUBLISH'
 const token = 'xxxx'; // optional. One will be fetched if not provided
-const deployPercentage = 25; // optional. Will default to 100%.
-const response = await store.publish(target, token, deployPercentage);
+const deployPercentage = 25; // optional. Sets the initial rollout percentage.
+const response = await store.publish(publishType, token, deployPercentage);
 // response is documented here:
-// https://developer.chrome.com/webstore/webstore_api/items#publish
+// https://developer.chrome.com/docs/webstore/api/reference/rest/v2/publishers.items/publish
+```
+
+### Set deployment rollout percentage
+
+Update the deployment percentage for an already-published extension without triggering a re-review:
+
+```javascript
+const deployPercentage = 50; // required. Must be higher than the current value.
+const token = 'xxxx'; // optional. One will be fetched if not provided
+await store.setDeployPercentage(deployPercentage, token);
+// https://developer.chrome.com/docs/webstore/api/reference/rest/v2/publishers.items/setPublishedDeployPercentage
 ```
 
-### Get a Chrome Web Store item
+### Get Chrome Web Store item status
 
 ```javascript
-const projection = "DRAFT"; // optional. Can also be 'PUBLISHED' but only "DRAFT" is supported at this time.
 const token = "xxxx"; // optional. One will be fetched if not provided
-const response = await store.get(projection, token);
+const response = await store.get(token);
 // response is documented here:
-// https://developer.chrome.com/docs/webstore/webstore_api/items#get
+// https://developer.chrome.com/docs/webstore/api/reference/rest/v2/publishers.items/fetchStatus
 ```
 
 ### Fetch token