Quiero ejecutar un servidor HTTP muy simple. Cada solicitud GET example.comdebe ser index.htmlatendida, pero como una página HTML normal (es decir, la misma experiencia que cuando lee páginas web normales).

Usando el siguiente código, puedo leer el contenido de index.html. ¿Cómo sirvo index.htmlcomo página web normal?

var http = require('http');
var fs = require('fs');
var index = fs.readFileSync('index.html');

http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end(index);
}).listen(9615);

Una de las sugerencias a continuación es complicada y requiere que escriba una getlínea para cada archivo de recursos (CSS, JavaScript, imágenes) que quiero usar.

¿Cómo puedo servir una sola página HTML con algunas imágenes, CSS y JavaScript?

El servidor más simple de Node.js es solo:

$ npm install http-server -g

Ahora puede ejecutar un servidor mediante los siguientes comandos:

$ cd MyApp

$ http-server

Si está utilizando NPM 5.2.0 o posterior, puede usarlo http-serversin instalarlo npx. No se recomienda su uso en producción, pero es una excelente manera de hacer que un servidor se ejecute rápidamente en localhost.

$ npx http-server

O bien, puede intentar esto, que abre su navegador web y habilita las solicitudes CORS:

$ http-server -o --cors

Para obtener más opciones, consulte la documentación de http-serverGitHub o ejecute:

$ http-server --help

Muchas otras características agradables y una implementación simple para NodeJitsu.

Tenedores de características

Por supuesto, puede recargar fácilmente las funciones con su propio tenedor. Es posible que ya lo haya hecho en uno de los más de 800 tenedores de este proyecto:

• https://github.com/nodeapps/http-server/network

Servidor ligero: una alternativa de actualización automática

Una buena alternativa a http-serveres light-server. Admite la visualización de archivos y la actualización automática y muchas otras funciones.

$ npm install -g light-server 
$ light-server

Agregar al menú contextual del directorio en el Explorador de Windows

 reg.exe add HKCR\Directory\shell\LightServer\command /ve /t REG_EXPAND_SZ /f /d "\"C:\nodejs\light-server.cmd\" \"-o\" \"-s\" \"%V\""

Servidor JSON REST simple

Si necesita crear un servidor REST simple para un proyecto prototipo, entonces json-server podría ser lo que está buscando.

Editores de actualización automática

La mayoría de los editores de páginas web y las herramientas IDE ahora incluyen un servidor web que vigilará sus archivos fuente y actualizará automáticamente su página web cuando cambien.

Yo uso Live Server con Visual Studio Code.

El editor de texto de código abierto Brackets también incluye un servidor web estático NodeJS. Simplemente abra cualquier archivo HTML entre paréntesis, presione " Vista previa en vivo " e iniciará un servidor estático y abrirá su navegador en la página. El navegador ** se actualizará automáticamente cada vez que edite y guarde el archivo HTML. Esto es especialmente útil cuando se prueban sitios web adaptativos. Abra su página HTML en múltiples navegadores / tamaños de ventana / dispositivos. Guarde su página HTML y vea instantáneamente si su material adaptativo funciona, ya que todos se actualizan automáticamente.

PhoneGap Developers

Si está codificando una aplicación móvil híbrida , puede interesarle saber que el equipo de PhoneGap incorporó este concepto de actualización automática con su nueva aplicación PhoneGap . Esta es una aplicación móvil genérica que puede cargar los archivos HTML5 desde un servidor durante el desarrollo. Este es un truco muy hábil ya que ahora puede omitir los pasos lentos de compilación / implementación en su ciclo de desarrollo para aplicaciones móviles híbridas si está cambiando archivos JS / CSS / HTML, que es lo que está haciendo la mayor parte del tiempo. También proporcionan el servidor web NodeJS estático (ejecución phonegap serve) que detecta cambios en los archivos.

PhoneGap + Sencha Touch Developers

