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

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

package/dist/generators/controller.js

@@ -0,0 +1,195 @@
+"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.ControllerGenerator = void 0;
+const path = __importStar(require("path"));
+const ts_morph_1 = require("ts-morph");
+const generator_1 = require("../utils/generator");
+const config_helper_1 = require("../utils/config-helper");
+class ControllerGenerator extends generator_1.Generator {
+    name;
+    className;
+    actions;
+    webservice;
+    routes;
+    auth;
+    navigation;
+    languageDefaults;
+    paths;
+    project;
+    constructor(options) {
+        super(options);
+        this.name = options.name;
+        this.actions = options.actions || [];
+        this.webservice = !!options.webservice;
+        this.auth = options.auth;
+        this.navigation = options.navigation || [];
+        this.languageDefaults = options.languageDefaults || [];
+        this.paths = options.paths;
+        const inferredClassName = this.name.endsWith('Controller') ? this.name.replace('Controller', '') : this.name;
+        this.className = options.className || inferredClassName;
+        this.project = new ts_morph_1.Project({
+            manipulationSettings: {
+                quoteKind: ts_morph_1.QuoteKind.Single,
+            },
+        });
+        this.validateActions();
+        // Handle backwards compatibility: convert single route to routes array
+        if (options.routes && options.routes.length > 0) {
+            this.routes = options.routes;
+        }
+        else if (options.route) {
+            // Legacy: single route maps to first action or 'index'
+            const action = (this.actions && this.actions.length > 0) ? this.actions[0] : 'index';
+            this.routes = [{ action, path: options.route, verb: 'get' }];
+        }
+        else {
+            this.routes = [];
+        }
+    }
+    async generate() {
+        const controllerName = this.name.endsWith('Controller') ? this.name : `${this.name}Controller`;
+        const className = this.className;
+        const controllerDir = path.join(this.paths.coreTypes, 'src', 'controllers', this.webservice ? 'webservice' : '');
+        const controllerPath = path.join(controllerDir, `${controllerName}.ts`);
+        const content = this.generateControllerContent(className);
+        this.writeFile(controllerPath, content);
+        if (!this.dryRun) {
+            await (0, config_helper_1.updateControllerIndex)({
+                project: this.project,
+                paths: this.paths,
+                root: this.root,
+                controllerName: controllerName,
+                className: className,
+                webservice: this.webservice,
+                dryRun: this.dryRun
+            });
+            // Process each route mapping
+            for (const routeMapping of this.routes) {
+                const routeKey = routeMapping.verb
+                    ? `${routeMapping.verb.toLowerCase()} ${routeMapping.path}`
+                    : routeMapping.path;
+                await (0, config_helper_1.updateRoutes)({
+                    project: this.project,
+                    paths: this.paths,
+                    root: this.root,
+                    route: routeKey,
+                    controllerName: controllerName,
+                    action: routeMapping.action,
+                    webservice: this.webservice,
+                    csrf: routeMapping.csrf,
+                    dryRun: this.dryRun
+                });
+                // Apply auth rules: use route-specific auth if provided, otherwise controller-level auth
+                const routeAuth = routeMapping.auth || this.auth;
+                if (routeAuth && routeAuth.length > 0) {
+                    await (0, config_helper_1.updateAuth)({
+                        project: this.project,
+                        paths: this.paths,
+                        root: this.root,
+                        route: routeKey,
+                        auth: routeAuth,
+                        dryRun: this.dryRun
+                    });
+                }
+            }
+            if (this.navigation.length > 0) {
+                for (const nav of this.navigation) {
+                    const actionName = nav.action || (this.routes.length === 1 ? this.routes[0].action : (this.actions.length === 1 ? this.actions[0] : undefined));
+                    if (!actionName) {
+                        console.warn('  [NAV] Navigation mapping missing action and cannot be inferred. Skipping.');
+                        continue;
+                    }
+                    const routeMapping = this.routes.find(r => r.action === actionName);
+                    if (!routeMapping) {
+                        console.warn(`  [NAV] No route mapping found for action '${actionName}'. Skipping.`);
+                        continue;
+                    }
+                    await (0, config_helper_1.updateNavigationConfig)({
+                        project: this.project,
+                        paths: this.paths,
+                        root: this.root,
+                        mapping: {
+                            ...nav,
+                            href: routeMapping.path
+                        },
+                        dryRun: this.dryRun
+                    });
+                }
+            }
+            if (this.languageDefaults.length > 0) {
+                await (0, config_helper_1.updateLanguageDefaults)({
+                    root: this.root,
+                    entries: this.languageDefaults,
+                    dryRun: this.dryRun
+                });
+            }
+        }
+    }
+    generateControllerContent(className) {
+        const importPath = this.webservice ? '../../index' : '../index';
+        const actionsCode = this.actions.map(action => `
+    public async ${action}(req: Sails.Req, res: Sails.Res): Promise<unknown> {
+      return this.sendResp(req, res, { data: { message: 'Action ${action} in ${className}' } });
+    }`).join('\n');
+        const exportedMethods = ['init', ...this.actions].map(a => `'${a}'`).join(',\n      ');
+        return `import { Controllers as controllers } from '${importPath}';
+
+export namespace Controllers {
+  export class ${className} extends controllers.Core.Controller {
+
+    protected override _exportedMethods: string[] = [
+      ${exportedMethods}
+    ];
+
+    public init(): void {
+      // Initialize services here
+    }
+${actionsCode}
+  }
+}
+`;
+    }
+    validateActions() {
+        const invalidActions = this.actions.filter(action => !this.isValidIdentifier(action));
+        if (invalidActions.length > 0) {
+            throw new Error(`Invalid action name(s): ${invalidActions.join(', ')}`);
+        }
+    }
+    isValidIdentifier(name) {
+        return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name);
+    }
+}
+exports.ControllerGenerator = ControllerGenerator;

package/dist/generators/form-component.d.ts

@@ -0,0 +1,46 @@
+import { Generator, GeneratorOptions } from '../utils/generator';
+import { RedboxPaths } from '../utils/paths';
+export interface FormComponentGeneratorOptions extends GeneratorOptions {
+    name: string;
+    app?: string;
+    withService?: boolean;
+    paths: RedboxPaths;
+}
+export declare class FormComponentGenerator extends Generator {
+    private readonly rawName;
+    private readonly app;
+    private readonly withService;
+    private readonly paths;
+    private readonly kebabName;
+    private readonly pascalName;
+    private readonly componentClassName;
+    private readonly modelClassName;
+    private readonly componentNameConstant;
+    private readonly modelNameConstant;
+    constructor(options: FormComponentGeneratorOptions);
+    generate(): Promise<void>;
+    private toKebabCase;
+    private toPascalCase;
+    private readFile;
+    private updateTextFile;
+    private insertBeforeMarker;
+    private ensureImport;
+    private appendToObjectLiteral;
+    private appendToArrayLiteral;
+    private findMatchingDelimiter;
+    private generateSailsNgCommonComponentFiles;
+    private generateAngularComponentFiles;
+    private generateAngularServiceFiles;
+    private updateSailsNgCommonDictionaries;
+    private updateSailsNgCommonIndex;
+    private updateBaseVisitors;
+    private updateConcreteVisitors;
+    private updateClientVisitor;
+    private updateDataValueVisitor;
+    private updateJsonTypeDefVisitor;
+    private updateValidatorVisitor;
+    private updateTemplateVisitor;
+    private updateConstructVisitor;
+    private updateMigrateVisitor;
+    private updateAngularWiring;
+}