@pnp/nodejs 2.10.0 → 2.13.0

package/net/msalfetchclient.d.ts

@@ -1,10 +1,10 @@
-import { AuthenticationResult, Configuration } from "@azure/msal-node";
-import { IHttpClientImpl } from "@pnp/common";
-export declare class MsalFetchClient implements IHttpClientImpl {
-    private _scopes;
-    private confidentialClient;
-    constructor(_config: Configuration, _scopes?: string[]);
-    fetch(url: string, options: any): Promise<Response>;
-    acquireToken(scopes?: string[]): Promise<AuthenticationResult>;
-}
+import { AuthenticationResult, Configuration } from "@azure/msal-node";
+import { IHttpClientImpl } from "@pnp/common";
+export declare class MsalFetchClient implements IHttpClientImpl {
+    private _scopes;
+    private confidentialClient;
+    constructor(_config: Configuration, _scopes?: string[]);
+    fetch(url: string, options: any): Promise<Response>;
+    acquireToken(scopes?: string[]): Promise<AuthenticationResult>;
+}
 //# sourceMappingURL=msalfetchclient.d.ts.map

package/net/msalfetchclient.js

@@ -1,33 +1,33 @@
-import { ConfidentialClientApplication } from "@azure/msal-node";
-import { objectDefinedNotNull, assign, } from "@pnp/common";
-import { fetch } from "./fetch.js";
-var MsalFetchClient = /** @class */ (function () {
-    function MsalFetchClient(_config, _scopes) {
-        if (_scopes === void 0) { _scopes = ["https://graph.microsoft.com/.default"]; }
-        this._scopes = _scopes;
-        this.confidentialClient = new ConfidentialClientApplication(_config);
-    }
-    MsalFetchClient.prototype.fetch = function (url, options) {
-        if (!objectDefinedNotNull(options)) {
-            options = {
-                headers: new Headers(),
-            };
-        }
-        else if (!objectDefinedNotNull(options.headers)) {
-            options = assign(options, {
-                headers: new Headers(),
-            });
-        }
-        return this.acquireToken().then(function (token) {
-            options.headers.set("Authorization", token.tokenType + " " + token.accessToken);
-            return fetch(url, options);
-        });
-    };
-    MsalFetchClient.prototype.acquireToken = function (scopes) {
-        if (scopes === void 0) { scopes = this._scopes; }
-        return this.confidentialClient.acquireTokenByClientCredential({ scopes: scopes });
-    };
-    return MsalFetchClient;
-}());
-export { MsalFetchClient };
+import { ConfidentialClientApplication } from "@azure/msal-node";
+import { objectDefinedNotNull, assign, } from "@pnp/common";
+import { fetch } from "./fetch.js";
+var MsalFetchClient = /** @class */ (function () {
+    function MsalFetchClient(_config, _scopes) {
+        if (_scopes === void 0) { _scopes = ["https://graph.microsoft.com/.default"]; }
+        this._scopes = _scopes;
+        this.confidentialClient = new ConfidentialClientApplication(_config);
+    }
+    MsalFetchClient.prototype.fetch = function (url, options) {
+        if (!objectDefinedNotNull(options)) {
+            options = {
+                headers: new Headers(),
+            };
+        }
+        else if (!objectDefinedNotNull(options.headers)) {
+            options = assign(options, {
+                headers: new Headers(),
+            });
+        }
+        return this.acquireToken().then(function (token) {
+            options.headers.set("Authorization", token.tokenType + " " + token.accessToken);
+            return fetch(url, options);
+        });
+    };
+    MsalFetchClient.prototype.acquireToken = function (scopes) {
+        if (scopes === void 0) { scopes = this._scopes; }
+        return this.confidentialClient.acquireTokenByClientCredential({ scopes: scopes });
+    };
+    return MsalFetchClient;
+}());
+export { MsalFetchClient };
 //# sourceMappingURL=msalfetchclient.js.map

package/net/nodefetchclient.d.ts

