netlify 12.0.0 → 12.0.2

package/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2020 Netlify <team@netlify.com>
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,8 +1,3 @@
-![netlify/js-client](js-client.png)
-
-[![npm version][npm-img]][npm] [![build status][build-img]][build] [![coverage][coverage-img]][coverage]
-[![dependencies][david-img]][david] [![downloads][dl-img]][dl]
-
 A Netlify [OpenAPI](https://github.com/netlify/open-api) client that works in the browser and Node.js.
 
 ## Usage
@@ -182,21 +177,6 @@ const client = new NetlifyAPI('1234myAccessToken', { agent })
 Support for site deployment has been removed from this package in version 7.0.0. You should consider using the
 [`deploy` command](https://cli.netlify.com/commands/deploy/) of Netlify CLI.
 
-## Contributing
-
-See [CONTRIBUTING.md](CONTRIBUTING.md) for more info on how to make contributions to this project.
-
 ## License
 
-MIT. See [LICENSE](LICENSE) for more details.
-
-[npm-img]: https://img.shields.io/npm/v/netlify.svg
-[npm]: https://npmjs.org/package/netlify
-[build-img]: https://github.com/netlify/js-client/workflows/Build/badge.svg
-[build]: https://github.com/netlify/js-client/actions
-[dl-img]: https://img.shields.io/npm/dm/netlify.svg
-[dl]: https://npmjs.org/package/netlify
-[coverage-img]: https://codecov.io/gh/netlify/js-client/branch/main/graph/badge.svg
-[coverage]: https://codecov.io/gh/netlify/js-client
-[david-img]: https://david-dm.org/netlify/js-client/status.svg
-[david]: https://david-dm.org/netlify/js-client
+MIT. See [LICENSE](./LICENSE) for more details.

package/lib/index.d.ts

@@ -0,0 +1,11 @@
+export class NetlifyAPI {
+    constructor(firstArg: any, secondArg: any);
+    set accessToken(arg: string);
+    get accessToken(): string;
+    get basePath(): string;
+    getAccessToken(ticket: any, { poll, timeout }?: {
+        poll?: number;
+        timeout?: number;
+    }): Promise<any>;
+}
+export const methods: any[];

package/lib/index.js

@@ -0,0 +1,65 @@
+import pWaitFor from 'p-wait-for';
+import { getMethods } from './methods/index.js';
+import { openApiSpec } from './open_api.js';
+import { getOperations } from './operations.js';
+export class NetlifyAPI {
+    constructor(firstArg, secondArg) {
+        // variadic arguments
+        const [accessTokenInput, opts = {}] = typeof firstArg === 'object' ? [null, firstArg] : [firstArg, secondArg];
+        // default opts
+        const { userAgent = 'netlify/js-client', scheme = openApiSpec.schemes[0], host = openApiSpec.host, pathPrefix = openApiSpec.basePath, accessToken = accessTokenInput, globalParams = {}, agent, } = opts;
+        const defaultHeaders = {
+            'User-agent': userAgent,
+            accept: 'application/json',
+        };
+        const basePath = getBasePath({ scheme, host, pathPrefix });
+        const methods = getMethods({ basePath, defaultHeaders, agent, globalParams });
+        Object.assign(this, { ...methods, defaultHeaders, scheme, host, pathPrefix, globalParams, accessToken, agent });
+    }
+    get accessToken() {
+        const { defaultHeaders: { Authorization }, } = this;
+        if (typeof Authorization !== 'string' || !Authorization.startsWith('Bearer ')) {
+            return null;
+        }
+        return Authorization.replace('Bearer ', '');
+    }
+    set accessToken(token) {
+        if (!token) {
+            delete this.defaultHeaders.Authorization;
+            return;
+        }
+        this.defaultHeaders.Authorization = `Bearer ${token}`;
+    }
+    get basePath() {
+        return getBasePath({ scheme: this.scheme, host: this.host, pathPrefix: this.pathPrefix });
+    }
+    async getAccessToken(ticket, { poll = DEFAULT_TICKET_POLL, timeout = DEFAULT_TICKET_TIMEOUT } = {}) {
+        const { id } = ticket;
+        // ticket capture
+        let authorizedTicket;
+        const checkTicket = async () => {
+            const t = await this.showTicket({ ticketId: id });
+            if (t.authorized) {
+                authorizedTicket = t;
+            }
+            return Boolean(t.authorized);
+        };
+        await pWaitFor(checkTicket, {
+            interval: poll,
+            timeout,
+            message: 'Timeout while waiting for ticket grant',
+        });
+        const accessTokenResponse = await this.exchangeTicket({ ticketId: authorizedTicket.id });
+        // See https://open-api.netlify.com/#/default/exchangeTicket for shape
+        this.accessToken = accessTokenResponse.access_token;
+        return accessTokenResponse.access_token;
+    }
+}
+const getBasePath = function ({ scheme, host, pathPrefix }) {
+    return `${scheme}://${host}${pathPrefix}`;
+};
+// 1 second
+const DEFAULT_TICKET_POLL = 1e3;
+// 1 hour
+const DEFAULT_TICKET_TIMEOUT = 3.6e6;
+export const methods = getOperations();

package/lib/methods/body.d.ts

@@ -0,0 +1 @@
+export function addBody(body: any, parameters: any, opts: any): any;

package/lib/methods/body.js

@@ -0,0 +1,25 @@
+// Handle request body
+export const addBody = function (body, parameters, opts) {
+    if (!body) {
+        return opts;
+    }
+    const bodyA = typeof body === 'function' ? body() : body;
+    if (isBinaryBody(parameters)) {
+        return {
+            ...opts,
+            body: bodyA,
+            headers: { 'Content-Type': 'application/octet-stream', ...opts.headers },
+        };
+    }
+    return {
+        ...opts,
+        body: JSON.stringify(bodyA),
+        headers: { 'Content-Type': 'application/json', ...opts.headers },
+    };
+};
+const isBinaryBody = function (parameters) {
+    return Object.values(parameters.body).some(isBodyParam);
+};
+const isBodyParam = function ({ schema }) {
+    return schema && schema.format === 'binary';
+};

package/lib/methods/index.d.ts

@@ -0,0 +1,6 @@
+export function getMethods({ basePath, defaultHeaders, agent, globalParams }: {
+    basePath: any;
+    defaultHeaders: any;
+    agent: any;
+    globalParams: any;
+}): any;

package/lib/methods/index.js

@@ -0,0 +1,84 @@
+import fetch from 'node-fetch';
+import { getOperations } from '../operations.js';
+import { addBody } from './body.js';
+import { getRequestParams } from './params.js';
+import { parseResponse, getFetchError } from './response.js';
+import { shouldRetry, waitForRetry, MAX_RETRY } from './retry.js';
+import { getUrl } from './url.js';
+// For each OpenAPI operation, add a corresponding method.
+// The `operationId` is the method name.
+export const getMethods = function ({ basePath, defaultHeaders, agent, globalParams }) {
+    const operations = getOperations();
+    const methods = operations.map((method) => getMethod({ method, basePath, defaultHeaders, agent, globalParams }));
+    return Object.assign({}, ...methods);
+};
+const getMethod = function ({ method, basePath, defaultHeaders, agent, globalParams }) {
+    return {
+        [method.operationId](params, opts) {
+            return callMethod({ method, basePath, defaultHeaders, agent, globalParams, params, opts });
+        },
+    };
+};
+const callMethod = async function ({ method, basePath, defaultHeaders, agent, globalParams, params, opts }) {
+    const requestParams = { ...globalParams, ...params };
+    const url = getUrl(method, basePath, requestParams);
+    const response = await makeRequestOrRetry({ url, method, defaultHeaders, agent, requestParams, opts });
+    const parsedResponse = await parseResponse(response);
+    return parsedResponse;
+};
+const getOpts = function ({ method: { verb, parameters }, defaultHeaders, agent, requestParams, opts }) {
+    const { body } = requestParams;
+    const optsA = addHttpMethod(verb, opts);
+    const optsB = addHeaderParams(parameters, requestParams, optsA);
+    const optsC = addDefaultHeaders(defaultHeaders, optsB);
+    const optsD = addBody(body, parameters, optsC);
+    const optsE = addAgent(agent, optsD);
+    return optsE;
+};
+// Add header parameters
+const addHeaderParams = function (parameters, requestParams, opts) {
+    if (parameters.header === undefined) {
+        return opts;
+    }
+    return { ...opts, headers: getRequestParams(parameters.header, requestParams, 'header parameter') };
+};
+// Add the HTTP method based on the OpenAPI definition
+const addHttpMethod = function (verb, opts) {
+    return { ...opts, method: verb.toUpperCase() };
+};
+// Assign default HTTP headers
+const addDefaultHeaders = function (defaultHeaders, opts) {
+    return { ...opts, headers: { ...defaultHeaders, ...opts.headers } };
+};
+// Assign fetch agent (like for example HttpsProxyAgent) if there is one
+const addAgent = function (agent, opts) {
+    if (agent) {
+        return { ...opts, agent };
+    }
+    return opts;
+};
+const makeRequestOrRetry = async function ({ url, method, defaultHeaders, agent, requestParams, opts }) {
+    // Using a loop is simpler here
+    for (let index = 0; index <= MAX_RETRY; index++) {
+        const optsA = getOpts({ method, defaultHeaders, agent, requestParams, opts });
+        const { response, error } = await makeRequest(url, optsA);
+        if (shouldRetry({ response, error, method }) && index !== MAX_RETRY) {
+            await waitForRetry(response);
+            continue;
+        }
+        if (error !== undefined) {
+            throw error;
+        }
+        return response;
+    }
+};
+const makeRequest = async function (url, opts) {
+    try {
+        const response = await fetch(url, opts);
+        return { response };
+    }
+    catch (error) {
+        const errorA = getFetchError(error, url, opts);
+        return { error: errorA };
+    }
+};

package/lib/methods/params.d.ts

@@ -0,0 +1 @@
+export function getRequestParams(params: any, requestParams: any, name: any): any;

package/lib/methods/params.js

@@ -0,0 +1,14 @@
+import { camelCase } from 'lodash-es';
+export const getRequestParams = function (params, requestParams, name) {
+    const entries = Object.values(params).map((param) => getRequestParam(param, requestParams, name));
+    return Object.assign({}, ...entries);
+};
+const getRequestParam = function (param, requestParams, name) {
+    const value = requestParams[param.name] || requestParams[camelCase(param.name)];
+    if (value !== undefined) {
+        return { [param.name]: value };
+    }
+    if (param.required) {
+        throw new Error(`Missing required ${name} '${param.name}'`);
+    }
+};

package/lib/methods/response.d.ts

@@ -0,0 +1,2 @@
+export function parseResponse(response: any): Promise<any>;
+export function getFetchError(error: any, url: any, opts: any): any;

package/lib/methods/response.js

@@ -0,0 +1,44 @@
+import { JSONHTTPError, TextHTTPError } from 'micro-api-client';
+import omit from 'omit.js';
+// Read and parse the HTTP response
+export const parseResponse = async function (response) {
+    const responseType = getResponseType(response);
+    const textResponse = await response.text();
+    const parsedResponse = parseJsonResponse(response, textResponse, responseType);
+    if (!response.ok) {
+        const ErrorType = responseType === 'json' ? JSONHTTPError : TextHTTPError;
+        throw addFallbackErrorMessage(new ErrorType(response, parsedResponse), textResponse);
+    }
+    return parsedResponse;
+};
+const getResponseType = function ({ headers }) {
+    const contentType = headers.get('Content-Type');
+    if (contentType != null && contentType.includes('json')) {
+        return 'json';
+    }
+    return 'text';
+};
+const parseJsonResponse = function (response, textResponse, responseType) {
+    if (responseType === 'text') {
+        return textResponse;
+    }
+    try {
+        return JSON.parse(textResponse);
+    }
+    catch {
+        throw addFallbackErrorMessage(new TextHTTPError(response, textResponse), textResponse);
+    }
+};
+const addFallbackErrorMessage = function (error, textResponse) {
+    error.message = error.message || textResponse;
+    return error;
+};
+export const getFetchError = function (error, url, opts) {
+    const data = omit.default(opts, ['Authorization']);
+    if (error.name !== 'FetchError') {
+        error.name = 'FetchError';
+    }
+    error.url = url;
+    error.data = data;
+    return error;
+};

package/lib/methods/retry.d.ts

@@ -0,0 +1,7 @@
+export function shouldRetry({ response, error, method }: {
+    response?: {};
+    error?: {};
+    method?: {};
+}): boolean;
+export function waitForRetry(response: any): Promise<void>;
+export const MAX_RETRY: 5;

package/lib/methods/retry.js

@@ -0,0 +1,40 @@
+// We retry:
+//  - when receiving a rate limiting response
+//  - on network failures due to timeouts
+export const shouldRetry = function ({ response = {}, error = {}, method = {} }) {
+    if (response.status === RATE_LIMIT_STATUS || RETRY_ERROR_CODES.has(error.code)) {
+        return true;
+    }
+    // Special case for the `getLatestPluginRuns` endpoint.
+    // See https://github.com/netlify/bitballoon/issues/9616.
+    if (method.operationId === 'getLatestPluginRuns' && response.status === 500) {
+        return true;
+    }
+    return false;
+};
+export const waitForRetry = async function (response) {
+    const delay = getDelay(response);
+    await sleep(delay);
+};
+const getDelay = function (response) {
+    if (response === undefined) {
+        return DEFAULT_RETRY_DELAY;
+    }
+    const rateLimitReset = response.headers.get(RATE_LIMIT_HEADER);
+    if (!rateLimitReset) {
+        return DEFAULT_RETRY_DELAY;
+    }
+    return Math.max(Number(rateLimitReset) * SECS_TO_MSECS - Date.now(), MIN_RETRY_DELAY);
+};
+const sleep = function (ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+};
+const DEFAULT_RETRY_DELAY = 5e3;
+const MIN_RETRY_DELAY = 1e3;
+const SECS_TO_MSECS = 1e3;
+export const MAX_RETRY = 5;
+const RATE_LIMIT_STATUS = 429;
+const RATE_LIMIT_HEADER = 'X-RateLimit-Reset';
+const RETRY_ERROR_CODES = new Set(['ETIMEDOUT', 'ECONNRESET']);

package/lib/methods/url.d.ts

@@ -0,0 +1,4 @@
+export function getUrl({ path, parameters }: {
+    path: any;
+    parameters: any;
+}, basePath: any, requestParams: any): any;

package/lib/methods/url.js

@@ -0,0 +1,24 @@
+import queryString from 'qs';
+import { getRequestParams } from './params.js';
+// Replace path parameters and query parameters in the URI, using the OpenAPI
+// definition
+export const getUrl = function ({ path, parameters }, basePath, requestParams) {
+    const url = `${basePath}${path}`;
+    const urlA = addPathParams(url, parameters, requestParams);
+    const urlB = addQueryParams(urlA, parameters, requestParams);
+    return urlB;
+};
+const addPathParams = function (url, parameters, requestParams) {
+    const pathParams = getRequestParams(parameters.path, requestParams, 'path variable');
+    return Object.entries(pathParams).reduce(addPathParam, url);
+};
+const addPathParam = function (url, [name, value]) {
+    return url.replace(`{${name}}`, value);
+};
+const addQueryParams = function (url, parameters, requestParams) {
+    const queryParams = getRequestParams(parameters.query, requestParams, 'query variable');
+    if (Object.keys(queryParams).length === 0) {
+        return url;
+    }
+    return `${url}?${queryString.stringify(queryParams, { arrayFormat: 'brackets' })}`;
+};

package/lib/open_api.d.ts

@@ -0,0 +1 @@
+export const openApiSpec: any;

package/lib/open_api.js

@@ -0,0 +1,5 @@
+import { createRequire } from 'module';
+// TODO: remove once Node.js supports JSON imports with pure ES modules without
+// any experimental flags
+const require = createRequire(import.meta.url);
+export const openApiSpec = require('@netlify/open-api');

package/lib/operations.d.ts

@@ -0,0 +1 @@
+export function getOperations(): any[];

package/lib/operations.js

@@ -0,0 +1,19 @@
+import omit from 'omit.js';
+import { openApiSpec } from './open_api.js';
+// Retrieve all OpenAPI operations
+export const getOperations = function () {
+    return Object.entries(openApiSpec.paths).flatMap(([path, pathItem]) => {
+        const operations = omit.default(pathItem, ['parameters']);
+        return Object.entries(operations).map(([method, operation]) => {
+            const parameters = getParameters(pathItem.parameters, operation.parameters);
+            return { ...operation, verb: method, path, parameters };
+        });
+    });
+};
+const getParameters = function (pathParameters = [], operationParameters = []) {
+    const parameters = [...pathParameters, ...operationParameters];
+    return parameters.reduce(addParameter, { path: {}, query: {}, body: {} });
+};
+const addParameter = function (parameters, param) {
+    return { ...parameters, [param.in]: { ...parameters[param.in], [param.name]: param } };
+};

package/package.json

@@ -1,33 +1,19 @@
 {
   "name": "netlify",
   "description": "Netlify Node.js API client",
-  "version": "12.0.0",
+  "version": "12.0.2",
   "type": "module",
+  "exports": "./lib/index.js",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
   "files": [
-    "src/**/*.js",
-    "!src/**/*.test.js"
+    "lib/**"
   ],
-  "exports": "./src/index.js",
-  "main": "./src/index.js",
   "scripts": {
-    "prepare": "husky install node_modules/@netlify/eslint-config-node/.husky/",
-    "prepublishOnly": "npm ci && npm test",
-    "test": "run-s format test:dev",
-    "format": "run-s format:check-fix:*",
-    "format:ci": "run-s format:check:*",
-    "format:check-fix:lint": "run-e format:check:lint format:fix:lint",
-    "format:check:lint": "cross-env-shell eslint $npm_package_config_eslint",
-    "format:fix:lint": "cross-env-shell eslint --fix $npm_package_config_eslint",
-    "format:check-fix:prettier": "run-e format:check:prettier format:fix:prettier",
-    "format:check:prettier": "cross-env-shell prettier --check $npm_package_config_prettier",
-    "format:fix:prettier": "cross-env-shell prettier --write $npm_package_config_prettier",
-    "test:dev": "ava",
-    "test:ci": "c8 -r lcovonly -r text -r json ava",
-    "update-snapshots": "ava -u"
-  },
-  "config": {
-    "eslint": "--ignore-path .gitignore --cache --format=codeframe --max-warnings=0 \"{src,tests,.github}/**/*.{cjs,mjs,js,md,html}\" \"*.{cjs,mjs,js,md,html}\" \".*.{cjs,mjs,js,md,html}\"",
-    "prettier": "--ignore-path .gitignore --loglevel=warn \"{src,tests,.github}/**/*.{cjs,mjs,js,md,yml,json,html}\" \"*.{cjs,mjs,js,yml,json,html}\" \".*.{cjs,mjs,js,yml,json,html}\" \"!package-lock.json\" \"!CHANGELOG.md\""
+    "prebuild": "rm -rf lib",
+    "build": "tsc",
+    "test": "ava",
+    "test:ci": "c8 -r lcovonly -r text -r json ava"
   },
   "license": "MIT",
   "author": "Netlify Inc.",
@@ -35,15 +21,16 @@
     "Mathias Biilmann <matt@netlify.com> (https://twitter.com/biilmann)",
     "David Calavera <david@netlify.com> (https://twitter.com/calavera)",
     "David Wells <david.wells@netlify.com> (https://davidwells.io/)",
-    "Bret Comnes <bcomnes@gmail.com> (https://bret.io)"
+    "Bret Comnes <bcomnes@gmail.com> (https://bret.io)",
+    "Lukas Holzer <lukas.holzer@netlify.com> (https://twitter.com/luka5c0m)"
   ],
-  "homepage": "https://github.com/netlify/js-client",
+  "homepage": "https://github.com/netlify/build",
   "repository": {
     "type": "git",
-    "url": "https://github.com/netlify/js-client.git"
+    "url": "https://github.com/netlify/build.git"
   },
   "bugs": {
-    "url": "https://github.com/netlify/js-client/issues"
+    "url": "https://github.com/netlify/build/issues"
   },
   "keywords": [
     "api client",
@@ -52,8 +39,7 @@
     "node client"
   ],
   "dependencies": {
-    "@netlify/open-api": "^2.11.0",
-    "lodash.camelcase": "^4.3.0",
+    "@netlify/open-api": "^2.12.0",
     "micro-api-client": "^3.3.0",
     "node-fetch": "^3.0.0",
     "omit.js": "^2.0.2",
@@ -61,23 +47,14 @@
     "qs": "^6.9.6"
   },
   "devDependencies": {
-    "@netlify/eslint-config-node": "^7.0.0",
     "ava": "^4.0.0",
     "c8": "^7.11.0",
     "from2-string": "^1.1.0",
-    "husky": "^8.0.0",
     "nock": "^13.0.0",
-    "npm-run-all": "^4.1.5",
     "uuid": "^8.3.2"
   },
   "engines": {
     "node": "^12.20.0 || ^14.14.0 || >=16.0.0"
   },
-  "ava": {
-    "files": [
-      "src/**/*.test.js"
-    ],
-    "verbose": true,
-    "workerThreads": false
-  }
+  "gitHead": "5555ff52d82f1c26f2074ee52d5e7c5c6c8d02d2"
 }

package/src/index.js

@@ -1,92 +0,0 @@
-import pWaitFor from 'p-wait-for'
-
-import { getMethods } from './methods/index.js'
-import { openApiSpec } from './open_api.js'
-import { getOperations } from './operations.js'
-
-export class NetlifyAPI {
-  constructor(firstArg, secondArg) {
-    // variadic arguments
-    const [accessTokenInput, opts = {}] = typeof firstArg === 'object' ? [null, firstArg] : [firstArg, secondArg]
-
-    // default opts
-    const {
-      userAgent = 'netlify/js-client',
-      scheme = openApiSpec.schemes[0],
-      host = openApiSpec.host,
-      pathPrefix = openApiSpec.basePath,
-      accessToken = accessTokenInput,
-      globalParams = {},
-      agent,
-    } = opts
-
-    const defaultHeaders = {
-      'User-agent': userAgent,
-      accept: 'application/json',
-    }
-
-    const basePath = getBasePath({ scheme, host, pathPrefix })
-    const methods = getMethods({ basePath, defaultHeaders, agent, globalParams })
-    Object.assign(this, { ...methods, defaultHeaders, scheme, host, pathPrefix, globalParams, accessToken, agent })
-  }
-
-  get accessToken() {
-    const {
-      defaultHeaders: { Authorization },
-    } = this
-    if (typeof Authorization !== 'string' || !Authorization.startsWith('Bearer ')) {
-      return null
-    }
-
-    return Authorization.replace('Bearer ', '')
-  }
-
-  set accessToken(token) {
-    if (!token) {
-      delete this.defaultHeaders.Authorization
-      return
-    }
-
-    this.defaultHeaders.Authorization = `Bearer ${token}`
-  }
-
-  get basePath() {
-    return getBasePath({ scheme: this.scheme, host: this.host, pathPrefix: this.pathPrefix })
-  }
-
-  async getAccessToken(ticket, { poll = DEFAULT_TICKET_POLL, timeout = DEFAULT_TICKET_TIMEOUT } = {}) {
-    const { id } = ticket
-
-    // ticket capture
-    let authorizedTicket
-    const checkTicket = async () => {
-      const t = await this.showTicket({ ticketId: id })
-      if (t.authorized) {
-        authorizedTicket = t
-      }
-      return Boolean(t.authorized)
-    }
-
-    await pWaitFor(checkTicket, {
-      interval: poll,
-      timeout,
-      message: 'Timeout while waiting for ticket grant',
-    })
-
-    const accessTokenResponse = await this.exchangeTicket({ ticketId: authorizedTicket.id })
-    // See https://open-api.netlify.com/#/default/exchangeTicket for shape
-    this.accessToken = accessTokenResponse.access_token
-    return accessTokenResponse.access_token
-  }
-}
-
-const getBasePath = function ({ scheme, host, pathPrefix }) {
-  return `${scheme}://${host}${pathPrefix}`
-}
-
-// 1 second
-const DEFAULT_TICKET_POLL = 1e3
-// 1 hour
-const DEFAULT_TICKET_TIMEOUT = 3.6e6
-
-export const methods = getOperations()

package/src/methods/body.js

@@ -1,30 +0,0 @@
-// Handle request body
-export const addBody = function (body, parameters, opts) {
-  if (!body) {
-    return opts
-  }
-
-  const bodyA = typeof body === 'function' ? body() : body
-
-  if (isBinaryBody(parameters)) {
-    return {
-      ...opts,
-      body: bodyA,
-      headers: { 'Content-Type': 'application/octet-stream', ...opts.headers },
-    }
-  }
-
-  return {
-    ...opts,
-    body: JSON.stringify(bodyA),
-    headers: { 'Content-Type': 'application/json', ...opts.headers },
-  }
-}
-
-const isBinaryBody = function (parameters) {
-  return Object.values(parameters.body).some(isBodyParam)
-}
-
-const isBodyParam = function ({ schema }) {
-  return schema && schema.format === 'binary'
-}

package/src/methods/index.js

@@ -1,100 +0,0 @@
-import fetch from 'node-fetch'
-
-import { getOperations } from '../operations.js'
-
-import { addBody } from './body.js'
-import { getRequestParams } from './params.js'
-import { parseResponse, getFetchError } from './response.js'
-import { shouldRetry, waitForRetry, MAX_RETRY } from './retry.js'
-import { getUrl } from './url.js'
-
-// For each OpenAPI operation, add a corresponding method.
-// The `operationId` is the method name.
-export const getMethods = function ({ basePath, defaultHeaders, agent, globalParams }) {
-  const operations = getOperations()
-  const methods = operations.map((method) => getMethod({ method, basePath, defaultHeaders, agent, globalParams }))
-  return Object.assign({}, ...methods)
-}
-
-const getMethod = function ({ method, basePath, defaultHeaders, agent, globalParams }) {
-  return {
-    [method.operationId](params, opts) {
-      return callMethod({ method, basePath, defaultHeaders, agent, globalParams, params, opts })
-    },
-  }
-}
-
-const callMethod = async function ({ method, basePath, defaultHeaders, agent, globalParams, params, opts }) {
-  const requestParams = { ...globalParams, ...params }
-  const url = getUrl(method, basePath, requestParams)
-  const response = await makeRequestOrRetry({ url, method, defaultHeaders, agent, requestParams, opts })
-
-  const parsedResponse = await parseResponse(response)
-  return parsedResponse
-}
-
-const getOpts = function ({ method: { verb, parameters }, defaultHeaders, agent, requestParams, opts }) {
-  const { body } = requestParams
-  const optsA = addHttpMethod(verb, opts)
-  const optsB = addHeaderParams(parameters, requestParams, optsA)
-  const optsC = addDefaultHeaders(defaultHeaders, optsB)
-  const optsD = addBody(body, parameters, optsC)
-  const optsE = addAgent(agent, optsD)
-  return optsE
-}
-
-// Add header parameters
-const addHeaderParams = function (parameters, requestParams, opts) {
-  if (parameters.header === undefined) {
-    return opts
-  }
-
-  return { ...opts, headers: getRequestParams(parameters.header, requestParams, 'header parameter') }
-}
-
-// Add the HTTP method based on the OpenAPI definition
-const addHttpMethod = function (verb, opts) {
-  return { ...opts, method: verb.toUpperCase() }
-}
-
-// Assign default HTTP headers
-const addDefaultHeaders = function (defaultHeaders, opts) {
-  return { ...opts, headers: { ...defaultHeaders, ...opts.headers } }
-}
-
-// Assign fetch agent (like for example HttpsProxyAgent) if there is one
-const addAgent = function (agent, opts) {
-  if (agent) {
-    return { ...opts, agent }
-  }
-  return opts
-}
-
-const makeRequestOrRetry = async function ({ url, method, defaultHeaders, agent, requestParams, opts }) {
-  // Using a loop is simpler here
-  for (let index = 0; index <= MAX_RETRY; index++) {
-    const optsA = getOpts({ method, defaultHeaders, agent, requestParams, opts })
-    const { response, error } = await makeRequest(url, optsA)
-
-    if (shouldRetry({ response, error, method }) && index !== MAX_RETRY) {
-      await waitForRetry(response)
-      continue
-    }
-
-    if (error !== undefined) {
-      throw error
-    }
-
-    return response
-  }
-}
-
-const makeRequest = async function (url, opts) {
-  try {
-    const response = await fetch(url, opts)
-    return { response }
-  } catch (error) {
-    const errorA = getFetchError(error, url, opts)
-    return { error: errorA }
-  }
-}

package/src/methods/params.js

@@ -1,18 +0,0 @@
-import camelCase from 'lodash.camelcase'
-
-export const getRequestParams = function (params, requestParams, name) {
-  const entries = Object.values(params).map((param) => getRequestParam(param, requestParams, name))
-  return Object.assign({}, ...entries)
-}
-
-const getRequestParam = function (param, requestParams, name) {
-  const value = requestParams[param.name] || requestParams[camelCase(param.name)]
-
-  if (value !== undefined) {
-    return { [param.name]: value }
-  }
-
-  if (param.required) {
-    throw new Error(`Missing required ${name} '${param.name}'`)
-  }
-}

package/src/methods/response.js

@@ -1,54 +0,0 @@
-import { JSONHTTPError, TextHTTPError } from 'micro-api-client'
-import omit from 'omit.js'
-
-// Read and parse the HTTP response
-export const parseResponse = async function (response) {
-  const responseType = getResponseType(response)
-  const textResponse = await response.text()
-
-  const parsedResponse = parseJsonResponse(response, textResponse, responseType)
-
-  if (!response.ok) {
-    const ErrorType = responseType === 'json' ? JSONHTTPError : TextHTTPError
-    throw addFallbackErrorMessage(new ErrorType(response, parsedResponse), textResponse)
-  }
-
-  return parsedResponse
-}
-
-const getResponseType = function ({ headers }) {
-  const contentType = headers.get('Content-Type')
-
-  if (contentType != null && contentType.includes('json')) {
-    return 'json'
-  }
-
-  return 'text'
-}
-
-const parseJsonResponse = function (response, textResponse, responseType) {
-  if (responseType === 'text') {
-    return textResponse
-  }
-
-  try {
-    return JSON.parse(textResponse)
-  } catch {
-    throw addFallbackErrorMessage(new TextHTTPError(response, textResponse), textResponse)
-  }
-}
-
-const addFallbackErrorMessage = function (error, textResponse) {
-  error.message = error.message || textResponse
-  return error
-}
-
-export const getFetchError = function (error, url, opts) {
-  const data = omit.default(opts, ['Authorization'])
-  if (error.name !== 'FetchError') {
-    error.name = 'FetchError'
-  }
-  error.url = url
-  error.data = data
-  return error
-}

package/src/methods/retry.js

@@ -1,49 +0,0 @@
-// We retry:
-//  - when receiving a rate limiting response
-//  - on network failures due to timeouts
-export const shouldRetry = function ({ response = {}, error = {}, method = {} }) {
-  if (response.status === RATE_LIMIT_STATUS || RETRY_ERROR_CODES.has(error.code)) {
-    return true
-  }
-
-  // Special case for the `getLatestPluginRuns` endpoint.
-  // See https://github.com/netlify/bitballoon/issues/9616.
-  if (method.operationId === 'getLatestPluginRuns' && response.status === 500) {
-    return true
-  }
-
-  return false
-}
-
-export const waitForRetry = async function (response) {
-  const delay = getDelay(response)
-  await sleep(delay)
-}
-
-const getDelay = function (response) {
-  if (response === undefined) {
-    return DEFAULT_RETRY_DELAY
-  }
-
-  const rateLimitReset = response.headers.get(RATE_LIMIT_HEADER)
-
-  if (!rateLimitReset) {
-    return DEFAULT_RETRY_DELAY
-  }
-
-  return Math.max(Number(rateLimitReset) * SECS_TO_MSECS - Date.now(), MIN_RETRY_DELAY)
-}
-
-const sleep = function (ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms)
-  })
-}
-
-const DEFAULT_RETRY_DELAY = 5e3
-const MIN_RETRY_DELAY = 1e3
-const SECS_TO_MSECS = 1e3
-export const MAX_RETRY = 5
-const RATE_LIMIT_STATUS = 429
-const RATE_LIMIT_HEADER = 'X-RateLimit-Reset'
-const RETRY_ERROR_CODES = new Set(['ETIMEDOUT', 'ECONNRESET'])

