@ossy/resources 1.12.2 → 3.0.1

package/src/upload-named-version.task.js

@@ -1,17 +1,14 @@
-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 { mutateResource } from './resource-stream.helpers.js'
+import { resolveResourceId } from './resource-read.helpers.js'
+import { derivativeObjectKey } from '@ossy/platform/storage-keys'
 import { mediaContextFromRun, withResourceMedia } from './resources.action-media.js'
 
-export const metadata = { id: 'resources/upload-named-version' }
+export const metadata = { id: '@ossy/resources/tasks/upload-named-version' }
 
-// TODO: remove named version concept
-
-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
-  const resourceId = payload?.resourceId ?? req?.params?.resourceId
+  const resourceId = resolveResourceId({ payload, req })
   const namedVersion = payload?.namedVersion ?? req?.params?.namedVersion
   const type = payload?.type
   const size = payload?.size
@@ -19,26 +16,23 @@ export async function run({ payload, integrations, req }) {
   if (!resourceId) throw Object.assign(new Error('resourceId is required'), { status: 400 })
   if (!namedVersion) throw Object.assign(new Error('namedVersion is required'), { status: 400 })
 
-  const workspace = await Aggregate.Of(Workspace, workspaceId).then(Aggregate.View())
-
-  const event = ResourcesEvents.NamedVersionUploaded({
+  const event = ResourcesEvents.Patched({
     createdBy,
-    namedVersion,
-    Key: `media/${workspace.id}/${resourceId}/${namedVersion}.${type.replace('image/', '')}`,
-    ContentLength: size,
-    ContentType: type,
+    content: {
+      sizes: { [namedVersion]: derivativeObjectKey(resourceId, namedVersion) },
+      ContentLength: size,
+      ContentType: type,
+    },
   })
 
   const storageClient = integrations?.get?.('storage')
   const uploadHeaders = {
-    ContentLength: event.payload.ContentLength,
-    ContentType: event.payload.ContentType,
-    Key: event.payload.Key,
+    ContentLength: size,
+    ContentType: type,
+    Key: derivativeObjectKey(resourceId, namedVersion),
   }
   const uploadUrl = storageClient ? await storageClient.createUploadUrl(uploadHeaders) : null
-  const resource = await Aggregate.Of(Resource, resourceId)
-    .then(Aggregate.Add(event))
-    .then(Aggregate.View())
+  const resource = await mutateResource(resourceId, event)
   const withUpload = uploadUrl
     ? { ...resource, content: { ...resource.content, uploadUrl } }
     : resource

package/src/useActivePath.jsx

@@ -4,20 +4,15 @@ import {
   o,
   endsWith
 } from 'ramda'
-import { useRouter } from '@ossy/router-react'
-import React, { useEffect } from 'react'
+import { useSearchParams } from '@ossy/router-react'
 
 const prependSlash = unless(startsWith('/'), path => `/${path}`)
 const appendSlash = unless(endsWith('/'), path => `${path}/`)
 const addSlashes = o(prependSlash, appendSlash)
 
 export const useActivePath = () => {
-    const router = useRouter()
-    const activePath = addSlashes(router.searchParams.location || '/')
-
-  // useEffect(() => {
-  //   console.log('useActivePath', activePath)
-  // }, [activePath])
+    const searchParams = useSearchParams()
+    const activePath = addSlashes(searchParams.location || '/')
 
     return activePath
   }

package/src/useDocumentValidator.js

@@ -0,0 +1,16 @@
+import { useMemo } from 'react'
+import { contentValidator } from '@ossy/schema'
+import { useSchemaEngine } from './useSchemaEngine.js'
+
+/**
+ * Returns a Form-compatible validator for a document schema (merged system + workspace).
+ *
+ * @param {string | object | undefined} schema
+ */
+export function useDocumentValidator (schema) {
+  const engine = useSchemaEngine()
+  return useMemo(() => {
+    if (!schema) return undefined
+    return contentValidator(engine, schema)
+  }, [engine, schema])
+}

package/src/useSchemaEngine.js

@@ -0,0 +1,9 @@
+import { useMemo } from 'react'
+import { Schema } from '@ossy/schema'
+import { useSchemas } from './useSchemas.js'
+
+/** Merged system + workspace schema engine for client-side validation. */
+export function useSchemaEngine () {
+  const schemas = useSchemas()
+  return useMemo(() => Schema.of({ schemas }), [schemas])
+}

package/src/useSchemas.js

@@ -0,0 +1,29 @@
+import { useMemo } from 'react'
+import { GetSchemas } from '@ossy/workspaces'
+import { useSdk } from '@ossy/sdk-react'
+
+/** Merged system + workspace schemas (see workspaces/actions/get-schemas). */
+export function useSchemas () {
+  const sdk = useSdk()
+  const { data: schemas = [] } = sdk.read(GetSchemas)
+  return schemas
+}
+
+export function useSchemasById () {
+  const schemas = useSchemas()
+  return useMemo(
+    () => schemas.reduce((acc, schema) => {
+      acc[schema.id] = schema
+      return acc
+    }, {}),
+    [schemas],
+  )
+}
+
+export function useSchema (schemaId) {
+  const schemas = useSchemas()
+  return useMemo(
+    () => schemas.find(s => s.id === schemaId),
+    [schemas, schemaId],
+  )
+}

package/src/useSelectedResourceId.jsx

@@ -0,0 +1,36 @@
+import { useCallback, useMemo } from 'react'
+import { useSearchParams } from '@ossy/router-react'
+
+export const RESOURCE_QUERY_PARAM = 'r'
+export const RESOURCE_QUERY_PARAM_ALT = 'resourceId'
+
+export const useSelectedResourceId = () => {
+  const searchParams = useSearchParams()
+
+  const selectedResourceId =
+    searchParams[RESOURCE_QUERY_PARAM] ||
+    searchParams[RESOURCE_QUERY_PARAM_ALT] ||
+    undefined
+
+  const setSelectedResourceId = useCallback((resourceId) => {
+    if (resourceId) {
+      searchParams.set(RESOURCE_QUERY_PARAM, resourceId)
+      searchParams.delete(RESOURCE_QUERY_PARAM_ALT)
+      return
+    }
+
+    searchParams.delete(RESOURCE_QUERY_PARAM)
+    searchParams.delete(RESOURCE_QUERY_PARAM_ALT)
+  }, [searchParams.set, searchParams.delete])
+
+  const clearSelectedResourceId = useCallback(
+    () => setSelectedResourceId(undefined),
+    [setSelectedResourceId],
+  )
+
+  return useMemo(() => ({
+    selectedResourceId,
+    setSelectedResourceId,
+    clearSelectedResourceId,
+  }), [selectedResourceId, setSelectedResourceId, clearSelectedResourceId])
+}

package/src/ResourceContentPage.stories.jsx

@@ -1,19 +0,0 @@
-import React from 'react'
-import { ResourceContentPage } from './ResourceContentPage.jsx'
-
-export default {
-  title: 'Websites/Ossy/ResourceContentPage',
-  component: ResourceContentPage,
-  parameters: {
-   layout: 'fullscreen',
-   workspaceId: '36zDqF0TKZZ5KkJdyg7NH',
-   params: {
-    resourceId: 'yBa6GdMeHg2EQr-u5xDd3'
- }
- },
-}
-
-const Story = props => <ResourceContentPage {...props}/>
-
-export const Default = Story.bind({})
-Default.args = { }

package/src/resource.aggregate.js

@@ -1,86 +0,0 @@
-export class Resource {
-
-  static AggregateType = 'Resource'
-
-  static View(events, savedState = {}) {
-    return events.reduce((resource, event) => {
-      switch (event.type) {
-
-        case 'Created': {
-          const content = event?.payload?.content || {}
-
-          return {
-            ...resource,
-            id: event.aggregateId,
-            name: event.payload.name,
-            location: event.payload.location,
-            belongsTo: event.payload.belongsTo,
-            type: event.payload.type,
-            createdBy: event.createdBy,
-            created: event.created,
-            lastUpdated: event.created,
-            content: content,
-            access: event.payload.access || 'restricted',
-          }
-        }
-
-        case 'NameUpdated':
-          return {
-            ...resource,
-            lastUpdated: event.created,
-            name: event.payload.name
-          }
-
-        case 'LocationUpdated':
-          return {
-            ...resource,
-            lastUpdated: event.created,
-            location: event.payload.location
-          }
-
-        case 'ContentUpdated':
-          return {
-            ...resource,
-            lastUpdated: event.created,
-            content: event.payload.content
-          }
-
-        case 'AccessUpdated':
-          return {
-            ...resource,
-            lastUpdated: event.created,
-            access: event.payload.access
-          }
-
-        case 'NamedVersionUploaded': {
-          const mediaKey = event.payload.Key
-
-          return {
-            ...resource,
-            lastUpdated: event.created,
-            content: {
-              ...resource.content,
-              sizes: {
-                ...(resource.content.sizes || {}),
-                [event.payload.namedVersion]: mediaKey
-              }
-            },
-          }
-        }
-
-        case 'Deleted':
-          return {
-            status: ['removed'],
-          }
-
-        default:
-          return resource
-
-      }
-    }, savedState)
-
-  }
-}
-
-export { Resource as Aggregate }
-export const id = 'Resource'