@zxncij2390/monorepo3 3.18.0

package/packages/graph/onenote/types.ts

@@ -0,0 +1,119 @@
+import { body } from "@pnp/queryable";
+import { Notebook as INotebookType, Onenote as IOnenoteType, OnenoteSection as ISectionType, OnenotePage as IOnenotePageType } from "@microsoft/microsoft-graph-types";
+import {
+    GraphQueryableCollection,
+    _GraphQueryableInstance,
+    _GraphQueryableCollection,
+    IGraphQueryableCollection,
+    graphInvokableFactory,
+} from "../graphqueryable.js";
+import { defaultPath, getById, IGetById } from "../decorators.js";
+import { graphPost } from "../operations.js";
+
+/**
+ * Represents a onenote entity
+ */
+@defaultPath("onenote")
+export class _OneNote extends _GraphQueryableInstance<IOnenoteType> {
+
+    public get notebooks(): INotebooks {
+        return Notebooks(this);
+    }
+
+    public get sections(): ISections {
+        return Sections(this);
+    }
+
+    public get pages(): IGraphQueryableCollection<IOnenotePageType[]> {
+        return GraphQueryableCollection(this, "pages");
+    }
+}
+export interface IOneNote extends _OneNote {}
+export const OneNote = graphInvokableFactory<IOneNote>(_OneNote);
+
+
+/**
+ * Describes a notebook instance
+ *
+ */
+export class _Notebook extends _GraphQueryableInstance<INotebookType> {
+    public get sections(): ISections {
+        return Sections(this);
+    }
+}
+export interface INotebook extends _Notebook {}
+export const Notebook = graphInvokableFactory<INotebook>(_Notebook);
+
+/**
+ * Describes a collection of Notebook objects
+ *
+ */
+@defaultPath("notebooks")
+@getById(Notebook)
+export class _Notebooks extends _GraphQueryableCollection<INotebookType[]> {
+    /**
+     * Create a new notebook as specified in the request body.
+     *
+     * @param displayName Notebook display name
+     */
+    public async add(displayName: string): Promise<INotebookAddResult> {
+
+        const data = await graphPost(this, body({ displayName }));
+
+        return {
+            data,
+            notebook: (<any>this).getById(data.id),
+        };
+    }
+}
+export interface INotebooks extends _Notebooks, IGetById<INotebook> {}
+export const Notebooks = graphInvokableFactory<INotebooks>(_Notebooks);
+
+
+/**
+ * Describes a sections instance
+ */
+export class _Section extends _GraphQueryableInstance<ISectionType> { }
+export interface ISection extends _Section { }
+export const Section = graphInvokableFactory<ISection>(_Section);
+
+/**
+ * Describes a collection of Sections objects
+ *
+ */
+@defaultPath("sections")
+@getById(Section)
+export class _Sections extends _GraphQueryableCollection<ISectionType[]> {
+    /**
+     * Adds a new section
+     *
+     * @param displayName New section display name
+     */
+    public async add(displayName: string): Promise<ISectionAddResult> {
+
+        const data = await graphPost(this, body({ displayName }));
+
+        return {
+            data,
+            section: (<any>this).getById(data.id),
+        };
+    }
+}
+export interface ISections extends _Sections, IGetById<ISection> {}
+export const Sections = graphInvokableFactory<ISections>(_Sections);
+
+/**
+ * INotebookAddResult
+ */
+export interface INotebookAddResult {
+    data: any;
+    notebook: INotebook;
+}
+
+/**
+ * ISectionAddResult
+ */
+export interface ISectionAddResult {
+    data: any;
+    section: ISection;
+}

package/packages/graph/onenote/users.ts

@@ -0,0 +1,14 @@
+import { addProp } from "@pnp/queryable";
+import { _User } from "../users/types.js";
+import { IOneNote, OneNote } from "./types.js";
+
+declare module "../users/types" {
+    interface _User {
+        readonly onenote: IOneNote;
+    }
+    interface IUser {
+        readonly onenote: IOneNote;
+    }
+}
+
+addProp(_User, "onenote", OneNote);

package/packages/graph/operations.ts

@@ -0,0 +1,22 @@
+import { op, get, post, patch, del, put } from "@pnp/queryable";
+import { IGraphQueryable } from "./graphqueryable.js";
+
+export const graphGet = <T = any>(o: IGraphQueryable<any>, init?: RequestInit): Promise<T> => {
+    return op(o, get, init);
+};
+
+export const graphPost = <T = any>(o: IGraphQueryable<any>, init?: RequestInit): Promise<T> => {
+    return op(o, post, init);
+};
+
+export const graphDelete = <T = any>(o: IGraphQueryable<any>, init?: RequestInit): Promise<T> => {
+    return op(o, del, init);
+};
+
+export const graphPatch = <T = any>(o: IGraphQueryable<any>, init?: RequestInit): Promise<T> => {
+    return op(o, patch, init);
+};
+
+export const graphPut = <T = any>(o: IGraphQueryable<any>, init?: RequestInit): Promise<T> => {
+    return op(o, put, init);
+};

