@untrustnova/nova-cli 1.0.0

package/README.md

@@ -0,0 +1,50 @@
+# Nova CLI
+
+CLI resmi untuk membuat dan menjalankan proyek Nova.js.
+
+## Instalasi
+
+```bash
+npm install -g @untrustnova/nova-cli
+```
+
+## Perintah Utama
+
+```bash
+nova new <name>                # Scaffold project baru (fetch template)
+nova dev                       # Jalankan backend + Vite dev server
+nova build                     # Build produksi (Vite)
+nova db:init                   # Drizzle generate
+nova db:push                   # Drizzle push
+nova create:controller <name>  # Controller baru
+nova create:middleware <name>  # Middleware baru
+nova create:migration <name>   # Migration baru
+```
+
+## Alur Cepat
+
+```bash
+npm install -g @untrustnova/nova-cli
+nova new my-app
+cd my-app
+npm run dev
+```
+
+## Struktur Template
+
+Template menggunakan:
+- `nova.config.js` sebagai konfigurasi utama (tanpa `vite.config.js`)
+- Routing hybrid (object + file-based)
+- Folder `app/` untuk server-side
+- Folder `web/` untuk frontend React
+
+## Catatan
+
+`nova new` akan mencoba fetch template dari repo `nova` dan meng-install dependency
+(`@untrustnova/nova-framework` termasuk). Gunakan `--no-install` jika ingin skip instalasi,
+atau set `NOVA_TEMPLATE_REPO` untuk mengganti repo template.
+
+`nova dev` akan menjalankan `server.js` dan Vite dev server secara bersamaan.
+
+Perintah `db:*` adalah pembungkus untuk `drizzle-kit`.
+Jika belum terpasang, install: `npm install -D drizzle-kit`.

package/bin/nova.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { run } from '../src/cli.js';
+
+run(process.argv.slice(2));

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@untrustnova/nova-cli",
+  "version": "1.0.0",
+  "description": "Nova.js CLI",
+  "type": "module",
+  "bin": {
+    "nova": "./bin/nova.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin",
+    "src",
+    "templates"
+  ],
+  "keywords": [
+    "nova",
+    "nova-js",
+    "cli"
+  ],
+  "license": "MIT"
+}

package/src/cli.js

