@crombolo/cli 0.14.4 → 0.15.0

package/src/support/types.ts

@@ -0,0 +1,112 @@
+/** What the `types` commands share: loading `schema/`, applying it, and the upgrade check. */
+import { existsSync } from 'node:fs'
+import {
+  allProperties,
+  loadSchemaDirectory,
+  type SyncReport,
+  type ValueMigration,
+} from '@crombolo/schema'
+import {
+  bootstrapDatabase,
+  type CromboloConfig,
+  formTypesFor,
+  syncSchemaDirectory,
+} from '@crombolo/server'
+import { CliError } from '../errors.ts'
+import * as ops from '../operations/commands.ts'
+import { describeProblem, describeSync, here, printFindings, printProblems } from './describe.ts'
+import type { Io } from './site.ts'
+
+export const loadTypes = (config: CromboloConfig) =>
+  loadSchemaDirectory(config.schemaDir, { formTypes: formTypesFor(config) })
+
+export function needSchemaDir(config: CromboloConfig): void {
+  if (!existsSync(config.schemaDir))
+    throw new CliError('not_found', `No schema directory at ${here(config.schemaDir)}.`)
+}
+
+export function refuseProblems(problems: SyncReport['problems'], message?: string): void {
+  if (problems.length > 0)
+    throw new CliError('refused', message ?? `${problems.length} problem(s) in schema/.`, {
+      details: problems.map(describeProblem),
+    })
+}
+
+/** Applies `schema/` as a boot or a deploy step would, and reports what it did. */
+export async function applySchema(io: Io, config: CromboloConfig): Promise<SyncReport> {
+  const { db } = await bootstrapDatabase(config)
+  try {
+    const report = await syncSchemaDirectory(db, config, {
+      nodeId: config.nodeId,
+      revision: config.schemaRevision,
+    })
+    if (report.problems.length > 0) printProblems(io, report.problems)
+    io.say(`  schema   ${describeSync(report)}`)
+    if (report.action === 'refused')
+      throw new CliError('refused', `The schema was not applied: ${describeSync(report)}.`, {
+        details: report.problems.map(describeProblem),
+      })
+    return report
+  } finally {
+    await db.close()
+  }
+}
+
+/** The pull-request rules: keys present, migrations well-formed, nothing the database needs. */
+export function staticProblems(
+  loaded: ReturnType<typeof loadSchemaDirectory>,
+  migrations: ValueMigration[],
+): string[] {
+  const problems: string[] = []
+  for (const t of loaded.set.contentTypes) {
+    if (!t.key)
+      problems.push(`${t.alias}: no key — run \`crombolo types sync\` in development to assign one`)
+    for (const p of allProperties(t)) if (!p.key) problems.push(`${t.alias}.${p.alias}: no key`)
+  }
+  for (const d of loaded.set.dataTypes) if (!d.key) problems.push(`data type ${d.alias}: no key`)
+  for (const m of migrations) {
+    const type = loaded.set.contentTypes.find((t) => t.alias === m.from.type)
+    if (!type) {
+      problems.push(`migration ${m.id}: no content type "${m.from.type}"`)
+      continue
+    }
+    for (const target of m.to)
+      if (!allProperties(type).some((p) => p.alias === target.property))
+        problems.push(
+          `migration ${m.id}: "${m.from.type}" has no property "${target.property}" to write to`,
+        )
+  }
+  return problems
+}
+
+/** `--set type.property=value`, repeatable: a value for a new mandatory property. */
+export function parseSet(pairs: readonly string[]): Record<string, unknown> {
+  const out: Record<string, unknown> = {}
+  for (const pair of pairs) {
+    const eq = pair.indexOf('=')
+    if (eq < 0) throw new CliError('usage', `--set wants <type>.<property>=<value>, not "${pair}".`)
+    const raw = pair.slice(eq + 1)
+    let value: unknown = raw
+    try {
+      value = JSON.parse(raw)
+    } catch {}
+    out[pair.slice(0, eq)] = value
+  }
+  return out
+}
+
+/** What the deployed `schema/` would do to this database's data: the check an upgrade runs. */
+export async function upgradeCheck(io: Io, config: CromboloConfig, set: Record<string, unknown>) {
+  const report = await ops.upgradeCheck(config, { set })
+  for (const bundle of report.bundles)
+    if (bundle.pending.length > 0)
+      io.say(
+        `  bundle   ${bundle.id}: ${bundle.pending.map((step) => `${step.name} (${step.kind})`).join(', ')}`,
+      )
+  printFindings(io, report)
+  if (!report.siteChecked)
+    io.say(
+      'The site schema is checked once the framework migrations have run (`crombolo upgrade`).',
+    )
+  return report
+}

package/src/support/umbraco.ts

