@ossy/resources 3.10.0 → 3.11.0

package/src/rename-file.flow.js

@@ -0,0 +1,43 @@
+import uploadFileFlow from './upload-file.flow.js'
+import { metadata as OpenRename } from './open-rename.action.js'
+import { metadata as UpdateResourceName } from './update-name.action.js'
+import { metadata as RenameForm } from './rename.form.js'
+
+export const metadata = {
+  id: '@ossy/resources/flows/rename-file',
+  feature: 'resources',
+  requires: ['server', 'database'],
+  timeout: 150_000,
+}
+
+/**
+ * After uploading a file, open rename in the resource panel, change the name,
+ * confirm, and see the new name in storage.
+ */
+export default {
+  title: 'Rename uploaded file',
+  description:
+    'Signed-in user uploads a file, renames it from the resource panel, and sees the new name in storage',
+  steps: [
+    ...uploadFileFlow.steps,
+    { click: { selector: '[data-resource-name="e2e-upload.txt"]' } },
+    { result: { action: OpenRename, timeout: 15000 } },
+    { action: OpenRename },
+    { result: { action: UpdateResourceName, timeout: 10000 } },
+    { form: RenameForm, fields: { name: 'e2e-renamed.txt' } },
+    { action: UpdateResourceName },
+    {
+      result: {
+        selector: '[data-resource-name="e2e-renamed.txt"]',
+        timeout: 20000,
+      },
+    },
+    {
+      result: {
+        selector: '[data-resource-name="e2e-upload.txt"]',
+        hidden: true,
+        timeout: 10000,
+      },
+    },
+  ],
+}

package/src/rename.form.js

@@ -0,0 +1,5 @@
+export const metadata = {
+  id: '@ossy/resources/form/rename',
+  schemaId: '@ossy/resources/schema/rename',
+  label: '@ossy/resources/form/rename.label',
+}

package/src/rename.schema.js

@@ -0,0 +1,9 @@
+/** Rename resource form — UI fields and flow faker schema. */
+export default {
+  id: '@ossy/resources/schema/rename',
+  name: 'Rename resource',
+  icon: 'pen',
+  fields: [
+    { name: 'name', type: 'text', required: true },
+  ],
+}

package/src/resource-list-query.js