@@ -0,0 +1,348 @@
+import { spawn } from 'node:child_process';
+import { mkdir, mkdtemp, readdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { tmpdir } from 'node:os';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const templateRoot = resolve(__dirname, '../templates/base');
+
+export async function run(args) {
+  const [command, ...rest] = args;
+
+  if (!command || command === 'help' || command === '--help' || command === '-h') {
+    printHelp();
+    return;
+  }
+
+  if (command === '--version' || command === '-v') {
+    console.log('nova-cli 0.1.0');
+    return;
+  }
+
+  try {
+    switch (command) {
+      case 'new':
+        await scaffoldProject(rest);
+        break;
+      case 'dev':
+        await runDev();
+        break;
+      case 'build':
+        await runBuild();
+        break;
+      case 'db:init':
+        await runDrizzle('generate');
+        break;
+      case 'db:push':
+        await runDrizzle('push');
+        break;
+      case 'create:controller':
+        await createController(rest[0]);
+        break;
+      case 'create:middleware':
+        await createMiddleware(rest[0]);
+        break;
+      case 'create:migration':
+        await createMigration(rest[0]);
+        break;
+      default:
+        console.error(`[nova] unknown command "${command}"`);
+        printHelp();
+    }
+  } catch (error) {
+    console.error(`[nova] ${error.message}`);
+    process.exitCode = 1;
+  }
+}
+
+function printHelp() {
+  console.log(`Nova CLI
+
+Usage:
+  nova new <name> [--no-install]
+  nova dev
+  nova build
+  nova db:init
+  nova db:push
+  nova create:controller <name>
+  nova create:middleware <name>
+  nova create:migration <name>
+`);
+}
+
+async function scaffoldProject(args) {
+  const [name, ...flags] = args;
+  const shouldInstall = !flags.includes('--no-install') && !flags.includes('--skip-install');
+
+  if (!name) {
+    throw new Error('project name is required');
+  }
+
+  const target = resolve(process.cwd(), name);
+  if (await pathExists(target)) {
+    const entries = await readdir(target);
+    if (entries.length > 0) {
+      throw new Error(`directory "${name}" is not empty`);
+    }
+  } else {
+    await mkdir(target, { recursive: true });
+  }
+
+  const remoteTemplate = await tryFetchTemplate(
+    process.env.NOVA_TEMPLATE_REPO || 'https://github.com/nova-js/nova',
+  );
+
+  const source = remoteTemplate?.path || templateRoot;
+  await copyTemplate(source, target, {
+    '__APP_NAME__': name,
+  });
+
+  console.log(`[nova] project created at ${target}`);
+
+  if (remoteTemplate?.cleanup) {
+    await remoteTemplate.cleanup();
+  }
+
+  if (shouldInstall) {
+    await runCommand('npm', ['install'], { cwd: target });
+    console.log('[nova] dependencies installed');
+  }
+}
+
+async function createController(name) {
+  if (!name) {
+    throw new Error('controller name is required');
+  }
+
+  const fileName = normalizeSuffix(name, '.controller.js');
+  const className = toClassName(fileName.replace('.controller.js', ''));
+  const target = resolve(process.cwd(), 'app', 'controllers', fileName);
+
+  await ensureDir(dirname(target));
+  await ensureNotExists(target);
+
+  const body = `import { Controller } from '@untrustnova/nova-framework/controller';
+
+export default class ${className}Controller extends Controller {
+  async index({ response }) {
+    response.json({ message: '${className} ready' });
+  }
+}
+`;
+
+  await writeFile(target, body, 'utf8');
+  console.log(`[nova] controller created: ${relativePath(target)}`);
+}
+
+async function createMiddleware(name) {
+  if (!name) {
+    throw new Error('middleware name is required');
+  }
+
+  const fileName = normalizeSuffix(name, '.middleware.js');
+  const className = toClassName(fileName.replace('.middleware.js', ''));
+  const target = resolve(process.cwd(), 'app', 'middleware', fileName);
+
+  await ensureDir(dirname(target));
+  await ensureNotExists(target);
+
+  const body = `export class ${className}Middleware {
+  async handle(req, res, next) {
+    return next();
+  }
+}
+`;
+
+  await writeFile(target, body, 'utf8');
+  console.log(`[nova] middleware created: ${relativePath(target)}`);
+}
+
+async function createMigration(name) {
+  if (!name) {
+    throw new Error('migration name is required');
+  }
+
+  const stamp = timestamp();
+  const fileName = `${stamp}_${sanitizeFileName(name)}.js`;
+  const target = resolve(process.cwd(), 'app', 'migrations', fileName);
+
+  await ensureDir(dirname(target));
+  await ensureNotExists(target);
+
+  const body = `export async function up(db) {
+  // TODO: add migration
+}
+
+export async function down(db) {
+  // TODO: rollback migration
+}
+`;
+
+  await writeFile(target, body, 'utf8');
+  console.log(`[nova] migration created: ${relativePath(target)}`);
+}
+
+async function runDrizzle(command) {
+  const args = ['drizzle-kit', command];
+  await runCommand('npx', args);
+}
+
+async function runDev() {
+  const config = await loadNovaConfig();
+  const { runDev: runViteDev } = await loadFrameworkModule('dev');
+
+  const server = spawn('node', ['server.js'], {
+    stdio: 'inherit',
+    shell: process.platform === 'win32',
+  });
+
+  process.on('SIGINT', () => server.kill('SIGINT'));
+  process.on('SIGTERM', () => server.kill('SIGTERM'));
+
+  await runViteDev(config);
+}
+
+async function runBuild() {
+  const config = await loadNovaConfig();
+  const { runBuild: runViteBuild } = await loadFrameworkModule('dev');
+  await runViteBuild(config);
+}
+
+async function runCommand(command, args, options = {}) {
+  await new Promise((resolvePromise, reject) => {
+    const child = spawn(command, args, {
+      stdio: 'inherit',
+      shell: process.platform === 'win32',
+      cwd: options.cwd || process.cwd(),
+    });
+
+    child.on('exit', (code) => {
+      if (code === 0) resolvePromise();
+      else reject(new Error(`command failed: ${command} ${args.join(' ')}`));
+    });
+  });
+}
+
+async function tryFetchTemplate(repo) {
+  const tempRoot = await mkdtemp(join(tmpdir(), 'nova-template-'));
+  const cleanup = async () => {
+    await rm(tempRoot, { recursive: true, force: true });
+  };
+
+  try {
+    await runCommand('git', ['clone', '--depth', '1', repo, tempRoot]);
+    const basePath = join(tempRoot, 'templates', 'base');
+    if (await pathExists(basePath)) {
+      return { path: basePath, cleanup };
+    }
+  } catch (error) {
+    await cleanup();
+    return null;
+  }
+
+  await cleanup();
+  return null;
+}
+
+async function copyTemplate(src, dest, replacements) {
+  const entries = await readdir(src, { withFileTypes: true });
+  await ensureDir(dest);
+
+  for (const entry of entries) {
+    const srcPath = join(src, entry.name);
+    const destPath = join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      await copyTemplate(srcPath, destPath, replacements);
+      continue;
+    }
+
+    const contents = await readFile(srcPath, 'utf8');
+    const replaced = applyReplacements(contents, replacements);
+    await writeFile(destPath, replaced, 'utf8');
+  }
+}
+
+function applyReplacements(contents, replacements) {
+  let result = contents;
+  for (const [key, value] of Object.entries(replacements)) {
+    result = result.split(key).join(value);
+  }
+  return result;
+}
+
+async function ensureDir(path) {
+  await mkdir(path, { recursive: true });
+}
+
+async function ensureNotExists(path) {
+  if (await pathExists(path)) {
+    throw new Error(`${relativePath(path)} already exists`);
+  }
+}
+
+async function pathExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch (error) {
+    if (error.code === 'ENOENT') return false;
+    throw error;
+  }
+}
+
+function normalizeSuffix(name, suffix) {
+  if (name.endsWith(suffix)) return name;
+  const base = name.replace(/\.[^.]+$/, '');
+  if (base.endsWith(suffix.replace('.js', ''))) return `${base}.js`;
+  return base + suffix;
+}
+
+function toClassName(input) {
+  return input
+    .split(/[^a-zA-Z0-9]/)
+    .filter(Boolean)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join('');
+}
+
+function sanitizeFileName(input) {
+  return input
+    .trim()
+    .toLowerCase()
+    .replace(/\s+/g, '_')
+    .replace(/[^a-z0-9_]+/g, '');
+}
+
+function timestamp() {
+  const now = new Date();
+  const pad = (value) => String(value).padStart(2, '0');
+  return [
+    now.getFullYear(),
+    pad(now.getMonth() + 1),
+    pad(now.getDate()),
+    pad(now.getHours()),
+    pad(now.getMinutes()),
+    pad(now.getSeconds()),
+  ].join('_');
+}
+
+function relativePath(path) {
+  return path.replace(process.cwd() + '/', '');
+}
+
+async function loadNovaConfig() {
+  const configPath = resolve(process.cwd(), 'nova.config.js');
+  const module = await import(pathToFileURL(configPath));
+  return module.default || module;
+}
+
+async function loadFrameworkModule(entry) {
+  const require = createRequire(import.meta.url);
+  const resolved = require.resolve(`@untrustnova/nova-framework/${entry}`, {
+    paths: [process.cwd()],
+  });
+  return import(pathToFileURL(resolved));
+}