package/src/methods/url.js

@@ -1,31 +0,0 @@
-import queryString from 'qs'
-
-import { getRequestParams } from './params.js'
-
-// Replace path parameters and query parameters in the URI, using the OpenAPI
-// definition
-export const getUrl = function ({ path, parameters }, basePath, requestParams) {
-  const url = `${basePath}${path}`
-  const urlA = addPathParams(url, parameters, requestParams)
-  const urlB = addQueryParams(urlA, parameters, requestParams)
-  return urlB
-}
-
-const addPathParams = function (url, parameters, requestParams) {
-  const pathParams = getRequestParams(parameters.path, requestParams, 'path variable')
-  return Object.entries(pathParams).reduce(addPathParam, url)
-}
-
-const addPathParam = function (url, [name, value]) {
-  return url.replace(`{${name}}`, value)
-}
-
-const addQueryParams = function (url, parameters, requestParams) {
-  const queryParams = getRequestParams(parameters.query, requestParams, 'query variable')
-
-  if (Object.keys(queryParams).length === 0) {
-    return url
-  }
-
-  return `${url}?${queryString.stringify(queryParams, { arrayFormat: 'brackets' })}`
-}

package/src/open_api.js

@@ -1,7 +0,0 @@
-import { createRequire } from 'module'
-
-// TODO: remove once Node.js supports JSON imports with pure ES modules without
-// any experimental flags
-const require = createRequire(import.meta.url)
-
-export const openApiSpec = require('@netlify/open-api')

package/src/operations.js

@@ -1,23 +0,0 @@
-import omit from 'omit.js'
-
-import { openApiSpec } from './open_api.js'
-
-// Retrieve all OpenAPI operations
-export const getOperations = function () {
-  return Object.entries(openApiSpec.paths).flatMap(([path, pathItem]) => {
-    const operations = omit.default(pathItem, ['parameters'])
-    return Object.entries(operations).map(([method, operation]) => {
-      const parameters = getParameters(pathItem.parameters, operation.parameters)
-      return { ...operation, verb: method, path, parameters }
-    })
-  })
-}
-
-const getParameters = function (pathParameters = [], operationParameters = []) {
-  const parameters = [...pathParameters, ...operationParameters]
-  return parameters.reduce(addParameter, { path: {}, query: {}, body: {} })
-}
-
-const addParameter = function (parameters, param) {
-  return { ...parameters, [param.in]: { ...parameters[param.in], [param.name]: param } }
-}