Ahora he adaptado ampliamente el servidor estático PhoneGap y la aplicación para desarrolladores PhoneGap para los desarrolladores Sencha Touch y jQuery Mobile. Compruébalo en Sencha Touch Live . Admite --qr QR Codes y --localtunnel que envía su servidor estático desde su computadora de escritorio a una URL fuera de su firewall. Toneladas de usos. Aceleración masiva para desarrolladores móviles híbridos.

Desarrolladores de Cordova + Ionic Framework

El servidor local y las funciones de actualización automática están integradas en la ionicherramienta. Simplemente ejecute ionic servedesde la carpeta de su aplicación. Aún mejor ... ionic serve --labpara ver las vistas de actualización automática de lado a lado de iOS y Android.

Puede usar Connect y ServeStatic con Node.js para esto:

1. Instalar connect y serve-static con NPM

   $ npm install connect serve-static

2. Cree un archivo server.js con este contenido:

   var connect = require('connect');
   var serveStatic = require('serve-static');
   
   connect()
       .use(serveStatic(__dirname))
       .listen(8080, () => console.log('Server running on 8080...'));

3. Ejecutar con Node.js

   $ node server.js

Ahora puedes ir a http://localhost:8080/yourfile.html

Mira esta esencia . Lo estoy reproduciendo aquí como referencia, pero la esencia se ha actualizado regularmente.

Servidor web de archivos estáticos Node.JS. Póngalo en su ruta para iniciar servidores en cualquier directorio, toma un argumento de puerto opcional.

var http = require("http"),
    url = require("url"),
    path = require("path"),
    fs = require("fs"),
    port = process.argv[2] || 8888;

http.createServer(function(request, response) {

  var uri = url.parse(request.url).pathname
    , filename = path.join(process.cwd(), uri);

  fs.exists(filename, function(exists) {
    if(!exists) {
      response.writeHead(404, {"Content-Type": "text/plain"});
      response.write("404 Not Found\n");
      response.end();
      return;
    }

    if (fs.statSync(filename).isDirectory()) filename += '/index.html';

    fs.readFile(filename, "binary", function(err, file) {
      if(err) {        
        response.writeHead(500, {"Content-Type": "text/plain"});
        response.write(err + "\n");
        response.end();
        return;
      }

      response.writeHead(200);
      response.write(file, "binary");
      response.end();
    });
  });
}).listen(parseInt(port, 10));

console.log("Static file server running at\n  => http://localhost:" + port + "/\nCTRL + C to shutdown");

Actualizar

La esencia maneja archivos css y js. Lo he usado yo mismo. Usar lectura / escritura en modo "binario" no es un problema. Eso solo significa que el archivo no es interpretado como texto por la biblioteca de archivos y no está relacionado con el tipo de contenido devuelto en la respuesta.

El problema con su código es que siempre devuelve un tipo de contenido de "texto / sin formato". El código anterior no devuelve ningún tipo de contenido, pero si solo lo está utilizando para HTML, CSS y JS, un navegador puede inferirlos perfectamente. Ningún tipo de contenido es mejor que uno incorrecto.

Normalmente, el tipo de contenido es una configuración de su servidor web. Así que lo siento si esto no resuelve tu problema, pero funcionó para mí como un servidor de desarrollo simple y pensé que podría ayudar a otras personas. Si necesita tipos de contenido correctos en la respuesta, debe definirlos explícitamente como joeytwiddle o usar una biblioteca como Connect que tenga valores predeterminados razonables. Lo bueno de esto es que es simple y autónomo (sin dependencias).

Pero siento tu problema. Así que aquí está la solución combinada.

var http = require("http"),
    url = require("url"),
    path = require("path"),
    fs = require("fs")
    port = process.argv[2] || 8888;

