@nextsparkjs/core 0.1.0-beta.13 → 0.1.0-beta.131

package/scripts/build/registry/discovery/core-entities.mjs

@@ -0,0 +1,166 @@
+/**
+ * Core Entity Discovery
+ *
+ * Discovers entities from packages/core/src/entities/
+ * These are framework-level entities that are always available.
+ *
+ * @module core/scripts/build/registry/discovery/core-entities
+ */
+
+import { readdir, stat, readFile } from 'fs/promises'
+import { join, dirname } from 'path'
+import { existsSync } from 'fs'
+import { fileURLToPath } from 'url'
+
+import { verbose } from '../../../utils/index.mjs'
+import { extractExportName } from '../../../utils/index.mjs'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+// Path from discovery/ to packages/core/src/entities/ (6 levels up + packages/core/src/entities)
+const corePackageRoot = join(__dirname, '../../../../../..')
+
+/**
+ * Discover all entities from packages/core/src/entities/
+ * @param {object} config - Configuration object
+ * @returns {Promise<Array>} Array of discovered core entities
+ */
+export async function discoverCoreEntities(config) {
+  const coreEntities = []
+
+  // Determine the core entities directory
+  // In NPM mode: node_modules/@nextsparkjs/core/src/entities
+  // In monorepo mode: use monorepoRoot/packages/core/src/entities
+  let coreEntitiesDir
+
+  if (config.isNpmMode) {
+    // NPM mode: core is in node_modules
+    coreEntitiesDir = join(config.projectRoot, 'node_modules/@nextsparkjs/core/src/entities')
+  } else if (config.isMonorepoMode && config.monorepoRoot) {
+    // Monorepo mode: core is at monorepoRoot/packages/core
+    coreEntitiesDir = join(config.monorepoRoot, 'packages/core/src/entities')
+  } else {
+    // Fallback: core is relative to projectRoot
+    coreEntitiesDir = join(config.projectRoot, 'packages/core/src/entities')
+  }
+
+  verbose(`[core-entities] Scanning ${coreEntitiesDir}`)
+
+  try {
+    // Check if directory exists
+    if (!existsSync(coreEntitiesDir)) {
+      verbose(`[core-entities] No core entities directory found at ${coreEntitiesDir}`)
+      return coreEntities
+    }
+
+    const entries = await readdir(coreEntitiesDir, { withFileTypes: true })
+
+    // Process only directories (each entity has its own directory)
+    const entityDirs = entries.filter(entry => entry.isDirectory())
+
+    for (const dir of entityDirs) {
+      const entityName = dir.name
+      const entityPath = join(coreEntitiesDir, entityName)
+
+      // Look for config file with entity name pattern
+      const configPatterns = [
+        `${entityName}.config.ts`,
+        `${entityName.slice(0, -1)}.config.ts`,
+        `${entityName.replace(/s$/, '')}.config.ts`
+      ]
+
+      let configPath = null
+      let actualConfigFile = null
+
+      for (const pattern of configPatterns) {
+        const testPath = join(entityPath, pattern)
+        try {
+          await stat(testPath)
+          configPath = testPath
+          actualConfigFile = pattern
+          break
+        } catch {
+          continue
+        }
+      }
+
+      if (!configPath) {
+        verbose(`[core-entities] Skipping ${entityName} - no config file found`)
+        continue
+      }
+
+      try {
+        // Extract export name from config file
+        const exportName = await extractExportName(configPath, [
+          /export\s+const\s+([a-zA-Z]+EntityConfig)\s*[:=]/,
+          /export\s+const\s+([a-zA-Z]+ChildConfig)\s*[:=]/
+        ])
+
+        if (!exportName) {
+          verbose(`[core-entities] Skipping ${entityName} - no valid export found in ${actualConfigFile}`)
+          continue
+        }
+
+        // Check for optional directories
+        const componentsPath = join(entityPath, 'components')
+        const hooksPath = join(entityPath, 'hooks')
+        const migrationsPath = join(entityPath, 'migrations')
+        const messagesPath = join(entityPath, 'messages')
+        const assetsPath = join(entityPath, 'assets')
+
+        const hasComponents = existsSync(componentsPath)
+        const hasHooks = existsSync(hooksPath)
+        const hasMigrations = existsSync(migrationsPath)
+        const hasMessages = existsSync(messagesPath)
+        const hasAssets = existsSync(assetsPath)
+
+        // Core entities use @nextsparkjs/core/entities/... import path
+        const configFileName = actualConfigFile.replace('.ts', '')
+        const importPath = `@nextsparkjs/core/entities/${entityName}/${configFileName}`
+        const messagesImportPath = `@nextsparkjs/core/entities/${entityName}/messages`
+
+        const entity = {
+          name: entityName,
+          exportName,
+          configPath: importPath,
+          actualConfigFile,
+          relativePath: entityName,
+          depth: 0,
+          parent: null,
+          children: [],
+          hasComponents,
+          hasHooks,
+          hasMigrations,
+          hasMessages,
+          hasAssets,
+          messagesPath: messagesImportPath,
+          pluginContext: null,
+          themeContext: null,
+          isCore: true,
+          source: 'core'
+        }
+
+        coreEntities.push(entity)
+
+        const features = [
+          hasComponents && 'components',
+          hasHooks && 'hooks',
+          hasMigrations && 'migrations',
+          hasMessages && 'messages',
+          hasAssets && 'assets'
+        ].filter(Boolean).join(', ') || 'config only'
+
+        verbose(`[core-entities] Core Entity: ${entityName} (${features})`)
+
+      } catch (error) {
+        verbose(`[core-entities] Error processing ${entityName}: ${error.message}`)
+      }
+    }
+
+  } catch (error) {
+    verbose(`[core-entities] Error scanning core entities: ${error.message}`)
+  }
+
+  return coreEntities
+}

