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

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