@zxncij2390/monorepo3 3.18.0

package/packages/graph/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "extends": "../tsconfig.json",
+    "include": [
+        "./**/*.ts",
+        "../core/**/*.ts",
+        "../queryable/**/*.ts"
+    ],
+    "references": [
+        {
+            "path": "../core/tsconfig.json"
+        },
+        {
+            "path": "../queryable/tsconfig.json"
+        }
+    ]
+}

package/packages/graph/users/index.ts

@@ -0,0 +1,34 @@
+import { GraphFI } from "../fi.js";
+import { IUser, User, IUsers, Users } from "./types.js";
+
+export {
+    IUser,
+    IUsers,
+    User,
+    Users,
+    IPeople,
+    People,
+} from "./types.js";
+
+declare module "../fi" {
+    interface GraphFI {
+        readonly me: IUser;
+        readonly users: IUsers;
+    }
+}
+
+Reflect.defineProperty(GraphFI.prototype, "me", {
+    configurable: true,
+    enumerable: true,
+    get: function (this: GraphFI) {
+        return this.create(User, "me");
+    },
+});
+
+Reflect.defineProperty(GraphFI.prototype, "users", {
+    configurable: true,
+    enumerable: true,
+    get: function (this: GraphFI) {
+        return this.create(Users);
+    },
+});

package/packages/graph/users/types.ts

@@ -0,0 +1,56 @@
+import { graphInvokableFactory } from "../graphqueryable.js";
+import { User as IUserType, Person as IPersonType } from "@microsoft/microsoft-graph-types";
+import { _DirectoryObject, DirectoryObjects, IDirectoryObjects, _DirectoryObjects } from "../directory-objects/types.js";
+import { defaultPath, updateable, deleteable, IUpdateable, IDeleteable, getById, IGetById } from "../decorators.js";
+
+@updateable()
+@deleteable()
+export class _User extends _DirectoryObject<IUserType> {
+    /**
+    * The groups and directory roles associated with the user
+    */
+    public get memberOf(): IDirectoryObjects {
+        return DirectoryObjects(this, "memberOf");
+    }
+
+    /**
+    * The groups and directory roles associated with the user
+    */
+    public get transitiveMemberOf(): IDirectoryObjects {
+        return DirectoryObjects(this, "transitiveMemberOf");
+    }
+
+    /**
+     * Retrieve a collection of person objects ordered by their relevance to the user
+     */
+    public get people(): IPeople {
+        return People(this);
+    }
+
+    /**
+    * People that have direct reports to the user
+    */
+    public get directReports(): IPeople {
+        return People(this, "directReports");
+    }
+
+    /**
+    * The manager associated with this user
+    */
+    public get manager(): IUser {
+        return User(this, "manager");
+    }
+}
+export interface IUser extends _User, IUpdateable<IUserType>, IDeleteable { }
+export const User = graphInvokableFactory<IUser>(_User);
+
+@defaultPath("users")
+@getById(User)
+export class _Users extends _DirectoryObjects<IUserType[]> { }
+export interface IUsers extends _Users, IGetById<IUser> { }
+export const Users = graphInvokableFactory<IUsers>(_Users);
+
+@defaultPath("people")
+export class _People extends _DirectoryObjects<IPersonType[]> { }
+export interface IPeople extends _People { }
+export const People = graphInvokableFactory<IPeople>(_People);

package/packages/graph/utils/type.ts

@@ -0,0 +1,3 @@
+export function type<T = unknown>(n: string, a: T): T & { "@odata.type": string} {
+    return Object.assign({ "@odata.type": n }, a);
+}

package/packages/logging/index.ts

