@zxncij2390/monorepo3 3.18.0

package/packages/graph/conversations/types.ts

@@ -0,0 +1,147 @@
+import { body } from "@pnp/queryable";
+import {
+    ConversationThread as IConversationThreadType,
+    Post as IPostType,
+    Recipient as IRecipientType,
+    Conversation as IConversationType,
+    User as IUserType,
+} from "@microsoft/microsoft-graph-types";
+import {
+    _GraphQueryableCollection,
+    _GraphQueryableInstance,
+    graphInvokableFactory,
+} from "../graphqueryable.js";
+import { defaultPath, updateable, IUpdateable, deleteable, IDeleteable, addable, IAddable, getById, IGetById } from "../decorators.js";
+import { graphPost, graphDelete } from "../operations.js";
+
+/**
+ * Conversation
+ */
+@updateable()
+@deleteable()
+export class _Conversation extends _GraphQueryableInstance<IConversationType> {
+
+    /**
+     * Get all the threads in a group conversation.
+     */
+    public get threads(): IThreads {
+        return Threads(this);
+    }
+}
+export interface IConversation extends _Conversation, IUpdateable<IConversationType>, IDeleteable { }
+export const Conversation = graphInvokableFactory<IConversation>(_Conversation);
+
+/**
+ * Conversations
+ */
+@defaultPath("conversations")
+@addable()
+@getById(Conversation)
+export class _Conversations extends _GraphQueryableCollection<IConversationType[]> { }
+export interface IConversations extends _Conversations, IGetById<IConversation>, IAddable<IConversationType> { }
+export const Conversations = graphInvokableFactory<IConversations>(_Conversations);
+
+/**
+ * Thread
+ */
+@deleteable()
+export class _Thread extends _GraphQueryableInstance {
+
+    /**
+     * Get all the threads in a group conversation.
+     */
+    public get posts(): IPosts {
+        return Posts(this);
+    }
+
+    /**
+     * Reply to a thread in a group conversation and add a new post to it
+     *
+     * @param post Contents of the post
+     */
+    public reply(post: IPostType): Promise<void> {
+        return graphPost(Thread(this, "reply"), body(post));
+    }
+}
+export interface IThread extends _Thread, IDeleteable { }
+export const Thread = graphInvokableFactory<IThread>(_Thread);
+
+/**
+ * Threads
+ */
+@defaultPath("threads")
+@addable()
+@getById(Thread)
+export class _Threads extends _GraphQueryableCollection<IConversationThreadType[]> { }
+export interface IThreads extends _Threads, IGetById<IThread>, IAddable<IConversationThreadType, { id: string }> { }
+export const Threads = graphInvokableFactory<IThreads>(_Threads);
+
+
+/**
+ * Post
+ */
+@deleteable()
+export class _Post extends _GraphQueryableInstance<IPostType> {
+    /**
+     * Forward a post to a recipient
+     */
+    public forward(info: IPostForwardInfo): Promise<void> {
+        return graphPost(Post(this, "forward"), body(info));
+    }
+
+    /**
+     * Reply to a thread in a group conversation and add a new post to it
+     *
+     * @param post Contents of the post
+     */
+    public reply(post: IPostType): Promise<void> {
+        return graphPost(Post(this, "reply"), body(post));
+    }
+}
+export interface IPost extends _Post, IDeleteable { }
+export const Post = graphInvokableFactory<IPost>(_Post);
+
+/**
+ * Posts
+ */
+@defaultPath("posts")
+@addable()
+@getById(Post)
+export class _Posts extends _GraphQueryableCollection<IPostType[]> { }
+export interface IPosts extends _Posts, IGetById<IPost>, IAddable<IPostType> { }
+export const Posts = graphInvokableFactory<IPosts>(_Posts);
+
+/**
+ * Senders
+ */
+export class _Senders extends _GraphQueryableCollection<IUserType[]> {
+
+    /**
+     * Add a new user or group to this senders collection
+     * @param id The full @odata.id value to add (ex: https://graph.microsoft.com/v1.0/users/user@contoso.com)
+     */
+    public add(id: string): Promise<any> {
+        return graphPost(Senders(this, "$ref"), body({ "@odata.id": id }));
+    }
+
+    /**
+     * Removes the entity from the collection
+     *
+     * @param id The full @odata.id value to remove (ex: https://graph.microsoft.com/v1.0/users/user@contoso.com)
+     */
+    public remove(id: string): Promise<void> {
+        const remover = Senders(this, "$ref");
+        remover.query.set("$id", id);
+        return graphDelete(remover);
+    }
+}
+export interface ISenders extends _Senders { }
+export const Senders = graphInvokableFactory<ISenders>(_Senders);
+
+/**
+ * Information used to forward a post
+ */
+export interface IPostForwardInfo {
+    comment?: string;
+    toRecipients: IRecipientType[];
+}

