Workbook package

packages/graph/behaviors/prefer-async.ts

@@ -0,0 +1,39 @@
+import { TimelinePipe } from "@pnp/core";
+import { InjectHeaders } from "@pnp/queryable";
+import { GraphQueryable, _GraphQueryable, graphGet } from "../graphqueryable.js";
+import { RichLongRunningOperation } from "@microsoft/microsoft-graph-types";
+
+export function PreferAsync(pollIntervalMs: number = 25000, maxPolls: number = 4): TimelinePipe {
+    return (instance: _GraphQueryable) => {
+        instance.using(InjectHeaders({ "Prefer": "respond-async" }));
+
+        instance.on.parse(async function (url, response, result) {
+            if (response.status === 202) {
+                const opLocation = response.headers.get("Location");
+                const opId = opLocation.split("/").at(-1);
+
+                let succeeded = false;
+                const statusQuery = GraphQueryable(instance, `operations/${opId}`);
+                for (let i = 0; i < maxPolls; i++) {
+                    await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
+
+                    const status = await graphGet<RichLongRunningOperation>(statusQuery);
+                    if (status.status === 'succeeded') {
+                        let resultEndpoint = status.resourceLocation.split("/").at(-1);
+                        result = await graphGet(GraphQueryable(instance, resultEndpoint));
+                        succeeded = true;
+                        break;
+                    } else if (status.status === 'failed') {
+                        throw status.error;
+                    }
+                }
+                if (!succeeded) {
+                    throw new Error(`Timed out waiting for async operation after ${pollIntervalMs * maxPolls}ms`);
+                }
+            }
+            return [url, response, result];
+        })
+
+        return instance;
+    }
+}

packages/graph/workbooks/driveitem.ts

@@ -0,0 +1,18 @@
+import { addProp } from "@pnp/queryable";
+import { _DriveItem } from "../files/types.js";
+import { IWorkbook, IWorkbookWithSession, Workbook } from "./types.js";
+import { getWorkbookSession } from "./session.js";
+
+declare module "../files/types.js" {
+    interface _DriveItem {
+        readonly workbook: IWorkbook;
+        getWorkbookSession(persistChanges: boolean): Promise<IWorkbookWithSession>;
+    }
+    interface DriveItem {
+        readonly workbook: IWorkbook;
+        getWorkbookSession(persistChanges: boolean): Promise<IWorkbookWithSession>;
+    }
+}
+
+addProp(_DriveItem, "workbook", Workbook);
+_DriveItem.prototype.getWorkbookSession = getWorkbookSession;

packages/graph/workbooks/index.ts

@@ -0,0 +1,11 @@
+import "./driveitem.js";
+
+export { 
+    IWorkbook,
+    ITable,
+    ITables,
+    ITableRow,
+    ITableRows,
+    ITableColumn,
+    ITableColumns
+} from "./types.js";

packages/graph/workbooks/session.ts

@@ -0,0 +1,20 @@
+import { GraphQueryable, graphPost } from "../graphqueryable.js";
+import { InjectHeaders, body } from "@pnp/queryable";
+import { IWorkbookWithSession, WorkbookWithSession } from "./types.js";
+import { _DriveItem } from "../files/types.js";
+import {
+    WorkbookSessionInfo
+} from "@microsoft/microsoft-graph-types";
+
+export async function getWorkbookSession(this: _DriveItem, persistChanges: boolean): Promise<IWorkbookWithSession> {
+    const workbook = WorkbookWithSession(this);
+    const sessionResult = await graphPost<WorkbookSessionInfo>(
+        GraphQueryable(workbook, 'createSession'), body({
+            persistChanges
+        }));
+
+    if (!sessionResult.id) throw new Error("createSession did not respond with a session ID");
+
+    workbook.using(InjectHeaders({ "workbook-session-id": sessionResult.id }));
+    return workbook;
+}

packages/graph/workbooks/types.ts

@@ -0,0 +1,91 @@
+import { updateable, IUpdateable, addable, getById, IAddable, IGetById, deleteable, IDeleteable, defaultPath } from "../decorators.js";
+import { _GraphCollection, graphInvokableFactory, _GraphInstance, GraphQueryable } from "../graphqueryable.js";
+import {
+    Workbook as WorkbookType, 
+    WorkbookTable as WorkbookTableType, 
+    WorkbookTableRow as WorkbookTableRowType,
+    WorkbookTableColumn as WorkbookTableColumnType
+} from "@microsoft/microsoft-graph-types";
+import { graphPost } from "@pnp/graph";
+
+@defaultPath("workbook")
+export class _Workbook extends _GraphInstance<WorkbookType> {
+    public get tables(): ITables {
+        return Tables(this);
+    }
+}
+export interface IWorkbook  extends _Workbook {}
+export const Workbook = graphInvokableFactory<IWorkbook>(_Workbook);
+
+export class _WorkbookWithSession extends _Workbook {
+    public closeSession(): Promise<void> {
+        return graphPost(GraphQueryable(this, "closeSession"));
+    }
+
+    public refreshSession(): Promise<void> {
+        return graphPost(GraphQueryable(this, "refreshSession"));
+    }
+}
+export interface IWorkbookWithSession extends _WorkbookWithSession {}
+export const WorkbookWithSession = graphInvokableFactory<IWorkbookWithSession>(_WorkbookWithSession);
+
+@updateable()
+@deleteable()
+export class _Table extends _GraphInstance<WorkbookTableType> {
+    public get rows(): ITableRows {
+        return TableRows(this);
+    }
+    public get columns(): ITableColumns {
+        return TableColumns(this);
+    }
+}
+export interface ITable extends _Table, IUpdateable, IDeleteable {}
+export const Table = graphInvokableFactory<ITable>(_Table);
+
+@defaultPath("tables")
+@addable()
+@getById(Table)
+export class _Tables extends _GraphCollection<WorkbookTableType[]> {
+    public getByName(name: string): ITable {
+        return Table(this, name);
+    }
+}
+export interface ITables extends _Tables, IAddable, IGetById<ITable> {}
+export const Tables = graphInvokableFactory<ITables>(_Tables);
+
+@deleteable()
+@updateable()
+export class _TableRow extends _GraphInstance<WorkbookTableRowType> {
+
+}
+export interface ITableRow extends _TableRow, IUpdateable, IDeleteable {}
+export const TableRow = graphInvokableFactory<ITableRow>(_TableRow);
+
+@defaultPath("rows")
+@addable()
+export class _TableRows extends _GraphCollection<WorkbookTableRowType[]> {
+    public getByIndex(index: number): ITableRow {
+        return TableRow(this, `${index}`);
+    }
+}
+export interface ITableRows extends _TableRows, IAddable {}
+export const TableRows = graphInvokableFactory<ITableRows>(_TableRows);
+
+@deleteable()
+@updateable()
+export class _TableColumn extends _GraphInstance<WorkbookTableColumnType> {
+
+}
+export interface ITableColumn extends _TableColumn, IUpdateable, IDeleteable {}
+export const TableColumn = graphInvokableFactory<ITableColumn>(_TableColumn);
+
+@defaultPath("columns")
+@addable()
+@getById(TableColumn)
+export class _TableColumns extends _GraphCollection<WorkbookTableColumnType[]> {
+    public getByName(name: string): ITableColumn {
+        return TableColumn(this, name);
+    }
+}
+export interface ITableColumns extends _TableColumns, IAddable {}
+export const TableColumns = graphInvokableFactory<ITableColumns>(_TableColumns);