@@ -0,0 +1,145 @@
+export * from "./listeners.js";
+
+/**
+ * A set of logging levels
+ */
+export const enum LogLevel {
+    Verbose = 0,
+    Info = 1,
+    Warning = 2,
+    Error = 3,
+    Off = 99,
+}
+
+/**
+ * Interface that defines a log entry
+ *
+ */
+export interface ILogEntry {
+    /**
+   * The main message to be logged
+   */
+    message: string;
+    /**
+   * The level of information this message represents
+   */
+    level: LogLevel;
+    /**
+   * Any associated data that a given logging listener may choose to log or ignore
+   */
+    data?: any;
+}
+
+/**
+ * Interface that defines a log listener
+ *
+ */
+export interface ILogListener {
+    /**
+     * Any associated data that a given logging listener may choose to log or ignore
+     *
+     * @param entry The information to be logged
+     */
+    log(entry: ILogEntry): void;
+}
+
+const _subscribers: ILogListener[] = [];
+let _activeLogLevel: LogLevel = LogLevel.Warning;
+
+/**
+ * Class used to subscribe ILogListener and log messages throughout an application
+ *
+ */
+export class Logger {
+
+    /**
+   * Gets or sets the active log level to apply for log filtering
+   */
+    public static get activeLogLevel(): LogLevel {
+        return _activeLogLevel;
+    }
+
+    public static set activeLogLevel(value: LogLevel) {
+        _activeLogLevel = value;
+    }
+
+    /**
+     * Adds ILogListener instances to the set of subscribed listeners
+     *
+     * @param listeners One or more listeners to subscribe to this log
+     */
+    public static subscribe(...listeners: ILogListener[]): void {
+        _subscribers.push(...listeners);
+    }
+
+    /**
+   * Clears the subscribers collection, returning the collection before modification
+   */
+    public static clearSubscribers(): ILogListener[] {
+        const s = _subscribers.slice(0);
+        _subscribers.length = 0;
+        return s;
+    }
+
+    /**
+   * Gets the current subscriber count
+   */
+    public static get count(): number {
+        return _subscribers.length;
+    }
+
+    /**
+   * Writes the supplied string to the subscribed listeners
+   *
+   * @param message The message to write
+   * @param level [Optional] if supplied will be used as the level of the entry (Default: LogLevel.Info)
+   */
+    public static write(message: string, level: LogLevel = LogLevel.Info) {
+        Logger.log({ level: level, message: message });
+    }
+
+    /**
+   * Writes the supplied string to the subscribed listeners
+   *
+   * @param json The json object to stringify and write
+   * @param level [Optional] if supplied will be used as the level of the entry (Default: LogLevel.Info)
+   */
+    public static writeJSON(json: any, level: LogLevel = LogLevel.Info) {
+        Logger.write(JSON.stringify(json), level);
+    }
+
+    /**
+   * Logs the supplied entry to the subscribed listeners
+   *
+   * @param entry The message to log
+   */
+    public static log(entry: ILogEntry) {
+        if (entry !== undefined && Logger.activeLogLevel <= entry.level) {
+            _subscribers.map(subscriber => subscriber.log(entry));
+        }
+    }
+
+    /**
+   * Logs an error object to the subscribed listeners
+   *
+   * @param err The error object
+   */
+    public static error(err: Error) {
+        Logger.log({ data: err, level: LogLevel.Error, message: err.message });
+    }
+}
+
+export function PnPLogging<T>(activeLevel: LogLevel): (o: T) => T {
+
+    return (instance: T) => {
+
+        (<any>instance).on.log(function (message: string, level: LogLevel) {
+
+            if (activeLevel <= level) {
+                _subscribers.map(subscriber => subscriber.log({ level, message }));
+            }
+        });
+
+        return instance;
+    };
+}

package/packages/logging/listeners.ts