package/packages/graph/outlook/index.ts

@@ -0,0 +1,11 @@
+import "./users.js";
+
+export {
+    Outlook,
+    IOutlook,
+    IMasterCategories,
+    MasterCategories,
+    IMasterCategoryAddResult,
+    OutlookCategory,
+    IOutlookCategory,
+} from "./types.js";

package/packages/graph/outlook/types.ts

@@ -0,0 +1,58 @@
+import { _GraphQueryableCollection, _GraphQueryableInstance, graphInvokableFactory } from "../graphqueryable.js";
+import { OutlookUser as IOutlookType, OutlookCategory as IOutlookCategoryType } from "@microsoft/microsoft-graph-types";
+import { defaultPath, deleteable, getById, IDeleteable, IGetById, IUpdateable, updateable } from "../decorators.js";
+import { graphPost } from "@pnp/graph";
+import { body } from "@pnp/queryable";
+
+/**
+ * Outlook
+ */
+export class _Outlook extends _GraphQueryableInstance<IOutlookType> {
+
+    public get masterCategories(): IMasterCategories {
+        return MasterCategories(this);
+    }
+}
+export interface IOutlook extends _Outlook { }
+export const Outlook = graphInvokableFactory<IOutlook>(_Outlook);
+
+
+/**
+ * Describes an Outlook Category instance
+ */
+@deleteable()
+@updateable()
+export class _OutlookCategory extends _GraphQueryableInstance<IOutlookCategoryType> { }
+export interface IOutlookCategory extends _OutlookCategory, IUpdateable<IOutlookCategoryType>, IDeleteable { }
+export const OutlookCategory = graphInvokableFactory<IOutlookCategory>(_OutlookCategory);
+
+/**
+ * Categories
+ */
+@defaultPath("masterCategories")
+@getById(OutlookCategory)
+export class _MasterCategories extends _GraphQueryableCollection<IOutlookCategoryType[]> {
+
+    /**
+     * Adds a new event to the collection
+     *
+     * @param properties The set of properties used to create the event
+     */
+    public async add(properties: IOutlookCategoryType): Promise<IMasterCategoryAddResult> {
+
+        const data = await graphPost(this, body(properties));
+
+        return {
+            data,
+        };
+    }
+}
+export interface IMasterCategories extends _MasterCategories, IGetById<IOutlookCategory> { }
+export const MasterCategories = graphInvokableFactory<IMasterCategories>(_MasterCategories);
+
+/**
+ * MasterCategoryAddResult
+ */
+export interface IMasterCategoryAddResult {
+    data: IOutlookCategoryType;
+}

package/packages/graph/outlook/users.ts

@@ -0,0 +1,14 @@
+import { addProp } from "@pnp/queryable";
+import { _User } from "../users/types.js";
+import { Outlook, IOutlook } from "./types.js";
+
+declare module "../users/types" {
+    interface _User {
+        readonly outlook: IOutlook;
+    }
+    interface IUser {
+        readonly outlook: IOutlook;
+    }
+}
+
+addProp(_User, "outlook", Outlook);

package/packages/graph/package.json

@@ -0,0 +1,16 @@
+{
+    "name": "@pnp/graph",
+    "version": "0.0.0-PLACEHOLDER",
+    "description": "pnp - provides a fluent interface to query the Microsoft Graph",
+    "main": "./index.js",
+    "typings": "./index",
+    "scripts": {
+        "postinstall": "node ./post-install.cjs"
+    },
+    "dependencies": {
+        "@microsoft/microsoft-graph-types": "2.35.0",
+        "tslib": "2.6.0",
+        "@pnp/core": "0.0.0-PLACEHOLDER",
+        "@pnp/queryable": "0.0.0-PLACEHOLDER"
+    }
+}

package/packages/graph/photos/groups.ts

@@ -0,0 +1,14 @@
+import { addProp } from "@pnp/queryable";
+import { _Group } from "../groups/types.js";
+import { Photo, IPhoto } from "./types.js";
+
+declare module "../groups/types" {
+    interface _Group {
+        readonly photo: IPhoto;
+    }
+    interface IGroup {
+        readonly photo: IPhoto;
+    }
+}
+
+addProp(_Group, "photo", Photo);