@@ -1,24 +1,24 @@
-import { IHttpClientImpl } from "@pnp/common";
-/**
- * Fetch client that encapsulates the node-fetch library and also adds retry logic
- * when encountering transient errors.
- */
-export declare class NodeFetchClient implements IHttpClientImpl {
-    private retryCount;
-    private retryInterval;
-    private minRetryInterval;
-    private maxRetryInterval;
-    /**
-     *
-     * @param retryCount: number - Maximum number of transient failure retries before throwing the error
-     * @param retryInterval: number - Starting interval to delay the first retry attempt
-     * @param minRetryInterval: number - Minimum retry delay boundary as retry intervals are randomly recalculated
-     * @param maxRetryInterval: number - Maximum retry delay boundary as retry intervals are radnomaly recalculated
-     */
-    constructor(retryCount?: number, retryInterval?: number, minRetryInterval?: number, maxRetryInterval?: number);
-    fetch(url: string, options?: any): Promise<Response>;
-    private delay;
-    private updateRetryData;
-    private shouldRetry;
-}
+import { IHttpClientImpl } from "@pnp/common";
+/**
+ * Fetch client that encapsulates the node-fetch library and also adds retry logic
+ * when encountering transient errors.
+ */
+export declare class NodeFetchClient implements IHttpClientImpl {
+    private retryCount;
+    private retryInterval;
+    private minRetryInterval;
+    private maxRetryInterval;
+    /**
+     *
+     * @param retryCount: number - Maximum number of transient failure retries before throwing the error
+     * @param retryInterval: number - Starting interval to delay the first retry attempt
+     * @param minRetryInterval: number - Minimum retry delay boundary as retry intervals are randomly recalculated
+     * @param maxRetryInterval: number - Maximum retry delay boundary as retry intervals are radnomaly recalculated
+     */
+    constructor(retryCount?: number, retryInterval?: number, minRetryInterval?: number, maxRetryInterval?: number);
+    fetch(url: string, options?: any): Promise<Response>;
+    private delay;
+    private updateRetryData;
+    private shouldRetry;
+}
 //# sourceMappingURL=nodefetchclient.d.ts.map

package/net/nodefetchclient.js

