@conduction/nextcloud-vue 0.1.0-beta.1 → 0.1.0-beta.11

package/src/store/plugins/lifecycle.js

@@ -1,180 +1,180 @@
-import { buildHeaders } from '../../utils/headers.js'
-import { parseResponseError, networkError } from '../../utils/errors.js'
-
-/**
- * Lifecycle plugin for the object store.
- *
- * Adds object lifecycle actions: lock, unlock, publish, depublish, revert, merge.
- * These operate on the object itself (not sub-resources) but share the same
- * URL pattern: POST /{register}/{schema}/{objectId}/{action}
- *
- * State: lifecycleLoading, lifecycleError
- * Actions: lockObject, unlockObject, publishObject, depublishObject, revertObject, mergeObjects
- *
- * @return {Function} Plugin factory
- *
- * @example
- * const useStore = createObjectStore('object', {
- *   plugins: [lifecyclePlugin()],
- * })
- * const store = useStore()
- * await store.lockObject('case', caseId, { process: 'review', duration: 3600 })
- * await store.publishObject('case', caseId, { date: '2025-01-01' })
- */
-export function lifecyclePlugin() {
-	return {
-		name: 'Lifecycle',
-
-		state: () => ({
-			lifecycleLoading: false,
-			lifecycleError: null,
-		}),
-
-		getters: {
-			isLifecycleLoading: (state) => state.lifecycleLoading,
-			getLifecycleError: (state) => state.lifecycleError,
-		},
-
-		actions: {
-			/**
-			 * Perform a lifecycle action on an object.
-			 *
-			 * @param {string} type The registered object type slug
-			 * @param {string} objectId The object ID
-			 * @param {string} action The lifecycle action endpoint (e.g. 'lock', 'publish')
-			 * @param {object} [body=null] Optional request body
-			 * @return {Promise<object|null>} Response data or null on error
-			 */
-			async _lifecycleAction(type, objectId, action, body = null) {
-				this.lifecycleLoading = true
-				this.lifecycleError = null
-
-				try {
-					const url = this._buildUrl(type, objectId) + '/' + action
-					const options = {
-						method: 'POST',
-						headers: buildHeaders(),
-					}
-					if (body) {
-						options.body = JSON.stringify(body)
-					}
-
-					const response = await fetch(url, options)
-
-					if (!response.ok) {
-						this.lifecycleError = await parseResponseError(response, action)
-						console.error(`Error performing ${action} on ${type}/${objectId}:`, this.lifecycleError)
-						return null
-					}
-
-					const data = await response.json()
-
-					if (this.objects[type] && data.id) {
-						this.objects[type][data.id] = data
-					}
-
-					return data
-				} catch (error) {
-					this.lifecycleError = error.name === 'TypeError'
-						? networkError(error)
-						: { status: null, message: error.message, details: null, isValidation: false, fields: null, toString() { return this.message } }
-					console.error(`Error performing ${action} on ${type}/${objectId}:`, error)
-					return null
-				} finally {
-					this.lifecycleLoading = false
-				}
-			},
-
-			/**
-			 * Lock an object to prevent concurrent edits.
-			 *
-			 * @param {string} type The registered object type slug
-			 * @param {string} objectId The object ID
-			 * @param {object} options Lock options
-			 * @param {string} [options.process] Lock reason/process name
-			 * @param {number} [options.duration] Lock duration in seconds
-			 * @return {Promise<object|null>} Updated object or null on error
-			 */
-			async lockObject(type, objectId, options = {}) {
-				return this._lifecycleAction(type, objectId, 'lock', options)
-			},
-
-			/**
-			 * Unlock an object.
-			 *
-			 * @param {string} type The registered object type slug
-			 * @param {string} objectId The object ID
-			 * @return {Promise<object|null>} Updated object or null on error
-			 */
-			async unlockObject(type, objectId) {
-				return this._lifecycleAction(type, objectId, 'unlock')
-			},
-
-			/**
-			 * Publish an object (make it publicly accessible).
-			 *
-			 * @param {string} type The registered object type slug
-			 * @param {string} objectId The object ID
-			 * @param {object} [options={}] Publish options
-			 * @param {string} [options.date] Publish date (ISO 8601)
-			 * @return {Promise<object|null>} Updated object or null on error
-			 */
-			async publishObject(type, objectId, options = {}) {
-				return this._lifecycleAction(type, objectId, 'publish', options)
-			},
-
-			/**
-			 * Depublish an object (revoke public access).
-			 *
-			 * @param {string} type The registered object type slug
-			 * @param {string} objectId The object ID
-			 * @param {object} [options={}] Depublish options
-			 * @param {string} [options.date] Depublish date (ISO 8601)
-			 * @return {Promise<object|null>} Updated object or null on error
-			 */
-			async depublishObject(type, objectId, options = {}) {
-				return this._lifecycleAction(type, objectId, 'depublish', options)
-			},
-
-			/**
-			 * Revert an object to a previous version.
-			 *
-			 * @param {string} type The registered object type slug
-			 * @param {string} objectId The object ID
-			 * @param {object} options Revert options
-			 * @param {string} [options.datetime] Target datetime
-			 * @param {string} [options.auditTrailId] Audit trail entry ID to revert to
-			 * @param {number} [options.version] Target version number
-			 * @param {boolean} [options.overwriteVersion] Overwrite current version
-			 * @return {Promise<object|null>} Updated object or null on error
-			 */
-			async revertObject(type, objectId, options = {}) {
-				return this._lifecycleAction(type, objectId, 'revert', options)
-			},
-
-			/**
-			 * Merge two objects together.
-			 *
-			 * @param {string} type The registered object type slug
-			 * @param {string} sourceId The source object ID (will be merged into target)
-			 * @param {object} options Merge options
-			 * @param {string} options.target Target object ID
-			 * @param {string} [options.fileAction] How to handle files ('move'|'copy'|'skip')
-			 * @param {string} [options.relationAction] How to handle relations
-			 * @param {string} [options.referenceAction] How to handle references
-			 * @return {Promise<object|null>} Merge result or null on error
-			 */
-			async mergeObjects(type, sourceId, options = {}) {
-				return this._lifecycleAction(type, sourceId, 'merge', options)
-			},
-
-			/**
-			 * Clear lifecycle state.
-			 */
-			clearLifecycle() {
-				this.lifecycleLoading = false
-				this.lifecycleError = null
-			},
-		},
-	}
-}
+import { buildHeaders } from '../../utils/headers.js'
+import { parseResponseError, networkError } from '../../utils/errors.js'
+
+/**
+ * Lifecycle plugin for the object store.
+ *
+ * Adds object lifecycle actions: lock, unlock, publish, depublish, revert, merge.
+ * These operate on the object itself (not sub-resources) but share the same
+ * URL pattern: POST /{register}/{schema}/{objectId}/{action}
+ *
+ * State: lifecycleLoading, lifecycleError
+ * Actions: lockObject, unlockObject, publishObject, depublishObject, revertObject, mergeObjects
+ *
+ * @return {Function} Plugin factory
+ *
+ * @example
+ * const useStore = createObjectStore('object', {
+ *   plugins: [lifecyclePlugin()],
+ * })
+ * const store = useStore()
+ * await store.lockObject('case', caseId, { process: 'review', duration: 3600 })
+ * await store.publishObject('case', caseId, { date: '2025-01-01' })
+ */
+export function lifecyclePlugin() {
+	return {
+		name: 'Lifecycle',
+
+		state: () => ({
+			lifecycleLoading: false,
+			lifecycleError: null,
+		}),
+
+		getters: {
+			isLifecycleLoading: (state) => state.lifecycleLoading,
+			getLifecycleError: (state) => state.lifecycleError,
+		},
+
+		actions: {
+			/**
+			 * Perform a lifecycle action on an object.
+			 *
+			 * @param {string} type The registered object type slug
+			 * @param {string} objectId The object ID
+			 * @param {string} action The lifecycle action endpoint (e.g. 'lock', 'publish')
+			 * @param {object} [body] Optional request body
+			 * @return {Promise<object|null>} Response data or null on error
+			 */
+			async _lifecycleAction(type, objectId, action, body = null) {
+				this.lifecycleLoading = true
+				this.lifecycleError = null
+
+				try {
+					const url = this._buildUrl(type, objectId) + '/' + action
+					const options = {
+						method: 'POST',
+						headers: buildHeaders(),
+					}
+					if (body) {
+						options.body = JSON.stringify(body)
+					}
+
+					const response = await fetch(url, options)
+
+					if (!response.ok) {
+						this.lifecycleError = await parseResponseError(response, action)
+						console.error(`Error performing ${action} on ${type}/${objectId}:`, this.lifecycleError)
+						return null
+					}
+
+					const data = await response.json()
+
+					if (this.objects[type] && data.id) {
+						this.objects = { ...this.objects, [type]: { ...this.objects[type], [data.id]: data } }
+					}
+
+					return data
+				} catch (error) {
+					this.lifecycleError = error.name === 'TypeError'
+						? networkError(error)
+						: { status: null, message: error.message, details: null, isValidation: false, fields: null, toString() { return this.message } }
+					console.error(`Error performing ${action} on ${type}/${objectId}:`, error)
+					return null
+				} finally {
+					this.lifecycleLoading = false
+				}
+			},
+
+			/**
+			 * Lock an object to prevent concurrent edits.
+			 *
+			 * @param {string} type The registered object type slug
+			 * @param {string} objectId The object ID
+			 * @param {object} options Lock options
+			 * @param {string} [options.process] Lock reason/process name
+			 * @param {number} [options.duration] Lock duration in seconds
+			 * @return {Promise<object|null>} Updated object or null on error
+			 */
+			async lockObject(type, objectId, options = {}) {
+				return this._lifecycleAction(type, objectId, 'lock', options)
+			},
+
+			/**
+			 * Unlock an object.
+			 *
+			 * @param {string} type The registered object type slug
+			 * @param {string} objectId The object ID
+			 * @return {Promise<object|null>} Updated object or null on error
+			 */
+			async unlockObject(type, objectId) {
+				return this._lifecycleAction(type, objectId, 'unlock')
+			},
+
+			/**
+			 * Publish an object (make it publicly accessible).
+			 *
+			 * @param {string} type The registered object type slug
+			 * @param {string} objectId The object ID
+			 * @param {object} [options] Publish options
+			 * @param {string} [options.date] Publish date (ISO 8601)
+			 * @return {Promise<object|null>} Updated object or null on error
+			 */
+			async publishObject(type, objectId, options = {}) {
+				return this._lifecycleAction(type, objectId, 'publish', options)
+			},
+
+			/**
+			 * Depublish an object (revoke public access).
+			 *
+			 * @param {string} type The registered object type slug
+			 * @param {string} objectId The object ID
+			 * @param {object} [options] Depublish options
+			 * @param {string} [options.date] Depublish date (ISO 8601)
+			 * @return {Promise<object|null>} Updated object or null on error
+			 */
+			async depublishObject(type, objectId, options = {}) {
+				return this._lifecycleAction(type, objectId, 'depublish', options)
+			},
+
+			/**
+			 * Revert an object to a previous version.
+			 *
+			 * @param {string} type The registered object type slug
+			 * @param {string} objectId The object ID
+			 * @param {object} options Revert options
+			 * @param {string} [options.datetime] Target datetime
+			 * @param {string} [options.auditTrailId] Audit trail entry ID to revert to
+			 * @param {number} [options.version] Target version number
+			 * @param {boolean} [options.overwriteVersion] Overwrite current version
+			 * @return {Promise<object|null>} Updated object or null on error
+			 */
+			async revertObject(type, objectId, options = {}) {
+				return this._lifecycleAction(type, objectId, 'revert', options)
+			},
+
+			/**
+			 * Merge two objects together.
+			 *
+			 * @param {string} type The registered object type slug
+			 * @param {string} sourceId The source object ID (will be merged into target)
+			 * @param {object} options Merge options
+			 * @param {string} options.target Target object ID
+			 * @param {string} [options.fileAction] How to handle files ('move'|'copy'|'skip')
+			 * @param {string} [options.relationAction] How to handle relations
+			 * @param {string} [options.referenceAction] How to handle references
+			 * @return {Promise<object|null>} Merge result or null on error
+			 */
+			async mergeObjects(type, sourceId, options = {}) {
+				return this._lifecycleAction(type, sourceId, 'merge', options)
+			},
+
+			/**
+			 * Clear lifecycle state.
+			 */
+			clearLifecycle() {
+				this.lifecycleLoading = false
+				this.lifecycleError = null
+			},
+		},
+	}
+}