@@ -0,0 +1,134 @@
+/* eslint-disable no-console */
+import { ILogEntry, ILogListener, LogLevel } from "./index.js";
+
+export function ConsoleListener(prefix?: string, colors?: IConsoleListenerColors): ILogListener {
+    return new _ConsoleListener(prefix, colors);
+}
+
+/**
+ * Text color options for use in the ConsoleListener
+ * All values can be specified as known names, hex values, rgb, or rgba values
+ */
+export interface IConsoleListenerColors {
+    /** Default text color for all logging levels unless they're specified */
+    color?: string;
+
+    /** Text color to use for messages with LogLevel.Verbose */
+    verbose?: string;
+
+    /** Text color to use for messages with LogLevel.Info */
+    info?: string;
+
+    /** Text color to use for messages with LogLevel.Warning */
+    warning?: string;
+
+    /** Text color to use for messages with LogLevel.Error */
+    error?: string;
+}
+
+function withColor(msg: string, color: string | undefined, logMethod): void {
+    if (typeof color === "undefined") {
+        logMethod(msg);
+    } else {
+        logMethod(`%c${msg}`, `color:${color}`);
+    }
+}
+
+/**
+ * Formats the message
+ *
+ * @param entry The information to format into a string
+ */
+function entryToString(entry: ILogEntry, prefix: string): string {
+    const msg: string[] = [];
+
+    if (prefix.length > 0) {
+        msg.push(`${prefix} -`);
+    }
+
+    msg.push(entry.message);
+
+    if (entry.data !== undefined) {
+        try {
+            msg.push("Data: " + JSON.stringify(entry.data));
+        } catch (e) {
+            msg.push(`Data: Error in stringify of supplied data ${e}`);
+        }
+    }
+
+    return msg.join(" ");
+}
+
+// index order matters, this is a lookup table based on the corresponding LogLevel value
+const colorProps = ["verbose", "info", "warning", "error"];
+
+/**
+ * Implementation of LogListener which logs to the console
+ *
+ */
+class _ConsoleListener implements ILogListener {
+
+    /**
+     * Makes a new one
+     *
+     * @param prefix Optional text to include at the start of all messages (useful for filtering)
+     * @param colors Optional text color settings
+     */
+    constructor(private _prefix = "", private _colors: IConsoleListenerColors = {}) { }
+
+    /**
+     * Any associated data that a given logging listener may choose to log or ignore
+     *
+     * @param entry The information to be logged
+     */
+    public log(entry: ILogEntry): void {
+
+        let logMethod = console.log;
+        switch(entry.level){
+            case LogLevel.Error:
+                logMethod = console.error;
+                break;
+            case LogLevel.Warning:
+                logMethod = console.warn;
+                break;
+            case LogLevel.Verbose:
+                logMethod = console.debug;
+                break;
+            case LogLevel.Info:
+                logMethod = console.info;
+                break;
+            default:
+                logMethod = console.log;
+        }
+
+        withColor(entryToString(entry, this._prefix), this._colors[colorProps[entry.level]], logMethod);
+    }
+}
+
+export function FunctionListener(impl: (entry: ILogEntry) => void): ILogListener {
+    return new _FunctionListener(impl);
+}
+
+/**
+ * Implementation of LogListener which logs to the supplied function
+ *
+ */
+class _FunctionListener implements ILogListener {
+
+    /**
+     * Creates a new instance of the FunctionListener class
+     *
+     * @constructor
+     * @param  method The method to which any logging data will be passed
+     */
+    constructor(private method: (entry: ILogEntry) => void) { }
+
+    /**
+     * Any associated data that a given logging listener may choose to log or ignore
+     *
+     * @param entry The information to be logged
+     */
+    public log(entry: ILogEntry): void {
+        this.method(entry);
+    }
+}

package/packages/logging/package.json

@@ -0,0 +1,10 @@
+{
+    "name": "@pnp/logging",
+    "version": "0.0.0-PLACEHOLDER",
+    "description": "pnp - light-weight, subscribable logging framework",
+    "main": "./index.js",
+    "typings": "./index",
+    "dependencies": {
+        "tslib": "2.4.1"
+    }
+}

package/packages/logging/tsconfig.json

@@ -0,0 +1,7 @@
+{
+    "extends": "../tsconfig.json",
+    "include": [
+        "./**/*.ts"
+    ],
+    "references": []
+}

package/packages/msaljsclient/index.ts

@@ -0,0 +1,40 @@
+import { AuthenticationParameters, Configuration, UserAgentApplication } from "msal";
+import { Queryable } from "@pnp/queryable";
+
+export function MSAL(config: Configuration, authParams: AuthenticationParameters = { scopes: ["https://graph.microsoft.com/.default"] }): (instance: Queryable) => Queryable {
+
+    const app = new UserAgentApplication(config);
+
+    return (instance: Queryable) => {
+
+        instance.on.auth.replace(async (url: URL, init: RequestInit) => {
+
+            let accessToken: string;
+
+            try {
+
+                // see if we have already the idtoken saved
+                const resp = await app.acquireTokenSilent(authParams);
+                accessToken = resp.accessToken;
+
+            } catch (e) {
+
+                // per examples we fall back to popup
+                const resp = await app.loginPopup(authParams);
+                if (resp.idToken) {
+                    const resp2 = await app.acquireTokenSilent(authParams);
+                    accessToken = resp2.accessToken;
+                } else {
+                    // throw the error that brought us here
+                    throw e;
+                }
+            }
+
+            init.headers = { ...init.headers, Authorization: `Bearer ${accessToken}` };
+
+            return [url, init];
+        });
+
+        return instance;
+    };
+}