@@ -1,118 +1,118 @@
-import { __awaiter, __generator } from "tslib";
-import { Logger } from "@pnp/logging";
-import { fetch } from "./fetch.js";
-/**
- * Fetch client that encapsulates the node-fetch library and also adds retry logic
- * when encountering transient errors.
- */
-var NodeFetchClient = /** @class */ (function () {
-    /**
-     *
-     * @param retryCount: number - Maximum number of transient failure retries before throwing the error
-     * @param retryInterval: number - Starting interval to delay the first retry attempt
-     * @param minRetryInterval: number - Minimum retry delay boundary as retry intervals are randomly recalculated
-     * @param maxRetryInterval: number - Maximum retry delay boundary as retry intervals are radnomaly recalculated
-     */
-    function NodeFetchClient(retryCount, retryInterval, minRetryInterval, maxRetryInterval) {
-        if (retryCount === void 0) { retryCount = 3; }
-        if (retryInterval === void 0) { retryInterval = 3000; }
-        if (minRetryInterval === void 0) { minRetryInterval = 3000; }
-        if (maxRetryInterval === void 0) { maxRetryInterval = 90000; }
-        this.retryCount = retryCount;
-        this.retryInterval = retryInterval;
-        this.minRetryInterval = minRetryInterval;
-        this.maxRetryInterval = maxRetryInterval;
-    }
-    NodeFetchClient.prototype.fetch = function (url, options) {
-        return __awaiter(this, void 0, void 0, function () {
-            var wrapper;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        wrapper = function (retryData) { return __awaiter(_this, void 0, void 0, function () {
-                            var err_1, retry;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0:
-                                        _a.trys.push([0, 2, , 7]);
-                                        return [4 /*yield*/, fetch(url, options || {})];
-                                    case 1: 
-                                    // Try to make the request...
-                                    return [2 /*return*/, _a.sent()];
-                                    case 2:
-                                        err_1 = _a.sent();
-                                        retry = this.updateRetryData(retryData, err_1);
-                                        // If there is no error code, this wasn't a transient error
-                                        // so we throw immediately.
-                                        if (!err_1.code) {
-                                            throw err_1;
-                                        }
-                                        if (!(["ETIMEDOUT", "ESOCKETTIMEDOUT", "ECONNREFUSED", "ECONNRESET"].indexOf(err_1.code.toUpperCase()) > -1)) return [3 /*break*/, 6];
-                                        Logger.write("Attempt #" + retry.retryCount + " - Retrying error code: " + err_1.code + "...", 0 /* Verbose */);
-                                        if (!this.shouldRetry(retry)) return [3 /*break*/, 5];
-                                        return [4 /*yield*/, this.delay(retry.retryInterval)];
-                                    case 3:
-                                        _a.sent();
-                                        return [4 /*yield*/, wrapper(retry)];
-                                    case 4: return [2 /*return*/, _a.sent()];
-                                    case 5: // max amount of retries reached, so throw the error
-                                    throw err_1;
-                                    case 6: return [3 /*break*/, 7];
-                                    case 7: return [2 /*return*/];
-                                }
-                            });
-                        }); };
-                        return [4 /*yield*/, wrapper(null)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    NodeFetchClient.prototype.delay = function (ms) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, new Promise(function (resolve) {
-                        setTimeout(function () {
-                            resolve();
-                        }, ms);
-                    })];
-            });
-        });
-    };
-    NodeFetchClient.prototype.updateRetryData = function (retryData, err) {
-        var data = retryData || {
-            error: null,
-            retryCount: 0,
-            retryInterval: 0,
-        };
-        var newError = err || null;
-        // Keep track of errors from previous retries
-        // if they exist
-        if (newError) {
-            if (data.error) {
-                newError.innerError = data.error;
-            }
-            data.error = newError;
-        }
-        // Adjust retry interval and cap based on the min and max intervals specified
-        var incrementDelta = Math.pow(2, data.retryCount) - 1;
-        var boundedRandDelta = this.retryInterval * 0.8 +
-            Math.floor(Math.random() * (this.retryInterval * 1.2 - this.retryInterval * 0.8));
-        incrementDelta *= boundedRandDelta;
-        // Adjust retry count
-        data.retryCount++;
-        data.retryInterval = Math.min(this.minRetryInterval + incrementDelta, this.maxRetryInterval);
-        return data;
-    };
-    NodeFetchClient.prototype.shouldRetry = function (retryData) {
-        if (!retryData) {
-            throw new Error("ERROR: retryData cannot be null.");
-        }
-        var currentCount = (retryData && retryData.retryCount);
-        return currentCount < this.retryCount;
-    };
-    return NodeFetchClient;
-}());
-export { NodeFetchClient };
+import { __awaiter, __generator } from "tslib";
+import { Logger } from "@pnp/logging";
+import { fetch } from "./fetch.js";
+/**
+ * Fetch client that encapsulates the node-fetch library and also adds retry logic
+ * when encountering transient errors.
+ */
+var NodeFetchClient = /** @class */ (function () {
+    /**
+     *
+     * @param retryCount: number - Maximum number of transient failure retries before throwing the error
+     * @param retryInterval: number - Starting interval to delay the first retry attempt
+     * @param minRetryInterval: number - Minimum retry delay boundary as retry intervals are randomly recalculated
+     * @param maxRetryInterval: number - Maximum retry delay boundary as retry intervals are radnomaly recalculated
+     */
+    function NodeFetchClient(retryCount, retryInterval, minRetryInterval, maxRetryInterval) {
+        if (retryCount === void 0) { retryCount = 3; }
+        if (retryInterval === void 0) { retryInterval = 3000; }
+        if (minRetryInterval === void 0) { minRetryInterval = 3000; }
+        if (maxRetryInterval === void 0) { maxRetryInterval = 90000; }
+        this.retryCount = retryCount;
+        this.retryInterval = retryInterval;
+        this.minRetryInterval = minRetryInterval;
+        this.maxRetryInterval = maxRetryInterval;
+    }
+    NodeFetchClient.prototype.fetch = function (url, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var wrapper;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        wrapper = function (retryData) { return __awaiter(_this, void 0, void 0, function () {
+                            var err_1, retry;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        _a.trys.push([0, 2, , 7]);
+                                        return [4 /*yield*/, fetch(url, options || {})];
+                                    case 1: 
+                                    // Try to make the request...
+                                    return [2 /*return*/, _a.sent()];
+                                    case 2:
+                                        err_1 = _a.sent();
+                                        retry = this.updateRetryData(retryData, err_1);
+                                        // If there is no error code, this wasn't a transient error
+                                        // so we throw immediately.
+                                        if (!err_1.code) {
+                                            throw err_1;
+                                        }
+                                        if (!(["ETIMEDOUT", "ESOCKETTIMEDOUT", "ECONNREFUSED", "ECONNRESET"].indexOf(err_1.code.toUpperCase()) > -1)) return [3 /*break*/, 6];
+                                        Logger.write("Attempt #" + retry.retryCount + " - Retrying error code: " + err_1.code + "...", 0 /* Verbose */);
+                                        if (!this.shouldRetry(retry)) return [3 /*break*/, 5];
+                                        return [4 /*yield*/, this.delay(retry.retryInterval)];
+                                    case 3:
+                                        _a.sent();
+                                        return [4 /*yield*/, wrapper(retry)];
+                                    case 4: return [2 /*return*/, _a.sent()];
+                                    case 5: // max amount of retries reached, so throw the error
+                                    throw err_1;
+                                    case 6: return [3 /*break*/, 7];
+                                    case 7: return [2 /*return*/];
+                                }
+                            });
+                        }); };
+                        return [4 /*yield*/, wrapper(null)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    NodeFetchClient.prototype.delay = function (ms) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, new Promise(function (resolve) {
+                        setTimeout(function () {
+                            resolve();
+                        }, ms);
+                    })];
+            });
+        });
+    };
+    NodeFetchClient.prototype.updateRetryData = function (retryData, err) {
+        var data = retryData || {
+            error: null,
+            retryCount: 0,
+            retryInterval: 0,
+        };
+        var newError = err || null;
+        // Keep track of errors from previous retries
+        // if they exist
+        if (newError) {
+            if (data.error) {
+                newError.innerError = data.error;
+            }
+            data.error = newError;
+        }
+        // Adjust retry interval and cap based on the min and max intervals specified
+        var incrementDelta = Math.pow(2, data.retryCount) - 1;
+        var boundedRandDelta = this.retryInterval * 0.8 +
+            Math.floor(Math.random() * (this.retryInterval * 1.2 - this.retryInterval * 0.8));
+        incrementDelta *= boundedRandDelta;
+        // Adjust retry count
+        data.retryCount++;
+        data.retryInterval = Math.min(this.minRetryInterval + incrementDelta, this.maxRetryInterval);
+        return data;
+    };
+    NodeFetchClient.prototype.shouldRetry = function (retryData) {
+        if (!retryData) {
+            throw new Error("ERROR: retryData cannot be null.");
+        }
+        var currentCount = (retryData && retryData.retryCount);
+        return currentCount < this.retryCount;
+    };
+    return NodeFetchClient;
+}());
+export { NodeFetchClient };
 //# sourceMappingURL=nodefetchclient.js.map