http.createServer(function(request, response) {

  var uri = url.parse(request.url).pathname
    , filename = path.join(process.cwd(), uri);

  var contentTypesByExtension = {
    '.html': "text/html",
    '.css':  "text/css",
    '.js':   "text/javascript"
  };

  fs.exists(filename, function(exists) {
    if(!exists) {
      response.writeHead(404, {"Content-Type": "text/plain"});
      response.write("404 Not Found\n");
      response.end();
      return;
    }

    if (fs.statSync(filename).isDirectory()) filename += '/index.html';

    fs.readFile(filename, "binary", function(err, file) {
      if(err) {        
        response.writeHead(500, {"Content-Type": "text/plain"});
        response.write(err + "\n");
        response.end();
        return;
      }

      var headers = {};
      var contentType = contentTypesByExtension[path.extname(filename)];
      if (contentType) headers["Content-Type"] = contentType;
      response.writeHead(200, headers);
      response.write(file, "binary");
      response.end();
    });
  });
}).listen(parseInt(port, 10));

console.log("Static file server running at\n  => http://localhost:" + port + "/\nCTRL + C to shutdown");

No necesitas expreso. No necesitas conectarte. Node.js hace http NATIVELY. Todo lo que necesita hacer es devolver un archivo dependiente de la solicitud:

var http = require('http')
var url = require('url')
var fs = require('fs')

http.createServer(function (request, response) {
    var requestUrl = url.parse(request.url)    
    response.writeHead(200)
    fs.createReadStream(requestUrl.pathname).pipe(response)  // do NOT use fs's sync methods ANYWHERE on production (e.g readFileSync) 
}).listen(9615)    

Un ejemplo más completo que garantiza que las solicitudes no puedan acceder a los archivos debajo de un directorio base y que maneje los errores de manera adecuada:

var http = require('http')
var url = require('url')
var fs = require('fs')
var path = require('path')
var baseDirectory = __dirname   // or whatever base directory you want

var port = 9615

http.createServer(function (request, response) {
    try {
        var requestUrl = url.parse(request.url)

        // need to use path.normalize so people can't access directories underneath baseDirectory
        var fsPath = baseDirectory+path.normalize(requestUrl.pathname)

        var fileStream = fs.createReadStream(fsPath)
        fileStream.pipe(response)
        fileStream.on('open', function() {
             response.writeHead(200)
        })
        fileStream.on('error',function(e) {
             response.writeHead(404)     // assume the file doesn't exist
             response.end()
        })
   } catch(e) {
        response.writeHead(500)
        response.end()     // end the response so browsers don't hang
        console.log(e.stack)
   }
}).listen(port)

console.log("listening on port "+port)

Creo que la parte que te estás perdiendo en este momento es que estás enviando:

Content-Type: text/plain

Si desea que un navegador web represente el HTML, debe cambiar esto a:

Content-Type: text/html

Paso 1 (dentro del símbolo del sistema [Espero que cd A SU CARPETA]): npm install express

Paso 2: crea un archivo server.js

var fs = require("fs");
var host = "127.0.0.1";
var port = 1337;
var express = require("express");

var app = express();
app.use(express.static(__dirname + "/public")); //use static files in ROOT/public folder

app.get("/", function(request, response){ //root dir
    response.send("Hello!!");
});

app.listen(port, host);

Tenga en cuenta que también debe agregar WATCHFILE (o usar nodemon). El código anterior es solo para un servidor de conexión simple.

PASO 3: node server.js onodemon server.js

Ahora hay un método más fácil si solo desea alojar un servidor HTTP simple. npm install -g http-server

y abra nuestro directorio y escriba http-server

https://www.npmjs.org/package/http-server

La manera rápida:

var express = require('express');
var app = express();
app.use('/', express.static(__dirname + '/../public')); // ← adjust
app.listen(3000, function() { console.log('listening'); });

A tu manera:

var http = require('http');
var fs = require('fs');