@@ -0,0 +1,182 @@
+import { useCallback, useMemo } from 'react'
+import { useSearchParams } from '@ossy/router-react'
+import { RESOURCE_LIST_SORT_FIELDS } from './resources-list-options.js'
+
+export const RESOURCE_LIST_QUERY_PAGE = 'page'
+export const RESOURCE_LIST_QUERY_SORT = 'sort'
+export const RESOURCE_LIST_QUERY_ORDER = 'order'
+
+export const DEFAULT_RESOURCE_LIST_SORT_BY = 'name'
+export const DEFAULT_RESOURCE_LIST_SORT_ORDER = 'asc'
+
+function normalizeSortBy (value, fallback = DEFAULT_RESOURCE_LIST_SORT_BY) {
+  if (typeof value !== 'string') return fallback
+  return RESOURCE_LIST_SORT_FIELDS.includes(value) ? value : fallback
+}
+
+function normalizeSortOrder (value, fallback = DEFAULT_RESOURCE_LIST_SORT_ORDER) {
+  if (typeof value !== 'string') return fallback
+  const order = value.trim().toLowerCase()
+  return order === 'desc' ? 'desc' : 'asc'
+}
+
+function normalizePageIndex (value) {
+  const n = Number(value)
+  if (!Number.isFinite(n)) return 0
+  return Math.max(0, Math.trunc(n))
+}
+
+/**
+ * Parse storage list controls from a query object (`page` is 1-based).
+ *
+ * @param {Record<string, unknown>} [search]
+ * @param {{ defaultSortBy?: string, defaultSortOrder?: 'asc' | 'desc' }} [options]
+ */
+export function parseResourceListQuery (search = {}, {
+  defaultSortBy = DEFAULT_RESOURCE_LIST_SORT_BY,
+  defaultSortOrder = DEFAULT_RESOURCE_LIST_SORT_ORDER,
+} = {}) {
+  const pageRaw = Number(search?.[RESOURCE_LIST_QUERY_PAGE])
+  const pageIndex = Number.isFinite(pageRaw) && pageRaw >= 1
+    ? Math.trunc(pageRaw) - 1
+    : 0
+
+  return {
+    pageIndex,
+    sortBy: normalizeSortBy(search?.[RESOURCE_LIST_QUERY_SORT], defaultSortBy),
+    sortOrder: normalizeSortOrder(search?.[RESOURCE_LIST_QUERY_ORDER], defaultSortOrder),
+  }
+}
+
+/**
+ * Serialize list controls for the URL. Defaults become `null` so they can be
+ * omitted / deleted (`page=1`, `sort=name`, `order=asc`).
+ *
+ * @param {{
+ *   pageIndex?: number,
+ *   sortBy?: string,
+ *   sortOrder?: 'asc' | 'desc',
+ * }} [state]
+ * @param {{ defaultSortBy?: string, defaultSortOrder?: 'asc' | 'desc' }} [options]
+ * @returns {{ page: string | null, sort: string | null, order: string | null }}
+ */
+export function serializeResourceListQuery ({
+  pageIndex = 0,
+  sortBy = DEFAULT_RESOURCE_LIST_SORT_BY,
+  sortOrder = DEFAULT_RESOURCE_LIST_SORT_ORDER,
+} = {}, {
+  defaultSortBy = DEFAULT_RESOURCE_LIST_SORT_BY,
+  defaultSortOrder = DEFAULT_RESOURCE_LIST_SORT_ORDER,
+} = {}) {
+  const safePageIndex = normalizePageIndex(pageIndex)
+  const field = normalizeSortBy(sortBy, defaultSortBy)
+  const order = normalizeSortOrder(sortOrder, defaultSortOrder)
+
+  return {
+    [RESOURCE_LIST_QUERY_PAGE]: safePageIndex > 0 ? String(safePageIndex + 1) : null,
+    [RESOURCE_LIST_QUERY_SORT]: field === defaultSortBy ? null : field,
+    [RESOURCE_LIST_QUERY_ORDER]: order === defaultSortOrder ? null : order,
+  }
+}
+
+/**
+ * Query string fragment for list controls, without a leading `?`.
+ */
+export function resourceListQuerySearchString (state, options) {
+  return Object.entries(serializeResourceListQuery(state, options))
+    .filter(([, value]) => value != null)
+    .map(([key, value]) => `${key}=${encodeURIComponent(value)}`)
+    .join('&')
+}
+
+/**
+ * Storage list page/sort as URL search params — same pattern as `r` for the
+ * open resource. Defaults stay out of the URL.
+ *
+ * @param {{
+ *   defaultSortBy?: string,
+ *   defaultSortOrder?: 'asc' | 'desc',
+ * }} [options]
+ */
+export function useResourceListQuery ({
+  defaultSortBy = DEFAULT_RESOURCE_LIST_SORT_BY,
+  defaultSortOrder = DEFAULT_RESOURCE_LIST_SORT_ORDER,
+} = {}) {
+  const searchParams = useSearchParams()
+  const { pageIndex, sortBy, sortOrder } = parseResourceListQuery(searchParams, {
+    defaultSortBy,
+    defaultSortOrder,
+  })
+
+  const patch = useCallback((updates) => {
+    if (typeof searchParams.patch === 'function') {
+      searchParams.patch(updates)
+      return
+    }
+    for (const [name, value] of Object.entries(updates || {})) {
+      if (value == null || value === '') searchParams.delete(name)
+      else searchParams.set(name, value)
+    }
+  }, [searchParams.patch, searchParams.delete, searchParams.set])
+
+  const setPage = useCallback((nextIndex) => {
+    const nextPageIndex = normalizePageIndex(nextIndex)
+    patch({
+      [RESOURCE_LIST_QUERY_PAGE]: nextPageIndex > 0 ? String(nextPageIndex + 1) : null,
+    })
+  }, [patch])
+
+  const nextPage = useCallback(() => {
+    setPage(pageIndex + 1)
+  }, [pageIndex, setPage])
+
+  const previousPage = useCallback(() => {
+    setPage(Math.max(0, pageIndex - 1))
+  }, [pageIndex, setPage])
+
+  const resetPage = useCallback(() => {
+    setPage(0)
+  }, [setPage])
+
+  const setSort = useCallback((nextSortBy, nextSortOrder) => {
+    patch(serializeResourceListQuery({
+      pageIndex: 0,
+      sortBy: nextSortBy ?? sortBy,
+      sortOrder: nextSortOrder ?? sortOrder,
+    }, { defaultSortBy, defaultSortOrder }))
+  }, [patch, sortBy, sortOrder, defaultSortBy, defaultSortOrder])
+
+  const setSortBy = useCallback((nextSortBy) => {
+    if (nextSortBy == null) return
+    setSort(nextSortBy, sortOrder)
+  }, [setSort, sortOrder])
+
+  const setSortOrder = useCallback((nextSortOrder) => {
+    if (nextSortOrder == null) return
+    setSort(sortBy, nextSortOrder)
+  }, [setSort, sortBy])
+
+  return useMemo(() => ({
+    pageIndex,
+    sortBy,
+    sortOrder,
+    setPage,
+    nextPage,
+    previousPage,
+    resetPage,
+    setSort,
+    setSortBy,
+    setSortOrder,
+  }), [
+    pageIndex,
+    sortBy,
+    sortOrder,
+    setPage,
+    nextPage,
+    previousPage,
+    resetPage,
+    setSort,
+    setSortBy,
+    setSortOrder,
+  ])
+}

