create-react-on-rails-app 16.4.0-rc.0

package/LICENSE.md

@@ -0,0 +1,83 @@
+# Licensing
+
+This repository contains code under two different licenses:
+
+- **Core**: MIT License (applies to most files)
+- **Pro**: React on Rails Pro License (applies to specific directories)
+
+## License Scope
+
+### MIT Licensed Code
+
+The following directories and all their contents are licensed under the **MIT License** (see full text below):
+
+- `react_on_rails/` (entire directory, including lib/, spec/, sig/)
+- `packages/react-on-rails/` (entire package)
+- All other directories in this repository not explicitly listed as Pro-licensed
+
+### Pro Licensed Code
+
+The following directories and all their contents are licensed under the **React on Rails Pro License**:
+
+- `packages/react-on-rails-pro/` (entire package)
+- `packages/react-on-rails-pro-node-renderer/` (entire package)
+- `react_on_rails_pro/` (entire directory)
+
+See [REACT-ON-RAILS-PRO-LICENSE.md](./REACT-ON-RAILS-PRO-LICENSE.md) for complete Pro license terms.
+
+**Important:** Pro-licensed code is included in this package but requires a valid React on Rails Pro subscription to use. Using Pro features without a valid license violates the React on Rails Pro License.
+
+---
+
+## MIT License
+
+This license applies to all MIT-licensed code as defined above.
+
+Copyright (c) 2017, 2018 Justin Gordon and ShakaCode  
+Copyright (c) 2015–2025 ShakaCode, LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+---
+
+## Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+## React on Rails Pro License
+
+For Pro-licensed code (as defined in the "License Scope" section above), see:
+[REACT-ON-RAILS-PRO-LICENSE.md](./REACT-ON-RAILS-PRO-LICENSE.md)
+
+**Key Points:**
+
+- Pro features require a valid React on Rails Pro subscription for production use
+- Free use is permitted for educational, personal, and non-production purposes
+- Modifying MIT-licensed interface files is permitted under MIT terms
+- However, using those modifications to access Pro features without a valid license violates the Pro License
+
+### License Validation Mechanisms
+
+**License validation mechanisms** include but are not limited to:
+
+- Runtime checks for valid Pro subscriptions
+- Authentication systems in `react_on_rails/lib/react_on_rails/utils.rb` and Pro TypeScript modules
+- The `react_on_rails_pro?` method and `rorPro` field generation
+
+While MIT-licensed code may be modified under MIT terms, using such modifications to access Pro features without a valid license violates the React on Rails Pro License.

package/bin/create-react-on-rails-app.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+
+// Check Node.js version before loading anything else
+const currentNodeVersion = process.versions.node;
+const major = parseInt(currentNodeVersion.split('.')[0], 10);
+
+if (major < 18) {
+  console.error(
+    `You are running Node.js ${currentNodeVersion}.\n` +
+      'create-react-on-rails-app requires Node.js 18 or higher.\n' +
+      'Please update your version of Node.js.',
+  );
+  process.exit(1);
+}
+
+require('../lib/index.js');

package/lib/create-app.d.ts

@@ -0,0 +1,7 @@
+import { CliOptions } from './types.js';
+export declare function validateAppName(name: string): {
+    success: boolean;
+    error?: string;
+};
+export declare function createApp(appName: string, options: CliOptions): void;
+//# sourceMappingURL=create-app.d.ts.map

