@researchdatabox/redbox-dev-tools 0.0.1-beta.8936

package/dist/generators/angular-app.js

@@ -0,0 +1,342 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AngularAppGenerator = void 0;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const ts_morph_1 = require("ts-morph");
+const generator_1 = require("../utils/generator");
+const config_helper_1 = require("../utils/config-helper");
+class AngularAppGenerator extends generator_1.Generator {
+    name;
+    ejsView;
+    auth;
+    paths;
+    project;
+    constructor(options) {
+        super(options);
+        this.name = options.name.toLowerCase();
+        this.ejsView = options.ejsView;
+        this.auth = options.auth;
+        this.paths = options.paths;
+        this.project = new ts_morph_1.Project();
+    }
+    async generate() {
+        // 1. Scaffold Angular app
+        this.scaffoldAngularApp();
+        // 2. Update angular.json
+        this.updateAngularJson();
+        // 3. Generate EJS view
+        this.generateEjsView();
+        // 4. Update route config
+        await this.updateRouteConfig();
+        // 5. Update auth config
+        if (this.auth && this.auth.length > 0) {
+            await this.updateAuthConfig();
+        }
+    }
+    scaffoldAngularApp() {
+        const projectRoot = path.join(this.paths.angular, 'projects', 'researchdatabox', this.name);
+        const srcRoot = path.join(projectRoot, 'src');
+        const appRoot = path.join(srcRoot, 'app');
+        const files = {
+            'tsconfig.app.json': JSON.stringify({
+                "extends": "../../../tsconfig.json",
+                "compilerOptions": {
+                    "outDir": "../../../dist/out-tsc",
+                    "types": []
+                },
+                "files": [
+                    "src/main.ts"
+                ],
+                "include": [
+                    "src/**/*.d.ts"
+                ]
+            }, null, 2),
+            'tsconfig.spec.json': JSON.stringify({
+                "extends": "../../../tsconfig.json",
+                "compilerOptions": {
+                    "outDir": "../../../dist/out-tsc",
+                    "types": [
+                        "jasmine"
+                    ]
+                },
+                "include": [
+                    "src/**/*.spec.ts",
+                    "src/**/*.d.ts"
+                ]
+            }, null, 2),
+            'src/main.ts': `import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
+import { ${this.toClassName(this.name)}Module } from './app/${this.name}.module';
+
+platformBrowserDynamic().bootstrapModule(${this.toClassName(this.name)}Module)
+  .catch(err => console.error(err));
+`,
+            'src/styles.scss': `/* Add application styles & imports to this file! */\n`,
+            'src/favicon.ico': '',
+            'src/assets/.gitkeep': '',
+            'src/index.html': `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>${this.toClassName(this.name)}</title>
+  <base href="/">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <link rel="icon" type="image/x-icon" href="favicon.ico">
+</head>
+<body>
+  <${this.name}></${this.name}>
+</body>
+</html>
+`,
+            [`src/app/${this.name}.module.ts`]: `import { NgModule } from '@angular/core';
+import { BrowserModule } from '@angular/platform-browser';
+import { APP_BASE_HREF, PlatformLocation, CommonModule } from '@angular/common';
+import { RedboxPortalCoreModule, trimLastSlashFromUrl } from '@researchdatabox/portal-ng-common';
+import { ${this.toClassName(this.name)}Component } from './${this.name}.component';
+
+@NgModule({
+  declarations: [
+    ${this.toClassName(this.name)}Component
+  ],
+  imports: [
+    BrowserModule,
+    CommonModule,
+    RedboxPortalCoreModule
+  ],
+  providers: [
+    {
+      provide: APP_BASE_HREF,
+      useFactory: (s: PlatformLocation) => trimLastSlashFromUrl(s.getBaseHrefFromDOM()),
+      deps: [PlatformLocation]
+    }
+  ],
+  bootstrap: [${this.toClassName(this.name)}Component]
+})
+export class ${this.toClassName(this.name)}Module { }
+`,
+            [`src/app/${this.name}.component.ts`]: `import { Component } from '@angular/core';
+
+@Component({
+  selector: '${this.name}',
+  templateUrl: './${this.name}.component.html',
+  styleUrls: ['./${this.name}.component.scss'],
+  standalone: false
+})
+export class ${this.toClassName(this.name)}Component {
+  title = '${this.name}';
+}
+`,
+            [`src/app/${this.name}.component.html`]: `<div class="container-fluid">
+  <h1>${this.toClassName(this.name)} App</h1>
+  <p>${this.name} works!</p>
+</div>
+`,
+            [`src/app/${this.name}.component.scss`]: ``,
+        };
+        for (const [relPath, content] of Object.entries(files)) {
+            this.writeFile(path.join(projectRoot, relPath), content);
+        }
+    }
+    updateAngularJson() {
+        const angularJsonPath = path.join(this.paths.angular, 'angular.json');
+        if (!fs.existsSync(angularJsonPath)) {
+            console.warn(`Warning: Could not find angular.json at ${angularJsonPath}`);
+            return;
+        }
+        let angularJson;
+        try {
+            angularJson = JSON.parse(fs.readFileSync(angularJsonPath, 'utf-8'));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`Error parsing angular.json at ${angularJsonPath}: ${message}`);
+            return;
+        }
+        const projectName = `@researchdatabox/${this.name}`;
+        if (typeof angularJson.projects !== 'object' || angularJson.projects === null) {
+            angularJson.projects = {};
+        }
+        if (angularJson.projects[projectName]) {
+            console.log(`  [SKIP] angular.json project ${projectName} already exists`);
+            return;
+        }
+        angularJson.projects[projectName] = {
+            "projectType": "application",
+            "schematics": {
+                "@schematics/angular:component": {
+                    "style": "scss"
+                }
+            },
+            "root": `projects/researchdatabox/${this.name}`,
+            "sourceRoot": `projects/researchdatabox/${this.name}/src`,
+            "prefix": "app",
+            "architect": {
+                "build": {
+                    "builder": "@angular-devkit/build-angular:application",
+                    "options": {
+                        "outputPath": {
+                            "base": `../assets/angular/${this.name}`
+                        },
+                        "index": `projects/researchdatabox/${this.name}/src/index.html`,
+                        "polyfills": [
+                            "zone.js"
+                        ],
+                        "tsConfig": `projects/researchdatabox/${this.name}/tsconfig.app.json`,
+                        "inlineStyleLanguage": "scss",
+                        "assets": [
+                            `projects/researchdatabox/${this.name}/src/favicon.ico`,
+                            `projects/researchdatabox/${this.name}/src/assets`
+                        ],
+                        "styles": [
+                            `projects/researchdatabox/${this.name}/src/styles.scss`
+                        ],
+                        "scripts": [],
+                        "browser": `projects/researchdatabox/${this.name}/src/main.ts`
+                    },
+                    "configurations": {
+                        "production": {
+                            "budgets": [
+                                {
+                                    "type": "initial",
+                                    "maximumWarning": "500kb",
+                                    "maximumError": "1mb"
+                                },
+                                {
+                                    "type": "anyComponentStyle",
+                                    "maximumWarning": "2kb",
+                                    "maximumError": "4kb"
+                                }
+                            ],
+                            "outputHashing": "all"
+                        },
+                        "development": {
+                            "optimization": false,
+                            "extractLicenses": false,
+                            "sourceMap": true
+                        }
+                    },
+                    "defaultConfiguration": "production"
+                }
+            }
+        };
+        this.writeFile(angularJsonPath, JSON.stringify(angularJson, null, 2));
+    }
+    generateEjsView() {
+        const safeViewName = this.getSafeEjsViewName();
+        const baseDir = path.join(this.root, 'views', 'default', 'default', 'admin');
+        const viewPath = path.resolve(baseDir, `${safeViewName}.ejs`);
+        if (!viewPath.startsWith(path.resolve(baseDir) + path.sep)) {
+            throw new Error(`EJS view name resolves outside the admin views directory: ${safeViewName}`);
+        }
+        const content = `<% let appName = '${this.name}'; %>
+<div class="row admin-layout">
+  <div class="col-md-3 col-lg-2">
+    <%- include('layout/sidebar.ejs') %>
+  </div>
+  <div class="col-md-9 col-lg-10 admin-main-content">
+    <${this.name} <% if (typeof contentSecurityPolicyNonce !== "undefined" && contentSecurityPolicyNonce) {%>ngCspNonce="<%= contentSecurityPolicyNonce %>"<% } %>>
+      <div class="col-xs-12">
+        <img class="center-block" src="<%= BrandingService.getRootContext() %>/images/loading.svg" alt="<%= TranslationService.t('loading-alt-text') %>">
+      </div>
+    </${this.name}>
+  </div>
+</div>
+<script src="<%= BrandingService.getRootContext() %>/angular/<%=appName%>/browser/polyfills<%=CacheService.getNgAppFileHash(appName, 'polyfills', '-') %>.js"
+   type="module"></script>
+
+<script src="<%= BrandingService.getRootContext() %>/angular/<%=appName%>/browser/main<%=CacheService.getNgAppFileHash(appName, 'main', '-') %>.js"
+   type="module"></script>
+<link rel="stylesheet" href="<%= BrandingService.getRootContext() %>/angular/<%= appName %>/browser/styles<%=CacheService.getNgAppFileHash(appName, 'styles', '-')%>.css">
+`;
+        this.writeFile(viewPath, content);
+    }
+    async updateRouteConfig() {
+        const route = `/:branding/:portal/admin/${this.name}`; // Defaulting to admin path
+        const safeViewName = this.getSafeEjsViewName();
+        // We can't use updateRoutes directly because it assumes a controller.action string
+        // But here we want a RouteTargetObject with locals.view
+        const routesPath = path.join(this.paths.coreTypes, 'src', 'config', 'routes.config.ts');
+        if (!fs.existsSync(routesPath))
+            return;
+        const sourceFile = this.project.addSourceFileAtPath(routesPath);
+        const routesVar = sourceFile.getVariableDeclaration('routes');
+        if (!routesVar)
+            return;
+        const initializer = routesVar.getInitializerIfKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
+        if (!initializer)
+            return;
+        if (!initializer.getProperty(`'${route}'`) && !initializer.getProperty(`"${route}"`)) {
+            initializer.addPropertyAssignment({
+                name: `'${route}'`,
+                initializer: `{
+                controller: 'RenderViewController',
+                action: 'render',
+                locals: { 'view': 'admin/${safeViewName}' }
+            }`
+            });
+        }
+        sourceFile.formatText();
+        if (!this.dryRun) {
+            await sourceFile.save();
+            console.log(`  [UPDATE] ${path.relative(this.root, routesPath)}`);
+        }
+    }
+    async updateAuthConfig() {
+        const route = `/:branding/:portal/admin/${this.name}`;
+        await (0, config_helper_1.updateAuth)({
+            project: this.project,
+            paths: this.paths,
+            root: this.root,
+            route: route,
+            auth: this.auth,
+            dryRun: this.dryRun
+        });
+    }
+    toClassName(name) {
+        return name.split('-').map(s => s.charAt(0).toUpperCase() + s.slice(1)).join('');
+    }
+    getSafeEjsViewName() {
+        const trimmed = this.ejsView.trim();
+        if (!trimmed) {
+            throw new Error('EJS view name cannot be empty.');
+        }
+        if (!/^[A-Za-z0-9_-]+$/.test(trimmed)) {
+            throw new Error(`EJS view name contains invalid characters: '${this.ejsView}'`);
+        }
+        return trimmed;
+    }
+}
+exports.AngularAppGenerator = AngularAppGenerator;

