@lindle/sharepoint_requests 0.1.9-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 lion.oncemore@gmail.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,170 @@
+# HTTP SharePoint Requests
+
+This package is a TypeScript library for interacting with SharePoint REST APIs. It provides a structured and flexible approach to perform CRUD operations, handle user information, manage files, and retrieve metadata from SharePoint lists.
+
+## Installation
+
+Install the package using npm:
+
+```bash
+npm install sharepoint-requests
+```
+
+## Usage
+
+### Create a SharePoint Request Instance
+
+```typescript
+import createBase from 'sharepoint-requests';
+
+const sharepoint = createBase().create({
+  baseURL: 'https://your-sharepoint-site.com',
+});
+```
+
+### Basic Methods
+
+#### Retrieve List Fields
+
+```typescript
+const fields = await sharepoint.field('ListName', 'FieldName');
+console.log(fields);
+```
+
+#### Access Lists
+
+```typescript
+const lists = await sharepoint.lists().get();
+console.log(lists);
+```
+
+#### Access Items in a List
+
+```typescript
+const { data, meta } = await sharepoint.from('ListName').get({ limit: 10 });
+console.log({ data, meta });
+```
+
+#### Create a New Item in a List
+
+```typescript
+const newItem = await sharepoint.from('ListName').create({
+  Title: 'New Item',
+  Description: 'This is a new item.',
+});
+console.log(newItem);
+```
+
+#### Update an Item in a List
+
+```typescript
+const updatedItem = await sharepoint.from('ListName').update(1, {
+  Title: 'Updated Title',
+});
+console.log(updatedItem);
+```
+
+#### Delete an Item in a List
+
+```typescript
+await sharepoint.from('ListName').delete(1);
+console.log('Item deleted successfully');
+```
+
+### Advanced Features
+
+#### Upload Files
+
+```typescript
+const file = new File(['content'], 'example.txt');
+await sharepoint.from('ListName').createFile({ file, itemId: 1 });
+console.log('File uploaded successfully');
+```
+
+#### Send Emails
+
+```typescript
+await sharepoint.email(
+  'sender@example.com',
+  ['recipient@example.com'],
+  'Subject of Email',
+  'Body of the email content.'
+);
+console.log('Email sent successfully');
+```
+
+#### Retrieve Current User Information
+
+```typescript
+const currentUser = await sharepoint.getCurrentUser();
+console.log(currentUser);
+```
+
+#### Retrieve User Properties
+
+```typescript
+const userProfile = await sharepoint.currentUserProperties();
+console.log(userProfile);
+```
+
+### Authentication
+
+Ensure that the requests are authenticated by passing the appropriate cookies or tokens for your SharePoint environment.
+
+### Error Handling
+
+Handle errors using try-catch blocks:
+
+```typescript
+try {
+  const lists = await sharepoint.lists().get();
+  console.log(lists);
+} catch (error) {
+  console.error('An error occurred:', error);
+}
+```
+
+### TypeScript Support
+
+The package is fully typed, enabling autocompletion and type safety for all methods.
+
+## API Reference
+
+### Constructor
+
+#### `createBase<T>()`
+
+- Creates a base instance for SharePoint requests.
+- **Params:**
+  - `baseURL` (string): The base URL of your SharePoint site.
+
+### Methods
+
+#### Lists
+
+- `lists().get()` - Retrieve all lists in the SharePoint site.
+- `from(listName)` - Access specific list operations.
+
+#### Items
+
+- `create(data)` - Create a new list item.
+- `get(options)` - Retrieve list items with filters, sorting, and limits.
+- `update(id, data)` - Update an existing list item.
+- `delete(id)` - Delete a list item.
+
+#### Users
+
+- `getCurrentUser()` - Retrieve the current user information.
+- `userGetId(userName)` - Get the ID of a user by username.
+
+#### Files
+
+- `createFile({ file, itemId })` - Upload a file to a list item.
+
+## Development
+
+Feel free to contribute or report issues. Pull requests are welcome.
+
+## License
+
+MIT License. See [LICENSE](LICENSE) for details.

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import SHAREPOINT_REQUESTS from './root';
+import type { LookupField, ChoiceField, PersonField } from './types';
+export default function createBase<T extends {
+    LISTS: Record<string, any>;
+    FOLDERS?: Record<string, any>;
+} = any>(): {
+    /**
+     * @deprecated Use `create` instead.
+     */
+    baseURL(url: string): SHAREPOINT_REQUESTS<T>;
+    create: ({ baseURL }: {
+        baseURL: string;
+    }) => SHAREPOINT_REQUESTS<T>;
+};
+export { LookupField, ChoiceField, PersonField };

package/dist/index.js

@@ -0,0 +1,8 @@
+
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./sharepoint_requests.cjs.production.min.js')
+} else {
+  module.exports = require('./sharepoint_requests.cjs.development.js')
+}

package/dist/root/index.d.ts

