@ossy/resources 1.12.2 → 3.0.1

package/src/SchemaFormDefault.jsx

@@ -0,0 +1,86 @@
+import React from 'react'
+import {
+  View,
+  Text,
+  Button,
+  Fields,
+  DelayedRender,
+  useLocale,
+  Form,
+  FieldFactory,
+} from '@ossy/design-system'
+
+/**
+ * Generic schema form — {@link Form} + {@link FieldFactory} (platform fallback).
+ *
+ * @param {{
+ *   schemaId?: string,
+ *   fields?: { name: string, type?: string, label?: string, required?: boolean }[],
+ *   mode?: 'create' | 'edit',
+ *   form?: { data?: Record<string, unknown>, onChange?: (detail: unknown) => void },
+ *   initialContent?: Record<string, unknown>,
+ *   resource?: { content?: Record<string, unknown> },
+ *   onSubmit?: (data: Record<string, unknown>) => void,
+ *   onCancel?: () => void,
+ *   submitLabel?: string,
+ * }} props
+ */
+export function SchemaFormDefault ({
+  schemaId,
+  fields: fieldsProp,
+  mode = 'create',
+  form,
+  initialContent = {},
+  resource,
+  onSubmit,
+  onCancel,
+  submitLabel,
+}) {
+  const { t } = useLocale()
+  const fields = fieldsProp ?? []
+  const defaultData = Object.keys(initialContent).length
+    ? initialContent
+    : (resource?.content ?? {})
+
+  if (form && mode === 'edit') {
+    if (fields.length && form.data) {
+      return (
+        <Fields
+          schemaId={schemaId}
+          data={form.data}
+          onChange={form.onChange}
+          fields={fields}
+        />
+      )
+    }
+
+    if (fields.length && !form.data) {
+      return (
+        <DelayedRender>
+          <Text>Loading...</Text>
+        </DelayedRender>
+      )
+    }
+
+    return null
+  }
+
+  return (
+    <Form
+      id={schemaId ? `${schemaId}/default` : 'schema-form-default'}
+      schemaId={schemaId}
+      fields={fields}
+      defaultData={defaultData}
+      onSubmit={onSubmit}
+      gap="m"
+    >
+      <FieldFactory />
+      <View layout="row" gap="s" justifyContent="flex-end">
+        {onCancel && <Button variant="link" onClick={onCancel} label="design-system.cancel" />}
+        <Button type="submit" variant="cta">
+          {submitLabel || (mode === 'edit' ? t('design-system.save') : 'Submit')}
+        </Button>
+      </View>
+    </Form>
+  )
+}

package/src/SchemaPresenter.jsx

