@nutin/cli 1.1.0 → 1.2.1

package/templates/base/tools/builder/core/copy-static.js.hbs

@@ -1,16 +1,9 @@
 import fs from 'fs/promises';
 import path from 'path';
 import { exit } from 'process';
-
+import { getFilesRecursive, print, isVerbose, isProd } from '../../utils/index.js';
 import { BINARY_EXTENSIONS } from '../variables/binary-extensions.js';
-import { getFilesRecursive, print } from '../../utils/index.js';
-
-const SOURCE_FOLDER = 'src';
-{{#if template}}
-const DEST_FOLDER = `dist-build/${SOURCE_FOLDER}`;
-{{else}}
-const DEST_FOLDER = `dist/${SOURCE_FOLDER}`;
-{{/if}}
+import { PATHS } from './paths.js';
 
 async function ensureDir(dir) {
   await fs.mkdir(dir, { recursive: true });
@@ -22,33 +15,59 @@ async function copyFile(src, dest) {
 }
 
 async function copyFavicon() {
-  const srcPath = path.join('public', 'favicon.ico');
-  const destPath = path.join( DEST_FOLDER, 'favicon.ico');
+  const srcPath = path.resolve(path.join('public', 'favicon.ico'));
+  const destPath = path.join(PATHS.tempSource, 'favicon.ico');
 
   try {
     await copyFile(srcPath, destPath);
-    print.info('✅ Copied: favicon.ico');
+    if (isVerbose) print.info('Copied: favicon.ico');
   } catch {
-    print.boldError('⚠️  No favicon found at public/favicon.ico\x1b[0m');
+    print.boldError('⚠️  No favicon found at public/favicon.ico');
   }
 }
 
+{{#if i18n}}
+async function copyConfig() {
+  const srcPath = path.resolve(path.join('config'));
+  const temp = isProd ? PATHS.temp : PATHS.tempSource;
+  const destPath = path.join(temp, 'config');
+  try {
+    await copyJsonFiles(srcPath, destPath);
+{{#if testinNutin}}
+    // for tests to run
+    if (!isProd) await copyJsonFiles(srcPath, path.join(PATHS.temp, 'config'))
+{{/if}}
+    if (isVerbose) print.info('Config files copied');
+  } catch {
+    print.boldError('Issue when copying config files.');
+    exit(1);
+  }
+}
+
+{{/if}}
 async function copyStatic() {
   const extensions = [...BINARY_EXTENSIONS, 'html'];
+  if (isProd) extensions.push('.ts');
+
+  if (isVerbose) print.info(`File types that will be copied: ${Array.from(extensions)}`);
+
+  await ensureDir(PATHS.tempSource);
 
-  await ensureDir(path.join(DEST_FOLDER));
   await copyFavicon();
+  {{#if i18n}}
+  await copyConfig();
+  {{/if}}
 
   for (const extension of extensions) {
-    const files = await getFilesRecursive(SOURCE_FOLDER, extension);
+    const files = await getFilesRecursive(PATHS.source, extension);
 
     for (const file of files) {
-      const relative = path.relative(SOURCE_FOLDER, file);
-      const dest = path.join(DEST_FOLDER, relative);
+      const relative = path.relative(PATHS.source, file);
+      const dest = path.join(PATHS.tempSource, relative);
 
       try {
         await copyFile(file, dest);
-        print.info(`✅ Copied: ${file} → ${dest}`);
+        if (isVerbose) print.info(`✅ Copied: ${file} → ${dest}`);
       } catch (err) {
         print.error(`❌ Failed to copy: ${file}. ${err.message}`);
         exit(1);
@@ -56,7 +75,9 @@ async function copyStatic() {
     }
   }
 
-  await copyJsonFiles(SOURCE_FOLDER, DEST_FOLDER)
+  if (isProd) await copyJsonFiles(PATHS.source, PATHS.tempSource);
+
+  if (isVerbose) print.boldInfo(`Copy complete.\n`);
 }
 
 async function copyJsonFiles(sourceDir, destDir) {
@@ -72,7 +93,7 @@ async function copyJsonFiles(sourceDir, destDir) {
     } else if (item.isFile() && path.extname(item.name) === '.json') {
       await fs.mkdir(path.dirname(destPath), { recursive: true });
       await fs.copyFile(sourcePath, destPath);
-      console.log(`Copied JSON: ${sourcePath} -> ${destPath}`);
+      if (isVerbose) print.info(`Copied JSON: ${sourcePath} -> ${destPath}`);
     }
   }
 }

package/templates/base/tools/builder/core/esbuild.js.hbs

@@ -0,0 +1,26 @@
+import esbuild from 'esbuild';
+import path from 'path';
+import { exit } from 'process';
+import { print, isVerbose } from '../../utils/index.js';
+import { PATHS } from './paths.js';
+import builderConfig from '../../../builder.config.js';
+
+const ENTRY_FILE = path.join(PATHS.tempApp, 'main.ts');
+const OUT_FILE = path.join(PATHS.tempSource, 'bundle.js');
+
+async function build() {
+  await esbuild.build({
+    ...builderConfig.esbuild,
+    entryPoints: [ENTRY_FILE],
+    outfile: OUT_FILE,
+    keepNames: true, // View names are used to update meta.title
+  });
+
+  if (isVerbose) print.boldInfo(`ESBuild complete.\n`);
+}
+
+
+build().catch((err) => {
+  print.boldError(`ESBuild failed: ${err.message}`);
+  exit(1);
+});

package/templates/base/tools/builder/core/finalize-build.js.hbs

@@ -0,0 +1,24 @@
+import { print, isProd, isVerbose } from "../../utils/index.js";
+import fs from 'fs';
+import path from 'path';
+import { PATHS } from "./paths.js";
+
+function removeFoldersAfterBundle() {
+  const foldersToRemove = ['core', 'libs', 'app'];
+  const pathToFolder = (folder) => path.join(PATHS.tempSource, folder);
+
+  foldersToRemove.forEach(folder => fs.rmSync(pathToFolder(folder), { recursive : true }));
+}
+
+function replaceDir(src, dest) {
+  fs.rmSync(dest, { recursive: true, force: true });
+  fs.renameSync(src, dest);
+}
+
+function finalizeBuild() {
+  if (isProd) removeFoldersAfterBundle();
+  replaceDir(PATHS.temp, PATHS.build);
+  if (isVerbose) print.boldInfo('Build finalized.\n');
+}
+
+finalizeBuild();

package/templates/base/tools/builder/core/minify-html.js.hbs

@@ -0,0 +1,60 @@
+import { minify } from 'html-minifier-terser';
+{{#unless template}}
+import fs from 'fs';
+import { exit } from 'process';
+import { getFilesRecursive, print, isProd, isVerbose } from '../../utils/index.js';
+import { PATHS } from './paths.js';
+{{/unless}}
+
+{{#if template}}export {{/if}}async function minifyHTML(html) {
+  return minify(html, {
+    collapseWhitespace: true,
+    removeComments: true,
+    removeRedundantAttributes: true,
+    removeScriptTypeAttributes: true,
+    removeStyleLinkTypeAttributes: true,
+    useShortDoctype: true,
+    keepClosingSlash: true,
+    minifyCSS: true,
+    minifyJS: true,
+  });
+}
+
+{{#unless template}}
+const TEMPLATE_REGEX =
+  /const\s+(template|templateFn)\s*=?\s*(?:\(.*?\)\s*=>\s*)?`([\s\S]*?)`/gm;
+
+async function minifyInlineHTML() {
+  const extension = isProd ? '.ts' : '.js';
+  const jsFiles = getFilesRecursive(PATHS.tempApp, extension);
+
+  for (const file of jsFiles) {
+    let code = fs.readFileSync(file, 'utf8');
+    let hasChanges = false;
+
+    const matches = [...code.matchAll(TEMPLATE_REGEX)];
+
+    if (matches.length) {
+      for (const match of matches) {
+        const [full, , html] = match;
+        const minified = await minifyHTML(html);
+        const minifiedBlock = full.replace(html, minified);
+        code = code.replace(full, minifiedBlock);
+        hasChanges = true;
+      }
+    }
+
+    if (hasChanges) {
+      fs.writeFileSync(file, code, 'utf8');
+      if (isVerbose) print.info(`Minified inline HTML in: ${file}`);
+    }
+  }
+  if (isVerbose) print.boldInfo('Inline templates minified.\n');
+}
+
+minifyInlineHTML().catch((err) => {
+  print.boldError(`Unexpected error: ${err.message}`);
+  exit(1);
+});
+
+{{/unless}}

package/templates/base/tools/builder/core/paths.js.hbs

@@ -0,0 +1,19 @@
+import path from 'path';
+
+const SRC_FOLDERNAME = 'src';
+const APP_FOLDERNAME = 'app';
+const TMP_FOLDERNAME = 'dist-build';
+const BLD_FOLDERNAME = 'dist';
+
+const BASE_PATHS = {
+  source: path.resolve(SRC_FOLDERNAME),
+  temp: path.resolve(TMP_FOLDERNAME),
+  build: path.resolve(BLD_FOLDERNAME)
+};
+
+export const PATHS = {
+  ...BASE_PATHS,
+  sourceApp: path.join(BASE_PATHS.source, APP_FOLDERNAME),
+  tempSource: path.join(BASE_PATHS.temp, SRC_FOLDERNAME),
+  tempApp: path.join(BASE_PATHS.temp, SRC_FOLDERNAME, APP_FOLDERNAME),
+};

package/templates/base/tools/builder/core/sass.js.hbs

@@ -0,0 +1,22 @@
+import * as sass from 'sass';
+import * as fs from 'fs';
+import path from 'path';
+import { isVerbose, print } from '../../utils/index.js';
+import { PATHS } from './paths.js';
+import builderConfig from '../../../builder.config.js';
+
+const stylesInput = path.join(PATHS.source, 'styles');
+const stylesOutput = path.join(PATHS.tempSource, 'main.css');
+
+const scssPath = (origin) => path.join(stylesInput, origin);
+const scssOrigins = builderConfig.sass.paths;
+
+const pathsToLoad = scssOrigins.map(origin => scssPath(origin));
+
+sass.compileAsync(path.join(stylesInput, 'main.scss'), {
+  loadPaths: [ ...pathsToLoad ],
+  style: 'compressed'
+}).then(result => {
+  fs.writeFileSync(stylesOutput, result.css);
+  if (isVerbose) print.boldInfo('Global styles compiled.\n');
+});

package/templates/base/tools/builder/core/tsc.js.hbs

@@ -0,0 +1,12 @@
+import { runCommand, print, isVerbose } from "../../utils/index.js";
+import { exit } from 'process';
+
+async function compileTS() {
+	await runCommand('tsc', ['--project', 'tsconfig.json']);
+  if (isVerbose) print.boldInfo('TypeScript compiled.\n');
+}
+
+compileTS().catch((err) => {
+  print.boldError(`Unexpected error: ${err.message}`);
+  exit(1);
+});

package/templates/base/tools/builder/core/validate-html.js.hbs

@@ -1,18 +1,36 @@
-import { readFile } from 'fs/promises';
+import { readFile, writeFile } from 'fs/promises';
 import { exit } from 'process';
-import { print } from '../../utils/index.js';
+import { print, isProd, isVerbose } from '../../utils/index.js';
+import { PATHS } from './paths.js';
+import path from 'path';
 
 function errorExit(message) {
   print.boldError(`[ERROR] ${message}`);
   exit(1);
 }
 
+async function addEntrypoint(htmlContent, filePath) {
+  if (isVerbose) print.info('Adding script in HTML...');
+
+  const scriptSrc = isProd ? "bundle.js" : "app/main.js";
+  const scriptTag = `<script type="module" src="/${scriptSrc}"></script>`;
+
+  let modifiedHtml;
+  if (/<\/body>/i.test(htmlContent)) {
+    modifiedHtml = htmlContent.replace(/<\/body>/i, `${scriptTag}</body>`);
+  } else {
+    modifiedHtml = htmlContent + scriptTag;
+  }
+
+  const minified = modifiedHtml.replace(/>\s+</g, '><');
+
+  writeFile(filePath, minified, "utf8");
+
+  return modifiedHtml;
+}
+
 async function validateHtml() {
-  {{#if template}}
-  const filePath = 'dist-build/src/index.html';
-  {{else}}
-  const filePath = 'dist/src/index.html';
-  {{/if}}
+  const filePath = path.join(PATHS.tempSource, 'index.html');
 
   let htmlContent;
   try {
@@ -25,15 +43,17 @@ async function validateHtml() {
     errorExit('Missing #app container in HTML');
   }
 
-  if (!/<script[^>]*type=["']module["']/.test(htmlContent)) {
-    errorExit('No module scripts found in HTML');
-  }
-
   if (!/<link[^>]*rel=["']stylesheet["']/.test(htmlContent)) {
     errorExit('No stylesheet found in HTML');
   }
 
-  print.info('HTML validation passed');
+  htmlContent = await addEntrypoint(htmlContent, filePath).catch(err => errorExit(err.message));
+
+  if (!/<script[^>]*type=["']module["']/.test(htmlContent)) {
+    errorExit('No module scripts found in HTML');
+  }
+
+  if (isVerbose) print.boldInfo('HTML validation passed\n');
 }
 
 validateHtml();

package/templates/base/tools/deployment/Dockerfile.hbs

@@ -0,0 +1,22 @@
+ARG NODE_VERSION=22.3.0
+ARG NGINX_VERSION=1.27-alpine
+
+FROM node:${NODE_VERSION} AS builder
+WORKDIR /usr/src/app
+COPY . .
+RUN {{ciCommand}} && \
+    {{packageManager}} run build:prod
+
+FROM nginx:${NGINX_VERSION}
+
+RUN rm /etc/nginx/conf.d/default.conf
+COPY --from=builder /usr/src/app/tools/deployment/nginx.conf /etc/nginx/conf.d/default.conf
+COPY --from=builder /usr/src/app/tools/deployment/gzip.conf /etc/nginx/conf.d/gzip.conf
+COPY --from=builder /usr/src/app/dist/src /usr/share/nginx/html
+
+EXPOSE 9090
+
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:9090/health || exit 1
+
+CMD ["nginx", "-g", "daemon off;"]

package/templates/base/tools/deployment/gzip.conf.hbs

@@ -0,0 +1,19 @@
+gzip on;
+gzip_vary on;
+gzip_proxied any;
+gzip_comp_level 6;
+gzip_min_length 1000;
+
+gzip_types
+    text/plain
+    text/css
+    text/xml
+    text/javascript
+    application/json
+    application/javascript
+    application/xml+rss
+    application/rss+xml
+    font/truetype
+    font/opentype
+    application/vnd.ms-fontobject
+    image/svg+xml;

package/templates/base/tools/deployment/nginx.conf.hbs

@@ -0,0 +1,78 @@
+server {
+    # ---------------------------
+    # LISTEN PORTS
+    # ---------------------------
+    listen 9090;
+    server_name _;
+
+    # ---------------------------
+    # ROOT + ROUTING
+    # ---------------------------
+    root /usr/share/nginx/html;
+    index index.html;
+
+    # SPA routing: serve index.html for unknown paths
+    location / {
+        try_files $uri $uri/ /index.html;
+    }
+
+    # ---------------------------
+    # SECURITY HEADERS
+    # ---------------------------
+
+    # Prevent clickjacking
+    add_header X-Frame-Options "SAMEORIGIN" always;
+
+    # Block MIME type sniffing
+    add_header X-Content-Type-Options "nosniff" always;
+
+    # Legacy XSS filter
+    add_header X-XSS-Protection "1; mode=block" always;
+
+    # Limit referrer leakage
+    add_header Referrer-Policy "strict-origin-when-cross-origin" always;
+
+    # Restrict powerful browser APIs
+    add_header Permissions-Policy "geolocation=(), microphone=(), camera=()" always;
+
+    # Content Security Policy
+    add_header Content-Security-Policy "default-src 'self'; \
+        script-src 'self'; \
+        style-src 'self' 'unsafe-inline'; \
+        img-src 'self' data: https:; \
+        font-src 'self'; \
+        connect-src 'self'; \
+        object-src 'none'; \
+        base-uri 'self'; \
+        form-action 'self'; \
+        frame-ancestors 'none';" always;
+
+    # Hide nginx version
+    server_tokens off;
+
+    # ---------------------------
+    # STATIC ASSETS CACHING
+    # ---------------------------
+
+    # Immutable cache for static assets
+    location ~* \.(js|css|png|jpg|jpeg|gif|avif|ico|svg|woff|woff2|ttf|eot)$ {
+        expires 1y;
+        add_header Cache-Control "public, immutable";
+    }
+
+    # No caching for HTML files (SPA shell)
+    location ~* \.html$ {
+        expires -1;
+        add_header Cache-Control "no-cache, no-store, must-revalidate";
+        add_header Pragma "no-cache";
+    }
+
+    # ---------------------------
+    # HEALTH ENDPOINT
+    # ---------------------------
+    location /health {
+        access_log off;
+        add_header Content-Type text/plain;
+        return 200 "healthy\n";
+    }
+}

package/templates/base/tools/dev/dev-serve.js.hbs

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+
+import { print, runCommand } from '../utils/index.js';
+
+async function startDev() {
+  try {
+    console.clear();
+    print.boldHead('🚀 Starting Dev Environment...');
+
+    await runCommand('{{packageManager}}', ['run', 'build']);
+
+    const { serve, watcher } = await Promise.all([
+      runCommand('npm', ['run', 'serve:only']),
+      runCommand('node', ['tools/dev/watcher.js'])
+    ]);
+
+    serve.on('close', (code) => {
+      print.error(`live-server exited with code ${code}`);
+      process.exit(code);
+    });
+    watcher.on('close', (code) => {
+      print.error(`watcher exited with code ${code}`);
+    });
+  } catch (err) {
+    print.boldError(`Dev startup failed: ${err.message}`);
+  }
+}
+
+startDev().catch((err) => {
+  print.boldError(`Unexpected error: ${err.message}`);
+  exit(1);
+});

package/templates/base/tools/dev/serve.js.hbs

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+import liveServer from 'live-server';
+
+const params = {
+  port: 9090,
+  root: 'dist/src',
+  open: false, // set to true to open a new window in browser
+  logLevel: 0, // 0 = errors only, 1 = some info, 2 = verbose
+  entryFile: 'index.html',
+  wait: 100, // debounce reloads
+  middleware: [
+    function(req, res, next) {
+      if (req.url.includes('.') && !req.url.endsWith('/')) {
+        return next();
+      }
+      req.url = '/index.html';
+      next();
+    }
+  ]
+};
+
+liveServer.start(params);

package/templates/base/tools/{watcher.js.hbs → dev/watcher.js.hbs}

@@ -1,7 +1,7 @@
 import chokidar from 'chokidar';
 import { exec } from 'child_process';
 import path from 'path';
-import { print } from './utils/index.js'
+import { print } from '../utils/index.js'
 
 const watcher = chokidar.watch(['src'], {
   ignored: /(^|[/\\])\../,
@@ -9,7 +9,6 @@ const watcher = chokidar.watch(['src'], {
 });
 
 let isBuilding = false;
-
 let buildTimeout = null;
 
 watcher.on('change', (filePath) => {
@@ -25,20 +24,21 @@ watcher.on('change', (filePath) => {
     print.boldInfo(`\n🔄 File changed: ${path.relative(process.cwd(), filePath)}\n`);
     print.info('\nRebuilding...');
 
-    const command = {{#if template}}'npm run build'{{else}}filePath.includes('.scss') ? 'npm run build-static' : 'npm run build'{{/if}};
+    const command = '{{packageManager}} run build';
     
     exec(command, (err, stdout, stderr) => {
       if (stdout) process.stdout.write(stdout);
       if (stderr) process.stderr.write(stderr);
-      
-      print.boldSuccess('\n✅ Build completed!');
-      print.boldHead('\nWaiting for changes...\n');
-      
+      if (err) {
+        print.error(`\n❌ Build failed: ${err.message}`);
+      } else {
+        print.boldHead('Watching for changes...');
+      }
       isBuilding = false;
     });
   }, 100);
 });
 
 watcher.on('ready', () => {
-  print.boldHead('\n👀 Watching for changes...\n');
+  print.boldHead('\nWatching for changes...\n');
 });

package/templates/base/tools/generator/generator.js.hbs

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 
-import { allFormats, getLastWord, print } from "../utils/index.js";
-import { generateFile, appendToIndex{{#if i18n}}, generateJson{{/if}} } from "./handle-file.js";
+import path from "path";
+import { allFormats, getLastWord, print{{#if stylinNutin}}, promptBoolean{{/if}} } from "../utils/index.js";
+import { generateFile, appendToIndex{{#if i18n}}, generateJson{{/if}}{{#if stylinNutin}}, generateStylesheet{{/if}} } from "./handle-file.js";
 import { serviceTemplate, componentTemplate, viewTemplate{{#if template}}, htmlTemplate{{/if}} } from "./templates/index.js";
 
 // Constants and Setup
@@ -14,7 +15,7 @@ if (!rawType || !rawFullPath) {
 const type = allFormats(rawType);
 const fullPath = allFormats(rawFullPath);
 const name = allFormats(getLastWord(fullPath.kebab));
-const targetPath = `src/app/${type.kebab}s/${fullPath.kebab}`;
+const targetPath = path.join('src', 'app', `${type.kebab}s/${fullPath.kebab}`);
 
 // Creator Mapping
 const creators = {
@@ -27,8 +28,12 @@ const creators = {
       handleError("Failed to generate service", err);
     }
   },
-  component: (name, targetPath) => {
+  component: {{#if stylinNutin}}async {{/if}}(name, targetPath) => {
     print.section(`Creating component: ${name.capitalized}`);
+    {{#if stylinNutin}}
+    const doCreateStylesheet = await promptBoolean('Create component\'s stylesheet in styles/components ?');
+    {{/if}}
+
     try {
       generateFile({ name, targetPath, templateFn: componentTemplate, suffix: 'component' });
       {{#if template}}
@@ -37,13 +42,20 @@ const creators = {
       {{#if i18n}}
       generateJson({ targetPath, name });
       {{/if}}
+      {{#if stylinNutin}}
+      if (doCreateStylesheet) generateStylesheet({ name, suffix: 'component' });
+      {{/if}}
       appendToIndex({ name, targetPath, suffix: 'component' });
     } catch (err) {
       handleError("Failed to generate component", err);
     }
   },
-  view: (name, targetPath) => {
+  view: {{#if stylinNutin}}async {{/if}}(name, targetPath) => {
     print.section(`Creating view: ${name.capitalized}`);
+    {{#if stylinNutin}}
+    const doCreateStylesheet = await promptBoolean('Create component\'s stylesheet in styles/components ?');
+    {{/if}}
+
     try {
       generateFile({ name, targetPath, templateFn: viewTemplate, suffix: 'view' });
       {{#if template}}
@@ -52,6 +64,9 @@ const creators = {
       {{#if i18n}}
       generateJson({ targetPath, name });
       {{/if}}
+      {{#if stylinNutin}}
+      if (doCreateStylesheet) generateStylesheet({ name, suffix: 'view' });
+      {{/if}}
       appendToIndex({name, targetPath, suffix: 'view' });
     } catch (err) {
       handleError("Failed to generate view", err);
@@ -63,7 +78,7 @@ const creators = {
 const create = creators[type.kebab];
 
 if (create) {
-  create(name, targetPath);
+  {{#if stylinNutin}}await {{/if}}create(name, targetPath);
   print.boldSuccess(`\n${type.capitalized} ${name.capitalized} has been generated.\n`)
 } else {
   showUsageAndExit(`Unsupported type: '${type.kebab}'`);