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

package/dist/esm/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.
 	 *
@@ -585,9 +656,12 @@ const baseActions = {
 	 *
 	 * @param {string} type The registered type slug
 	 * @param {object} [params] Query parameters (_limit, _page, _search, _order, filters)
+	 * @param {object} [options] Call options
+	 * @param {{error?: object|null}} [options.outcome] Opt-in sink for THIS call's own result: `error` is set to the error it records on `errors[type]`, or `null` on success. Unlike `errors[type]`, which every call for the type shares, a later call cannot overwrite it.
 	 * @return {Promise<Array>} The fetched collection (also stored in state)
 	 */
-	async fetchCollection(type, params = {}) {
+	async fetchCollection(type, params = {}, options = {}) {
+		const outcome = (options && typeof options.outcome === 'object' && options.outcome) || null;
 		this.loading = { ...this.loading, [type]: true };
 		this.errors = { ...this.errors, [type]: null };
 
@@ -604,17 +678,23 @@ 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) };
+				const failure = await parseResponseError(response, type);
+				this.errors = { ...this.errors, [type]: failure };
+				if (outcome) {
+					outcome.error = failure;
+				}
 				// eslint-disable-next-line no-console -- diagnostic for a failure this code already degrades from
-				console.error(`Error fetching ${type} collection:`, this.errors[type]);
+				console.error(`Error fetching ${type} collection:`, failure);
 				return []
 			}
 
@@ -638,14 +718,18 @@ const baseActions = {
 				this.facets = { ...this.facets, [type]: transformed };
 			}
 
+			if (outcome) {
+				outcome.error = null;
+			}
 			return results
 		} catch (error) {
-			this.errors = {
-				...this.errors,
-				[type]: error.name === 'TypeError'
-					? networkError(error)
-					: genericError(error),
-			};
+			const failure = error.name === 'TypeError'
+				? networkError(error)
+				: genericError(error);
+			this.errors = { ...this.errors, [type]: failure };
+			if (outcome) {
+				outcome.error = failure;
+			}
 			// eslint-disable-next-line no-console -- diagnostic for a failure this code already degrades from
 			console.error(`Error fetching ${type} collection:`, error);
 			return []
@@ -675,11 +759,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 +821,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 +896,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 +960,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) };