@ossy/platform 1.39.2 → 3.0.1

package/src/resources/schema.registry.js

@@ -0,0 +1,26 @@
+import { createLogger } from '@ossy/observability'
+
+const log = createLogger('platform')
+
+/** @type {object[]} */
+const systemSchemas = []
+
+/**
+ * Register a single schema POJO (as inlined in `build/manifest.json`).
+ *
+ * @param {object} schema
+ */
+export function registerSchema (schema) {
+  if (!schema || typeof schema !== 'object' || Array.isArray(schema)) return
+  if (typeof schema.id !== 'string' || schema.id.trim() === '') return
+  if (systemSchemas.find(s => s.id === schema.id)) return
+  systemSchemas.push(schema)
+  log.info(`[SchemaRegistry] Registered system schema: ${schema.id}`)
+}
+
+/**
+ * @returns {object[]}
+ */
+export function getSystemSchemas () {
+  return systemSchemas
+}

package/src/resources/schema.service.js

@@ -0,0 +1,54 @@
+import { Schema } from '@ossy/schema'
+
+/** @type {Schema | null} */
+let platformSchema = null
+
+/**
+ * Platform-wide schema engine from build manifest (no workspace overlays).
+ *
+ * @param {{ schemas?: object[], actions?: { id: string }[], tasks?: { id: string }[] }} manifest
+ */
+export function initPlatformSchema (manifest) {
+  platformSchema = Schema.of(manifest, {
+    actionIds: (manifest.actions ?? []).map((a) => a.id),
+    taskIds: (manifest.tasks ?? []).map((t) => t.id),
+    strictRefs: false,
+  })
+  return platformSchema
+}
+
+/**
+ * @returns {Schema}
+ */
+export function getPlatformSchema () {
+  if (!platformSchema) {
+    throw new Error('[@ossy/platform] Platform Schema not initialized — call initPlatformSchema after loadManifest')
+  }
+  return platformSchema
+}
+
+/**
+ * Build-time or per-request engine with optional strict ref checks.
+ *
+ * @param {{ schemas?: object[], actions?: { id: string }[], tasks?: { id: string }[] }} manifest
+ * @param {{ strictRefs?: boolean, actionIds?: string[], taskIds?: string[] }} [options]
+ */
+export function createSchemaEngine (manifest, options = {}) {
+  return Schema.of(manifest, {
+    actionIds: options.actionIds ?? (manifest.actions ?? []).map((a) => a.id),
+    taskIds: options.taskIds ?? (manifest.tasks ?? []).map((t) => t.id),
+    strictRefs: options.strictRefs ?? false,
+  })
+}
+
+/**
+ * Platform schema engine with optional workspace schema overlays.
+ *
+ * @param {object[]} [workspaceSchemas]
+ */
+export function schemaForWorkspace (workspaceSchemas = []) {
+  const platform = getPlatformSchema()
+  const extra = (workspaceSchemas ?? []).filter((s) => s?.id && !platform.has(s.id))
+  if (!extra.length) return platform
+  return platform.withWorkspaceSchemas(extra)
+}

package/src/resources/schema.validation.js

@@ -0,0 +1,90 @@
+import { Schema } from '@ossy/schema'
+
+/** Field input types accepted in schema definitions (UI + API contract). */
+export const ALLOWED_FIELD_TYPES = new Set([
+  'text',
+  'email',
+  'textarea',
+  'richtext',
+  'number',
+  'select',
+  'multiselect',
+  'file',
+  'image',
+  'boolean',
+  'date',
+  'timestamp',
+  'date-range',
+  'date-ranges',
+  'id',
+  'path',
+])
+
+/**
+ * Normalize template field `type` to the canonical editor type.
+ * `image` is an alias for `file` with default `accept: 'image/*'` when accept is omitted.
+ *
+ * @param {string | undefined} type
+ * @returns {{ type: string, defaultAccept?: string }}
+ */
+export function normalizeFieldType (type) {
+  const raw = typeof type === 'string' ? type.trim() : ''
+  if (raw === 'image') return { type: 'file', defaultAccept: 'image/*' }
+  return { type: raw }
+}
+
+/**
+ * @param {{ type?: string, accept?: string, min?: number, max?: number } & Record<string, unknown>} field
+ */
+export function resolveFieldDef (field) {
+  const { type: canonical, defaultAccept } = normalizeFieldType(field?.type)
+  return {
+    ...field,
+    type: canonical,
+    accept: field?.accept ?? defaultAccept,
+    max: field?.max ?? 1,
+  }
+}
+
+/**
+ * Validates a batch import of workspace schemas.
+ *
+ * @param {unknown} templates
+ * @param {Set<string>} reservedIds - System schema ids that must not be redefined
+ * @returns {{ ok: true } | { ok: false, code: string, message: string }}
+ */
+export function validateSchemasForImport (templates, reservedIds) {
+  if (!Array.isArray(templates)) {
+    return { ok: false, code: 'INVALID_PAYLOAD', message: 'Body must be a JSON array of schemas' }
+  }
+
+  const engine = Schema.of({ schemas: templates })
+  const seenIds = new Set()
+
+  for (const template of templates) {
+    if (reservedIds?.has(template?.id)) {
+      return {
+        ok: false,
+        code: 'RESERVED_SCHEMA_ID',
+        message: `Template id "${template.id}" is reserved by a system template`,
+      }
+    }
+
+    const result = engine.validate(template)
+    if (!result.ok) {
+      const first = result.errors[0]
+      return { ok: false, code: first.code, message: first.message }
+    }
+
+    if (seenIds.has(template.id)) {
+      return {
+        ok: false,
+        code: 'DUPLICATE_SCHEMA_ID',
+        message: `Duplicate schema id "${template.id}" in import payload`,
+      }
+    }
+    seenIds.add(template.id)
+  }
+
+  return { ok: true }
+}

