stonyx 0.2.2 → 0.2.3-alpha.1

package/src/cli/new.js

@@ -0,0 +1,232 @@
+import { confirm, prompt } from '@stonyx/utils/prompt';
+import { createFile, createDirectory, copyFile, fileExists } from '@stonyx/utils/file';
+import { spawn } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const MODULE_OPTIONS = [
+  {
+    question: 'Will this project need a REST server?',
+    package: '@stonyx/rest-server',
+    dirs: ['requests']
+  },
+  {
+    question: 'Will this project need WebSockets?',
+    package: '@stonyx/sockets',
+    dirs: ['socket-handlers']
+  },
+  {
+    question: 'Will this project need data management?',
+    package: '@stonyx/orm',
+    dirs: ['models', 'serializers', 'access', 'transforms', 'hooks'],
+    files: { 'config/db-schema.js': generateDbSchema }
+  },
+  {
+    question: 'Will this project need scheduled tasks (cron)?',
+    package: '@stonyx/cron',
+    dirs: ['crons']
+  },
+  {
+    question: 'Will this project need OAuth?',
+    package: '@stonyx/oauth'
+  },
+  {
+    question: 'Will this project need pub/sub events?',
+    package: '@stonyx/events'
+  }
+];
+
+function generateDbSchema() {
+  return `import { Model, hasMany } from '@stonyx/orm';
+
+export default class DBModel extends Model {
+  // Define your collections here
+  // examples = hasMany('example');
+}
+`;
+}
+
+function generatePackageJson(name, selectedModules) {
+  const devDependencies = { stonyx: 'latest' };
+
+  for (const mod of selectedModules) {
+    devDependencies[mod.package] = 'latest';
+  }
+
+  // Sort dependencies alphabetically
+  const sorted = Object.fromEntries(
+    Object.entries(devDependencies).sort(([a], [b]) => a.localeCompare(b))
+  );
+
+  return JSON.stringify({
+    name,
+    version: '0.1.0',
+    type: 'module',
+    private: true,
+    scripts: {
+      start: 'stonyx serve',
+      test: 'stonyx test'
+    },
+    devDependencies: sorted
+  }, null, 2) + '\n';
+}
+
+function generateAppJs() {
+  return `import log from 'stonyx/log';
+
+export default class App {
+  constructor() {
+    if (App.instance) return App.instance;
+    App.instance = this;
+
+    this.ready = this.init();
+  }
+
+  async init() {
+    log.info('Initializing Application');
+
+    // Application setup here
+
+    log.info('Application has been initialized');
+  }
+}
+`;
+}
+
+function generateEnvironmentJs() {
+  return `export default {
+}
+`;
+}
+
+function generateEnvironmentExampleJs() {
+  return `// Copy this file to environment.js and fill in your values
+// All values should use environment variables with ?? fallback defaults
+
+const {
+  NODE_ENV,
+} = process.env;
+
+const environment = NODE_ENV ?? 'development';
+
+export default {
+}
+`;
+}
+
+function generateGitignore() {
+  return `node_modules/
+.env
+db.json
+*.log
+`;
+}
+
+function runPnpmInstall(projectDir) {
+  return new Promise((resolve, reject) => {
+    const child = spawn('pnpm', ['install'], {
+      cwd: projectDir,
+      stdio: 'inherit'
+    });
+
+    child.on('close', code => {
+      if (code === 0) resolve();
+      else reject(new Error(`pnpm install exited with code ${code}`));
+    });
+
+    child.on('error', reject);
+  });
+}
+
+export default async function newCommand({ args }) {
+  let appName = args[0];
+
+  if (!appName) {
+    appName = await prompt('Project name:');
+  }
+
+  if (!appName) {
+    console.error('Project name is required.');
+    process.exit(1);
+  }
+
+  const projectDir = path.resolve(process.cwd(), appName);
+
+  if (await fileExists(projectDir)) {
+    console.error(`Directory "${appName}" already exists.`);
+    process.exit(1);
+  }
+
+  console.log(`\nScaffolding new Stonyx project: ${appName}\n`);
+
+  // Prompt for module selection
+  const selectedModules = [];
+
+  for (const mod of MODULE_OPTIONS) {
+    if (await confirm(mod.question)) {
+      selectedModules.push(mod);
+    }
+  }
+
+  console.log('\nCreating project structure...\n');
+
+  // Create project directory
+  await createDirectory(projectDir);
+
+  // Copy .nvmrc from monorepo root
+  const monorepoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', '..');
+  const nvmrcSource = path.join(monorepoRoot, '.nvmrc');
+
+  if (await fileExists(nvmrcSource)) {
+    await copyFile(nvmrcSource, path.join(projectDir, '.nvmrc'));
+  }
+
+  // Generate core files
+  await createFile(path.join(projectDir, 'package.json'), generatePackageJson(appName, selectedModules));
+  await createFile(path.join(projectDir, 'app.js'), generateAppJs());
+  await createFile(path.join(projectDir, '.gitignore'), generateGitignore());
+
+  // Create config directory and files
+  await createFile(path.join(projectDir, 'config', 'environment.js'), generateEnvironmentJs());
+  await createFile(path.join(projectDir, 'config', 'environment.example.js'), generateEnvironmentExampleJs());
+
+  // Create module-specific directories and files
+  for (const mod of selectedModules) {
+    if (mod.dirs) {
+      for (const dir of mod.dirs) {
+        await createDirectory(path.join(projectDir, dir));
+        // Create .gitkeep so empty dirs are tracked
+        await createFile(path.join(projectDir, dir, '.gitkeep'), '');
+      }
+    }
+
+    if (mod.files) {
+      for (const [filePath, generator] of Object.entries(mod.files)) {
+        await createFile(path.join(projectDir, filePath), generator());
+      }
+    }
+  }
+
+  // Create test structure
+  await createDirectory(path.join(projectDir, 'test', 'unit'));
+  await createFile(path.join(projectDir, 'test', 'unit', '.gitkeep'), '');
+  await createDirectory(path.join(projectDir, 'test', 'integration'));
+  await createFile(path.join(projectDir, 'test', 'integration', '.gitkeep'), '');
+  await createDirectory(path.join(projectDir, 'test', 'acceptance'));
+  await createFile(path.join(projectDir, 'test', 'acceptance', '.gitkeep'), '');
+
+  // Create test config
+  await createFile(path.join(projectDir, 'test', 'config', 'environment.js'), `export default {\n  // Test-specific config overrides\n}\n`);
+
+  console.log('Installing dependencies...\n');
+
+  try {
+    await runPnpmInstall(projectDir);
+  } catch (error) {
+    console.error('Failed to install dependencies. Run `pnpm install` manually in the project directory.');
+  }
+
+  console.log(`\n✓ Project "${appName}" created successfully!`);
+  console.log(`\n  cd ${appName}`);
+  console.log(`  stonyx serve\n`);
+}