package/src/store/plugins/logs.d.ts

@@ -0,0 +1,22 @@
+import type { CrudPlugin } from '../createCrudStore'
+
+export interface LogsPluginOptions {
+	/** Required. Query-param name carrying the active item's id (e.g. 'source_id'). */
+	parentIdParam: string
+	/** Path segment appended to the store's base API URL. Default: 'logs'. */
+	path?: string
+	/** Default query params merged before caller-supplied filters. Default: `{ '_sort[created]': 'desc' }`. */
+	defaultSort?: Record<string, string>
+	/**
+	 * When true, the plugin's `setup` hook registers a `store.$onAction`
+	 * subscriber that auto-fires `refreshLogs()` after every `setItem` with
+	 * an id (or `clearLogs()` when the item is cleared). Composes with other
+	 * plugins that observe `setItem`.
+	 */
+	autoRefreshOnItemChange?: boolean
+}
+
+/**
+ * Create a logs sub-resource plugin for a `createCrudStore`.
+ */
+export function logsPlugin(options: LogsPluginOptions): CrudPlugin

package/src/store/plugins/logs.js

@@ -0,0 +1,172 @@
+import { buildHeaders, buildQueryString } from '../../utils/headers.js'
+import { parseResponseError, networkError, genericError } from '../../utils/errors.js'
+
+/**
+ * Logs sub-resource plugin for createCrudStore.
+ *
+ * Many apps expose a logs collection keyed off the parent resource ID, via a
+ * flat endpoint like `/sources/logs?source_id=<id>`. This plugin generates the
+ * standard state, getters, and actions for that pattern so consumer stores
+ * don't have to re-implement the same fetch/refresh logic.
+ *
+ * **Contributed state**
+ * - `logs` — last fetched response (raw array or `{ results, ... }` shape)
+ * - `logsLoading` — per-store loading flag
+ * - `logsError` — last error (`ApiError` or null)
+ *
+ * **Contributed getters**
+ * - `getLogs`, `isLogsLoading`, `getLogsError`
+ *
+ * **Contributed actions**
+ * - `refreshLogs(filters?)` — fetch and store; returns `{ response, data }`
+ * - `setLogs(data)` — replace state directly
+ * - `clearLogs()` — reset to empty
+ *
+ * When `autoRefreshOnItemChange: true`, the plugin registers a
+ * `store.$onAction` subscriber in its `setup` hook that observes `setItem`
+ * and triggers `refreshLogs()` / `clearLogs()` after the action resolves.
+ * This composes cleanly with other plugins that also want to observe
+ * `setItem` — none of them have to override the action.
+ *
+ * **URL construction**
+ * - `this._options.baseApiUrl + '/' + path` → e.g. `/sources/logs`
+ * - Query params: `{ [parentIdParam]: item.id, ...defaultSort, ...filters }` —
+ *   caller-supplied filters always win.
+ *
+ * @param {object} options Plugin options
+ * @param {string} options.parentIdParam Required. Query param name carrying the
+ *   parent resource's id — e.g. `'source_id'` for a sources store.
+ * @param {string} [options.path] Path segment appended to the store's base API
+ *   URL. Default: `'logs'`.
+ * @param {object} [options.defaultSort] Default query params merged before
+ *   user filters. Default: `{ '_sort[created]': 'desc' }`.
+ * @param {boolean} [options.autoRefreshOnItemChange] When true, overrides
+ *   `setItem` so selecting a new item automatically refreshes logs. Default:
+ *   `false`.
+ * @return {object} Plugin definition consumed by `createCrudStore`.
+ *
+ * @example
+ * import { createCrudStore, logsPlugin } from '@conduction/nextcloud-vue'
+ *
+ * export const useSourceStore = createCrudStore('source', {
+ *     endpoint: 'sources',
+ *     entity: Source,
+ *     plugins: [logsPlugin({ parentIdParam: 'source_id', autoRefreshOnItemChange: true })],
+ * })
+ *
+ * // Later
+ * const store = useSourceStore()
+ * await store.refreshLogs({ '_limit': 50 })
+ * console.log(store.logs, store.logsLoading)
+ */
+export function logsPlugin(options = {}) {
+	const {
+		parentIdParam,
+		path = 'logs',
+		defaultSort = { '_sort[created]': 'desc' },
+		autoRefreshOnItemChange = false,
+	} = options
+
+	if (!parentIdParam) {
+		throw new Error('logsPlugin: options.parentIdParam is required')
+	}
+
+	const actions = {
+		/**
+		 * Fetch logs for the current item from the logs endpoint.
+		 *
+		 * @param {object} [filters] Extra query params (override defaults).
+		 * @return {Promise<{ response: Response, data: unknown }>}
+		 */
+		async refreshLogs(filters = {}) {
+			this.logsLoading = true
+			this.logsError = null
+
+			try {
+				const params = { ...defaultSort }
+				if (!(parentIdParam in filters) && this.item?.id != null) {
+					params[parentIdParam] = String(this.item.id)
+				}
+				Object.assign(params, filters)
+
+				const url = this._options.baseApiUrl + '/' + path + buildQueryString(params)
+				const response = await fetch(url, {
+					method: 'GET',
+					headers: buildHeaders(),
+				})
+
+				if (!response.ok) {
+					this.logsError = await parseResponseError(response, 'logs')
+					return { response, data: null }
+				}
+
+				const data = await response.json()
+				this.logs = data
+				return { response, data }
+			} catch (error) {
+				this.logsError = error?.name === 'TypeError'
+					? networkError(error)
+					: genericError(error)
+				throw error
+			} finally {
+				this.logsLoading = false
+			}
+		},
+
+		/**
+		 * Replace the logs state directly (e.g. when a parent action returned
+		 * logs as a side effect).
+		 *
+		 * @param {unknown} data Response data (array or `{ results, ... }`).
+		 */
+		setLogs(data) {
+			this.logs = data
+		},
+
+		/**
+		 * Reset logs state back to empty defaults.
+		 */
+		clearLogs() {
+			this.logs = []
+			this.logsLoading = false
+			this.logsError = null
+		},
+	}
+
+	const plugin = {
+		name: 'logs',
+
+		state: () => ({
+			logs: [],
+			logsLoading: false,
+			logsError: null,
+		}),
+
+		getters: {
+			getLogs: (state) => state.logs,
+			isLogsLoading: (state) => state.logsLoading,
+			getLogsError: (state) => state.logsError,
+		},
+
+		actions,
+	}
+
+	if (autoRefreshOnItemChange) {
+		plugin.setup = function setup(store) {
+			store.$onAction(({ name, after }) => {
+				if (name !== 'setItem') return
+				after(() => {
+					if (store.item?.id != null) {
+						store.refreshLogs().catch((error) => {
+							console.error('logsPlugin: auto-refresh failed:', error)
+						})
+					} else {
+						store.clearLogs()
+					}
+				})
+			})
+		}
+	}
+
+	return plugin
+}