package/packages/graph/decorators.ts

@@ -0,0 +1,164 @@
+import { IGraphQueryable } from "./graphqueryable.js";
+import { graphDelete, graphPatch, graphPost } from "./operations.js";
+import { body, headers } from "@pnp/queryable";
+
+/**
+ * Decorator used to specify the default path for Queryable objects
+ *
+ * @param path
+ */
+export function defaultPath(path: string) {
+
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    return function <T extends { new(...args: any[]): {} }>(target: T) {
+
+        return class extends target {
+            constructor(...args: any[]) {
+                super(args[0], args.length > 1 && args[1] !== undefined ? args[1] : path);
+            }
+        };
+    };
+}
+
+/**
+ * Adds the delete method to the tagged class
+ */
+export function deleteable() {
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    return function <T extends { new(...args: any[]): {} }>(target: T) {
+
+        return class extends target {
+            public delete(this: IGraphQueryable): Promise<void> {
+                return graphDelete(this);
+            }
+        };
+    };
+}
+
+export interface IDeleteable {
+    /**
+     * Delete this instance
+     */
+    delete(): Promise<void>;
+}
+
+/**
+ * Adds the delete method to the tagged class
+ */
+export function deleteableWithETag() {
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    return function <T extends { new(...args: any[]): {} }>(target: T) {
+
+        return class extends target {
+            public delete(this: IGraphQueryable, eTag = "*"): Promise<void> {
+                return graphDelete(this, headers({
+                    "If-Match": eTag,
+                }));
+            }
+        };
+    };
+}
+
+export interface IDeleteableWithETag {
+    /**
+     * Delete this instance
+     */
+    delete(eTag?: string): Promise<void>;
+}
+
+/**
+ * Adds the update method to the tagged class
+ */
+export function updateable() {
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    return function <T extends { new(...args: any[]): {} }>(target: T) {
+
+        return class extends target {
+            public update(this: IGraphQueryable, props: any): Promise<T> {
+                return graphPatch(this, body(props));
+            }
+        };
+    };
+}
+
+export interface IUpdateable<T = any> {
+    /**
+     * Update the properties of an event object
+     *
+     * @param props Set of properties to update
+     */
+    update(props: T): Promise<T>;
+}
+
+/**
+ * Adds the update method to the tagged class
+ */
+export function updateableWithETag() {
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    return function <T extends { new(...args: any[]): {} }>(target: T) {
+
+        return class extends target {
+            public update(this: IGraphQueryable, props: any, eTag = "*"): Promise<T> {
+                return graphPatch(this, body(props, headers({
+                    "If-Match": eTag,
+                })));
+            }
+        };
+    };
+}
+
+export interface IUpdateableWithETag<T = any> {
+    /**
+     * Update the properties of an event object
+     *
+     * @param props Set of properties to update
+     */
+    update(props: T, eTag?: string): Promise<T>;
+}
+
+/**
+ * Adds the add method to the tagged class
+ */
+export function addable() {
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    return function <T extends { new(...args: any[]): {} }>(target: T) {
+
+        return class extends target {
+            public add(this: IGraphQueryable, props: any): Promise<void> {
+                return graphPost(this, body(props));
+            }
+        };
+    };
+}
+
+export interface IAddable<T = any, R = { id: string }> {
+    /**
+     * Adds a new item to this collection
+     *
+     * @param props properties used to create the new thread
+     */
+    add(props: T): Promise<R>;
+}
+
+/**
+ * Adds the getById method to a collection
+ */
+export function getById<R>(factory: (...args: any[]) => R) {
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    return function <T extends { new(...args: any[]): {} }>(target: T) {
+
+        return class extends target {
+            public getById(this: IGraphQueryable, id: string): R {
+                return factory(this, id);
+            }
+        };
+    };
+}
+export interface IGetById<R = any, T = string> {
+    /**
+     * Adds a new item to this collection
+     *
+     * @param props properties used to create the new thread
+     */
+    getById(id: T): R;
+}