package/dist/generators/angular-service.d.ts

@@ -0,0 +1,21 @@
+import { Generator, GeneratorOptions } from '../utils/generator';
+import { RedboxPaths } from '../utils/paths';
+export interface AngularServiceGeneratorOptions extends GeneratorOptions {
+    app: string;
+    name: string;
+    methods?: string[];
+    paths: RedboxPaths;
+}
+export declare class AngularServiceGenerator extends Generator {
+    private app;
+    private name;
+    private methods;
+    private paths;
+    constructor(options: AngularServiceGeneratorOptions);
+    generate(): Promise<void>;
+    private generateServiceContent;
+    private toClassName;
+    private capitalize;
+    private isValidTsIdentifier;
+    private toSafeMethodName;
+}

package/dist/generators/angular-service.js

@@ -0,0 +1,154 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AngularServiceGenerator = void 0;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const generator_1 = require("../utils/generator");
+class AngularServiceGenerator extends generator_1.Generator {
+    app;
+    name;
+    methods;
+    paths;
+    constructor(options) {
+        super(options);
+        this.app = options.app.toLowerCase();
+        this.name = options.name.toLowerCase();
+        this.methods = options.methods || [];
+        this.paths = options.paths;
+    }
+    async generate() {
+        const projectRoot = path.join(this.paths.angular, 'projects', 'researchdatabox', this.app);
+        if (!fs.existsSync(projectRoot)) {
+            throw new Error(`Angular app project not found at: ${projectRoot}`);
+        }
+        const serviceClassName = this.toClassName(this.name);
+        const fileName = `${this.name}.service.ts`;
+        const servicePath = path.join(projectRoot, 'src', 'app', fileName);
+        const content = this.generateServiceContent(serviceClassName);
+        this.writeFile(servicePath, content);
+    }
+    generateServiceContent(serviceClassName) {
+        const className = `${serviceClassName}Service`;
+        let methodsContent = '';
+        if (this.methods.length > 0) {
+            const methodInfos = this.methods.map(method => ({
+                raw: method,
+                identifier: this.toSafeMethodName(method)
+            }));
+            methodsContent = methodInfos.map(method => `
+  /**
+   * ${this.capitalize(method.identifier)}
+   */
+  public async ${method.identifier}(): Promise<any> {
+    const url = \`\${this.brandingAndPortalUrl}/app/${this.app}/${method.raw}\`;
+    const result$ = this.http.get(url, { ...this.reqOptsJsonBodyOnly, context: this.httpContext });
+    return await firstValueFrom(result$);
+  }
+`).join('\n');
+        }
+        return `import { Injectable, Inject } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { APP_BASE_HREF } from '@angular/common';
+import { HttpClientService, ConfigService, UtilityService } from '@researchdatabox/portal-ng-common';
+import { firstValueFrom } from 'rxjs';
+
+/**
+ * ${serviceClassName} Service
+ * 
+ * Generated by ReDBox Hook Kit
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class ${className} extends HttpClientService {
+
+  constructor(
+    @Inject(HttpClient) http: HttpClient,
+    @Inject(APP_BASE_HREF) rootContext: string,
+    @Inject(UtilityService) utilService: UtilityService,
+    @Inject(ConfigService) configService: ConfigService
+  ) {
+    super(http, rootContext, utilService, configService);
+  }
+
+  public override async waitForInit(): Promise<any> {
+    await super.waitForInit(); 
+    this.enableCsrfHeader();
+    return this;
+  }
+${methodsContent}
+}
+`;
+    }
+    toClassName(name) {
+        return name.split('-').map(s => s.charAt(0).toUpperCase() + s.slice(1)).join('');
+    }
+    capitalize(s) {
+        return s.charAt(0).toUpperCase() + s.slice(1);
+    }
+    isValidTsIdentifier(name) {
+        return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name);
+    }
+    toSafeMethodName(method) {
+        const trimmed = method.trim();
+        if (!trimmed) {
+            throw new Error('Method name cannot be empty.');
+        }
+        if (this.isValidTsIdentifier(trimmed)) {
+            return trimmed;
+        }
+        const parts = trimmed.split(/[^A-Za-z0-9_$]+/).filter(Boolean);
+        const camel = parts.map((part, index) => {
+            const lower = part.toLowerCase();
+            if (index === 0)
+                return lower;
+            return lower.charAt(0).toUpperCase() + lower.slice(1);
+        }).join('');
+        let candidate = camel || trimmed.replace(/[^A-Za-z0-9_$]/g, '');
+        if (!candidate) {
+            throw new Error(`Method name '${method}' cannot be converted to a valid identifier.`);
+        }
+        if (!/^[A-Za-z_$]/.test(candidate)) {
+            candidate = `_${candidate}`;
+        }
+        if (!this.isValidTsIdentifier(candidate)) {
+            throw new Error(`Method name '${method}' cannot be converted to a valid identifier.`);
+        }
+        console.warn(`  [WARN] Sanitized method name '${method}' to '${candidate}'.`);
+        return candidate;
+    }
+}
+exports.AngularServiceGenerator = AngularServiceGenerator;

