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

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
+}

package/src/store/useObjectStore.js

@@ -2,6 +2,7 @@ import { defineStore } from 'pinia'
 import { buildHeaders, buildQueryString, prefixUrl, capitalize } from '../utils/headers.js'
 import { parseResponseError, networkError, genericError } from '../utils/errors.js'
 import { extractId } from '../utils/id.js'
+import { mergePluginState, mergePluginGetters, mergePluginActions } from './pluginMerge.js'
 
 /**
  * Generic Pinia store for OpenRegister object CRUD operations.
@@ -26,54 +27,6 @@ import { extractId } from '../utils/id.js'
 const DEFAULT_STORE_ID = 'conduction-objects'
 const DEFAULT_BASE_URL = '/apps/openregister/api/objects'
 
-/**
- * Merge plugin state factories into a single state object.
- *
- * @param {Array} plugins Array of plugin definitions
- * @return {object} Merged state object
- */
-function mergePluginState(plugins) {
-	const merged = {}
-	for (const plugin of plugins) {
-		if (plugin.state) {
-			Object.assign(merged, plugin.state())
-		}
-	}
-	return merged
-}
-
-/**
- * Merge plugin getters into a single getters object.
- *
- * @param {Array} plugins Array of plugin definitions
- * @return {object} Merged getters object
- */
-function mergePluginGetters(plugins) {
-	const merged = {}
-	for (const plugin of plugins) {
-		if (plugin.getters) {
-			Object.assign(merged, plugin.getters)
-		}
-	}
-	return merged
-}
-
-/**
- * Merge plugin actions into a single actions object.
- *
- * @param {Array} plugins Array of plugin definitions
- * @return {object} Merged actions object
- */
-function mergePluginActions(plugins) {
-	const merged = {}
-	for (const plugin of plugins) {
-		if (plugin.actions) {
-			Object.assign(merged, plugin.actions)
-		}
-	}
-	return merged
-}
-
 // ── Base state ──────────────────────────────────────────────────────────
 
 function baseState(baseUrl = DEFAULT_BASE_URL) {
@@ -750,8 +703,10 @@ function defineObjectStore(storeId, plugins = [], baseUrl = DEFAULT_BASE_URL) {
 	const pluginState = mergePluginState(plugins)
 	const pluginGetters = mergePluginGetters(plugins)
 	const pluginActions = mergePluginActions(plugins)
+	const setupPlugins = plugins.filter((p) => typeof p.setup === 'function')
+	const initialized = new WeakSet()
 
-	return defineStore(storeId, {
+	const useStore = defineStore(storeId, {
 		state: () => ({
 			...baseState(baseUrl),
 			...pluginState,
@@ -780,6 +735,21 @@ function defineObjectStore(storeId, plugins = [], baseUrl = DEFAULT_BASE_URL) {
 			},
 		},
 	})
+
+	if (setupPlugins.length === 0) {
+		return useStore
+	}
+
+	return function useObjectStoreWithSetup(pinia) {
+		const store = useStore(pinia)
+		if (!initialized.has(store)) {
+			initialized.add(store)
+			for (const plugin of setupPlugins) {
+				plugin.setup(store)
+			}
+		}
+		return store
+	}
 }
 
 /**

package/src/types/index.d.ts

@@ -33,3 +33,35 @@ export type { TOrganisation, TOrganisationAuthorization } from './organisation'
 export type { TFile } from './file'
 export type { TTask, TTaskPriority, TTaskStatus } from './task'
 export type { TNotification, TNotificationType, TNotificationPriority } from './notification'
+
+// Runtime exports from the store factory. The implementation is in
+// `../store/createCrudStore.js`; its companion `createCrudStore.d.ts`
+// provides full generic types (entity inference, feature-flag gating,
+// extend merging with correct `this` typing). We re-export both the
+// factory and its supporting types so consumers can `import type
+// { BaseState, MergedActions, Features } from '@conduction/nextcloud-vue'`.
+export { createCrudStore } from '../store/createCrudStore'
+export type {
+	Prettify,
+	EntityClass,
+	InferEntity,
+	Features,
+	LoadingState,
+	ViewModeState,
+	LoadingGetters,
+	ViewModeGetters,
+	ViewModeActions,
+	BaseState,
+	BaseActions,
+	MergedActions,
+	FullState,
+	FullGetters,
+	StoreThis,
+	ExtendConfig,
+	CrudConfig,
+	CrudPlugin,
+} from '../store/createCrudStore'
+
+// Runtime store plugins. Each plugin is a factory returning a plugin definition
+// consumed by `createCrudStore({ plugins: [...] })` or `createObjectStore`.
+export { logsPlugin } from '../store/plugins/logs'

package/src/utils/schema.js

@@ -323,8 +323,9 @@ export function fieldsFromSchema(schema, options = {}) {
 			if (exclude.includes(key)) return false
 			// Apply include whitelist
 			if (include && !include.includes(key)) return false
-			// Skip complex object types (not supported in auto-form)
-			if (prop.type === 'object') return false
+			// Skip complex object types unless the caller opts in with an explicit widget
+			// (e.g. `widget: 'json'` or `widget: 'code'` in CnFormDialog).
+			if (prop.type === 'object' && !prop.widget) return false
 			return true
 		})
 		.sort(([keyA, propA], [keyB, propB]) => {