@crombolo/schema 0.0.0-stage → 0.10.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kineco
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NOTICE

@@ -0,0 +1,69 @@
+crombolo
+Copyright (c) 2026 Kineco
+
+This product includes third-party software. crombolo is an independent project.
+It is not affiliated with, endorsed by, or sponsored by Umbraco A/S, which owns
+the Umbraco trademark.
+
+There are three places third-party material is redistributed, rather than merely
+depended on:
+
+  @crombolo/backoffice-dist   the built Umbraco backoffice and the browser
+                              packages bundled into it, produced by
+                              `bun run vendor:backoffice`
+  @crombolo/backoffice-dist   three CSS files copied unmodified from the Umbraco
+                              client source tree
+  @crombolo/contracts         the Umbraco Management API OpenAPI document,
+                              copied unmodified
+
+No Umbraco trademark is redistributed. The Umbraco wordmark, the "U" roundel
+favicon and the installer illustration are deliberately not carried in this
+repository: MIT grants copyright permission and says nothing about trademarks, so
+crombolo's own marks are served at those paths instead. See `BRANDED_ASSETS` in
+`@crombolo/backoffice-host`.
+
+The Umbraco backoffice
+----------------------
+@umbraco-cms/backoffice 18.2.0 — MIT — https://github.com/umbraco/Umbraco-CMS
+@umbraco-ui/uui 2.0.2 — MIT — https://github.com/umbraco/Umbraco.UI
+
+Static files from the Umbraco client source tree
+------------------------------------------------
+css/umb-css.css, css/rte-content.css, css/umbraco-blockgridlayout.css
+  — copied unmodified from Umbraco-CMS release-18.2.0 — MIT
+  — https://github.com/umbraco/Umbraco-CMS
+Shipped in @crombolo/backoffice-dist under `upstream-static/`.
+
+`rte-content.css` itself carries Tiptap's default editor styles, copied from
+tiptap v2.11.7 (MIT); the file records this in its own header.
+
+The Umbraco Management API contract
+-----------------------------------
+OpenApi.json — copied unmodified from Umbraco-CMS release-18.2.0
+  (src/Umbraco.Cms.Api.Management/OpenApi.json) — MIT
+  — https://github.com/umbraco/Umbraco-CMS
+Shipped in @crombolo/contracts, which also ships the TypeScript types generated
+from it.
+
+Browser runtime dependencies bundled into the backoffice build
+--------------------------------------------------------------
+@heximal/expressions 0.1.5 — BSD-3-Clause
+@microsoft/signalr 10.0.11 — MIT
+@tiptap/* 3.31.3 — MIT
+diff 9.0.0 — BSD-3-Clause
+dompurify 3.4.16 — Apache-2.0, elected from "MPL-2.0 OR Apache-2.0"
+element-internals-polyfill 3.0.2 — MIT
+lit 3.3.3 — BSD-3-Clause
+luxon 3.7.2 — MIT
+marked 18.0.14 — MIT
+monaco-editor 0.57.0 — MIT
+rxjs 7.8.2 — Apache-2.0
+uuid 14.0.2 — MIT
+
+dompurify is offered under either licence; Apache-2.0 is elected here, so no
+MPL-2.0 obligation attaches to the copy bundled into the backoffice build. Of the
+Apache-2.0 packages above, none ships a NOTICE file of its own, so Apache-2.0
+section 4(d) adds nothing to this file.
+
+Each package's own licence text ships inside its npm distribution and applies
+unchanged to the copies bundled here.

package/package.json

@@ -1,6 +1,34 @@
 {
   "name": "@crombolo/schema",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.10.0",
+  "description": "Schema-as-code for crombolo: TOML document, media and member type definitions.",
+  "license": "MIT",
+  "author": "Crombolo",
+  "homepage": "https://github.com/kineco-au/crombolo-cms#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kineco-au/crombolo-cms.git",
+    "directory": "packages/schema"
+  },
+  "bugs": {
+    "url": "https://github.com/kineco-au/crombolo-cms/issues"
+  },
+  "engines": {
+    "bun": ">=1.3.0"
+  },
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "files": [
+    "src",
+    "NOTICE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@crombolo/core": "0.10.0",
+    "@crombolo/data": "0.10.0"
+  }
+}

package/src/builtin.ts

@@ -0,0 +1,215 @@
+/**
+ * The data types that ship built in and need no file. A site file with the same
+ * alias overrides the built-in. Mirrors the seeded set in @crombolo/data.
+ */
+import {
+  ALL_SEEDED_DATA_TYPES,
+  BUILT_IN_MEDIA_TYPES,
+  type BuiltInContentType,
+  type BuiltInMediaType,
+  SYSTEM_CONTENT_TYPES,
+  SYSTEM_MEDIA_TYPES,
+} from '@crombolo/data'
+import type { SchemaContentType, SchemaDataType, SchemaProperty } from './model.ts'
+import { fileNameFor, writeMediaType } from './write.ts'
+
+/** Every seeded data type, in the file vocabulary; the seed is the one definition. */
+export const BUILTIN_DATA_TYPES: readonly SchemaDataType[] = ALL_SEEDED_DATA_TYPES.map(
+  (seeded) => ({
+    alias: seeded.alias,
+    name: seeded.name,
+    editor: seeded.editorAlias,
+    editorUi: seeded.editorUiAlias,
+    config: { ...(seeded.config ?? {}) },
+  }),
+)
+
+/** The `property_value` column family an editor stores into; Umbraco's ValueStorageType. */
+/** Folder, Image and File: always present, never deleted, alias fixed. */
+export const SYSTEM_MEDIA_TYPE_ALIASES: ReadonlySet<string> = new Set(
+  SYSTEM_MEDIA_TYPES.map((t) => t.alias),
+)
+
+/**
+ * A built-in media type in the file vocabulary: what `crombolo init` writes
+ * for the site-owned four, and what export compares a system type against.
+ * Folder allows only the built-ins in `present`.
+ */
+export function builtInMediaTypeSchema(
+  def: BuiltInMediaType,
+  present: ReadonlySet<string> = new Set(BUILT_IN_MEDIA_TYPES.map((t) => t.alias)),
+): SchemaContentType {
+  const type: SchemaContentType = {
+    key: def.key,
+    alias: def.alias,
+    name: def.name,
+    icon: def.icon,
+    allowAtRoot: true,
+    isElement: false,
+    allowInLibrary: false,
+    variesByCulture: false,
+    variesBySegment: false,
+    compositions: [],
+    allowChildren: def.allowChildren.filter((a) => present.has(a)),
+    components: [],
+    cleanup: { prevent: false },
+    properties: [],
+    tabs: [],
+  }
+  if (def.collection) type.collection = def.collection
+  if (def.group)
+    type.groups = [
+      {
+        name: def.group.name,
+        alias: def.group.alias,
+        properties: def.properties.map((p) => ({
+          key: p.key,
+          alias: p.alias,
+          name: p.name,
+          type: p.dataType,
+          mandatory: p.mandatory,
+          variesByCulture: false,
+          variesBySegment: false,
+          labelOnTop: false,
+        })),
+      },
+    ]
+  return type
+}
+
+/** Content types the framework ships: always present, never deleted, alias fixed. */
+export const SYSTEM_CONTENT_TYPE_ALIASES: ReadonlySet<string> = new Set(
+  SYSTEM_CONTENT_TYPES.map((t) => t.alias),
+)
+
+const dataTypeAliasOf = (key: string): string => {
+  const found = ALL_SEEDED_DATA_TYPES.find((d) => d.key === key)
+  if (!found) throw new Error(`system content types reference unknown data type "${key}"`)
+  return found.alias
+}
+
+/** A system content type in the file vocabulary: what export compares a site's copy against. */
+export function builtInContentTypeSchema(def: BuiltInContentType): SchemaContentType {
+  return {
+    key: def.key,
+    alias: def.alias,
+    name: def.name,
+    description: def.description,
+    icon: def.icon,
+    allowAtRoot: false,
+    isElement: false,
+    allowInLibrary: false,
+    variesByCulture: false,
+    variesBySegment: false,
+    compositions: [],
+    allowChildren: [],
+    components: [],
+    cleanup: { prevent: false },
+    properties: [],
+    tabs: [
+      {
+        name: def.tab.name,
+        alias: def.tab.alias,
+        groups: [],
+        properties: def.properties.map((p) => ({
+          key: p.key,
+          alias: p.alias,
+          name: p.name,
+          description: p.description,
+          type: dataTypeAliasOf(p.dataTypeKey),
+          mandatory: false,
+          variesByCulture: false,
+          variesBySegment: false,
+          labelOnTop: false,
+        })),
+      },
+    ],
+  }
+}
+
+/** Every property a type file declares, wherever it sits. */
+export function declaredProperties(t: SchemaContentType): SchemaProperty[] {
+  return [
+    ...t.properties,
+    ...(t.groups ?? []).flatMap((g) => g.properties),
+    ...t.tabs.flatMap((tab) => [...tab.properties, ...tab.groups.flatMap((g) => g.properties)]),
+  ]
+}
+
+/**
+ * What is wrong with a site's file for a system content type: it may add
+ * fields, relabel and move them, and vary them by culture, but every shipped
+ * field keeps its key, alias and data type.
+ */
+export function checkSystemContentTypeFile(t: SchemaContentType): string[] {
+  const def = SYSTEM_CONTENT_TYPES.find((d) => d.alias === t.alias)
+  if (!def) return []
+  const findings: string[] = []
+  if (t.key && t.key.toLowerCase() !== def.key)
+    findings.push(`"${t.alias}" is provided by Crombolo; its key must be ${def.key}`)
+  if (t.isElement)
+    findings.push(`"${t.alias}" is provided by Crombolo and cannot be an element type`)
+  const declared = declaredProperties(t)
+  for (const shipped of def.properties) {
+    const found = declared.find((p) => p.alias === shipped.alias)
+    const type = dataTypeAliasOf(shipped.dataTypeKey)
+    if (!found)
+      findings.push(`the "${shipped.alias}" field is provided by Crombolo and cannot be removed`)
+    else if (found.type !== type)
+      findings.push(
+        `the "${shipped.alias}" field is provided by Crombolo; its type must stay "${type}"`,
+      )
+    else if (found.key && found.key.toLowerCase() !== shipped.key)
+      findings.push(
+        `the "${shipped.alias}" field is provided by Crombolo; its key must be ${shipped.key}`,
+      )
+  }
+  return findings
+}
+
+/** A system content type's shipped property keys by alias, for a file that omits them. */
+export function systemPropertyKeys(alias: string): ReadonlyMap<string, string> {
+  const def = SYSTEM_CONTENT_TYPES.find((d) => d.alias === alias)
+  return new Map((def?.properties ?? []).map((p) => [p.alias, p.key]))
+}
+
+export function storageTypeFor(
+  editorAlias: string,
+): 'Ntext' | 'Nvarchar' | 'Integer' | 'Date' | 'Decimal' {
+  switch (editorAlias) {
+    case 'Umbraco.TextBox':
+    case 'Umbraco.ContentPicker':
+    case 'Umbraco.UploadField':
+    case 'Umbraco.EmailAddress':
+    // One form key, which is a UUID and never long.
+    case 'Crombolo.FormPicker':
+      return 'Nvarchar'
+    case 'Umbraco.Integer':
+    case 'Umbraco.TrueFalse':
+      return 'Integer'
+    case 'Umbraco.Decimal':
+      return 'Decimal'
+    case 'Umbraco.DateTime':
+      return 'Date'
+    default:
+      return 'Ntext'
+  }
+}
+
+export const BUILTIN_DATA_TYPE_ALIASES: ReadonlySet<string> = new Set(
+  BUILTIN_DATA_TYPES.map((d) => d.alias),
+)
+
+/**
+ * The media types a new site owns as files: Umbraco's Video, Audio, Article
+ * and Vector Graphics, keyed as Umbraco keys them. `crombolo init` writes these
+ * to `schema/media-types/`; relative path → canonical TOML.
+ */
+export function siteMediaTypeFiles(): Record<string, string> {
+  const files: Record<string, string> = {}
+  for (const def of BUILT_IN_MEDIA_TYPES.filter((t) => !t.system))
+    files[`schema/media-types/${fileNameFor(def.alias)}`] = writeMediaType(
+      builtInMediaTypeSchema(def),
+    )
+  return files
+}