@@ -0,0 +1,207 @@
+import React, { useMemo } from 'react'
+import { metadata as GetResource } from './get.action.js'
+import { AsyncStatus, useSdk } from '@ossy/sdk-react'
+import { useSchemas } from './useSchemas.js'
+import {
+  isMimeType,
+  isSchemaDocumentType,
+  resolveFormComponentId,
+  resolveMimeViewChain,
+  resolveViewComponentChain,
+} from '@ossy/schema/resolve'
+import { Guide, Text, DelayedRender, Slot, View } from '@ossy/design-system'
+import { SchemaDetailView } from './SchemaDetailView.jsx'
+import { useSchema } from './useSchemas.js'
+import { ImageResource } from './ImageResource.jsx'
+import { AudioResource } from './AudioResource.jsx'
+import { VideoResource } from './VideoResource.jsx'
+import { PDFResource } from './PDFResource.jsx'
+import { ResourceGenericView } from './ResourceGenericView.jsx'
+import { GenericResourceForm } from './GenericResourceForm.jsx'
+
+/** MIME type for rendering — file envelope stores MIME in content. */
+export function resolveMediaType (resource) {
+  if (resource?.content?.ContentType) return resource.content.ContentType
+  return resource?.type
+}
+
+function SchemaViewFallback ({ resource, projection, resourceId, fields }) {
+  if (fields?.length || resource?.content) {
+    return (
+      <View inset="m">
+        <SchemaDetailView
+          schemaId={resource?.type}
+          fields={fields}
+          data={resource?.content ?? {}}
+          title={resource?.name}
+        />
+        {projection && (
+          <Text size="s" color="secondary">projection: {projection}</Text>
+        )}
+      </View>
+    )
+  }
+
+  return <ResourceGenericView resourceId={resourceId} />
+}
+
+function SchemaViewPresenter ({ resource, projection, resourceId }) {
+  const template = useSchema(resource?.type)
+  const chain = useMemo(
+    () => resolveViewComponentChain(resource.type, projection),
+    [resource.type, projection],
+  )
+  const [primary, secondary] = chain
+  const slotProps = {
+    resourceId,
+    resource,
+    schemaId: resource.type,
+    projection,
+    fields: template?.fields,
+  }
+
+  return (
+    <Slot
+      view={primary}
+      {...slotProps}
+      fallback={
+        <Slot
+          view={secondary}
+          {...slotProps}
+          fallback={(
+            <SchemaViewFallback
+              resource={resource}
+              projection={projection}
+              resourceId={resourceId}
+              fields={template?.fields}
+            />
+          )}
+        />
+      }
+    />
+  )
+}
+
+function MimeViewPresenter ({ resource, projection, resourceId, onClose }) {
+  const mime = resolveMediaType(resource)
+  if (['image/jpeg', 'image/png', 'image/webp'].includes(mime)) {
+    return <ImageResource resourceId={resourceId} onClose={onClose} />
+  }
+  if (mime?.startsWith('video/')) {
+    return <VideoResource resourceId={resourceId} onClose={onClose} />
+  }
+  if (mime?.startsWith('audio/')) {
+    return <AudioResource resourceId={resourceId} onClose={onClose} />
+  }
+  if (mime === 'application/pdf') {
+    return <PDFResource resourceId={resourceId} onClose={onClose} />
+  }
+
+  const chain = resolveMimeViewChain(mime, projection)
+  const [primary, secondary] = chain
+  return (
+    <Slot
+      view={primary}
+      resourceId={resourceId}
+      resource={resource}
+      projection={projection}
+      fallback={
+        <Slot
+          view={secondary}
+          resourceId={resourceId}
+          resource={resource}
+          projection={projection}
+          fallback={<ResourceGenericView resourceId={resourceId} onClose={onClose} />}
+        />
+      }
+    />
+  )
+}
+
+/**
+ * ADR 0006 host: `resourceId` → fetch → `resource.type` → view/form component chain.
+ */
+export function SchemaPresenter ({
+  resourceId,
+  resource: resourceProp,
+  flow = 'View',
+  projection,
+  form,
+  onClose,
+  onSubmit,
+  onCancel,
+  mode,
+  initialName,
+  initialContent,
+  submitLabel,
+}) {
+  const sdk = useSdk()
+  const schemas = useSchemas()
+  const { data: loaded, status } = sdk.read(GetResource, { resourceId }, { enabled: !!resourceId && !resourceProp })
+  const resource = resourceProp ?? loaded
+
+  if (!resourceProp && AsyncStatus.Error === status) {
+    return (
+      <Guide
+        title="Not found"
+        text="We can't find the resource you are looking for"
+        style={{ padding: '40px 16px' }}
+      />
+    )
+  }
+
+  if (!resource && [AsyncStatus.Loading, AsyncStatus.NotInitialized].includes(status)) {
+    return (
+      <DelayedRender>
+        <Text>loading...</Text>
+      </DelayedRender>
+    )
+  }
+
+  if (!resource) return null
+
+  const isDocumentSchema =
+    isSchemaDocumentType(resource.type) || schemas.some(s => s.id === resource.type)
+
+  if (flow === 'Edit' || flow === 'edit') {
+    if (isDocumentSchema) {
+      return (
+        <GenericResourceForm
+          schemaId={resource.type}
+          mode="edit"
+          resourceId={resourceId}
+          resource={resource}
+          form={form}
+          onSubmit={onSubmit}
+          onCancel={onCancel}
+          submitLabel={submitLabel}
+        />
+      )
+    }
+    return <ResourceGenericView resourceId={resourceId} onClose={onClose} />
+  }
+
+  if (resource.type === '@ossy/platform/schema/directory' || resource.type === 'directory') {
+    return <Text>directory</Text>
+  }
+
+  if (isDocumentSchema) {
+    return <SchemaViewPresenter resource={resource} projection={projection} resourceId={resourceId} />
+  }
+
+  const mime = resolveMediaType(resource)
+  if (isMimeType(mime) || resource.type === '@ossy/platform/schema/file') {
+    return <MimeViewPresenter resource={resource} projection={projection} resourceId={resourceId} onClose={onClose} />
+  }
+
+  return <ResourceGenericView resourceId={resourceId} onClose={onClose} />
+}
+
+/**
+ * Create flow — resolves form component for a schema id.
+ */
+export function SchemaFormPresenter (props) {
+  return <GenericResourceForm {...props} />
+}
+
+export { resolveFormComponentId, resolveFormComponentChain } from '@ossy/schema/resolve'

package/src/Upload.jsx