package/src/resource-list-query.spec.js

@@ -0,0 +1,75 @@
+import { describe, expect, it } from '@jest/globals'
+import {
+  DEFAULT_RESOURCE_LIST_SORT_BY,
+  DEFAULT_RESOURCE_LIST_SORT_ORDER,
+  parseResourceListQuery,
+  resourceListQuerySearchString,
+  serializeResourceListQuery,
+} from './resource-list-query.js'
+
+describe('resource-list-query', () => {
+  describe('parseResourceListQuery', () => {
+    it('defaults to page 0, name, asc', () => {
+      expect(parseResourceListQuery({})).toEqual({
+        pageIndex: 0,
+        sortBy: DEFAULT_RESOURCE_LIST_SORT_BY,
+        sortOrder: DEFAULT_RESOURCE_LIST_SORT_ORDER,
+      })
+    })
+
+    it('reads 1-based page from the query', () => {
+      expect(parseResourceListQuery({ page: '2' }).pageIndex).toBe(1)
+      expect(parseResourceListQuery({ page: '1' }).pageIndex).toBe(0)
+      expect(parseResourceListQuery({ page: '0' }).pageIndex).toBe(0)
+      expect(parseResourceListQuery({ page: 'nope' }).pageIndex).toBe(0)
+    })
+
+    it('accepts known sort fields and orders', () => {
+      expect(parseResourceListQuery({ sort: 'created', order: 'desc' })).toEqual({
+        pageIndex: 0,
+        sortBy: 'created',
+        sortOrder: 'desc',
+      })
+    })
+
+    it('ignores unknown sort fields', () => {
+      expect(parseResourceListQuery({ sort: 'mystery' }).sortBy).toBe('name')
+    })
+  })
+
+  describe('serializeResourceListQuery', () => {
+    it('omits defaults', () => {
+      expect(serializeResourceListQuery({
+        pageIndex: 0,
+        sortBy: 'name',
+        sortOrder: 'asc',
+      })).toEqual({
+        page: null,
+        sort: null,
+        order: null,
+      })
+    })
+
+    it('writes 1-based page and non-default sort', () => {
+      expect(serializeResourceListQuery({
+        pageIndex: 2,
+        sortBy: 'lastUpdated',
+        sortOrder: 'desc',
+      })).toEqual({
+        page: '3',
+        sort: 'lastUpdated',
+        order: 'desc',
+      })
+    })
+  })
+
+  describe('resourceListQuerySearchString', () => {
+    it('builds a query fragment without defaults or a leading ?', () => {
+      expect(resourceListQuerySearchString({
+        pageIndex: 0,
+        sortBy: 'size',
+        sortOrder: 'asc',
+      })).toBe('sort=size')
+    })
+  })
+})

package/src/resource-selection.js

@@ -89,3 +89,28 @@ export function applyResourceSelectionGesture ({
     nextAnchorId: targetId,
   }
 }
+
+/**
+ * Keep selected resource records so batch download/remove still work after
+ * paging away. Drops ids that are no longer selected; prefers `knownResources`
+ * (usually the current page) and falls back to the previous map.
+ *
+ * @param {Iterable<string> | Set<string>} selectedIds
+ * @param {Map<string, object> | null | undefined} previousById
+ * @param {object[]} [knownResources]
+ * @returns {Map<string, object>}
+ */
+export function syncSelectedResources (selectedIds, previousById, knownResources = []) {
+  const ids = selectedIds instanceof Set ? selectedIds : new Set(selectedIds || [])
+  const knownById = new Map()
+  for (const resource of knownResources) {
+    if (resource?.id) knownById.set(resource.id, resource)
+  }
+  const prev = previousById instanceof Map ? previousById : new Map()
+  const next = new Map()
+  for (const id of ids) {
+    const resource = knownById.get(id) ?? prev.get(id)
+    if (resource) next.set(id, resource)
+  }
+  return next
+}

