@ossy/resources 3.9.0 → 3.11.0

package/src/resources-list-options.spec.js

@@ -0,0 +1,141 @@
+import { describe, expect, it } from '@jest/globals'
+import {
+  DEFAULT_RESOURCE_LIST_LIMIT,
+  extractResourceListOptions,
+  mergeResourceListParams,
+  mongoSortForResourceList,
+  paginateResources,
+  sortResources,
+} from './resources-list-options.js'
+
+describe('extractResourceListOptions', () => {
+  it('leaves filter fields and strips list controls', () => {
+    const { filter, limit, offset, sortBy, sortOrder, paginated } = extractResourceListOptions({
+      location: '/docs/',
+      belongsTo: 'ws-1',
+      limit: '25',
+      offset: '50',
+      sortBy: 'created',
+      sortOrder: 'desc',
+    })
+
+    expect(filter).toEqual({ location: '/docs/', belongsTo: 'ws-1' })
+    expect(limit).toBe(25)
+    expect(offset).toBe(50)
+    expect(sortBy).toBe('created')
+    expect(sortOrder).toBe('desc')
+    expect(paginated).toBe(true)
+  })
+
+  it('parses sort shorthand and clamps limit', () => {
+    const options = extractResourceListOptions({
+      sort: 'size:desc',
+      limit: 9999,
+      offset: -10,
+    })
+    expect(options.sortBy).toBe('size')
+    expect(options.sortOrder).toBe('desc')
+    expect(options.limit).toBe(200)
+    expect(options.offset).toBe(0)
+    expect(options.paginated).toBe(true)
+  })
+
+  it('defaults sortBy to name when paginating without sort', () => {
+    const options = extractResourceListOptions({ limit: 10 })
+    expect(options.sortBy).toBe('name')
+    expect(options.sortOrder).toBe('asc')
+  })
+
+  it('keeps sortBy null when neither sort nor pagination is requested', () => {
+    const options = extractResourceListOptions({ location: '/' })
+    expect(options.sortBy).toBeNull()
+    expect(options.paginated).toBe(false)
+    expect(options.limit).toBeNull()
+  })
+})
+
+describe('mergeResourceListParams', () => {
+  it('prefers top-level payload list controls over nested query', () => {
+    const merged = mergeResourceListParams(
+      {
+        query: { location: '/a/', limit: 10 },
+        location: '/b/',
+        limit: 20,
+        sortBy: 'name',
+      },
+      { offset: 5 },
+    )
+    expect(merged).toEqual({
+      location: '/b/',
+      limit: 20,
+      sortBy: 'name',
+      offset: 5,
+    })
+  })
+
+  it('keeps nested query location when top-level location is absent', () => {
+    const merged = mergeResourceListParams(
+      { query: { location: '/nested/' } },
+      { location: '/from-req/', limit: 10 },
+    )
+    expect(merged.location).toBe('/nested/')
+    expect(merged.limit).toBe(10)
+  })
+})
+
+describe('sortResources', () => {
+  const resources = [
+    { id: 'f2', name: 'zeta.txt', type: '@ossy/platform/schema/file', created: 2, content: { ContentLength: 10 } },
+    { id: 'd1', name: 'Beta', type: '@ossy/platform/schema/directory', created: 3 },
+    { id: 'f1', name: 'alpha.txt', type: '@ossy/platform/schema/file', created: 1, content: { ContentLength: 30 } },
+    { id: 'd2', name: 'Alpha', type: 'directory', created: 4 },
+  ]
+
+  it('keeps directories first and sorts by name ascending', () => {
+    expect(sortResources(resources).map(r => r.id)).toEqual(['d2', 'd1', 'f1', 'f2'])
+  })
+
+  it('sorts files by size descending while keeping directories first', () => {
+    expect(sortResources(resources, { sortBy: 'size', sortOrder: 'desc' }).map(r => r.id))
+      .toEqual(['d2', 'd1', 'f1', 'f2'])
+  })
+
+  it('sorts by created ascending', () => {
+    expect(sortResources(resources, { sortBy: 'created', sortOrder: 'asc' }).map(r => r.id))
+      .toEqual(['d1', 'd2', 'f1', 'f2'])
+  })
+})
+
+describe('paginateResources', () => {
+  it('slices with total metadata', () => {
+    const items = Array.from({ length: 5 }, (_, i) => ({ id: String(i) }))
+    expect(paginateResources(items, { limit: 2, offset: 2 })).toEqual({
+      items: [{ id: '2' }, { id: '3' }],
+      total: 5,
+      limit: 2,
+      offset: 2,
+    })
+  })
+
+  it('falls back to default page size', () => {
+    const items = Array.from({ length: DEFAULT_RESOURCE_LIST_LIMIT + 5 }, (_, i) => ({ id: String(i) }))
+    const page = paginateResources(items)
+    expect(page.limit).toBe(DEFAULT_RESOURCE_LIST_LIMIT)
+    expect(page.items).toHaveLength(DEFAULT_RESOURCE_LIST_LIMIT)
+    expect(page.total).toBe(DEFAULT_RESOURCE_LIST_LIMIT + 5)
+  })
+})
+
+describe('mongoSortForResourceList', () => {
+  it('builds directory-first mongo sort', () => {
+    expect(mongoSortForResourceList({ sortBy: 'name', sortOrder: 'asc' })).toEqual({
+      _isDirectory: 1,
+      'state.name': 1,
+    })
+    expect(mongoSortForResourceList({ sortBy: 'size', sortOrder: 'desc' })).toEqual({
+      _isDirectory: 1,
+      'state.content.ContentLength': -1,
+      'state.name': 1,
+    })
+  })
+})