package/templates/base/.env.example

@@ -0,0 +1,30 @@
+NOVA_APP_NAME=Nova App
+NOVA_APP_URL=http://localhost:3000
+NOVA_ENV=development
+NOVA_DEBUG=true
+
+NOVA_HOST=0.0.0.0
+NOVA_PORT=3000
+NOVA_KERNEL_ADAPTER=node
+
+NOVA_DB_CONNECTION=sqlite
+NOVA_DATABASE_URL=file:./storage/db.sqlite
+# postgresql://user:password@localhost:5432/nova_db
+# mysql://user:password@localhost:3306/nova_db
+# mongodb://user:password@localhost:27017/nova_db
+# supabase://project-ref.supabase.co?key=service-role-key
+
+NOVA_STORAGE_DRIVER=local
+# NOVA_AWS_BUCKET=my-bucket
+# NOVA_AWS_REGION=us-east-1
+# NOVA_MINIO_ENDPOINT=minio.example.com
+# NOVA_MINIO_ACCESS_KEY=minioadmin
+# NOVA_MINIO_SECRET_KEY=minioadmin
+
+NOVA_CACHE_DRIVER=memory
+# NOVA_REDIS_URL=redis://localhost:6379
+
+NOVA_LOG_LEVEL=info
+
+VITE_API_URL=http://localhost:3000/api
+VITE_APP_TITLE=Nova.js App

