chore: import upstream snapshot with attribution

apps/sim/tools/sharepoint/utils.ts

@@ -0,0 +1,180 @@
+import { createLogger } from '@sim/logger'
+import type { CanvasLayout } from '@/tools/sharepoint/types'
+
+const logger = createLogger('SharepointUtils')
+
+export function optionalTrim(value: unknown): string | undefined {
+  if (value === undefined || value === null) return undefined
+  const trimmed = String(value).trim()
+  return trimmed || undefined
+}
+
+export function escapeODataString(value: string): string {
+  return value.replace(/'/g, "''")
+}
+
+export function escapeHtml(value: string): string {
+  return value
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;')
+}
+
+export function getGraphNextPageUrl(data: object): string | undefined {
+  const nextLink = (data as Record<string, unknown>)['@odata.nextLink']
+  return typeof nextLink === 'string' ? nextLink : undefined
+}
+
+export function assertGraphNextPageUrl(nextPageUrl: string): string {
+  const trimmed = nextPageUrl.trim()
+  const url = new URL(trimmed)
+  if (url.origin !== 'https://graph.microsoft.com') {
+    throw new Error('nextPageUrl must be a Microsoft Graph @odata.nextLink URL')
+  }
+  return url.toString()
+}
+
+function stripHtmlTags(html: string): string {
+  let text = html
+  let previous: string
+
+  do {
+    previous = text
+    text = text.replace(/<[^>]*>/g, '')
+    text = text.replace(/[<>]/g, '')
+  } while (text !== previous)
+
+  return text.trim()
+}
+
+export function extractTextFromCanvasLayout(canvasLayout: CanvasLayout | null | undefined): string {
+  logger.info('Extracting text from canvas layout', {
+    hasCanvasLayout: !!canvasLayout,
+    hasHorizontalSections: !!canvasLayout?.horizontalSections,
+    sectionsCount: canvasLayout?.horizontalSections?.length || 0,
+  })
+
+  if (!canvasLayout?.horizontalSections) {
+    logger.info('No canvas layout or horizontal sections found')
+    return ''
+  }
+
+  const textParts: string[] = []
+
+  for (const section of canvasLayout.horizontalSections) {
+    logger.info('Processing section', {
+      sectionId: section.id,
+      hasColumns: !!section.columns,
+      hasWebparts: !!section.webparts,
+      columnsCount: section.columns?.length || 0,
+    })
+
+    if (section.columns) {
+      for (const column of section.columns) {
+        if (column.webparts) {
+          for (const webpart of column.webparts) {
+            logger.info('Processing webpart', {
+              webpartId: webpart.id,
+              hasInnerHtml: !!webpart.innerHtml,
+              innerHtml: webpart.innerHtml,
+            })
+
+            if (webpart.innerHtml) {
+              const text = stripHtmlTags(webpart.innerHtml)
+              if (text) {
+                textParts.push(text)
+                logger.info('Extracted text', { text })
+              }
+            }
+          }
+        }
+      }
+    } else if (section.webparts) {
+      for (const webpart of section.webparts) {
+        if (webpart.innerHtml) {
+          const text = stripHtmlTags(webpart.innerHtml)
+          if (text) textParts.push(text)
+        }
+      }
+    }
+  }
+
+  const finalContent = textParts.join('\n\n')
+  logger.info('Final extracted content', {
+    textPartsCount: textParts.length,
+    finalContentLength: finalContent.length,
+    finalContent,
+  })
+
+  return finalContent
+}
+
+/** SharePoint list item fields that are system-managed and cannot be set via the Graph API. */
+export const READ_ONLY_LIST_ITEM_FIELDS = new Set<string>([
+  'Id',
+  'id',
+  'UniqueId',
+  'GUID',
+  'ContentTypeId',
+  'Created',
+  'Modified',
+  'Author',
+  'Editor',
+  'CreatedBy',
+  'ModifiedBy',
+  'AuthorId',
+  'EditorId',
+  '_UIVersionString',
+  'Attachments',
+  'FileRef',
+  'FileDirRef',
+  'FileLeafRef',
+])
+
+/**
+ * Removes read-only/system-managed fields from a SharePoint list item field set, logging any
+ * fields that were stripped. Throws if no updatable fields remain.
+ */
+export function sanitizeListItemFields(
+  fields: Record<string, unknown>,
+  context: { action: 'update' | 'create' }
+): Record<string, unknown> {
+  const entries = Object.entries(fields)
+  const updatableEntries = entries.filter(([key]) => !READ_ONLY_LIST_ITEM_FIELDS.has(key))
+
+  if (updatableEntries.length !== entries.length) {
+    const removed = entries
+      .filter(([key]) => READ_ONLY_LIST_ITEM_FIELDS.has(key))
+      .map(([key]) => key)
+    logger.warn(`Removed read-only SharePoint fields from ${context.action}`, { removed })
+  }
+
+  if (updatableEntries.length === 0) {
+    const requestedKeys = Object.keys(fields)
+    const verb = context.action === 'update' ? 'updated' : 'set'
+    throw new Error(
+      `All provided fields are read-only and cannot be ${verb}: ${requestedKeys.join(', ')}`
+    )
+  }
+
+  return Object.fromEntries(updatableEntries)
+}
+
+export function cleanODataMetadata<T>(obj: T): T {
+  if (!obj || typeof obj !== 'object') return obj
+
+  if (Array.isArray(obj)) {
+    return obj.map((item) => cleanODataMetadata(item)) as T
+  }
+
+  const cleaned: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
+    if (key.includes('@odata')) continue
+
+    cleaned[key] = cleanODataMetadata(value)
+  }
+
+  return cleaned as T
+}