@@ -1,5 +1,5 @@
-import React, { useState, useEffect } from 'react'
-import { Button, View, Text, Upload as _Upload, Icon } from '@ossy/design-system'
+import React, { useState } from 'react'
+import { Button, View, Text, UploadInput, Icon, LocalFilePreview } from '@ossy/design-system'
 import { useRouter } from '@ossy/router-react'
 
 const FlowStage = {
@@ -53,8 +53,8 @@ export const Upload = ({
           <View gap="s" style={{ flexGrow: '1', overflow: 'auto', padding: 'var(--space-m) 0' }}>
           {
             files.map(({ status, file }) => (
-              <View layout="row" gap="m" alignItems="center">
-                <UploadImgPreview file={file} />
+              <View key={file.name} layout="row" gap="m" alignItems="center">
+                <LocalFilePreview file={file} />
                 <Text style={{ margin: '0', lineHeight: '1', textWrap: 'nowrap', textOverflow: 'ellipsis', flexGrow: '1' }}>{file?.name || 'Untitled'}</Text>
                 <View layout="row" gap="xs">
                   <UploadStatus status={status} size="8px" />
@@ -68,7 +68,8 @@ export const Upload = ({
       }
 
       {files.length === 0 && (
-        <_Upload
+        <UploadInput
+          id="upload-resources"
           type="file"
           multiple
           onChange={onUserInput}
@@ -133,26 +134,6 @@ export const Upload = ({
 
 
 
-function UploadImgPreview({ file, size = "32px" }) {
-  const [src, setSrc] = useState()
-
-  useEffect(() => {
-    const reader = new FileReader()
-    reader.onload = (e) => setSrc(e.target.result)
-    reader.readAsDataURL(file)
-  }, [file])
-
-  return (
-    <View
-      as="img"
-      src={src}
-      width={size}
-      height={size}
-      style={{ backgroundSize: 'cover', borderRadius: 'var(--space-s)' }}
-    />
-  )
-}
-
 function UploadStatus({ status }) {
   if (status === 'preview') return <></>
   if (status === 'uploading') return <Icon name="spinner" size="s" animation="rotate" />

package/src/Upload.page.jsx

@@ -14,7 +14,7 @@ export const metadata = {
 export const UploadPage = () => {
   return (
     <View layout="off-center-s" style={{ height: '100%' }}>
-      <View slot="content" surface="primary" roundness="m" inset="m">
+      <View data-region="content" surface="primary" roundness="m" inset="m">
         <UploadResources/>
       </View>
     </View>

package/src/UploadResources.jsx

@@ -1,7 +1,7 @@
 import React from 'react'
 import { uploadFile } from './resource.helpers.js'
 import { useSdk } from '@ossy/sdk-react'
-import { Title, View, Text, useLocale } from '@ossy/design-system'
+import { View, Text, useLocale } from '@ossy/design-system'
 import { useRouter } from '@ossy/router-react'
 import { Upload } from './Upload.jsx'
 
@@ -14,7 +14,7 @@ export const UploadResources = () => {
   return (
     <View gap="s" style={{ height: '100%' }}>
       <View gap="s">
-        <Title variant="tertiary" style={{ marginBottom: '0' }}>{t('resources.upload.title')}</Title>
+        <Text variant="heading-tertiary" style={{ marginBottom: '0' }} as="h3" text="resources.upload.title" />
         <View layout="row" gap="s">
           <Text variant="small">{t('resources.upload.location', { location })}</Text>
         </View>

package/src/VideoResource.jsx

@@ -7,7 +7,7 @@ export const VideoResource = ({
   resourceId
 }) => {
   const sdk = useSdk()
-  const { data: resource } = sdk.read(GetResource, { id: resourceId }, { enabled: !!resourceId })
+  const { data: resource } = sdk.read(GetResource, { resourceId }, { enabled: !!resourceId })
 
   return (
     <View stack bordered>

package/src/access-filter.spec.js

@@ -50,7 +50,7 @@ describe('accessFilter', () => {
       const user = { id: 'u-1', workspaces: ['ws-1', 'ws-2'], policies: [] }
       const filter = accessFilter(user)
       expect(filter.$or).toContainEqual({
-        'state.access': { $in: ['public', 'workspace'] },
+        'state.access': { $in: ['public', 'workspace', 'restricted'] },
         'state.belongsTo': { $in: ['ws-1', 'ws-2'] },
       })
     })

package/src/create-page-view.action.js

@@ -1 +1 @@
-export const metadata = { id: 'resources/create-page-view', access: 'workspace' }
+export const metadata = { id: '@ossy/resources/actions/create-page-view', access: 'workspace' }

package/src/create-page-view.task.js

@@ -1,21 +1,20 @@
+import { nanoid } from 'nanoid'
 import { Aggregate } from '@ossy/event-store'
-import { Resource } from './resource.aggregate.js'
-import { ResourcesEvents } from './resources.events.js'
 import { Workspace } from '@ossy/workspaces/server'
-import { normalizeAndValidateDocumentContent } from '@ossy/platform'
+import { ResourcesEvents } from './resources.events.js'
+import { commitResource } from './resource-stream.helpers.js'
 
-export const metadata = { id: 'resources/create-page-view' }
+export const metadata = { id: '@ossy/resources/tasks/create-page-view' }
 
-const PAGE_VIEW_TEMPLATE_ID = '@ossy/web/page-view'
+const PAGE_VIEW_SCHEMA_ID = '@ossy/web/schema/page-view'
 const PAGE_VIEW_LOCATION = '/@ossy/analytics/page-views/'
 
-export async function run({ payload, req }) {
+export async function run ({ payload, req }) {
   const workspaceId = payload?.workspaceId ?? req?.workspaceId
   if (!workspaceId) throw Object.assign(new Error('workspaceId is required'), { status: 400 })
 
   const workspace = await Aggregate.Of(Workspace, workspaceId).then(Aggregate.View())
 
-  // Page-view template is a built-in; instantiate directly without schema validation
   const contentInput = {
     ...(payload ?? {}),
     userAgent: payload?.userAgent ?? req?.headers?.['user-agent'],
@@ -23,8 +22,10 @@ export async function run({ payload, req }) {
     path: payload?.path ?? '/',
   }
 
+  const resourceId = nanoid()
   const event = ResourcesEvents.Created({
-    type: PAGE_VIEW_TEMPLATE_ID,
+    resourceId,
+    schemaId: PAGE_VIEW_SCHEMA_ID,
     createdBy: payload?.userId ?? req?.userId ?? 'public',
     belongsTo: workspace.id,
     location: PAGE_VIEW_LOCATION,
@@ -33,6 +34,6 @@ export async function run({ payload, req }) {
     access: 'restricted',
   })
 
-  const resource = await Aggregate.Of(Resource, event).then(Aggregate.View())
+  const resource = await commitResource(event)
   return { id: resource.id }
 }

package/src/create.action.js

@@ -1 +1 @@
-export const metadata = { id: 'resources/create', access: 'workspace' }
+export const metadata = { id: '@ossy/resources/actions/create', access: 'workspace' }

package/src/create.task.js

@@ -1,17 +1,16 @@
 import { is } from 'ramda'
 import { nanoid } from 'nanoid'
 import { Aggregate } from '@ossy/event-store'
-import { Resource } from './resource.aggregate.js'
-import { ResourcesEvents } from './resources.events.js'
 import { Workspace } from '@ossy/workspaces/server'
-import { getSystemResourceTemplates, normalizeAndValidateDocumentContent } from '@ossy/platform'
+import { schemaForWorkspace } from '@ossy/platform'
+import { originalObjectKey } from '@ossy/platform/storage-keys'
+import { commitResource } from './resource-stream.helpers.js'
+import { ResourcesEvents } from './resources.events.js'
 import { mediaContextFromRun, withResourceMedia } from './resources.action-media.js'
 
-export const metadata = { id: 'resources/create' }
-
-const NativeResourceTypes = { DIRECTORY: 'directory' }
+export const metadata = { id: '@ossy/resources/tasks/create' }
 
-export async function run({ payload, integrations, req }) {
+export async function run ({ payload, integrations, req }) {
   const createdBy = payload?.userId ?? req?.userId
   const workspaceId = payload?.workspaceId ?? req?.workspaceId
 
@@ -30,56 +29,55 @@ export async function run({ payload, integrations, req }) {
   location = location.endsWith('/') ? location : location + '/'
   location = location.startsWith('/') ? location : '/' + location
 
-  const systemTemplates = getSystemResourceTemplates()
-  const allTemplates = [
-    ...systemTemplates,
-    ...(workspace.resourceTemplates || []).filter(t => !systemTemplates.find(s => s.id === t.id)),
-  ]
-  const isResourceTemplateType = allTemplates.map(t => t.id).includes(type)
+  const engine = schemaForWorkspace(workspace.schemas)
+  const isDocumentSchema = engine.has(type)
 
-  if (type === NativeResourceTypes.DIRECTORY) {
+  if (type === 'directory' || type === '@ossy/platform/schema/directory') {
     const event = ResourcesEvents.Created({
-      type: NativeResourceTypes.DIRECTORY,
+      schemaId: '@ossy/platform/schema/directory',
       createdBy,
       belongsTo: workspace.id,
       location,
       name,
       access: 'workspace',
     })
-    return Aggregate.Of(Resource, event).then(Aggregate.View())
+    return commitResource(event)
   }
 
-  if (isResourceTemplateType) {
-    const template = allTemplates.find(t => t.id === type)
-    const normalized = normalizeAndValidateDocumentContent(content, template)
-    if (!normalized.ok) {
-      throw Object.assign(new Error(normalized.message), { status: 400, type: normalized.code })
+  if (isDocumentSchema) {
+    const schema = engine.resolve(type)
+    const result = engine.validate(schema, content)
+    if (!result.ok) {
+      const first = result.errors[0]
+      throw Object.assign(new Error(first.message), { status: 400, type: first.code })
     }
     const event = ResourcesEvents.Created({
-      type,
+      schemaId: type,
       createdBy,
       belongsTo: workspace.id,
       location,
       name,
-      content: normalized.content,
+      content: result.data,
+      access: payload?.access ?? 'workspace',
     })
-    return Aggregate.Of(Resource, event).then(Aggregate.View())
+    return commitResource(event)
   }
 
   if (!fileExtension) {
     throw Object.assign(new Error('Missing valid file extension'), { status: 400 })
   }
 
-  const aggregateId = nanoid()
+  const resourceId = nanoid()
   const event = ResourcesEvents.Created({
-    aggregateId,
-    type,
+    resourceId,
+    schemaId: '@ossy/platform/schema/file',
     createdBy,
     belongsTo: workspace.id,
     location,
     name,
+    access: payload?.access ?? 'workspace',
     content: {
-      Key: `media/${workspace.id}/${aggregateId}/original.${fileExtension}`,
+      Key: originalObjectKey(resourceId),
       ContentLength: size,
       ContentType: type,
     },
@@ -92,7 +90,7 @@ export async function run({ payload, integrations, req }) {
     Key: event.payload.content.Key,
   }
   const uploadUrl = storageClient ? await storageClient.createUploadUrl(uploadHeaders) : null
-  const resource = await Aggregate.Of(Resource, event).then(Aggregate.View())
+  const resource = await commitResource(event)
   const withUpload = uploadUrl
     ? { ...resource, content: { ...resource.content, uploadUrl } }
     : resource

package/src/delete.action.js

@@ -1 +1 @@
-export const metadata = { id: 'resources/delete', access: 'workspace' }
+export const metadata = { id: '@ossy/resources/actions/delete', access: 'workspace' }

package/src/delete.task.js

@@ -1,31 +1,27 @@
-import { Aggregate } from '@ossy/event-store'
-import { Resource } from './resource.aggregate.js'
 import { ResourcesEvents } from './resources.events.js'
 import { ResourcesQueries } from './resources.queries.js'
+import { mutateResource, viewResource } from './resource-stream.helpers.js'
+import { resolveResourceId } from './resource-read.helpers.js'
 
-export const metadata = { id: 'resources/delete' }
+export const metadata = { id: '@ossy/resources/tasks/delete' }
 
-const DIRECTORY_TYPE = 'directory'
-
-export async function run({ payload, req }) {
+export async function run ({ payload, req }) {
   const createdBy = payload?.userId ?? req?.userId
-  const resourceId = payload?.resourceId ?? req?.params?.resourceId
+  const resourceId = resolveResourceId({ payload, req })
 
   if (!resourceId) throw Object.assign(new Error('resourceId is required'), { status: 400 })
 
-  const aggregate = await Aggregate.Of(Resource, resourceId)
-  const resource = Aggregate.View()(aggregate)
+  const resource = await viewResource(resourceId)
 
-  if (resource.type === DIRECTORY_TYPE) {
+  if (resource.type === '@ossy/platform/schema/directory' || resource.type === 'directory') {
     const nestedResources = await ResourcesQueries.GetNestedResources({
       location: resource.location + resource.name + '/',
     })
     await Promise.all(nestedResources.map(nested =>
-      Aggregate.Of(Resource, nested.id)
-        .then(Aggregate.Add(ResourcesEvents.Deleted({ createdBy })))
+      mutateResource(nested.id, ResourcesEvents.Deleted({ createdBy })),
     ))
   }
 
-  await Aggregate.Add(ResourcesEvents.Deleted({ createdBy }))(aggregate)
+  await mutateResource(resourceId, ResourcesEvents.Deleted({ createdBy }))
   return null
 }