package/packages/graph/directory-objects/index.ts

@@ -0,0 +1,24 @@
+import { GraphFI } from "../fi.js";
+import { IDirectoryObjects, DirectoryObjects } from "./types.js";
+
+export {
+    IDirectoryObject,
+    DirectoryObjectTypes,
+    DirectoryObject,
+    DirectoryObjects,
+    IDirectoryObjects,
+} from "./types.js";
+
+declare module "../fi" {
+    interface GraphFI {
+        readonly directoryObjects: IDirectoryObjects;
+    }
+}
+
+Reflect.defineProperty(GraphFI.prototype, "directoryObjects", {
+    configurable: true,
+    enumerable: true,
+    get: function (this: GraphFI) {
+        return this.create(DirectoryObjects);
+    },
+});

package/packages/graph/directory-objects/types.ts

@@ -0,0 +1,94 @@
+import { _GraphQueryableCollection, _GraphQueryableInstance, graphInvokableFactory } from "../graphqueryable.js";
+import { DirectoryObject as IDirectoryObjectType } from "@microsoft/microsoft-graph-types";
+import { defaultPath, getById, IGetById, deleteable, IDeleteable } from "../decorators.js";
+import { body } from "@pnp/queryable";
+import { graphPost } from "../operations.js";
+import { Count } from "../behaviors/paged.js";
+
+/**
+ * Represents a Directory Object entity
+ */
+@deleteable()
+export class _DirectoryObject<GetType = IDirectoryObjectType> extends _GraphQueryableInstance<GetType> {
+
+    /**
+   * Returns all the groups and directory roles that the specified Directory Object is a member of. The check is transitive
+   *
+   * @param securityEnabledOnly
+   */
+    public getMemberObjects(securityEnabledOnly = false): Promise<string[]> {
+        return graphPost(DirectoryObject(this, "getMemberObjects"), body({ securityEnabledOnly }));
+    }
+
+    /**
+   * Returns all the groups that the specified Directory Object is a member of. The check is transitive
+   *
+   * @param securityEnabledOnly
+   */
+    public getMemberGroups(securityEnabledOnly = false): Promise<string[]> {
+        return graphPost(DirectoryObject(this, "getMemberGroups"), body({ securityEnabledOnly }));
+    }
+
+    /**
+   * Check for membership in a specified list of groups, and returns from that list those groups of which the specified user, group, or directory object is a member.
+   * This function is transitive.
+   * @param groupIds A collection that contains the object IDs of the groups in which to check membership. Up to 20 groups may be specified.
+   */
+    public checkMemberGroups(groupIds: string[]): Promise<string[]> {
+        return graphPost(DirectoryObject(this, "checkMemberGroups"), body({ groupIds }));
+    }
+}
+
+export interface IDirectoryObject extends _DirectoryObject, IDeleteable { }
+export const DirectoryObject = graphInvokableFactory<IDirectoryObject>(_DirectoryObject);
+
+/**
+ * Describes a collection of Directory Objects
+ *
+ */
+@defaultPath("directoryObjects")
+@getById(DirectoryObject)
+export class _DirectoryObjects<GetType = IDirectoryObjectType[]> extends _GraphQueryableCollection<GetType> {
+    /**
+  * Returns the directory objects specified in a list of ids. NOTE: The directory objects returned are the full objects containing all their properties.
+  * The $select query option is not available for this operation.
+  *
+  * @param ids A collection of ids for which to return objects. You can specify up to 1000 ids.
+  * @param type A collection of resource types that specifies the set of resource collections to search. Default is directoryObject.
+  */
+    public getByIds(ids: string[], type: DirectoryObjectTypes = DirectoryObjectTypes.directoryObject): Promise<IDirectoryObjectType[]> {
+        return graphPost(DirectoryObjects(this, "getByIds"), body({ ids, type }));
+    }
+
+    /**
+     * 	Retrieves the total count of matching resources
+     *  If the resource doesn't support count, this value will always be zero
+     */
+    public async count(): Promise<number> {
+        return Count(this);
+    }
+}
+export interface IDirectoryObjects extends _DirectoryObjects, IGetById<IDirectoryObjectType> { }
+export const DirectoryObjects = graphInvokableFactory<IDirectoryObjects>(_DirectoryObjects);
+
+/**
+ * DirectoryObjectTypes
+ */
+export enum DirectoryObjectTypes {
+    /**
+   * Directory Objects
+   */
+    directoryObject,
+    /**
+   * User
+   */
+    user,
+    /**
+   * Group
+   */
+    group,
+    /**
+   * Device
+   */
+    device,
+}

