@conduction/nextcloud-vue 2.56.0-beta.12 → 2.56.0-beta.13

package/src/store/useObjectStore.js

@@ -264,6 +264,27 @@ const baseActions = {
 		this.facets = { ...this.facets, [slug]: {} }
 	},
 
+	/**
+	 * Give a registered type a second schema path segment to try once when
+	 * its own answers 404 (see `_fetchWithSchemaFallback`). Set by
+	 * `resolveObjectOpType` for a schema title it kebab-cased, with the
+	 * title as written. A type that is not registered is left alone.
+	 *
+	 * @spec openspec/changes/zuiddrecht-pixel-gaps-2/specs/zuiddrecht-pixel-gaps-2/spec.md#requirement-a-schema-title-falls-back-to-its-written-form
+	 * @param {string} slug The type slug
+	 * @param {string} schema The fallback schema path segment
+	 */
+	setSchemaFallback(slug, schema) {
+		const config = this.objectTypeRegistry[slug]
+		if (!config || typeof schema !== 'string' || schema === '') {
+			return
+		}
+		this.objectTypeRegistry = {
+			...this.objectTypeRegistry,
+			[slug]: { ...config, schemaFallback: schema },
+		}
+	},
+
 	/**
 	 * Unregister an object type and clean up all its state.
 	 *
@@ -433,11 +454,12 @@ const baseActions = {
 	 *
 	 * @param {string} type The type slug
 	 * @param {string|null} [id] Optional object ID
+	 * @param {string|null} [schema] Schema path segment to use instead of the type's own
 	 * @return {string} Full API URL path
 	 */
