@conduction/nextcloud-vue 2.120.0 → 2.121.0

package/src/components/CnReadinessChecklist/CnReadinessChecklist.vue

@@ -0,0 +1,335 @@
+<!--
+  - SPDX-FileCopyrightText: 2026 Conduction B.V.
+  - SPDX-License-Identifier: EUPL-1.2
+-->
+<template>
+	<div class="cn-readiness-checklist" data-testid="cn-readiness-checklist">
+		<p v-if="description" class="cn-readiness-checklist__description">
+			{{ description }}
+		</p>
+
+		<NcLoadingIcon v-if="loading" :size="32" :name="t('nextcloud-vue', 'Loading')" />
+
+		<NcNoteCard v-else-if="loadError" type="error" data-testid="cn-readiness-checklist-error">
+			{{ loadError }}
+		</NcNoteCard>
+
+		<template v-else>
+			<NcNoteCard v-if="blockingText && blockingItems.length > 0"
+				type="error"
+				data-testid="cn-readiness-checklist-blocking">
+				{{ blockingText }} {{ blockingItems.map((item) => item.label).join(', ') }}
+			</NcNoteCard>
+
+			<p v-if="shownItems.length === 0" class="cn-readiness-checklist__empty" data-testid="cn-readiness-checklist-empty">
+				{{ emptyText || t('nextcloud-vue', 'Nothing to check.') }}
+			</p>
+
+			<section v-for="group in shownGroups"
+				:key="group.id"
+				class="cn-readiness-checklist__group"
+				:data-testid="`cn-readiness-checklist-group-${group.id}`">
+				<h4 v-if="group.title" class="cn-readiness-checklist__group-title">
+					{{ group.title }}
+				</h4>
+				<ul class="cn-readiness-checklist__list">
+					<li v-for="item in group.items"
+						:key="item.id"
+						class="cn-readiness-checklist__item"
+						:data-testid="`cn-readiness-item-${item.id}`">
+						<!-- The state is a word, not a colour (WCAG 1.4.1); the
+						     colour repeats it. -->
+						<span class="cn-readiness-checklist__state"
+							:class="`cn-readiness-checklist__state--${stateOf(item)}`"
+							data-testid="cn-readiness-item-state">
+							{{ stateLabel(item) }}
+						</span>
+						<span class="cn-readiness-checklist__body">
+							<a v-if="item.fixHref"
+								:href="item.fixHref"
+								class="cn-readiness-checklist__label"
+								data-testid="cn-readiness-item-fix">{{ item.label }}</a>
+							<span v-else class="cn-readiness-checklist__label">{{ item.label }}</span>
+							<span v-if="item.explanation" class="cn-readiness-checklist__explanation">{{ item.explanation }}</span>
+							<span v-if="item.failure" class="cn-readiness-checklist__failure">
+								{{ t('nextcloud-vue', 'This could not be read: {reason}', { reason: item.failure }) }}
+							</span>
+						</span>
+					</li>
+				</ul>
+			</section>
+		</template>
+	</div>
+</template>
+
+<script>
+import axios from '@nextcloud/axios'
+import { translate as t } from '@nextcloud/l10n'
+import { generateUrl } from '@nextcloud/router'
+import { NcLoadingIcon, NcNoteCard } from '@nextcloud/vue'
+import { readPath } from '../../utils/readPath.js'
+
+/**
+ * The fields an item is read from by default.
+ *
+ * @type {Readonly<Record<string, string>>}
+ */
+const DEFAULT_FIELDS = Object.freeze({
+	id: 'id',
+	label: 'label',
+	explanation: 'explanation',
+	met: 'met',
+	fixHref: 'fixHref',
+	failure: 'failure',
+	group: 'group',
+	blocking: 'blocking',
+})
+
+/**
+ * CnReadinessChecklist: a list of things an instance needs, each with its
+ * state in words (met, open, unknown), an explanation and a link to the
+ * screen that fixes it. Reported, never gated: nothing here blocks the app.
+ *
+ * Items come from `items`, or are read from an app endpoint (`source`, an app
+ * path resolved with `generateUrl`, the list at `itemsPath`) and re-read when
+ * the reader comes back to the tab. `fields` maps an item's keys onto the
+ * row's (`{ label: 'title', met: 'done', fixHref: 'screen' }`). Items carrying
+ * a `group` render under that group's heading (`groups`, in order).
+ *
+ * @spec openspec/changes/readiness-checklist/specs/readiness-checklist/spec.md
+ */
+export default {
+	name: 'CnReadinessChecklist',
+
+	components: { NcLoadingIcon, NcNoteCard },
+
+	inject: {
+		/** The host app's translate, for texts the page declares. */
+		cnTranslate: { default: () => (key) => key },
+	},
+
+	props: {
+		/** The items: `{ id, label, explanation?, met (true|false|null), fixHref?, failure?, group?, blocking? }`. */
+		items: { type: Array, default: () => [] },
+		/** An app path to read the items from (`/apps/<app>/api/setup/status`). */
+		source: { type: String, default: '' },
+		/** Where the items sit in the answer. */
+		itemsPath: { type: String, default: 'items' },
+		/** Item key to row key, over the defaults. */
+		fields: { type: Object, default: () => ({}) },
+		/** Headings for grouped items, in order: `[{ id, title }]`. */
+		groups: { type: Array, default: () => [] },
+		/** A line above the list. */
+		description: { type: String, default: '' },
+		/** The words for each state: `{ met, unmet, unknown }`. */
+		statusLabels: { type: Object, default: () => ({}) },
+		/** Said when there is nothing to check. */
+		emptyText: { type: String, default: '' },
+		/** Said when the source could not be read. */
+		errorText: { type: String, default: '' },
+		/** Said before the unmet items marked `blocking` ("Cannot run until this is installed:"). */
+		blockingText: { type: String, default: '' },
+	},
+
+	emits: ['loaded'],
+
+	data() {
+		return {
+			loading: false,
+			loadError: '',
+			loadedItems: null,
+		}
+	},
+
+	computed: {
+		/** @return {Array<object>} The items, normalised. */
+		shownItems() {
+			const raw = this.loadedItems !== null ? this.loadedItems : this.items
+			const map = { ...DEFAULT_FIELDS, ...(this.fields || {}) }
+			return (Array.isArray(raw) ? raw : []).map((row, index) => {
+				const read = (key) => readPath(row, map[key])
+				const met = read('met')
+				return {
+					id: String(read('id') ?? index),
+					label: this.text(read('label') ?? read('id') ?? ''),
+					explanation: this.text(read('explanation') ?? ''),
+					met: met === true || met === false ? met : null,
+					fixHref: typeof read('fixHref') === 'string' ? read('fixHref') : '',
+					failure: read('failure') ? String(read('failure')) : '',
+					group: read('group') ? String(read('group')) : '',
+					blocking: read('blocking') === true,
+				}
+			})
+		},
+
+		/** @return {Array<object>} The unmet blocking items. */
+		blockingItems() {
+			return this.shownItems.filter((item) => item.blocking && item.met !== true)
+		},
+
+		/** @return {Array<{id: string, title: string, items: Array<object>}>} The groups that hold items, in order. */
+		shownGroups() {
+			const declared = (Array.isArray(this.groups) ? this.groups : []).map((group) => ({
+				id: String(group.id),
+				title: this.text(group.title || ''),
+				items: this.shownItems.filter((item) => item.group === String(group.id)),
+			}))
+			const known = new Set(declared.map((group) => group.id))
+			const rest = this.shownItems.filter((item) => !known.has(item.group))
+			const all = rest.length > 0 ? [{ id: 'items', title: '', items: rest }, ...declared] : declared
+			return all.filter((group) => group.items.length > 0)
+		},
+	},
+
+	watch: {
+		source() {
+			this.reload()
+		},
+	},
+
+	mounted() {
+		this.reload()
+		window.addEventListener('focus', this.onFocus)
+	},
+
+	beforeUnmount() {
+		window.removeEventListener('focus', this.onFocus)
+	},
+
+	methods: {
+		t,
+
+		/**
+		 * A declared text through the host's translate.
+		 *
+		 * @param {string} value The text.
+		 * @return {string} The translated text.
+		 */
+		text(value) {
+			return value ? String(this.cnTranslate(String(value))) : ''
+		},
+
+		/**
+		 * @param {object} item The item.
+		 * @return {string} `met`, `unmet` or `unknown`.
+		 */
+		stateOf(item) {
+			if (item.met === true) {
+				return 'met'
+			}
+			return item.met === false ? 'unmet' : 'unknown'
+		},
+
+		/**
+		 * The word for an item's state.
+		 *
+		 * @param {object} item The item.
+		 * @return {string} The word.
+		 */
+		stateLabel(item) {
+			const state = this.stateOf(item)
+			const own = this.statusLabels && this.statusLabels[state]
+			if (own) {
+				return this.text(own)
+			}
+			return {
+				met: t('nextcloud-vue', 'Done'),
+				unmet: t('nextcloud-vue', 'Still open'),
+				unknown: t('nextcloud-vue', 'Unknown'),
+			}[state]
+		},
+
+		/**
+		 * Read the items again, from the source. The source asks the instance
+		 * rather than a stored flag, so a fix made elsewhere shows on return.
+		 *
+		 * @return {Promise<void>}
+		 */
+		async reload() {
+			if (!this.source) {
+				this.loadedItems = null
+				return
+			}
+			this.loading = this.loadedItems === null
+			this.loadError = ''
+			try {
+				const { data } = await axios.get(generateUrl(this.source))
+				const rows = Array.isArray(data) ? data : readPath(data, this.itemsPath)
+				this.loadedItems = Array.isArray(rows) ? rows : []
+				/** @event loaded The source answered. Payload: the whole answer. */
+				this.$emit('loaded', data)
+			} catch {
+				this.loadedItems = []
+				this.loadError = this.errorText ? this.text(this.errorText) : t('nextcloud-vue', 'The checklist could not be read.')
+			} finally {
+				this.loading = false
+			}
+		},
+
+		/** Re-read when the reader comes back from fixing something. */
+		onFocus() {
+			if (this.source) {
+				this.reload()
+			}
+		},
+	},
+}
+</script>
+
+<style scoped>
+.cn-readiness-checklist__description,
+.cn-readiness-checklist__empty {
+	color: var(--color-text-maxcontrast);
+	margin: 0 0 12px;
+}
+
+.cn-readiness-checklist__group-title {
+	margin: 12px 0 4px;
+}
+
+.cn-readiness-checklist__list {
+	list-style: none;
+	margin: 0;
+	padding: 0;
+}
+
+.cn-readiness-checklist__item {
+	display: flex;
+	gap: calc(var(--default-grid-baseline, 4px) * 3);
+	padding-block: calc(var(--default-grid-baseline, 4px) * 2);
+	border-block-end: 1px solid var(--color-border);
+}
+
+.cn-readiness-checklist__state {
+	flex: 0 0 auto;
+	min-width: 6em;
+	font-weight: bold;
+}
+
+.cn-readiness-checklist__state--met {
+	color: var(--color-success-text, var(--color-success));
+}
+
+.cn-readiness-checklist__state--unmet {
+	color: var(--color-error-text, var(--color-error));
+}
+
+.cn-readiness-checklist__state--unknown {
+	color: var(--color-text-maxcontrast);
+}
+
+.cn-readiness-checklist__body {
+	display: flex;
+	flex-direction: column;
+	gap: 2px;
+	min-width: 0;
+}
+
+.cn-readiness-checklist__explanation {
+	color: var(--color-text-maxcontrast);
+}
+
+.cn-readiness-checklist__failure {
+	color: var(--color-error-text, var(--color-error));
+}
+</style>