package/src/resources.action-media.js

@@ -26,6 +26,12 @@ export async function withResourceMedia(result, context) {
   if (Array.isArray(result)) {
     return Promise.all(result.map(r => attachOrKeep(r, context)))
   }
+  if (result && typeof result === 'object' && Array.isArray(result.items)) {
+    return {
+      ...result,
+      items: await Promise.all(result.items.map(r => attachOrKeep(r, context))),
+    }
+  }
   if (result && typeof result === 'object' && result.id) {
     return attachOrKeep(result, context)
   }

package/src/resources.queries.js

@@ -1,5 +1,11 @@
 import { Aggregate } from '@ossy/event-store'
 import { createLogger } from '@ossy/observability'
+import {
+  extractResourceListOptions,
+  isDirectoryResourceType,
+  mongoSortForResourceList,
+  sortResources,
+} from './resources-list-options.js'
 
 const log = createLogger('resources')
 
@@ -79,16 +85,95 @@ export class ResourcesQueries {
   }
 
   static GetResources(_query = {}, user = null) {
+    const {
+      filter,
+      sortBy,
+      sortOrder,
+      limit,
+      offset,
+      paginated,
+    } = extractResourceListOptions(_query)
+
     log.info('[ResourcesQueries][GetResources] Building query')
-    const mongoQuery = ResourcesQueries.buildMongoQuery(_query, user)
-    const workspaceScope = _query.belongsTo ?? '(no workspace scope)'
+    const mongoQuery = ResourcesQueries.buildMongoQuery(filter, user)
+    const workspaceScope = filter.belongsTo ?? '(no workspace scope)'
     log.info(`[ResourcesQueries][GetResources] Fetching resources for ${workspaceScope}`)
 
-    return Aggregate.Collection.find(mongoQuery, { state: true }).toArray()
-      .then(resources => {
-        log.info(`[ResourcesQueries][GetResources] Found ${resources.length} resources`)
-        return resources.map(resource => resource.state)
+    if (!paginated && !sortBy) {
+      return Aggregate.Collection.find(mongoQuery, { projection: { state: true } }).toArray()
+        .then(resources => {
+          log.info(`[ResourcesQueries][GetResources] Found ${resources.length} resources`)
+          return resources.map(resource => resource.state)
+        })
+    }
+
+    const sort = mongoSortForResourceList({ sortBy: sortBy ?? 'name', sortOrder })
+
+    // Mongo find projections cannot compute fields; use aggregation when sorting/paging.
+    const pipeline = [
+      { $match: mongoQuery },
+      {
+        $addFields: {
+          _isDirectory: {
+            $cond: [
+              {
+                $in: [
+                  '$state.type',
+                  ['directory', '@ossy/platform/schema/directory'],
+                ],
+              },
+              0,
+              1,
+            ],
+          },
+        },
+      },
+      { $sort: sort },
+    ]
+
+    if (paginated) {
+      pipeline.push({ $skip: offset })
+      pipeline.push({ $limit: limit })
+    }
+
+    pipeline.push({ $project: { state: true } })
+
+    const itemsPromise = Aggregate.Collection.aggregate(pipeline).toArray()
+      .then(resources => resources.map(resource => resource.state))
+
+    if (!paginated) {
+      return itemsPromise.then(items => {
+        log.info(`[ResourcesQueries][GetResources] Found ${items.length} resources`)
+        return items
       })
+    }
+
+    return Promise.all([
+      itemsPromise,
+      Aggregate.Collection.countDocuments(mongoQuery),
+    ]).then(([items, total]) => {
+      log.info(`[ResourcesQueries][GetResources] Found ${items.length}/${total} resources (limit=${limit}, offset=${offset})`)
+      return {
+        items,
+        total,
+        limit,
+        offset,
+        sortBy: sortBy ?? 'name',
+        sortOrder,
+      }
+    })
+  }
+
+  /**
+   * In-memory folder-first sort for callers that already hold a resource array.
+   * Prefer GetResources sort options for large collections.
+   */
+  static SortResources(resources, options) {
+    return sortResources(resources, options)
+  }
+
+  static IsDirectoryType(type) {
+    return isDirectoryResourceType(type)
   }
 
   static GetNestedResources({ location }) {

package/src/schema-field-display.js

@@ -1,3 +1,5 @@
+const TEMPORAL_FIELD_TYPES = new Set(['date', 'month', 'timestamp'])
+
 /**
  * Whether a schema field value should render as Markdown in detail views.
  *
@@ -10,3 +12,32 @@ export function shouldRenderFieldAsMarkdown (field, value) {
     && typeof value === 'string'
     && value.trim().length > 0
 }
+
+/**
+ * @param {{ type?: string } | null | undefined} field
+ */
+export function isTemporalField (field) {
+  return TEMPORAL_FIELD_TYPES.has(field?.type)
+}
+
+/**
+ * Localized label for date / month / timestamp schema values (Unix ms).
+ *
+ * @param {unknown} value
+ * @param {{ type?: string } | null | undefined} field
+ * @param {string} [locale]
+ * @returns {string | null}
+ */
+export function formatTemporalFieldValue (value, field, locale = 'en-GB') {
+  if (value == null || value === '') return null
+  const ms = typeof value === 'number' ? value : Number(value)
+  if (!Number.isFinite(ms)) return null
+
+  const options = field?.type === 'month'
+    ? { year: 'numeric', month: 'long' }
+    : field?.type === 'timestamp'
+      ? { dateStyle: 'medium', timeStyle: 'short' }
+      : { dateStyle: 'medium' }
+
+  return new Intl.DateTimeFormat(locale, options).format(new Date(ms))
+}

package/src/schema-field-display.spec.js

@@ -0,0 +1,37 @@
+import { describe, expect, it } from '@jest/globals'
+import {
+  formatTemporalFieldValue,
+  isTemporalField,
+} from './schema-field-display.js'
+
+describe('isTemporalField', () => {
+  it('matches date, month, and timestamp', () => {
+    expect(isTemporalField({ type: 'date' })).toBe(true)
+    expect(isTemporalField({ type: 'month' })).toBe(true)
+    expect(isTemporalField({ type: 'timestamp' })).toBe(true)
+    expect(isTemporalField({ type: 'number' })).toBe(false)
+    expect(isTemporalField({})).toBe(false)
+  })
+})
+
+describe('formatTemporalFieldValue', () => {
+  const ms = Date.UTC(2020, 7, 8)
+
+  it('formats date fields as a calendar day', () => {
+    const label = formatTemporalFieldValue(ms, { type: 'date' }, 'en-GB')
+    expect(label).toContain('2020')
+    expect(label).not.toMatch(/1596844800000/)
+  })
+
+  it('formats month fields as month and year', () => {
+    const label = formatTemporalFieldValue(ms, { type: 'month' }, 'en-GB')
+    expect(label.toLowerCase()).toContain('august')
+    expect(label).toContain('2020')
+  })
+
+  it('returns em-dash fallback as null for empty values', () => {
+    expect(formatTemporalFieldValue(null, { type: 'date' })).toBe(null)
+    expect(formatTemporalFieldValue('', { type: 'date' })).toBe(null)
+    expect(formatTemporalFieldValue('not-a-date', { type: 'date' })).toBe(null)
+  })
+})

package/src/search-payload.js

@@ -0,0 +1,10 @@
+import { extractResourceListOptions } from './resources-list-options.js'
+
+/**
+ * Strip pagination/sort keys from search payloads so callers that accidentally
+ * forward list options keep receiving an array (not `{ items, total }`).
+ */
+export function sanitizeSearchPayload (payload = {}) {
+  const { filter } = extractResourceListOptions(payload ?? {})
+  return filter
+}

package/src/search-payload.spec.js

@@ -0,0 +1,20 @@
+import { describe, it, expect } from '@jest/globals'
+import { sanitizeSearchPayload } from './search-payload.js'
+
+describe('sanitizeSearchPayload', () => {
+  it('strips list options so search stays an array-shaped query', () => {
+    const result = sanitizeSearchPayload({
+      location: '/docs/',
+      limit: 10,
+      offset: 20,
+      sortBy: 'name',
+      sortOrder: 'desc',
+      q: 'brief',
+    })
+
+    expect(result).toEqual({
+      location: '/docs/',
+      q: 'brief',
+    })
+  })
+})

package/src/search.task.js

@@ -1,10 +1,11 @@
 import { ResourcesQueries } from './resources.queries.js'
 import { mediaContextFromRun, withResourceMedia } from './resources.action-media.js'
+import { sanitizeSearchPayload } from './search-payload.js'
 
 export const metadata = { id: '@ossy/resources/tasks/search' }
 
 export async function run({ payload, req }) {
-  const query = { ...(payload ?? {}) }
+  const query = sanitizeSearchPayload(payload ?? {})
   const workspaceId = payload?.workspaceId ?? req?.workspaceId
   const user = payload?.user ?? req?.user
   let location = query.location

package/src/share-resource.flow.js

@@ -0,0 +1,59 @@
+import uploadFileFlow from './upload-file.flow.js'
+import { metadata as OpenShare } from './open-share.action.js'
+import { metadata as MakePublic } from './make-public.action.js'
+import { metadata as CopyShareLink } from './copy-share-link.action.js'
+import { metadata as CloseShare } from './close-share.action.js'
+
+export const metadata = {
+  id: '@ossy/resources/flows/share-resource',
+  feature: 'resources',
+  requires: ['server', 'database'],
+  timeout: 150_000,
+}
+
+/**
+ * After uploading a file, open the share dialog from the resource panel,
+ * make the file public, see the copy-link control plus public access marker,
+ * then close the share dialog.
+ */
+export default {
+  title: 'Share uploaded resource',
+  description:
+    'Signed-in user uploads a file, opens share from the panel, makes it public, sees the share link controls, then closes the dialog',
+  steps: [
+    ...uploadFileFlow.steps,
+    { click: { selector: '[data-resource-name="e2e-upload.txt"]' } },
+    { result: { action: OpenShare, timeout: 15000 } },
+    { action: OpenShare },
+    {
+      result: {
+        selector: '[data-region="resource-share"][data-share-status="private"]',
+        timeout: 15000,
+      },
+    },
+    { result: { action: MakePublic, timeout: 10000 } },
+    { action: MakePublic },
+    {
+      result: {
+        selector: '[data-region="resource-share"][data-share-status="public"]',
+        timeout: 20000,
+      },
+    },
+    { result: { action: CopyShareLink, timeout: 10000 } },
+    {
+      result: {
+        selector: '[data-resource-name="e2e-upload.txt"][data-resource-access="public"]',
+        timeout: 20000,
+      },
+    },
+    { result: { action: CloseShare, timeout: 10000 } },
+    { action: CloseShare },
+    {
+      result: {
+        selector: '[data-region="resource-share"]',
+        hidden: true,
+        timeout: 10000,
+      },
+    },
+  ],
+}

package/src/sort-ascending.action.js

@@ -0,0 +1,5 @@
+/** Client-only — sort storage resources ascending. */
+export const metadata = {
+  id: '@ossy/resources/actions/sort-ascending',
+  access: 'workspace',
+}

package/src/sort-by-created.action.js

@@ -0,0 +1,5 @@
+/** Client-only — sort storage resources by created time. */
+export const metadata = {
+  id: '@ossy/resources/actions/sort-by-created',
+  access: 'workspace',
+}

package/src/sort-by-last-updated.action.js

@@ -0,0 +1,5 @@
+/** Client-only — sort storage resources by last updated time. */
+export const metadata = {
+  id: '@ossy/resources/actions/sort-by-last-updated',
+  access: 'workspace',
+}

package/src/sort-by-name.action.js

@@ -0,0 +1,5 @@
+/** Client-only — sort storage resources by name. */
+export const metadata = {
+  id: '@ossy/resources/actions/sort-by-name',
+  access: 'workspace',
+}

package/src/sort-by-size.action.js

@@ -0,0 +1,5 @@
+/** Client-only — sort storage resources by size. */
+export const metadata = {
+  id: '@ossy/resources/actions/sort-by-size',
+  access: 'workspace',
+}

package/src/sort-by-type.action.js

@@ -0,0 +1,5 @@
+/** Client-only — sort storage resources by type. */
+export const metadata = {
+  id: '@ossy/resources/actions/sort-by-type',
+  access: 'workspace',
+}

package/src/sort-descending.action.js

@@ -0,0 +1,5 @@
+/** Client-only — sort storage resources descending. */
+export const metadata = {
+  id: '@ossy/resources/actions/sort-descending',
+  access: 'workspace',
+}

package/src/sort-storage-created.flow.js

@@ -0,0 +1,87 @@
+import signUpFlow from '@ossy/authentication/sign-up.flow.js'
+import { metadata as ConfirmUpload } from './confirm-upload.action.js'
+import { metadata as FinishUpload } from './finish-upload.action.js'
+import { metadata as OpenSort } from './open-sort.action.js'
+import { metadata as SortByCreated } from './sort-by-created.action.js'
+
+export const metadata = {
+  id: '@ossy/resources/flows/sort-storage-created',
+  feature: 'resources',
+  requires: ['server', 'database'],
+  timeout: 180_000,
+}
+
+/**
+ * Upload two files whose name order is opposite their created order, open the
+ * storage sort menu, switch to created ascending, and assert list order + markers.
+ */
+export default {
+  title: 'Sort storage resources by created',
+  description:
+    'Signed-in user uploads two files, opens sort, chooses created, and sees created ascending order',
+  steps: [
+    ...signUpFlow.steps,
+    { page: '@upload-media', search: { location: '/' } },
+    { result: { selector: '#upload-resources', timeout: 15000 } },
+    { result: { selector: '[data-flow-stage="upload-idle"]', timeout: 15000 } },
+    {
+      files: {
+        selector: '#upload-resources',
+        items: [{
+          name: 'e2e-created-z.txt',
+          mimeType: 'text/plain',
+          // Uploaded first so created-asc places this before the later "a" file.
+          content: 'created first z',
+        }],
+      },
+    },
+    { result: { selector: '[data-flow-stage="upload-preview"]', timeout: 15000 } },
+    { result: { action: ConfirmUpload, timeout: 10000 } },
+    { action: ConfirmUpload },
+    { result: { selector: '[data-flow-stage="upload-done"]', timeout: 30000 } },
+    { result: { action: FinishUpload, timeout: 10000 } },
+    { action: FinishUpload },
+    { result: { page: '@storage/home', timeout: 20000 } },
+    { result: { selector: '[data-resource-name="e2e-created-z.txt"]', timeout: 20000 } },
+    { page: '@upload-media', search: { location: '/' } },
+    { result: { selector: '#upload-resources', timeout: 15000 } },
+    { result: { selector: '[data-flow-stage="upload-idle"]', timeout: 15000 } },
+    {
+      files: {
+        selector: '#upload-resources',
+        items: [{
+          name: 'e2e-created-a.txt',
+          mimeType: 'text/plain',
+          content: 'created second a',
+        }],
+      },
+    },
+    { result: { selector: '[data-flow-stage="upload-preview"]', timeout: 15000 } },
+    { result: { action: ConfirmUpload, timeout: 10000 } },
+    { action: ConfirmUpload },
+    { result: { selector: '[data-flow-stage="upload-done"]', timeout: 30000 } },
+    { result: { action: FinishUpload, timeout: 10000 } },
+    { action: FinishUpload },
+    { result: { page: '@storage/home', timeout: 20000 } },
+    { result: { selector: '[data-resource-name="e2e-created-a.txt"]', timeout: 20000 } },
+    { result: { selector: '[data-resource-name="e2e-created-z.txt"]', timeout: 20000 } },
+    { result: { selector: '[data-sort-by="name"][data-sort-order="asc"]', timeout: 10000 } },
+    {
+      result: {
+        selector: '[data-resource-name="e2e-created-a.txt"] ~ [data-resource-name="e2e-created-z.txt"]',
+        timeout: 10000,
+      },
+    },
+    { result: { action: OpenSort, timeout: 10000 } },
+    { action: OpenSort },
+    { result: { action: SortByCreated, timeout: 10000 } },
+    { action: SortByCreated },
+    { result: { selector: '[data-sort-by="created"][data-sort-order="asc"]', timeout: 10000 } },
+    {
+      result: {
+        selector: '[data-resource-name="e2e-created-z.txt"] ~ [data-resource-name="e2e-created-a.txt"]',
+        timeout: 10000,
+      },
+    },
+  ],
+}