@conduction/nextcloud-vue 0.1.0-beta.1

package/src/css/utilities.css

@@ -0,0 +1,46 @@
+/* ========================================
+   @conduction/nextcloud-vue — Utilities
+   ======================================== */
+
+/* Text Utilities */
+.cn-text-ellipsis {
+	overflow: hidden;
+	text-overflow: ellipsis;
+	white-space: nowrap;
+}
+
+.cn-text-description {
+	font-size: 0.9em;
+	color: var(--color-text-maxcontrast);
+}
+
+.cn-text-success { color: var(--color-success); }
+.cn-text-error { color: var(--color-error); }
+.cn-text-warning { color: var(--color-warning); }
+.cn-text-muted { color: var(--color-text-maxcontrast); }
+
+/* Vue Transition Animations */
+.cn-slide-fade-enter-active {
+	transition: all 0.4s cubic-bezier(0.4, 0, 0.2, 1);
+}
+
+.cn-slide-fade-leave-active {
+	transition: all 0.3s cubic-bezier(0.4, 0, 1, 1);
+}
+
+.cn-slide-fade-enter,
+.cn-slide-fade-enter-from {
+	transform: translateY(-10px);
+	opacity: 0;
+}
+
+.cn-slide-fade-leave-to {
+	transform: translateY(-5px);
+	opacity: 0;
+}
+
+/* Backwards compatibility aliases */
+.textEllipsis { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.textDescription { font-size: 0.9em; color: var(--color-text-maxcontrast); }
+.successMessage { color: var(--color-success); }
+.errorMessage { color: var(--color-error); }

package/src/index.js

@@ -0,0 +1,50 @@
+// Components
+export {
+	CnDataTable,
+	CnFilterBar,
+	CnListViewLayout,
+	CnDetailViewLayout,
+	CnStatusBadge,
+	CnEmptyState,
+	CnPagination,
+	CnSettingsCard,
+	CnSettingsSection,
+	CnStatsBlock,
+	CnConfigurationCard,
+	CnVersionInfoCard,
+	CnCellRenderer,
+	CnObjectCard,
+	CnCardGrid,
+	CnFacetSidebar,
+	CnViewModeToggle,
+	CnRowActions,
+	CnIndexPage,
+	CnMassActionBar,
+	CnMassDeleteDialog,
+	CnMassCopyDialog,
+	CnKpiGrid,
+	CnMassExportDialog,
+	CnMassImportDialog,
+} from './components/index.js'
+
+// Store
+export { useObjectStore, createObjectStore } from './store/index.js'
+export { createSubResourcePlugin, emptyPaginated } from './store/index.js'
+
+// Store plugins
+export {
+	auditTrailsPlugin,
+	relationsPlugin,
+	filesPlugin,
+	lifecyclePlugin,
+} from './store/plugins/index.js'
+
+// Composables
+export { useListView, useDetailView, useSubResource } from './composables/index.js'
+
+// Utilities
+export { buildHeaders, buildQueryString, parseResponseError, networkError, genericError } from './utils/index.js'
+export { columnsFromSchema, formatValue, filtersFromSchema } from './utils/index.js'
+
+// CSS (consumers should import separately)
+// import '@conduction/nextcloud-vue/src/css/index.css'

package/src/store/createSubResourcePlugin.js

@@ -0,0 +1,135 @@
+import { buildHeaders, buildQueryString } from '../utils/headers.js'
+import { parseResponseError, networkError } from '../utils/errors.js'
+
+/**
+ * Standard empty paginated response shape used by all sub-resource plugins.
+ *
+ * @param {number} [limit=20] Default page size
+ * @return {object} Empty paginated state
+ */
+export function emptyPaginated(limit = 20) {
+	return { results: [], total: 0, page: 1, pages: 0, limit, offset: 0 }
+}
+
+/**
+ * Capitalize the first letter of a string.
+ *
+ * @param {string} str Input string
+ * @return {string} Capitalized string
+ */
+function capitalize(str) {
+	return str.charAt(0).toUpperCase() + str.slice(1)
+}
+
+/**
+ * Create a sub-resource plugin for the object store.
+ *
+ * Generates state, getters, and actions for a standard OpenRegister sub-resource
+ * endpoint that returns paginated results. The generated plugin follows the
+ * naming convention: fetch{Name}, clear{Name}, get{Name}, is{Name}Loading, etc.
+ *
+ * @param {string} name Camel-case name for the sub-resource (e.g. 'auditTrails')
+ * @param {string} endpoint URL path segment appended to the object URL (e.g. 'audit-trails')
+ * @param {object} [options={}] Plugin options
+ * @param {number} [options.limit=20] Default page size
+ * @return {Function} Plugin factory that returns the plugin definition
+ *
+ * @example
+ * // Simple read-only sub-resource
+ * export const auditTrailsPlugin = createSubResourcePlugin('auditTrails', 'audit-trails')
+ *
+ * @example
+ * // With custom limit
+ * export const contractsPlugin = createSubResourcePlugin('contracts', 'contracts', { limit: 50 })
+ *
+ * @example
+ * // Usage in store creation
+ * const useStore = createObjectStore('object', {
+ *   plugins: [auditTrailsPlugin()],
+ * })
+ * const store = useStore()
+ * await store.fetchAuditTrails('case', caseId)
+ * console.log(store.auditTrails.results)
+ */
+export function createSubResourcePlugin(name, endpoint, options = {}) {
+	const cap = capitalize(name)
+	const limit = options.limit || 20
+
+	return () => ({
+		name,
+
+		state: () => ({
+			[name]: emptyPaginated(limit),
+			[`${name}Loading`]: false,
+			[`${name}Error`]: null,
+		}),
+
+		getters: {
+			[`get${cap}`]: (state) => state[name],
+			[`is${cap}Loading`]: (state) => state[`${name}Loading`],
+			[`get${cap}Error`]: (state) => state[`${name}Error`],
+		},
+
+		actions: {
+			/**
+			 * Fetch the sub-resource collection for an object.
+			 *
+			 * @param {string} type The registered object type slug
+			 * @param {string} objectId The parent object ID
+			 * @param {object} [params={}] Query parameters (_search, _limit, _page)
+			 * @return {Promise<Array>} The fetched results
+			 */
+			async [`fetch${cap}`](type, objectId, params = {}) {
+				this[`${name}Loading`] = true
+				this[`${name}Error`] = null
+
+				try {
+					const url = this._buildUrl(type, objectId)
+						+ '/' + endpoint
+						+ buildQueryString(params)
+
+					const response = await fetch(url, {
+						method: 'GET',
+						headers: buildHeaders(),
+					})
+
+					if (!response.ok) {
+						this[`${name}Error`] = await parseResponseError(response, name)
+						console.error(`Error fetching ${name} for ${type}/${objectId}:`, this[`${name}Error`])
+						return []
+					}
+
+					const data = await response.json()
+
+					this[name] = {
+						results: data.results || data,
+						total: data.total || (data.results || data).length,
+						page: data.page || 1,
+						pages: data.pages || 0,
+						limit: params._limit || limit,
+						offset: data.offset || 0,
+					}
+
+					return this[name].results
+				} catch (error) {
+					this[`${name}Error`] = error.name === 'TypeError'
+						? networkError(error)
+						: { status: null, message: error.message, details: null, isValidation: false, fields: null, toString() { return this.message } }
+					console.error(`Error fetching ${name} for ${type}/${objectId}:`, error)
+					return []
+				} finally {
+					this[`${name}Loading`] = false
+				}
+			},
+
+			/**
+			 * Clear all sub-resource state back to empty defaults.
+			 */
+			[`clear${cap}`]() {
+				this[name] = emptyPaginated(limit)
+				this[`${name}Loading`] = false
+				this[`${name}Error`] = null
+			},
+		},
+	})
+}

package/src/store/index.js

@@ -0,0 +1,3 @@
+export { useObjectStore, createObjectStore } from './useObjectStore.js'
+export { createSubResourcePlugin, emptyPaginated } from './createSubResourcePlugin.js'
+export { auditTrailsPlugin, relationsPlugin, filesPlugin, lifecyclePlugin } from './plugins/index.js'

package/src/store/plugins/auditTrails.js

@@ -0,0 +1,17 @@
+import { createSubResourcePlugin } from '../createSubResourcePlugin.js'
+
+/**
+ * Audit trails plugin for the object store.
+ *
+ * Adds state, getters, and actions for fetching audit trail records
+ * for an object. Read-only — no create/update/delete.
+ *
+ * State: auditTrails, auditTrailsLoading, auditTrailsError
+ * Actions: fetchAuditTrails(type, objectId, params), clearAuditTrails()
+ * Getters: getAuditTrails, isAuditTrailsLoading, getAuditTrailsError
+ *
+ * @param {object} [options={}] Plugin options
+ * @param {number} [options.limit=20] Default page size
+ * @return {Function} Plugin factory
+ */
+export const auditTrailsPlugin = createSubResourcePlugin('auditTrails', 'audit-trails')

package/src/store/plugins/files.js

@@ -0,0 +1,186 @@
+import { createSubResourcePlugin } from '../createSubResourcePlugin.js'
+import { buildHeaders } from '../../utils/headers.js'
+import { parseResponseError, networkError } from '../../utils/errors.js'
+
+/**
+ * Files plugin for the object store.
+ *
+ * Extends the generic sub-resource with file-specific actions:
+ * upload (multipart), publish, unpublish, and delete.
+ *
+ * State: files, filesLoading, filesError
+ * Actions: fetchFiles, uploadFiles, publishFile, unpublishFile, deleteFile, clearFiles
+ * Getters: getFiles, isFilesLoading, getFilesError
+ *
+ * @param {object} [options={}] Plugin options
+ * @param {number} [options.limit=20] Default page size
+ * @return {Function} Plugin factory
+ *
+ * @example
+ * const useStore = createObjectStore('object', {
+ *   plugins: [filesPlugin()],
+ * })
+ * const store = useStore()
+ * await store.fetchFiles('case', caseId)
+ * await store.uploadFiles('case', caseId, formData)
+ * await store.publishFile('case', caseId, fileId)
+ */
+export function filesPlugin(options = {}) {
+	const base = createSubResourcePlugin('files', 'files', options)()
+
+	return {
+		...base,
+
+		actions: {
+			...base.actions,
+
+			/**
+			 * Upload files to an object via multipart form data.
+			 *
+			 * @param {string} type The registered object type slug
+			 * @param {string} objectId The parent object ID
+			 * @param {FormData} formData FormData with files[] and optional tags/share fields
+			 * @return {Promise<object|null>} Upload response or null on error
+			 */
+			async uploadFiles(type, objectId, formData) {
+				this.filesLoading = true
+				this.filesError = null
+
+				try {
+					const url = this._buildUrl(type, objectId) + '/filesMultipart'
+
+					const response = await fetch(url, {
+						method: 'POST',
+						headers: buildHeaders(null),
+						body: formData,
+					})
+
+					if (!response.ok) {
+						this.filesError = await parseResponseError(response, 'files')
+						console.error(`Error uploading files for ${type}/${objectId}:`, this.filesError)
+						return null
+					}
+
+					const data = await response.json()
+
+					await this.fetchFiles(type, objectId)
+
+					return data
+				} catch (error) {
+					this.filesError = error.name === 'TypeError'
+						? networkError(error)
+						: { status: null, message: error.message, details: null, isValidation: false, fields: null, toString() { return this.message } }
+					console.error(`Error uploading files for ${type}/${objectId}:`, error)
+					return null
+				} finally {
+					this.filesLoading = false
+				}
+			},
+
+			/**
+			 * Publish a file (make it publicly accessible).
+			 *
+			 * @param {string} type The registered object type slug
+			 * @param {string} objectId The parent object ID
+			 * @param {string} fileId The file ID to publish
+			 * @return {Promise<boolean>} True if published successfully
+			 */
+			async publishFile(type, objectId, fileId) {
+				this.filesLoading = true
+				this.filesError = null
+
+				try {
+					const url = this._buildUrl(type, objectId) + `/files/${fileId}/publish`
+
+					const response = await fetch(url, {
+						method: 'POST',
+						headers: buildHeaders(),
+					})
+
+					if (!response.ok) {
+						this.filesError = await parseResponseError(response, 'files')
+						return false
+					}
+
+					await this.fetchFiles(type, objectId)
+					return true
+				} catch (error) {
+					this.filesError = networkError(error)
+					return false
+				} finally {
+					this.filesLoading = false
+				}
+			},
+
+			/**
+			 * Unpublish a file (revoke public access).
+			 *
+			 * @param {string} type The registered object type slug
+			 * @param {string} objectId The parent object ID
+			 * @param {string} fileId The file ID to unpublish
+			 * @return {Promise<boolean>} True if unpublished successfully
+			 */
+			async unpublishFile(type, objectId, fileId) {
+				this.filesLoading = true
+				this.filesError = null
+
+				try {
+					const url = this._buildUrl(type, objectId) + `/files/${fileId}/depublish`
+
+					const response = await fetch(url, {
+						method: 'POST',
+						headers: buildHeaders(),
+					})
+
+					if (!response.ok) {
+						this.filesError = await parseResponseError(response, 'files')
+						return false
+					}
+
+					await this.fetchFiles(type, objectId)
+					return true
+				} catch (error) {
+					this.filesError = networkError(error)
+					return false
+				} finally {
+					this.filesLoading = false
+				}
+			},
+
+			/**
+			 * Delete a file from an object.
+			 *
+			 * @param {string} type The registered object type slug
+			 * @param {string} objectId The parent object ID
+			 * @param {string} fileId The file ID to delete
+			 * @return {Promise<boolean>} True if deleted successfully
+			 */
+			async deleteFile(type, objectId, fileId) {
+				this.filesLoading = true
+				this.filesError = null
+
+				try {
+					const url = this._buildUrl(type, objectId) + `/files/${fileId}`
+
+					const response = await fetch(url, {
+						method: 'DELETE',
+						headers: buildHeaders(),
+					})
+
+					if (!response.ok) {
+						this.filesError = await parseResponseError(response, 'files')
+						return false
+					}
+
+					await this.fetchFiles(type, objectId)
+					return true
+				} catch (error) {
+					this.filesError = networkError(error)
+					return false
+				} finally {
+					this.filesLoading = false
+				}
+			},
+		},
+	}
+}

package/src/store/plugins/index.js

@@ -0,0 +1,4 @@
+export { auditTrailsPlugin } from './auditTrails.js'
+export { relationsPlugin } from './relations.js'
+export { filesPlugin } from './files.js'
+export { lifecyclePlugin } from './lifecycle.js'

package/src/store/plugins/lifecycle.js

@@ -0,0 +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
+			},
+		},
+	}
+}