http.createServer(function (req, res) {
    console.dir(req.url);

    // will get you  '/' or 'index.html' or 'css/styles.css' ...
    // • you need to isolate extension
    // • have a small mimetype lookup array/object
    // • only there and then reading the file
    // •  delivering it after setting the right content type

    res.writeHead(200, {'Content-Type': 'text/html'});

    res.end('ok');
}).listen(3001);

En lugar de tratar con una declaración de cambio, creo que es mejor buscar el tipo de contenido de un diccionario:

var contentTypesByExtension = {
    'html': "text/html",
    'js':   "text/javascript"
};

...

    var contentType = contentTypesByExtension[fileExtension] || 'text/plain';

Esta es básicamente una versión actualizada de la respuesta aceptada para conectar la versión 3:

var connect = require('connect');
var serveStatic = require('serve-static');

var app = connect();

app.use(serveStatic(__dirname, {'index': ['index.html']}));
app.listen(3000);

También agregué una opción predeterminada para que index.html se sirva como predeterminado.

No necesita usar ningún módulo NPM para ejecutar un servidor simple, hay una biblioteca muy pequeña llamada " Servidor libre NPM " para Node:

• Servidor gratuito NPM en GitHub

50 líneas de código, salidas si está solicitando un archivo o una carpeta y le da un color rojo o verde si no funciona. Menos de 1 KB de tamaño (minificado).

si tiene un nodo instalado en su PC, probablemente tenga el NPM, si no necesita cosas de NodeJS, puede usar el paquete de servicio para esto:

1 - Instala el paquete en tu PC:

npm install -g serve

2 - Sirve tu carpeta estática:

serve <path> 
d:> serve d:\StaticSite

Le mostrará en qué puerto se está sirviendo su carpeta estática, solo navegue hasta el host como:

http://localhost:3000