package/src/resource-selection.spec.js

@@ -5,6 +5,7 @@ import {
   isMultiSelectGesture,
   isRangeSelectModifier,
   isToggleSelectModifier,
+  syncSelectedResources,
 } from './resource-selection.js'
 
 describe('resource-selection', () => {
@@ -74,4 +75,43 @@ describe('resource-selection', () => {
       expect(result.nextAnchorId).toBe('a')
     })
   })
+
+  describe('syncSelectedResources', () => {
+    it('keeps previously selected resources that are not on the current page', () => {
+      const previous = new Map([
+        ['a', { id: 'a', name: 'one' }],
+        ['b', { id: 'b', name: 'two' }],
+      ])
+      const next = syncSelectedResources(
+        new Set(['a', 'c']),
+        previous,
+        [{ id: 'c', name: 'three' }],
+      )
+
+      expect([...next.keys()]).toEqual(['a', 'c'])
+      expect(next.get('a')).toEqual({ id: 'a', name: 'one' })
+      expect(next.get('c')).toEqual({ id: 'c', name: 'three' })
+    })
+
+    it('prefers the current page record when both exist', () => {
+      const previous = new Map([['a', { id: 'a', name: 'stale' }]])
+      const next = syncSelectedResources(
+        ['a'],
+        previous,
+        [{ id: 'a', name: 'fresh' }],
+      )
+
+      expect(next.get('a')).toEqual({ id: 'a', name: 'fresh' })
+    })
+
+    it('drops resources that are no longer selected', () => {
+      const previous = new Map([
+        ['a', { id: 'a' }],
+        ['b', { id: 'b' }],
+      ])
+      const next = syncSelectedResources(new Set(['b']), previous, [])
+
+      expect([...next.keys()]).toEqual(['b'])
+    })
+  })
 })

package/src/resource.helpers.js

