@ossy/resources 3.7.0 → 3.8.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ossy/resources",
   "description": "Resource domain — aggregate and events for the Ossy resource model",
-  "version": "3.7.0",
+  "version": "3.8.0",
   "private": false,
   "type": "module",
   "main": "./src/index.js",
@@ -23,10 +23,10 @@
     "src": "./src"
   },
   "dependencies": {
-    "@ossy/event-store": "^3.7.0",
+    "@ossy/event-store": "^3.8.0",
     "@ossy/fold": "^3.4.0",
-    "@ossy/platform": "^3.7.0",
-    "@ossy/schema": "^3.6.1"
+    "@ossy/platform": "^3.8.0",
+    "@ossy/schema": "^3.8.0"
   },
   "peerDependencies": {
     "@ossy/design-system": ">=1.0.0",
@@ -49,5 +49,5 @@
     "/src",
     "README.md"
   ],
-  "gitHead": "622d97535abad08415963405ace2f5aaaecd7ca4"
+  "gitHead": "14548dfc2019e7258e8c75db527acbf66fe829bd"
 }

package/src/CreateDocument.jsx

@@ -1,36 +1,104 @@
-import React, { useState } from 'react'
+import React, { useMemo, useState } from 'react'
 import { createDocument } from './resource.helpers.js'
 import { useSdk } from '@ossy/sdk-react'
-import { Alert, useLocale } from '@ossy/design-system'
+import { Alert, Button, Text, View, useLocale } from '@ossy/design-system'
 import { useRouter } from '@ossy/router-react'
 import { GenericResourceForm } from './GenericResourceForm.jsx'