Encontré una biblioteca interesante en npm que podría serle útil. Se llama mime ( npm install mimeo https://github.com/broofa/node-mime ) y puede determinar el tipo mime de un archivo. Aquí hay un ejemplo de un servidor web que escribí usándolo:

var mime = require("mime"),http = require("http"),fs = require("fs");
http.createServer(function (req, resp) {
path  = unescape(__dirname + req.url)
var code = 200
 if(fs.existsSync(path)) {
    if(fs.lstatSync(path).isDirectory()) {
        if(fs.existsSync(path+"index.html")) {
        path += "index.html"
        } else {
            code = 403
            resp.writeHead(code, {"Content-Type": "text/plain"});
            resp.end(code+" "+http.STATUS_CODES[code]+" "+req.url);
        }
    }
    resp.writeHead(code, {"Content-Type": mime.lookup(path)})
    fs.readFile(path, function (e, r) {
    resp.end(r);

})
} else {
    code = 404
    resp.writeHead(code, {"Content-Type":"text/plain"});
    resp.end(code+" "+http.STATUS_CODES[code]+" "+req.url);
}
console.log("GET "+code+" "+http.STATUS_CODES[code]+" "+req.url)
}).listen(9000,"localhost");
console.log("Listening at http://localhost:9000")

Esto servirá cualquier archivo de texto o imagen regular (.html, .css, .js, .pdf, .jpg, .png, .m4a y .mp3 son las extensiones que he probado, pero en teoría debería funcionar para todo)

Notas del desarrollador

Aquí hay un ejemplo de salida que obtuve con él:

Listening at http://localhost:9000
GET 200 OK /cloud
GET 404 Not Found /cloud/favicon.ico
GET 200 OK /cloud/icon.png
GET 200 OK /
GET 200 OK /501.png
GET 200 OK /cloud/manifest.json
GET 200 OK /config.log
GET 200 OK /export1.png
GET 200 OK /Chrome3DGlasses.pdf
GET 200 OK /cloud
GET 200 OK /-1
GET 200 OK /Delta-Vs_for_inner_Solar_System.svg

Observe la unescapefunción en la construcción del camino. Esto es para permitir nombres de archivos con espacios y caracteres codificados.

Editar:

La aplicación de muestra Node.js Node Chat tiene la funcionalidad que desea.
En su archivo README.text
3. El paso es lo que está buscando.

paso 1

• crear un servidor que responda con hello world en el puerto 8002

paso 2

• crear un index.html y servirlo

paso 3

• introduce util.js
• cambiar la lógica para que se sirva cualquier archivo estático
• muestre 404 en caso de que no se encuentre ningún archivo

paso 4

• agregar jquery-1.4.2.js
• agregar client.js
• cambie index.html para solicitar al usuario el apodo

Aquí está el server.js

Aquí está el util.js

La forma en que lo hago es, en primer lugar, instalar el servidor estático de nodo globalmente a través de

npm install node-static -g

luego navegue al directorio que contiene sus archivos html e inicie el servidor estático con static .

Vaya al navegador y escriba localhost:8080/"yourHtmlFile".

var http = require('http');
var fs = require('fs');
var index = fs.readFileSync('index.html');

http.createServer(function (req, res) {
    res.writeHead(200, {'Content-Type': 'text/html'});
    // change the to 'text/plain' to 'text/html' it will work as your index page
    res.end(index);
}).listen(9615);

Creo que estabas buscando esto. En su index.html, simplemente llénelo con el código html normal, lo que quiera renderizar en él, como:

<html>
    <h1>Hello world</h1>
</html>

Básicamente copiando la respuesta aceptada, pero evitando crear un archivo js.

$ node
> var connect = require('connect'); connect().use(static('.')).listen(8000);

Lo encontré muy conveniente.

Actualizar

A partir de la última versión de Express, serve-static se ha convertido en un middleware separado. Use esto para servir:

require('http').createServer(require('serve-static')('.')).listen(3000)

Instalar serve-staticprimero.

de w3schools

es bastante fácil crear un servidor de nodo para servir cualquier archivo que se solicite, y no necesita instalar ningún paquete para él

var http = require('http');
var url = require('url');
var fs = require('fs');

http.createServer(function (req, res) {
  var q = url.parse(req.url, true);
  var filename = "." + q.pathname;
  fs.readFile(filename, function(err, data) {
    if (err) {
      res.writeHead(404, {'Content-Type': 'text/html'});
      return res.end("404 Not Found");
    }  
    res.writeHead(200, {'Content-Type': 'text/html'});
    res.write(data);
    return res.end();
  });
}).listen(8080);

http: // localhost: 8080 / file.html

servirá file.html desde el disco

Puedes escribirlos en tu shell

npx serve

Repo: https://github.com/zeit/serve .

Utilizo el siguiente código para iniciar un servidor web simple que representa el archivo html predeterminado si no se menciona ningún archivo en la URL.

var http = require('http'),
fs = require('fs'),
url = require('url'),
rootFolder = '/views/',
defaultFileName = '/views/5 Tips on improving Programming Logic   Geek Files.htm';


http.createServer(function(req, res){

    var fileName = url.parse(req.url).pathname;
    // If no file name in Url, use default file name
    fileName = (fileName == "/") ? defaultFileName : rootFolder + fileName;

    fs.readFile(__dirname + decodeURIComponent(fileName), 'binary',function(err, content){
        if (content != null && content != '' ){
            res.writeHead(200,{'Content-Length':content.length});
            res.write(content);
        }
        res.end();
    });

}).listen(8800);

Representará todos los archivos js, css e imagen, junto con todo el contenido html.

Acuerde la declaración " Ningún tipo de contenido es mejor que uno incorrecto "

No estoy seguro de si esto es exactamente lo que quería, sin embargo, puede intentar cambiar:

{'Content-Type': 'text/plain'}

a esto:

{'Content-Type': 'text/html'}

Esto hará que el cliente del navegador muestre el archivo como html en lugar de texto sin formato.

var http = require('http');
var fs = require('fs');
var index = fs.readFileSync('index.html');

http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'html'});
res.end(index);
}).listen(9615);

