netlify 13.3.5 → 21.5.0

package/lib/methods/index.js

@@ -1,84 +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/lib/methods/params.d.ts

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

package/lib/methods/params.js

@@ -1,14 +0,0 @@
-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

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

package/lib/methods/response.js

@@ -1,44 +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(opts, ['Authorization']);
-    if (error.name !== 'FetchError') {
-        error.name = 'FetchError';
-    }
-    error.url = url;
-    error.data = data;
-    return error;
-};

package/lib/methods/retry.d.ts

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

package/lib/methods/retry.js

@@ -1,40 +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/lib/methods/url.d.ts

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

package/lib/methods/url.js

@@ -1,24 +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/lib/omit.d.ts

@@ -1 +0,0 @@
-export default function omit<T extends Record<string | number | symbol, unknown>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;

package/lib/omit.js

@@ -1,7 +0,0 @@
-export default function omit(obj, keys) {
-    const shallowCopy = { ...obj };
-    for (const key of keys) {
-        delete shallowCopy[key];
-    }
-    return shallowCopy;
-}

package/lib/open_api.d.ts

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

package/lib/open_api.js

@@ -1,5 +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/lib/operations.d.ts

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

package/lib/operations.js

@@ -1,19 +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(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/lib/types.d.ts

@@ -1,129 +0,0 @@
-import type { ReadStream } from 'node:fs';
-import type { operations } from '@netlify/open-api';
-import type { RequestInit } from 'node-fetch';
-/**
- * Determines whether all keys in T are optional.
- */
-type AreAllOptional<T> = keyof T extends never ? true : T extends Record<string, any> ? {
-    [K in keyof T]-?: undefined extends T[K] ? never : K;
-}[keyof T] extends never ? true : false : false;
-/**
- * Determines whether `path` and `query` are both optional.
- */
-type IsPathAndQueryOptional<K extends keyof operations> = 'parameters' extends keyof operations[K] ? AreAllOptional<'path' extends keyof operations[K]['parameters'] ? operations[K]['parameters']['path'] : object> extends true ? AreAllOptional<'query' extends keyof operations[K]['parameters'] ? operations[K]['parameters']['query'] : object> extends true ? true : false : false : true;
-/**
- * Converts snake_case to camelCase for TypeScript types.
- */
-type CamelCase<S extends string> = S extends `${infer T}_${infer U}` ? `${T}${Capitalize<CamelCase<U>>}` : S;
-/**
- * Creates a union of both snake_case and camelCase keys with their respective types.
- */
-type SnakeToCamel<T> = {
-    [K in keyof T as CamelCase<K & string>]: T[K];
-};
-/**
- * Combines snake_case and camelCase parameters into one Params type.
- */
-type Params<T> = SnakeToCamel<T> | T;
-type HasRequestBody<K extends keyof operations> = 'requestBody' extends keyof operations[K] ? operations[K]['requestBody'] extends {
-    content: any;
-} ? 'application/json' extends keyof operations[K]['requestBody']['content'] ? true : 'application/octet-stream' extends keyof operations[K]['requestBody']['content'] ? true : false : false : false;
-/**
- * Extracts the request body type from the operation.
- */
-type RequestBody<K extends keyof operations> = 'requestBody' extends keyof operations[K] ? operations[K]['requestBody'] extends {
-    content: any;
-} ? 'application/json' extends keyof operations[K]['requestBody']['content'] ? operations[K]['requestBody']['content']['application/json'] : 'application/octet-stream' extends keyof operations[K]['requestBody']['content'] ? ReadStream | (() => ReadStream) : never : never : never;
-type IsRequestBodyJson<K extends keyof operations> = 'requestBody' extends keyof operations[K] ? operations[K]['requestBody'] extends {
-    content: any;
-} ? 'application/json' extends keyof operations[K]['requestBody']['content'] ? true : false : false : false;
-type IsRequestBodyOctetStream<K extends keyof operations> = 'requestBody' extends keyof operations[K] ? operations[K]['requestBody'] extends {
-    content: any;
-} ? 'application/octet-stream' extends keyof operations[K]['requestBody']['content'] ? true : false : false : false;
-type RequestBodyParam<K extends keyof operations> = HasRequestBody<K> extends true ? IsRequestBodyOptional<K> extends true ? DetailedRequestBodyOptional<K> : DetailedRequestBody<K> : never;
-type DetailedRequestBody<K extends keyof operations> = IsRequestBodyJson<K> extends true ? {
-    /**
-     * The request body for `application/json`.
-     * Automatically serialized to JSON based on the operation.
-     * Can be a JSON object or a function returning one.
-     */
-    body: RequestBody<K> | (() => RequestBody<K>);
-} : IsRequestBodyOctetStream<K> extends true ? {
-    /**
-     * The request body for `application/octet-stream`.
-     * Can be a Node.js readable stream or a function returning one
-     * @example
-     * fs.createReadStream('./file')
-     * @example
-     * () => fs.createReadStream('./file')
-     */
-    body: ReadStream | (() => ReadStream);
-} : never;
-type DetailedRequestBodyOptional<K extends keyof operations> = IsRequestBodyJson<K> extends true ? {
-    /**
-     * The request body for `application/json`.
-     * Automatically serialized to JSON based on the operation.
-     * Can be a JSON object or a function returning one.
-     */
-    body?: RequestBody<K> | (() => RequestBody<K>);
-} : IsRequestBodyOctetStream<K> extends true ? {
-    /**
-     * The request body for `application/octet-stream`.
-     * Can be a Node.js readable stream or a function returning one
-     * @example
-     * fs.createReadStream('./file')
-     * @example
-     * () => fs.createReadStream('./file')
-     */
-    body?: ReadStream | (() => ReadStream);
-} : never;
-/**
- * Determines whether all properties in the request body are optional.
- */
-type IsRequestBodyOptional<K extends keyof operations> = HasRequestBody<K> extends true ? (AreAllOptional<RequestBody<K>> extends true ? true : false) : true;
-/**
- * Determines whether any parameters or request body are required.
- */
-type IsParamsOrRequestBodyRequired<K extends keyof operations> = 'parameters' extends keyof operations[K] ? IsPathAndQueryOptional<K> extends true ? IsRequestBodyOptional<K> extends true ? false : true : true : false;
-/**
- * Extracts and combines `path` and `query` parameters into a single type.
- */
-type ExtractPathAndQueryParameters<K extends keyof operations> = 'parameters' extends keyof operations[K] ? 'path' extends keyof operations[K]['parameters'] ? 'query' extends keyof operations[K]['parameters'] ? Params<Omit<operations[K]['parameters']['path'], keyof operations[K]['parameters']['query']> & operations[K]['parameters']['query']> : Params<operations[K]['parameters']['path']> : 'query' extends keyof operations[K]['parameters'] ? Params<operations[K]['parameters']['query']> : undefined : undefined;
-/**
- * Combines path, query, and request body parameters into a single type.
- */
-type CombinedParamsAndRequestBody<K extends keyof operations> = HasRequestBody<K> extends true ? ExtractPathAndQueryParameters<K> & RequestBodyParam<K> : ExtractPathAndQueryParameters<K>;
-type OperationParams<K extends keyof operations> = IsParamsOrRequestBodyRequired<K> extends false ? CombinedParamsAndRequestBody<K> | void | undefined : CombinedParamsAndRequestBody<K>;
-type SuccessHttpStatusCodes = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226;
-/**
- * Extracts the response type from the operation.
- */
-type OperationResponse<K extends keyof operations> = 'responses' extends keyof operations[K] ? SuccessHttpStatusCodes extends infer StatusKeys ? StatusKeys extends keyof operations[K]['responses'] ? 'content' extends keyof operations[K]['responses'][StatusKeys] ? 'application/json' extends keyof operations[K]['responses'][StatusKeys]['content'] ? operations[K]['responses'][StatusKeys]['content']['application/json'] : never : never : never : never : never;
-export type DynamicMethods = {
-    [K in keyof operations]: (params: OperationParams<K>, 
-    /**
-     * Any properties you want passed to `node-fetch`.
-     *
-     * The `headers` property is merged with some `defaultHeaders`:
-     * ```ts
-     * {
-     *  'User-agent': 'netlify-js-client',
-     *  'accept': 'application/json',
-     * }
-     * ```
-     *
-     * @example
-     * ```ts
-     * const site = await client.getSite(
-     *  { site_id: 'YOUR_SITE_ID' },
-     *  {
-     *    headers: {
-     *      'X-Example-Header': 'Example Value',
-     *    },
-     *  },
-     * )
-     * ```
-     */
-    opts?: RequestInit | void | undefined) => Promise<OperationResponse<K>>;
-};
-export {};

package/lib/types.js

@@ -1 +0,0 @@
-export {};