package/packages/graph/fi.ts

@@ -0,0 +1,46 @@
+import { TimelinePipe } from "@pnp/core";
+import { GraphQueryable, IGraphInvokableFactory, IGraphQueryable, GraphInit } from "./graphqueryable.js";
+
+export class GraphFI {
+
+    protected _root: IGraphQueryable;
+
+    /**
+     * Creates a new instance of the GraphFI class
+     *
+     * @param root Establishes a root url/configuration
+     */
+    constructor(root: GraphInit = "") {
+
+        this._root = GraphQueryable(root);
+    }
+
+    /**
+     * Applies one or more behaviors which will be inherited by all instances chained from this root
+     *
+     */
+    public using(...behaviors: TimelinePipe[]): this {
+
+        this._root.using(...behaviors);
+        return this;
+    }
+
+    /**
+     * Used by extending classes to create new objects directly from the root
+     *
+     * @param factory The factory for the type of object to create
+     * @returns A configured instance of that object
+     */
+    protected create<T extends IGraphQueryable>(factory: IGraphInvokableFactory<T>, path?: string): T {
+        return factory(this._root, path);
+    }
+}
+
+export function graphfi(root: GraphInit | GraphFI = ""): GraphFI {
+
+    if (typeof root === "object" && !Reflect.has(root, "length")) {
+        root = (<any>root)._root;
+    }
+
+    return new GraphFI(<any>root);
+}

package/packages/graph/graphqueryable.ts