package/lib/create-app.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAppName = validateAppName;
+exports.createApp = createApp;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const utils_js_1 = require("./utils.js");
+const TOTAL_STEPS = 4;
+function buildGeneratorArgs(options) {
+    const args = [];
+    if (options.template === 'typescript') {
+        args.push('--typescript');
+    }
+    if (options.rspack) {
+        args.push('--rspack');
+    }
+    args.push('--ignore-warnings');
+    return args;
+}
+function printSuccessMessage(appName) {
+    console.log('');
+    (0, utils_js_1.logSuccess)(`Created ${appName} with React on Rails!`);
+    console.log('');
+    (0, utils_js_1.logInfo)('Next steps:');
+    console.log(`  cd ${appName}`);
+    console.log('  bin/dev');
+    console.log('');
+    (0, utils_js_1.logInfo)('Then visit http://localhost:3000/hello_world');
+    console.log('');
+    (0, utils_js_1.logInfo)('Documentation: https://www.shakacode.com/react-on-rails/docs/');
+    console.log('');
+}
+function validateAppName(name) {
+    if (!name || name.trim() === '') {
+        return { success: false, error: 'App name is required.' };
+    }
+    if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+        return {
+            success: false,
+            error: 'App name can only contain letters, numbers, hyphens, and underscores.',
+        };
+    }
+    const appPath = path_1.default.resolve(process.cwd(), name);
+    if (fs_1.default.existsSync(appPath)) {
+        return {
+            success: false,
+            error: `Directory "${name}" already exists. Please choose a different name or remove it.`,
+        };
+    }
+    return { success: true };
+}
+function createApp(appName, options) {
+    const appPath = path_1.default.resolve(process.cwd(), appName);
+    // Step 1: Create Rails application
+    // appName is validated by validateAppName() to be [a-zA-Z0-9_-]+ only,
+    // so it's always a simple directory name safe to use with rails new.
+    (0, utils_js_1.logStep)(1, TOTAL_STEPS, 'Creating Rails application...');
+    try {
+        (0, utils_js_1.execLiveArgs)('rails', ['new', appName, '--database=postgresql', '--skip-javascript']);
+        (0, utils_js_1.logStepDone)('Rails application created');
+    }
+    catch (error) {
+        (0, utils_js_1.logError)('Failed to create Rails application. Check the output above for details.');
+        if (error instanceof Error && error.message) {
+            console.error(`Debug info: ${error.message}`);
+        }
+        process.exit(1);
+    }
+    // Step 2: Add react_on_rails gem
+    (0, utils_js_1.logStep)(2, TOTAL_STEPS, 'Adding react_on_rails gem...');
+    try {
+        (0, utils_js_1.execLiveArgs)('bundle', ['add', 'react_on_rails', '--strict'], appPath);
+        (0, utils_js_1.logStepDone)('react_on_rails gem added');
+    }
+    catch (error) {
+        (0, utils_js_1.logError)('Failed to add react_on_rails gem. Check the output above for details.');
+        if (error instanceof Error && error.message) {
+            console.error(`Debug info: ${error.message}`);
+        }
+        process.exit(1);
+    }
+    // Step 3: Run react_on_rails generator
+    const generatorArgs = buildGeneratorArgs(options);
+    (0, utils_js_1.logStep)(3, TOTAL_STEPS, 'Running React on Rails generator...');
+    try {
+        (0, utils_js_1.execLiveArgs)('bundle', ['exec', 'rails', 'generate', 'react_on_rails:install', ...generatorArgs], appPath);
+        (0, utils_js_1.logStepDone)('React on Rails setup complete');
+    }
+    catch (error) {
+        (0, utils_js_1.logError)('React on Rails generator failed. Check the output above for details.');
+        if (error instanceof Error && error.message) {
+            console.error(`Debug info: ${error.message}`);
+        }
+        process.exit(1);
+    }
+    // Step 4: Success
+    (0, utils_js_1.logStep)(4, TOTAL_STEPS, 'Done!');
+    printSuccessMessage(appName);
+}
+//# sourceMappingURL=create-app.js.map

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const validators_js_1 = require("./validators.js");
+const create_app_js_1 = require("./create-app.js");
+const utils_js_1 = require("./utils.js");
+// Use require() for CJS compatibility - avoids __dirname + fs.readFileSync
+// eslint-disable-next-line @typescript-eslint/no-require-imports, global-require
+const packageJson = require('../package.json');
+function run(appName, rawOpts) {
+    const { template } = rawOpts;
+    if (typeof template !== 'string' || (template !== 'javascript' && template !== 'typescript')) {
+        (0, utils_js_1.logError)(`Invalid template "${String(template)}". Must be "javascript" or "typescript".`);
+        process.exit(1);
+    }
+    let packageManager = rawOpts.packageManager;
+    if (packageManager) {
+        if (packageManager !== 'npm' && packageManager !== 'pnpm') {
+            (0, utils_js_1.logError)(`Invalid package manager "${packageManager}". Must be "npm" or "pnpm".`);
+            process.exit(1);
+        }
+    }
+    else {
+        packageManager = (0, utils_js_1.detectPackageManager)() ?? 'npm';
+    }
+    const options = {
+        template,
+        packageManager: packageManager,
+        rspack: Boolean(rawOpts.rspack),
+    };
+    console.log('');
+    console.log(`${chalk_1.default.bold('create-react-on-rails-app')} v${packageJson.version}`);
+    console.log('');
+    const nameValidation = (0, create_app_js_1.validateAppName)(appName);
+    if (!nameValidation.success) {
+        (0, utils_js_1.logError)(nameValidation.error ?? 'Invalid app name');
+        process.exit(1);
+    }
+    (0, utils_js_1.logInfo)('Checking prerequisites...');
+    const { allValid, results } = (0, validators_js_1.validateAll)(options.packageManager);
+    for (const { name, result } of results) {
+        if (result.valid) {
+            console.log(chalk_1.default.green(`  ✓ ${name}: ${result.message}`));
+        }
+        else {
+            console.log(chalk_1.default.red(`  ✗ ${name}`));
+        }
+    }
+    if (!allValid) {
+        console.log('');
+        for (const { result } of results) {
+            if (!result.valid) {
+                (0, utils_js_1.logError)(result.message);
+            }
+        }
+        process.exit(1);
+    }
+    console.log('');
+    (0, utils_js_1.logInfo)(`Creating "${appName}" with template: ${options.template}, package manager: ${options.packageManager}${options.rspack ? ', bundler: rspack' : ''}`);
+    (0, create_app_js_1.createApp)(appName, options);
+}
+const program = new commander_1.Command();
+program
+    .name('create-react-on-rails-app')
+    .description('Create a new React on Rails application with a single command.\n\n' +
+    'Sets up a Rails app with React, Webpack/Rspack, server-side rendering,\n' +
+    'and hot module replacement - ready to develop in minutes.')
+    .version(packageJson.version)
+    .argument('<app-name>', 'Name of the application to create')
+    .option('-t, --template <type>', 'javascript or typescript', 'typescript')
+    .option('-p, --package-manager <pm>', 'npm or pnpm (auto-detected if not specified)')
+    .option('--rspack', 'Use Rspack instead of Webpack (~20x faster builds)', false)
+    .addHelpText('after', `
+Examples:
+  $ npx create-react-on-rails-app my-app
+  $ npx create-react-on-rails-app my-app --template javascript
+  $ npx create-react-on-rails-app my-app --rspack
+  $ npx create-react-on-rails-app my-app --package-manager pnpm
+
+What it does:
+  1. Creates a new Rails app with PostgreSQL
+  2. Adds the react_on_rails gem
+  3. Runs the React on Rails generator (Shakapacker, components, webpack config)
+
+After setup, run bin/dev and visit http://localhost:3000/hello_world
+
+Documentation: https://www.shakacode.com/react-on-rails/docs/`)
+    .action((appName, opts) => {
+    try {
+        run(appName, opts);
+    }
+    catch (error) {
+        (0, utils_js_1.logError)(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+program.parse();
+//# sourceMappingURL=index.js.map

package/lib/types.d.ts

@@ -0,0 +1,10 @@
+export interface CliOptions {
+    template: 'javascript' | 'typescript';
+    packageManager: 'npm' | 'pnpm';
+    rspack: boolean;
+}
+export interface ValidationResult {
+    valid: boolean;
+    message: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/lib/utils.d.ts

@@ -0,0 +1,9 @@
+export declare function execLiveArgs(command: string, args: string[], cwd?: string): void;
+export declare function getCommandVersion(command: string): string | null;
+export declare function detectPackageManager(): 'npm' | 'pnpm' | null;
+export declare function logStep(current: number, total: number, message: string): void;
+export declare function logStepDone(message: string): void;
+export declare function logError(message: string): void;
+export declare function logSuccess(message: string): void;
+export declare function logInfo(message: string): void;
+//# sourceMappingURL=utils.d.ts.map

package/lib/utils.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execLiveArgs = execLiveArgs;
+exports.getCommandVersion = getCommandVersion;
+exports.detectPackageManager = detectPackageManager;
+exports.logStep = logStep;
+exports.logStepDone = logStepDone;
+exports.logError = logError;
+exports.logSuccess = logSuccess;
+exports.logInfo = logInfo;
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+function execLiveArgs(command, args, cwd) {
+    const result = (0, child_process_1.spawnSync)(command, args, {
+        stdio: 'inherit',
+        cwd,
+    });
+    if (result.error) {
+        throw result.error;
+    }
+    if (result.status !== 0) {
+        throw new Error(`Command "${command}" exited with code ${result.status}`);
+    }
+}
+function getCommandVersion(command) {
+    try {
+        return (0, child_process_1.execFileSync)(command, ['--version'], { encoding: 'utf8', stdio: 'pipe' }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+function detectPackageManager() {
+    const userAgent = process.env.npm_config_user_agent;
+    if (userAgent) {
+        if (userAgent.startsWith('pnpm'))
+            return 'pnpm';
+        if (userAgent.startsWith('npm'))
+            return 'npm';
+    }
+    if (getCommandVersion('pnpm'))
+        return 'pnpm';
+    if (getCommandVersion('npm'))
+        return 'npm';
+    return null;
+}
+function logStep(current, total, message) {
+    console.log(chalk_1.default.cyan(`\n[${current}/${total}] ${message}`));
+}
+function logStepDone(message) {
+    console.log(chalk_1.default.green(`  ✓ ${message}`));
+}
+function logError(message) {
+    console.error(chalk_1.default.red(`\nError: ${message}\n`));
+}
+function logSuccess(message) {
+    console.log(chalk_1.default.green(message));
+}
+function logInfo(message) {
+    console.log(chalk_1.default.cyan(message));
+}
+//# sourceMappingURL=utils.js.map

package/lib/validators.d.ts

@@ -0,0 +1,14 @@
+import { ValidationResult } from './types.js';
+export declare function validateNode(): ValidationResult;
+export declare function validateRuby(): ValidationResult;
+export declare function validateRails(): ValidationResult;
+export declare function validatePackageManager(pm: 'npm' | 'pnpm'): ValidationResult;
+export interface PrerequisiteResults {
+    allValid: boolean;
+    results: {
+        name: string;
+        result: ValidationResult;
+    }[];
+}
+export declare function validateAll(packageManager: 'npm' | 'pnpm'): PrerequisiteResults;
+//# sourceMappingURL=validators.d.ts.map

package/lib/validators.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateNode = validateNode;
+exports.validateRuby = validateRuby;
+exports.validateRails = validateRails;
+exports.validatePackageManager = validatePackageManager;
+exports.validateAll = validateAll;
+const utils_js_1 = require("./utils.js");
+const MIN_NODE_VERSION = 18;
+const MIN_RUBY_MAJOR = 3;
+const MIN_RUBY_MINOR = 0;
+function validateNode() {
+    const version = process.versions.node;
+    const major = parseInt(version.split('.')[0], 10);
+    if (major < MIN_NODE_VERSION) {
+        return {
+            valid: false,
+            message: `Node.js ${version} detected. React on Rails requires Node.js ${MIN_NODE_VERSION}+.\n` +
+                'Please update your version of Node.js: https://nodejs.org/',
+        };
+    }
+    return { valid: true, message: `Node.js ${version}` };
+}
+function validateRuby() {
+    const rubyVersion = (0, utils_js_1.getCommandVersion)('ruby');
+    if (!rubyVersion) {
+        return {
+            valid: false,
+            message: 'Ruby is not installed or not found in PATH.\n\n' +
+                'React on Rails requires Ruby 3.0+.\n\n' +
+                'Popular installation options:\n' +
+                '  - mise:   https://mise.jdx.dev/ (recommended)\n' +
+                '  - rbenv:  https://github.com/rbenv/rbenv\n' +
+                '  - asdf:   https://asdf-vm.com/\n' +
+                '  - rvm:    https://rvm.io/\n\n' +
+                'After installing Ruby, restart your terminal and try again.',
+        };
+    }
+    const match = rubyVersion.match(/ruby\s+(\d+)\.(\d+)/);
+    if (!match) {
+        return {
+            valid: false,
+            message: `Could not parse Ruby version from: "${rubyVersion.split('\n')[0].trim()}". Please ensure Ruby ${MIN_RUBY_MAJOR}.${MIN_RUBY_MINOR}+ is installed.`,
+        };
+    }
+    const major = parseInt(match[1], 10);
+    const minor = parseInt(match[2], 10);
+    if (major < MIN_RUBY_MAJOR || (major === MIN_RUBY_MAJOR && minor < MIN_RUBY_MINOR)) {
+        return {
+            valid: false,
+            message: `Ruby ${major}.${minor} detected. React on Rails requires Ruby ${MIN_RUBY_MAJOR}.${MIN_RUBY_MINOR}+.`,
+        };
+    }
+    return { valid: true, message: rubyVersion.split('\n')[0].trim() };
+}
+function validateRails() {
+    const railsVersion = (0, utils_js_1.getCommandVersion)('rails');
+    if (!railsVersion) {
+        return {
+            valid: false,
+            message: 'Rails is not installed or not found in PATH.\n\n' +
+                'Install Rails:\n' +
+                '  gem install rails\n\n' +
+                'Then try again.',
+        };
+    }
+    return { valid: true, message: railsVersion.split('\n')[0].trim() };
+}
+function validatePackageManager(pm) {
+    const version = (0, utils_js_1.getCommandVersion)(pm);
+    if (!version) {
+        return {
+            valid: false,
+            message: `${pm} is not installed or not found in PATH.`,
+        };
+    }
+    return { valid: true, message: `${pm} ${version.split('\n')[0].trim()}` };
+}
+function validateAll(packageManager) {
+    const results = [
+        { name: 'Node.js', result: validateNode() },
+        { name: 'Ruby', result: validateRuby() },
+        { name: 'Rails', result: validateRails() },
+        { name: 'Package Manager', result: validatePackageManager(packageManager) },
+    ];
+    const allValid = results.every((r) => r.result.valid);
+    return { allValid, results };
+}
+//# sourceMappingURL=validators.js.map

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "create-react-on-rails-app",
+  "version": "16.4.0-rc.0",
+  "description": "Create React on Rails applications with a single command",
+  "bin": {
+    "create-react-on-rails-app": "./bin/create-react-on-rails-app.js"
+  },
+  "main": "lib/index.js",
+  "files": [
+    "bin/",
+    "lib/**/*.js",
+    "lib/**/*.d.ts"
+  ],
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^12.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.16",
+    "typescript": "^5.8.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shakacode/react_on_rails.git",
+    "directory": "packages/create-react-on-rails-app"
+  },
+  "keywords": [
+    "react",
+    "rails",
+    "react-on-rails",
+    "create-app",
+    "cli",
+    "scaffold"
+  ],
+  "author": "justin@shakacode.com",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/shakacode/react_on_rails/issues"
+  },
+  "homepage": "https://github.com/shakacode/react_on_rails#readme",
+  "scripts": {
+    "build": "pnpm run clean && tsc",
+    "build-watch": "pnpm run clean && tsc --watch",
+    "clean": "rm -rf ./lib",
+    "test": "jest tests",
+    "type-check": "tsc --noEmit --noErrorTruncation"
+  }
+}