@@ -0,0 +1,86 @@
+/**
+ * `crombolo import umbraco`: a compatibility report for an Umbraco backup, and
+ * then a crombolo site written from it. Neither touches a database.
+ *
+ * The importer is a package of its own, loaded here on demand, so a site that
+ * never imports anything does not carry it or the `.bacpac` reader it needs.
+ */
+
+import { VERSION } from '@crombolo/server'
+import { Args, Flags } from '@oclif/core'
+import { CliError } from '../errors.ts'
+import { contentFlags } from './flags.ts'
+import type { Io } from './site.ts'
+
+export const umbracoArgs = {
+  backup: Args.string({ required: true, description: "a .bacpac, or Umbraco's SQLite file" }),
+}
+
+export const umbracoFlags = {
+  site: Flags.string({
+    summary: "the Umbraco site's files, for its views, media and plugins",
+    helpValue: '<dir>',
+  }),
+  media: Flags.string({
+    summary: 'where its media files are, if not under --site',
+    helpValue: '<dir>',
+  }),
+  name: Flags.string({ summary: "the new site's name", helpValue: '<site name>' }),
+  drafts: Flags.boolean({ summary: 'bring drafts too' }),
+  staging: Flags.string({ summary: 'where to unpack a .bacpac', helpValue: '<dir>' }),
+  'with-members': Flags.boolean({ summary: 'bring members, encrypted' }),
+  'with-users': Flags.boolean({ summary: 'bring back-office users, encrypted' }),
+  ...contentFlags,
+}
+
+export function deprecated(io: Io, json: boolean): void {
+  // Not into JSON output, which a machine reads.
+  if (!json)
+    io.warning(
+      '  deprecated  `crombolo import umbraco` is going away: an Umbraco extension will write a crombolo file that `crombolo import <file>` reads (story 074)',
+    )
+}
+
+export async function loadImporter(): Promise<typeof import('@crombolo/import-umbraco')> {
+  try {
+    return await import('@crombolo/import-umbraco')
+  } catch {
+    throw new CliError('not_found', 'The importer is a separate package.', {
+      hint: 'Add it, then run this again: bun add -d @crombolo/import-umbraco',
+    })
+  }
+}
+
+export async function planUmbraco(
+  importer: typeof import('@crombolo/import-umbraco'),
+  backup: string,
+  flags: {
+    site?: string
+    media?: string
+    name?: string
+    drafts: boolean
+    staging?: string
+    'with-members': boolean
+    'with-users': boolean
+  },
+  content: 'omitted' | 'sealed' | 'open',
+  passphrase: string | undefined,
+) {
+  try {
+    return await importer.planImport({
+      source: backup,
+      site: flags.site,
+      media: flags.media,
+      siteName: flags.name,
+      drafts: flags.drafts,
+      staging: flags.staging,
+      coreVersion: VERSION,
+      content,
+      withMembers: flags['with-members'],
+      withUsers: flags['with-users'],
+      passphrase,
+    })
+  } catch (error) {
+    throw new CliError('refused', error instanceof Error ? error.message : String(error))
+  }
+}

package/templates/basic/bundle/content/bundle.json

@@ -3,7 +3,7 @@
   "id": "2de473a2-d391-4161-801e-e34b202759b8",
   "createdAt": "2026-10-01T00:00:00.000Z",
   "createdBy": "bun run build:template",
-  "integrity": "sha256-5e0caa815b7238c8f691bb51692c4b222e8d564fd6490366752f80b98bbd9c70",
+  "integrity": "sha256-fa7b7651e0726518570df713624c1ab29af47f7f04a615b514e29d47de301b97",
   "snapshot": "published",
   "provenance": {
     "siteName": "Basic",

package/templates/basic/bundle/content/nodes/36955f6e-d110-469e-b280-72096eccd148.json

@@ -23,7 +23,7 @@
       "segment": null,
       "editor": "Umbraco.RichText",
       "value": {
-        "markup": "<p>This page is content: it lives in the database and you edit it in the backoffice. Its <em>shape</em> is code — <code>schema/content-types/home-page.toml</code> — and the markup around it is <code>components/homePage.tsx</code>.</p><p>Add a property to the TOML, run <code>crombolo schema check</code> to see what it would do to this page, then <code>crombolo start</code> to apply it.</p>",
+        "markup": "<p>This page is content: it lives in the database and you edit it in the backoffice. Its <em>shape</em> is code — <code>schema/content-types/home-page.toml</code> — and the markup around it is <code>components/homePage.tsx</code>.</p><p>Add a property to the TOML, run <code>crombolo types check</code> to see what it would do to this page, then <code>crombolo start</code> to apply it.</p>",
         "blocks": null
       }
     },

package/templates/basic/bundle/package.json

@@ -6,7 +6,7 @@
     "content"
   ],
   "peerDependencies": {
-    "@crombolo/crombolo": ">=0.14.4"
+    "@crombolo/crombolo": ">=0.15.0"
   },
   "crombolo": {
     "id": "basic",

package/templates/demo/harbourstone/bundle/package.json

@@ -6,7 +6,7 @@
     "content"
   ],
   "peerDependencies": {
-    "@crombolo/crombolo": ">=0.14.4"
+    "@crombolo/crombolo": ">=0.15.0"
   },
   "crombolo": {
     "id": "demo-harbourstone",

package/templates/starter/bundle/package.json

@@ -6,7 +6,7 @@
     "content"
   ],
   "peerDependencies": {
-    "@crombolo/crombolo": ">=0.14.4"
+    "@crombolo/crombolo": ">=0.15.0"
   },
   "crombolo": {
     "id": "starter",