package/packages/msaljsclient/package.json

@@ -0,0 +1,12 @@
+{
+    "name": "@pnp/msaljsclient",
+    "version": "0.0.0-PLACEHOLDER",
+    "description": "pnp - provides an MSAL wrapper client for use with PnPjs",
+    "main": "./index.js",
+    "typings": "./index",
+    "dependencies": {
+        "@pnp/queryable": "0.0.0-PLACEHOLDER",
+        "msal": "1.4.17",
+        "tslib": "2.4.1"
+    }
+}

package/packages/msaljsclient/tsconfig.json

@@ -0,0 +1,12 @@
+{
+    "extends": "../tsconfig.json",
+    "include": [
+        "./**/*.ts",
+        "../queryable/**/*.ts"
+    ],
+    "references": [
+        {
+            "path": "../queryable/tsconfig.json"
+        }
+    ]
+}

package/packages/nodejs/behaviors/fetch.ts

@@ -0,0 +1,130 @@
+import { LogLevel } from "@pnp/logging";
+import { HttpRequestError, Queryable } from "@pnp/queryable";
+import { default as nodeFetch } from "node-fetch";
+import { delay, TimelinePipe } from "@pnp/core";
+
+export interface INodeFetchProps {
+    replace?: boolean;
+}
+
+export function NodeFetch(props?: INodeFetchProps): TimelinePipe<Queryable> {
+
+    const { replace } = {
+        replace: true,
+        ...props,
+    };
+
+    return (instance: Queryable) => {
+
+        if (replace) {
+            instance.on.send.clear();
+        }
+
+        instance.on.send(function (this: Queryable, url: URL, init: RequestInit) {
+
+            this.log(`Fetch: ${init.method} ${url.toString()}`, LogLevel.Verbose);
+
+            return <any>nodeFetch(url.toString(), <any>init);
+        });
+
+        return instance;
+    };
+}
+
+export interface INodeFetchWithRetryProps extends INodeFetchProps {
+    retries?: number;
+    interval?: number;
+}
+
+export function NodeFetchWithRetry(props?: INodeFetchWithRetryProps): TimelinePipe<Queryable> {
+
+    const { interval, replace, retries } = {
+        replace: true,
+        interval: 200,
+        retries: 3,
+        ...props,
+    };
+
+    return (instance: Queryable) => {
+
+        if (replace) {
+            instance.on.send.clear();
+        }
+
+        instance.on.send(function (this: Queryable, url: URL, init: RequestInit): Promise<Response> {
+
+            let response: Response;
+            let wait = interval;
+            let count = 0;
+            let lastErr: Error;
+
+            const retry = async (): Promise<Response> => {
+
+                // if we've tried too many times, throw
+                if (count >= retries) {
+                    throw lastErr || new HttpRequestError(`Retry count exceeded (${retries}) for this request. ${response?.status}: ${response?.statusText};`, response || null);
+                }
+
+                count++;
+
+                if (typeof response === "undefined" || response?.status === 429 || response?.status === 503 || response?.status === 504) {
+                    // this is our first try and response isn't defined yet
+                    // we have been throttled OR http status code 503 or 504, we can retry this
+
+                    if (typeof response !== "undefined") {
+
+                        // this isn't our first try so we need to calculate delay
+                        if (response.headers.has("Retry-After")) {
+
+                            // if we have gotten a header, use that value as the delay value in seconds
+                            wait = parseInt(response?.headers?.get("Retry-After") || "1", 10) * 1000;
+
+                        } else {
+
+                            // Increment our counters.
+                            wait *= 2;
+                        }
+
+                        this.log(`Attempt #${count} to retry request which failed with ${response.status}: ${response.statusText}`, LogLevel.Verbose);
+                        await delay(wait);
+                    }
+
+                    try {
+
+                        this.log(`Fetch: ${init.method} ${url.toString()}`, LogLevel.Verbose);
+
+                        response = await <any>nodeFetch(url.toString(), <any>init);
+
+                        // if we got a good response, return it, otherwise see if we can retry
+                        return response.ok ? response : retry();
+
+                    } catch (err) {
+
+                        if (err && err.code && ["ETIMEDOUT", "ESOCKETTIMEDOUT", "ECONNREFUSED", "ECONNRESET"].indexOf(err.code.toUpperCase()) < 0) {
+                            // this is some non-transient node error, no retry
+                            throw err;
+                        }
+
+                        if (/AbortError/.test(err.name)) {
+                            // don't retry canceled requests
+                            throw err;
+                        }
+
+                        lastErr = err;
+                        return retry();
+                    }
+
+                } else {
+
+                    return response;
+                }
+            };
+
+            // this the the first call to retry that starts the cycle
+            // response is undefined and the other values have their defaults
+            return retry();
+        });
+
+        return instance;
+    };
+}

