@nextsparkjs/theme-default 0.1.0-beta.24 → 0.1.0-beta.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextsparkjs/theme-default",
-  "version": "0.1.0-beta.24",
+  "version": "0.1.0-beta.26",
   "private": false,
   "type": "module",
   "main": "./config/theme.config.ts",

package/tests/jest/__mocks__/@nextsparkjs/core/components/ui/badge.js

@@ -0,0 +1,16 @@
+/**
+ * Mock for @nextsparkjs/core/components/ui/badge
+ */
+const React = require('react')
+
+const Badge = ({ children, variant = 'default', className = '', ...props }) => {
+  return React.createElement('span', {
+    className: `badge badge-${variant} ${className}`.trim(),
+    'data-testid': 'badge',
+    ...props,
+  }, children)
+}
+
+module.exports = { Badge }
+module.exports.Badge = Badge
+module.exports.default = Badge

package/tests/jest/__mocks__/@nextsparkjs/core/lib/db.js

@@ -0,0 +1,11 @@
+/**
+ * Mock for @nextsparkjs/core/lib/db
+ */
+
+const queryWithRLS = jest.fn().mockResolvedValue([])
+const mutateWithRLS = jest.fn().mockResolvedValue({ rowCount: 1 })
+
+module.exports = {
+  queryWithRLS,
+  mutateWithRLS,
+}

package/tests/jest/__mocks__/@nextsparkjs/registries/permissions-registry.ts

@@ -0,0 +1,155 @@
+/**
+ * Mock Permissions Registry for Jest tests
+ */
+
+export type Permission = string
+
+export interface ResolvedPermission {
+  id: string
+  label: string
+  description: string
+  category: string
+  roles: string[]
+  dangerous: boolean
+  source: 'core' | 'theme'
+  disabled?: boolean
+}
+
+export interface PermissionUISection {
+  id: string
+  label: string
+  description: string
+  categories: string[]
+}
+
+export interface RolesConfig {
+  additionalRoles?: string[]
+  hierarchy?: Record<string, number>
+  displayNames?: Record<string, string>
+  descriptions?: Record<string, string>
+}
+
+// Mock permissions data
+export const ALL_RESOLVED_PERMISSIONS: ResolvedPermission[] = [
+  {
+    id: 'tasks.create',
+    label: 'Create tasks',
+    description: 'Can create new tasks',
+    category: 'Tasks',
+    roles: ['owner', 'admin', 'member'],
+    dangerous: false,
+    source: 'theme',
+  },
+  {
+    id: 'tasks.read',
+    label: 'View tasks',
+    description: 'Can view task details',
+    category: 'Tasks',
+    roles: ['owner', 'admin', 'member'],
+    dangerous: false,
+    source: 'theme',
+  },
+  {
+    id: 'tasks.update',
+    label: 'Edit tasks',
+    description: 'Can modify task information',
+    category: 'Tasks',
+    roles: ['owner', 'admin', 'member'],
+    dangerous: false,
+    source: 'theme',
+  },
+  {
+    id: 'tasks.delete',
+    label: 'Delete tasks',
+    description: 'Can delete tasks',
+    category: 'Tasks',
+    roles: ['owner', 'admin'],
+    dangerous: true,
+    source: 'theme',
+  },
+]
+
+export const ALL_PERMISSIONS: Permission[] = ALL_RESOLVED_PERMISSIONS.map(p => p.id)
+
+export const ALL_PERMISSIONS_SET = new Set(ALL_PERMISSIONS)
+
+export const AVAILABLE_ROLES: readonly string[] = ['owner', 'admin', 'member', 'viewer']
+
+export const ROLE_HIERARCHY: Record<string, number> = {
+  owner: 100,
+  admin: 50,
+  member: 10,
+  viewer: 1,
+}
+
+export const ROLE_DISPLAY_NAMES: Record<string, string> = {
+  owner: 'common.teamRoles.owner',
+  admin: 'common.teamRoles.admin',
+  member: 'common.teamRoles.member',
+  viewer: 'common.teamRoles.viewer',
+}
+
+export const ROLE_DESCRIPTIONS: Record<string, string> = {
+  owner: 'Full team control, cannot be removed',
+  admin: 'Manage team members and settings',
+  member: 'Standard team access',
+  viewer: 'Read-only access to team resources',
+}
+
+export const CUSTOM_ROLES: RolesConfig = {
+  additionalRoles: [],
+  hierarchy: {},
+  displayNames: {},
+  descriptions: {},
+}
+
+export const PERMISSIONS_BY_ROLE: Record<string, Set<Permission>> = {
+  owner: new Set(ALL_PERMISSIONS),
+  admin: new Set(['tasks.create', 'tasks.read', 'tasks.update', 'tasks.delete']),
+  member: new Set(['tasks.create', 'tasks.read', 'tasks.update']),
+  viewer: new Set(['tasks.read']),
+}
+
+export const ROLE_PERMISSIONS_ARRAY: Record<string, Permission[]> = {
+  owner: [...ALL_PERMISSIONS],
+  admin: ['tasks.create', 'tasks.read', 'tasks.update', 'tasks.delete'],
+  member: ['tasks.create', 'tasks.read', 'tasks.update'],
+  viewer: ['tasks.read'],
+}
+
+export const PERMISSIONS_BY_CATEGORY: Record<string, ResolvedPermission[]> = {
+  Tasks: ALL_RESOLVED_PERMISSIONS,
+}
+
+export const FULL_MATRIX: Record<Permission, Record<string, boolean>> = {}
+for (const perm of ALL_RESOLVED_PERMISSIONS) {
+  FULL_MATRIX[perm.id] = {}
+  for (const role of AVAILABLE_ROLES) {
+    FULL_MATRIX[perm.id][role] = PERMISSIONS_BY_ROLE[role]?.has(perm.id) ?? false
+  }
+}
+
+export const UI_SECTIONS: PermissionUISection[] = [
+  {
+    id: 'entities',
+    label: 'Entities',
+    description: 'Entity-specific permissions',
+    categories: ['Tasks'],
+  },
+]
+
+export const TEAM_PERMISSIONS_RAW = []
+export const TEAM_PERMISSIONS_BY_ROLE: Record<string, string[]> = {}
+
+export const PERMISSIONS_METADATA = {
+  totalPermissions: ALL_PERMISSIONS.length,
+  corePermissions: 0,
+  teamPermissions: 0,
+  featurePermissions: 0,
+  entityPermissions: ALL_RESOLVED_PERMISSIONS.length,
+  customRoles: 0,
+  availableRoles: AVAILABLE_ROLES.length,
+  categories: Object.keys(PERMISSIONS_BY_CATEGORY).length,
+  generatedAt: new Date().toISOString(),
+  theme: 'default',
+}

