@crombolo/server 0.0.0-stage → 0.9.1

package/src/adapters/template-files.ts

@@ -0,0 +1,58 @@
+/**
+ * Template views on disk.
+ *
+ * Umbraco keeps templates at ~/components/{alias}.cshtml and treats the file as the
+ * source of truth for its content; we do the same with .tsx.
+ */
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import type { ComponentFileStore } from '@crombolo/data'
+
+/** Aliases become filenames, so they must not be able to escape the directory. */
+function safeAlias(alias: string): string | undefined {
+  return /^[A-Za-z0-9_-]+$/.test(alias) ? alias : undefined
+}
+
+/**
+ * `onChange` fires after a template is written or removed, with the alias.
+ *
+ * A view is code: the node that wrote it has to take a new snapshot before it
+ * renders again, and the others have to be told to look. This is the only place
+ * that knows a view changed.
+ */
+export function createTemplateFileStore(
+  dir: string,
+  onChange?: (alias: string) => void | Promise<void>,
+): ComponentFileStore {
+  const fileFor = (alias: string): string | undefined => {
+    const safe = safeAlias(alias)
+    return safe ? join(dir, `${safe}.tsx`) : undefined
+  }
+
+  return {
+    async read(alias) {
+      const file = fileFor(alias)
+      if (!file) return undefined
+      try {
+        return await readFile(file, 'utf8')
+      } catch {
+        return undefined
+      }
+    },
+    async write(alias, content) {
+      const file = fileFor(alias)
+      if (!file) throw new Error(`Unsafe template alias '${alias}'.`)
+      await mkdir(dir, { recursive: true })
+      await writeFile(file, content, 'utf8')
+      // Awaited, so a saved template is already the one this node renders by the
+      // time the editor's request comes back.
+      await onChange?.(alias)
+    },
+    async remove(alias) {
+      const file = fileFor(alias)
+      if (!file) return
+      await rm(file, { force: true })
+      await onChange?.(alias)
+    },
+  }
+}

package/src/adapters/template-query.ts

@@ -0,0 +1,127 @@
+/**
+ * Runs what the template query builder describes.
+ *
+ * Against the published cache and through `Navigation`, because that is what a
+ * component renders from: the count and the sample the builder shows are then
+ * the answer the snippet it wrote would give, not a second implementation that
+ * can drift from it.
+ */
+import type {
+  TemplateQueryFilter,
+  TemplateQueryPort,
+  TemplateQueryRequest,
+  TemplateQuerySort,
+} from '@crombolo/api-management'
+import type { ContentTypeRepository } from '@crombolo/data'
+import type { PublishedCache, PublishedContent } from '@crombolo/render'
+
+/** The accessor each queryable property names, and how it compares. */
+const FIELDS: Record<
+  string,
+  { of: (content: PublishedContent) => string | number; text: boolean }
+> = {
+  Id: { of: (content) => content.id, text: false },
+  Name: { of: (content) => content.name, text: true },
+  CreateDate: { of: (content) => content.createDate.getTime(), text: false },
+  UpdateDate: { of: (content) => content.updateDate.getTime(), text: false },
+}
+
+function matches(content: PublishedContent, filter: TemplateQueryFilter): boolean {
+  const field = FIELDS[filter.propertyAlias]
+  if (!field) return true
+  const left = field.of(content)
+
+  if (field.text) {
+    const right = filter.constraintValue
+    const text = String(left)
+    switch (filter.operator) {
+      case 'Equals':
+        return text === right
+      case 'NotEquals':
+        return text !== right
+      case 'Contains':
+        return text.includes(right)
+      case 'NotContains':
+        return !text.includes(right)
+      default:
+        return true
+    }
+  }
+
+  const right = filter.propertyAlias.endsWith('Date')
+    ? new Date(filter.constraintValue).getTime()
+    : Number(filter.constraintValue)
+  // An unparseable constraint filters nothing out rather than everything: the
+  // builder sends what has been typed so far, half-finished dates included.
+  if (Number.isNaN(right)) return true
+  const value = Number(left)
+  switch (filter.operator) {
+    case 'Equals':
+      return value === right
+    case 'NotEquals':
+      return value !== right
+    case 'LessThan':
+      return value < right
+    case 'LessThanEqualTo':
+      return value <= right
+    case 'GreaterThan':
+      return value > right
+    case 'GreaterThanEqualTo':
+      return value >= right
+    default:
+      return true
+  }
+}
+
+function compare(sort: TemplateQuerySort): (a: PublishedContent, b: PublishedContent) => number {
+  const field = FIELDS[sort.propertyAlias]
+  if (!field) return () => 0
+  const descending = sort.direction?.toLowerCase() === 'descending'
+  return (a, b) => {
+    const [first, second] = descending ? [b, a] : [a, b]
+    const left = field.of(first)
+    const right = field.of(second)
+    if (field.text) return String(left).localeCompare(String(right))
+    return Number(left) - Number(right)
+  }
+}
+
+export function createTemplateQueryPort(options: {
+  cache: PublishedCache
+  types: ContentTypeRepository
+}): TemplateQueryPort {
+  return {
+    async documentTypeAliases() {
+      const all = await options.types.all()
+      return (
+        all
+          // An element type is never routed to, so a query cannot return one.
+          .filter((type) => !type.isElement)
+          .map((type) => type.alias)
+          .sort((a, b) => a.localeCompare(b))
+      )
+    },
+
+    async execute(request: TemplateQueryRequest) {
+      const nav = await options.cache.navigation()
+      const root = request.rootKey ? nav.byKey(request.rootKey) : undefined
+      // No root picked means "below the page this renders on", which has no one
+      // answer here — the site's own roots are the closest honest stand-in.
+      const from = root ? nav.children(root) : nav.root().flatMap((node) => nav.children(node))
+
+      let found = from
+      if (request.documentTypeAlias)
+        found = found.filter((item) => item.contentType.alias === request.documentTypeAlias)
+      for (const filter of request.filters) found = found.filter((item) => matches(item, filter))
+      if (request.sort) found = [...found].sort(compare(request.sort))
+
+      return {
+        total: found.length,
+        items: found.slice(0, request.take).map((item) => ({
+          icon: 'icon-document',
+          name: item.name,
+        })),
+      }
+    },
+  }
+}