@mojojs/core 1.27.0 → 2.0.0

package/lib/cli/create-full-app.js

@@ -1,13 +1,18 @@
 import crypto from 'node:crypto';
-import { version } from '../core.js';
-import * as util from '../util.js';
-import nopt from 'nopt';
+import { parseArgs } from 'node:util';
+import { version } from "../core.js";
+import * as util from "../util.js";
 /**
  * Minimal application generator command.
  */
 export default async function createFullAppCommand(app, args) {
-    const parsed = nopt({ ts: Boolean }, {}, args, 1);
-    const ts = parsed.ts === true;
+    const { values } = parseArgs({
+        args: args.slice(1),
+        options: { ts: { type: 'boolean' } },
+        allowPositionals: true,
+        allowNegative: true
+    });
+    const ts = values.ts === true;
     process.stdout.write('Generating application directory structure:\n');
     await util.cliCreateFile('config.yml', yamlConfig, { secret: crypto.randomBytes(16).toString('hex') });
     await util.cliCreateDir('views/layouts');
@@ -24,35 +29,31 @@ export default async function createFullAppCommand(app, args) {
         await util.cliCreateFile('src/controllers/example.ts', tsController);
         await util.cliCreateDir('src/models');
         await util.cliCreateDir('test');
-        await util.cliCreateFile('test/example.js', jsTest, { indexPath: '../lib/index.js' });
+        await util.cliCreateFile('test/example.js', jsTest, { indexPath: '../src/index.ts' });
+        // Node.js runs the TypeScript sources directly, so tsc is only used for type checking
         const tsConfig = {
             compilerOptions: {
-                lib: ['ESNext', 'DOM'],
-                target: 'ES2020',
-                module: 'ES2020',
-                sourceMap: true,
-                declaration: true,
-                incremental: true,
-                moduleResolution: 'node',
-                esModuleInterop: true,
+                lib: ['ESNext'],
+                target: 'ESNext',
+                module: 'nodenext',
+                moduleResolution: 'nodenext',
+                noEmit: true,
+                allowImportingTsExtensions: true,
+                erasableSyntaxOnly: true,
+                verbatimModuleSyntax: true,
                 noErrorTruncation: true,
-                strict: true,
-                outDir: 'lib',
-                rootDir: 'src',
-                composite: true
+                strict: true
             },
             include: ['src/**/*']
         };
         await util.cliCreateFile('tsconfig.json', JSON.stringify(tsConfig, null, 2));
         await util.cliFixPackage({
             dependencies: { '@mojojs/core': `^${version}` },
-            devDependencies: await util.devDependencies(/^(@types\/.+|nodemon|tap|typescript)$/),
+            devDependencies: await util.devDependencies(/^(@types\/node|tap|typescript)$/),
             scripts: {
-                build: 'npx tsc --build ./',
-                'build:test': 'npm run build && npm test',
-                'build:watch': 'npm run build -- --watch',
-                dev: 'npx nodemon lib/index.js server',
-                start: 'NODE_ENV=production node lib/index.js server -l http://*:8080',
+                check: 'npx tsc',
+                dev: 'node --watch src/index.ts server',
+                start: 'NODE_ENV=production node src/index.ts server -l http://*:8080',
                 test: 'node --test test/*.js'
             }
         });
@@ -67,9 +68,9 @@ export default async function createFullAppCommand(app, args) {
         await util.cliCreateFile('test/example.js', jsTest, { indexPath: '../index.js' });
         await util.cliFixPackage({
             dependencies: { '@mojojs/core': `^${version}` },
-            devDependencies: await util.devDependencies(/^(nodemon|tap)$/),
+            devDependencies: await util.devDependencies(/^tap$/),
             scripts: {
-                dev: 'npx nodemon index.js server',
+                dev: 'node --watch index.js server',
                 start: 'NODE_ENV=production node index.js server -l http://*:8080',
                 test: 'node --test test/*.js'
             }
@@ -163,4 +164,3 @@ t.test('Example application', async t => {
   await ua.stop();
 });
 `;
-//# sourceMappingURL=create-full-app.js.map

package/lib/cli/create-lite-app.d.ts

@@ -1,4 +1,4 @@
-import type { App } from '../app.js';
+import type { App } from '../app.ts';
 /**
  * Application generator command.
  */

package/lib/cli/create-lite-app.js

@@ -1,5 +1,5 @@
-import { version } from '../core.js';
-import * as util from '../util.js';
+import { version } from "../core.js";
+import * as util from "../util.js";
 /**
  * Application generator command.
  */
@@ -60,4 +60,3 @@ const defaultLayout = \`
 </html>
 \`;
 `;
-//# sourceMappingURL=create-lite-app.js.map

package/lib/cli/create-plugin.d.ts

@@ -1,4 +1,4 @@
-import type { App } from '../app.js';
+import type { App } from '../app.ts';
 /**
  * Plugin generator command.
  */

package/lib/cli/create-plugin.js

@@ -1,24 +1,30 @@
-import { version } from '../core.js';
-import * as util from '../util.js';
-import nopt from 'nopt';
+import { parseArgs } from 'node:util';
+import { version } from "../core.js";
+import * as util from "../util.js";
 /**
  * Plugin generator command.
  */
 export default async function createPluginCommand(app, args) {
-    const parsed = nopt({ ts: Boolean }, {}, args, 1);
-    const ts = parsed.ts === true;
+    const { values, positionals } = parseArgs({
+        args: args.slice(1),
+        options: { ts: { type: 'boolean' } },
+        allowPositionals: true,
+        allowNegative: true
+    });
+    const ts = values.ts === true;
     const stdout = process.stdout;
     stdout.write('Generating plugin:\n');
-    const name = parsed.argv.remain[0] ?? 'mojo-plugin-myplugin';
+    const name = positionals[0] ?? 'mojo-plugin-myplugin';
     const file = `lib/${name}.js`;
+    const tsFile = `src/${name}.ts`;
     await util.cliCreateDir('test');
-    await util.cliCreateFile('test/basic.js', test, { file });
+    await util.cliCreateFile('test/basic.js', test, { file: ts === true ? tsFile : file });
     await util.cliCreateFile('README.md', readme, { name });
     const commonSettings = {
         author: 'A Good Programmer <nospam@example.com>',
         description: 'A mojo.js plugin',
         dependencies: { '@mojojs/core': `^${version}` },
-        exports: './lib/plugin.js',
+        exports: `./${file}`,
         files: ['lib/'],
         name,
         license: 'MIT',
@@ -26,35 +32,32 @@ export default async function createPluginCommand(app, args) {
     };
     // TypeScript
     if (ts === true) {
-        const tsFile = `src/${name}.ts`;
         await util.cliCreateDir('src');
         await util.cliCreateFile(tsFile, tsPlugin);
         const tsConfig = {
             compilerOptions: {
-                lib: ['ESNext', 'DOM'],
-                target: 'ES2020',
-                module: 'ES2020',
-                sourceMap: true,
+                lib: ['ESNext'],
+                target: 'ES2023',
+                module: 'nodenext',
+                moduleResolution: 'nodenext',
                 declaration: true,
-                incremental: true,
-                moduleResolution: 'node',
-                esModuleInterop: true,
+                erasableSyntaxOnly: true,
+                verbatimModuleSyntax: true,
+                rewriteRelativeImportExtensions: true,
                 noErrorTruncation: true,
                 strict: true,
                 outDir: 'lib',
-                rootDir: 'src',
-                composite: true
+                rootDir: 'src'
             },
             include: ['src/**/*']
         };
         await util.cliCreateFile('tsconfig.json', JSON.stringify(tsConfig, null, 2));
         await util.cliFixPackage({
             ...commonSettings,
-            devDependencies: await util.devDependencies(/^(@types\/.+|tap|typescript)$/),
+            devDependencies: await util.devDependencies(/^(@types\/node|tap|typescript)$/),
             scripts: {
-                build: 'npx tsc --build ./',
-                'build:test': 'npm run build && npm test',
-                'build:watch': 'npm run build -- --watch',
+                build: 'npx tsc',
+                prepublishOnly: 'npm run build',
                 test: 'node --test test/*.js'
             }
         });
@@ -137,4 +140,3 @@ All you need is Node.js 16.0.0 (or newer).
 $ npm install <%= name %>
 \`\`\`
 `;
-//# sourceMappingURL=create-plugin.js.map

package/lib/cli/eval.d.ts

@@ -1,4 +1,4 @@
-import type { MojoApp } from '../types.js';
+import type { MojoApp } from '../types.ts';
 /**
  * Eval command.
  */

package/lib/cli/eval.js

@@ -1,11 +1,16 @@
-import nopt from 'nopt';
+import { parseArgs } from 'node:util';
 /**
  * Eval command.
  */
 export default async function evalCommand(app, args) {
-    const parsed = nopt({ verbose: Boolean }, { v: '--verbose' }, args, 1);
-    const output = await eval('(async () => (' + parsed.argv.remain[0] + '))()');
-    if (parsed.verbose === true)
+    const { values, positionals } = parseArgs({
+        args: args.slice(1),
+        options: { verbose: { type: 'boolean', short: 'v' } },
+        allowPositionals: true,
+        allowNegative: true
+    });
+    const output = await eval('(async () => (' + positionals[0] + '))()');
+    if (values.verbose === true)
         console.log(output);
 }
 evalCommand.description = 'Run code against application';
@@ -15,8 +20,10 @@ evalCommand.usage = `Usage: APPLICATION eval [OPTIONS] CODE
   node index.js eval -v 'app.home.toString()'
   node index.js eval -v 'app.renderer.viewPaths'
 
+  # Use "--" for code starting with "-"
+  node index.js eval -v -- '-1 + 2'
+
 Options:
   -h, --help      Show this summary of available options
   -v, --verbose   Print return value to stdout
 `;
-//# sourceMappingURL=eval.js.map

package/lib/cli/get.d.ts

@@ -1,4 +1,4 @@
-import type { MojoApp } from '../types.js';
+import type { MojoApp } from '../types.ts';
 /**
  * Get command.
  */

package/lib/cli/get.js

@@ -1,41 +1,46 @@
-import chalk from 'chalk';
-import nopt from 'nopt';
+import { parseArgs, styleText } from 'node:util';
 /**
  * Get command.
  */
 export default async function getCommand(app, args) {
-    const parsed = nopt({
-        body: String,
-        header: [String, Array],
-        insecure: Boolean,
-        method: String,
-        redirect: Boolean,
-        'socket-path': String,
-        verbose: Boolean
-    }, { b: '--body', H: '--header', k: '--insecure', X: '--method', P: '--socket-path', r: '--redirect', v: '--verbose' }, args, 1);
-    const argv = parsed.argv;
+    const { values, positionals } = parseArgs({
+        args: args.slice(1),
+        options: {
+            body: { type: 'string', short: 'b' },
+            header: { type: 'string', short: 'H', multiple: true },
+            insecure: { type: 'boolean', short: 'k' },
+            method: { type: 'string', short: 'X' },
+            redirect: { type: 'boolean', short: 'r' },
+            'socket-path': { type: 'string', short: 'P' },
+            verbose: { type: 'boolean', short: 'v' }
+        },
+        allowPositionals: true,
+        allowNegative: true
+    });
     const request = {
-        body: parsed.body,
-        headers: parseHeaders(parsed.header),
-        insecure: parsed.insecure,
-        method: parsed.method ?? 'GET',
-        socketPath: parsed['socket-path'],
-        url: argv.remain[0] ?? '/'
+        body: values.body,
+        headers: parseHeaders(values.header),
+        insecure: values.insecure,
+        method: values.method ?? 'GET',
+        socketPath: values['socket-path'],
+        url: positionals[0] ?? '/'
     };
-    const ua = await app.newMockUserAgent({ maxRedirects: parsed.redirect === true ? 10 : 0 });
+    const ua = await app.newMockUserAgent({ maxRedirects: values.redirect === true ? 10 : 0 });
     const res = await ua.request(request);
-    if (parsed.verbose === true) {
+    if (values.verbose === true) {
         const stderr = process.stderr;
-        const resVersion = chalk.blue('HTTP') + '/' + chalk.blue(res.httpVersion);
+        // Colors depend on the stream the output goes to
+        const options = { stream: stderr };
+        const resVersion = styleText('blue', 'HTTP', options) + '/' + styleText('blue', res.httpVersion, options);
         const statusCode = res.statusCode;
-        const statusMessage = chalk.blue(res.statusMessage);
+        const statusMessage = styleText('blue', res.statusMessage, options);
         stderr.write(`${resVersion} ${statusCode} ${statusMessage}\n`);
         writeHeaders(res.headers.toArray());
     }
-    if (argv.remain[1] !== undefined) {
+    if (positionals[1] !== undefined) {
         const html = await res.html();
         process.stdout.write(html
-            .find(argv.remain[1])
+            .find(positionals[1])
             .map(el => el.toString())
             .join('') ?? '');
     }
@@ -75,8 +80,7 @@ function parseHeaders(list = []) {
 function writeHeaders(headers) {
     const stderr = process.stderr;
     for (let i = 0; i < headers.length; i += 2) {
-        stderr.write(chalk.cyan(headers[i]) + `: ${headers[i + 1]}\n`);
+        stderr.write(styleText('cyan', headers[i], { stream: stderr }) + `: ${headers[i + 1]}\n`);
     }
     stderr.write('\n');
 }
-//# sourceMappingURL=get.js.map

package/lib/cli/repl.d.ts

@@ -1,4 +1,4 @@
-import type { MojoApp } from '../types.js';
+import type { MojoApp } from '../types.ts';
 /**
  * Repl command.
  */

package/lib/cli/repl.js

@@ -13,4 +13,3 @@ replCommand.usage = `Usage: APPLICATION repl [OPTIONS]
 Options:
   -h, --help   Show this summary of available options
 `;
-//# sourceMappingURL=repl.js.map

package/lib/cli/routes.d.ts

@@ -1,4 +1,4 @@
-import type { MojoApp } from '../types.js';
+import type { MojoApp } from '../types.ts';
 /**
  * Routes command.
  */

package/lib/cli/routes.js

@@ -1,13 +1,17 @@
+import { parseArgs, styleText } from 'node:util';
 import { tablify } from '@mojojs/util';
-import chalk from 'chalk';
-import nopt from 'nopt';
 /**
  * Routes command.
  */
 export default async function routesCommand(app, args) {
-    const parsed = nopt({ verbose: Boolean }, { v: '--verbose' }, args, 1);
+    const { values } = parseArgs({
+        args: args.slice(1),
+        options: { verbose: { type: 'boolean', short: 'v' } },
+        allowPositionals: true,
+        allowNegative: true
+    });
     const table = [];
-    app.router.children.map(route => walk(route, 0, table, parsed.verbose));
+    app.router.children.map(route => walk(route, 0, table, values.verbose === true));
     process.stdout.write(tablify(table));
 }
 routesCommand.description = 'Show available routes';
@@ -27,9 +31,9 @@ function walk(route, depth, rows, verbose) {
     rows.push(row);
     // Methods
     const methods = route.methods;
-    row.push(chalk.cyan(methods.length === 0 ? '*' : methods.map(method => method.toUpperCase()).join(',')));
+    row.push(styleText('cyan', methods.length === 0 ? '*' : methods.map(method => method.toUpperCase()).join(',')));
     // Name
-    row.push(route.customName !== undefined ? chalk.green(route.customName) : chalk.red(route.defaultName ?? 'n/a'));
+    row.push(route.customName !== undefined ? styleText('green', route.customName) : styleText('red', route.defaultName ?? 'n/a'));
     // Regex (verbose)
     const pattern = route.pattern;
     pattern.match('/', { isEndpoint: route.isEndpoint() });
@@ -40,4 +44,3 @@ function walk(route, depth, rows, verbose) {
     route.children.map(child => walk(child, depth, rows, verbose));
     depth--;
 }
-//# sourceMappingURL=routes.js.map

package/lib/cli/server.d.ts

@@ -1,4 +1,4 @@
-import type { MojoApp } from '../types.js';
+import type { MojoApp } from '../types.ts';
 /**
  * Server command.
  */

package/lib/cli/server.js

@@ -1,32 +1,39 @@
-import { Server } from '../server.js';
-import nopt from 'nopt';
+import { parseArgs } from 'node:util';
+import { Server } from "../server.js";
 const EVENTS = ['SIGINT', 'SIGTERM', 'SIGUSR2'];
 /**
  * Server command.
  */
 export default async function serverCommand(app, args) {
-    const parsed = nopt({
-        cluster: Boolean,
-        'headers-timeout': Number,
-        'keep-alive-timeout': Number,
-        level: String,
-        listen: [String, Array],
-        proxy: Boolean,
-        requests: Number,
-        'request-timeout': Number,
-        workers: Number
-    }, { c: '--cluster', L: '--level', l: '--listen', p: '--proxy', r: '--requests', w: '--workers' }, args, 1);
-    if (parsed.level !== undefined)
-        app.log.level = parsed.level;
+    const { values } = parseArgs({
+        args: args.slice(1),
+        options: {
+            cluster: { type: 'boolean', short: 'c' },
+            'headers-timeout': { type: 'string' },
+            'keep-alive-timeout': { type: 'string' },
+            level: { type: 'string', short: 'L' },
+            listen: { type: 'string', short: 'l', multiple: true },
+            'max-websocket-size': { type: 'string' },
+            proxy: { type: 'boolean', short: 'p' },
+            requests: { type: 'string', short: 'r' },
+            'request-timeout': { type: 'string' },
+            workers: { type: 'string', short: 'w' }
+        },
+        allowPositionals: true,
+        allowNegative: true
+    });
+    if (values.level !== undefined)
+        app.log.level = values.level;
     const server = new Server(app, {
-        cluster: parsed.cluster,
-        headersTimeout: parsed['headers-timeout'],
-        keepAliveTimeout: parsed['keep-alive-timeout'],
-        listen: parsed.listen,
-        maxRequestsPerSocket: parsed.requests,
-        requestTimeout: parsed['request-timeout'],
-        reverseProxy: parsed.proxy,
-        workers: parsed.workers
+        cluster: values.cluster,
+        headersTimeout: toNumber(values['headers-timeout']),
+        keepAliveTimeout: toNumber(values['keep-alive-timeout']),
+        listen: values.listen,
+        maxRequestsPerSocket: toNumber(values.requests),
+        maxWebSocketSize: toNumber(values['max-websocket-size']),
+        requestTimeout: toNumber(values['request-timeout']),
+        reverseProxy: values.proxy,
+        workers: toNumber(values.workers)
     });
     const listener = () => {
         EVENTS.forEach(signal => process.removeListener(signal, listener));
@@ -82,6 +89,9 @@ Options:
   -L, --level <level>             Log level for application
   -l, --listen <location>         One or more locations you want to listen on,
                                   defaults to "http://*:3000"
+      --max-websocket-size <bytes>
+                                  Maximum WebSocket message size, defaults to
+                                  262144 (256 KiB)
   -p, --proxy                     Activate reverse proxy support
   -r, --requests <num>            Maximum number of requests socket can handle
                                   before closing keep alive connection,
@@ -92,4 +102,11 @@ Options:
   -w, --workers <num>             Number of workers to spawn in cluster mode,
                                   defaults to the number of available CPUs
 `;
-//# sourceMappingURL=server.js.map
+function toNumber(value) {
+    if (value === undefined)
+        return undefined;
+    const number = Number(value);
+    if (value.trim() === '' || Number.isNaN(number))
+        throw new Error(`Invalid number "${value}"`);
+    return number;
+}

package/lib/cli/version.js

@@ -1,4 +1,4 @@
-import { version } from '../core.js';
+import { version } from "../core.js";
 import { tablify } from '@mojojs/util';
 /**
  * Version command.
@@ -18,4 +18,3 @@ versionCommand.usage = `Usage: APPLICATION version [OPTIONS]
 Options:
   -h, --help   Show this summary of available options
 `;
-//# sourceMappingURL=version.js.map

package/lib/cli.d.ts

@@ -1,4 +1,4 @@
-import type { App } from './app.js';
+import type { App } from './app.ts';
 interface Command {
     (app: App, args: string[]): Promise<void>;
     description: string;

package/lib/cli.js

@@ -1,21 +1,22 @@
-import { loadModules } from './util.js';
+import { parseArgs } from 'node:util';
+import { loadModules } from "./util.js";
 import Path from '@mojojs/path';
 import { tablify } from '@mojojs/util';
-import nopt from 'nopt';
 /**
  * Command line interface class.
  */
 export class CLI {
+    /**
+     * Paths to search for commands.
+     */
+    commandPaths = [Path.currentFile().sibling('cli').toString()];
+    /**
+     * Registered commands.
+     */
+    commands = {};
+    _app;
+    _loaded = undefined;
     constructor(app) {
-        /**
-         * Paths to search for commands.
-         */
-        this.commandPaths = [Path.currentFile().sibling('cli').toString()];
-        /**
-         * Registered commands.
-         */
-        this.commands = {};
-        this._loaded = undefined;
         this._app = new WeakRef(app);
     }
     /**
@@ -51,23 +52,29 @@ export class CLI {
             await this._loadCommands();
         if ((await app.hooks.runHook('command:init', app, commandArgs)) === true)
             return;
-        const parsed = nopt({ help: Boolean, 'show-all': Boolean }, { h: '--help' }, commandArgs);
-        const { argv } = parsed;
-        if (argv.remain.length > 0) {
-            const name = argv.original[0];
+        // Not strict, because the options of the command itself are unknown here
+        const original = commandArgs.slice(2);
+        const { values, positionals } = parseArgs({
+            args: original,
+            options: { help: { type: 'boolean', short: 'h' }, 'show-all': { type: 'boolean' } },
+            allowPositionals: true,
+            strict: false
+        });
+        if (positionals.length > 0) {
+            const name = original[0];
             const command = this.commands[name];
             if (command === undefined) {
                 process.stdout.write(`Unknown command "${name}", maybe you need to install it?\n`);
             }
-            else if (parsed.help === true) {
+            else if (values.help === true) {
                 process.stdout.write(command.usage);
             }
             else {
-                await command(app, argv.original);
+                await command(app, original);
             }
         }
         else {
-            await this._listCommands(parsed['show-all']);
+            await this._listCommands(values['show-all'] === true);
         }
         await app.hooks.commandAfter(app, commandArgs);
     }
@@ -99,4 +106,3 @@ Commands:
 const footer = `
 See 'APPLICATION COMMAND --help' for more information on a specific command.
 `;
-//# sourceMappingURL=cli.js.map

package/lib/context.d.ts

@@ -1,16 +1,16 @@
-import type { App } from './app.js';
-import type { ChildLogger } from './logger.js';
-import type { Plan } from './router/plan.js';
-import type { ServerRequest } from './server/request.js';
-import type { ServerResponse } from './server/response.js';
-import type { BackendInfo, MojoAction, MojoModels, MojoRenderOptions, MojoURLOptions, ScopedNestedHelpers, SessionData, SSEEvent, UploadOptions, ValidatorFunction } from './types.js';
-import type { UserAgent } from './user-agent.js';
-import type { WebSocket } from './websocket.js';
+import type { App } from './app.ts';
+import type { ChildLogger } from './logger.ts';
+import type { Plan } from './router/plan.ts';
+import type { ServerRequest } from './server/request.ts';
+import type { ServerResponse } from './server/response.ts';
+import type { BackendInfo, MojoAction, MojoModels, MojoRenderOptions, MojoURLOptions, ScopedNestedHelpers, SessionData, SSEEvent, UploadOptions, ValidatorFunction } from './types.ts';
+import type { UserAgent } from './user-agent.ts';
+import type { WebSocket } from './websocket.ts';
 import type Path from '@mojojs/path';
 import EventEmitter from 'node:events';
 import { PassThrough } from 'node:stream';
-import { Params } from './body/params.js';
-import { SafeString } from './util.js';
+import { Params } from './body/params.ts';
+import { SafeString } from './util.ts';
 type WebSocketHandler = (ws: WebSocket) => void | Promise<void>;
 interface ContextEvents {
     connection: (ws: WebSocket) => void;