package/tests/jest/__mocks__/@nextsparkjs/registries/theme-registry.ts

@@ -0,0 +1,68 @@
+/**
+ * Mock Theme Registry for Jest tests
+ */
+
+export interface ThemeEntity {
+  name: string
+  source: string
+  config: any
+}
+
+export interface ThemeRouteFile {
+  path: string
+  type: 'api' | 'page'
+  methods?: string[]
+}
+
+export interface ThemeRegistryEntry {
+  name: string
+  slug: string
+  displayName: string
+  description: string
+  version: string
+  entities: ThemeEntity[]
+  routes: ThemeRouteFile[]
+  middlewares: any[]
+  plugins: string[]
+  path: string
+}
+
+export const THEME_REGISTRY: Record<string, ThemeRegistryEntry> = {
+  default: {
+    name: 'default',
+    slug: 'default',
+    displayName: 'Default Theme',
+    description: 'Default theme for NextSpark',
+    version: '1.0.0',
+    entities: [
+      { name: 'posts', source: 'default', config: { name: 'posts', label: 'Posts' } }
+    ],
+    routes: [
+      { path: '/api/v1/posts', type: 'api', methods: ['GET', 'POST'] }
+    ],
+    middlewares: [],
+    plugins: [],
+    path: 'contents/themes/default',
+  },
+}
+
+export type ThemeName = keyof typeof THEME_REGISTRY | string
+
+export const THEME_METADATA = {
+  generated: new Date().toISOString(),
+  activeTheme: 'default',
+  totalThemes: Object.keys(THEME_REGISTRY).length,
+  totalThemeEntities: 1,
+  totalThemeRoutes: 1,
+  themes: Object.keys(THEME_REGISTRY),
+}
+
+// Helper function for getting active theme
+export function getActiveTheme(): ThemeRegistryEntry | undefined {
+  return THEME_REGISTRY[THEME_METADATA.activeTheme]
+}
+
+// Helper function for getting theme by name
+export function getTheme(name: string): ThemeRegistryEntry | undefined {
+  return THEME_REGISTRY[name]
+}

package/tests/jest/__mocks__/next/image.js

@@ -0,0 +1,15 @@
+/**
+ * Mock for next/image
+ */
+const React = require('react')
+
+const Image = ({ src, alt, ...props }) => {
+  return React.createElement('img', {
+    src: typeof src === 'object' ? src.src : src,
+    alt: alt || '',
+    ...props,
+  })
+}
+
+module.exports = Image
+module.exports.default = Image

package/tests/jest/jest.config.cjs

@@ -27,9 +27,18 @@ const projectRoot = isNpmMode ? npmModeRoot : monorepoAppRoot
 // Module name mapper based on mode
 const moduleNameMapper = isNpmMode
   ? {
-      // NPM mode: resolve from node_modules
-      '^@nextsparkjs/core/(.*)$': '@nextsparkjs/core/$1',
-      '^@nextsparkjs/core$': '@nextsparkjs/core',
+      // NPM mode: Mock core UI components (ESM can't be transformed by Jest)
+      '^@nextsparkjs/core/components/ui/badge$': path.join(themeTestsRoot, '__mocks__/@nextsparkjs/core/components/ui/badge.js'),
+      // NPM mode: Mock core lib modules that are ESM
+      '^@nextsparkjs/core/lib/db$': path.join(themeTestsRoot, '__mocks__/@nextsparkjs/core/lib/db.js'),
+      // NPM mode: explicitly resolve @nextsparkjs/core subpaths to dist directory
+      // Jest doesn't respect package.json exports, so we map directly to dist files
+      '^@nextsparkjs/core/lib/(.*)$': '<rootDir>/node_modules/@nextsparkjs/core/dist/lib/$1',
+      '^@nextsparkjs/core/hooks/(.*)$': '<rootDir>/node_modules/@nextsparkjs/core/dist/hooks/$1',
+      '^@nextsparkjs/core/components/(.*)$': '<rootDir>/node_modules/@nextsparkjs/core/dist/components/$1',
+      '^@nextsparkjs/core/(.*)$': '<rootDir>/node_modules/@nextsparkjs/core/dist/$1',
+      '^@nextsparkjs/core$': '<rootDir>/node_modules/@nextsparkjs/core/dist/index.js',
+      '^@nextsparkjs/registries/(.*)$': path.join(themeTestsRoot, '__mocks__/@nextsparkjs/registries/$1'),
       '^@/contents/(.*)$': '<rootDir>/contents/$1',
       '^@/entities/(.*)$': '<rootDir>/contents/entities/$1',
       '^@/plugins/(.*)$': '<rootDir>/contents/plugins/$1',
@@ -37,6 +46,7 @@ const moduleNameMapper = isNpmMode
       '^@/(.*)$': '<rootDir>/$1',
       // Mocks from theme-local folder
       'next/server': path.join(themeTestsRoot, '__mocks__/next-server.js'),
+      'next/image': path.join(themeTestsRoot, '__mocks__/next/image.js'),
       '^jose$': path.join(themeTestsRoot, '__mocks__/jose.js'),
       '^jose/(.*)$': path.join(themeTestsRoot, '__mocks__/jose.js'),
     }