package/packages/graph/photos/index.ts

@@ -0,0 +1,7 @@
+import "./groups.js";
+import "./users.js";
+
+export {
+    IPhoto,
+    Photo,
+} from "./types.js";

package/packages/graph/photos/types.ts

@@ -0,0 +1,33 @@
+import { _GraphQueryableInstance, graphInvokableFactory } from "../graphqueryable.js";
+import { BlobParse, BufferParse } from "@pnp/queryable";
+import { Photo as IPhotoType } from "@microsoft/microsoft-graph-types";
+import { defaultPath } from "../decorators.js";
+import { graphPatch } from "../operations.js";
+
+@defaultPath("photo")
+export class _Photo extends _GraphQueryableInstance<IPhotoType> {
+    /**
+     * Gets the image bytes as a blob (browser)
+     */
+    public getBlob(): Promise<Blob> {
+        return Photo(this, "$value").using(BlobParse())<Blob>();
+    }
+
+    /**
+     * Gets the image file bytes as a Buffer (node.js)
+     */
+    public getBuffer(): Promise<ArrayBuffer> {
+        return Photo(this, "$value").using(BufferParse())<ArrayBuffer>();
+    }
+
+    /**
+     * Sets the file bytes
+     *
+     * @param content Image file contents, max 4 MB
+     */
+    public setContent(content: ArrayBuffer | Blob): Promise<void> {
+        return graphPatch(Photo(this, "$value"), { body: content });
+    }
+}
+export interface IPhoto extends _Photo { }
+export const Photo = graphInvokableFactory<IPhoto>(_Photo);

package/packages/graph/photos/users.ts

@@ -0,0 +1,14 @@
+import { addProp } from "@pnp/queryable";
+import { _User } from "../users/types.js";
+import { Photo, IPhoto } from "./types.js";
+
+declare module "../users/types" {
+    interface _User {
+        readonly photo: IPhoto;
+    }
+    interface IUser {
+        readonly photo: IPhoto;
+    }
+}
+
+addProp(_User, "photo", Photo);

package/packages/graph/planner/groups.ts

@@ -0,0 +1,14 @@
+import { addProp } from "@pnp/queryable";
+import { _Group } from "../groups/types.js";
+import { IPlans, Plans } from "./types.js";
+
+declare module "../groups/types" {
+    interface _Group {
+        readonly plans: IPlans;
+    }
+    interface IGroup {
+        readonly plans: IPlans;
+    }
+}
+
+addProp(_Group, "plans", Plans, "planner/plans");

package/packages/graph/planner/index.ts

@@ -0,0 +1,42 @@
+import { GraphFI } from "../fi.js";
+import { IPlanner, Planner } from "./types.js";
+
+import "./groups.js";
+import "./users.js";
+
+export {
+    Bucket,
+    Buckets,
+    IBucket,
+    IBucketAddResult,
+    IBuckets,
+    IPlan,
+    IPlanAddResult,
+    IPlanner,
+    IPlans,
+    ITask,
+    ITaskAddResult,
+    ITasks,
+    ITaskDetails,
+    Plan,
+    Planner,
+    Plans,
+    Task,
+    Tasks,
+    TaskDetails,
+    PlanDetails,
+} from "./types.js";
+
+declare module "../fi" {
+    interface GraphFI {
+        readonly planner: IPlanner;
+    }
+}
+
+Reflect.defineProperty(GraphFI.prototype, "planner", {
+    configurable: true,
+    enumerable: true,
+    get: function (this: GraphFI) {
+        return this.create(Planner);
+    },
+});

package/packages/graph/planner/types.ts

