@researchdatabox/redbox-dev-tools 0.0.1 → 5.0.0-RC1

package/dist/generators/add-method.js

@@ -0,0 +1,235 @@
+"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.AddMethodGenerator = 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 AddMethodGenerator extends generator_1.Generator {
+    filePath;
+    method;
+    route;
+    http;
+    auth;
+    navigation;
+    languageDefaults;
+    paths;
+    project;
+    constructor(options) {
+        super(options);
+        this.filePath = path.isAbsolute(options.file) ? options.file : path.resolve(this.root, options.file);
+        this.method = options.method;
+        this.route = options.route;
+        this.http = options.http || 'GET';
+        this.auth = options.auth;
+        this.navigation = options.navigation || [];
+        this.languageDefaults = options.languageDefaults || [];
+        this.paths = options.paths;
+        this.project = new ts_morph_1.Project({
+            manipulationSettings: {
+                quoteKind: ts_morph_1.QuoteKind.Single,
+            },
+        });
+    }
+    async generate() {
+        if (!fs.existsSync(this.filePath)) {
+            throw new Error(`File not found: ${this.filePath}`);
+        }
+        const sourceFile = this.project.addSourceFileAtPath(this.filePath);
+        const relativePath = path.relative(this.root, this.filePath);
+        // 1. Identify if it's a Controller or Service
+        const isController = this.filePath.endsWith('Controller.ts');
+        const isService = this.filePath.endsWith('Service.ts');
+        if (!isController && !isService) {
+            throw new Error('Target file must be a Controller or Service (.ts)');
+        }
+        // 2. Find the class
+        const targetClass = sourceFile.getFirstDescendantByKind(ts_morph_1.SyntaxKind.ClassDeclaration);
+        if (!targetClass) {
+            throw new Error('Could not find a class in the target file');
+        }
+        this.updateClass(targetClass, isController);
+        sourceFile.formatText();
+        if (this.dryRun) {
+            console.log(`  [UPDATE] ${relativePath} (dry run)`);
+        }
+        else {
+            await sourceFile.save();
+            console.log(`  [UPDATE] ${relativePath}`);
+        }
+        const fileName = path.basename(this.filePath, '.ts');
+        const className = isController ? fileName.replace('Controller', '') : fileName.replace('Service', '');
+        if (!this.dryRun) {
+            if (isController) {
+                await (0, config_helper_1.updateControllerIndex)({
+                    project: this.project,
+                    paths: this.paths,
+                    root: this.root,
+                    controllerName: fileName,
+                    className: className,
+                    webservice: this.filePath.includes(path.join('controllers', 'webservice')),
+                    dryRun: this.dryRun
+                });
+            }
+            else {
+                await (0, config_helper_1.updateServiceIndex)({
+                    project: this.project,
+                    paths: this.paths,
+                    root: this.root,
+                    serviceName: fileName,
+                    className: className,
+                    dryRun: this.dryRun
+                });
+            }
+        }
+        // 3. Update routes and auth if it's a controller and route is provided
+        if (isController && this.route) {
+            const trimmedRoute = this.route.trim();
+            if (!trimmedRoute) {
+                throw new Error('Route cannot be empty or whitespace.');
+            }
+            const controllerName = fileName;
+            const webservice = this.filePath.includes(path.join('controllers', 'webservice'));
+            await (0, config_helper_1.updateRoutes)({
+                project: this.project,
+                paths: this.paths,
+                root: this.root,
+                route: trimmedRoute,
+                controllerName: controllerName,
+                action: this.method,
+                webservice: webservice,
+                dryRun: this.dryRun
+            });
+            if (this.auth && this.auth.length > 0) {
+                await (0, config_helper_1.updateAuth)({
+                    project: this.project,
+                    paths: this.paths,
+                    root: this.root,
+                    route: trimmedRoute,
+                    auth: this.auth,
+                    dryRun: this.dryRun
+                });
+            }
+            if (this.navigation.length > 0) {
+                const routePath = trimmedRoute.split(' ').pop();
+                if (!routePath) {
+                    throw new Error(`Route is missing a path segment: '${trimmedRoute}'.`);
+                }
+                for (const nav of this.navigation) {
+                    const actionName = nav.action || this.method;
+                    if (actionName !== this.method) {
+                        console.warn(`  [NAV] Navigation mapping action '${actionName}' does not match method '${this.method}'. Skipping.`);
+                        continue;
+                    }
+                    await (0, config_helper_1.updateNavigationConfig)({
+                        project: this.project,
+                        paths: this.paths,
+                        root: this.root,
+                        mapping: {
+                            ...nav,
+                            href: routePath
+                        },
+                        dryRun: this.dryRun
+                    });
+                }
+            }
+        }
+        if (this.languageDefaults.length > 0) {
+            await (0, config_helper_1.updateLanguageDefaults)({
+                root: this.root,
+                entries: this.languageDefaults,
+                dryRun: this.dryRun
+            });
+        }
+    }
+    updateClass(klass, isController) {
+        // 1. Add method stub if it doesn't exist
+        if (!klass.getMethod(this.method)) {
+            if (isController) {
+                klass.addMethod({
+                    name: this.method,
+                    scope: ts_morph_1.Scope.Public,
+                    isAsync: true,
+                    returnType: 'Promise<unknown>',
+                    parameters: [
+                        { name: 'req', type: 'Sails.Req' },
+                        { name: 'res', type: 'Sails.Res' }
+                    ],
+                    statements: `return this.sendResp(req, res, { data: { message: 'Action ${this.method} in ${klass.getName()}' } });`
+                });
+            }
+            else {
+                klass.addMethod({
+                    name: this.method,
+                    scope: ts_morph_1.Scope.Public,
+                    isAsync: true,
+                    returnType: 'Promise<Record<string, unknown>>',
+                    parameters: [
+                        { name: '..._args', type: 'unknown[]' }
+                    ],
+                    statements: [
+                        `sails.log.verbose(\`\${this.logHeader} ${this.method} called\`);`,
+                        `return { message: 'Method ${this.method} in ${klass.getName()}' };`
+                    ]
+                });
+            }
+        }
+        // 2. Update _exportedMethods
+        const exportedMethodsProp = klass.getProperty('_exportedMethods');
+        if (exportedMethodsProp) {
+            const initializer = exportedMethodsProp.getInitializerIfKind(ts_morph_1.SyntaxKind.ArrayLiteralExpression);
+            if (initializer) {
+                if (!initializer.getElements().some((e) => e.getText().replace(/['"]/g, '') === this.method)) {
+                    initializer.addElement(`'${this.method}'`);
+                }
+            }
+        }
+        else {
+            // Create _exportedMethods if missing
+            const hasInit = !!klass.getMethod('init');
+            const methods = hasInit ? ['init', this.method] : [this.method];
+            klass.addProperty({
+                name: '_exportedMethods',
+                scope: ts_morph_1.Scope.Protected,
+                hasOverrideKeyword: true,
+                type: 'string[]',
+                initializer: `[${methods.map(m => `'${m}'`).join(', ')}]`
+            });
+        }
+    }
+}
+exports.AddMethodGenerator = AddMethodGenerator;

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

@@ -0,0 +1,24 @@
+import { Generator, GeneratorOptions } from '../utils/generator';
+import { RedboxPaths } from '../utils/paths';
+export interface AngularAppGeneratorOptions extends GeneratorOptions {
+    name: string;
+    ejsView: string;
+    auth?: string[];
+    paths: RedboxPaths;
+}
+export declare class AngularAppGenerator extends Generator {
+    private name;
+    private ejsView;
+    private auth?;
+    private paths;
+    private project;
+    constructor(options: AngularAppGeneratorOptions);
+    generate(): Promise<void>;
+    private scaffoldAngularApp;
+    private updateAngularJson;
+    private generateEjsView;
+    private updateRouteConfig;
+    private updateAuthConfig;
+    private toClassName;
+    private getSafeEjsViewName;
+}

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;
+}