@@ -44,6 +54,7 @@ const moduleNameMapper = isNpmMode
       // Monorepo mode: resolve from packages/core/src (rootDir is apps/dev)
       '^@nextsparkjs/core/(.*)$': '<rootDir>/../../packages/core/src/$1',
       '^@nextsparkjs/core$': '<rootDir>/../../packages/core/src',
+      '^@nextsparkjs/registries/(.*)$': '<rootDir>/../../packages/core/tests/jest/__mocks__/@nextsparkjs/registries/$1',
       '^@/contents/(.*)$': '<rootDir>/contents/$1',
       '^@/entities/(.*)$': '<rootDir>/contents/entities/$1',
       '^@/plugins/(.*)$': '<rootDir>/contents/plugins/$1',
@@ -96,7 +107,7 @@ module.exports = {
   // Transform configuration
   transform: {
     '^.+\\.(ts|tsx)$': ['ts-jest', {
-      tsconfig: path.join(projectRoot, 'tsconfig.json'),
+      tsconfig: path.join(themeTestsRoot, 'tsconfig.jest.json'),
     }],
   },
 

package/tests/jest/langchain/streaming.test.ts

@@ -127,7 +127,8 @@ describe('Streaming Service', () => {
         const chunk: StreamChunk = { type: 'token', content: 'test' }
         const result = encoder.encode(chunk)
 
-        expect(result).toBeInstanceOf(Uint8Array)
+        // Use constructor name check to avoid jsdom cross-realm issues
+        expect(result.constructor.name).toBe('Uint8Array')
       })
     })
 
@@ -142,7 +143,8 @@ describe('Streaming Service', () => {
       it('should return Uint8Array', () => {
         const result = encoder.encodeDone()
 
-        expect(result).toBeInstanceOf(Uint8Array)
+        // Use constructor name check to avoid jsdom cross-realm issues
+        expect(result.constructor.name).toBe('Uint8Array')
       })
     })
   })
@@ -360,7 +362,8 @@ describe('Streaming Service', () => {
 
       expect(results).toHaveLength(100)
       results.forEach(result => {
-        expect(result).toBeInstanceOf(Uint8Array)
+        // Use constructor name check to avoid jsdom cross-realm issues
+        expect(result.constructor.name).toBe('Uint8Array')
       })
     })
   })

package/tests/jest/tsconfig.jest.json

@@ -0,0 +1,6 @@
+{
+  "extends": "../../../../apps/dev/tsconfig.json",
+  "compilerOptions": {
+    "jsx": "react-jsx"
+  }
+}

package/tests/jest/config/role-config.test.ts