@@ -0,0 +1,193 @@
+import { isArray } from "@pnp/core";
+import { IInvokable, Queryable, queryableFactory } from "@pnp/queryable";
+import { ConsistencyLevel } from "./behaviors/consistency-level.js";
+import { AsAsyncIterable } from "./behaviors/paged.js";
+
+export type GraphInit = string | IGraphQueryable | [IGraphQueryable, string];
+
+export interface IGraphQueryableConstructor<T> {
+    new(base: GraphInit, path?: string): T;
+}
+
+export type IGraphInvokableFactory<R extends IGraphQueryable> = (base: GraphInit, path?: string) => R & IInvokable;
+
+export const graphInvokableFactory = <R extends IGraphQueryable>(f: any): IGraphInvokableFactory<R> => {
+    return queryableFactory<R>(f);
+};
+
+/**
+ * Queryable Base Class
+ *
+ */
+export class _GraphQueryable<GetType = any> extends Queryable<GetType> {
+
+    protected parentUrl: string;
+
+    /**
+     * Creates a new instance of the Queryable class
+     *
+     * @constructor
+     * @param base A string or Queryable that should form the base part of the url
+     *
+     */
+    constructor(base: GraphInit, path?: string) {
+
+        super(base, path);
+
+        if (typeof base === "string") {
+
+            this.parentUrl = base;
+
+        } else if (isArray(base)) {
+
+            this.parentUrl = base[0].toUrl();
+
+        } else {
+
+            this.parentUrl = base.toUrl();
+        }
+    }
+
+    /**
+     * Choose which fields to return
+     *
+     * @param selects One or more fields to return
+     */
+    public select(...selects: string[]): this {
+        if (selects.length > 0) {
+            this.query.set("$select", selects.join(","));
+        }
+        return this;
+    }
+
+    /**
+     * Expands fields such as lookups to get additional data
+     *
+     * @param expands The Fields for which to expand the values
+     */
+    public expand(...expands: string[]): this {
+        if (expands.length > 0) {
+            this.query.set("$expand", expands.join(","));
+        }
+        return this;
+    }
+
+    /**
+     * Gets a parent for this instance as specified
+     *
+     * @param factory The contructor for the class to create
+     */
+    protected getParent<T extends _GraphQueryable>(
+        factory: IGraphQueryableConstructor<T>,
+        base: GraphInit = this.parentUrl,
+        path?: string): T {
+
+        if (typeof base === "string") {
+            // we need to ensure the parent has observers, even if we are rebasing the url (#2435)
+            base = [this, base];
+        }
+
+        return new factory(base, path);
+    }
+}
+
+export interface IGraphQueryable<GetType = any> extends _GraphQueryable<GetType> { }
+export const GraphQueryable = graphInvokableFactory<IGraphQueryable>(_GraphQueryable);
+
+/**
+ * Represents a REST collection which can be filtered, paged, and selected
+ *
+ */
+export class _GraphQueryableCollection<GetType = any[]> extends _GraphQueryable<GetType> {
+
+    /**
+     *
+     * @param filter The string representing the filter query
+     */
+    public filter(filter: string): this {
+        this.query.set("$filter", filter);
+        return this;
+    }
+
+    /**
+     * Orders based on the supplied fields
+     *
+     * @param orderby The name of the field on which to sort
+     * @param ascending If false DESC is appended, otherwise ASC (default)
+     */
+    public orderBy(orderBy: string, ascending = true): this {
+        const o = "$orderby";
+        const query = this.query.get(o)?.split(",") || [];
+        query.push(`${orderBy} ${ascending ? "asc" : "desc"}`);
+        this.query.set(o, query.join(","));
+        return this;
+    }
+
+    /**
+     * Limits the query to only return the specified number of items
+     *
+     * @param top The query row limit
+     */
+    public top(top: number): this {
+        this.query.set("$top", top.toString());
+        return this;
+    }
+
+    /**
+     * Skips a set number of items in the return set
+     *
+     * @param num Number of items to skip
+     */
+    public skip(num: number): this {
+        this.query.set("$skip", num.toString());
+        return this;
+    }
+
+    /**
+     * Skips a set number of items in the return set
+     *
+     * @param num Number of items to skip
+     */
+    public search(query: string): this {
+        this.using(ConsistencyLevel());
+        this.query.set("$search", query);
+        return this;
+    }
+
+    /**
+     * 	To request second and subsequent pages of Graph data
+     */
+    public skipToken(token: string): this {
+        this.query.set("$skiptoken", token);
+        return this;
+    }
+
+    /**
+     * 	Retrieves the total count of matching resources
+     *  If the resource doesn't support count, this value will always be zero
+     */
+    public async count(): Promise<number> {
+        // TODO::do we want to do this, or just attach count to the collections that support it? we could use a decorator for countable on the few collections that support count.
+        return -1;
+    }
+
+    /**
+     * Allows reading through a collection as pages of information whose size is determined by top or the api method's default
+     *
+     * @returns an object containing results, the ability to determine if there are more results, and request the next page of results
+     */
+    public paged(): AsyncIterable<GetType> {
+        return AsAsyncIterable(this);
+    }
+}
+export interface IGraphQueryableCollection<GetType = any[]> extends _GraphQueryableCollection<GetType> { }
+export const GraphQueryableCollection = graphInvokableFactory<IGraphQueryableCollection>(_GraphQueryableCollection);
+
+/**
+ * Represents an instance that can be selected
+ *
+ */
+export class _GraphQueryableInstance<GetType = any> extends _GraphQueryable<GetType> { }
+
+export interface IGraphQueryableInstance<GetType = any> extends IInvokable, IGraphQueryable<GetType> { }
+export const GraphQueryableInstance = graphInvokableFactory<IGraphQueryableInstance>(_GraphQueryableInstance);

package/packages/graph/groups/index.ts

@@ -0,0 +1,25 @@
+import { GraphFI } from "../fi.js";
+import { IGroups, Groups } from "./types.js";
+
+export {
+    Group,
+    GroupType,
+    Groups,
+    IGroup,
+    IGroupAddResult,
+    IGroups,
+} from "./types.js";
+
+declare module "../fi" {
+    interface GraphFI {
+        readonly groups: IGroups;
+    }
+}
+
+Reflect.defineProperty(GraphFI.prototype, "groups", {
+    configurable: true,
+    enumerable: true,
+    get: function (this: GraphFI) {
+        return this.create(Groups);
+    },
+});