package/src/components/CnReadinessChecklist/index.js

@@ -0,0 +1,9 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Conduction B.V.
+ * SPDX-License-Identifier: EUPL-1.2
+ */
+
+import CnReadinessChecklist from './CnReadinessChecklist.vue'
+
+export default CnReadinessChecklist
+export { CnReadinessChecklist }

package/src/components/CnSchemaRulesWidget/CnSchemaRulesWidget.vue

@@ -0,0 +1,300 @@
+<!--
+  - SPDX-FileCopyrightText: 2026 Conduction B.V.
+  - SPDX-License-Identifier: EUPL-1.2
+-->
+<template>
+	<div class="cn-schema-rules" data-testid="cn-schema-rules">
+		<h4 v-if="title !== null">
+			{{ title ? text(title) : t('nextcloud-vue', 'Rules on this schema') }}
+		</h4>
+		<p class="cn-schema-rules__hint">
+			{{ description ? text(description) : t('nextcloud-vue', 'Everything the platform checks when an object is saved, in the order it checks it.') }}
+		</p>
+
+		<NcLoadingIcon v-if="loading" :size="32" :name="t('nextcloud-vue', 'Loading')" />
+		<p v-else-if="error"
+			class="cn-schema-rules__error"
+			role="alert"
+			data-testid="cn-schema-rules-error">
+			{{ error }}
+		</p>
+		<p v-else-if="rules.length === 0" class="cn-schema-rules__empty" data-testid="cn-schema-rules-empty">
+			{{ emptyText ? text(emptyText) : t('nextcloud-vue', 'Nothing is checked on this schema yet.') }}
+		</p>
+		<table v-else class="cn-schema-rules__table" data-testid="cn-schema-rules-table">
+			<thead>
+				<tr>
+					<th scope="col">
+						{{ t('nextcloud-vue', 'Rule') }}
+					</th>
+					<th scope="col">
+						{{ t('nextcloud-vue', 'Kind') }}
+					</th>
+					<th scope="col">
+						{{ t('nextcloud-vue', 'On') }}
+					</th>
+					<th scope="col">
+						{{ t('nextcloud-vue', 'Last run') }}
+					</th>
+					<th scope="col">
+						<span class="hidden-visually">{{ t('nextcloud-vue', 'Try') }}</span>
+					</th>
+				</tr>
+			</thead>
+			<tbody>
+				<tr v-for="rule in rules" :key="rule.id" data-testid="cn-schema-rules-row">
+					<th scope="row">
+						{{ rule.label || rule.key || rule.id }}
+					</th>
+					<td data-testid="cn-schema-rules-kind">
+						{{ kindLabel(rule) }}
+					</td>
+					<td>{{ rule.enabled === false ? t('nextcloud-vue', 'Off') : t('nextcloud-vue', 'On') }}</td>
+					<td>{{ rule.lastRun || t('nextcloud-vue', 'Never') }}</td>
+					<td>
+						<NcButton variant="tertiary"
+							:disabled="trying === rule.id || trialObject.trim() === ''"
+							:data-testid="`cn-schema-rules-try-${rule.id}`"
+							@click="tryRule(rule)">
+							{{ t('nextcloud-vue', 'Try it') }}
+						</NcButton>
+					</td>
+				</tr>
+			</tbody>
+		</table>
+
+		<div class="cn-schema-rules__trial">
+			<NcTextField :modelValue="trialObject"
+				:label="objectLabel ? text(objectLabel) : t('nextcloud-vue', 'Object to try a rule against')"
+				:placeholder="objectPlaceholder ? text(objectPlaceholder) : t('nextcloud-vue', 'Paste an object id')"
+				data-testid="cn-schema-rules-object-id"
+				@update:modelValue="(v) => (trialObject = v)" />
+			<p class="cn-schema-rules__hint">
+				{{ t('nextcloud-vue', 'A trial writes nothing. It reads the object as it stands and says what the rule would have decided.') }}
+			</p>
+			<div v-if="trace" class="cn-schema-rules__trace" data-testid="cn-schema-rules-trace">
+				<p class="cn-schema-rules__verdict">
+					{{ verdictLine }}
+				</p>
+				<p v-if="trace.operand" data-testid="cn-schema-rules-operand">
+					{{ t('nextcloud-vue', 'It read {operand} and found {value}.', { operand: trace.operand, value: trace.operandValue || t('nextcloud-vue', 'nothing') }) }}
+				</p>
+				<p v-if="trace.message">
+					{{ trace.message }}
+				</p>
+			</div>
+		</div>
+	</div>
+</template>
+
+<script>
+import { translate as t } from '@nextcloud/l10n'
+import { NcButton, NcLoadingIcon, NcTextField } from '@nextcloud/vue'
+import { evaluateRule, fetchRuleVocabulary, fetchSchemaRules, kindsByName, traceOf } from './schemaRules.js'
+
+/**
+ * CnSchemaRulesWidget: the rules OpenRegister's engine holds for one schema,
+ * in the order it evaluates them, each with its kind (from the engine's own
+ * vocabulary), whether it is on and when it last ran, and a dry run against
+ * one stored object that writes nothing and shows the trace (verdict, the
+ * operand it read and what it found).
+ *
+ * The inventory is an admin read: a refusal is said in one sentence instead
+ * of an empty table that would read as "nothing is checked".
+ *
+ * @spec openspec/changes/schema-rules-widget/specs/schema-rules-widget/spec.md
+ */
+export default {
+	name: 'CnSchemaRulesWidget',
+
+	components: { NcButton, NcLoadingIcon, NcTextField },
+
+	inject: {
+		/** The host app's translate, for the texts the page declares. */
+		cnTranslate: { default: () => (key) => key },
+	},
+
+	props: {
+		/** The register slug the trial object lives in. */
+		register: { type: String, required: true },
+		/** The schema slug whose rules are listed. */
+		schema: { type: String, required: true },
+		/** The object a trial runs against, pre-filled; the reader can change it. */
+		objectId: { type: String, default: '' },
+		/** The heading; `null` draws none. */
+		title: { type: String, default: '' },
+		/** The line under the heading. */
+		description: { type: String, default: '' },
+		/** Said when the schema has no rules. */
+		emptyText: { type: String, default: '' },
+		/** The label of the trial object field. */
+		objectLabel: { type: String, default: '' },
+		/** The placeholder of the trial object field. */
+		objectPlaceholder: { type: String, default: '' },
+		/** Said when the inventory is refused (403). */
+		refusedText: { type: String, default: '' },
+		/** Whether to read nothing yet (a record still being created). */
+		disabled: { type: Boolean, default: false },
+	},
+
+	data() {
+		return {
+			loading: false,
+			error: '',
+			rules: [],
+			kinds: {},
+			trialObject: this.objectId,
+			trying: '',
+			trace: null,
+		}
+	},
+
+	computed: {
+		/** @return {string} What the trial decided, as a sentence. */
+		verdictLine() {
+			const verdicts = {
+				fired: t('nextcloud-vue', 'The rule fired.'),
+				no_match: t('nextcloud-vue', 'The rule did not match this object.'),
+				refused: t('nextcloud-vue', 'The rule refused the save.'),
+				error: t('nextcloud-vue', 'The rule could not be evaluated.'),
+			}
+			return verdicts[this.trace && this.trace.verdict] || (this.trace && this.trace.verdict) || ''
+		},
+	},
+
+	watch: {
+		objectId(value) {
+			this.trialObject = value
+		},
+
+		schema() {
+			this.load()
+		},
+	},
+
+	mounted() {
+		if (!this.disabled) {
+			this.load()
+		}
+	},
+
+	methods: {
+		t,
+
+		/**
+		 * @param {string} value A declared text.
+		 * @return {string} It, translated by the host.
+		 */
+		text(value) {
+			return value ? String(this.cnTranslate(String(value))) : ''
+		},
+
+		/**
+		 * The word for a rule's kind, from the vocabulary, else the kind the
+		 * rule carries: a blank would read as "this rule has no kind".
+		 *
+		 * @param {object} rule An inventory row.
+		 * @return {string} The label.
+		 */
+		kindLabel(rule) {
+			const kind = String((rule && rule.kind) ?? '')
+			return String((this.kinds[kind] && this.kinds[kind].description) || kind)
+		},
+
+		/**
+		 * Read the vocabulary and the inventory.
+		 *
+		 * @return {Promise<void>}
+		 */
+		async load() {
+			if (!this.schema) {
+				return
+			}
+			this.loading = true
+			this.error = ''
+			this.kinds = kindsByName(await fetchRuleVocabulary())
+			try {
+				this.rules = await fetchSchemaRules(this.schema)
+			} catch (e) {
+				this.rules = []
+				const refused = Number(e && e.response && e.response.status) === 403
+				this.error = refused
+					? (this.refusedText ? this.text(this.refusedText) : t('nextcloud-vue', 'Only an administrator can read the rules of this schema.'))
+					: t('nextcloud-vue', 'The rules could not be read. Ask an administrator.')
+			}
+			this.loading = false
+		},
+
+		/**
+		 * Try one rule against the trial object, keyed on the rule's id.
+		 *
+		 * @param {object} rule An inventory row.
+		 * @return {Promise<void>}
+		 */
+		async tryRule(rule) {
+			const ruleId = String((rule && rule.id) ?? '')
+			const objectId = this.trialObject.trim()
+			if (ruleId === '' || objectId === '') {
+				return
+			}
+			this.trying = ruleId
+			this.trace = null
+			try {
+				this.trace = traceOf(await evaluateRule(this.schema, ruleId, this.register, objectId))
+			} catch {
+				this.trace = { verdict: 'error', operand: '', operandValue: '', message: t('nextcloud-vue', 'That object could not be read.') }
+			}
+			this.trying = ''
+		},
+	},
+}
+</script>
+
+<style scoped>
+.cn-schema-rules__hint {
+	font-size: 12px;
+	color: var(--color-text-maxcontrast);
+	margin: 4px 0 12px;
+}
+
+.cn-schema-rules__table {
+	width: 100%;
+	border-collapse: collapse;
+}
+
+.cn-schema-rules__table th,
+.cn-schema-rules__table td {
+	text-align: start;
+	padding: 6px 8px;
+	border-bottom: 1px solid var(--color-border);
+}
+
+.cn-schema-rules__trial {
+	margin-top: 16px;
+	border-top: 1px solid var(--color-border);
+	padding-top: 12px;
+}
+
+.cn-schema-rules__trace {
+	margin-top: 8px;
+	padding: 8px 12px;
+	border-radius: var(--border-radius-large, 8px);
+	background-color: var(--color-background-hover);
+}
+
+.cn-schema-rules__trace p {
+	margin: 0;
+}
+
+.cn-schema-rules__verdict {
+	font-weight: bold;
+}
+
+.cn-schema-rules__error {
+	color: var(--color-error-text);
+}
+
+.cn-schema-rules__empty {
+	color: var(--color-text-maxcontrast);
+}
+</style>

package/src/components/CnSchemaRulesWidget/index.js

@@ -0,0 +1,10 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Conduction B.V.
+ * SPDX-License-Identifier: EUPL-1.2
+ */
+
+import CnSchemaRulesWidget from './CnSchemaRulesWidget.vue'
+
+export default CnSchemaRulesWidget
+export { CnSchemaRulesWidget }
+export { evaluateRule, fetchRuleVocabulary, fetchSchemaRules, kindsByName, traceOf } from './schemaRules.js'