@@ -0,0 +1,125 @@
+import { AxiosResponse } from 'axios';
+import { CreateFileProps, CurrentUser, EmailProps, Field_Options, Folder_Options, IListName, ItemID, ListData, Options, PersonField, SHAREPOINT_VER, SPItem, UserPermision, UserProfile } from '../types';
+declare class HTTPSharePointRequests<T extends {
+    LISTS: Record<string, any>;
+    FOLDERS?: Record<string, any>;
+}> {
+    private baseURL;
+    private endpoint;
+    private listName;
+    private instance;
+    constructor(baseURL: string);
+    private transformArraysToEdmStrings;
+    /**
+     * @deprecated Use `from` instead.
+     */
+    list(listName: IListName<T>): this;
+    readonly lists: {
+        get: () => Promise<{
+            data: any[];
+            meta: {
+                url: URL;
+            };
+        }>;
+    };
+    from<K extends Extract<keyof T['LISTS'], string>>(listName: K, sharepoint_ver?: SHAREPOINT_VER): {
+        create: (data: ListData) => Promise<AxiosResponse<any, any>>;
+        get: (options?: Options<T['LISTS'][K]>) => Promise<{
+            data: (T["LISTS"][K] & Partial<SPItem>)[];
+            meta: {
+                url: URL;
+            };
+        }>;
+        update: (id: ItemID, data: ListData, digest?: string) => Promise<AxiosResponse<any, any>>;
+        delete: (id: ItemID) => Promise<AxiosResponse<any, any>>;
+        createFile: (props: CreateFileProps) => Promise<AxiosResponse<any, any>>;
+        fields: (options?: Field_Options<T['LISTS'][K]>) => {
+            get: () => Promise<any>;
+        };
+    };
+    folders: {
+        get: () => void;
+    };
+    folder(folderName?: string | string[]): {
+        get: (options?: Folder_Options<any>) => Promise<{
+            data: any;
+            meta: {
+                url: URL;
+            };
+        }>;
+    };
+    users: {
+        get: (options?: Options<any>) => Promise<{
+            data: any[];
+            meta: {
+                url: URL;
+            };
+        }>;
+    };
+    /**
+     * Asynchronously retrieves the Form Digest Value from the context information API.
+     *
+     * @returns {Promise<string>} A promise that resolves to the Form Digest Value.
+     * @throws {Error} If the HTTP request fails or the response does not contain the expected data.
+     */
+    private getDigest;
+    private get_only;
+    private get_files;
+    private get_v2;
+    private update_2;
+    private create_v2;
+    private createFile;
+    private delete;
+    email: {
+        /**
+         * Sends an email using SharePoint's Utility.SendEmail API.
+         *
+         * @param {EmailProps} param0 - The email properties.
+         * @param {string} param0.From - The sender's email address.
+         * @example
+         *  Example of a sender's email address
+         *  "sender@example.com"
+         * @param {string | string[]} param0.To - The recipient's email address or an array of email addresses.
+         * @example
+         *  Example of a single recipient's email address
+         *   "recipient@example.com"
+         *  Example of multiple recipients' email addresses
+         *  ["recipient1@example.com", "recipient2@example.com"]
+         * @param {string} param0.Subject - The subject of the email.
+         * @example
+         *  Example of an email subject
+         *  "Meeting Reminder"
+         * @param {string} param0.Body - The body content of the email.
+         * @example
+         *  Example of an email body
+         *  "Dear team, please be reminded of the meeting scheduled for tomorrow at 10 AM."
+         * @returns {Promise<any>} - A promise that resolves to the response of the email send request.
+         */
+        send: (props: EmailProps) => Promise<AxiosResponse<{
+            d: {
+                SendEmail: null;
+            };
+        }, any>>;
+    };
+    private sendEmail;
+    private typeAhead;
+    private currentUserProperties;
+    user: {
+        properties: () => {
+            get: () => Promise<UserProfile>;
+        };
+        searchSiteUser: (searchValue: string) => Promise<any>;
+        searchUser: (input: string, filter?: string) => Promise<PersonField>;
+        current: () => {
+            get: () => Promise<CurrentUser>;
+        };
+        currentPermission: () => {
+            get: () => Promise<UserPermision>;
+        };
+    };
+    private getSiteUser;
+    private roleDefinitions;
+    private getEffectiveBasePermissions;
+    private currentUserPermissions;
+}
+export default HTTPSharePointRequests;

package/dist/root/request/digest.d.ts

@@ -0,0 +1,7 @@
+import { AxiosInstance } from 'axios';
+declare type GetDigestProps = {
+    instance: AxiosInstance;
+    baseURL: string;
+};
+declare const getDigest: ({ instance, baseURL, }: GetDigestProps) => Promise<string>;
+export default getDigest;

package/dist/root/request/get.d.ts

@@ -0,0 +1,13 @@
+import { AxiosInstance } from 'axios';
+import { Options, SPItem } from '../../types';
+declare type GetProps = {
+    instance: AxiosInstance;
+    endpoint: string;
+};
+declare const get: <K = any>({ instance, endpoint }: GetProps, options?: Options<K>) => Promise<{
+    data: (K & Partial<SPItem>)[];
+    meta: {
+        url: URL;
+    };
+}>;
+export default get;