package/src/store/plugins/relations.js

@@ -0,0 +1,68 @@
+import { createSubResourcePlugin } from '../createSubResourcePlugin.js'
+
+/**
+ * Relations plugin for the object store.
+ *
+ * Adds three sub-resources for object relations:
+ * - contracts: contractual relations between objects
+ * - uses: outgoing references (this object uses other objects)
+ * - used: incoming references (other objects use this object)
+ *
+ * Each sub-resource gets its own state, loading, error, fetch, and clear.
+ */
+
+const contractsBase = createSubResourcePlugin('contracts', 'contracts')
+const usesBase = createSubResourcePlugin('uses', 'uses')
+const usedBase = createSubResourcePlugin('used', 'used')
+
+/**
+ * Combined relations plugin that registers contracts, uses, and used sub-resources.
+ *
+ * @param {object} [options={}] Plugin options
+ * @return {Function} Plugin factory
+ *
+ * @example
+ * const useStore = createObjectStore('object', {
+ *   plugins: [relationsPlugin()],
+ * })
+ * const store = useStore()
+ * await store.fetchContracts('case', caseId)
+ * await store.fetchUses('case', caseId)
+ * await store.fetchUsed('case', caseId)
+ */
+export function relationsPlugin(options = {}) {
+	const contracts = contractsBase(options)
+	const uses = usesBase(options)
+	const used = usedBase(options)
+
+	return {
+		name: 'Relations',
+
+		state: () => ({
+			...contracts.state(),
+			...uses.state(),
+			...used.state(),
+		}),
+
+		getters: {
+			...contracts.getters,
+			...uses.getters,
+			...used.getters,
+		},
+
+		actions: {
+			...contracts.actions,
+			...uses.actions,
+			...used.actions,
+
+			/**
+			 * Clear all relation sub-resources.
+			 */
+			clearRelations() {
+				this.clearContracts()
+				this.clearUses()
+				this.clearUsed()
+			},
+		},
+	}
+}