@ossy/platform 1.25.1 → 1.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/platform",
-  "version": "1.25.1",
+  "version": "1.26.0",
   "description": "Ossy application server runtime",
   "repository": {
     "type": "git",
@@ -14,7 +14,8 @@
     "./proxy-internal": "./src/proxy-internal.js",
     "./runtime": "./src/runtime.js",
     "./site-loader": "./src/site-loader.js",
-    "./tasks": "./src/index.js"
+    "./tasks": "./src/index.js",
+    "./resources": "./src/resources/index.js"
   },
   "scripts": {
     "start": "PORT=3003 node -e \"import('./src/server.js').then(m => m.startServer())\""
@@ -23,8 +24,8 @@
   "author": "Ossy <yourfriends@ossy.se> (https://ossy.se)",
   "license": "MIT",
   "dependencies": {
-    "@ossy/router": "^1.26.1",
-    "@ossy/sdk": "^1.26.1",
+    "@ossy/router": "^1.27.0",
+    "@ossy/sdk": "^1.27.0",
     "cookie-parser": "^1.4.7",
     "dotenv": ">=16.0.0 <18.0.0",
     "express": ">=5.0.0 <6.0.0",
@@ -35,5 +36,5 @@
     "src",
     "Dockerfile"
   ],
-  "gitHead": "efb5f69afd7a5bbef66887334a2118449ae2c6b4"
+  "gitHead": "ed72d972761405ecc4e12804aefa77f763aa4646"
 }

package/src/index.js

@@ -1,3 +1,5 @@
 export { TaskService } from './tasks/task-service.js'
 export { loadAndRegisterTasks } from './tasks/task-registry.js'
 export { ChangeStream } from './tasks/change-stream.js'
+export { registerResourceTemplate, getSystemResourceTemplates } from './resources/resource-template.registry.js'
+export { normalizeAndValidateDocumentContent, validateResourceTemplatesForImport, ALLOWED_FIELD_TYPES } from './resources/resource-template.validation.js'

package/src/resources/index.js

@@ -0,0 +1,2 @@
+export { registerResourceTemplate, getSystemResourceTemplates } from './resource-template.registry.js'
+export { normalizeAndValidateDocumentContent, validateResourceTemplatesForImport, ALLOWED_FIELD_TYPES } from './resource-template.validation.js'

package/src/resources/resource-template.registry.js

@@ -0,0 +1,25 @@
+/** @type {object[]} */
+const systemTemplates = []
+
+/**
+ * Register a single resource template POJO (as inlined in `build/manifest.json`).
+ * Silently skips duplicates (same `id`) and invalid entries.
+ *
+ * @param {object} template
+ */
+export function registerResourceTemplate(template) {
+  if (!template || typeof template !== 'object' || Array.isArray(template)) return
+  if (typeof template.id !== 'string' || template.id.trim() === '') return
+  if (systemTemplates.find(t => t.id === template.id)) return
+  systemTemplates.push(template)
+  console.log(`[INFO][ResourceTemplateRegistry] Registered system template: ${template.id}`)
+}
+
+/**
+ * Returns all registered system resource templates.
+ *
+ * @returns {object[]}
+ */
+export function getSystemResourceTemplates() {
+  return systemTemplates
+}

package/src/resources/resource-template.validation.js

