@raclettejs/workbench 0.1.34 → 0.1.36-canary.0

package/plugins/raclette__cache/frontend/utils/cacheValueTableRows.ts

@@ -0,0 +1,340 @@
+export type ValueTableRow = Record<string, string>
+
+/** Minimal cache row fields needed to build the value table. */
+export type CacheEntryValueSource = {
+  key: string
+  value: string
+  valueParsed?: unknown
+}
+
+export type ValueTableHeader = {
+  title: string
+  key: string
+}
+
+export const CACHE_KEY_COLUMN = "_cacheKey"
+export const MAP_ENTRY_KEY_COLUMN = "entryKey"
+const SCALAR_COLUMN = "value"
+const RAW_COLUMN = "raw"
+
+const stringifyCell = (value: unknown): string => {
+  if (value === null) {
+    return "null"
+  }
+  if (value === undefined) {
+    return ""
+  }
+  if (Array.isArray(value)) {
+    return value.length === 0 ? "" : JSON.stringify(value)
+  }
+  if (isPlainObject(value)) {
+    return Object.keys(value).length === 0 ? "" : JSON.stringify(value)
+  }
+  if (typeof value === "object") {
+    return JSON.stringify(value)
+  }
+  return String(value)
+}
+
+const tryParseJson = (value: string): unknown | undefined => {
+  try {
+    return JSON.parse(value)
+  } catch {
+    return undefined
+  }
+}
+
+const isPlainObject = (value: unknown): value is Record<string, unknown> =>
+  value !== null && typeof value === "object" && !Array.isArray(value)
+
+const isScalarValue = (value: unknown): value is string | number | boolean | null =>
+  value === null ||
+  typeof value === "string" ||
+  typeof value === "number" ||
+  typeof value === "boolean"
+
+const MAP_ENTRY_KEY_PATTERN =
+  /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+
+const isMapEntryKey = (key: string): boolean => MAP_ENTRY_KEY_PATTERN.test(key)
+
+const isHomogeneousObjectMap = (value: Record<string, unknown>): boolean => {
+  const objectValues = Object.values(value)
+  if (objectValues.length === 0) {
+    return false
+  }
+  return (
+    objectValues.every(isPlainObject) || objectValues.every(isScalarValue)
+  )
+}
+
+const headersFromKeys = (keys: string[]): ValueTableHeader[] =>
+  keys.map((key) => ({ title: key, key }))
+
+const sortedKeys = (keys: Iterable<string>): string[] =>
+  [...keys].sort((a, b) => a.localeCompare(b))
+
+const rowFromRecord = (
+  record: Record<string, unknown>,
+  columns: string[],
+): ValueTableRow => {
+  const row: ValueTableRow = {}
+  for (const column of columns) {
+    row[column] = column in record ? stringifyCell(record[column]) : ""
+  }
+  return row
+}
+
+const collectKeysFromObjects = (items: Record<string, unknown>[]): string[] => {
+  const columns = new Set<string>()
+  for (const item of items) {
+    for (const key of Object.keys(item)) {
+      columns.add(key)
+    }
+  }
+  return sortedKeys(columns)
+}
+
+/** Items inside one cache value that share the same object shape (array or object map). */
+export const unwrapValueCollection = (
+  parsed: unknown | undefined,
+  raw?: string,
+): Record<string, unknown>[] | null => {
+  const value = parsed ?? (raw !== undefined ? tryParseJson(raw) : undefined)
+  if (value === undefined) {
+    return null
+  }
+
+  if (Array.isArray(value)) {
+    return value.every(isPlainObject) ? value : null
+  }
+
+  if (!isPlainObject(value)) {
+    return null
+  }
+
+  const objectKeys = Object.keys(value)
+  const objectValues = Object.values(value)
+  if (objectValues.length > 0 && objectValues.every(isPlainObject)) {
+    if (objectKeys.length > 0 && objectKeys.every(isMapEntryKey)) {
+      return Object.entries(value).map(([entryKey, entryValue]) => ({
+        ...(entryValue as Record<string, unknown>),
+        [MAP_ENTRY_KEY_COLUMN]: entryKey,
+      }))
+    }
+    return objectValues
+  }
+
+  if (
+    objectKeys.length > 0 &&
+    objectKeys.every(isMapEntryKey) &&
+    objectValues.every(isScalarValue)
+  ) {
+    return Object.entries(value).map(([entryKey, entryValue]) => ({
+      [MAP_ENTRY_KEY_COLUMN]: entryKey,
+      [SCALAR_COLUMN]: entryValue,
+    }))
+  }
+
+  if (objectKeys.length === 1) {
+    const nested = value[objectKeys[0]]
+    if (Array.isArray(nested) && nested.every(isPlainObject)) {
+      return nested
+    }
+  }
+
+  return null
+}
+
+const tableFromCollection = (
+  items: Record<string, unknown>[],
+  cacheKey?: string,
+): { rows: ValueTableRow[]; headers: ValueTableHeader[] } => {
+  const columns = collectKeysFromObjects(items)
+  if (columns.length === 0) {
+    return { rows: [], headers: [] }
+  }
+
+  const attributeHeaders = headersFromKeys(columns)
+  const headers = cacheKey
+    ? [
+        { title: "Key", key: CACHE_KEY_COLUMN },
+        ...attributeHeaders,
+      ]
+    : attributeHeaders
+
+  const rows = items.map((item, index) => {
+    const row: ValueTableRow = {
+      ...rowFromRecord(item, columns),
+    }
+    if (cacheKey) {
+      row[CACHE_KEY_COLUMN] = cacheKey
+    }
+    row._id = cacheKey ? `${cacheKey}:${index}` : String(index)
+    return row
+  })
+
+  return { rows, headers }
+}
+
+const scalarTable = (text: string): { rows: ValueTableRow[]; headers: ValueTableHeader[] } => ({
+  rows: [{ _id: "0", [SCALAR_COLUMN]: text }],
+  headers: [{ title: "(value)", key: SCALAR_COLUMN }],
+})
+
+const rawFallback = (value: unknown): { rows: ValueTableRow[]; headers: ValueTableHeader[] } => ({
+  rows: [{ _id: "0", [RAW_COLUMN]: JSON.stringify(value, null, 2) }],
+  headers: [{ title: "Raw", key: RAW_COLUMN }],
+})
+
+const parsedValueObject = (
+  entry: CacheEntryValueSource,
+): Record<string, unknown> | null => {
+  const parsed = entry.valueParsed ?? tryParseJson(entry.value)
+  return isPlainObject(parsed) ? parsed : null
+}
+
+/**
+ * Build a table from loaded cache entries: attribute keys become columns,
+ * each entry's parsed value object becomes one row.
+ */
+export const cacheEntriesValueTableRows = (
+  entries: CacheEntryValueSource[],
+  schemaEntry?: CacheEntryValueSource,
+): { rows: ValueTableRow[]; headers: ValueTableHeader[] } => {
+  if (entries.length === 0) {
+    return { rows: [], headers: [] }
+  }
+
+  const focus = schemaEntry ?? entries[0]
+  const innerItems = unwrapValueCollection(focus.valueParsed, focus.value)
+  if (innerItems && innerItems.length > 0) {
+    const cacheKeyForCollection = entries.length > 1 ? focus.key : undefined
+    return tableFromCollection(innerItems, cacheKeyForCollection)
+  }
+
+  const schemaObject = schemaEntry ? parsedValueObject(schemaEntry) : null
+  if (schemaObject && !isHomogeneousObjectMap(schemaObject)) {
+    const fallback = schemaEntry ?? entries[0]
+    return cacheValueTableRows(fallback.valueParsed, fallback.value)
+  }
+
+  const rowObjects = entries
+    .map((entry) => ({ entry, data: parsedValueObject(entry) }))
+    .filter(
+      (row): row is { entry: CacheEntryValueSource; data: Record<string, unknown> } =>
+        row.data !== null,
+    )
+
+  if (rowObjects.length === 0) {
+    const fallback = schemaEntry ?? entries[0]
+    return cacheValueTableRows(fallback.valueParsed, fallback.value)
+  }
+
+  const columns = schemaObject
+    ? sortedKeys(Object.keys(schemaObject))
+    : collectKeysFromObjects(rowObjects.map((row) => row.data))
+
+  if (columns.length === 0) {
+    return { rows: [], headers: [] }
+  }
+
+  const headers: ValueTableHeader[] = [
+    { title: "Key", key: CACHE_KEY_COLUMN },
+    ...headersFromKeys(columns),
+  ]
+
+  const rows = rowObjects.map(({ entry, data }) => ({
+    _id: entry.key,
+    [CACHE_KEY_COLUMN]: entry.key,
+    ...rowFromRecord(data, columns),
+  }))
+
+  return { rows, headers }
+}
+
+/** Map one cache value into rows (collection items or single-object pivot). */
+export const cacheValueTableRows = (
+  parsed: unknown | undefined,
+  raw?: string,
+  cacheKey?: string,
+): { rows: ValueTableRow[]; headers: ValueTableHeader[] } => {
+  const collection = unwrapValueCollection(parsed, raw)
+  if (collection && collection.length > 0) {
+    return tableFromCollection(collection, cacheKey)
+  }
+
+  if (parsed === undefined) {
+    return scalarTable(raw ?? "")
+  }
+
+  if (parsed === null) {
+    return scalarTable("null")
+  }
+
+  if (
+    typeof parsed === "string" ||
+    typeof parsed === "number" ||
+    typeof parsed === "boolean"
+  ) {
+    return scalarTable(String(parsed))
+  }
+
+  if (isPlainObject(parsed)) {
+    if (!isHomogeneousObjectMap(parsed)) {
+      return rawFallback(parsed)
+    }
+
+    const columns = sortedKeys(Object.keys(parsed))
+    if (columns.length === 0) {
+      return { rows: [], headers: [] }
+    }
+    const row: ValueTableRow = {
+      _id: cacheKey ?? "0",
+      ...rowFromRecord(parsed, columns),
+    }
+    if (cacheKey) {
+      row[CACHE_KEY_COLUMN] = cacheKey
+      return {
+        rows: [row],
+        headers: [
+          { title: "Key", key: CACHE_KEY_COLUMN },
+          ...headersFromKeys(columns),
+        ],
+      }
+    }
+    return {
+      rows: [row],
+      headers: headersFromKeys(columns),
+    }
+  }
+
+  if (Array.isArray(parsed)) {
+    return rawFallback(parsed)
+  }
+
+  return rawFallback(parsed)
+}
+
+/** True when tabular layout is not meaningful; use pretty-print instead. */
+export const isScalarFallbackResult = (
+  rows: ValueTableRow[],
+  headers: ValueTableHeader[],
+  entry: CacheEntryValueSource,
+): boolean => {
+  if (rows.length === 0) {
+    return true
+  }
+
+  if (rows.length === 1 && headers.length === 1) {
+    const columnKey = headers[0].key
+    if (columnKey === RAW_COLUMN) {
+      return true
+    }
+    if (columnKey === SCALAR_COLUMN && entry.valueParsed === undefined) {
+      return true
+    }
+  }
+
+  return false
+}