package/templates/base/.env.local

@@ -0,0 +1,19 @@
+NOVA_APP_NAME=Nova
+NOVA_APP_URL=http://localhost:3000
+NOVA_ENV=development
+NOVA_DEBUG=true
+
+NOVA_HOST=0.0.0.0
+NOVA_PORT=3000
+NOVA_KERNEL_ADAPTER=node
+
+NOVA_DB_CONNECTION=sqlite
+NOVA_DATABASE_URL=file:./storage/db.sqlite
+# postgresql://user:password@localhost:5432/nova_db
+# mysql://user:password@localhost:3306/nova_db
+# mongodb://user:password@localhost:27017/nova_db
+# supabase://project-ref.supabase.co?key=service-role-key
+
+NOVA_CACHE_DRIVER=memory
+NOVA_STORAGE_DRIVER=local
+NOVA_LOG_LEVEL=debug

package/templates/base/.eslintrc.cjs

@@ -0,0 +1,21 @@
+module.exports = {
+  env: {
+    browser: true,
+    es2023: true,
+    node: true,
+  },
+  parserOptions: {
+    ecmaVersion: 'latest',
+    sourceType: 'module',
+  },
+  plugins: ['react'],
+  extends: ['eslint:recommended', 'plugin:react/recommended', 'prettier'],
+  settings: {
+    react: {
+      version: 'detect',
+    },
+  },
+  rules: {
+    'react/react-in-jsx-scope': 'off',
+  },
+};

package/templates/base/.prettierrc

@@ -0,0 +1,6 @@
+{
+  "singleQuote": true,
+  "semi": true,
+  "trailingComma": "all",
+  "printWidth": 100
+}

package/templates/base/app/controllers/home.controller.js

@@ -0,0 +1,7 @@
+import { Controller } from '@untrustnova/nova-framework/controller';
+
+export default class HomeController extends Controller {
+  async index({ response }) {
+    response.json({ message: 'Welcome to Nova.js', status: 'ok' });
+  }
+}

package/templates/base/app/routes/pages/home.index.js

@@ -0,0 +1,3 @@
+export default async ({ response }) => {
+  response.json({ page: 'home' });
+};

package/templates/base/app/routes/web.js

@@ -0,0 +1,12 @@
+import { route } from '@untrustnova/nova-framework/routing';
+
+export default () => {
+  const routes = route();
+
+  routes.get('/', 'HomeController@index');
+  routes.get('/status', async ({ response }) => {
+    response.json({ status: 'ready' });
+  });
+
+  return routes.toArray();
+};