+import { useSchemas } from './useSchemas.js'
+import { safeReturnTo, schemasForGenericCreate } from './document-create.helpers.js'
 
 export const CreateDocument = () => {
   const { t } = useLocale()
   const router = useRouter()
   const schemaId = router.searchParams.schemaId
   const location = router.searchParams.location
+  const category = router.searchParams.category
   const sdk = useSdk()
+  const schemas = useSchemas()
   const [error, setError] = useState()
 
-  const onCancel = () => {
-    const search = new URLSearchParams({ location }).toString()
-    router.navigate(`@storage/home?${search}`)
+  const returnTo = safeReturnTo(router.searchParams.returnTo)
+
+  const creatable = useMemo(
+    () => schemasForGenericCreate(schemas, { category: category || undefined }),
+    [schemas, category],
+  )
+
+  const grouped = useMemo(() => {
+    const groups = new Map()
+    for (const schema of creatable) {
+      const name = schema.categoryName || t('resources.form.otherCategory')
+      const list = groups.get(name) || []
+      list.push(schema)
+      groups.set(name, list)
+    }
+    return [...groups.entries()].sort(([a], [b]) => a.localeCompare(b))
+  }, [creatable, t])
+
+  const onDone = () => {
+    if (returnTo) {
+      router.navigate(returnTo)
+      return
+    }
+    const search = location ? new URLSearchParams({ location }).toString() : ''
+    router.navigate(`@storage/home${search ? `?${search}` : ''}`)
   }
 
   const onSubmit = ({ name, content, type }) => {
     createDocument(sdk, { type, location, name, content })
-      .then(() => onCancel())
+      .then(() => onDone())
       .catch((err) => setError(err?.message || t('resources.form.createFailed')))
   }
 
+  const selectSchema = (id) => {
+    const params = new URLSearchParams()
+    if (location) params.set('location', location)
+    if (category) params.set('category', category)
+    if (returnTo) params.set('returnTo', returnTo)
+    params.set('schemaId', id)
+    router.navigate(`@create-document?${params.toString()}`)
+  }
+
+  if (!schemaId) {
+    return (
+      <View gap="m" style={{ minWidth: 'min(28rem, calc(100vw - 2rem))' }}>
+        <View gap="xs">
+          <Text variant="heading-tertiary" as="h3" text="resources.createDocument.title" />
+          <Text color="secondary" text="resources.createDocument.pickType" />
+        </View>
+        {grouped.length === 0 ? (
+          <Text color="secondary" text="resources.createDocument.noTypes" />
+        ) : grouped.map(([categoryName, items]) => (
+          <View key={categoryName} gap="s">
+            <Text variant="small" weight="medium">{categoryName}</Text>
+            <View layout="row" gap="s" style={{ flexWrap: 'wrap' }}>
+              {items.map((schema) => (
+                <Button
+                  key={schema.id}
+                  variant="neutral"
+                  prefix={schema.icon || 'add'}
+                  onClick={() => selectSchema(schema.id)}
+                >
+                  {schema.name || schema.id}
+                </Button>
+              ))}
+            </View>
+          </View>
+        ))}
+        <View layout="row" justifyContent="flex-end">
+          <Button variant="link" onClick={onDone} label="design-system.cancel" />
+        </View>
+      </View>
+    )
+  }
+
   return (
     <>
       <GenericResourceForm
         schemaId={schemaId}
         mode="create"
         onSubmit={onSubmit}
-        onCancel={onCancel}
+        onCancel={onDone}
       />
       {error && <Alert>{error}</Alert>}
     </>

package/src/ResourceGrid.jsx

@@ -201,7 +201,7 @@ const ResourceGridItem = memo(function ResourceGridItem({
         position: 'relative',
       }}
     >
-      {(showSelectionControls || selected) && (
+      {showSelectionControls && (
         <View
           style={{
             position: 'absolute',

package/src/ResourceList.jsx

@@ -160,7 +160,7 @@ const ResourceListItem = memo(function ResourceListItem({
 
     const leading = (
       <View layout="row" alignItems="center" gap="s" style={{ flexShrink: 0 }}>
-        {(showSelectionControls || selected) && (
+        {showSelectionControls && (
           <ResourceSelectionCheckbox
             selected={selected}
             onToggle={handleToggleSelect}

package/src/ResourcePanel.jsx

@@ -176,7 +176,7 @@ export const ResourcePanel = memo(function ResourcePanel ({
             <Switch.Case match={[ViewMode.View]}>
 
                 <View.Item fill surface="primary" style={{ padding: '4px 8px' }}>
-                  <Text as="h3" variant="breadcrumb">{resourceName}</Text>
+                  <Text as="h3" variant="small" style={{ fontWeight: 'bold' }}>{resourceName}</Text>
                </View.Item>
 
               {downloadHref && (

package/src/VideoResource.jsx

@@ -1,7 +1,6 @@
-import React  from 'react'
+import React from 'react'
 import { metadata as GetResource } from './get.action.js'
 import { useSdk } from '@ossy/sdk-react'
-import { View } from '@ossy/design-system'
 
 export const VideoResource = ({
   resourceId
@@ -10,17 +9,17 @@ export const VideoResource = ({
   const { data: resource } = sdk.read(GetResource, { resourceId }, { enabled: !!resourceId })
 
   return (
-    <View stack bordered>
-          <View.Item fill style={{ padding: '16px 8px' }}>
-
-      <div style={{ display: 'flex', justifyContent: 'center' }}>
-              <video
-                controls
-                src={resource?.content?.src}
-                style={{ width: 'auto', height: '400px', margin: 'var(--space-l) auto' }}
-              />
-            </div>
-      </View.Item>
-    </View>
+    <div style={{ display: 'flex', justifyContent: 'center', padding: 'var(--space-m) var(--space-s) var(--space-xl)' }}>
+      <video
+        controls
+        src={resource?.content?.src}
+        style={{
+          width: '100%',
+          maxWidth: '960px',
+          height: 'auto',
+          margin: 'var(--space-m) auto var(--space-l)',
+        }}
+      />
+    </div>
   )
 }

package/src/document-create.helpers.js

@@ -0,0 +1,78 @@
+import { parseSchemaId } from '@ossy/schema'
+
+/**
+ * Document types that can be created from the generic create-document GUI.
+ * Platform internals and capability schemas are excluded.
+ *
+ * @param {object} schema
+ * @returns {boolean}
+ */
+export function isGenericCreateSchema (schema) {
+  if (!schema?.id || !Array.isArray(schema.fields) || schema.fields.length === 0) return false
+  const category = schema.categoryName ?? ''
+  if (/platform/i.test(category)) return false
+  return true
+}
+
+function kebabConcept (value) {
+  return String(value)
+    .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+    .replace(/_/g, '-')
+    .toLowerCase()
+}
+
+/**
+ * Treat canonical ADR 0006 ids and pre-migration `@provider/feature/concept` ids
+ * as the same create-document type (e.g. employee vs schema/employee).
+ *
+ * @param {string} [schemaId]
+ * @returns {string | undefined}
+ */
+export function schemaCreateIdentity (schemaId) {
+  if (typeof schemaId !== 'string' || !schemaId) return schemaId
+  const parsed = parseSchemaId(schemaId)
+  if (parsed) return `${parsed.provider}/${parsed.feature}/${kebabConcept(parsed.concept)}`
+  const legacy = /^@([^/]+)\/([^/]+)\/([^/]+)$/.exec(schemaId)
+  if (legacy) return `${legacy[1]}/${legacy[2]}/${kebabConcept(legacy[3])}`
+  return schemaId
+}
+
+function schemaNameKey (schema) {
+  const name = schema?.name
+  if (!name) return null
+  return `name:${schema.categoryName ?? ''}:${name}`
+}
+
+/**
+ * @param {object[]} schemas
+ * @param {{ category?: string }} [options]
+ * @returns {object[]}
+ */
+export function schemasForGenericCreate (schemas, { category } = {}) {
+  const list = Array.isArray(schemas) ? schemas : []
+  const seen = new Set()
+  const result = []
+  for (const schema of list) {
+    if (!isGenericCreateSchema(schema)) continue
+    if (category && schema.categoryName !== category) continue
+    const identity = schemaCreateIdentity(schema.id)
+    const nameKey = schemaNameKey(schema)
+    if (seen.has(identity) || (nameKey && seen.has(nameKey))) continue
+    seen.add(identity)
+    if (nameKey) seen.add(nameKey)
+    result.push(schema)
+  }
+  return result
+}
+
+/**
+ * Same-origin relative path only.
+ * @param {unknown} value
+ * @returns {string | null}
+ */
+export function safeReturnTo (value) {
+  if (typeof value !== 'string') return null
+  const trimmed = value.trim()
+  if (!trimmed.startsWith('/') || trimmed.startsWith('//')) return null
+  return trimmed
+}

package/src/document-create.helpers.spec.js

@@ -0,0 +1,71 @@
+import { describe, expect, it } from '@jest/globals'
+import { isGenericCreateSchema, safeReturnTo, schemaCreateIdentity, schemasForGenericCreate } from './document-create.helpers.js'
+
+describe('document-create helpers', () => {
+  it('excludes platform schemas and field-less types', () => {
+    const schemas = [
+      { id: '@ossy/consultancy/schema/employee', categoryName: 'Consultancy', fields: [{ name: 'name', type: 'text' }] },
+      { id: '@ossy/platform/schema/file', categoryName: 'Platform', fields: [{ name: 'name', type: 'text' }] },
+      { id: '@ossy/empty/schema/x', categoryName: 'Other', fields: [] },
+    ]
+    expect(schemasForGenericCreate(schemas).map((s) => s.id)).toEqual([
+      '@ossy/consultancy/schema/employee',
+    ])
+    expect(isGenericCreateSchema(schemas[1])).toBe(false)
+  })
+
+  it('filters by category when asked', () => {
+    const schemas = [
+      { id: 'a', categoryName: 'Consultancy', fields: [{ name: 'n', type: 'text' }] },
+      { id: 'b', categoryName: 'Web', fields: [{ name: 'n', type: 'text' }] },
+    ]
+    expect(schemasForGenericCreate(schemas, { category: 'Consultancy' }).map((s) => s.id)).toEqual(['a'])
+  })
+
+  it('aliases canonical and pre-migration consultancy ids', () => {
+    expect(schemaCreateIdentity('@ossy/consultancy/schema/employee')).toBe('ossy/consultancy/employee')
+    expect(schemaCreateIdentity('@ossy/consultancy/employee')).toBe('ossy/consultancy/employee')
+    expect(schemaCreateIdentity('@ossy/consultancy/companyBasicInfo')).toBe('ossy/consultancy/company-basic-info')
+    expect(schemaCreateIdentity('@ossy/consultancy/schema/company-basic-info')).toBe('ossy/consultancy/company-basic-info')
+  })
+
+  it('hides workspace copies of system schemas on the create picker', () => {
+    const schemas = [
+      { id: '@ossy/consultancy/schema/company-basic-info', name: 'Company Basic Info', categoryName: 'Consultancy', icon: 'organisation', fields: [{ name: 'name', type: 'text' }] },
+      { id: '@ossy/consultancy/schema/contract', name: 'Contract', categoryName: 'Consultancy', icon: 'file', fields: [{ name: 'name', type: 'text' }] },
+      { id: '@ossy/consultancy/schema/employee', name: 'Employee', categoryName: 'Consultancy', icon: 'user-add', fields: [{ name: 'name', type: 'text' }] },
+      { id: '@ossy/consultancy/schema/opportunity', name: 'Opportunity', categoryName: 'Consultancy', fields: [{ name: 'name', type: 'text' }] },
+      { id: '@ossy/consultancy/schema/proposal', name: 'Proposal', categoryName: 'Consultancy', icon: 'file', fields: [{ name: 'name', type: 'text' }] },
+      { id: '@ossy/consultancy/schema/vacation', name: 'Vacation', categoryName: 'Consultancy', icon: 'calendar', fields: [{ name: 'name', type: 'text' }] },
+      { id: '@ossy/consultancy/vacation', name: 'Vacation', categoryName: 'Consultancy', fields: [{ name: 'name', type: 'text' }] },
+      { id: '@ossy/consultancy/employee', name: 'Employee', categoryName: 'Consultancy', fields: [{ name: 'name', type: 'text' }] },
+      { id: '@ossy/consultancy/companyBasicInfo', name: 'Company Basic Info', categoryName: 'Consultancy', fields: [{ name: 'name', type: 'text' }] },
+      { id: '@ossy/consultancy/contract', name: 'Contract', categoryName: 'Consultancy', fields: [{ name: 'name', type: 'text' }] },
+    ]
+    expect(schemasForGenericCreate(schemas).map((s) => s.id)).toEqual([
+      '@ossy/consultancy/schema/company-basic-info',
+      '@ossy/consultancy/schema/contract',
+      '@ossy/consultancy/schema/employee',
+      '@ossy/consultancy/schema/opportunity',
+      '@ossy/consultancy/schema/proposal',
+      '@ossy/consultancy/schema/vacation',
+    ])
+  })
+
+  it('keeps workspace-only custom types', () => {
+    const schemas = [
+      { id: '@ossy/consultancy/schema/employee', name: 'Employee', categoryName: 'Consultancy', fields: [{ name: 'name', type: 'text' }] },
+      { id: 'workspace/custom-invoice', name: 'Invoice', categoryName: 'Consultancy', fields: [{ name: 'name', type: 'text' }] },
+    ]
+    expect(schemasForGenericCreate(schemas).map((s) => s.id)).toEqual([
+      '@ossy/consultancy/schema/employee',
+      'workspace/custom-invoice',
+    ])
+  })
+
+  it('only allows same-origin relative returnTo paths', () => {
+    expect(safeReturnTo('/forecasts')).toBe('/forecasts')
+    expect(safeReturnTo('//evil.example')).toBe(null)
+    expect(safeReturnTo('https://evil.example')).toBe(null)
+  })
+})

package/src/en.translations.json

@@ -8,6 +8,7 @@
   "resources.form.createFailed": "Create failed",
   "resources.form.createResource": "Create resource",
   "resources.form.typeRemoved": "This document type has been removed and can't be edited.",
+  "resources.form.otherCategory": "Other",
   "@ossy/resources/actions/create.label": "Create resource",
   "@ossy/resources/actions/create.description": "Create a new resource in the workspace",
   "@ossy/resources/actions/list.label": "List resources",
@@ -41,6 +42,8 @@
   "resources.upload.location": "Location: {location}",
   "resources.createDirectory.title": "Create directory",
   "resources.createDocument.title": "Create document",
+  "resources.createDocument.pickType": "Choose a document type to create in this location.",
+  "resources.createDocument.noTypes": "No document types are available to create here.",
   "resources.createDirectory.description": "Create a new directory to organize your resources. The new directory will be created in the location: {location}",
   "resources.createDirectory.namePlaceholder": "Directory name",
   "resources.createDirectory.submit": "Create directory",

package/src/index.js

@@ -52,3 +52,4 @@ export * from './useSchemaEngine.js'
 export * from './useDocumentValidator.js'
 export * from './useForm.js'
 export * from './resource.helpers.js'
+export * from './document-create.helpers.js'

package/src/resources.action-media.js

@@ -1,4 +1,7 @@
 import { attachResourceMediaUrls } from './resources.attach-media-urls.js'
+import { createLogger } from '@ossy/observability'
+
+const log = createLogger('resources')
 
 export function mediaContextFromRun({ payload, req }) {
   return {
@@ -7,12 +10,24 @@ export function mediaContextFromRun({ payload, req }) {
   }
 }
 
+async function attachOrKeep (resource, context) {
+  try {
+    return await attachResourceMediaUrls(resource, context)
+  } catch (error) {
+    log.warn('[withResourceMedia] skipping media urls', {
+      resourceId: resource?.id,
+      error: error?.message,
+    })
+    return resource
+  }
+}
+
 export async function withResourceMedia(result, context) {
   if (Array.isArray(result)) {
-    return Promise.all(result.map(r => attachResourceMediaUrls(r, context)))
+    return Promise.all(result.map(r => attachOrKeep(r, context)))
   }
   if (result && typeof result === 'object' && result.id) {
-    return attachResourceMediaUrls(result, context)
+    return attachOrKeep(result, context)
   }
   return result
 }

package/src/resources.attach-media-urls.js

@@ -1,6 +1,10 @@
 import { StorageClient } from '@ossy/platform'
 import { Aggregate } from '@ossy/event-store'
+import { coerceStorageKey } from '@ossy/platform/storage-keys'
 import { Workspace } from '@ossy/workspaces/server'
+import { createLogger } from '@ossy/observability'
+
+const log = createLogger('resources')
 
 /**
  * Adds `content.src` (and `content.sizes[*]` URLs) for file resources, respecting
@@ -39,11 +43,19 @@ export async function attachResourceMediaUrls(resource, { userId, workspaceId }
     return { ...resource, content: nextContent }
   }
 
-  if (Key) {
+  const originalKey = coerceStorageKey(Key, resource.id)
+  if (Key && !originalKey) {
+    log.warn('[attachResourceMediaUrls] skipping invalid storage key', {
+      resourceId: resource.id,
+      key: Key,
+    })
+  }
+
+  if (originalKey) {
     nextContent.src =
       access === 'public'
-        ? StorageClient.createDownloadUrl(Key)
-        : await StorageClient.createPresignedDownloadUrl(Key)
+        ? StorageClient.createDownloadUrl(originalKey)
+        : await StorageClient.createPresignedDownloadUrl(originalKey)
   }
 
   if (hasSizes) {
@@ -54,10 +66,15 @@ export async function attachResourceMediaUrls(resource, { userId, workspaceId }
         nextSizes[name] = value
         continue
       }
+      const sizeFallback = resource.id && /^[A-Za-z0-9_-]+$/.test(name)
+        ? `${resource.id}:${name}`
+        : resource.id
+      const logical = coerceStorageKey(value, sizeFallback)
+      if (!logical) continue
       nextSizes[name] =
         access === 'public'
-          ? StorageClient.createDownloadUrl(value)
-          : await StorageClient.createPresignedDownloadUrl(value)
+          ? StorageClient.createDownloadUrl(logical)
+          : await StorageClient.createPresignedDownloadUrl(logical)
     }
     nextContent.sizes = nextSizes
   }

package/src/sv.translations.json

@@ -8,6 +8,7 @@
   "resources.form.createFailed": "Skapandet misslyckades",
   "resources.form.createResource": "Skapa resurs",
   "resources.form.typeRemoved": "Den här dokumenttypen har tagits bort och kan inte redigeras.",
+  "resources.form.otherCategory": "Övrigt",
   "@ossy/resources/actions/create.label": "Skapa resurs",
   "@ossy/resources/actions/create.description": "Skapa en ny resurs i workspace",
   "@ossy/resources/actions/list.label": "Lista resurser",
@@ -41,6 +42,8 @@
   "resources.upload.location": "Plats: {location}",
   "resources.createDirectory.title": "Skapa mapp",
   "resources.createDocument.title": "Skapa dokument",
+  "resources.createDocument.pickType": "Välj en dokumenttyp att skapa på den här platsen.",
+  "resources.createDocument.noTypes": "Inga dokumenttyper kan skapas här.",
   "resources.createDirectory.description": "Skapa en ny mapp för att organisera dina resurser. Den nya mappen skapas på platsen: {location}",
   "resources.createDirectory.namePlaceholder": "Mappnamn",
   "resources.createDirectory.submit": "Skapa mapp",