package/net/proxy.d.ts

@@ -1,18 +1,18 @@
-import { IConfigOptions } from "@pnp/common";
-import * as HttpsProxyAgent from "https-proxy-agent";
-export declare function configureProxyOptions<T extends IConfigOptions>(opts: T): T & {
-    agent: typeof HttpsProxyAgent;
-};
-/**
- * Sets the given url as a proxy on all requests
- *
- * @param url The url of the proxy
- */
-export declare function setProxyUrl(url: string): void;
-/**
- * Sets the given agent as a proxy on all requests
- *
- * @param agent The proxy agent to use
- */
-export declare function setProxyAgent(agent: any): void;
+import { IConfigOptions } from "@pnp/common";
+import * as HttpsProxyAgent from "https-proxy-agent";
+export declare function configureProxyOptions<T extends IConfigOptions>(opts: T): T & {
+    agent: typeof HttpsProxyAgent;
+};
+/**
+ * Sets the given url as a proxy on all requests
+ *
+ * @param url The url of the proxy
+ */
+export declare function setProxyUrl(url: string): void;
+/**
+ * Sets the given agent as a proxy on all requests
+ *
+ * @param agent The proxy agent to use
+ */
+export declare function setProxyAgent(agent: any): void;
 //# sourceMappingURL=proxy.d.ts.map