package/packages/nodejs/behaviors/graphdefault.ts

@@ -0,0 +1,50 @@
+import { Configuration } from "@azure/msal-node";
+import { combine, isUrlAbsolute, TimelinePipe } from "@pnp/core";
+import { DefaultParse, Queryable } from "@pnp/queryable";
+import { DefaultHeaders, DefaultInit } from "@pnp/graph";
+import { NodeFetchWithRetry } from "./fetch.js";
+import { MSAL } from "./msal.js";
+
+export interface IGraphDefaultProps {
+    baseUrl?: string;
+    msal?: {
+        config: Configuration;
+        scopes?: string[];
+    };
+}
+
+/**
+ * Behavior for adding the default observers to the Graph queryable object
+ * @param props - Specify the IGraphDefaultProps for configuring the object
+ *        props.msal: (deprecated, use separate MSAL behavior)
+ */
+export function GraphDefault(props?: IGraphDefaultProps): TimelinePipe<Queryable> {
+
+    if (props?.baseUrl && !isUrlAbsolute(props?.baseUrl)) {
+        throw Error("GraphDefault props.baseUrl must be absolute when supplied.");
+    }
+
+    const { baseUrl, msal } = {
+        baseUrl: "https://graph.microsoft.com/",
+        ...props,
+    };
+
+    return (instance: Queryable) => {
+        const behaviors: TimelinePipe<any>[] = [DefaultHeaders(), DefaultInit(), NodeFetchWithRetry(), DefaultParse()];
+        if(props?.msal){
+            behaviors.push(MSAL(msal.config, msal?.scopes || [combine(baseUrl, ".default")]));
+        }
+        instance.using(...behaviors);
+
+        instance.on.pre(async (url, init, result) => {
+
+            if (!isUrlAbsolute(url)) {
+                url = combine(baseUrl, url);
+            }
+
+            return [url, init, result];
+        });
+
+        return instance;
+    };
+}

package/packages/nodejs/behaviors/msal.ts

@@ -0,0 +1,24 @@
+import { ConfidentialClientApplication, Configuration } from "@azure/msal-node";
+import { objectDefinedNotNull, TimelinePipe } from "@pnp/core";
+import { Queryable } from "@pnp/queryable";
+
+export function MSAL(config: Configuration, scopes: string[] = ["https://graph.microsoft.com/.default"]): TimelinePipe<Queryable> {
+
+    const confidentialClient = new ConfidentialClientApplication(config);
+
+    return (instance: Queryable) => {
+
+        instance.on.auth(async (url: URL, init: RequestInit) => {
+
+            const token = await confidentialClient.acquireTokenByClientCredential({ scopes });
+
+            if (objectDefinedNotNull(token)) {
+                init.headers = { ...init.headers, Authorization: `${token.tokenType} ${token.accessToken}` };
+            }
+
+            return [url, init];
+        });
+
+        return instance;
+    };
+}