package/scripts/build/registry/discovery/index.mjs

@@ -9,6 +9,7 @@
 // Re-export individual discovery functions
 export { discoverPlugins, discoverRouteFiles } from './plugins.mjs'
 export { discoverEntities, discoverNestedEntities } from './entities.mjs'
+export { discoverCoreEntities } from './core-entities.mjs'
 export { discoverThemes, discoverThemeRouteFiles } from './themes.mjs'
 export { discoverTemplates, discoverThemeTemplates } from './templates.mjs'
 export { discoverBlocks } from './blocks.mjs'
@@ -17,3 +18,4 @@ export { discoverPermissionsConfig } from './permissions.mjs'
 export { discoverAuthConfig } from './auth.mjs'
 export { discoverParentChildRelations } from './parent-child.mjs'
 export { discoverCoreRoutes } from './core-routes.mjs'
+export { discoverApiPresets } from './api-presets.mjs'

package/scripts/build/registry/discovery/permissions.mjs

@@ -103,7 +103,19 @@ function parseEntitiesFromConfig(content) {
   const entitiesContent = entitiesMatch[1]
 
   // Match each entity block: entityName: [ ... ]
-  const entityBlockRegex = /(\w+):\s*\[([\s\S]*?)\],?\s*(?=\n\s*\/\/|$|\n\s*\w+:)/g
+  // Supports: customers:, "ai-agents":, 'landing-metrics':
+  // The key can be:
+  //   - Simple word: customers
+  //   - Quoted with hyphens: "ai-agents" or 'ai-agents'
+  //
+  // IMPORTANT: The closing bracket must be at the start of a line (after newline + whitespace)
+  // This prevents matching `]` inside nested arrays like `roles: ['owner', 'admin']`
+  // which appear in the MIDDLE of a line, not at the start.
+  //
+  // The regex requires:
+  //   - Entity key at start of line (newline + whitespace)
+  //   - Closing bracket at start of line (newline + whitespace)
+  const entityBlockRegex = /\n\s*['"]?([\w-]+)['"]?:\s*\[([\s\S]*?)\n\s*\]/g
   let entityMatch
 
   while ((entityMatch = entityBlockRegex.exec(entitiesContent)) !== null) {
@@ -146,6 +158,71 @@ function parseEntitiesFromConfig(content) {
   return entities
 }
 
+/**
+ * Parse a flat array of permission action objects from a named section
+ * Works for both `teams: [...]` and `features: [...]`
+ * Each item has: action, label, description, roles, category?, dangerous?
+ *
+ * @param {string} content - Full file content
+ * @param {string} sectionName - Section name ('teams' or 'features')
+ * @returns {Array} Parsed permission actions
+ */
+function parseActionArrayFromConfig(content, sectionName) {
+  const results = []
+
+  // Find the section: sectionName: [ ... ]
+  // The closing bracket must be at column 2 (two-space indent) followed by ],
+  const sectionRegex = new RegExp(`${sectionName}:\\s*\\[([\\s\\S]*?)\\n  \\],?\\s*\\n`)
+  const sectionMatch = content.match(sectionRegex)
+  if (!sectionMatch) {
+    verbose(`No ${sectionName} section found in permissions.config.ts`)
+    return results
+  }
+
+  const sectionContent = sectionMatch[1]
+
+  // Match each action object { ... }
+  // Handles both single-line: { action: 'x', ... }
+  // and multi-line: {\n  action: 'x',\n  ...\n}
+  const actionRegex = /\{[^}]+\}/g
+  let actionMatch
+
+  while ((actionMatch = actionRegex.exec(sectionContent)) !== null) {
+    const block = actionMatch[0]
+
+    // Extract action (supports dotted names like 'media.upload', 'team.view')
+    const actionKeyMatch = block.match(/action:\s*['"]([^'"]+)['"]/)
+    if (!actionKeyMatch) continue
+    const action = actionKeyMatch[1]
+
+    // Extract label
+    const labelMatch = block.match(/label:\s*['"]([^'"]+)['"]/)
+    const label = labelMatch ? labelMatch[1] : action
+
+    // Extract description
+    const descMatch = block.match(/description:\s*['"]([^'"]+)['"]/)
+    const description = descMatch ? descMatch[1] : null
+
+    // Extract category (features have this, teams don't)
+    const categoryMatch = block.match(/category:\s*['"]([^'"]+)['"]/)
+    const category = categoryMatch ? categoryMatch[1] : null
+
+    // Extract roles
+    const rolesMatch = block.match(/roles:\s*\[([^\]]+)\]/)
+    const roles = rolesMatch
+      ? rolesMatch[1].split(',').map(r => r.trim().replace(/['"]/g, ''))
+      : ['owner', 'admin']
+
+    // Extract dangerous
+    const dangerousMatch = block.match(/dangerous:\s*(true|false)/)
+    const dangerous = dangerousMatch ? dangerousMatch[1] === 'true' : false
+
+    results.push({ action, label, description, category, roles, dangerous })
+  }
+
+  return results
+}
+
 /**
  * Discover permissions configuration from active theme
  * Returns null if theme doesn't have a permissions.config.ts
@@ -168,19 +245,29 @@ export async function discoverPermissionsConfig(config = DEFAULT_CONFIG) {
 
   log(`Found permissions.config.ts for theme ${themeName}`, 'success')
 
-  // Parse entities and roles from the config file
+  // Parse entities, roles, teams, and features from the config file
   let entities = {}
   let roles = null
+  let teams = []
+  let features = []
   try {
     const content = readFileSync(permissionsPath, 'utf8')
     entities = parseEntitiesFromConfig(content)
     roles = parseRolesFromConfig(content)
+    teams = parseActionArrayFromConfig(content, 'teams')
+    features = parseActionArrayFromConfig(content, 'features')
 
     const entityCount = Object.keys(entities).length
     const permCount = Object.values(entities).reduce((acc, arr) => acc + arr.length, 0)
     if (entityCount > 0) {
       log(`  📋 Parsed ${permCount} entity permissions across ${entityCount} entities`, 'info')
     }
+    if (teams.length > 0) {
+      log(`  🔑 Parsed ${teams.length} team permissions`, 'info')
+    }
+    if (features.length > 0) {
+      log(`  ⚡ Parsed ${features.length} feature permissions`, 'info')
+    }
     if (roles && roles.additionalRoles) {
       log(`  👥 Parsed ${roles.additionalRoles.length} custom roles: ${roles.additionalRoles.join(', ')}`, 'info')
     }
@@ -193,6 +280,8 @@ export async function discoverPermissionsConfig(config = DEFAULT_CONFIG) {
     importPath: `@/contents/themes/${themeName}/config/permissions.config`,
     themeName,
     entities,
-    roles
+    roles,
+    teams,
+    features
   }
 }

package/scripts/build/registry/discovery/permissions.test.mjs

@@ -0,0 +1,256 @@
+/**
+ * Unit tests for parseEntitiesFromConfig function
+ *
+ * Run with: node --test packages/core/scripts/build/registry/discovery/permissions.test.mjs
+ */
+
+import { describe, it } from 'node:test'
+import assert from 'node:assert'
+
+// Import the regex pattern directly since parseEntitiesFromConfig is not exported
+// We'll test the regex patterns directly
+
+/**
+ * Test the entity block regex pattern
+ */
+describe('Entity Block Regex', () => {
+  // The regex pattern from permissions.mjs (MUST match the actual implementation!)
+  // IMPORTANT: The closing bracket must be at the start of a line (after newline + whitespace)
+  // This prevents matching `]` inside nested arrays like `roles: ['owner', 'admin']`
+  const entityBlockRegex = /\n\s*['"]?([\w-]+)['"]?:\s*\[([\s\S]*?)\n\s*\]/g
+
+  it('should match simple entity keys', () => {
+    const content = `
+    customers: [
+      { action: 'create', roles: ['owner'] }
+    ],
+    tasks: [
+      { action: 'read', roles: ['member'] }
+    ]
+    }`
+
+    const matches = [...content.matchAll(entityBlockRegex)]
+    assert.strictEqual(matches.length, 2)
+    assert.strictEqual(matches[0][1], 'customers')
+    assert.strictEqual(matches[1][1], 'tasks')
+  })
+
+  it('should match quoted entity keys with hyphens (double quotes)', () => {
+    const content = `
+    "ai-agents": [
+      { action: 'create', roles: ['owner'] }
+    ],
+    "landing-pages": [
+      { action: 'read', roles: ['member'] }
+    ]
+    }`
+
+    const matches = [...content.matchAll(entityBlockRegex)]
+    assert.strictEqual(matches.length, 2)
+    assert.strictEqual(matches[0][1], 'ai-agents')
+    assert.strictEqual(matches[1][1], 'landing-pages')
+  })
+
+  it('should match quoted entity keys with hyphens (single quotes)', () => {
+    const content = `
+    'ai-agents': [
+      { action: 'create', roles: ['owner'] }
+    ],
+    'user-profiles': [
+      { action: 'read', roles: ['member'] }
+    ]
+    }`
+
+    const matches = [...content.matchAll(entityBlockRegex)]
+    assert.strictEqual(matches.length, 2)
+    assert.strictEqual(matches[0][1], 'ai-agents')
+    assert.strictEqual(matches[1][1], 'user-profiles')
+  })
+
+  it('should match mixed quoted and unquoted keys', () => {
+    const content = `
+    customers: [
+      { action: 'create', roles: ['owner'] }
+    ],
+    "ai-agents": [
+      { action: 'read', roles: ['member'] }
+    ],
+    tasks: [
+      { action: 'update', roles: ['admin'] }
+    ]
+    }`
+
+    const matches = [...content.matchAll(entityBlockRegex)]
+    assert.strictEqual(matches.length, 3)
+    assert.strictEqual(matches[0][1], 'customers')
+    assert.strictEqual(matches[1][1], 'ai-agents')
+    assert.strictEqual(matches[2][1], 'tasks')
+  })
+
+  it('should handle last entity without trailing comma', () => {
+    const content = `
+    customers: [
+      { action: 'create', roles: ['owner'] }
+    ],
+    tasks: [
+      { action: 'read', roles: ['member'] }
+    ]
+    }`
+
+    const matches = [...content.matchAll(entityBlockRegex)]
+    assert.strictEqual(matches.length, 2)
+    assert.strictEqual(matches[1][1], 'tasks')
+  })
+
+  it('should handle entity followed by closing brace', () => {
+    const content = `
+    customers: [
+      { action: 'create', roles: ['owner'] }
+    ]
+  }`
+
+    const matches = [...content.matchAll(entityBlockRegex)]
+    assert.strictEqual(matches.length, 1)
+    assert.strictEqual(matches[0][1], 'customers')
+  })
+
+  it('should handle entities with comments between them', () => {
+    const content = `
+    customers: [
+      { action: 'create', roles: ['owner'] }
+    ],
+    // This is a comment about tasks
+    tasks: [
+      { action: 'read', roles: ['member'] }
+    ]
+    }`
+
+    const matches = [...content.matchAll(entityBlockRegex)]
+    assert.strictEqual(matches.length, 2)
+    assert.strictEqual(matches[0][1], 'customers')
+    assert.strictEqual(matches[1][1], 'tasks')
+  })
+
+  it('should handle entity with multiple hyphens', () => {
+    const content = `
+    "ai-landing-page-templates": [
+      { action: 'create', roles: ['owner'] }
+    ]
+    }`
+
+    const matches = [...content.matchAll(entityBlockRegex)]
+    assert.strictEqual(matches.length, 1)
+    assert.strictEqual(matches[0][1], 'ai-landing-page-templates')
+  })
+
+  it('should handle empty actions array (multiline format)', () => {
+    // Note: Empty arrays on a single line (e.g., "customers: [],") won't be matched
+    // because the regex requires the closing ] to be on its own line.
+    // In practice, if you define permissions for an entity, you'd have at least one.
+    // This test covers the multiline empty array case.
+    const content = `
+    customers: [
+    ],
+    tasks: [
+      { action: 'read', roles: ['member'] }
+    ]
+    }`
+
+    const matches = [...content.matchAll(entityBlockRegex)]
+    assert.strictEqual(matches.length, 2)
+    assert.strictEqual(matches[0][1], 'customers')
+    assert.strictEqual(matches[0][2].trim(), '')
+  })
+
+  /**
+   * CRITICAL TEST: This is the exact bug that broke beta.62
+   * The regex was matching `roles: ['owner', 'admin']` inside action objects
+   * as if it were an entity key, causing "Invalid entity slug: roles" errors.
+   */
+  it('should NOT match roles inside action objects as entity keys', () => {
+    // This is the exact structure from a real permissions.config.ts
+    const content = `
+    patterns: [
+      { action: 'create', label: 'Create Patterns', description: 'Can create patterns', roles: ['owner', 'admin'] },
+      { action: 'read', label: 'View Patterns', description: 'Can view patterns', roles: ['owner', 'admin', 'member'] },
+      { action: 'delete', label: 'Delete Patterns', description: 'Can delete patterns', roles: ['owner', 'admin'], dangerous: true },
+    ],
+
+    'ai-agents': [
+      { action: 'create', label: 'Create AI Agents', description: 'Can create agents', roles: ['owner', 'admin'] },
+      { action: 'read', label: 'View AI Agents', description: 'Can view agents', roles: ['owner', 'admin', 'member'] },
+    ],
+
+    analysis: [
+      { action: 'create', label: 'Create Analysis', description: 'Can create analyses', roles: ['owner'] },
+      { action: 'read', label: 'View Analysis', description: 'Can view analyses', roles: ['owner', 'admin', 'member'] },
+    ],
+  }`
+
+    const matches = [...content.matchAll(entityBlockRegex)]
+
+    // Should find exactly 3 entity keys: patterns, ai-agents, analysis
+    // Should NOT find 'roles' as an entity key
+    assert.strictEqual(matches.length, 3, `Expected 3 entities but found ${matches.length}: ${matches.map(m => m[1]).join(', ')}`)
+
+    const entityNames = matches.map(m => m[1])
+    assert.ok(entityNames.includes('patterns'), 'Should include patterns')
+    assert.ok(entityNames.includes('ai-agents'), 'Should include ai-agents')
+    assert.ok(entityNames.includes('analysis'), 'Should include analysis')
+    assert.ok(!entityNames.includes('roles'), 'Should NOT include roles (that\'s inside action objects)')
+  })
+
+  it('should handle real-world permissions config structure', () => {
+    // Mimics the exact indentation and structure of a real config file
+    const content = `
+    // PATTERNS ENTITY
+    patterns: [
+      { action: 'create', label: 'Create', roles: ['owner', 'admin'] },
+      { action: 'read', label: 'Read', roles: ['owner', 'admin', 'member'] },
+    ],
+
+    // AI-AGENTS ENTITY (hyphenated, quoted)
+    'ai-agents': [
+      { action: 'create', label: 'Create', roles: ['owner'] },
+    ],
+  }`
+
+    const matches = [...content.matchAll(entityBlockRegex)]
+    assert.strictEqual(matches.length, 2)
+    assert.strictEqual(matches[0][1], 'patterns')
+    assert.strictEqual(matches[1][1], 'ai-agents')
+  })
+})
+
+/**
+ * Test the action regex pattern
+ */
+describe('Action Block Regex', () => {
+  const actionRegex = /\{\s*action:\s*['"](\w+)['"][^}]*\}/g
+
+  it('should extract action names', () => {
+    const content = `
+      { action: 'create', label: 'Create', roles: ['owner'] },
+      { action: 'read', label: 'Read', roles: ['member'] },
+      { action: 'update', label: 'Update', roles: ['admin'] }
+    `
+
+    const matches = [...content.matchAll(actionRegex)]
+    assert.strictEqual(matches.length, 3)
+    assert.strictEqual(matches[0][1], 'create')
+    assert.strictEqual(matches[1][1], 'read')
+    assert.strictEqual(matches[2][1], 'update')
+  })
+
+  it('should handle action with dangerous flag', () => {
+    const content = `
+      { action: 'delete', label: 'Delete', roles: ['owner'], dangerous: true }
+    `
+
+    const matches = [...content.matchAll(actionRegex)]
+    assert.strictEqual(matches.length, 1)
+    assert.strictEqual(matches[0][1], 'delete')
+  })
+})
+
+console.log('\n✅ All permission parsing tests passed!\n')

package/scripts/build/registry/discovery/plugins.mjs

@@ -137,11 +137,31 @@ export async function discoverPlugins(config = DEFAULT_CONFIG) {
           // No entities directory in plugin
         }
 
-        // Check for messages, assets
+        // Check for settings areas (settings/<area>/)
+        const settingsPath = join(pluginsDir, pluginName, 'settings')
+        let pluginSettings = []
+
+        try {
+          const settingsDirs = await readdir(settingsPath, { withFileTypes: true })
+          for (const dir of settingsDirs.filter(e => e.isDirectory())) {
+            const area = dir.name
+            const areaPath = join(settingsPath, area)
+            const migrationsPath = join(areaPath, 'migrations')
+            const hasMigrations = existsSync(migrationsPath)
+            pluginSettings.push({ area, hasMigrations })
+            verbose(`Plugin ${pluginName} settings/${area}${hasMigrations ? ' (migrations)' : ''}`)
+          }
+        } catch {
+          // No settings directory
+        }
+
+        // Check for messages, assets, pages server
         const messagesPath = join(pluginsDir, pluginName, 'messages')
         const assetsPath = join(pluginsDir, pluginName, 'assets')
+        const pagesServerPath = join(pluginsDir, pluginName, 'plugin.pages.server.ts')
         const hasMessages = existsSync(messagesPath)
         const hasAssets = existsSync(assetsPath)
+        const hasPagesServer = existsSync(pagesServerPath)
 
         plugins.push({
           name: pluginName,
@@ -151,13 +171,16 @@ export async function discoverPlugins(config = DEFAULT_CONFIG) {
           apiPath: hasAPI ? `@/contents/plugins/${pluginName}/api` : null,
           routeFiles,
           entities: pluginEntities,
+          settings: pluginSettings,
           hasMessages,
-          hasAssets
+          hasAssets,
+          hasPagesServer
         })
 
         const info = [
           hasAPI && `API [${routeFiles.length} routes]`,
           pluginEntities.length > 0 && `${pluginEntities.length} entities`,
+          pluginSettings.length > 0 && `settings [${pluginSettings.map(s => s.area).join(', ')}]`,
           hasMessages && 'messages',
           hasAssets && 'assets'
         ].filter(Boolean).join(', ')