@lindle/sharepoint_requests 0.1.12 → 0.1.14

package/src/root/internal/context.ts

@@ -0,0 +1,10 @@
+import type { AxiosInstance } from 'axios';
+import type { SHAREPOINT_VER } from '../../types';
+
+export interface RequestContext<V extends SHAREPOINT_VER = '2013'> {
+  instance: AxiosInstance;
+  baseURL: string;
+  endpoint: string;
+  listName: string;
+  sharepointVersion: V;
+}

package/src/root/internal/digest.ts

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

package/src/root/internal/emailRequests.ts

@@ -0,0 +1,45 @@
+import type { AxiosResponse } from 'axios';
+import type { EmailProps } from '../../types';
+import { fetchDigest } from './digest';
+import type { RequestContext } from './context';
+
+type SendEmailResponse = AxiosResponse<{
+  d: {
+    SendEmail: null;
+  };
+}>;
+
+export async function sendEmail(
+  context: RequestContext,
+  { From, To, Subject, Body }: EmailProps
+): Promise<SendEmailResponse> {
+  const httpRequest = '_api/SP.Utilities.Utility.SendEmail';
+
+  const response = await context.instance({
+    url: httpRequest,
+    method: 'POST',
+    headers: {
+      'X-RequestDigest': await fetchDigest(
+        context.instance,
+        context.baseURL
+      ),
+      '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;
+}

package/src/root/internal/listRequests/createAttachment.ts

@@ -0,0 +1,18 @@
+import type { CreateFileProps, SHAREPOINT_VER } from '../../../types';
+import { fetchDigest } from '../digest';
+import type { RequestContext } from '../context';
+
+export async function createAttachment<V extends SHAREPOINT_VER = '2013'>(
+  context: RequestContext<V>,
+  { file, itemId }: CreateFileProps
+) {
+  const requestUrl = `_api/lists/getbytitle('${context.listName}')/items(${itemId})/AttachmentFiles/add(FileName='${file.name}')`;
+  const response = await context.instance.post(requestUrl, file, {
+    headers: {
+      'X-RequestDigest': await fetchDigest(context.instance, context.baseURL),
+    },
+    withCredentials: true,
+  });
+
+  return response;
+}

package/src/root/internal/listRequests/createListItem.ts

@@ -0,0 +1,35 @@
+import type { ListData, SHAREPOINT_VER } from '../../../types';
+import { fetchDigest } from '../digest';
+import type { RequestContext } from '../context';
+
+function transformArraysToEdmStrings(data: ListData) {
+  for (const key in data) {
+    if (Array.isArray(data[key])) {
+      data[key] = {
+        __metadata: { type: 'Collection(Edm.String)' },
+        results: data[key],
+      };
+    }
+  }
+}
+
+export async function createListItem<V extends SHAREPOINT_VER = '2013'>(
+  context: RequestContext<V>,
+  listData: ListData
+) {
+  transformArraysToEdmStrings(listData);
+  listData.__metadata = {
+    type: `SP.Data.${context.listName}ListItem`,
+  };
+
+  const response = await context.instance({
+    url: context.endpoint,
+    method: 'POST',
+    data: JSON.stringify(listData),
+    headers: {
+      'X-RequestDigest': await fetchDigest(context.instance, context.baseURL),
+    },
+  });
+
+  return response;
+}

package/src/root/internal/listRequests/deleteItem.ts

@@ -0,0 +1,10 @@
+import type { SHAREPOINT_VER } from '../../../types';
+import type { RequestContext } from '../context';
+
+export async function deleteItem<V extends SHAREPOINT_VER = '2013'>(
+  context: RequestContext<V>,
+  id: number | string
+) {
+  const response = await context.instance.delete(`${context.endpoint}(${id})`);
+  return response;
+}

package/src/root/internal/listRequests/getFiles.ts

@@ -0,0 +1,31 @@
+import type { Folder_Options, SHAREPOINT_VER } from '../../../types';
+import { appendParamsToUrl, buildODataParams } from '../odata';
+import type { RequestContext } from '../context';
+
+export async function getFiles<
+  T,
+  V extends SHAREPOINT_VER = '2013'
+>(
+  context: RequestContext<V>,
+  options?: Folder_Options<T>
+) {
+  const params = buildODataParams(options, ',');
+  const url = new URL(context.endpoint, context.instance.defaults.baseURL);
+
+  appendParamsToUrl(url, params);
+
+  const response = await context.instance.request({
+    url: context.endpoint,
+    method: 'GET',
+    params,
+  });
+
+  const data =
+    options?.limit || !response.data.d.results
+      ? response.data.d
+      : response.data.d.results;
+
+  const meta = { url };
+
+  return { data, meta };
+}

package/src/root/internal/listRequests/getListItems.ts

@@ -0,0 +1,50 @@
+import type { Options, SPItem, SHAREPOINT_VER } from '../../../types';
+import { appendParamsToUrl, buildODataParams } from '../odata';
+import type { RequestContext } from '../context';
+
+export async function getListItems<
+  K,
+  V extends SHAREPOINT_VER = '2013'
+>(
+  context: RequestContext<V>,
+  options?: Options<K, V>
+): Promise<{ data: (K & Partial<SPItem<V>>)[]; meta: { url: URL } }> {
+  const params = buildODataParams(options, ' ');
+
+  const url = new URL(context.endpoint, context.instance.defaults.baseURL);
+  appendParamsToUrl(url, params);
+
+  const response = await context.instance.request({
+    url: context.endpoint,
+    method: 'GET',
+    params,
+  });
+
+  const rawData = response.data?.d?.results ?? response.data?.d ?? response.data;
+  const cols = options?.cols;
+  const keys = cols
+    ? (Array.isArray(cols) ? cols : [cols]).filter(Boolean)
+    : undefined;
+
+  const filterItem = (item: unknown) => {
+    if (!keys || !item || typeof item !== 'object') {
+      return item;
+    }
+
+    return keys.reduce<Record<string, unknown>>((acc, key) => {
+      if (key in item) {
+        acc[key] = (item as Record<string, unknown>)[key];
+      }
+
+      return acc;
+    }, {});
+  };
+
+  const data = Array.isArray(rawData)
+    ? rawData.map(filterItem)
+    : filterItem(rawData);
+
+  const meta = { url };
+
+  return { data: data as (K & Partial<SPItem<V>>)[], meta };
+}

package/src/root/internal/listRequests/getOnly.ts

@@ -0,0 +1,18 @@
+import type { AxiosInstance } from 'axios';
+import type { Options, SHAREPOINT_VER } from '../../../types';
+import { buildODataParams } from '../odata';
+
+export async function getOnly<
+  T,
+  V extends SHAREPOINT_VER = '2013'
+>(
+  instance: AxiosInstance,
+  endpoint: string,
+  options?: Options<T, V>
+) {
+  const params = buildODataParams(options, ',');
+  const { data } = await instance.get(endpoint, { params });
+  if (data) {
+    return data.d.results ? data.d.results : data.d;
+  }
+}

package/src/root/internal/listRequests/index.ts

@@ -0,0 +1,7 @@
+export { createListItem } from './createListItem';
+export { createAttachment } from './createAttachment';
+export { deleteItem } from './deleteItem';
+export { getFiles } from './getFiles';
+export { getListItems } from './getListItems';
+export { getOnly } from './getOnly';
+export { updateListItem } from './updateListItem';

package/src/root/internal/listRequests/updateListItem.ts

@@ -0,0 +1,32 @@
+import type { ListData, SHAREPOINT_VER } from '../../../types';
+import { fetchDigest } from '../digest';
+import type { RequestContext } from '../context';
+
+export async function updateListItem<V extends SHAREPOINT_VER = '2013'>(
+  context: RequestContext<V>,
+  id: number | string,
+  data: ListData,
+  digest?: string
+) {
+  const formDigestValue =
+    digest || (await fetchDigest(context.instance, context.baseURL));
+
+  data.__metadata = {
+    type: `SP.Data.${context.listName}ListItem`,
+  };
+
+  const url = `_api/lists/getbytitle('${context.listName}')/getItemById('${id}')`;
+
+  const response = await context.instance({
+    url,
+    method: 'POST',
+    data: JSON.stringify(data),
+    headers: {
+      'X-RequestDigest': formDigestValue,
+      'IF-MATCH': '*',
+      'X-Http-Method': 'PATCH',
+    },
+  });
+
+  return response;
+}

package/src/root/internal/odata.ts

@@ -0,0 +1,36 @@
+import type { Folder_Options, Options, SHAREPOINT_VER } from '../../types';
+
+type QueryableOptions<T, V extends SHAREPOINT_VER = '2013'> =
+  | Options<T, V>
+  | Folder_Options<T>;
+
+export function buildODataParams<T, V extends SHAREPOINT_VER = '2013'>(
+  options: QueryableOptions<T, V> | undefined,
+  orderBySeparator: ',' | ' ' = ','
+) {
+  const { expand, orderBy, limit, filter, cols, skip } = options || {};
+
+  const params: Record<string, string | number | undefined> = {
+    $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(orderBySeparator)
+      : orderBy,
+  };
+
+  return params;
+}
+
+export function appendParamsToUrl(
+  baseUrl: URL,
+  params: Record<string, string | number | undefined | null>
+) {
+  Object.entries(params).forEach(([key, value]) => {
+    if (value !== undefined && value !== null) {
+      baseUrl.searchParams.append(key, String(value));
+    }
+  });
+}

package/src/root/internal/userRequests.ts

@@ -0,0 +1,109 @@
+import type { AxiosInstance } from 'axios';
+import type {
+  PersonField,
+  UserPermision,
+  UserProfile,
+} from '../../types';
+import type { RequestContext } from './context';
+
+type RoleDefinition = {
+  BasePermissions: {
+    High: string;
+  };
+};
+
+export async function typeAhead(
+  instance: AxiosInstance,
+  input: string,
+  filter?: string
+): Promise<PersonField> {
+  const requestUrl = `_api/SP.UI.ApplicationPages.ClientPeoplePickerWebServiceInterface.clientPeoplePickerSearchUser`;
+
+  const data = {
+    queryParams: {
+      __metadata: {
+        type: 'SP.UI.ApplicationPages.ClientPeoplePickerQueryParameters',
+      },
+      AllowEmailAddresses: true,
+      AllowMultipleEntities: false,
+      AllUrlZones: false,
+      MaximumEntitySuggestions: 10,
+      PrincipalSource: 15,
+      PrincipalType: 1,
+      QueryString: input,
+    },
+  };
+
+  if (filter) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (data.queryParams as any).RequiredProperties = [filter];
+  }
+
+  const response = await instance.post(requestUrl, JSON.stringify(data), {
+    headers: {
+      Accept: 'application/json; odata=verbose',
+      'Content-Type': 'application/json;odata=verbose',
+    },
+  });
+
+  return response.data.d.ClientPeoplePickerSearchUser;
+}
+
+export async function currentUserProperties(
+  instance: AxiosInstance
+): Promise<UserProfile> {
+  const requestUrl = '_api/sp.userprofiles.peoplemanager/getmyproperties';
+  let profile: any = await 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;
+}
+
+export async function getSiteUser(instance: AxiosInstance, 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 instance.get(requestUrl);
+  return response.data.d;
+}
+
+export async function roleDefinitions(instance: AxiosInstance) {
+  const requestUrl = `_api/Web/RoleDefinitions`;
+  const response = await instance.get(requestUrl);
+  return response.data.d.results as RoleDefinition[];
+}
+
+export async function getEffectiveBasePermissions(instance: AxiosInstance) {
+  const requestUrl = `_api/Web/effectiveBasePermissions`;
+  const response = await instance.get(requestUrl);
+  return response.data.d.EffectiveBasePermissions;
+}
+
+export async function currentUserPermissions(
+  context: RequestContext
+): Promise<UserPermision> {
+  const { High } = await getEffectiveBasePermissions(context.instance);
+  const definitions = await roleDefinitions(context.instance);
+
+  const result = definitions.find(
+    ({ BasePermissions }: RoleDefinition) => BasePermissions.High === High
+  );
+
+  return result as UserPermision;
+}

package/src/types.ts

@@ -1,36 +1,73 @@
-export type Metadata = {
-  id?: string;
-  type?: string;
-  uri?: string;
-  etag?: string;
-};
-
-export type SPItem = {
-  Attachments: string;
-  ContentType: string;
-  ContentTypeID: string;
-  Created: string;
-  CreatedBy: PersonField & _Deferred;
-  CreatedById: string;
-  Modified: string;
-  ModifiedBy: PersonField & _Deferred;
-  ModifiedById: string;
-  Id: number;
-  Title: string;
-  Path: string;
-  Version: string;
-  Owshiddenversion: number;
-  __metadata: Metadata;
-};
-
-type ListFields<K> = Extract<keyof K, string> | keyof SPItem;
-
-export interface Options<K = any> {
-  expand?: ListFields<K>[] | ListFields<K>;
-  orderBy?: ListFields<K> | [ListFields<K>, 'asc' | 'desc'];
-  limit?: number;
-  filter?: string;
-  cols?: ListFields<K>[] | ListFields<K>;
+export type Metadata = {
+  id?: string;
+  type?: string;
+  uri?: string;
+  etag?: string;
+};
+
+export type SPItem2010 = {
+  Attachments: string;
+  ContentType: string;
+  ContentTypeID: string;
+  Created: string;
+  CreatedBy: PersonField & _Deferred;
+  CreatedById: string;
+  Modified: string;
+  ModifiedBy: PersonField & _Deferred;
+  ModifiedById: string;
+  Id: number;
+  Title: string;
+  Path: string;
+  Version: string;
+  Owshiddenversion: number;
+  __metadata: Metadata;
+};
+
+export type SPItem2013 = {
+  __metadata: Metadata;
+  FirstUniqueAncestorSecurableObject: _Deferred;
+  RoleAssignments: _Deferred;
+  AttachmentFiles: _Deferred;
+  ContentType: _Deferred;
+  GetDlpPolicyTip: _Deferred;
+  FieldValuesAsHtml: _Deferred;
+  FieldValuesAsText: _Deferred;
+  FieldValuesForEdit: _Deferred;
+  File: _Deferred;
+  Folder: _Deferred;
+  ParentList: _Deferred;
+  FileSystemObjectType: number;
+  Id: number;
+  ContentTypeId: string;
+  Title: string;
+  PhotoRefId?: number;
+  ID: number;
+  Modified: string;
+  Created: string;
+  AuthorId: number;
+  EditorId: number;
+  OData__UIVersionString?: string;
+  Attachments: boolean;
+  GUID: string;
+  Author?: PersonField & _Deferred;
+  Editor?: PersonField & _Deferred;
+  [key: string]: unknown;
+};
+
+export type SPItem<V extends SHAREPOINT_VER = '2013'> = V extends '2010'
+  ? SPItem2010
+  : SPItem2013;
+
+type ListFields<K, V extends SHAREPOINT_VER = '2013'> =
+  | Extract<keyof K, string>
+  | Extract<keyof SPItem<V>, string>;
+
+export interface Options<K = any, V extends SHAREPOINT_VER = '2013'> {
+  expand?: ListFields<K, V>[] | ListFields<K, V>;
+  orderBy?: ListFields<K, V> | [ListFields<K, V>, 'asc' | 'desc'];
+  limit?: number;
+  filter?: string;
+  cols?: ListFields<K, V>[] | ListFields<K, V>;
   skip?: number;
 }
 export interface Folder_Options<K = any> {
@@ -45,9 +82,12 @@ export interface Folder_Options<K = any> {
   skip?: number;
 }
 
-export interface Field_Options<K> extends Omit<Options<K>, 'filter'> {
-  fieldName?: Extract<keyof K, string>;
-}
+export interface Field_Options<
+  K,
+  V extends SHAREPOINT_VER = '2013'
+> extends Omit<Options<K, V>, 'filter'> {
+  fieldName?: Extract<keyof K, string>;
+}
 
 export type SHAREPOINT_VER = '2010' | '2013';