package/src/runtime.js

@@ -4,7 +4,7 @@ import express from 'express'
 import cookieParser from 'cookie-parser'
 import morgan from 'morgan'
 import { Router as OssyRouter } from '@ossy/router'
-import { loadManifest, resolveEntryUrl } from './server.js'
+import { loadManifest, resolveEntryUrl, loadLayoutsById, resolvePageLayoutRender } from './server.js'
 import { resolveRequestLocale } from './locale.js'
 import { buildManifestSummary } from '@ossy/app/manifest/build-manifest-summary'
 import { ProxyInternal } from './proxy-internal.js'
@@ -31,7 +31,7 @@ function cloneSerializable (value) {
  */
 const siteContextCache = new Map()
 
-function buildSiteContext (manifest, buildDir) {
+function buildSiteContext (manifest, buildDir, layoutsById) {
   const config = manifest.config
   const supportedLanguages = Array.isArray(config.supportedLanguages) ? config.supportedLanguages : []
 
@@ -50,14 +50,15 @@ function buildSiteContext (manifest, buildDir) {
     return promise
   }
 
-  return { pageRouter, apiRouter, manifest, manifestSummary: buildManifestSummary(manifest), loadEntry, buildDir }
+  return { pageRouter, apiRouter, manifest, manifestSummary: buildManifestSummary(manifest), loadEntry, buildDir, layoutsById }
 }
 
 async function getSiteContext (domain) {
   if (siteContextCache.has(domain)) return siteContextCache.get(domain)
   const buildDir = await loadSite(domain)
   const manifest = loadManifest(buildDir)
-  const context = buildSiteContext(manifest, buildDir)
+  const layoutsById = await loadLayoutsById(manifest.layouts, buildDir, log)
+  const context = buildSiteContext(manifest, buildDir, layoutsById)
   siteContextCache.set(domain, context)
   return context
 }
@@ -129,7 +130,7 @@ export async function startRuntime ({ port } = {}) {
       return
     }
 
-    const { pageRouter, apiRouter, manifest, manifestSummary, loadEntry, buildDir } = context
+    const { pageRouter, apiRouter, manifest, manifestSummary, loadEntry, buildDir, layoutsById } = context
 
     try {
       const apiRoute = apiRouter.getPageByUrl(requestUrl)
@@ -169,13 +170,21 @@ export async function startRuntime ({ port } = {}) {
 
       const config = manifest.config
       const { language, messages, fallbackMessages } = resolveRequestLocale(pageRouter, requestUrl, buildDir, config)
+      const {
+        Layout,
+        layoutEntry,
+        layoutSlots,
+      } = resolvePageLayoutRender(layoutsById, pageEntry)
       const props = {
         ...config,
         ...(req.userAppSettings || {}),
         theme: req.userAppSettings?.theme || cloneSerializable(config?.theme),
         themes: cloneSerializable(config?.themes),
-        resourceTemplates: cloneSerializable(manifest.resourceTemplates),
+        schemas: cloneSerializable(manifest.schemas),
         manifestSummary: cloneSerializable(manifestSummary),
+        actionRoutes: cloneSerializable(manifest.actionRoutes || {}),
+        taskCatalog: cloneSerializable(manifest.taskCatalog || []),
+        taskGraphEdges: cloneSerializable(manifest.taskGraphEdges || []),
         url: requestUrl,
         isAuthenticated: !!req.isAuthenticated,
         language,
@@ -187,6 +196,11 @@ export async function startRuntime ({ port } = {}) {
           ...(page.package ? { package: page.package } : {}),
         })),
         pageId: pageRoute.id,
+        componentEntries: manifest.components,
+        resolveComponentEntry: (entry) => resolveEntryUrl(entry, buildDir),
+        layoutSlots,
+        Layout,
+        layoutEntry,
       }
       const html = await mod.render(props)
       res.status(200).type('html').send(html)