package/src/cli/serve.js

@@ -0,0 +1,38 @@
+import { runStartupHooks, runShutdownHooks } from '../lifecycle.js';
+
+export function createShutdownHandler(modules) {
+  let shuttingDown = false;
+  return async () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+
+    await runShutdownHooks(modules);
+    process.exit(0);
+  };
+}
+
+export default async function serve({ args }) {
+  const cwd = process.cwd();
+  const entryFlag = args.indexOf('--entry');
+  const entryPoint = entryFlag !== -1 ? args[entryFlag + 1] : 'app.js';
+
+  const { default: config } = await import(`${cwd}/config/environment.js`);
+  const { default: Stonyx } = await import('../main.js');
+
+  new Stonyx(config, cwd);
+  await Stonyx.ready;
+
+  const { modules } = Stonyx.instance;
+  await runStartupHooks(modules);
+
+  const shutdown = createShutdownHandler(modules);
+
+  process.on('SIGTERM', shutdown);
+  process.on('SIGINT', shutdown);
+
+  const entryModule = await import(`${cwd}/${entryPoint}`);
+
+  if (entryModule.default) {
+    new entryModule.default();
+  }
+}

package/src/cli/test-setup.js

@@ -0,0 +1,8 @@
+import { pathToFileURL } from 'url';
+
+const cwd = process.cwd();
+
+const { default: Stonyx } = await import('stonyx');
+const { default: config } = await import(pathToFileURL(`${cwd}/config/environment.js`));
+
+new Stonyx(config, cwd);

package/src/cli/test.js

@@ -0,0 +1,27 @@
+import { spawn } from 'child_process';
+import { fileURLToPath, pathToFileURL } from 'url';
+import path from 'path';
+
+export default async function test({ args }) {
+  const cwd = process.cwd();
+  const setupFile = path.resolve(path.dirname(fileURLToPath(import.meta.url)), 'test-setup.js');
+  const setupFileUrl = pathToFileURL(setupFile).href;
+  const qunitBin = path.resolve(cwd, 'node_modules/qunit/bin/qunit.js');
+
+  // Default to conventional test glob if no args provided
+  const testArgs = args.length > 0 ? args : ['test/**/*-test.js'];
+
+  const child = spawn(process.execPath, [
+    '--import', setupFileUrl,
+    qunitBin,
+    ...testArgs
+  ], {
+    cwd,
+    stdio: 'inherit',
+    env: { ...process.env, NODE_ENV: 'test' }
+  });
+
+  child.on('close', (code) => {
+    process.exit(code);
+  });
+}

