@team-codeme/crud-forge 0.0.0-stage → 1.0.0

package/src/templates/fuse-packs/access-control-tools/lib/ts-component-index.js

@@ -0,0 +1,482 @@
+'use strict';
+
+/**
+ * TypeScript Compiler API index of Angular @Component metadata.
+ * Indexes every component declaration (multi-component files included):
+ * selector, template/templateUrl, class name, SCREEN / DEFAULT_SCREEN, imports.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { createRequire } = require('module');
+const { duplicatePrimaryRank } = require('./id-rules');
+
+function loadTypescript() {
+  try {
+    return require(require.resolve('typescript', { paths: [process.cwd(), __dirname] }));
+  } catch {
+    try {
+      return createRequire(path.join(process.cwd(), 'package.json'))('typescript');
+    } catch {
+      throw new Error(
+        'access-control hierarchy scanner requires the `typescript` package (installed in generated Angular apps).'
+      );
+    }
+  }
+}
+const ts = loadTypescript();
+
+const SKIP_DIR_RE = /(?:^|[/\\])(?:node_modules|\.git|dist|coverage|out-tsc)(?:[/\\]|$)/;
+const SPEC_RE = /\.spec\.ts$/i;
+
+function readSafe(filePath) {
+  try {
+    return fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+function walkTsFiles(dir, out = []) {
+  if (!dir || !fs.existsSync(dir)) {
+    return out;
+  }
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (SKIP_DIR_RE.test(full)) {
+        continue;
+      }
+      walkTsFiles(full, out);
+    } else if (entry.isFile() && full.endsWith('.ts') && !SPEC_RE.test(full)) {
+      out.push(full);
+    }
+  }
+  return out;
+}
+
+function decoratorName(decorator) {
+  const expr = decorator.expression;
+  if (ts.isCallExpression(expr)) {
+    if (ts.isIdentifier(expr.expression)) {
+      return expr.expression.text;
+    }
+    if (ts.isPropertyAccessExpression(expr.expression)) {
+      return expr.expression.name.text;
+    }
+  }
+  if (ts.isIdentifier(expr)) {
+    return expr.text;
+  }
+  return null;
+}
+
+function decoratorObjectLiteral(decorator) {
+  const expr = decorator.expression;
+  if (!ts.isCallExpression(expr) || !expr.arguments.length) {
+    return null;
+  }
+  const arg = expr.arguments[0];
+  return ts.isObjectLiteralExpression(arg) ? arg : null;
+}
+
+function objectProp(obj, name) {
+  if (!obj) {
+    return null;
+  }
+  for (const prop of obj.properties) {
+    if (!ts.isPropertyAssignment(prop)) {
+      continue;
+    }
+    const key =
+      (ts.isIdentifier(prop.name) && prop.name.text) ||
+      (ts.isStringLiteral(prop.name) && prop.name.text) ||
+      null;
+    if (key === name) {
+      return prop.initializer;
+    }
+  }
+  return null;
+}
+
+function stringValue(node) {
+  if (!node) {
+    return null;
+  }
+  if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+    return node.text;
+  }
+  return null;
+}
+
+function firstAppElementSelector(selectorText) {
+  if (!selectorText) {
+    return '';
+  }
+  return (
+    selectorText
+      .split(',')
+      .map((s) => s.trim())
+      .find((s) => /^app-[a-z0-9-]+$/i.test(s)) || ''
+  ).toLowerCase();
+}
+
+function importIdentifiers(initializer) {
+  const names = [];
+  if (!initializer || !ts.isArrayLiteralExpression(initializer)) {
+    return names;
+  }
+  for (const el of initializer.elements) {
+    if (ts.isIdentifier(el)) {
+      names.push(el.text);
+    }
+  }
+  return names;
+}
+
+function memberHasInputDecorator(member) {
+  const decorators = ts.canHaveDecorators(member) ? ts.getDecorators(member) : undefined;
+  return (decorators || []).some((d) => decoratorName(d) === 'Input');
+}
+
+/**
+ * Own-screen identity only — skip `@Input() SCREEN` (hostScreen passthrough on embeds).
+ */
+function extractScreenId(classNode, sourceFile) {
+  // 1) readonly/field SCREEN / DEFAULT_SCREEN (not @Input)
+  for (const member of classNode.members) {
+    if (!ts.isPropertyDeclaration(member) || !member.name || !ts.isIdentifier(member.name)) {
+      continue;
+    }
+    const name = member.name.text;
+    if (name !== 'SCREEN' && name !== 'DEFAULT_SCREEN') {
+      continue;
+    }
+    if (memberHasInputDecorator(member)) {
+      // Embed cards often expose @Input() SCREEN for the host page — not their own id.
+      continue;
+    }
+    const value = stringValue(member.initializer);
+    if (value) {
+      return value;
+    }
+  }
+  // 2) get SCREEN() with @Input() screenId default
+  for (const member of classNode.members) {
+    if (
+      ts.isGetAccessorDeclaration(member) &&
+      member.name &&
+      ts.isIdentifier(member.name) &&
+      member.name.text === 'SCREEN'
+    ) {
+      break;
+    }
+  }
+  for (const member of classNode.members) {
+    if (!ts.isPropertyDeclaration(member) || !member.name || !ts.isIdentifier(member.name)) {
+      continue;
+    }
+    if (member.name.text !== 'screenId') {
+      continue;
+    }
+    if (!memberHasInputDecorator(member)) {
+      continue;
+    }
+    const value = stringValue(member.initializer);
+    if (value) {
+      return value;
+    }
+  }
+  return null;
+}
+
+/** Prefer real page/list hosts when duplicate SCREEN ids exist in the tree. */
+function screenOwnerScore(meta) {
+  let score = 0;
+  const className = meta.className || '';
+  const file = (meta.tsFile || '').replace(/\\/g, '/');
+  const sourceType = meta.sourceType || '';
+  // Align with sync disambiguation: lower module rank → higher score
+  score += Math.max(0, 20 - duplicatePrimaryRank(file) * 2);
+  if (sourceType === 'pages' || file.includes('/pages/')) {
+    score += 8;
+  }
+  if (/-(list|page)$/.test(meta.screenId || '') || (meta.screenId || '').endsWith('-management-list')) {
+    score += 4;
+  }
+  if (/Card|Dialog|Drawer|Filter|Actions|Dropdown|Summary|Header/i.test(className)) {
+    score -= 6;
+  }
+  if (memberLooksLikeHostFile(file, meta.screenId)) {
+    score += 5;
+  }
+  if (meta.templateContent && /<app-[a-z0-9-]+\b/i.test(meta.templateContent)) {
+    score += 2;
+  }
+  return score;
+}
+
+function memberLooksLikeHostFile(file, screenId) {
+  if (!file || !screenId) {
+    return false;
+  }
+  const base = path.basename(file).replace(/\.ts$/i, '');
+  const normalized = screenId.replace(/-/g, '');
+  const fileNorm = base.replace(/\.component$/i, '').replace(/-/g, '');
+  return fileNorm.includes(normalized) || normalized.includes(fileNorm);
+}
+
+/**
+ * @returns {Array<{
+ *   tsFile: string,
+ *   className: string,
+ *   selector: string,
+ *   screenId: string|null,
+ *   templateUrl: string|null,
+ *   inlineTemplate: string|null,
+ *   standalone: boolean|null,
+ *   importNames: string[],
+ *   sourceText: string
+ * }>}
+ */
+function extractComponentsFromFile(tsFile, sourceText) {
+  if (!sourceText || !sourceText.includes('@Component')) {
+    return [];
+  }
+  const sourceFile = ts.createSourceFile(
+    tsFile,
+    sourceText,
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.TS
+  );
+  const results = [];
+
+  const visit = (node) => {
+    if (ts.isClassDeclaration(node) && node.name) {
+      const decorators = ts.canHaveDecorators(node) ? ts.getDecorators(node) : undefined;
+      const componentDecorator = (decorators || []).find((d) => decoratorName(d) === 'Component');
+      if (componentDecorator) {
+        const obj = decoratorObjectLiteral(componentDecorator);
+        const selectorRaw = stringValue(objectProp(obj, 'selector'));
+        const templateUrl = stringValue(objectProp(obj, 'templateUrl'));
+        const inlineTemplate = stringValue(objectProp(obj, 'template'));
+        const standaloneInit = objectProp(obj, 'standalone');
+        let standalone = null;
+        if (standaloneInit && standaloneInit.kind === ts.SyntaxKind.TrueKeyword) {
+          standalone = true;
+        } else if (standaloneInit && standaloneInit.kind === ts.SyntaxKind.FalseKeyword) {
+          standalone = false;
+        }
+        results.push({
+          tsFile,
+          className: node.name.text,
+          selector: firstAppElementSelector(selectorRaw),
+          screenId: extractScreenId(node, sourceFile),
+          templateUrl,
+          inlineTemplate,
+          standalone,
+          importNames: importIdentifiers(objectProp(obj, 'imports')),
+          sourceText,
+        });
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return results;
+}
+
+function loadTemplate(component) {
+  if (component.inlineTemplate) {
+    return { html: component.inlineTemplate, htmlPath: component.tsFile };
+  }
+  if (component.templateUrl) {
+    const htmlPath = path.resolve(path.dirname(component.tsFile), component.templateUrl);
+    return { html: readSafe(htmlPath), htmlPath: fs.existsSync(htmlPath) ? htmlPath : '' };
+  }
+  return { html: '', htmlPath: '' };
+}
+
+/**
+ * Build a selector/class/screen index for Angular components under the given roots.
+ * @param {string[]} roots absolute directories
+ */
+function buildComponentCatalog(roots) {
+  /** @type {Map<string, any>} */
+  const bySelector = new Map();
+  /** @type {Map<string, any>} */
+  const byClassName = new Map();
+  /** @type {Map<string, any>} */
+  const byScreenId = new Map();
+  /** @type {any[]} */
+  const components = [];
+
+  const files = [];
+  for (const root of roots) {
+    walkTsFiles(root, files);
+  }
+
+  for (const tsFile of files) {
+    const sourceText = readSafe(tsFile);
+    if (!sourceText.includes('@Component')) {
+      continue;
+    }
+    const extracted = extractComponentsFromFile(tsFile, sourceText);
+    for (const comp of extracted) {
+      const { html, htmlPath } = loadTemplate(comp);
+      const meta = {
+        ...comp,
+        templateContent: html,
+        htmlPath,
+      };
+      components.push(meta);
+      if (meta.selector) {
+        // Prefer the declaration that carries a SCREEN when selectors collide.
+        const existing = bySelector.get(meta.selector);
+        if (!existing || (!existing.screenId && meta.screenId)) {
+          bySelector.set(meta.selector, meta);
+        }
+      }
+      if (meta.className) {
+        byClassName.set(meta.className, meta);
+      }
+      if (meta.screenId) {
+        const prev = byScreenId.get(meta.screenId);
+        if (!prev || screenOwnerScore(meta) > screenOwnerScore(prev)) {
+          byScreenId.set(meta.screenId, meta);
+        }
+      }
+    }
+  }
+
+  return { components, bySelector, byClassName, byScreenId, fileCount: files.length };
+}
+
+/**
+ * Statically resolve loadComponent / loadChildren / component: ClassName in route files.
+ * @returns {Array<{ className: string, path: string, routesFile: string, kind: string }>}
+ */
+function extractRouteComponentHits(routesFile, sourceText) {
+  const hits = [];
+  if (!sourceText) {
+    return hits;
+  }
+
+  // component: ClassName
+  const componentRe = /\{\s*path\s*:\s*['"]([^'"]*)['"]\s*,\s*component\s*:\s*(\w+)/g;
+  let match;
+  while ((match = componentRe.exec(sourceText)) !== null) {
+    hits.push({
+      path: match[1],
+      className: match[2],
+      routesFile,
+      kind: 'component',
+    });
+  }
+
+  // loadComponent: () => import('...').then(m => m.ClassName)
+  const loadComponentRe =
+    /path\s*:\s*['"]([^'"]*)['"]\s*,\s*loadComponent\s*:\s*\(\)\s*=>\s*import\(\s*['"]([^'"]+)['"]\s*\)(?:\s*\.then\(\s*(?:\(m\)|m)\s*=>\s*m\.(\w+)\s*\))?/g;
+  while ((match = loadComponentRe.exec(sourceText)) !== null) {
+    const routePath = match[1];
+    const importPath = match[2];
+    let className = match[3] || '';
+    if (!className) {
+      // Bare default import — resolve file and take first @Component class.
+      const resolved = resolveImportToTs(routesFile, importPath);
+      if (resolved) {
+        const comps = extractComponentsFromFile(resolved, readSafe(resolved));
+        if (comps[0]) {
+          className = comps[0].className;
+        }
+      }
+    }
+    if (className) {
+      hits.push({
+        path: routePath,
+        className,
+        routesFile,
+        kind: 'loadComponent',
+        importPath,
+      });
+    }
+  }
+
+  // loadChildren path markers (prefix resolution handled by hierarchy)
+  const loadChildrenRe =
+    /path\s*:\s*['"]([^'"]+)['"]\s*,\s*loadChildren\s*:\s*\(\)\s*=>\s*import\(\s*['"]([^'"]+)['"]\s*\)/g;
+  while ((match = loadChildrenRe.exec(sourceText)) !== null) {
+    hits.push({
+      path: match[1],
+      className: '',
+      routesFile,
+      kind: 'loadChildren',
+      importPath: match[2],
+    });
+  }
+
+  return hits;
+}
+
+function resolveImportToTs(fromFile, importPath) {
+  const base = path.resolve(path.dirname(fromFile), importPath);
+  const candidates = [`${base}.ts`, path.join(base, 'index.ts'), base];
+  for (const c of candidates) {
+    if (fs.existsSync(c) && c.endsWith('.ts')) {
+      return c;
+    }
+  }
+  return null;
+}
+
+/**
+ * Classify why a selector was historically unresolved / has no SCREEN embed.
+ */
+function classifyRootCause(opts) {
+  const { selector, childMeta, hostFile } = opts;
+  if (!childMeta) {
+    return {
+      code: 'selector_not_found',
+      detail: `No @Component with selector '${selector}' under scanned apps trees`,
+    };
+  }
+  const childFile = (childMeta.tsFile || '').replace(/\\/g, '/');
+  if (!childMeta.screenId) {
+    if (childFile.includes('/shared/')) {
+      return {
+        code: 'shared_component_without_screen',
+        detail: 'Resolved under shared/; no SCREEN / DEFAULT_SCREEN — not an RBAC embed',
+      };
+    }
+    if (!path.basename(childFile).endsWith('.component.ts')) {
+      return {
+        code: 'non_component_filename_without_screen',
+        detail: 'Resolved via AST; filename is not *.component.ts and has no SCREEN',
+      };
+    }
+    return {
+      code: 'component_without_screen',
+      detail: 'Component resolved but declares no SCREEN / DEFAULT_SCREEN',
+    };
+  }
+  // Has screen — if parent somehow still failed historically, multi-component index
+  if (childFile.includes('damage-loss-record-form.component.ts') || hostFile) {
+    return {
+      code: 'multi_component_file',
+      detail: 'Multiple @Component declarations in one file; selector now bound to SCREEN class',
+    };
+  }
+  return { code: 'resolved', detail: 'Indexed via TypeScript AST' };
+}
+
+module.exports = {
+  buildComponentCatalog,
+  extractComponentsFromFile,
+  extractRouteComponentHits,
+  resolveImportToTs,
+  classifyRootCause,
+  loadTemplate,
+  walkTsFiles,
+  screenOwnerScore,
+};

package/src/templates/fuse-packs/access-control-tools/run.sh

@@ -0,0 +1,223 @@
+#!/usr/bin/env bash
+# Access Control + QA ID runner
+# Scans micro-functions and pages (custom screens), injects SCREEN / accessCtrl / QA ids,
+# and updates screen-components.csv.
+#
+# Usage (from anywhere):
+#   ./run.sh                 # uses MODE preference below (default: apply)
+#   ./run.sh dry-run         # report only
+#   ./run.sh apply           # write ids + CSV
+#   ./run.sh all             # dry-run, then apply
+#   ./run.sh --help
+#
+# Examples:
+#   bash src/app/domains/admin/modules/apps/shared/access-control-tools/run.sh
+#   bash .../run.sh dry-run
+#   MODE=dry-run bash .../run.sh
+
+set -euo pipefail
+
+# ── Preferences (override via env or CLI) ─────────────────────────────────────
+# MODE: dry-run | apply | all
+# Default dry-run so accidental apply cannot thrash Keycloak-facing SCREEN ids.
+MODE="${MODE:-dry-run}"
+
+# When applying, normalize legacy noisy ids to qa-{screen}__{action}
+REWRITE_IDS="${REWRITE_IDS:-true}"
+
+# When applying, drop CSV rows not rediscovered in this scan
+# Keep false by default after product renames (regional-office-*).
+PRUNE_CSV="${PRUNE_CSV:-false}"
+
+# Rebuild SCREEN from template heading + view.
+# Default false for CRUDForge Fuse: generated entities keep nav-aligned
+# `{micro-functions|microservice}/{entity}` SCREEN values. Set true when
+# stamping custom pages under apps/pages with heading-based ids.
+FORCE_CONTENT_IDS="${FORCE_CONTENT_IDS:-false}"
+
+# Scope: all apps/* trees except shared/enums (micro-functions, microservice, pages, …)
+# ─────────────────────────────────────────────────────────────────────────────
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Resolve repo root (directory that contains package.json)
+find_repo_root() {
+  local dir="$SCRIPT_DIR"
+  while [[ "$dir" != "/" ]]; do
+    if [[ -f "$dir/package.json" ]]; then
+      echo "$dir"
+      return 0
+    fi
+    dir="$(dirname "$dir")"
+  done
+  return 1
+}
+
+REPO_ROOT="$(find_repo_root)" || {
+  echo "error: could not find repo root (package.json) from $SCRIPT_DIR" >&2
+  exit 1
+}
+
+SYNC_JS="$SCRIPT_DIR/access-control-sync.js"
+REPORT_REL="src/app/domains/admin/modules/apps/shared/access-control-tools/output/sync-report.json"
+CSV_REL="src/app/domains/admin/modules/apps/shared/access-control-tools/output/screen-components.csv"
+HIER_REL="src/app/domains/admin/modules/apps/shared/access-control-tools/output/screen-navigation-map.json"
+
+print_help() {
+  cat <<'EOF'
+Access Control & QA ID runner
+
+Scans (under modules/apps, excluding shared/enums):
+  • micro-functions / microservice  (generated + custom entities)
+  • pages                           (custom screens)
+
+Usage:
+  ./run.sh              Use MODE preference (default: dry-run)
+  ./run.sh dry-run      Report only → output/sync-report.json
+  ./run.sh apply        Write SCREEN, accessCtrl, QA ids, CSV
+  ./run.sh all          Dry-run first, then apply
+  ./run.sh -h | --help
+
+Environment preferences:
+  MODE=dry-run|apply|all          Default run mode (default: dry-run)
+  REWRITE_IDS=true|false          Normalize legacy ids on apply (default: true)
+  PRUNE_CSV=true|false            Prune stale CSV rows on apply (default: false)
+  FORCE_CONTENT_IDS=true|false    Rebuild SCREEN from page heading (default: false)
+
+Id / description rules:
+  • Generated entities use {folder}/{entity} SCREEN (nav ACL). Keep FORCE_CONTENT_IDS=false.
+  • Custom pages: FORCE_CONTENT_IDS=true → heading + view (e.g. book-list)
+  • componentId = semantic verb (create, open-filter, toggle-view, open-columns, …)
+  • Prefix CSV description with [manual] to lock a hand-written blurb
+
+Examples:
+  ./run.sh dry-run
+  ./run.sh apply
+  FORCE_CONTENT_IDS=true ./run.sh apply   # heading-based ids for custom pages
+  ./run.sh all
+EOF
+}
+
+parse_cli() {
+  if [[ $# -eq 0 ]]; then
+    return 0
+  fi
+
+  case "$1" in
+    -h|--help|help)
+      print_help
+      exit 0
+      ;;
+    dry-run|--dry-run)
+      MODE="dry-run"
+      ;;
+    apply|--apply|--write|write)
+      MODE="apply"
+      ;;
+    all|--all)
+      MODE="all"
+      ;;
+    *)
+      echo "error: unknown argument: $1" >&2
+      echo "Run ./run.sh --help for usage." >&2
+      exit 1
+      ;;
+  esac
+}
+
+require_node() {
+  if ! command -v node >/dev/null 2>&1; then
+    echo "error: node is required but not found on PATH" >&2
+    exit 1
+  fi
+  if [[ ! -f "$SYNC_JS" ]]; then
+    echo "error: missing sync script: $SYNC_JS" >&2
+    exit 1
+  fi
+}
+
+banner() {
+  echo ""
+  echo "══════════════════════════════════════════════════════════"
+  echo " Access Control / QA ID Sync"
+  echo "══════════════════════════════════════════════════════════"
+  echo " Repo:         $REPO_ROOT"
+  echo " Mode:         $MODE"
+  echo " Rewrite:      $REWRITE_IDS"
+  echo " Prune:        $PRUNE_CSV"
+  echo " Content ids:  $FORCE_CONTENT_IDS"
+  echo " Targets:      apps/* (micro-functions, microservice, pages, …)"
+  echo "══════════════════════════════════════════════════════════"
+  echo ""
+}
+
+run_sync() {
+  local -a args=("$@")
+  echo "→ node access-control-sync.js ${args[*]}"
+  echo ""
+  (
+    cd "$REPO_ROOT"
+    node "$SYNC_JS" "${args[@]}"
+  )
+}
+
+content_id_flags() {
+  case "${FORCE_CONTENT_IDS:-true}" in
+    true|1|yes|YES|True) echo --force-content-ids ;;
+    *) echo --keep-existing-screen ;;
+  esac
+}
+
+run_apply() {
+  local -a args=(--write)
+  case "${REWRITE_IDS:-true}" in
+    true|1|yes|YES|True) args+=(--rewrite-ids) ;;
+  esac
+  case "${PRUNE_CSV:-false}" in
+    true|1|yes|YES|True) args+=(--prune-csv) ;;
+  esac
+  args+=("$(content_id_flags)")
+  run_sync "${args[@]}"
+}
+
+print_report_hint() {
+  echo ""
+  echo "Report: $REPO_ROOT/$REPORT_REL"
+  echo "CSV:    $REPO_ROOT/$CSV_REL"
+echo "Nav map:$REPO_ROOT/$HIER_REL"
+  echo ""
+}
+
+main() {
+  parse_cli "$@"
+  require_node
+  banner
+
+  case "$MODE" in
+    dry-run)
+      run_sync --dry-run "$(content_id_flags)"
+      print_report_hint
+      echo "Dry-run complete. Re-run with:  ./run.sh apply"
+      ;;
+    apply)
+      run_apply
+      print_report_hint
+      echo "Apply complete. IDs written for micro-functions + pages."
+      ;;
+    all)
+      echo "── Step 1/2: dry-run ───────────────────────────────────"
+      run_sync --dry-run "$(content_id_flags)"
+      print_report_hint
+      echo "── Step 2/2: apply ─────────────────────────────────────"
+      run_apply
+      print_report_hint
+      echo "All done. Dry-run + apply finished."
+      ;;
+    *)
+      echo "error: invalid MODE='$MODE' (use dry-run | apply | all)" >&2
+      exit 1
+      ;;
+  esac
+}
+
+main "$@"