//Just Change The CONTENT TYPE to 'html'

Una versión 4.x express un poco más detallada pero que proporciona un listado de directorios, compresión, almacenamiento en caché y solicitudes de registro en un número mínimo de líneas

var express = require('express');
var compress = require('compression');
var directory = require('serve-index');
var morgan = require('morgan'); //logging for express

var app = express();

var oneDay = 86400000;

app.use(compress());
app.use(morgan());
app.use(express.static('filesdir', { maxAge: oneDay }));
app.use(directory('filesdir', {'icons': true}))

app.listen(process.env.PORT || 8000);

console.log("Ready To serve files !")

Gran cantidad de respuestas complicadas aquí. Si no tiene la intención de procesar archivos / base de datos nodeJS pero solo quiere servir html / css / js / images estáticas como sugiere su pregunta, simplemente instale el módulo de servidor de estado de inserción o similar;

Aquí hay un "one liner" que creará y lanzará un mini sitio. Simplemente pegue todo el bloque en su terminal en el directorio apropiado.

mkdir mysite; \
cd mysite; \
npm install pushstate-server --save; \
mkdir app; \
touch app/index.html; \
echo '<h1>Hello World</h1>' > app/index.html; \
touch server.js; \
echo "var server = require('pushstate-server');server.start({ port: 3000, directory: './app' });" > server.js; \
node server.js

Abra el navegador y vaya a http: // localhost: 3000 . Hecho.

El servidor usará el appdirectorio como la raíz para servir archivos. Para agregar activos adicionales simplemente colóquelos dentro de ese directorio.

Ya hay algunas grandes soluciones para un simple nodejs server. Hay una solución más si la necesita live-reloadingmientras realiza cambios en sus archivos.

npm install lite-server -g

navegar su directorio y hacer

lite-server

te abrirá el navegador con la recarga en vivo.

La función Express sendFile hace exactamente lo que necesita, y dado que desea la funcionalidad del servidor web desde el nodo, express es una opción natural y luego servir archivos estáticos se vuelve tan fácil como:

res.sendFile('/path_to_your/index.html')

Lea más aquí: https://expressjs.com/en/api.html#res.sendFile

Un pequeño ejemplo con el servidor web express para el nodo:

var express = require('express');
var app = express();
var path = require('path');

app.get('/', function(req, res) {
    res.sendFile(path.join(__dirname + '/index.html'));
});

app.listen(8080);

ejecuta esto y navega a http: // localhost: 8080

Para ampliar esto para permitirle servir archivos estáticos como CSS e imágenes, aquí hay otro ejemplo:

var express = require('express');
var app = express();
var path = require('path');

app.use(express.static(__dirname + '/css'));

app.get('/', function(req, res) {
    res.sendFile(path.join(__dirname + '/index.html'));
});

app.listen(8080);

así que cree una subcarpeta llamada css, coloque su contenido estático y estará disponible en su index.html para una referencia fácil como:

<link type="text/css" rel="stylesheet" href="/css/style.css" />

Observe la ruta relativa en href!

voila!

La mayoría de las respuestas anteriores describen muy bien cómo se sirven los contenidos. Lo que estaba buscando como adicional era una lista del directorio para que se puedan examinar otros contenidos del directorio. Aquí está mi solución para más lectores:

'use strict';

var finalhandler = require('finalhandler');
var http = require('http');
var serveIndex = require('serve-index');
var serveStatic = require('serve-static');
var appRootDir = require('app-root-dir').get();
var log = require(appRootDir + '/log/bunyan.js');

var PORT = process.env.port || 8097;

// Serve directory indexes for reports folder (with icons)
var index = serveIndex('reports/', {'icons': true});

// Serve up files under the folder
var serve = serveStatic('reports/');

// Create server
var server = http.createServer(function onRequest(req, res){
    var done = finalhandler(req, res);
    serve(req, res, function onNext(err) {
    if (err)
        return done(err);
    index(req, res, done);
    })
});