@@ -0,0 +1,213 @@
+import {
+    PlannerPlan as IPlannerPlanType,
+    PlannerPlanDetails as IPlannerPlanDetailsType,
+    PlannerTask as IPlannerTaskType,
+    PlannerTaskDetails as IPlannerTaskDetailsType,
+    PlannerBucket as IPlannerBucketType,
+    Planner as IPlannerType,
+} from "@microsoft/microsoft-graph-types";
+import { body } from "@pnp/queryable";
+import { _GraphQueryableInstance, _GraphQueryableCollection, graphInvokableFactory } from "../graphqueryable.js";
+import { getById, IGetById, deleteableWithETag, IDeleteableWithETag, updateableWithETag, IUpdateableWithETag } from "../decorators.js";
+import { graphPost } from "../operations.js";
+import { defaultPath } from "../decorators.js";
+
+/**
+ * Planner
+ */
+@defaultPath("planner")
+export class _Planner extends _GraphQueryableInstance<IPlannerType> {
+
+    // Should Only be able to get by id, or else error occur
+    public get plans(): IPlans {
+        return Plans(this);
+    }
+
+    // Should Only be able to get by id, or else error occur
+    public get tasks(): ITasks {
+        return Tasks(this);
+    }
+
+    // Should Only be able to get by id, or else error occur
+    public get buckets(): IBuckets {
+        return Buckets(this);
+    }
+}
+export interface IPlanner extends _Planner { }
+export const Planner = graphInvokableFactory<IPlanner>(_Planner);
+
+/**
+ * Details
+ */
+@defaultPath("details")
+@updateableWithETag()
+export class _PlanDetails extends _GraphQueryableInstance<IPlannerPlanDetailsType> { }
+export interface IPlanDetails extends _PlanDetails, IUpdateableWithETag<IPlannerPlanDetailsType> { }
+export const PlanDetails = graphInvokableFactory<ITaskDetails>(_PlanDetails);
+
+/**
+ * Plan
+ */
+@updateableWithETag()
+@deleteableWithETag()
+export class _Plan extends _GraphQueryableInstance<IPlannerPlanType> {
+
+    public get tasks(): ITasks {
+        return Tasks(this);
+    }
+
+    public get buckets(): IBuckets {
+        return Buckets(this);
+    }
+
+    public get details(): IPlanDetails {
+        return PlanDetails(this);
+    }
+}
+export interface IPlan extends _Plan, IUpdateableWithETag<IPlannerPlanType>, IDeleteableWithETag { }
+export const Plan = graphInvokableFactory<IPlan>(_Plan);
+
+@defaultPath("plans")
+@getById(Plan)
+export class _Plans extends _GraphQueryableCollection<IPlannerPlanType[]> {
+    /**
+     * Create a new Planner Plan.
+     *
+     * @param owner Id of Group object.
+     * @param title The Title of the Plan.
+     */
+    public async add(owner: string, title: string): Promise<IPlanAddResult> {
+
+        const data = await graphPost(this, body({ owner, title }));
+
+        return {
+            data,
+            plan: (<any>this).getById(data.id),
+        };
+    }
+}
+export interface IPlans extends _Plans, IGetById<IPlan> { }
+export const Plans = graphInvokableFactory<IPlans>(_Plans);
+
+/**
+ * Details
+ */
+@defaultPath("details")
+@updateableWithETag()
+export class _TaskDetails extends _GraphQueryableInstance<IPlannerTaskDetailsType> { }
+export interface ITaskDetails extends _TaskDetails, IUpdateableWithETag<IPlannerTaskDetailsType> { }
+export const TaskDetails = graphInvokableFactory<ITaskDetails>(_TaskDetails);
+
+/**
+ * Task
+ */
+@updateableWithETag()
+@deleteableWithETag()
+export class _Task extends _GraphQueryableInstance<IPlannerTaskType> {
+    public get details(): ITaskDetails {
+        return TaskDetails(this);
+    }
+}
+export interface ITask extends _Task, IUpdateableWithETag<IPlannerTaskType>, IDeleteableWithETag { }
+export const Task = graphInvokableFactory<ITask>(_Task);
+
+/**
+ * Tasks
+ */
+@defaultPath("tasks")
+@getById(Task)
+export class _Tasks extends _GraphQueryableCollection<IPlannerTaskType[]> {
+    /**
+     * Create a new Planner Task.
+     *
+     * @param planId Id of Plan.
+     * @param title The Title of the Task.
+     * @param assignments Assign the task
+     * @param bucketId Id of Bucket
+     */
+    public async add(planId: string, title: string, assignments?: Record<string, any>, bucketId?: string): Promise<ITaskAddResult> {
+
+        let postBody = {
+            planId,
+            title,
+            ...assignments,
+        };
+
+        if (bucketId) {
+            postBody = <any>{
+                ...postBody,
+                bucketId,
+            };
+        }
+
+        const data = await graphPost(this, body(postBody));
+
+        return {
+            data,
+            task: (<any>this).getById(data.id),
+        };
+    }
+}
+export interface ITasks extends _Tasks, IGetById<ITask> { }
+export const Tasks = graphInvokableFactory<ITasks>(_Tasks);
+
+/**
+ * Bucket
+ */
+@updateableWithETag()
+@deleteableWithETag()
+export class _Bucket extends _GraphQueryableInstance<IPlannerBucketType> {
+    public get tasks(): ITasks {
+        return Tasks(this);
+    }
+}
+export interface IBucket extends _Bucket, IUpdateableWithETag<IPlannerBucketType>, IDeleteableWithETag { }
+export const Bucket = graphInvokableFactory<IBucket>(_Bucket);
+
+
+/**
+ * Buckets
+ */
+@defaultPath("buckets")
+@getById(Bucket)
+export class _Buckets extends _GraphQueryableCollection<IPlannerBucketType[]> {
+    /**
+     * Create a new Bucket.
+     *
+     * @param name Name of Bucket object.
+     * @param planId The Id of the Plan.
+     * @param oderHint Hint used to order items of this type in a list view.
+     */
+    public async add(name: string, planId: string, orderHint?: string): Promise<IBucketAddResult> {
+
+        const postBody = {
+            name: name,
+            orderHint: orderHint ? orderHint : "",
+            planId: planId,
+        };
+
+        const data = await graphPost(this, body(postBody));
+
+        return {
+            bucket: (<any>this).getById(data.id),
+            data,
+        };
+    }
+}
+export interface IBuckets extends _Buckets, IGetById<IBucket> { }
+export const Buckets = graphInvokableFactory<IBuckets>(_Buckets);
+
+export interface IBucketAddResult {
+    data: IPlannerBucketType;
+    bucket: IBucket;
+}
+
+export interface IPlanAddResult {
+    data: IPlannerPlanType;
+    plan: IPlan;
+}
+
+export interface ITaskAddResult {
+    data: IPlannerTaskType;
+    task: ITask;
+}