package/templates/base/jsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "@app/*": ["app/*"],
+      "@web/*": ["web/*"],
+      "@components/*": ["web/components/*"],
+      "@lib/*": ["web/lib/*"]
+    }
+  },
+  "include": [
+    "app",
+    "web",
+    "server.js",
+    "nova.config.js"
+  ]
+}

package/templates/base/nova.config.js

@@ -0,0 +1,88 @@
+import { defineConfig, react, tailwindcss } from '@untrustnova/nova-framework/config';
+
+export default defineConfig({
+  app: {
+    name: process.env.NOVA_APP_NAME || '__APP_NAME__',
+    url: process.env.NOVA_APP_URL || 'http://localhost:3000',
+    env: process.env.NOVA_ENV || 'development',
+    debug: process.env.NOVA_DEBUG === 'true',
+  },
+  server: {
+    host: process.env.NOVA_HOST || '0.0.0.0',
+    port: Number(process.env.NOVA_PORT || 3000),
+  },
+  security: {
+    bodyLimit: 1024 * 1024,
+  },
+  kernel: {
+    adapter: process.env.NOVA_KERNEL_ADAPTER || 'node',
+  },
+  database: {
+    default: process.env.NOVA_DB_CONNECTION || 'sqlite',
+    connections: {
+      postgres: {
+        driver: 'pg',
+        url: process.env.NOVA_DATABASE_URL,
+      },
+      mysql: {
+        driver: 'mysql2',
+        url: process.env.NOVA_DATABASE_URL,
+      },
+      sqlite: {
+        driver: 'better-sqlite3',
+        url: process.env.NOVA_DATABASE_URL || 'file:./storage/db.sqlite',
+      },
+      mongodb: {
+        driver: 'mongodb',
+        url: process.env.NOVA_DATABASE_URL,
+      },
+      supabase: {
+        driver: 'supabase',
+        url: process.env.NOVA_DATABASE_URL,
+      },
+    },
+  },
+  modules: {
+    storage: {
+      driver: process.env.NOVA_STORAGE_DRIVER || 'local',
+      disks: {
+        local: { root: './storage/app' },
+        s3: {
+          bucket: process.env.NOVA_AWS_BUCKET,
+          region: process.env.NOVA_AWS_REGION,
+        },
+        minio: {
+          endPoint: process.env.NOVA_MINIO_ENDPOINT,
+          accessKey: process.env.NOVA_MINIO_ACCESS_KEY,
+          secretKey: process.env.NOVA_MINIO_SECRET_KEY,
+        },
+      },
+    },
+    cache: {
+      driver: process.env.NOVA_CACHE_DRIVER || 'memory',
+      stores: {
+        memory: { max: 500 },
+        redis: { url: process.env.NOVA_REDIS_URL },
+      },
+    },
+    logs: {
+      driver: 'paperlog',
+      level: process.env.NOVA_LOG_LEVEL || 'info',
+    },
+  },
+  frontend: {
+    entry: './web/main.jsx',
+    globals: './web/styles/globals.css',
+  },
+  plugins: [
+    react(),
+    tailwindcss({
+      content: ['./web/**/*.{js,jsx}'],
+    }),
+  ],
+  alias: {
+    '@': './web',
+    '@components': './web/components',
+    '@lib': './web/lib',
+  },
+});

package/templates/base/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "__APP_NAME__",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "nova dev",
+    "build": "nova build",
+    "start": "node server.js",
+    "lint": "eslint ."
+  },
+  "dependencies": {
+    "dotenv": "^16.4.5",
+    "drizzle-orm": "^0.40.0",
+    "@untrustnova/nova-framework": "^0.1.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-react": "^4.3.4",
+    "eslint": "^9.18.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-react": "^7.37.3",
+    "vite": "^6.0.0"
+  }
+}

package/templates/base/server.js

