@lindle/sharepoint_requests 0.1.18 → 0.1.20

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

@@ -1,44 +1,35 @@
-import type { ListData, SHAREPOINT_VER } from '../../../types';
+import { ListData, SHAREPOINT_VER } from '../../../types';
 import { fetchDigest } from '../digest';
-import type { RequestContext } from '../context';
+import { RequestContext } from '../context';
 import { normalizeListPayload } from './normalizePayload';
-
-async function resolveMetadataType<V extends SHAREPOINT_VER>(
-  context: RequestContext<V>
-) {
-  if (context.resolveListItemEntityType) {
-    return context.resolveListItemEntityType();
-  }
-
-  if (context.listItemEntityTypeFullName) {
-    return context.listItemEntityTypeFullName;
-  }
-
-  return `SP.Data.${context.listName}ListItem`;
-}
+import { resolveMetadataType } from './resolveMetadataType';
 
 export async function createListItem<
   D = Record<string, unknown>,
   V extends SHAREPOINT_VER = '2013'
 >(context: RequestContext<V>, listData: ListData<D>) {
-  const metadataType = await resolveMetadataType(context);
   const normalizedData = normalizeListPayload(listData);
-  const userMetadata =
-    (listData as { __metadata?: Record<string, unknown> }).__metadata;
-  const payload = {
-    ...normalizedData,
-    __metadata: {
-      ...(userMetadata && typeof userMetadata === 'object' ? userMetadata : {}),
-      type: metadataType,
-    },
-  };
+  let payload: Record<string, unknown> = normalizedData;
+
+  if (context.sharepointVersion === '2013') {
+    const metadataType = await resolveMetadataType(context);
+    const userMetadata = (listData as { __metadata?: Record<string, unknown> })
+      .__metadata;
+    payload = {
+      ...normalizedData,
+      __metadata: {
+        ...(userMetadata && typeof userMetadata === 'object' ? userMetadata : {}),
+        type: metadataType,
+      },
+    };
+  }
 
   const response = await context.instance({
     url: context.endpoint,
     method: 'POST',
     data: JSON.stringify(payload),
     headers: {
-      'X-RequestDigest': await fetchDigest(context.instance, context.baseURL),
+      'X-RequestDigest': await fetchDigest(context.instance),
     },
   });
 

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

@@ -1,7 +1,8 @@
-import type { SHAREPOINT_VER, DeleteFileProps } from '../../../types';
+import { SHAREPOINT_VER, DeleteFileProps } from '../../../types';
 import { fetchDigest } from '../digest';
-import type { RequestContext } from '../context';
+import { RequestContext } from '../context';
 import { buildLibraryPath, encodeFileName } from './utils';
+import { buildListByTitleEndpoint } from '../sharepointUrl';
 
 const SUPPORTED_VERSION: SHAREPOINT_VER = '2013';
 
@@ -16,11 +17,11 @@ export async function deleteFile<V extends SHAREPOINT_VER = '2013'>(
   }
 
   const encodedFileName = encodeFileName(fileName);
-  let requestUrl = `_api/web/lists/getbytitle('${context.listName}')/RootFolder`;
+  let requestUrl = `${buildListByTitleEndpoint(context.listName)}/RootFolder`;
   requestUrl += buildLibraryPath(folderPath);
   requestUrl += `/Files('${encodedFileName}')`;
 
-  const digest = await fetchDigest(context.instance, context.baseURL);
+  const digest = await fetchDigest(context.instance);
 
   const response = await context.instance.post(requestUrl, undefined, {
     headers: {
@@ -28,7 +29,6 @@ export async function deleteFile<V extends SHAREPOINT_VER = '2013'>(
       'IF-MATCH': '*',
       'X-RequestDigest': digest,
     },
-    withCredentials: true,
   });
 
   return response;

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

@@ -1,10 +1,24 @@
-import type { SHAREPOINT_VER } from '../../../types';
-import type { RequestContext } from '../context';
+import { SHAREPOINT_VER } from '../../../types';
+import { RequestContext } from '../context';
+import { fetchDigest } from '../digest';
+import { buildListByTitleEndpoint } from '../sharepointUrl';
 
 export async function deleteItem<V extends SHAREPOINT_VER = '2013'>(
   context: RequestContext<V>,
   id: number | string
 ) {
-  const response = await context.instance.delete(`${context.endpoint}(${id})`);
+  const requestDigest = await fetchDigest(context.instance);
+  const url =
+    context.sharepointVersion === '2013'
+      ? `${buildListByTitleEndpoint(context.listName)}/items(${id})`
+      : `${context.endpoint}(${id})`;
+
+  const response = await context.instance.post(url, undefined, {
+    headers: {
+      'X-RequestDigest': requestDigest,
+      'IF-MATCH': '*',
+      'X-HTTP-Method': 'DELETE',
+    },
+  });
   return response;
 }

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

@@ -1,11 +1,8 @@
-import type { Folder_Options, SHAREPOINT_VER } from '../../../types';
+import { Folder_Options, SHAREPOINT_VER } from '../../../types';
 import { appendParamsToUrl, buildODataParams } from '../odata';
-import type { RequestContext } from '../context';
+import { RequestContext } from '../context';
 
-export async function getFiles<
-  T,
-  V extends SHAREPOINT_VER = '2013'
->(
+export async function getFiles<T, V extends SHAREPOINT_VER = '2013'>(
   context: RequestContext<V>,
   options?: Folder_Options<T>
 ) {
@@ -20,10 +17,7 @@ export async function getFiles<
     params,
   });
 
-  const data =
-    options?.limit || !response.data.d.results
-      ? response.data.d
-      : response.data.d.results;
+  const data = response.data?.d?.results ?? response.data?.d ?? response.data;
 
   const meta = { url };
 

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

@@ -1,14 +1,38 @@
-import type { Options, SPItem, SHAREPOINT_VER } from '../../../types';
+import { Options, SPItem, SHAREPOINT_VER } from '../../../types';
 import { appendParamsToUrl, buildODataParams } from '../odata';
-import type { RequestContext } from '../context';
+import { RequestContext } from '../context';
+
+type ListItemShape<K, V extends SHAREPOINT_VER> = K & Partial<SPItem<V>>;
+
+type SelectedColumns<
+  K,
+  V extends SHAREPOINT_VER,
+  O extends Options<K, V> | undefined
+> = O extends { cols?: infer C }
+  ? C extends readonly (infer Key)[]
+    ? Extract<Key, keyof ListItemShape<K, V>>
+    : Extract<C, keyof ListItemShape<K, V>>
+  : never;
+
+type ListItemResponseData<
+  K,
+  V extends SHAREPOINT_VER,
+  O extends Options<K, V> | undefined
+> = [SelectedColumns<K, V, O>] extends [never]
+  ? ListItemShape<K, V>
+  : Pick<ListItemShape<K, V>, SelectedColumns<K, V, O>>;
 
 export async function getListItems<
   K,
-  V extends SHAREPOINT_VER = '2013'
+  V extends SHAREPOINT_VER = '2013',
+  O extends Options<K, V> | undefined = Options<K, V> | undefined
 >(
   context: RequestContext<V>,
-  options?: Options<K, V>
-): Promise<{ data: (K & Partial<SPItem<V>>)[]; meta: { url: URL } }> {
+  options?: O
+): Promise<{
+  data: ListItemResponseData<K, V, O> | ListItemResponseData<K, V, O>[] | undefined;
+  meta: { url: URL };
+}> {
   const params = buildODataParams(options, ' ');
 
   const url = new URL(context.endpoint, context.instance.defaults.baseURL);
@@ -20,10 +44,14 @@ export async function getListItems<
     params,
   });
 
-  const rawData = response.data?.d?.results ?? response.data?.d ?? response.data;
-  const cols = options?.cols;
+  const rawData =
+    response.data?.d?.results ?? response.data?.d ?? response.data;
+  const cols = options?.cols as Options<K, V>['cols'] | undefined;
   const keys = cols
-    ? (Array.isArray(cols) ? cols : [cols]).filter(Boolean)
+    ? (Array.isArray(cols) ? cols : [cols]).filter(
+        (key): key is Extract<keyof ListItemShape<K, V>, string> =>
+          typeof key === 'string'
+      )
     : undefined;
 
   const filterItem = (item: unknown) => {
@@ -46,5 +74,11 @@ export async function getListItems<
 
   const meta = { url };
 
-  return { data: data as (K & Partial<SPItem<V>>)[], meta };
+  return {
+    data: data as
+      | ListItemResponseData<K, V, O>
+      | ListItemResponseData<K, V, O>[]
+      | undefined,
+    meta,
+  };
 }

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

@@ -1,18 +1,21 @@
-import type { AxiosInstance } from 'axios';
-import type { Options, SHAREPOINT_VER } from '../../../types';
+import { AxiosInstance } from 'axios';
+import { Options, SHAREPOINT_VER } from '../../../types';
 import { buildODataParams } from '../odata';
 
-export async function getOnly<
-  T,
-  V extends SHAREPOINT_VER = '2013'
->(
+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) {
+  if (!data) {
+    return undefined;
+  }
+
+  if (data.d) {
     return data.d.results ? data.d.results : data.d;
   }
+
+  return data;
 }

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

@@ -1,4 +1,4 @@
-import type { ListData } from '../../../types';
+import { ListData } from '../../../types';
 
 type AnyRecord = Record<string, unknown>;
 

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

@@ -0,0 +1,14 @@
+import { SHAREPOINT_VER } from '../../../types';
+import { RequestContext } from '../context';
+
+export async function resolveMetadataType<V extends SHAREPOINT_VER>(
+  context: RequestContext<V>
+): Promise<string> {
+  if (context.resolveListItemEntityType) {
+    return context.resolveListItemEntityType();
+  }
+  if (context.listItemEntityTypeFullName) {
+    return context.listItemEntityTypeFullName;
+  }
+  return `SP.Data.${context.listName}ListItem`;
+}

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

@@ -1,21 +1,9 @@
-import type { ListData, SHAREPOINT_VER } from '../../../types';
+import { ListData, SHAREPOINT_VER } from '../../../types';
 import { fetchDigest } from '../digest';
-import type { RequestContext } from '../context';
+import { RequestContext } from '../context';
 import { normalizeListPayload } from './normalizePayload';
-
-async function resolveMetadataType<V extends SHAREPOINT_VER>(
-  context: RequestContext<V>
-) {
-  if (context.resolveListItemEntityType) {
-    return context.resolveListItemEntityType();
-  }
-
-  if (context.listItemEntityTypeFullName) {
-    return context.listItemEntityTypeFullName;
-  }
-
-  return `SP.Data.${context.listName}ListItem`;
-}
+import { buildListByTitleEndpoint } from '../sharepointUrl';
+import { resolveMetadataType } from './resolveMetadataType';
 
 export async function updateListItem<
   D = Record<string, unknown>,
@@ -26,22 +14,28 @@ export async function updateListItem<
   data: ListData<D>,
   digest?: string
 ) {
-  const formDigestValue =
-    digest || (await fetchDigest(context.instance, context.baseURL));
+  const formDigestValue = digest ?? (await fetchDigest(context.instance));
 
-  const metadataType = await resolveMetadataType(context);
   const normalizedData = normalizeListPayload(data);
-  const userMetadata = (data as { __metadata?: Record<string, unknown> })
-    .__metadata;
-  const payload = {
-    ...normalizedData,
-    __metadata: {
-      ...(userMetadata && typeof userMetadata === 'object' ? userMetadata : {}),
-      type: metadataType,
-    },
-  };
+  let payload: Record<string, unknown> = normalizedData;
+
+  if (context.sharepointVersion === '2013') {
+    const metadataType = await resolveMetadataType(context);
+    const userMetadata = (data as { __metadata?: Record<string, unknown> })
+      .__metadata;
+    payload = {
+      ...normalizedData,
+      __metadata: {
+        ...(userMetadata && typeof userMetadata === 'object' ? userMetadata : {}),
+        type: metadataType,
+      },
+    };
+  }
 
-  const url = `_api/lists/getbytitle('${context.listName}')/getItemById('${id}')`;
+  const url =
+    context.sharepointVersion === '2013'
+      ? `${buildListByTitleEndpoint(context.listName)}/items(${id})`
+      : `${context.endpoint}(${id})`;
 
   const response = await context.instance({
     url,
@@ -50,7 +44,7 @@ export async function updateListItem<
     headers: {
       'X-RequestDigest': formDigestValue,
       'IF-MATCH': '*',
-      'X-Http-Method': 'PATCH',
+      'X-HTTP-Method': 'MERGE',
     },
   });
 

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

@@ -1,19 +1,16 @@
-import type { AxiosResponse } from 'axios';
-import type {
-  ItemID,
-  SHAREPOINT_VER,
-  UploadFileProps,
-} from '../../../types';
+import { AxiosResponse } from 'axios';
+import { ItemID, SHAREPOINT_VER, UploadFileProps } from '../../../types';
 import { fetchDigest } from '../digest';
-import type { RequestContext } from '../context';
+import { RequestContext } from '../context';
 import { buildLibraryPath, encodeFileName } from './utils';
+import { buildListByTitleEndpoint } from '../sharepointUrl';
 
 const SUPPORTED_VERSION: SHAREPOINT_VER = '2013';
 
 export async function uploadFile<V extends SHAREPOINT_VER = '2013'>(
   context: RequestContext<V>,
   { file, folderPath, overwrite = true }: UploadFileProps
-): Promise<AxiosResponse & { itemId?: ItemID }> {
+): Promise<{ response: AxiosResponse; itemId?: ItemID }> {
   if (context.sharepointVersion !== SUPPORTED_VERSION) {
     throw new Error(
       'uploadFile is only supported for SharePoint 2013 REST endpoints.'
@@ -24,8 +21,7 @@ export async function uploadFile<V extends SHAREPOINT_VER = '2013'>(
     throw new Error('A file with a valid name must be provided.');
   }
 
-  let requestUrl = `_api/web/lists/getbytitle('${context.listName}')/RootFolder`;
-
+  let requestUrl = `${buildListByTitleEndpoint(context.listName)}/RootFolder`;
   requestUrl += buildLibraryPath(folderPath);
 
   const encodedFileName = encodeFileName(file.name);
@@ -33,37 +29,33 @@ export async function uploadFile<V extends SHAREPOINT_VER = '2013'>(
     overwrite ? 'true' : 'false'
   })?$expand=ListItemAllFields&$select=ListItemAllFields/Id`;
 
-  const digest = await fetchDigest(context.instance, context.baseURL);
+  const digest = await fetchDigest(context.instance);
 
-  const response = (await context.instance.post(requestUrl, file, {
+  const response = await context.instance.post(requestUrl, file, {
     headers: {
       'Content-Type': file.type || 'application/octet-stream',
       'X-RequestDigest': digest,
     },
-    withCredentials: true,
-  })) as AxiosResponse & { itemId?: ItemID };
+  });
 
   const responseData = response.data?.d ?? response.data;
   const listItemFields = responseData?.ListItemAllFields;
-  const itemId =
+  let itemId: ItemID | undefined =
     listItemFields?.Id ??
     listItemFields?.ID ??
     responseData?.Id ??
     responseData?.ID;
 
-  if (typeof itemId !== 'undefined') {
-    response.itemId = itemId;
-  } else if (listItemFields?.__deferred?.uri) {
+  if (typeof itemId === 'undefined' && listItemFields?.__deferred?.uri) {
     const listItemResponse = await context.instance.get(
       listItemFields.__deferred.uri
     );
     const deferredId =
       listItemResponse.data?.d?.Id ?? listItemResponse.data?.Id;
-
     if (typeof deferredId !== 'undefined') {
-      response.itemId = deferredId;
+      itemId = deferredId;
     }
   }
 
-  return response;
+  return { response, itemId };
 }

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

@@ -11,7 +11,7 @@ export function buildLibraryPath(folderPath?: string | string[]) {
     return '';
   }
 
-  const escapedSegments = segments.map((segment) => {
+  const escapedSegments = segments.map(segment => {
     if (!segment.trim()) {
       throw new Error('Folder path segments cannot be empty.');
     }

package/src/root/internal/odata.ts

@@ -1,4 +1,4 @@
-import type { Folder_Options, Options, SHAREPOINT_VER } from '../../types';
+import { Folder_Options, Options, SHAREPOINT_VER } from '../../types';
 
 type QueryableOptions<T, V extends SHAREPOINT_VER = '2013'> =
   | Options<T, V>
@@ -16,9 +16,7 @@ export function buildODataParams<T, V extends SHAREPOINT_VER = '2013'>(
     $skip: skip,
     $select: Array.isArray(cols) ? cols.join(',') : cols,
     $filter: filter,
-    $orderby: Array.isArray(orderBy)
-      ? orderBy.join(orderBySeparator)
-      : orderBy,
+    $orderby: Array.isArray(orderBy) ? orderBy.join(orderBySeparator) : orderBy,
   };
 
   return params;

package/src/root/internal/sharepointUrl.ts

@@ -0,0 +1,7 @@
+export function escapeODataStringLiteral(value: string) {
+  return value.replace(/'/g, "''");
+}
+
+export function buildListByTitleEndpoint(listName: string) {
+  return `_api/web/lists/GetByTitle('${escapeODataStringLiteral(listName)}')`;
+}

package/src/root/internal/userRequests.ts

@@ -1,17 +1,28 @@
-import type { AxiosInstance } from 'axios';
-import type {
-  PersonField,
-  UserPermision,
-  UserProfile,
-} from '../../types';
-import type { RequestContext } from './context';
+import { AxiosInstance } from 'axios';
+import { PermissionLabel, PersonField, UserPermision, UserProfile } from '../../types';
+import { RequestContext } from './context';
+import { escapeODataStringLiteral } from './sharepointUrl';
 
 type RoleDefinition = {
+  Name: string;
+  Description: string;
+  Hidden: boolean;
+  Id: number;
+  Order: number;
+  RoleTypeKind: number;
   BasePermissions: {
     High: string;
+    Low: string;
   };
 };
 
+const PERMISSION_PRIORITY: PermissionLabel[] = [
+  'Full Control',
+  'Edit',
+  'Contribute',
+  'Read',
+];
+
 export async function typeAhead(
   instance: AxiosInstance,
   input: string,
@@ -46,64 +57,109 @@ export async function typeAhead(
     },
   });
 
-  return response.data.d.ClientPeoplePickerSearchUser;
+  const searchResults =
+    response.data?.d?.ClientPeoplePickerSearchUser ??
+    response.data?.ClientPeoplePickerSearchUser;
+
+  if (typeof searchResults === 'string') {
+    const parsed = JSON.parse(searchResults);
+    if (Array.isArray(parsed) && parsed.length > 0) {
+      return parsed[0] as PersonField;
+    }
+    throw new Error('People picker returned no results.');
+  }
+
+  if (Array.isArray(searchResults) && searchResults.length > 0) {
+    return searchResults[0] as PersonField;
+  }
+
+  if (searchResults && typeof searchResults === 'object') {
+    return searchResults as PersonField;
+  }
+
+  throw new Error('Invalid people picker response.');
 }
 
 export async function currentUserProperties(
   instance: AxiosInstance
 ): Promise<UserProfile> {
   const requestUrl = '_api/sp.userprofiles.peoplemanager/getmyproperties';
-  let profile: any = await instance.get(requestUrl);
+  const response = await instance.get(requestUrl);
 
-  profile = profile.data.d;
+  const profile = (response.data?.d ?? response.data) as UserProfile | undefined;
+  if (!profile) {
+    throw new Error('Unable to retrieve user profile.');
+  }
 
-  profile.UserProfileProperties.results.forEach(
+  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;
-      }
+      if (prop.Key === 'FirstName') profile.FirstName = prop.Value;
+      else if (prop.Key === 'LastName') profile.LastName = prop.Value;
+      else if (prop.Key === 'Country') profile.Country = prop.Value;
+      else 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);
+export async function getSiteUser(
+  instance: AxiosInstance,
+  searchValue: string
+) {
+  const safeSearchValue = escapeODataStringLiteral(searchValue);
+  const response = await instance.get('_api/web/siteusers', {
+    params: {
+      $filter: `substringof('${safeSearchValue}', Title) or substringof('${safeSearchValue}', LoginName) or substringof('${safeSearchValue}', Email)`,
+      $top: 50,
+      $expand: 'Groups',
+    },
+  });
   return response.data.d;
 }
 
-export async function roleDefinitions(instance: AxiosInstance) {
-  const requestUrl = `_api/Web/RoleDefinitions`;
-  const response = await instance.get(requestUrl);
+async function roleDefinitions(instance: AxiosInstance): Promise<RoleDefinition[]> {
+  const response = await instance.get('_api/Web/RoleDefinitions');
   return response.data.d.results as RoleDefinition[];
 }
 
-export async function getEffectiveBasePermissions(instance: AxiosInstance) {
-  const requestUrl = `_api/Web/effectiveBasePermissions`;
-  const response = await instance.get(requestUrl);
+async function getEffectiveBasePermissions(
+  instance: AxiosInstance
+): Promise<{ High: string; Low: string }> {
+  const response = await instance.get('_api/Web/effectiveBasePermissions');
   return response.data.d.EffectiveBasePermissions;
 }
 
 export async function currentUserPermissions(
   context: RequestContext
 ): Promise<UserPermision> {
-  const { High } = await getEffectiveBasePermissions(context.instance);
+  const { High: userHigh, Low: userLow } = await getEffectiveBasePermissions(
+    context.instance
+  );
   const definitions = await roleDefinitions(context.instance);
 
-  const result = definitions.find(
-    ({ BasePermissions }: RoleDefinition) => BasePermissions.High === High
-  );
+  const userHighInt = parseInt(userHigh, 10);
+  const userLowInt = parseInt(userLow, 10);
+
+  const matching = definitions
+    .filter((def): def is RoleDefinition =>
+      PERMISSION_PRIORITY.includes(def.Name as PermissionLabel) &&
+      (userHighInt & parseInt(def.BasePermissions.High, 10)) === parseInt(def.BasePermissions.High, 10) &&
+      (userLowInt & parseInt(def.BasePermissions.Low, 10)) === parseInt(def.BasePermissions.Low, 10)
+    )
+    .sort(
+      (a, b) =>
+        PERMISSION_PRIORITY.indexOf(a.Name as PermissionLabel) -
+        PERMISSION_PRIORITY.indexOf(b.Name as PermissionLabel)
+    );
+
+  const result = matching[0];
+
+  if (!result) {
+    throw new Error(
+      `Unable to resolve current user permission. Effective: High="${userHigh}", Low="${userLow}"`
+    );
+  }
 
-  return result as UserPermision;
+  return result as unknown as UserPermision;
 }