-	_buildUrl(type, id = null) {
+	_buildUrl(type, id = null, schema = null) {
 		const config = this._getTypeConfig(type)
-		let url = `${this._options.baseUrl}/${config.register}/${config.schema}`
+		let url = `${this._options.baseUrl}/${config.register}/${schema ?? config.schema}`
 		if (id) {
 			url += `/${id}`
 		}
@@ -458,11 +480,12 @@ const baseActions = {
 	 * @param {string} type The type slug
 	 * @param {object} [params] Extra query parameters
 	 * @param {string|null} [id] Optional object ID
+	 * @param {string|null} [schema] Schema path segment to use instead of the type's own
 	 * @return {string} Full API URL path including query string
 	 */
-	_buildUrlWithParams(type, params = {}, id = null) {
+	_buildUrlWithParams(type, params = {}, id = null, schema = null) {
 		const config = this._getTypeConfig(type)
-		let url = `${this._options.baseUrl}/${config.register}/${config.schema}`
+		let url = `${this._options.baseUrl}/${config.register}/${schema ?? config.schema}`
 		if (id) {
 			url += `/${id}`
 		}
@@ -472,6 +495,54 @@ const baseActions = {
 		return url
 	},
 
+	/**
+	 * Fetch for a type, retrying ONCE with its `schemaFallback` when the
+	 * schema path segment answers 404. A type without a fallback (every type
+	 * not registered by `resolveObjectOpType` for a kebab-cased title) makes
+	 * exactly the one request it always made. When the retry succeeds the
+	 * fallback becomes the type's schema, so later calls go straight to it;
+	 * when it does not, the first answer is returned and nothing changes.
+	 *
+	 * @spec openspec/changes/zuiddrecht-pixel-gaps-2/specs/zuiddrecht-pixel-gaps-2/spec.md#requirement-a-schema-title-falls-back-to-its-written-form
+	 * @param {string} type The type slug
+	 * @param {function((string|null)): string} makeUrl Builds the URL; called with
+	 *   null for the type's own schema, or with the fallback segment.
+	 * @param {object} init The fetch options.
+	 * @return {Promise<Response>} The response to use.
+	 */
+	async _fetchWithSchemaFallback(type, makeUrl, init) {
+		// `makeUrl` wraps `_buildUrl` / `_buildUrlWithParams`, so `url` is built
+		// from the prefixed `_options.baseUrl` like every other request here.
+		let url = makeUrl(null)
+		const response = await fetch(url, init)
+		if (!response || response.status !== 404) {
+			return response
+		}
+		const config = this.objectTypeRegistry[type]
+		const fallback = config && config.schemaFallback
+		if (!fallback || String(fallback) === String(config.schema)) {
+			return response
+		}
+		let retry
+		try {
+			url = makeUrl(fallback)
+			retry = await fetch(url, init)
+		} catch {
+			return response
+		}
+		if (!retry || !retry.ok) {
+			discardResponseBody(retry)
+			return response
+		}
+		discardResponseBody(response)
+		const { schemaFallback: _, ...rest } = config
+		this.objectTypeRegistry = {
+			...this.objectTypeRegistry,
+			[type]: { ...rest, schema: fallback },
+		}
+		return retry
+	},
+
 	/**
 	 * Clear the error state for a type.
 	 *
@@ -604,12 +675,14 @@ const baseActions = {
 				}
 			}
 
-			const url = this._buildUrlWithParams(type, fetchParams)
-
-			const response = await fetch(url, {
-				method: 'GET',
-				headers: this._buildHeaders(),
-			})
+			const response = await this._fetchWithSchemaFallback(
+				type,
+				(schema) => this._buildUrlWithParams(type, fetchParams, null, schema),
+				{
+					method: 'GET',
+					headers: this._buildHeaders(),
+				},
+			)
 
 			if (!response.ok) {
 				this.errors = { ...this.errors, [type]: await parseResponseError(response, type) }
@@ -675,11 +748,14 @@ const baseActions = {
 	 */
 	async fetchCollectionForOptions(type, params = {}) {
 		try {
-			const url = this._buildUrlWithParams(type, params)
-			const response = await fetch(url, {
-				method: 'GET',
-				headers: this._buildHeaders(),
-			})
+			const response = await this._fetchWithSchemaFallback(
+				type,
+				(schema) => this._buildUrlWithParams(type, params, null, schema),
+				{
+					method: 'GET',
+					headers: this._buildHeaders(),
+				},
+			)
 
 			if (!response.ok) {
 				discardResponseBody(response)
@@ -734,10 +810,14 @@ const baseActions = {
 		this.errors = { ...this.errors, [type]: null }
 
 		try {
-			const response = await fetch(url, {
-				method: 'GET',
-				headers: this._buildHeaders(),
-			})
+			const response = await this._fetchWithSchemaFallback(
+				type,
+				(schema) => (schema === null ? url : this._buildUrl(type, id, schema)),
+				{
+					method: 'GET',
+					headers: this._buildHeaders(),
+				},
+			)
 
 			if (!response.ok) {
 				this.errors = { ...this.errors, [type]: await parseResponseError(response, type) }
@@ -805,16 +885,19 @@ const baseActions = {
 
 		try {
 			const isUpdate = !!objectData.id
-			const url = isUpdate
-				? this._buildUrl(type, objectData.id)
-				: this._buildUrl(type)
 			const method = isUpdate ? 'PUT' : 'POST'
 
-			const response = await fetch(url, {
-				method,
-				headers: this._buildHeaders(),
-				body: JSON.stringify(objectData),
-			})
+			const response = await this._fetchWithSchemaFallback(
+				type,
+				(schema) => (isUpdate
+					? this._buildUrl(type, objectData.id, schema)
+					: this._buildUrl(type, null, schema)),
+				{
+					method,
+					headers: this._buildHeaders(),
+					body: JSON.stringify(objectData),
+				},
+			)
 
 			if (!response.ok) {
 				this.errors = { ...this.errors, [type]: await parseResponseError(response, type) }
@@ -866,12 +949,14 @@ const baseActions = {
 		this.errors = { ...this.errors, [type]: null }
 
 		try {
-			const url = this._buildUrl(type, id)
-
-			const response = await fetch(url, {
-				method: 'DELETE',
-				headers: this._buildHeaders(),
-			})
+			const response = await this._fetchWithSchemaFallback(
+				type,
+				(schema) => this._buildUrl(type, id, schema),
+				{
+					method: 'DELETE',
+					headers: this._buildHeaders(),
+				},
+			)
 
 			if (!response.ok) {
 				this.errors = { ...this.errors, [type]: await parseResponseError(response, type) }

package/src/utils/actionsDispatcher.js

@@ -100,13 +100,33 @@ export function isExternalActionTarget(target) {
  * would otherwise register — and fetch — a 404 (defect 7, learniq round
  * 1). Idempotent for a caller that already passes a correct slug.
  *
+ * A caller that already holds the schema SLUG (not a `$ref` title) passes
+ * `{ exactSchema: true }`: the slug is then used exactly as given. Kebab-casing
+ * a real camelCase slug (`productCategory` -> `product-category`) asks the
+ * objects API for a schema that does not exist and 404s (pipelinq review,
+ * round two).
+ *
+ * @spec openspec/changes/review-round-two/specs/schema-utilities/spec.md
+ *
+ * A title is not always registered under its kebab form: learniq holds
+ * `LearniqSettings` and `SubjectTeacherAssignment` as written. So a type
+ * registered here for a value the kebab rule CHANGED also carries the value
+ * as written as its `schemaFallback`, and the store retries with it once
+ * when the kebab form answers 404 (keeping it from then on). The kebab form
+ * is still tried first, so a schema registered under it costs nothing.
+ *
+ * @spec openspec/changes/zuiddrecht-pixel-gaps-2/specs/zuiddrecht-pixel-gaps-2/spec.md#requirement-a-schema-title-falls-back-to-its-written-form
  * @param {object} store The object store instance (useObjectStore shape).
  * @param {{register: (string|number), schema: (string|number)}} source The widget source.
+ * @param {{exactSchema: (boolean|undefined)}} [options] `exactSchema: true` skips the title-to-slug step.
  * @return {string} The type slug to use for store CRUD calls.
  */
-export function resolveObjectOpType(store, source) {
+export function resolveObjectOpType(store, source, options = {}) {
 	const register = String(source.register)
-	const schema = String(schemaRefSlug(source.schema))
+	const schema = options.exactSchema === true ? String(source.schema) : String(schemaRefSlug(source.schema))
+	const written = typeof source.schema === 'string'
+		? source.schema.substring(source.schema.lastIndexOf('/') + 1)
+		: ''
 	const registry = store.objectTypeRegistry || {}
 	for (const [slug, config] of Object.entries(registry)) {
 		if (!config) {
@@ -120,6 +140,9 @@ export function resolveObjectOpType(store, source) {
 	const slug = `${register}/${schema}`
 	if (!registry[slug]) {
 		store.registerObjectType(slug, schema, register)
+		if (written !== '' && written !== schema && typeof store.setSchemaFallback === 'function') {
+			store.setSchemaFallback(slug, written)
+		}
 	}
 	return slug
 }

package/src/utils/columnFilters.js

@@ -15,13 +15,19 @@
  * Parameter shapes, as OpenRegister reads them:
  * - equality and "any of": `key=value`, `key[]=a&key[]=b`
  * - ranges: `key[gte]=from`, `key[lte]=to`
+ * - contains (text): `key[like]=term`, case-insensitive (openregister#4430);
+ *   the server escapes `%`, `_` and `\`, so the raw term goes out as typed
  *
  * @module utils/columnFilters
  * @spec openspec/changes/table-header-sort-and-filter/specs/cn-data-table/spec.md
+ * @spec openspec/changes/header-filter-contains/specs/cn-data-table/spec.md#requirement-a-text-header-filter-matches-on-contains
  */
 
 import { schemaRefSlug } from './schemaRefSlug.js'
 
+/** OpenRegister's case-insensitive contains operator, used by the text filter. */
+export const CONTAINS_OPERATOR = 'like'
+
 /** Column keys that mark a value computed on the client, never stored. */
 const COMPUTED_MARKERS = ['aggregate', 'compute', 'computed', 'virtual']
 
@@ -160,7 +166,7 @@ function referenceTarget(column, prop) {
  *
  * Kinds: `enum` (checkbox list), `boolean` (yes, no, any), `reference`
  * (searchable list of the referenced objects), `number` and `date` (from and
- * to), and `string` (equals). `filterable: false` on the column turns it
+ * to), and `string` (contains, through OpenRegister's `[like]`). `filterable: false` on the column turns it
  * off. A column with no schema property behind it only filters when it
  * carries an enum hint (`enum`, or a badge widget's colour map), because the
  * server cannot filter on a value it does not store.
@@ -234,9 +240,25 @@ export function columnFilterParamKeys(def) {
 	if (def.kind === 'number' || def.kind === 'date') {
 		return [`${def.key}[gte]`, `${def.key}[lte]`]
 	}
+	if (def.kind === 'string') {
+		return [containsKey(def)]
+	}
 	return [def.key]
 }
 
+/**
+ * The parameter a text filter writes: `{key}[like]`. An exact `key=value`
+ * from the facet sidebar or a fixed filter is a different key, so the header
+ * neither shows nor clears it.
+ *
+ * @param {object} def A filter definition of kind `string`.
+ * @return {string} The parameter key.
+ * @spec openspec/changes/header-filter-contains/specs/cn-data-table/spec.md#requirement-a-text-header-filter-matches-on-contains
+ */
+function containsKey(def) {
+	return `${def.key}[${CONTAINS_OPERATOR}]`
+}
+
 /**
  * A column filter's current state, read from the active-filter map.
  *
@@ -262,6 +284,9 @@ export function columnFilterState(def, activeFilters) {
 			to: def.kind === 'date' ? to.slice(0, 10) : to,
 		}
 	}
+	if (def.kind === 'string') {
+		return { value: asList(filters[containsKey(def)])[0] || '' }
+	}
 	return { value: asList(filters[def.key])[0] || '' }
 }
 
@@ -309,8 +334,10 @@ export function columnFilterParams(def, state) {
 	if (def.kind === 'boolean') {
 		return { [def.key]: (s.value === 'true' || s.value === 'false') ? [s.value] : [] }
 	}
+	// Text: the raw term under `[like]`. No wildcards: OpenRegister wraps
+	// the term itself and escapes `%`, `_` and `\` in it.
 	const value = s.value === undefined || s.value === null ? '' : String(s.value).trim()
-	return { [def.key]: value === '' ? [] : [value] }
+	return { [containsKey(def)]: value === '' ? [] : [value] }
 }
 
 /**

package/src/utils/schema.js

@@ -367,7 +367,7 @@ function isUserProp(prop) {
 	if (!prop || typeof prop !== 'object') {
 		return false
 	}
-	if (prop.referenceType === 'nextcloud-user') {
+	if (prop.referenceType === 'nextcloud-user' || prop.widget === 'user') {
 		return true
 	}
 	const format = prop.format || ''
@@ -389,7 +389,44 @@ function isGroupProp(prop) {
 	if (!prop || typeof prop !== 'object') {
 		return false
 	}
-	return prop.referenceType === 'nextcloud-group' || prop.format === 'nc-group'
+	return prop.referenceType === 'nextcloud-group' || prop.format === 'nc-group' || prop.widget === 'group'
+}
+
+/**
+ * Make a manifest field override that names a picker widget behave exactly
+ * like the schema format that triggers it.
+ *
+ * OpenRegister refuses formats it does not know (`nc-group`, `language`,
+ * `timezone`) at import, so an app cannot always put them in its schema. It
+ * declares `fieldOverrides.<key>.widget: 'group' | 'language' | 'timezone'`
+ * (or `'user'`) instead. The widget alone is not enough for the user and
+ * group pickers, which CnFormDialog recognises by `userPicker` /
+ * `groupPicker`, so set those here. An override may also carry its own
+ * `x-default` (`current-language`, `current-timezone`), which becomes the
+ * field's `defaultToken` just as the schema key does.
+ *
+ * Mutates `field` in place.
+ *
+ * @spec openspec/changes/review-round-two/specs/schema-utilities/spec.md
+ * @param {object} field The field descriptor, overrides already merged in.
+ * @param {object} override The raw override for this key.
+ * @return {void}
+ */
+function applyPickerOverride(field, override) {
+	if (!override || typeof override !== 'object') {
+		return
+	}
+	const widget = override.widget
+	if (widget === 'group' || widget === 'group-multiselect') {
+		field.groupPicker = { multiple: widget === 'group-multiselect' }
+		field.userPicker = null
+	} else if (widget === 'user' || widget === 'user-multiselect') {
+		field.userPicker = { multiple: widget === 'user-multiselect' }
+		field.groupPicker = null
+	}
+	if (typeof override['x-default'] === 'string' && override['x-default'] !== '') {
+		field.defaultToken = override['x-default']
+	}
 }
 
 /**
@@ -844,6 +881,7 @@ export function fieldsFromSchema(schema, options = {}) {
 		// Apply per-field overrides
 		if (overrides[key]) {
 			Object.assign(field, overrides[key])
+			applyPickerOverride(field, overrides[key])
 		}
 
 		return field