@@ -1,529 +0,0 @@
-/**
- * Unit Tests - Role Configuration (app.config.ts)
- *
- * Tests role configuration for Developer Area feature:
- * - Developer role in availableRoles array
- * - Developer hierarchy value (100, highest)
- * - Developer displayName translation key
- * - Developer description
- * - Configuration completeness
- *
- * Focus on developer role configuration validation.
- */
-
-import { DEFAULT_APP_CONFIG } from '@nextsparkjs/core/lib/config/app.config'
-
-describe('Role Configuration - Developer Role', () => {
-  describe('availableRoles Array', () => {
-    it('should include developer role', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-
-      expect(roles).toContain('developer')
-    })
-
-    it('should include superadmin role', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-
-      expect(roles).toContain('superadmin')
-    })
-
-    it('should include member role', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-
-      expect(roles).toContain('member')
-    })
-
-    it('should have exactly 3 roles', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-
-      expect(roles.length).toBe(3)
-    })
-
-    it('should have roles in correct order', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-
-      expect(roles).toEqual(['member', 'superadmin', 'developer'])
-    })
-
-    it('should have all roles as strings', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-
-      roles.forEach(role => {
-        expect(typeof role).toBe('string')
-      })
-    })
-
-    it('should have all roles in lowercase', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-
-      roles.forEach(role => {
-        expect(role).toBe(role.toLowerCase())
-      })
-    })
-
-    it('should not have duplicate roles', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-      const uniqueRoles = new Set(roles)
-
-      expect(uniqueRoles.size).toBe(roles.length)
-    })
-  })
-
-  describe('Role Hierarchy', () => {
-    it('should have developer at level 100', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      expect(hierarchy.developer).toBe(100)
-    })
-
-    it('should have superadmin at level 99', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      expect(hierarchy.superadmin).toBe(99)
-    })
-
-    it('should have member at level 1', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      expect(hierarchy.member).toBe(1)
-    })
-
-    it('should have developer as highest hierarchy', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      expect(hierarchy.developer).toBeGreaterThan(hierarchy.superadmin)
-      expect(hierarchy.developer).toBeGreaterThan(hierarchy.member)
-    })
-
-    it('should have superadmin higher than member', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      expect(hierarchy.superadmin).toBeGreaterThan(hierarchy.member)
-    })
-
-    it('should have all hierarchy values as numbers', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      expect(typeof hierarchy.developer).toBe('number')
-      expect(typeof hierarchy.superadmin).toBe('number')
-      expect(typeof hierarchy.member).toBe('number')
-    })
-
-    it('should have all hierarchy values as positive integers', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      expect(hierarchy.developer).toBeGreaterThan(0)
-      expect(hierarchy.superadmin).toBeGreaterThan(0)
-      expect(hierarchy.member).toBeGreaterThan(0)
-
-      expect(Number.isInteger(hierarchy.developer)).toBe(true)
-      expect(Number.isInteger(hierarchy.superadmin)).toBe(true)
-      expect(Number.isInteger(hierarchy.member)).toBe(true)
-    })
-
-    it('should have correct hierarchy gap between developer and superadmin', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      // Developer (100) should be 1 level above superadmin (99)
-      expect(hierarchy.developer - hierarchy.superadmin).toBe(1)
-    })
-
-    it('should have large gap between superadmin and member', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      // Large gap indicates future extensibility
-      expect(hierarchy.superadmin - hierarchy.member).toBeGreaterThan(50)
-    })
-
-    it('should have hierarchy keys matching availableRoles', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      roles.forEach(role => {
-        expect(hierarchy[role as keyof typeof hierarchy]).toBeDefined()
-        expect(typeof hierarchy[role as keyof typeof hierarchy]).toBe('number')
-      })
-    })
-  })
-
-  describe('Display Names (Translation Keys)', () => {
-    it('should have translation key for developer role', () => {
-      const displayNames = DEFAULT_APP_CONFIG.userRoles.displayNames
-
-      expect(displayNames.developer).toBe('common.userRoles.developer')
-    })
-
-    it('should have translation key for superadmin role', () => {
-      const displayNames = DEFAULT_APP_CONFIG.userRoles.displayNames
-
-      expect(displayNames.superadmin).toBe('common.userRoles.superadmin')
-    })
-
-    it('should have translation key for member role', () => {
-      const displayNames = DEFAULT_APP_CONFIG.userRoles.displayNames
-
-      expect(displayNames.member).toBe('common.userRoles.member')
-    })
-
-    it('should have translation keys in correct format', () => {
-      const displayNames = DEFAULT_APP_CONFIG.userRoles.displayNames
-
-      Object.values(displayNames).forEach(key => {
-        expect(key).toMatch(/^common\.userRoles\.\w+$/)
-      })
-    })
-
-    it('should have translation keys for all available roles', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-      const displayNames = DEFAULT_APP_CONFIG.userRoles.displayNames
-
-      roles.forEach(role => {
-        expect(displayNames[role as keyof typeof displayNames]).toBeDefined()
-        expect(displayNames[role as keyof typeof displayNames]).toContain('common.userRoles.')
-      })
-    })
-
-    it('should use common namespace for all role names', () => {
-      const displayNames = DEFAULT_APP_CONFIG.userRoles.displayNames
-
-      Object.values(displayNames).forEach(key => {
-        expect(key).toMatch(/^common\./)
-      })
-    })
-  })
-
-  describe('Role Descriptions', () => {
-    it('should have description for developer role', () => {
-      const descriptions = DEFAULT_APP_CONFIG.userRoles.descriptions
-
-      expect(descriptions.developer).toBe('Ultimate access (platform developers only)')
-    })
-
-    it('should have description for superadmin role', () => {
-      const descriptions = DEFAULT_APP_CONFIG.userRoles.descriptions
-
-      expect(descriptions.superadmin).toBe('Full system access (product owners only)')
-    })
-
-    it('should have description for member role', () => {
-      const descriptions = DEFAULT_APP_CONFIG.userRoles.descriptions
-
-      expect(descriptions.member).toBe('Regular user with team-based permissions')
-    })
-
-    it('should have descriptions as non-empty strings', () => {
-      const descriptions = DEFAULT_APP_CONFIG.userRoles.descriptions
-
-      Object.values(descriptions).forEach(description => {
-        expect(typeof description).toBe('string')
-        expect(description.length).toBeGreaterThan(0)
-      })
-    })
-
-    it('should have descriptions for all available roles', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-      const descriptions = DEFAULT_APP_CONFIG.userRoles.descriptions
-
-      roles.forEach(role => {
-        expect(descriptions[role as keyof typeof descriptions]).toBeDefined()
-        expect(descriptions[role as keyof typeof descriptions].length).toBeGreaterThan(0)
-      })
-    })
-
-    it('should have developer description indicating highest access', () => {
-      const descriptions = DEFAULT_APP_CONFIG.userRoles.descriptions
-
-      expect(descriptions.developer.toLowerCase()).toContain('ultimate')
-    })
-
-    it('should have developer description indicating platform developer usage', () => {
-      const descriptions = DEFAULT_APP_CONFIG.userRoles.descriptions
-
-      expect(descriptions.developer.toLowerCase()).toContain('developer')
-    })
-
-    it('should have superadmin description indicating product owner usage', () => {
-      const descriptions = DEFAULT_APP_CONFIG.userRoles.descriptions
-
-      expect(descriptions.superadmin.toLowerCase()).toContain('owner')
-    })
-  })
-
-  describe('Default Role', () => {
-    it('should have member as default role', () => {
-      const defaultRole = DEFAULT_APP_CONFIG.userRoles.defaultRole
-
-      expect(defaultRole).toBe('member')
-    })
-
-    it('should have default role in availableRoles', () => {
-      const defaultRole = DEFAULT_APP_CONFIG.userRoles.defaultRole
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-
-      expect(roles).toContain(defaultRole)
-    })
-
-    it('should not have developer as default role', () => {
-      const defaultRole = DEFAULT_APP_CONFIG.userRoles.defaultRole
-
-      expect(defaultRole).not.toBe('developer')
-    })
-
-    it('should not have superadmin as default role', () => {
-      const defaultRole = DEFAULT_APP_CONFIG.userRoles.defaultRole
-
-      expect(defaultRole).not.toBe('superadmin')
-    })
-  })
-
-  describe('Configuration Completeness', () => {
-    it('should have all roles in hierarchy map', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      roles.forEach(role => {
-        expect(hierarchy[role as keyof typeof hierarchy]).toBeDefined()
-      })
-    })
-
-    it('should have all roles in displayNames map', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-      const displayNames = DEFAULT_APP_CONFIG.userRoles.displayNames
-
-      roles.forEach(role => {
-        expect(displayNames[role as keyof typeof displayNames]).toBeDefined()
-      })
-    })
-
-    it('should have all roles in descriptions map', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-      const descriptions = DEFAULT_APP_CONFIG.userRoles.descriptions
-
-      roles.forEach(role => {
-        expect(descriptions[role as keyof typeof descriptions]).toBeDefined()
-      })
-    })
-
-    it('should have no extra keys in hierarchy map', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      const hierarchyKeys = Object.keys(hierarchy)
-
-      expect(hierarchyKeys.length).toBe(roles.length)
-    })
-
-    it('should have no extra keys in displayNames map', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-      const displayNames = DEFAULT_APP_CONFIG.userRoles.displayNames
-
-      const displayNameKeys = Object.keys(displayNames)
-
-      expect(displayNameKeys.length).toBe(roles.length)
-    })
-
-    it('should have no extra keys in descriptions map', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-      const descriptions = DEFAULT_APP_CONFIG.userRoles.descriptions
-
-      const descriptionKeys = Object.keys(descriptions)
-
-      expect(descriptionKeys.length).toBe(roles.length)
-    })
-  })
-})
-
-describe('Role Configuration - Backwards Compatibility', () => {
-  describe('Existing Roles Preserved', () => {
-    it('should still have member role (Phase 1)', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-
-      expect(roles).toContain('member')
-    })
-
-    it('should still have superadmin role (Phase 2)', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-
-      expect(roles).toContain('superadmin')
-    })
-
-    it('should preserve member hierarchy value', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      expect(hierarchy.member).toBe(1)
-    })
-
-    it('should preserve superadmin hierarchy value', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      expect(hierarchy.superadmin).toBe(99)
-    })
-
-    it('should preserve default role as member', () => {
-      const defaultRole = DEFAULT_APP_CONFIG.userRoles.defaultRole
-
-      expect(defaultRole).toBe('member')
-    })
-  })
-
-  describe('New Role Addition (Phase 3)', () => {
-    it('should add developer role without breaking existing config', () => {
-      const config = DEFAULT_APP_CONFIG.userRoles
-
-      // All Phase 1-2 features still work
-      expect(config.defaultRole).toBe('member')
-      expect(config.availableRoles).toContain('member')
-      expect(config.availableRoles).toContain('superadmin')
-
-      // Phase 3 addition
-      expect(config.availableRoles).toContain('developer')
-    })
-
-    it('should have developer hierarchy higher than existing roles', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      expect(hierarchy.developer).toBeGreaterThan(hierarchy.superadmin)
-      expect(hierarchy.developer).toBeGreaterThan(hierarchy.member)
-    })
-
-    it('should not affect superadmin hierarchy relative to member', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      expect(hierarchy.superadmin).toBeGreaterThan(hierarchy.member)
-    })
-  })
-})
-
-describe('Role Configuration - Edge Cases', () => {
-  describe('Type Safety', () => {
-    it('should have userRoles as an object', () => {
-      expect(typeof DEFAULT_APP_CONFIG.userRoles).toBe('object')
-      expect(DEFAULT_APP_CONFIG.userRoles).not.toBeNull()
-    })
-
-    it('should have availableRoles as readonly array', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-
-      expect(Array.isArray(roles)).toBe(true)
-    })
-
-    it('should have hierarchy as object with string keys', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      expect(typeof hierarchy).toBe('object')
-      Object.keys(hierarchy).forEach(key => {
-        expect(typeof key).toBe('string')
-      })
-    })
-  })
-
-  describe('Invalid Data Protection', () => {
-    it('should not have empty string roles', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-
-      roles.forEach(role => {
-        expect(role.length).toBeGreaterThan(0)
-      })
-    })
-
-    it('should not have negative hierarchy values', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      Object.values(hierarchy).forEach(value => {
-        expect(value).toBeGreaterThan(0)
-      })
-    })
-
-    it('should not have hierarchy values as floats', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      Object.values(hierarchy).forEach(value => {
-        expect(Number.isInteger(value)).toBe(true)
-      })
-    })
-
-    it('should not have empty translation keys', () => {
-      const displayNames = DEFAULT_APP_CONFIG.userRoles.displayNames
-
-      Object.values(displayNames).forEach(key => {
-        expect(key.length).toBeGreaterThan(0)
-      })
-    })
-
-    it('should not have empty descriptions', () => {
-      const descriptions = DEFAULT_APP_CONFIG.userRoles.descriptions
-
-      Object.values(descriptions).forEach(description => {
-        expect(description.length).toBeGreaterThan(0)
-      })
-    })
-  })
-})
-
-describe('Real-World Configuration Usage', () => {
-  describe('Guard Implementation Support', () => {
-    it('should support DeveloperGuard role check', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-
-      // DeveloperGuard checks if role === 'developer'
-      expect(roles).toContain('developer')
-    })
-
-    it('should support SuperAdminGuard dual role check', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-
-      // SuperAdminGuard allows both superadmin and developer
-      expect(roles).toContain('superadmin')
-      expect(roles).toContain('developer')
-    })
-
-    it('should support middleware role validation', () => {
-      const hierarchy = DEFAULT_APP_CONFIG.userRoles.hierarchy
-
-      // Middleware compares hierarchy levels
-      expect(hierarchy.developer).toBeDefined()
-      expect(hierarchy.superadmin).toBeDefined()
-      expect(hierarchy.member).toBeDefined()
-    })
-  })
-
-  describe('UI Display Support', () => {
-    it('should provide translation keys for role selection dropdown', () => {
-      const displayNames = DEFAULT_APP_CONFIG.userRoles.displayNames
-
-      const roles = ['developer', 'superadmin', 'member'] as const
-
-      roles.forEach(role => {
-        expect(displayNames[role]).toMatch(/^common\.userRoles\.\w+$/)
-      })
-    })
-
-    it('should provide descriptions for role info tooltips', () => {
-      const descriptions = DEFAULT_APP_CONFIG.userRoles.descriptions
-
-      const roles = ['developer', 'superadmin', 'member'] as const
-
-      roles.forEach(role => {
-        expect(descriptions[role].length).toBeGreaterThan(10) // Meaningful description
-      })
-    })
-  })
-
-  describe('Database Schema Support', () => {
-    it('should have role values compatible with database enum', () => {
-      const roles = DEFAULT_APP_CONFIG.userRoles.availableRoles
-
-      // Database enum values should be lowercase strings
-      roles.forEach(role => {
-        expect(role).toMatch(/^[a-z]+$/)
-      })
-    })
-
-    it('should have default role for user creation', () => {
-      const defaultRole = DEFAULT_APP_CONFIG.userRoles.defaultRole
-
-      expect(defaultRole).toBe('member')
-      expect(DEFAULT_APP_CONFIG.userRoles.availableRoles).toContain(defaultRole)
-    })
-  })
-})