server.listen(PORT, log.info('Server listening on: ', PORT));

Esta es una de las soluciones más rápidas que uso para ver rápidamente páginas web

sudo npm install ripple-emulator -g

A partir de entonces solo ingrese el directorio de sus archivos html y ejecute

ripple emulate

luego cambie el dispositivo a Nexus 7 horizontal.

La versión más simple que he encontrado es la siguiente. Para fines educativos, es mejor, ya que no utiliza ninguna biblioteca abstracta.

var http = require('http'),
url = require('url'),
path = require('path'),
fs = require('fs');

var mimeTypes = {
  "html": "text/html",
  "mp3":"audio/mpeg",
  "mp4":"video/mp4",
  "jpeg": "image/jpeg",
  "jpg": "image/jpeg",
  "png": "image/png",
  "js": "text/javascript",
  "css": "text/css"};

http.createServer(function(req, res) {
    var uri = url.parse(req.url).pathname;
    var filename = path.join(process.cwd(), uri);
    fs.exists(filename, function(exists) {
        if(!exists) {
            console.log("not exists: " + filename);
            res.writeHead(200, {'Content-Type': 'text/plain'});
            res.write('404 Not Found\n');
            res.end();
            return;
        }
        var mimeType = mimeTypes[path.extname(filename).split(".")[1]];
        res.writeHead(200, {'Content-Type':mimeType});

        var fileStream = fs.createReadStream(filename);
        fileStream.pipe(res);

    }); //end path.exists
}).listen(1337);

Ahora ve al navegador y abre lo siguiente:

http://127.0.0.1/image.jpg

Aquí image.jpgdebe estar en el mismo directorio que este archivo. Espero que esto ayude a alguien :)

También puedo recomendar SugoiJS, es muy fácil de configurar y ofrece la opción de comenzar a escribir rápidamente y tiene excelentes características.

Eche un vistazo aquí para comenzar: http://demo.sugoijs.com/ , documentación: https://wiki.sugoijs.com/

Tiene decoradores de gestión de solicitudes, decoradores de políticas de solicitud y políticas de autorización.

Por ejemplo:

import {Controller,Response,HttpGet,RequestParam} from "@sugoi/server";
​
@Controller('/dashboard')
export class CoreController{
    constructor(){}
​
    @HttpGet("/:role")
    test(@RequestParam('role') role:string,
         @RequestHeader("role") headerRole:string){
        if(role === headerRole )
            return "authorized";
        else{
            throw new Error("unauthorized")
        }
    }
}

Es muy fácil con las toneladas de bibliotecas presentes hoy. Las respuestas aquí son funcionales. Si quieres otra versión para comenzar más rápido y simple

Por supuesto, primero instale node.js. Más tarde:

> # module with zero dependencies
> npm install -g @kawix/core@latest 
> # change /path/to/static with your folder or empty for current
> kwcore "https://raw.githubusercontent.com/voxsoftware/kawix-core/master/example/npmrequire/express-static.js" /path/to/static

Aquí el contenido de " https://raw.githubusercontent.com/voxsoftware/kawix-core/master/example/npmrequire/express-static.js " (no necesita descargarlo, publiqué para entender cómo funciona detrás)

// you can use like this:
// kwcore "https://raw.githubusercontent.com/voxsoftware/kawix-core/master/example/npmrequire/express.js" /path/to/static
// kwcore "https://raw.githubusercontent.com/voxsoftware/kawix-core/master/example/npmrequire/express.js" 

// this will download the npm module and make a local cache
import express from 'npm://express@^4.16.4'
import Path from 'path'

var folder= process.argv[2] || "."
folder= Path.resolve(process.cwd(), folder)
console.log("Using folder as public: " + folder)

var app = express() 
app.use(express.static(folder)) 
app.listen(8181)
console.log("Listening on 8181")