@nextsparkjs/core 0.1.0-beta.7 → 0.1.0-beta.70

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) {

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')