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

package/dist/completion/index.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCompletionScript = generateCompletionScript;
+function getCompletionSpec() {
+    const globalOptions = ['--root', '--core-types-root', '--angular-root', '--dry-run', '-h', '--help', '-V', '--version'];
+    const topLevelCommands = ['init', 'check', 'migrate-hook-dependencies', 'generate', 'g', 'install-skills', 'skills', 'migrate-form-config', 'completion', 'help'];
+    const generateCommands = ['controller', 'service', 'method', 'angular-app', 'angular-service', 'form-component', 'form-field', 'model'];
+    const commandOptions = {
+        'migrate-form-config': ['-i', '--input', '-o', '--output'],
+        'check': [],
+        'completion': [],
+        'init': [],
+        'install-skills': [],
+        'migrate-hook-dependencies': [],
+        'skills': [],
+        'generate controller': ['--actions', '--webservice', '--class-name', '--route', '--routes', '--nav', '--lang', '--auth'],
+        'generate service': ['--methods'],
+        'generate method': ['--file', '--method', '--route', '--http', '--auth', '--nav', '--lang'],
+        'generate angular-app': ['--ejs-view', '--auth'],
+        'generate angular-service': ['--app', '--methods'],
+        'generate form-component': ['--app', '--with-service'],
+        'generate form-field': ['--type'],
+        'generate model': ['--identity', '--attrs', '--belongs-to', '--has-many']
+    };
+    const fileValueOptions = ['--root', '--core-types-root', '--angular-root', '--input', '--output', '--file'];
+    return { globalOptions, topLevelCommands, generateCommands, commandOptions, fileValueOptions };
+}
+function generateBashCompletion() {
+    const spec = getCompletionSpec();
+    const top = spec.topLevelCommands.join(' ');
+    const generateSubs = spec.generateCommands.join(' ');
+    const globalOpts = spec.globalOptions.join(' ');
+    const fileOpts = spec.fileValueOptions.join(' ');
+    const commandOptionEntries = Object.entries(spec.commandOptions)
+        .map(([key, value]) => `"${key}") opts="${value.join(' ')}";;`)
+        .join('\n      ');
+    return `# bash completion for redbox-dev-tools
+_redbox_dev_tools_completion() {
+  local cur prev words cword
+  _init_completion || return
+
+  local top_commands="${top}"
+  local generate_subcommands="${generateSubs}"
+  local global_opts="${globalOpts}"
+  local file_value_opts="${fileOpts}"
+
+  case "$prev" in
+    $file_value_opts)
+      COMPREPLY=($(compgen -f -- "$cur"))
+      return
+      ;;
+  esac
+
+  if [[ $cword -le 1 ]]; then
+    COMPREPLY=($(compgen -W "$top_commands $global_opts" -- "$cur"))
+    return
+  fi
+
+  if [[ "\${words[1]}" == "generate" || "\${words[1]}" == "g" ]]; then
+    if [[ $cword -eq 2 ]]; then
+      COMPREPLY=($(compgen -W "$generate_subcommands" -- "$cur"))
+      return
+    fi
+    local key="generate \${words[2]}"
+    local opts=""
+    case "$key" in
+      ${commandOptionEntries}
+      *) opts="";;
+    esac
+    COMPREPLY=($(compgen -W "$opts $global_opts" -- "$cur"))
+    return
+  fi
+
+  local opts=""
+  case "\${words[1]}" in
+    "migrate-form-config") opts="-i --input -o --output" ;;
+    "check") opts="" ;;
+    "completion") opts="" ;;
+    "init") opts="" ;;
+    "install-skills") opts="" ;;
+    "migrate-hook-dependencies") opts="" ;;
+    "skills") opts="" ;;
+    *) opts="" ;;
+  esac
+
+  COMPREPLY=($(compgen -W "$opts $global_opts" -- "$cur"))
+}
+
+complete -F _redbox_dev_tools_completion redbox-dev-tools
+`;
+}
+function generateZshCompletion() {
+    const bashScript = generateBashCompletion();
+    return `#compdef redbox-dev-tools
+autoload -U +X bashcompinit && bashcompinit
+${bashScript}`;
+}
+function generateFishCompletion() {
+    const spec = getCompletionSpec();
+    const lines = [
+        '# fish completion for redbox-dev-tools',
+        'set -l __rbhk_cmd redbox-dev-tools',
+        'complete -c $__rbhk_cmd -f'
+    ];
+    for (const cmd of spec.topLevelCommands) {
+        lines.push(`complete -c $__rbhk_cmd -n "__fish_use_subcommand" -a "${cmd}"`);
+    }
+    for (const option of spec.globalOptions) {
+        if (option.startsWith('--')) {
+            const name = option.replace(/^--/, '');
+            const requiresValue = ['root', 'core-types-root', 'angular-root'].includes(name);
+            lines.push(`complete -c $__rbhk_cmd -l ${name}${requiresValue ? ' -r' : ''}`);
+        }
+    }
+    for (const sub of spec.generateCommands) {
+        lines.push(`complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate g; and __fish_use_subcommand" -a "${sub}"`);
+    }
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from migrate-form-config" -s i -l input -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from migrate-form-config" -s o -l output -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from completion" -a "bash zsh fish powershell pwsh"');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from controller" -l actions -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from controller" -l webservice');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from controller" -l class-name -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from controller" -l route -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from controller" -l routes -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from controller" -l nav -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from controller" -l lang -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from controller" -l auth -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from service" -l methods -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from method" -l file -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from method" -l method -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from method" -l route -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from method" -l http -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from method" -l auth -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from method" -l nav -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from method" -l lang -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from angular-app" -l ejs-view -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from angular-app" -l auth -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from angular-service" -l app -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from angular-service" -l methods -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from form-component" -l app -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from form-component" -l with-service');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from form-field" -l type -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from model" -l identity -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from model" -l attrs -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from model" -l belongs-to -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from model" -l has-many -r');
+    return `${lines.join('\n')}\n`;
+}
+function generatePowerShellCompletion() {
+    return `# PowerShell completion for redbox-dev-tools
+Register-ArgumentCompleter -Native -CommandName redbox-dev-tools -ScriptBlock {
+  param($wordToComplete, $commandAst, $cursorPosition)
+  $tokens = $commandAst.CommandElements | ForEach-Object { $_.Extent.Text }
+  $global = @('--root','--core-types-root','--angular-root','--dry-run','-h','--help','-V','--version')
+  $top = @('init','check','migrate-hook-dependencies','generate','g','install-skills','skills','migrate-form-config','completion','help')
+  $generateSub = @('controller','service','method','angular-app','angular-service','form-component','form-field','model')
+
+  if ($tokens.Count -le 2) {
+    @($top + $global) | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+      [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+    }
+    return
+  }
+
+  if ($tokens[1] -eq 'generate' -or $tokens[1] -eq 'g') {
+    if ($tokens.Count -le 3) {
+      $generateSub | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+        [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+      }
+      return
+    }
+    $sub = $tokens[2]
+    $opts = switch ($sub) {
+      'controller' { @('--actions','--webservice','--class-name','--route','--routes','--nav','--lang','--auth') }
+      'service' { @('--methods') }
+      'method' { @('--file','--method','--route','--http','--auth','--nav','--lang') }
+      'angular-app' { @('--ejs-view','--auth') }
+      'angular-service' { @('--app','--methods') }
+      'form-component' { @('--app','--with-service') }
+      'form-field' { @('--type') }
+      'model' { @('--identity','--attrs','--belongs-to','--has-many') }
+      default { @() }
+    }
+    @($opts + $global) | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+      [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterName', $_)
+    }
+    return
+  }
+
+  $opts = switch ($tokens[1]) {
+    'migrate-form-config' { @('-i','--input','-o','--output') }
+    'completion' { @('bash','zsh','fish','powershell','pwsh') }
+    default { @() }
+  }
+
+  @($opts + $global) | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+    [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterName', $_)
+  }
+}
+`;
+}
+function generateCompletionScript(shell) {
+    switch (shell) {
+        case 'bash':
+            return generateBashCompletion();
+        case 'zsh':
+            return generateZshCompletion();
+        case 'fish':
+            return generateFishCompletion();
+        case 'powershell':
+        case 'pwsh':
+            return generatePowerShellCompletion();
+        default:
+            throw new Error(`Unsupported shell '${shell}'. Expected one of: bash, zsh, fish, powershell`);
+    }
+}

package/dist/generators/add-method.d.ts

@@ -0,0 +1,27 @@
+import { Generator, GeneratorOptions } from '../utils/generator';
+import { RedboxPaths } from '../utils/paths';
+import { NavigationMapping, LanguageDefaultEntry } from '../utils/config-helper';
+export interface AddMethodGeneratorOptions extends GeneratorOptions {
+    file: string;
+    method: string;
+    route?: string;
+    http?: string;
+    auth?: string[];
+    navigation?: NavigationMapping[];
+    languageDefaults?: LanguageDefaultEntry[];
+    paths: RedboxPaths;
+}
+export declare class AddMethodGenerator extends Generator {
+    private filePath;
+    private method;
+    private route?;
+    private http?;
+    private auth?;
+    private navigation;
+    private languageDefaults;
+    private paths;
+    private project;
+    constructor(options: AddMethodGeneratorOptions);
+    generate(): Promise<void>;
+    private updateClass;
+}

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