package/src/cli.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+
+import serve from './cli/serve.js';
+import test from './cli/test.js';
+import help from './cli/help.js';
+import newCommand from './cli/new.js';
+import loadModuleCommands from './cli/load-commands.js';
+
+try { process.loadEnvFile(); } catch { /* no .env file */ }
+
+const aliases = { s: 'serve', t: 'test', h: 'help', n: 'new' };
+
+const builtInCommands = {
+  serve: { description: 'Bootstrap Stonyx and run the app', run: serve },
+  test: { description: 'Bootstrap Stonyx in test mode and run tests', run: test },
+  new: { description: 'Scaffold a new Stonyx project', run: newCommand },
+  help: { description: 'Show available commands', run: help }
+};
+
+const args = process.argv.slice(2);
+const commandName = aliases[args[0]] || args[0];
+const commandArgs = args.slice(1);
+
+async function main() {
+  if (!commandName || commandName === 'help') {
+    await help({ args: commandArgs, builtInCommands, loadModuleCommands });
+    return;
+  }
+
+  const builtIn = builtInCommands[commandName];
+
+  if (builtIn) {
+    await builtIn.run({ args: commandArgs });
+    return;
+  }
+
+  // Search module commands
+  const moduleCommands = await loadModuleCommands();
+  const moduleCommand = moduleCommands[commandName];
+
+  if (moduleCommand) {
+    const cwd = process.cwd();
+
+    if (moduleCommand.bootstrap) {
+      const { default: config } = await import(`${cwd}/config/environment.js`);
+      const { default: Stonyx } = await import('./main.js');
+      new Stonyx(config, cwd);
+      await Stonyx.ready;
+    }
+
+    await moduleCommand.run({ args: commandArgs, cwd });
+    return;
+  }
+
+  console.error(`Unknown command: ${args[0]}\n`);
+  await help({ args: [], builtInCommands, loadModuleCommands });
+  process.exit(1);
+}
+
+main().catch(error => {
+  console.error(error);
+  process.exit(1);
+});

package/src/lifecycle.js

@@ -0,0 +1,17 @@
+export async function runStartupHooks(modules) {
+  for (const module of modules) {
+    if (typeof module.startup === 'function') await module.startup();
+  }
+}
+
+export async function runShutdownHooks(modules) {
+  for (const module of [...modules].reverse()) {
+    if (typeof module.shutdown === 'function') {
+      try {
+        await module.shutdown();
+      } catch (error) {
+        console.error('Error during module shutdown:', error);
+      }
+    }
+  }
+}

package/src/main.js

@@ -17,6 +17,7 @@
 import Chronicle from 'node-chronicle';
 import loadModules from './modules.js';
 import { kebabCaseToCamelCase } from '@stonyx/utils/string';
+import { mergeObject } from '@stonyx/utils/object';
 
 export default class Stonyx {
   static initialized = false
@@ -45,6 +46,16 @@ export default class Stonyx {
 
     Stonyx.initialized = true;
 
+    // Auto-merge test environment overrides (after initialized flag, before modules load)
+    // Uses in-place mutation to preserve existing references (e.g. stonyx/config export cache)
+    if (process.env.NODE_ENV === 'test') {
+      try {
+        const { default: testOverrides } = await import(`${rootPath}/test/config/environment.js`);
+        const merged = mergeObject(config, testOverrides);
+        Object.assign(config, merged);
+      } catch { /* no test overrides found */ }
+    }
+
     this.modules = await loadModules(config, rootPath, this.chronicle);
     this.configureUserLogs();
   }

package/src/bootstrap.cjs

@@ -1,9 +0,0 @@
-/**
- * commonJS Bootstrap loading - Stonyx must be loaded first, prior to the rest of the application
- */
-const { default:Stonyx } = require('stonyx');
-const { default:config } = require('./config/environment.js');
-
-new Stonyx(config, __dirname);
-
-module.exports = Stonyx;

package/stonyx-bootstrap.cjs

@@ -1,9 +0,0 @@
-/**
- * commonJS Bootstrap loading - Stonyx must be loaded first, prior to the rest of the application
- */
-const { default:Stonyx } = require('stonyx');
-const { default:config } = require('./config/environment.js');
-
-new Stonyx(config, __dirname);
-
-module.exports = Stonyx;