@quazardous/qdadm 2.4.4 → 2.5.0

package/README.md

@@ -137,6 +137,8 @@ This is the canonical Vite/Webpack pattern for Vue plugin singletons. The `file:
 
 Installing qdadm from npm (`@quazardous/qdadm@^1.19.3`) doesn't have this issue: the published tarball ships no `node_modules/`, so peers always resolve from the host. The trap is specific to `file:` / `workspace:` links onto a package that lives inside another monorepo.
 
+One more caveat: qdadm ships TypeScript sources, so with a `file:` link your `vue-tsc` / lint / test counters measure qdadm's **working tree**, not a released version. Any local qdadm edit moves your numbers with zero change on your side — don't calibrate quality ratchets or CI thresholds against a linked checkout; pin them to the published package your CI actually installs.
+
 ## License
 
 MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quazardous/qdadm",
-  "version": "2.4.4",
+  "version": "2.5.0",
   "description": "Vue 3 framework for admin dashboards with PrimeVue",
   "author": "quazardous",
   "license": "MIT",

package/src/components/editors/VanillaJsonEditor.vue

@@ -22,7 +22,13 @@ type JsonValue = Record<string, unknown> | unknown[] | string | null
 
 interface Props {
   modelValue?: JsonValue
-  mode?: Mode
+  /**
+   * Editor mode. String literals are accepted (#1253) so consumers never
+   * need to import the `Mode` enum from vanilla-jsoneditor (which is not
+   * a direct dependency of theirs); `Mode` itself is re-exported from
+   * '@quazardous/qdadm/editors' for those who want it.
+   */
+  mode?: Mode | 'tree' | 'text' | 'table'
   height?: string
   readOnly?: boolean
   mainMenuBar?: boolean
@@ -40,7 +46,7 @@ interface Props {
 
 const props = withDefaults(defineProps<Props>(), {
   modelValue: () => ({}),
-  mode: 'tree' as Mode,
+  mode: 'tree',
   height: '400px',
   readOnly: false,
   mainMenuBar: true,
@@ -100,7 +106,7 @@ onMounted(() => {
     target: containerRef.value,
     props: {
       content,
-      mode: props.mode,
+      mode: props.mode as Mode,
       readOnly: props.readOnly,
       mainMenuBar: props.mainMenuBar,
       navigationBar: props.navigationBar,
@@ -161,9 +167,9 @@ watch(() => props.modelValue, (newVal: JsonValue | undefined) => {
 }, { deep: true })
 
 // Watch mode changes
-watch(() => props.mode, (newMode: Mode | undefined) => {
+watch(() => props.mode, (newMode) => {
   if (editor && newMode) {
-    editor.updateProps({ mode: newMode })
+    editor.updateProps({ mode: newMode as Mode })
   }
 })
 

package/src/composables/useListPage.ts

@@ -35,6 +35,7 @@ import { useEntityItemPage, type ParentConfig, type UseEntityItemPageReturn } fr
 import { useActiveStack } from '../chain/useActiveStack.js'
 import { useI18n } from '../i18n/useI18n'
 import { formatDateOnly } from '../utils/formatters'
+import { humanizeFieldName } from '../utils/humanize'
 
 // Import types from dedicated types file
 import type {
@@ -294,6 +295,42 @@ export function useListPage<T = unknown>(config: UseListPageOptions<T>): UseList
     }
   })
 
+  /**
+   * Template-side column binding helper (#1255): spread onto a PrimeVue
+   * `<Column>` so `field` + `header` come from one source instead of being
+   * retyped in every list template:
+   *
+   * ```html
+   * <Column v-bind="list.column('botUuid')" sortable>
+   *   <template #body="{ data }">...</template>
+   * </Column>
+   * ```
+   *
+   * Header resolution: i18n key (`entities.{entity}.fields.{field}`) >
+   * `overrides.header` > inline header given to `addColumn` >
+   * `manager.fields[name].label` > humanized field name. Pure read — it
+   * never registers into columnsMap, so calling it during render is safe.
+   */
+  function column(name: string, overrides: Partial<ColumnConfig> = {}): ColumnConfig {
+    // Depend on the locale so headers re-render on locale change.
+    void i18nLocale.value
+
+    let header: string | undefined
+    if (entity && kernelI18n) {
+      const trace = kernelI18n.resolve(`entities.${entity}.fields.${name}`)
+      if (trace.hit) header = trace.result
+    }
+    const fieldConfig = manager.getFieldConfig?.(name) as { label?: string } | null | undefined
+    header ??=
+      overrides.header ??
+      columnInlineHeaders.get(name) ??
+      fieldConfig?.label ??
+      humanizeFieldName(name)
+
+    const registered = columnsMap.value.get(name)
+    return { ...registered, ...overrides, field: name, header }
+  }
+
   function removeColumn(field: string): void {
     columnsMap.value.delete(field)
   }
@@ -1111,6 +1148,7 @@ export function useListPage<T = unknown>(config: UseListPageOptions<T>): UseList
 
     // Columns
     columns,
+    column,
     addColumn,
     removeColumn,
     updateColumn,

package/src/composables/useListPage.types.ts

@@ -347,6 +347,8 @@ export interface UseListPageReturn<T = unknown> {
 
   // Columns
   columns: ComputedRef<ColumnConfig[]>
+  /** v-bind column binding helper (#1255): field + header from one source */
+  column: (name: string, overrides?: Partial<ColumnConfig>) => ColumnConfig
   addColumn: (field: string, config?: Partial<ColumnConfig>) => void
   removeColumn: (field: string) => void
   updateColumn: (field: string, updates: Partial<ColumnConfig>) => void

package/src/editors/index.ts

@@ -10,3 +10,8 @@
 
 export { default as VanillaJsonEditor } from '../components/editors/VanillaJsonEditor.vue'
 export { default as JsonStructuredField } from '../components/editors/JsonStructuredField.vue'
+
+// Re-export the mode enum so consumers who want it don't need to depend on
+// vanilla-jsoneditor directly (#1253). String literals ('tree' | 'text' |
+// 'table') are accepted by VanillaJsonEditor's `mode` prop anyway.
+export { Mode } from 'vanilla-jsoneditor'

package/src/entity/EntityManager.interface.ts

@@ -60,6 +60,8 @@ export interface EntityManagerRead<T = unknown> extends EntityManagerBase<T>, En
   request: (method: string, path: string, options?: { data?: unknown }) => Promise<unknown>
   invalidateCache?: () => void
   localFilterThreshold?: number
+  /** Field config lookup — read-side too since list column binding (#1255) */
+  getFieldConfig?: (name: string) => unknown | null
 }
 
 // ─── CRUD ────────────────────────────────────────────────────────────────────

package/src/entity/EntityManager.ts

@@ -34,6 +34,8 @@ import type { NullSortMode } from '../query/clientFilter'
 
 // Re-export public types from types file
 export type {
+  StorageResolution,
+  ResolvedStorage,
   RoutingContext,
   PresaveContext,
   PostsaveContext,
@@ -501,10 +503,7 @@ export class EntityManager<T extends EntityRecord = EntityRecord> {
    * Check if SecurityChecker is configured via authAdapter
    */
   protected _hasSecurityChecker(): boolean {
-    return (
-      (this.authAdapter as unknown as { _securityChecker?: unknown })
-        ?._securityChecker != null
-    )
+    return this.authAdapter?.hasSecurityChecker?.() ?? false
   }
 
   /**

package/src/entity/auth/EntityAuthAdapter.ts

@@ -41,6 +41,16 @@ export class EntityAuthAdapter {
     this._securityChecker = checker
   }
 
+  /**
+   * Whether a SecurityChecker is configured (#1196).
+   *
+   * Public capability probe — EntityManager used to reach into the
+   * private _securityChecker field through a cast.
+   */
+  hasSecurityChecker(): boolean {
+    return this._securityChecker != null
+  }
+
   /**
    * Check if current user is granted an attribute (Symfony-like contract)
    *

package/src/entity/auth/SecurityChecker.ts

@@ -52,28 +52,24 @@ export interface SecurityCheckerConfig {
  */
 export class SecurityChecker {
   protected _rolesProvider: RoleProvider
-  protected _legacyRoleHierarchy: RoleHierarchy | null
   readonly getCurrentUser: () => AuthUser | null
 
   constructor({ rolesProvider, roleHierarchy, rolePermissions, getCurrentUser }: SecurityCheckerOptions) {
-    // Support both new rolesProvider and legacy rolePermissions
     if (rolesProvider) {
       this._rolesProvider = rolesProvider
-      this._legacyRoleHierarchy = null
     } else {
-      // Legacy: create static provider from rolePermissions
+      // Legacy options (roleHierarchy/rolePermissions) are normalized ONCE
+      // into a static provider (#1196) — the parallel _legacyRoleHierarchy
+      // branch is gone; only the provider path remains.
       const hierarchyConfig =
-        roleHierarchy instanceof RoleHierarchy ? {} : (roleHierarchy as RoleHierarchyConfig) || {}
+        roleHierarchy instanceof RoleHierarchy
+          ? roleHierarchy.map
+          : (roleHierarchy as RoleHierarchyConfig) || {}
 
       this._rolesProvider = new StaticRoleProvider({
         role_hierarchy: hierarchyConfig,
         role_permissions: rolePermissions || {},
       })
-
-      this._legacyRoleHierarchy =
-        roleHierarchy instanceof RoleHierarchy
-          ? roleHierarchy
-          : new RoleHierarchy(hierarchyConfig)
     }
 
     this.getCurrentUser = getCurrentUser
@@ -83,9 +79,6 @@ export class SecurityChecker {
    * Get role hierarchy (dynamically resolved from rolesProvider)
    */
   get roleHierarchy(): RoleHierarchy {
-    if (this._legacyRoleHierarchy) {
-      return this._legacyRoleHierarchy
-    }
     return new RoleHierarchy(this._rolesProvider.getHierarchy())
   }
 

package/src/gen/connectors/OpenAPIConnector.test.js

@@ -1,4 +1,4 @@
-import { describe, it, expect } from 'vitest'
+import { describe, it, expect, vi } from 'vitest'
 import { OpenAPIConnector } from './OpenAPIConnector'
 import sampleSpec from './__fixtures__/sample-openapi.json'
 
@@ -584,6 +584,258 @@ describe('OpenAPIConnector', () => {
 
       expect(result.warnings.some(w => w.code === 'UNRESOLVED_REF')).toBe(true)
     })
+
+    describe('EMPTY_OBJECT_SCHEMA detection (#1240)', () => {
+      // Build a spec with a single tasks entity whose `payload` field uses
+      // the given schema node.
+      function specWithPayload(payloadSchema) {
+        return {
+          openapi: '3.0.0',
+          paths: {
+            '/api/tasks/{id}': {
+              get: {
+                responses: {
+                  '200': {
+                    content: {
+                      'application/json': {
+                        schema: {
+                          type: 'object',
+                          properties: {
+                            data: {
+                              type: 'object',
+                              properties: {
+                                id: { type: 'string' },
+                                payload: payloadSchema
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+
+      function warningsFor(payloadSchema) {
+        const connector = new OpenAPIConnector()
+        const result = connector.parseWithWarnings(specWithPayload(payloadSchema))
+        return result.warnings.filter(w => w.code === 'EMPTY_OBJECT_SCHEMA')
+      }
+
+      it('warns on a bare object schema (no properties, no additionalProperties)', () => {
+        const warnings = warningsFor({ type: 'object' })
+        expect(warnings).toHaveLength(1)
+        expect(warnings[0].path).toBe('/api/tasks/{id}#payload')
+        expect(warnings[0].message).toContain('additionalProperties: true')
+      })
+
+      it('warns when properties is present but empty', () => {
+        expect(warningsFor({ type: 'object', properties: {} })).toHaveLength(1)
+      })
+
+      it('does not warn when additionalProperties is true', () => {
+        expect(warningsFor({ type: 'object', additionalProperties: true })).toHaveLength(0)
+      })
+
+      it('does not warn when additionalProperties is a sub-schema', () => {
+        expect(
+          warningsFor({ type: 'object', additionalProperties: { type: 'string' } })
+        ).toHaveLength(0)
+      })
+
+      it('does not warn when the object declares properties', () => {
+        expect(
+          warningsFor({ type: 'object', properties: { targets: { type: 'array' } } })
+        ).toHaveLength(0)
+      })
+
+      it('does not warn on composition schemas (oneOf/anyOf/allOf)', () => {
+        expect(
+          warningsFor({ type: 'object', oneOf: [{ type: 'object', properties: { a: { type: 'string' } } }] })
+        ).toHaveLength(0)
+        expect(
+          warningsFor({ type: 'object', allOf: [{ type: 'object', properties: { a: { type: 'string' } } }] })
+        ).toHaveLength(0)
+      })
+
+      it('does not warn on non-object types', () => {
+        expect(warningsFor({ type: 'string' })).toHaveLength(0)
+      })
+
+      it('still generates the field as a usable object type', () => {
+        const connector = new OpenAPIConnector()
+        const { schemas } = connector.parseWithWarnings(specWithPayload({ type: 'object' }))
+        const tasks = schemas.find(e => e.name === 'tasks')
+        expect(tasks.fields.payload).toBeDefined()
+        expect(tasks.fields.payload.type).toBe('object')
+      })
+
+      it('parse() logs collected warnings to console.warn', () => {
+        const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+        try {
+          const connector = new OpenAPIConnector()
+          connector.parse(specWithPayload({ type: 'object' }))
+          const calls = warnSpy.mock.calls.map(args => args.join(' '))
+          expect(calls.some(line => line.includes('EMPTY') || line.includes('additionalProperties'))).toBe(true)
+          expect(calls.some(line => line.includes('/api/tasks/{id}#payload'))).toBe(true)
+        } finally {
+          warnSpy.mockRestore()
+        }
+      })
+    })
+  })
+
+  describe('inference options (#1255)', () => {
+    // /api/bots: GET item + POST with a partial body; lastSeen/uuid are
+    // response-only, name is writable, status declares readOnly in-schema.
+    const botsSpec = {
+      openapi: '3.0.0',
+      paths: {
+        '/api/bots/{id}': {
+          get: {
+            responses: {
+              '200': {
+                content: {
+                  'application/json': {
+                    schema: {
+                      type: 'object',
+                      properties: {
+                        data: {
+                          type: 'object',
+                          properties: {
+                            uuid: { type: 'string', format: 'uuid' },
+                            name: { type: 'string' },
+                            lastSeen: { type: 'string', format: 'date-time' },
+                            status: { type: 'string', readOnly: true },
+                            notes: { type: 'string', description: 'Operator notes' }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        '/api/bots': {
+          post: {
+            requestBody: {
+              content: {
+                'application/json': {
+                  schema: {
+                    type: 'object',
+                    properties: {
+                      name: { type: 'string' },
+                      notes: { type: 'string', description: 'Operator notes' }
+                    }
+                  }
+                }
+              }
+            },
+            responses: {
+              '200': {
+                content: {
+                  'application/json': {
+                    schema: { type: 'object', properties: { data: { type: 'object', properties: { uuid: { type: 'string' } } } } }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    // Read-only entity: no write operation at all
+    const logsSpec = {
+      openapi: '3.0.0',
+      paths: {
+        '/api/logs': {
+          get: {
+            responses: {
+              '200': {
+                content: {
+                  'application/json': {
+                    schema: {
+                      type: 'object',
+                      properties: {
+                        data: {
+                          type: 'array',
+                          items: {
+                            type: 'object',
+                            properties: {
+                              id: { type: 'string' },
+                              message: { type: 'string' }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    describe('inferLabels', () => {
+      it('is off by default (label only from description)', () => {
+        const connector = new OpenAPIConnector()
+        const bots = connector.parse(botsSpec).find(e => e.name === 'bots')
+
+        expect(bots.fields.lastSeen.label).toBeUndefined()
+        expect(bots.fields.notes.label).toBe('Operator notes')
+      })
+
+      it('humanizes field names when enabled and description is absent', () => {
+        const connector = new OpenAPIConnector({ inferLabels: 'humanize' })
+        const bots = connector.parse(botsSpec).find(e => e.name === 'bots')
+
+        expect(bots.fields.lastSeen.label).toBe('Last Seen')
+        expect(bots.fields.uuid.label).toBe('Uuid')
+        // description still wins
+        expect(bots.fields.notes.label).toBe('Operator notes')
+      })
+    })
+
+    describe('inferReadOnly', () => {
+      it('is off by default (readOnly only from schema)', () => {
+        const connector = new OpenAPIConnector()
+        const bots = connector.parse(botsSpec).find(e => e.name === 'bots')
+
+        expect(bots.fields.lastSeen.readOnly).toBe(false)
+        expect(bots.fields.status.readOnly).toBe(true)
+      })
+
+      it('marks response-only fields readOnly when enabled', () => {
+        const connector = new OpenAPIConnector({ inferReadOnly: true })
+        const bots = connector.parse(botsSpec).find(e => e.name === 'bots')
+
+        // never in a request body → inferred readOnly
+        expect(bots.fields.uuid.readOnly).toBe(true)
+        expect(bots.fields.lastSeen.readOnly).toBe(true)
+        // present in the POST body → stays writable
+        expect(bots.fields.name.readOnly).toBe(false)
+        expect(bots.fields.notes.readOnly).toBe(false)
+        // schema-declared readOnly preserved
+        expect(bots.fields.status.readOnly).toBe(true)
+      })
+
+      it('marks every field readOnly for entities without write operations', () => {
+        const connector = new OpenAPIConnector({ inferReadOnly: true })
+        const logs = connector.parse(logsSpec).find(e => e.name === 'logs')
+
+        expect(logs.fields.id.readOnly).toBe(true)
+        expect(logs.fields.message.readOnly).toBe(true)
+      })
+    })
   })
 
   describe('extensions option', () => {