@@ -34,10 +34,17 @@ export {
   isMultiSelectGesture,
   isRangeSelectModifier,
   isToggleSelectModifier,
+  syncSelectedResources,
 } from './resource-selection.js'
 
 function invalidateLocation(sdk, location) {
-  sdk.invalidate(cacheKey(ListResources, { location: normalizeLocation(location) }))
+  const normalized = normalizeLocation(location)
+  if (typeof sdk.invalidateLocation === 'function') {
+    sdk.invalidateLocation(normalized)
+    return
+  }
+  // Fallback for older sdk-react builds: exact unpaginated key only.
+  sdk.invalidate(cacheKey(ListResources, { location: normalized }))
 }
 
 export async function createDocument(sdk, document) {

package/src/resources-list-options.js

@@ -0,0 +1,169 @@
+export const RESOURCE_LIST_SORT_FIELDS = Object.freeze([
+  'name',
+  'created',
+  'lastUpdated',
+  'size',
+  'type',
+])
+
+export const DEFAULT_RESOURCE_LIST_LIMIT = 50
+export const MAX_RESOURCE_LIST_LIMIT = 200
+
+const LIST_OPTION_KEYS = new Set(['limit', 'offset', 'sortBy', 'sortOrder', 'sort'])
+
+export function isDirectoryResourceType(type) {
+  return type === '@ossy/platform/schema/directory' || type === 'directory'
+}
+
+export function resourceSizeOf(resource) {
+  const length = resource?.content?.ContentLength
+  if (typeof length === 'number' && Number.isFinite(length)) return length
+  if (typeof resource?.size === 'number' && Number.isFinite(resource.size)) return resource.size
+  return 0
+}
+
+function parsePositiveInt(value, { fallback = null, min = 0, max = Number.MAX_SAFE_INTEGER } = {}) {
+  if (value === undefined || value === null || value === '') return fallback
+  const n = Number(value)
+  if (!Number.isFinite(n)) return fallback
+  return Math.min(max, Math.max(min, Math.trunc(n)))
+}
+
+function normalizeSortField(value) {
+  if (typeof value !== 'string') return null
+  const field = value.trim()
+  return RESOURCE_LIST_SORT_FIELDS.includes(field) ? field : null
+}
+
+function normalizeSortOrder(value) {
+  if (typeof value !== 'string') return 'asc'
+  const order = value.trim().toLowerCase()
+  return order === 'desc' ? 'desc' : 'asc'
+}
+
+/**
+ * Pull pagination/sort controls out of a resources query object so they are not
+ * treated as Mongo field filters (e.g. `state.limit`).
+ */
+export function extractResourceListOptions(query = {}) {
+  const source = query && typeof query === 'object' ? query : {}
+  const rest = { ...source }
+
+  let sortBy = normalizeSortField(rest.sortBy)
+  let sortOrder = normalizeSortOrder(rest.sortOrder)
+
+  if (!sortBy && typeof rest.sort === 'string' && rest.sort.trim()) {
+    const [field, order] = rest.sort.trim().split(':')
+    sortBy = normalizeSortField(field)
+    if (order) sortOrder = normalizeSortOrder(order)
+  }
+
+  const limit = parsePositiveInt(rest.limit, {
+    fallback: null,
+    min: 1,
+    max: MAX_RESOURCE_LIST_LIMIT,
+  })
+  const offset = parsePositiveInt(rest.offset, {
+    fallback: 0,
+    min: 0,
+  }) ?? 0
+
+  for (const key of LIST_OPTION_KEYS) delete rest[key]
+
+  const paginated = limit != null
+  return {
+    filter: rest,
+    sortBy: sortBy ?? (paginated ? 'name' : null),
+    sortOrder,
+    limit,
+    offset,
+    paginated,
+  }
+}
+
+export function mergeResourceListParams(payload = {}, reqQuery = {}) {
+  const merged = { ...(payload?.query ?? {}) }
+  for (const key of LIST_OPTION_KEYS) {
+    if (payload?.[key] !== undefined) merged[key] = payload[key]
+    else if (reqQuery?.[key] !== undefined) merged[key] = reqQuery[key]
+  }
+  if (payload?.location !== undefined) merged.location = payload.location
+  else if (merged.location === undefined && reqQuery?.location !== undefined) {
+    merged.location = reqQuery.location
+  }
+  return merged
+}
+
+function compareStrings(a, b) {
+  return String(a ?? '').localeCompare(String(b ?? ''), undefined, {
+    sensitivity: 'base',
+    numeric: true,
+  })
+}
+
+function compareValues(a, b, sortBy) {
+  switch (sortBy) {
+    case 'created':
+    case 'lastUpdated':
+      return (Number(a?.[sortBy]) || 0) - (Number(b?.[sortBy]) || 0)
+    case 'size':
+      return resourceSizeOf(a) - resourceSizeOf(b)
+    case 'type':
+      return compareStrings(a?.type, b?.type)
+    case 'name':
+    default:
+      return compareStrings(a?.name, b?.name)
+  }
+}
+
+/**
+ * Stable folder-first sort used by storage UI and list API defaults.
+ */
+export function sortResources(resources = [], { sortBy = 'name', sortOrder = 'asc' } = {}) {
+  const field = normalizeSortField(sortBy) ?? 'name'
+  const order = normalizeSortOrder(sortOrder)
+  const direction = order === 'desc' ? -1 : 1
+
+  return [...resources].sort((a, b) => {
+    const aDir = isDirectoryResourceType(a?.type)
+    const bDir = isDirectoryResourceType(b?.type)
+    if (aDir && !bDir) return -1
+    if (!aDir && bDir) return 1
+    const primary = compareValues(a, b, field) * direction
+    if (primary !== 0) return primary
+    return compareStrings(a?.name, b?.name)
+  })
+}
+
+export function paginateResources(resources = [], { limit = DEFAULT_RESOURCE_LIST_LIMIT, offset = 0 } = {}) {
+  const safeLimit = parsePositiveInt(limit, {
+    fallback: DEFAULT_RESOURCE_LIST_LIMIT,
+    min: 1,
+    max: MAX_RESOURCE_LIST_LIMIT,
+  })
+  const safeOffset = parsePositiveInt(offset, { fallback: 0, min: 0 }) ?? 0
+  const total = resources.length
+  const items = resources.slice(safeOffset, safeOffset + safeLimit)
+  return {
+    items,
+    total,
+    limit: safeLimit,
+    offset: safeOffset,
+  }
+}
+
+export function mongoSortForResourceList({ sortBy = 'name', sortOrder = 'asc' } = {}) {
+  const field = normalizeSortField(sortBy) ?? 'name'
+  const order = normalizeSortOrder(sortOrder) === 'desc' ? -1 : 1
+  const fieldPath = field === 'size'
+    ? 'state.content.ContentLength'
+    : `state.${field}`
+
+  // Directories first, then the requested field. Secondary name keeps ties stable.
+  const sort = {
+    _isDirectory: 1,
+    [fieldPath]: order,
+  }
+  if (field !== 'name') sort['state.name'] = 1
+  return sort
+}