package/dist/generators/controller.d.ts

@@ -0,0 +1,40 @@
+import { Generator, GeneratorOptions } from '../utils/generator';
+import { RedboxPaths } from '../utils/paths';
+import { NavigationMapping, LanguageDefaultEntry } from '../utils/config-helper';
+export interface RouteMapping {
+    action: string;
+    verb?: string;
+    path: string;
+    auth?: string[];
+    csrf?: boolean;
+}
+export interface ControllerGeneratorOptions extends GeneratorOptions {
+    name: string;
+    actions?: string[];
+    webservice?: boolean;
+    /** @deprecated Use routes instead */
+    route?: string;
+    routes?: RouteMapping[];
+    auth?: string[];
+    navigation?: NavigationMapping[];
+    languageDefaults?: LanguageDefaultEntry[];
+    className?: string;
+    paths: RedboxPaths;
+}
+export declare class ControllerGenerator extends Generator {
+    private name;
+    private className;
+    private actions;
+    private webservice;
+    private routes;
+    private auth?;
+    private navigation;
+    private languageDefaults;
+    private paths;
+    private project;
+    constructor(options: ControllerGeneratorOptions);
+    generate(): Promise<void>;
+    private generateControllerContent;
+    private validateActions;
+    private isValidIdentifier;
+}