package/net/proxy.js

@@ -1,29 +1,29 @@
-import { stringIsNullOrEmpty, mergeOptions, objectDefinedNotNull } from "@pnp/common";
-import * as HttpsProxyAgent from "https-proxy-agent";
-var proxyUrl = "";
-var proxyAgent = null;
-export function configureProxyOptions(opts) {
-    if (!stringIsNullOrEmpty(proxyUrl) || objectDefinedNotNull(proxyAgent)) {
-        mergeOptions(opts, {
-            agent: proxyAgent || HttpsProxyAgent(proxyUrl),
-        });
-    }
-    return opts;
-}
-/**
- * Sets the given url as a proxy on all requests
- *
- * @param url The url of the proxy
- */
-export function setProxyUrl(url) {
-    proxyUrl = url;
-}
-/**
- * Sets the given agent as a proxy on all requests
- *
- * @param agent The proxy agent to use
- */
-export function setProxyAgent(agent) {
-    proxyAgent = agent;
-}
+import { stringIsNullOrEmpty, mergeOptions, objectDefinedNotNull } from "@pnp/common";
+import * as HttpsProxyAgent from "https-proxy-agent";
+var proxyUrl = "";
+var proxyAgent = null;
+export function configureProxyOptions(opts) {
+    if (!stringIsNullOrEmpty(proxyUrl) || objectDefinedNotNull(proxyAgent)) {
+        mergeOptions(opts, {
+            agent: proxyAgent || HttpsProxyAgent(proxyUrl),
+        });
+    }
+    return opts;
+}
+/**
+ * Sets the given url as a proxy on all requests
+ *
+ * @param url The url of the proxy
+ */
+export function setProxyUrl(url) {
+    proxyUrl = url;
+}
+/**
+ * Sets the given agent as a proxy on all requests
+ *
+ * @param agent The proxy agent to use
+ */
+export function setProxyAgent(agent) {
+    proxyAgent = agent;
+}
 //# sourceMappingURL=proxy.js.map

package/net/spfetchclient.d.ts

@@ -1,22 +1,22 @@
-import { IHttpClientImpl } from "@pnp/common";
-import { SPOAuthEnv, AuthToken } from "../types.js";
-/**
- * Fetch client for use within nodejs, requires you register a client id and secret with app only permissions.
- *
- * See either the MSAL client or ADAL client for more modern options
- */
-export declare class SPFetchClient implements IHttpClientImpl {
-    siteUrl: string;
-    protected _clientId: string;
-    protected _clientSecret: string;
-    authEnv: SPOAuthEnv;
-    protected _realm: string;
-    protected _fetchClient: IHttpClientImpl;
-    protected token: AuthToken | null;
-    constructor(siteUrl: string, _clientId: string, _clientSecret: string, authEnv?: SPOAuthEnv, _realm?: string, _fetchClient?: IHttpClientImpl);
-    fetch(url: string, options?: any): Promise<Response>;
-    getAuthHostUrl(env: SPOAuthEnv): string;
-    private getRealm;
-    private getAuthUrl;
-}
+import { IHttpClientImpl } from "@pnp/common";
+import { SPOAuthEnv, AuthToken } from "../types.js";
+/**
+ * Fetch client for use within nodejs, requires you register a client id and secret with app only permissions.
+ *
+ * See either the MSAL client or ADAL client for more modern options
+ */
+export declare class SPFetchClient implements IHttpClientImpl {
+    siteUrl: string;
+    protected _clientId: string;
+    protected _clientSecret: string;
+    authEnv: SPOAuthEnv;
+    protected _realm: string;
+    protected _fetchClient: IHttpClientImpl;
+    protected token: AuthToken | null;
+    constructor(siteUrl: string, _clientId: string, _clientSecret: string, authEnv?: SPOAuthEnv, _realm?: string, _fetchClient?: IHttpClientImpl);
+    fetch(url: string, options?: any): Promise<Response>;
+    getAuthHostUrl(env: SPOAuthEnv): string;
+    private getRealm;
+    private getAuthUrl;
+}
 //# sourceMappingURL=spfetchclient.d.ts.map