package/packages/graph/planner/users.ts

@@ -0,0 +1,14 @@
+import { addProp } from "@pnp/queryable";
+import { _User } from "../users/types.js";
+import { ITasks, Tasks } from "./types.js";
+
+declare module "../users/types" {
+    interface _User {
+        readonly tasks: ITasks;
+    }
+    interface IUser {
+        readonly tasks: ITasks;
+    }
+}
+
+addProp(_User, "tasks", Tasks, "planner/tasks");

package/packages/graph/post-install.cjs

@@ -0,0 +1,20 @@
+const { readFileSync } = require("fs");
+const { join } = require("path");
+const projectRoot = process.cwd();
+const packageLoc = join(projectRoot, "package.json");
+const packageFile = readFileSync(packageLoc, "utf8");
+const packageJSON = JSON.parse(packageFile);
+if (packageJSON.dependencies != null) {
+    const spfxVersion = packageJSON.dependencies["@microsoft/sp-core-library"];
+    if (spfxVersion != null) {
+        const spfxVersionFloat = parseFloat(spfxVersion);
+        if (spfxVersionFloat > 1.11 && spfxVersionFloat < 1.15) {
+            console.log("");
+            console.log("\x1b[43m%s\x1b[0m", " PnPjs WARNING ");
+            console.log("\x1b[33m%s\x1b[0m", "  The version of SPFx you are using requires an update to work with PnPjs. Please make sure to follow the getting started instructions to make the appropriate changes. ➡ https://pnp.github.io/pnpjs/getting-started/#spfx-version-1121-later");
+            console.log("");
+        }
+    }
+} else {
+    console.log("Package has no dependencies");
+}

package/packages/graph/presets/all.ts

@@ -0,0 +1,42 @@
+import "../attachments/index.js";
+import "../calendars/index.js";
+import "../cloud-communications/index.js";
+import "../contacts/index.js";
+import "../conversations/index.js";
+import "../directory-objects/index.js";
+import "../groups/index.js";
+import "../insights/index.js";
+import "../invitations/index.js";
+import "../members/index.js";
+import "../messages/index.js";
+import "../onedrive/index.js";
+import "../onenote/index.js";
+import "../photos/index.js";
+import "../planner/index.js";
+import "../search/index.js";
+import "../shares/index.js";
+import "../subscriptions/index.js";
+import "../teams/index.js";
+import "../users/index.js";
+
+export * from "../attachments/index.js";
+export * from "../calendars/index.js";
+export * from "../cloud-communications/index.js";
+export * from "../contacts/index.js";
+export * from "../conversations/index.js";
+export * from "../directory-objects/index.js";
+export * from "../groups/index.js";
+export * from "../insights/index.js";
+export * from "../invitations/index.js";
+export * from "../members/index.js";
+export * from "../messages/index.js";
+export * from "../onedrive/index.js";
+export * from "../onenote/index.js";
+export * from "../photos/index.js";
+export * from "../planner/index.js";
+export * from "../search/index.js";
+export * from "../shares/index.js";
+export * from "../subscriptions/index.js";
+export * from "../teams/index.js";
+export * from "../users/index.js";
+export * from "../index.js";