@@ -0,0 +1,232 @@
+/** Field input types accepted in resource template definitions (UI + API contract). */
+export const ALLOWED_FIELD_TYPES = new Set([
+  'text',
+  'textarea',
+  'richtext',
+  'number',
+  'select',
+  'multiselect',
+  'image',
+  'boolean',
+  'date',
+])
+
+function isNonEmptyString(value) {
+  return typeof value === 'string' && value.trim().length > 0
+}
+
+function isEmptyValue(value) {
+  if (value === undefined || value === null) return true
+  if (typeof value === 'string' && value.trim() === '') return true
+  return false
+}
+
+/**
+ * @param {unknown} template
+ * @param {{ reservedIds: Set<string> }} ctx
+ * @returns {{ ok: true } | { ok: false, code: string, message: string }}
+ */
+function validateOneTemplateShape(template, ctx) {
+  if (template === null || typeof template !== 'object' || Array.isArray(template)) {
+    return { ok: false, code: 'INVALID_TEMPLATE', message: 'Each template must be a non-array object' }
+  }
+
+  if (!isNonEmptyString(template.id)) {
+    return { ok: false, code: 'INVALID_TEMPLATE', message: 'Each template must have a non-empty string id' }
+  }
+
+  if (!isNonEmptyString(template.name)) {
+    return { ok: false, code: 'INVALID_TEMPLATE', message: `Template "${template.id}" must have a non-empty string name` }
+  }
+
+  if (ctx.reservedIds.has(template.id)) {
+    return {
+      ok: false,
+      code: 'RESERVED_TEMPLATE_ID',
+      message: `Template id "${template.id}" is reserved by a system template`,
+    }
+  }
+
+  if (!Array.isArray(template.fields)) {
+    return {
+      ok: false,
+      code: 'INVALID_TEMPLATE',
+      message: `Template "${template.id}" must have a fields array`,
+    }
+  }
+
+  const fieldNames = new Set()
+  for (let i = 0; i < template.fields.length; i++) {
+    const field = template.fields[i]
+    if (field === null || typeof field !== 'object' || Array.isArray(field)) {
+      return {
+        ok: false,
+        code: 'INVALID_FIELD',
+        message: `Template "${template.id}" fields[${i}] must be an object`,
+      }
+    }
+    if (!isNonEmptyString(field.name)) {
+      return {
+        ok: false,
+        code: 'INVALID_FIELD',
+        message: `Template "${template.id}" fields[${i}] must have a non-empty string name`,
+      }
+    }
+    if (fieldNames.has(field.name)) {
+      return {
+        ok: false,
+        code: 'DUPLICATE_FIELD_NAME',
+        message: `Template "${template.id}" has duplicate field name "${field.name}"`,
+      }
+    }
+    fieldNames.add(field.name)
+
+    if (typeof field.type !== 'string' || !isNonEmptyString(field.type)) {
+      return {
+        ok: false,
+        code: 'INVALID_FIELD_TYPE',
+        message: `Template "${template.id}" field "${field.name}" must have a non-empty string type`,
+      }
+    }
+
+    const fieldType = field.type.trim()
+    if (!ALLOWED_FIELD_TYPES.has(fieldType)) {
+      return {
+        ok: false,
+        code: 'INVALID_FIELD_TYPE',
+        message: `Template "${template.id}" field "${field.name}" has unsupported type "${fieldType}"`,
+      }
+    }
+
+    if (fieldType === 'select' || fieldType === 'multiselect') {
+      if (!Array.isArray(field.options) || field.options.length === 0) {
+        return {
+          ok: false,
+          code: 'INVALID_FIELD_OPTIONS',
+          message: `Template "${template.id}" field "${field.name}" of type ${fieldType} requires a non-empty options array`,
+        }
+      }
+      const badOption = field.options.find(o => typeof o !== 'string' || o.trim() === '')
+      if (badOption !== undefined) {
+        return {
+          ok: false,
+          code: 'INVALID_FIELD_OPTIONS',
+          message: `Template "${template.id}" field "${field.name}" options must be non-empty strings`,
+        }
+      }
+    }
+  }
+
+  return { ok: true }
+}
+
+/**
+ * Validates a batch import of workspace resource templates.
+ *
+ * @param {unknown} templates
+ * @param {Set<string>} reservedIds - System template ids that must not be redefined
+ * @returns {{ ok: true } | { ok: false, code: string, message: string }}
+ */
+export function validateResourceTemplatesForImport(templates, reservedIds) {
+  if (!Array.isArray(templates)) {
+    return { ok: false, code: 'INVALID_PAYLOAD', message: 'Body must be a JSON array of resource templates' }
+  }
+
+  const seenIds = new Set()
+  for (let i = 0; i < templates.length; i++) {
+    const template = templates[i]
+    const shape = validateOneTemplateShape(template, { reservedIds })
+    if (!shape.ok) return shape
+
+    if (seenIds.has(template.id)) {
+      return {
+        ok: false,
+        code: 'DUPLICATE_TEMPLATE_ID',
+        message: `Duplicate template id "${template.id}" in import payload`,
+      }
+    }
+    seenIds.add(template.id)
+  }
+
+  return { ok: true }
+}
+
+/**
+ * Strips content to template field names and validates required fields and basic value shapes.
+ *
+ * @param {unknown} rawContent
+ * @param {{ fields?: { name: string, type?: string, required?: boolean, options?: string[] }[] }} template
+ * @returns {{ ok: true, content: Record<string, unknown> } | { ok: false, code: string, message: string }}
+ */
+export function normalizeAndValidateDocumentContent(rawContent, template) {
+  const fields = template?.fields || []
+
+  let base
+  if (rawContent === undefined || rawContent === null) {
+    base = {}
+  } else if (typeof rawContent !== 'object' || Array.isArray(rawContent)) {
+    return { ok: false, code: 'INVALID_CONTENT', message: 'Content must be a plain object' }
+  } else {
+    base = rawContent
+  }
+
+  const allowedNames = new Set(fields.map(f => f.name))
+  const content = {}
+  for (const name of allowedNames) {
+    if (Object.prototype.hasOwnProperty.call(base, name)) {
+      content[name] = base[name]
+    }
+  }
+
+  for (const field of fields) {
+    const v = content[field.name]
+    const t = typeof field.type === 'string' ? field.type.trim() : field.type
+
+    if (field.required && isEmptyValue(v)) {
+      return {
+        ok: false,
+        code: 'REQUIRED_FIELD_MISSING',
+        message: `Field "${field.name}" is required`,
+      }
+    }
+
+    if (v === undefined) continue
+
+    if (t === 'number' && v !== null && (typeof v !== 'number' || Number.isNaN(v))) {
+      return {
+        ok: false,
+        code: 'INVALID_FIELD_VALUE',
+        message: `Field "${field.name}" must be a number`,
+      }
+    }
+
+    if (t === 'select' && v !== null && v !== undefined && !field.options?.includes(v)) {
+      return {
+        ok: false,
+        code: 'INVALID_FIELD_VALUE',
+        message: `Field "${field.name}" must be one of the defined options`,
+      }
+    }
+
+    if (t === 'multiselect' && v !== null && v !== undefined) {
+      if (!Array.isArray(v)) {
+        return {
+          ok: false,
+          code: 'INVALID_FIELD_VALUE',
+          message: `Field "${field.name}" must be an array of option values`,
+        }
+      }
+      const opts = field.options || []
+      const invalid = v.some(item => typeof item !== 'string' || !opts.includes(item))
+      if (invalid) {
+        return {
+          ok: false,
+          code: 'INVALID_FIELD_VALUE',
+          message: `Field "${field.name}" must only contain values from options`,
+        }
+      }
+    }
+  }
+
+  return { ok: true, content }
+}