@lindle/sharepoint_requests 0.1.9-beta.0

package/src/root/index.ts

@@ -0,0 +1,429 @@
+import axios, { AxiosInstance, AxiosResponse } from 'axios';
+import {
+  CreateFileProps,
+  CurrentUser,
+  EmailProps,
+  Field_Options,
+  Folder_Options,
+  IListName,
+  ItemID,
+  ListData,
+  Options,
+  PersonField,
+  SHAREPOINT_VER,
+  SPItem,
+  UserPermision,
+  UserProfile,
+} from '../types';
+import get from './request/get';
+import getDigest from './request/digest';
+
+class HTTPSharePointRequests<
+  T extends { LISTS: Record<string, any>; FOLDERS?: Record<string, any> }
+> {
+  private baseURL: string;
+  private endpoint: string;
+  private listName: string;
+  private instance: AxiosInstance;
+
+  constructor(baseURL: string) {
+    this.baseURL = baseURL.endsWith('/') ? baseURL : `${baseURL}/`;
+    this.endpoint = '/api';
+    this.listName = '';
+    const headers = {
+      Accept: 'application/json; odata=verbose',
+      'Content-Type': 'application/json; odata=verbose',
+    };
+
+    this.instance = axios.create({
+      baseURL: `${this.baseURL}`,
+      withCredentials: true,
+      headers: {
+        common: headers,
+        post: headers,
+      },
+    });
+  }
+
+  private transformArraysToEdmStrings(data: ListData) {
+    for (const key in data) {
+      if (Array.isArray(data[key])) {
+        data[key] = {
+          __metadata: { type: 'Collection(Edm.String)' },
+          results: data[key],
+        };
+      }
+    }
+  }
+
+  /**
+   * @deprecated Use `from` instead.
+   */
+  list(listName: IListName<T>) {
+    this.listName = listName;
+    this.endpoint = `_vti_bin/ListData.svc/${listName}`;
+    return this;
+  }
+  public readonly lists = {
+    get: () => {
+      this.endpoint = '_api/web/lists';
+      return this.get_v2();
+    },
+  };
+
+  from<K extends Extract<keyof T['LISTS'], string>>(
+    listName: K,
+    sharepoint_ver: SHAREPOINT_VER = '2013'
+  ) {
+    this.listName = listName;
+    this.endpoint =
+      sharepoint_ver === '2013'
+        ? `_api/web/lists/GetByTitle('${this.listName}')/items`
+        : `_vti_bin/ListData.svc/${listName}`;
+    return {
+      create: (data: ListData) => this.create_v2(data),
+      get: (options?: Options<T['LISTS'][K]>) =>
+        this.get_v2<T['LISTS'][K]>(options),
+      update: (id: ItemID, data: ListData, digest?: string) =>
+        this.update_2(id, data, digest),
+      delete: (id: ItemID) => this.delete(id),
+      createFile: (props: CreateFileProps) => this.createFile(props),
+      fields: (options?: Field_Options<T['LISTS'][K]>) => {
+        // return this.field_v2(options)
+        this.endpoint = !options?.fieldName
+          ? `_api/web/lists/GetByTitle('${this.listName}')/fields`
+          : `_api/web/lists/GetByTitle('${this.listName}')/fields/getbytitle('${options.fieldName}')`;
+        return {
+          get: () => this.get_only(options),
+        };
+      },
+    };
+  }
+
+  public folders = {
+    get: () => {
+      this.endpoint = '_api/web/folders';
+      this.get_v2();
+    },
+  };
+
+  public folder(folderName?: string | string[]) {
+    let filePath = ['Shared Documents'];
+
+    if (folderName) {
+      filePath = Array.isArray(folderName)
+        ? [...filePath, ...folderName]
+        : [...filePath, folderName];
+    }
+    this.endpoint = `_api/web/GetFolderByServerRelativeUrl('${filePath.join(
+      '/'
+    )}')`;
+    return {
+      get: (options?: Folder_Options<any>) => {
+        if (!options?.type) {
+          this.endpoint += '/Files';
+        } else {
+          this.endpoint += `/${options.type}`;
+        }
+
+        return this.get_files(options);
+      },
+    };
+  }
+
+  // public users(options?: Options<any>) {
+  //   this.endpoint = '_api/web/SiteUserInfoList/items';
+  //   return {
+  //     get: () => this.get_v2(options),
+  //   };
+  // }
+  public users = {
+    get: async (options?: Options<any>) => {
+      this.endpoint = '_api/web/SiteUserInfoList/items';
+      return await this.get_v2(options);
+    },
+  };
+
+  /**
+   * 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 async getDigest(): Promise<string> {
+    const value = await getDigest({
+      instance: this.instance,
+      baseURL: this.baseURL,
+    });
+
+    return value;
+  }
+
+  private async get_only(options?: any) {
+    const { expand, orderBy, limit, filter, cols, skip } = options || {};
+
+    const params = {
+      $expand: Array.isArray(expand) ? expand.join(',') : expand,
+      $top: limit,
+      $skip: skip,
+      $select: Array.isArray(cols) ? cols.join(',') : cols,
+      $filter: filter,
+      $orderby: Array.isArray(orderBy) ? orderBy.join(',') : orderBy,
+    };
+    const { data } = await this.instance.get(this.endpoint, { params });
+    if (data) {
+      return data.d.results ? data.d.results : data.d;
+    }
+  }
+
+  private async get_files(options?: Folder_Options<any>) {
+    const { expand, orderBy, limit, filter, cols, skip } = options || {};
+    const params = {
+      $expand: Array.isArray(expand) ? expand.join(',') : expand,
+      $top: limit,
+      $skip: skip,
+      $select: Array.isArray(cols) ? cols.join(',') : cols,
+      $filter: filter,
+      $orderby: Array.isArray(orderBy) ? orderBy.join(',') : orderBy,
+    };
+    const url = new URL(this.endpoint, this.instance.defaults.baseURL);
+    Object.entries(params).forEach(([key, value]) => {
+      if (value !== undefined && value !== null) {
+        url.searchParams.append(key, String(value));
+      }
+    });
+
+    const response = await this.instance.request({
+      url: this.endpoint,
+      method: 'GET',
+      params,
+    });
+
+    const data =
+      limit || !response.data.d.results
+        ? response.data.d
+        : response.data.d.results;
+
+    const meta = { url };
+
+    return { data, meta };
+  }
+
+  private async get_v2<K = any>(
+    options?: Options<K>
+  ): Promise<{ data: (K & Partial<SPItem>)[]; meta: { url: URL } }> {
+    const { data, meta } = await get(
+      { instance: this.instance, endpoint: this.endpoint },
+      options
+    );
+
+    return { data, meta };
+  }
+
+  private async update_2(id: ItemID, data: ListData, digest?: string) {
+    const formDigestValue = digest || (await this.getDigest());
+
+    data.__metadata = {
+      type: `SP.Data.${this.listName}ListItem`,
+    };
+    const url = `_api/lists/getbytitle('${this.listName}')/getItemById('${id}')`;
+    const response = await this.instance({
+      url,
+      method: 'POST',
+      data: JSON.stringify(data),
+      headers: {
+        'X-RequestDigest': formDigestValue,
+        'IF-MATCH': '*',
+        'X-Http-Method': 'PATCH',
+      },
+    });
+    return response;
+  }
+
+  private async create_v2(listData: ListData) {
+    this.transformArraysToEdmStrings(listData);
+    listData.__metadata = {
+      type: `SP.Data.${this.listName}ListItem`,
+    };
+    const response = await this.instance({
+      url: this.endpoint,
+      method: 'POST',
+      data: JSON.stringify(listData),
+      headers: {
+        'X-RequestDigest': await this.getDigest(),
+        'IF-MATCH': '*',
+      },
+    });
+    return response;
+  }
+
+  private async createFile({ file, itemId }: CreateFileProps) {
+    const requestUrl = `_api/lists/getbytitle('${this.listName}')/items(${itemId})/AttachmentFiles/add(FileName='${file.name}')`;
+    const res = await this.instance.post(requestUrl, file, {
+      headers: {
+        'X-RequestDigest': await this.getDigest(),
+      },
+      withCredentials: true,
+    });
+
+    return res;
+  }
+
+  private async delete(ID: string | number) {
+    const response = await this.instance.delete(`${this.endpoint!}(${ID})`);
+    return response;
+  }
+
+  public 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) => this.sendEmail(props),
+  };
+
+  private async sendEmail({
+    From,
+    To,
+    Subject,
+    Body,
+  }: EmailProps): Promise<
+    AxiosResponse<{
+      d: {
+        SendEmail: null;
+      };
+    }>
+  > {
+    const httpRequest = '_api/SP.Utilities.Utility.SendEmail';
+    const response = await this.instance({
+      url: httpRequest,
+      method: 'POST',
+      headers: {
+        'X-RequestDigest': await this.getDigest(),
+        'X-Http-Method': 'POST',
+        'Content-Type': 'application/json;odata=verbose',
+      },
+      data: JSON.stringify({
+        properties: {
+          __metadata: {
+            type: 'SP.Utilities.EmailProperties',
+          },
+          From,
+          To: {
+            results: Array.isArray(To) ? To : [To],
+          },
+          Body,
+          Subject,
+        },
+      }),
+    });
+
+    return response;
+  }
+
+  private async typeAhead(input: string, filter?: string) {
+    const filterValue = filter ? ` and ${filter}` : '';
+    const response = await this.instance.get(
+      `_vti_bin/listdata.svc/UserInformationList?$top=10&$filter=substringof('${input}',Name) or substringof('${input}',WorkEmail)${filterValue}`
+    );
+    return response.data.d;
+  }
+
+  private async currentUserProperties() {
+    const requestUrl = '_api/sp.userprofiles.peoplemanager/getmyproperties';
+    let profile: any = await this.instance.get(requestUrl);
+
+    profile = profile.data.d;
+
+    profile.UserProfileProperties.results.forEach(
+      (prop: { Key: string; Value: string }) => {
+        if (prop.Key === 'FirstName') {
+          profile.FirstName = prop.Value;
+        }
+        if (prop.Key === 'LastName') {
+          profile.LastName = prop.Value;
+        }
+        if (prop.Key === 'Country') {
+          profile.Country = prop.Value;
+        }
+        if (prop.Key === 'UserName') {
+          profile.UserName = prop.Value;
+        }
+      }
+    );
+    return profile as Promise<UserProfile>;
+  }
+  public user = {
+    properties: () => {
+      return {
+        get: () => this.currentUserProperties(),
+      };
+    },
+    searchSiteUser: (searchValue: string) => this.getSiteUser(searchValue),
+    searchUser: (input: string, filter?: string): Promise<PersonField> =>
+      this.typeAhead(input, filter),
+    current: () => {
+      this.endpoint = '_api/web/currentUser';
+      return {
+        get: (): Promise<CurrentUser> => this.get_only(),
+      };
+    },
+    currentPermission: () => {
+      return {
+        get: () => this.currentUserPermissions(),
+      };
+    },
+  };
+
+  private async getSiteUser(searchValue: string) {
+    const requestUrl = `_api/web/siteusers?&$filter=substringof('${searchValue}', Title) or substringof('${searchValue}', LoginName) or substringof('${searchValue}', Email)&$top=50&$expand=Groups`;
+    const response = await this.instance.get(requestUrl);
+    return response.data.d;
+  }
+
+  private async roleDefinitions() {
+    const requestUrl = `_api/Web/RoleDefinitions`;
+    const response = await this.instance.get(requestUrl);
+    return response.data.d.results;
+  }
+
+  private async getEffectiveBasePermissions() {
+    const requestUrl = `_api/Web/effectiveBasePermissions`;
+    const response = await this.instance.get(requestUrl);
+    return response.data.d.EffectiveBasePermissions;
+  }
+
+  private async currentUserPermissions() {
+    const { High } = await this.getEffectiveBasePermissions();
+    const roleDefinitions = await this.roleDefinitions();
+
+    const result = roleDefinitions.find(
+      ({ BasePermissions }: { BasePermissions: { High: string } }) =>
+        BasePermissions.High === High
+    );
+
+    return result as UserPermision;
+  }
+}
+
+export default HTTPSharePointRequests;

package/src/root/request/digest.ts

@@ -0,0 +1,25 @@
+import { AxiosInstance } from 'axios';
+
+type GetDigestProps = {
+  instance: AxiosInstance;
+  baseURL: string;
+};
+
+const getDigest = async ({
+  instance,
+  baseURL,
+}: GetDigestProps): Promise<string> => {
+  try {
+    const response = await instance.post(`${baseURL}_api/contextinfo`);
+    if (!response.data?.d?.GetContextWebInformation?.FormDigestValue) {
+      throw new Error('Invalid response structure: Missing FormDigestValue');
+    }
+    return response.data.d.GetContextWebInformation.FormDigestValue;
+  } catch (error) {
+    console.error('Failed to retrieve the Form Digest Value:', error);
+    throw new Error(`Error retrieving Form Digest Value`);
+  }
+  '';
+};
+
+export default getDigest;

package/src/root/request/get.ts

@@ -0,0 +1,44 @@
+import { AxiosInstance } from 'axios';
+import { Options, SPItem } from '../../types';
+
+type GetProps = { instance: AxiosInstance; endpoint: string };
+
+const get = async <K = any>(
+  { instance, endpoint }: GetProps,
+  options?: Options<K>
+): Promise<{ data: (K & Partial<SPItem>)[]; meta: { url: URL } }> => {
+  const { expand, orderBy, limit, filter, cols, skip } = options || {};
+
+  const params = {
+    $expand: Array.isArray(expand) ? expand.join(',') : expand,
+    $top: limit,
+    $skip: skip,
+    $select: Array.isArray(cols) ? cols.join(',') : cols,
+    $filter: filter,
+    $orderby: Array.isArray(orderBy) ? orderBy.join(' ') : orderBy,
+  };
+
+  const url = new URL(endpoint, instance.defaults.baseURL);
+  Object.entries(params).forEach(([key, value]) => {
+    if (value !== undefined && value !== null) {
+      url.searchParams.append(key, String(value));
+    }
+  });
+
+  const response = await instance.request({
+    url: endpoint,
+    method: 'GET',
+    params,
+  });
+
+  const data =
+    limit || !response.data.d.results
+      ? response.data.d
+      : response.data.d.results;
+
+  const meta = { url };
+
+  return { data, meta };
+};
+
+export default get;