package/tests/jest/user-roles/role-helpers.test.ts

@@ -1,432 +0,0 @@
-/**
- * Unit Tests - User Role Helper Functions
- *
- * Tests role helper functions for Developer Area feature:
- * - isDeveloper(): Check if user is developer
- * - canAccessAdmin(): Check if user has Sector7 access
- * - hasRoleLevel(): Hierarchy comparison with developer role
- * - getAllRolesByHierarchy(): Verify developer is first (highest)
- *
- * Focus on developer role integration with existing role system.
- */
-
-import { roleHelpers, USER_ROLES, ROLE_HIERARCHY, type UserRole } from '@nextsparkjs/core/types/user.types'
-
-describe('User Role Helpers - Developer Role Integration', () => {
-  describe('isDeveloper()', () => {
-    it('should return true for developer role', () => {
-      const result = roleHelpers.isDeveloper(USER_ROLES.DEVELOPER)
-      expect(result).toBe(true)
-    })
-
-    it('should return false for superadmin role', () => {
-      const result = roleHelpers.isDeveloper(USER_ROLES.SUPERADMIN)
-      expect(result).toBe(false)
-    })
-
-    it('should return false for member role', () => {
-      const result = roleHelpers.isDeveloper(USER_ROLES.MEMBER)
-      expect(result).toBe(false)
-    })
-
-    it('should handle string literal "developer"', () => {
-      const result = roleHelpers.isDeveloper('developer' as UserRole)
-      expect(result).toBe(true)
-    })
-
-    it('should handle case-sensitive comparison', () => {
-      // Should fail because role names are lowercase
-      const result = roleHelpers.isDeveloper('Developer' as UserRole)
-      expect(result).toBe(false)
-    })
-  })
-
-  describe('canAccessAdmin()', () => {
-    it('should return true for developer role', () => {
-      const result = roleHelpers.canAccessAdmin(USER_ROLES.DEVELOPER)
-      expect(result).toBe(true)
-    })
-
-    it('should return true for superadmin role', () => {
-      const result = roleHelpers.canAccessAdmin(USER_ROLES.SUPERADMIN)
-      expect(result).toBe(true)
-    })
-
-    it('should return false for member role', () => {
-      const result = roleHelpers.canAccessAdmin(USER_ROLES.MEMBER)
-      expect(result).toBe(false)
-    })
-
-    it('should handle string literal "developer"', () => {
-      const result = roleHelpers.canAccessAdmin('developer' as UserRole)
-      expect(result).toBe(true)
-    })
-
-    it('should handle string literal "superadmin"', () => {
-      const result = roleHelpers.canAccessAdmin('superadmin' as UserRole)
-      expect(result).toBe(true)
-    })
-
-    it('should handle both privileged roles', () => {
-      // Verify both roles have access (dual access pattern)
-      const developerAccess = roleHelpers.canAccessAdmin(USER_ROLES.DEVELOPER)
-      const superadminAccess = roleHelpers.canAccessAdmin(USER_ROLES.SUPERADMIN)
-
-      expect(developerAccess).toBe(true)
-      expect(superadminAccess).toBe(true)
-    })
-  })
-
-  describe('isSuperAdmin()', () => {
-    it('should return true for superadmin role', () => {
-      const result = roleHelpers.isSuperAdmin(USER_ROLES.SUPERADMIN)
-      expect(result).toBe(true)
-    })
-
-    it('should return false for developer role', () => {
-      // Developer is NOT superadmin (separate role)
-      const result = roleHelpers.isSuperAdmin(USER_ROLES.DEVELOPER)
-      expect(result).toBe(false)
-    })
-
-    it('should return false for member role', () => {
-      const result = roleHelpers.isSuperAdmin(USER_ROLES.MEMBER)
-      expect(result).toBe(false)
-    })
-  })
-
-  describe('hasRoleLevel() - Developer Hierarchy', () => {
-    it('should confirm developer has higher level than superadmin', () => {
-      const result = roleHelpers.hasRoleLevel(USER_ROLES.DEVELOPER, USER_ROLES.SUPERADMIN)
-      expect(result).toBe(true)
-    })
-
-    it('should confirm developer has higher level than member', () => {
-      const result = roleHelpers.hasRoleLevel(USER_ROLES.DEVELOPER, USER_ROLES.MEMBER)
-      expect(result).toBe(true)
-    })
-
-    it('should confirm superadmin does NOT have developer level', () => {
-      const result = roleHelpers.hasRoleLevel(USER_ROLES.SUPERADMIN, USER_ROLES.DEVELOPER)
-      expect(result).toBe(false)
-    })
-
-    it('should confirm member does NOT have developer level', () => {
-      const result = roleHelpers.hasRoleLevel(USER_ROLES.MEMBER, USER_ROLES.DEVELOPER)
-      expect(result).toBe(false)
-    })
-
-    it('should confirm developer equals developer level', () => {
-      const result = roleHelpers.hasRoleLevel(USER_ROLES.DEVELOPER, USER_ROLES.DEVELOPER)
-      expect(result).toBe(true)
-    })
-
-    it('should confirm superadmin has superadmin level', () => {
-      const result = roleHelpers.hasRoleLevel(USER_ROLES.SUPERADMIN, USER_ROLES.SUPERADMIN)
-      expect(result).toBe(true)
-    })
-
-    it('should confirm superadmin has higher level than member', () => {
-      const result = roleHelpers.hasRoleLevel(USER_ROLES.SUPERADMIN, USER_ROLES.MEMBER)
-      expect(result).toBe(true)
-    })
-
-    it('should confirm member does NOT have superadmin level', () => {
-      const result = roleHelpers.hasRoleLevel(USER_ROLES.MEMBER, USER_ROLES.SUPERADMIN)
-      expect(result).toBe(false)
-    })
-  })
-
-  describe('getAllRolesByHierarchy() - Developer First', () => {
-    it('should return developer as first role (highest hierarchy)', () => {
-      const roles = roleHelpers.getAllRolesByHierarchy()
-
-      expect(roles[0]).toBe(USER_ROLES.DEVELOPER)
-    })
-
-    it('should return superadmin as second role', () => {
-      const roles = roleHelpers.getAllRolesByHierarchy()
-
-      expect(roles[1]).toBe(USER_ROLES.SUPERADMIN)
-    })
-
-    it('should return member as last role (lowest hierarchy)', () => {
-      const roles = roleHelpers.getAllRolesByHierarchy()
-
-      expect(roles[roles.length - 1]).toBe(USER_ROLES.MEMBER)
-    })
-
-    it('should return all roles in descending hierarchy order', () => {
-      const roles = roleHelpers.getAllRolesByHierarchy()
-
-      expect(roles).toEqual([
-        USER_ROLES.DEVELOPER,   // 100
-        USER_ROLES.SUPERADMIN,  // 99
-        USER_ROLES.MEMBER       // 1
-      ])
-    })
-
-    it('should return array with correct length', () => {
-      const roles = roleHelpers.getAllRolesByHierarchy()
-
-      expect(roles.length).toBe(3)
-    })
-
-    it('should not mutate original roles array', () => {
-      const roles1 = roleHelpers.getAllRolesByHierarchy()
-      const roles2 = roleHelpers.getAllRolesByHierarchy()
-
-      expect(roles1).toEqual(roles2)
-      expect(roles1).not.toBe(roles2) // Different array instances
-    })
-  })
-
-  describe('getRoleDisplayKey()', () => {
-    it('should return translation key for developer role', () => {
-      const key = roleHelpers.getRoleDisplayKey(USER_ROLES.DEVELOPER)
-
-      expect(key).toBe('common.userRoles.developer')
-    })
-
-    it('should return translation key for superadmin role', () => {
-      const key = roleHelpers.getRoleDisplayKey(USER_ROLES.SUPERADMIN)
-
-      expect(key).toBe('common.userRoles.superadmin')
-    })
-
-    it('should return translation key for member role', () => {
-      const key = roleHelpers.getRoleDisplayKey(USER_ROLES.MEMBER)
-
-      expect(key).toBe('common.userRoles.member')
-    })
-  })
-})
-
-describe('Role Hierarchy Configuration', () => {
-  describe('ROLE_HIERARCHY Values', () => {
-    it('should have developer at hierarchy level 100', () => {
-      expect(ROLE_HIERARCHY.developer).toBe(100)
-    })
-
-    it('should have superadmin at hierarchy level 99', () => {
-      expect(ROLE_HIERARCHY.superadmin).toBe(99)
-    })
-
-    it('should have member at hierarchy level 1', () => {
-      expect(ROLE_HIERARCHY.member).toBe(1)
-    })
-
-    it('should have developer as highest hierarchy', () => {
-      const developerLevel = ROLE_HIERARCHY.developer
-      const superadminLevel = ROLE_HIERARCHY.superadmin
-      const memberLevel = ROLE_HIERARCHY.member
-
-      expect(developerLevel).toBeGreaterThan(superadminLevel)
-      expect(developerLevel).toBeGreaterThan(memberLevel)
-    })
-
-    it('should have superadmin higher than member', () => {
-      const superadminLevel = ROLE_HIERARCHY.superadmin
-      const memberLevel = ROLE_HIERARCHY.member
-
-      expect(superadminLevel).toBeGreaterThan(memberLevel)
-    })
-
-    it('should have numeric values for all roles', () => {
-      expect(typeof ROLE_HIERARCHY.developer).toBe('number')
-      expect(typeof ROLE_HIERARCHY.superadmin).toBe('number')
-      expect(typeof ROLE_HIERARCHY.member).toBe('number')
-    })
-
-    it('should have positive values for all roles', () => {
-      expect(ROLE_HIERARCHY.developer).toBeGreaterThan(0)
-      expect(ROLE_HIERARCHY.superadmin).toBeGreaterThan(0)
-      expect(ROLE_HIERARCHY.member).toBeGreaterThan(0)
-    })
-
-    it('should maintain expected hierarchy gap', () => {
-      // Developer (100) is 1 level above superadmin (99)
-      expect(ROLE_HIERARCHY.developer - ROLE_HIERARCHY.superadmin).toBe(1)
-
-      // Large gap between superadmin (99) and member (1)
-      expect(ROLE_HIERARCHY.superadmin - ROLE_HIERARCHY.member).toBe(98)
-    })
-  })
-
-  describe('USER_ROLES Constants', () => {
-    it('should have DEVELOPER constant', () => {
-      expect(USER_ROLES.DEVELOPER).toBe('developer')
-    })
-
-    it('should have SUPERADMIN constant', () => {
-      expect(USER_ROLES.SUPERADMIN).toBe('superadmin')
-    })
-
-    it('should have MEMBER constant', () => {
-      expect(USER_ROLES.MEMBER).toBe('member')
-    })
-
-    it('should have all constants as lowercase strings', () => {
-      expect(USER_ROLES.DEVELOPER).toBe(USER_ROLES.DEVELOPER.toLowerCase())
-      expect(USER_ROLES.SUPERADMIN).toBe(USER_ROLES.SUPERADMIN.toLowerCase())
-      expect(USER_ROLES.MEMBER).toBe(USER_ROLES.MEMBER.toLowerCase())
-    })
-  })
-})
-
-describe('Edge Cases and Error Handling', () => {
-  describe('hasRoleLevel() Edge Cases', () => {
-    it('should handle null-like values gracefully', () => {
-      // These would fail TypeScript compile-time but test runtime behavior
-      const result = roleHelpers.hasRoleLevel(
-        undefined as unknown as UserRole,
-        USER_ROLES.MEMBER
-      )
-
-      expect(result).toBe(false)
-    })
-
-    it('should handle comparing same role multiple times', () => {
-      const result1 = roleHelpers.hasRoleLevel(USER_ROLES.DEVELOPER, USER_ROLES.DEVELOPER)
-      const result2 = roleHelpers.hasRoleLevel(USER_ROLES.DEVELOPER, USER_ROLES.DEVELOPER)
-
-      expect(result1).toBe(result2)
-      expect(result1).toBe(true)
-    })
-  })
-
-  describe('isDeveloper() Edge Cases', () => {
-    it('should handle whitespace in role name', () => {
-      const result = roleHelpers.isDeveloper(' developer ' as UserRole)
-      expect(result).toBe(false) // Exact match required
-    })
-
-    it('should handle empty string', () => {
-      const result = roleHelpers.isDeveloper('' as UserRole)
-      expect(result).toBe(false)
-    })
-  })
-
-  describe('canAccessAdmin() Edge Cases', () => {
-    it('should handle invalid role gracefully', () => {
-      const result = roleHelpers.canAccessAdmin('invalid-role' as UserRole)
-      expect(result).toBe(false)
-    })
-
-    it('should handle null-like value', () => {
-      const result = roleHelpers.canAccessAdmin(null as unknown as UserRole)
-      expect(result).toBe(false)
-    })
-
-    it('should handle undefined', () => {
-      const result = roleHelpers.canAccessAdmin(undefined as unknown as UserRole)
-      expect(result).toBe(false)
-    })
-  })
-})
-
-describe('Real-World Use Cases', () => {
-  describe('Guard Logic Simulation', () => {
-    it('should allow developer through DeveloperGuard', () => {
-      const userRole: UserRole = 'developer'
-      const canAccess = roleHelpers.isDeveloper(userRole)
-
-      expect(canAccess).toBe(true)
-    })
-
-    it('should block superadmin from DeveloperGuard', () => {
-      const userRole: UserRole = 'superadmin'
-      const canAccess = roleHelpers.isDeveloper(userRole)
-
-      expect(canAccess).toBe(false)
-    })
-
-    it('should block member from DeveloperGuard', () => {
-      const userRole: UserRole = 'member'
-      const canAccess = roleHelpers.isDeveloper(userRole)
-
-      expect(canAccess).toBe(false)
-    })
-
-    it('should allow developer through SuperAdminGuard (Sector7)', () => {
-      const userRole: UserRole = 'developer'
-      const canAccess = roleHelpers.canAccessAdmin(userRole)
-
-      expect(canAccess).toBe(true)
-    })
-
-    it('should allow superadmin through SuperAdminGuard (Sector7)', () => {
-      const userRole: UserRole = 'superadmin'
-      const canAccess = roleHelpers.canAccessAdmin(userRole)
-
-      expect(canAccess).toBe(true)
-    })
-
-    it('should block member from SuperAdminGuard (Sector7)', () => {
-      const userRole: UserRole = 'member'
-      const canAccess = roleHelpers.canAccessAdmin(userRole)
-
-      expect(canAccess).toBe(false)
-    })
-  })
-
-  describe('Permission Checks', () => {
-    it('should grant developer access to all areas', () => {
-      const userRole: UserRole = 'developer'
-
-      const devArea = roleHelpers.isDeveloper(userRole)
-      const sector7 = roleHelpers.canAccessAdmin(userRole)
-      const hasAdminLevel = roleHelpers.hasRoleLevel(userRole, USER_ROLES.SUPERADMIN)
-
-      expect(devArea).toBe(true)
-      expect(sector7).toBe(true)
-      expect(hasAdminLevel).toBe(true)
-    })
-
-    it('should grant superadmin limited access (no /dev)', () => {
-      const userRole: UserRole = 'superadmin'
-
-      const devArea = roleHelpers.isDeveloper(userRole)
-      const sector7 = roleHelpers.canAccessAdmin(userRole)
-      const isSuperAdmin = roleHelpers.isSuperAdmin(userRole)
-
-      expect(devArea).toBe(false) // Cannot access /dev
-      expect(sector7).toBe(true)  // Can access Sector7
-      expect(isSuperAdmin).toBe(true)
-    })
-
-    it('should grant member minimal access', () => {
-      const userRole: UserRole = 'member'
-
-      const devArea = roleHelpers.isDeveloper(userRole)
-      const sector7 = roleHelpers.canAccessAdmin(userRole)
-      const isSuperAdmin = roleHelpers.isSuperAdmin(userRole)
-
-      expect(devArea).toBe(false)
-      expect(sector7).toBe(false)
-      expect(isSuperAdmin).toBe(false)
-    })
-  })
-
-  describe('Role Display in UI', () => {
-    it('should provide translation keys for all roles', () => {
-      const roles = roleHelpers.getAllRolesByHierarchy()
-
-      roles.forEach(role => {
-        const key = roleHelpers.getRoleDisplayKey(role)
-        expect(key).toContain('common.userRoles.')
-      })
-    })
-
-    it('should list roles in correct order for admin UI', () => {
-      const roles = roleHelpers.getAllRolesByHierarchy()
-
-      // Admin UI should show roles from most powerful to least
-      expect(roles).toEqual([
-        'developer',
-        'superadmin',
-        'member'
-      ])
-    })
-  })
-})