@@ -0,0 +1,12 @@
+import 'dotenv/config';
+import config from './nova.config.js';
+import { NovaKernel } from '@untrustnova/nova-framework/kernel';
+import { storageModule, cacheModule, logsModule } from '@untrustnova/nova-framework/modules';
+
+const app = new NovaKernel(config);
+
+app.registerModule('storage', storageModule);
+app.registerModule('cache', cacheModule);
+app.registerModule('logs', logsModule);
+
+app.start();

package/templates/base/web/App.jsx

@@ -0,0 +1,9 @@
+import Hero from './components/Hero.jsx';
+
+export default function App() {
+  return (
+    <div className="app-shell">
+      <Hero />
+    </div>
+  );
+}

package/templates/base/web/components/Hero.jsx

@@ -0,0 +1,18 @@
+export default function Hero() {
+  return (
+    <main className="hero">
+      <div className="badge">Nova</div>
+      <h1>DX bersih untuk frontend React & backend modular.</h1>
+      <p>
+        Mulai dari <code>nova dev</code>, lanjutkan dengan modul Storage, Cache,
+        Logs, dan DB yang bisa diganti driver-nya.
+      </p>
+      <div className="cta">
+        <button type="button">Lihat Dokumentasi</button>
+        <button type="button" className="ghost">
+          Buat Project
+        </button>
+      </div>
+    </main>
+  );
+}

package/templates/base/web/index.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Nova.js</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/main.jsx"></script>
+  </body>
+</html>

package/templates/base/web/lib/api.js

@@ -0,0 +1,8 @@
+const baseUrl = import.meta.env.VITE_API_URL || 'http://localhost:3000/api';
+
+export const api = {
+  async get(path) {
+    const response = await fetch(`${baseUrl}${path}`);
+    return response.json();
+  },
+};

package/templates/base/web/main.jsx

@@ -0,0 +1,6 @@
+import { createRoot } from 'react-dom/client';
+import App from './App.jsx';
+import './styles/globals.css';
+
+const root = createRoot(document.getElementById('root'));
+root.render(<App />);

package/templates/base/web/styles/globals.css

@@ -0,0 +1,77 @@
+:root {
+  font-family: 'Inter', system-ui, sans-serif;
+  color: #e6edf3;
+  background-color: #0b1220;
+}
+
+* {
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+}
+
+body {
+  min-height: 100vh;
+  background: radial-gradient(circle at top, #1c2b4f 0%, #0b1220 60%);
+}
+
+.app-shell {
+  display: flex;
+  min-height: 100vh;
+  align-items: center;
+  justify-content: center;
+  padding: 4rem 1.5rem;
+}
+
+.hero {
+  max-width: 720px;
+  display: grid;
+  gap: 1.5rem;
+  background: rgba(15, 23, 42, 0.65);
+  border: 1px solid rgba(148, 163, 184, 0.2);
+  border-radius: 24px;
+  padding: 3rem;
+  backdrop-filter: blur(20px);
+}
+
+.hero h1 {
+  font-size: clamp(2rem, 3vw, 2.75rem);
+  line-height: 1.2;
+}
+
+.hero p {
+  font-size: 1.05rem;
+  color: #cbd5f5;
+}
+
+.badge {
+  width: fit-content;
+  padding: 0.4rem 0.9rem;
+  border-radius: 999px;
+  background: rgba(59, 130, 246, 0.2);
+  border: 1px solid rgba(59, 130, 246, 0.45);
+  color: #93c5fd;
+  font-weight: 600;
+}
+
+.cta {
+  display: flex;
+  gap: 1rem;
+  flex-wrap: wrap;
+}
+
+.cta button {
+  border: none;
+  border-radius: 12px;
+  padding: 0.8rem 1.5rem;
+  background: #3b82f6;
+  color: white;
+  font-weight: 600;
+  cursor: pointer;
+}
+
+.cta button.ghost {
+  background: transparent;
+  border: 1px solid rgba(148, 163, 184, 0.5);
+  color: #cbd5f5;
+}