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

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/registerMapping.js

@@ -0,0 +1,195 @@
+import { buildHeaders, prefixUrl } from '../../utils/headers.js'
+
+/**
+ * Register mapping plugin for the object store.
+ *
+ * Adds state and actions for fetching OpenRegister registers and their
+ * schemas, used by CnRegisterMapping to populate dropdowns.
+ *
+ * State: registers, registerSchemas, registersLoading, registersError
+ * Actions: fetchRegisters, fetchSchemasForRegister, clearRegisterMapping
+ * Getters: getRegisters, registerOptions, schemaOptions, isRegistersLoading, getRegistersError
+ *
+ * @return {Function} Plugin factory
+ *
+ * @example
+ * const useStore = createObjectStore('object', {
+ *   plugins: [registerMappingPlugin()],
+ * })
+ * const store = useStore()
+ * await store.fetchRegisters()
+ * const options = store.registerOptions       // [{ label, value }]
+ * const schemas = store.schemaOptions('5')    // [{ label, value }]
+ */
+export function registerMappingPlugin() {
+	return {
+		name: 'RegisterMapping',
+
+		state: () => ({
+			/** @type {Array} All available registers from OpenRegister */
+			registers: [],
+			/** @type {{[key: string]: Array}} Schemas keyed by register ID */
+			registerSchemas: {},
+			/** @type {boolean} Whether registers are being fetched */
+			registersLoading: false,
+			/** @type {string|null} Error message from last fetch */
+			registersError: null,
+		}),
+
+		getters: {
+			/**
+			 * @param {object} state - Pinia state
+			 * @return {Array} Raw register list
+			 */
+			getRegisters: (state) => state.registers,
+
+			/**
+			 * @param {object} state - Pinia state
+			 * @return {boolean} Whether registers are loading
+			 */
+			isRegistersLoading: (state) => state.registersLoading,
+
+			/**
+			 * @param {object} state - Pinia state
+			 * @return {string|null} Last error
+			 */
+			getRegistersError: (state) => state.registersError,
+
+			/**
+			 * Registers as NcSelect-compatible options.
+			 *
+			 * @param {object} state - Pinia state
+			 * @return {Array<{label: string, value: string}>}
+			 */
+			registerOptions: (state) => state.registers.map((r) => ({
+				label: r.title || r.slug || `Register ${r.id}`,
+				value: String(r.id),
+			})),
+		},
+
+		actions: {
+			/**
+			 * Get schemas for a register as NcSelect options.
+			 *
+			 * @param {string|number} registerId Register ID
+			 * @return {Array<{label: string, value: string}>}
+			 */
+			schemaOptions(registerId) {
+				const id = String(registerId)
+				return (this.registerSchemas[id] || []).map((s) => ({
+					label: s.title || s.slug || `Schema ${s.id}`,
+					value: String(s.id),
+				}))
+			},
+
+			/**
+			 * Fetch all registers from OpenRegister with expanded schemas.
+			 *
+			 * @param {boolean} [withSchemas] Include schemas in response
+			 * @return {Promise<Array>} Fetched registers
+			 */
+			async fetchRegisters(withSchemas = true) {
+				this.registersLoading = true
+				this.registersError = null
+
+				try {
+					let url = prefixUrl('/apps/openregister/api/registers')
+					if (withSchemas) {
+						url += '?_extend[]=schemas'
+					}
+
+					const response = await fetch(url, {
+						method: 'GET',
+						headers: buildHeaders(),
+					})
+
+					if (!response.ok) {
+						this.registersError = `Failed to fetch registers: ${response.statusText}`
+						return []
+					}
+
+					const data = await response.json()
+					const results = data.results || data
+					this.registers = Array.isArray(results) ? results : []
+
+					// Cache expanded schemas by register ID
+					if (withSchemas) {
+						for (const reg of this.registers) {
+							if (Array.isArray(reg.schemas) && reg.schemas.length > 0) {
+								this.registerSchemas = {
+									...this.registerSchemas,
+									[String(reg.id)]: reg.schemas.filter(
+										(s) => s && typeof s === 'object' && s.id,
+									),
+								}
+							}
+						}
+					}
+
+					return this.registers
+				} catch (error) {
+					this.registersError = error.message || 'Network error fetching registers'
+					return []
+				} finally {
+					this.registersLoading = false
+				}
+			},
+
+			/**
+			 * Fetch schemas for a specific register.
+			 * Returns cached data if already fetched via expanded registers.
+			 *
+			 * @param {string|number} registerId Register ID
+			 * @return {Promise<Array>} Schemas for the register
+			 */
+			async fetchSchemasForRegister(registerId) {
+				const id = String(registerId)
+
+				// Return cached if available and non-empty
+				if (this.registerSchemas[id]?.length > 0) {
+					return this.registerSchemas[id]
+				}
+
+				// Check registers array for expanded schemas
+				const register = this.registers.find((r) => String(r.id) === id)
+				if (register?.schemas?.length > 0) {
+					const schemas = register.schemas.filter(
+						(s) => s && typeof s === 'object' && s.id,
+					)
+					if (schemas.length > 0) {
+						this.registerSchemas = { ...this.registerSchemas, [id]: schemas }
+						return schemas
+					}
+				}
+
+				// Fetch from API as fallback
+				try {
+					const response = await fetch(
+						prefixUrl(`/apps/openregister/api/registers/${id}?_extend[]=schemas`),
+						{ method: 'GET', headers: buildHeaders() },
+					)
+					if (!response.ok) return []
+
+					const data = await response.json()
+					const schemas = (data.schemas || []).filter(
+						(s) => s && typeof s === 'object' && s.id,
+					)
+					this.registerSchemas = { ...this.registerSchemas, [id]: schemas }
+					return schemas
+				} catch {
+					return []
+				}
+			},
+
+			/**
+			 * Clear all register mapping state.
+			 */
+			clearRegisterMapping() {
+				this.registers = []
+				this.registerSchemas = {}
+				this.registersLoading = false
+				this.registersError = null
+			},
+		},
+	}
+}