koa-classic-server 1.0.6 → 1.1.0

package/.vscode/OLD_launch.json

@@ -0,0 +1,26 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+    {
+        "name": "Attach by Process ID",
+        "processId": "${command:PickProcess}",
+        "request": "attach",
+        "skipFiles": [
+            "<node_internals>/**"
+        ],
+        "type": "node"
+    },
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "Launch Program",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "program": "${workspaceFolder}/index.cjs"
+        }
+    ]
+}

package/.vscode/launch.json

@@ -0,0 +1,41 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+      {
+        "name": "Attach by Process ID",
+        "processId": "${command:PickProcess}",
+        "request": "attach",
+        "skipFiles": [
+          "<node_internals>/**"
+        ],
+        "type": "node"
+      },
+      {
+        "type": "node",
+        "request": "launch",
+        "name": "Launch Program",
+        "skipFiles": [
+          "<node_internals>/**"
+        ],
+        "program": "${workspaceFolder}/index.cjs"
+      },
+      {
+        "name": "Debug Jest Tests",
+        "type": "node",
+        "request": "launch",
+        "runtimeExecutable": "node",
+        "runtimeArgs": [
+          "--inspect-brk",
+          "${workspaceFolder}/node_modules/jest/bin/jest.js",
+          "--runInBand"
+        ],
+        "port": 9229,
+        "console": "integratedTerminal",
+        "internalConsoleOptions": "neverOpen",
+        "skipFiles": [
+          "<node_internals>/**"
+        ]
+      }
+    ]
+  }
+  

package/README.md

@@ -41,6 +41,10 @@ next import
 ```js
 const koaClassicServer = require('koa-classic-server');
 ```
+or
+```js
+import koaClassicServer from "koa-classic-server";
+'''
 
 ## API
 

package/__tests__/index.test.js

@@ -0,0 +1,337 @@
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  ATTENZIONE QUESTO TEST NON COPRE SE NEL VISUALIZARE IL CONTENUTO DELLE CARTELLE TUTTO VIENE MOSTRATO COME SI DEVE
+//  ATTENZIONE MANCA IL TEST PER TESTARE I MOTORI DI RENDERING COME .ejs
+//  ERRORI NOTI:
+//  1)QUANDO UNA RISORSA NON VIENE TROVATA IN UNA CARTELLO LO STATO NON È SETTATO SU 404 MA SU 200
+//  2)IL PERCORSO RISERVATO UNZIONA SOLO SE NON VI SONO SPAZI NEL NOME 
+//  FURURES:
+//  A) IMPLEMENTARE UNA ARRAY DI FILE INDEX ,MAGAI DANDO LA POSSIBILITA DI NON DISTINGURE FRA MINUSCOLE EMAIUSCOLE 
+//
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+const supertest = require('supertest');
+const koaClassicServer = require('../index.cjs');
+const Koa = require('koa');
+const fs = require('fs');
+const path = require('path');
+const mime = require('mime-types'); //serve alla funzione getFilesRecursivelySync();
+//const {configurations} = require('../customTest/serversToLoad.util'); --> inutile questo serve solo per testari manualmente 
+
+const rootDir = path.join(__dirname, 'publicWwwTest');
+
+// Legge tutti i file ricorsivamente e li memorizza in un array
+const filesAndDirArray = getFilesRecursivelySync(rootDir);
+
+// Visualizza l'array risultante
+//console.log(filesAndDirArray);
+
+//START option0
+
+// Configuriamo le opzioni per koa-classic-server
+const options0 = {  
+  urlPrefix: '/public', // Il prefisso URL che il middleware dovrà intercettare
+  method: ['GET'],// I metodi HTTP ammessi (default 'GET')
+  showDirContents: true,// Se mostrare il contenuto della directory in caso di richiesta ad una cartella
+  //index: 'index.html', // Nome del file index da cercare all'interno di una directory (se presente)
+};
+
+describe(` koaClassicServer options0: ${JSON.stringify(options0)}`, () => {
+  let app;
+  let server;
+
+  // Avvia il server prima di eseguire i test
+  beforeAll(() => {
+    app = new Koa();
+    app.use(koaClassicServer(rootDir, options0));    // Monta il middleware
+    server = app.listen();// Avvia il server in modo che Supertest possa inviare richieste HTTP
+  });
+  
+  test('controllo che se chiamo un percorso che non esiste mi venga restituito l\'errore apropiato ', async () => {
+    // Effettua una richiesta GET sull'endpoint configurato (il prefisso)
+    const res = await supertest(server).get('/public/percorso_di_una_cartella_o_file_che_non_esiste_fbrojngbornbo/gbrtbbbrbr/tbrbr/rtbrtbrt');
+    expect(res.status).toBe(200);
+    expect(res.type).toMatch(/text\/html/);// type sta per mimetype .... restituisce text/plain anche se dovrebbe essere text/html
+    expect(res.text.replace(/\s/g, '')).toBe(requestedUrlNotFound().replace(/\s/g, '')); //.replace(/\s/g, '') --> rimuoce gli spazi bianchi e le tabulazioni , il server agiunge degli spazi all'inizio facendo fallire il controllo 
+  });
+
+  test('controllo che se l\'indirizzo non ricade nel urlPrefix allora debba essere passato al midlware successivo e se non c\'e allora errore 404 not founf', async () => {
+    // Effettua una richiesta GET sull'endpoint configurato (il prefisso)
+    const res = await supertest(server).get('/percorso al di fuori di url prefix public/gbrtbbbrbr/tbrbr/rtbrtbrt');
+    expect(res.status).toBe(404);
+    expect(res.type).toMatch("text/plain");// type sta per mimetype .... restituisce text/plain anche se dovrebbe essere text/html
+    expect(res.text.replace(/\s/g, '')).toBe("Not Found".replace(/\s/g, '')); //.replace(/\s/g, '') --> rimuoce gli spazi bianchi e le tabulazioni , il server agiunge degli spazi all'inizio facendo fallire il controllo 
+  });
+
+  
+  // queste rige generaranno test per ogni ile presente nella cartella di test 
+  const testFnCallbacks = testAllPathByFileList(filesAndDirArray, () => server, options0);//Genera l'array di callback per i test
+  testFnCallbacks.forEach(cb => cb());// Esegui ogni callback per registrare il test nello scope del describe
+
+  afterAll(() => {// Chiude il server dopo aver completato tutti i test
+    server.close();
+  });  
+});
+
+//END option0
+
+//START option1
+const options1 = {
+  method: ['GET'],
+  showDirContents: true,
+};
+
+describe(` koaClassicServer options1: ${JSON.stringify(options1)}`, () => {
+  let app;
+  let server;
+
+  // Avvia il server prima di eseguire i test
+  beforeAll(() => {
+    app = new Koa();
+    app.use(koaClassicServer(rootDir, options1));    // Monta il middleware
+    server = app.listen();// Avvia il server in modo che Supertest possa inviare richieste HTTP
+  });
+
+  test('controllo che se chiamo un percorso che non esiste mi venga restituito l\'errore apropiato [ANCHE SENZA URL PREFIX] ', async () => {
+    // Effettua una richiesta GET sull'endpoint configurato (il prefisso)
+    const res = await supertest(server).get('/BTBg h gh /percorso_di_una_cartella_o_file_che_non_esiste_fbrojngbornbo/gbrtbbbrbr/tbrbr/rtbrtbrt');
+    expect(res.status).toBe(200);
+    expect(res.type).toMatch(/text\/html/);// type sta per mimetype .... restituisce text/plain anche se dovrebbe essere text/html
+    expect(res.text.replace(/\s/g, '')).toBe(requestedUrlNotFound().replace(/\s/g, '')); //.replace(/\s/g, '') --> rimuoce gli spazi bianchi e le tabulazioni , il server agiunge degli spazi all'inizio facendo fallire il controllo 
+  });
+  
+  const testFnCallbacks = testAllPathByFileList(filesAndDirArray, () => server, options1);//Genera l'array di callback per i test
+  testFnCallbacks.forEach(cb => cb());// Esegui ogni callback per registrare il test nello scope del describe
+
+  afterAll(() => {// Chiude il server dopo aver completato tutti i test
+    server.close();
+  });  
+});
+
+//END option1
+
+//STASRT option2
+const options2 = {
+  method: ['GET'],
+  showDirContents: false,
+  index: 'index.html',
+};
+
+describe(` koaClassicServer options2: ${JSON.stringify(options2)}`, () => {
+  let app;
+  let server;
+
+  // Avvia il server prima di eseguire i test
+  beforeAll(() => {
+    app = new Koa();
+    app.use(koaClassicServer(rootDir, options2));    // Monta il middleware
+    server = app.listen();// Avvia il server in modo che Supertest possa inviare richieste HTTP
+  });
+  
+  const testFnCallbacks = testAllPathByFileList(filesAndDirArray, () => server, options2);//Genera l'array di callback per i test
+  testFnCallbacks.forEach(cb => cb());// Esegui ogni callback per registrare il test nello scope del describe
+
+  afterAll(() => {// Chiude il server dopo aver completato tutti i test
+    server.close();
+  });  
+});
+//END option2
+
+//STASRT option3
+const options3 = {
+  method: ['GET'],
+  showDirContents: false,
+  urlsReserved : Array('/percorso_riservato', '/percorso riservato con spazi')
+};
+
+describe(` koaClassicServer options2: ${JSON.stringify(options2)}`, () => {
+  let app;
+  let server;
+
+  // Avvia il server prima di eseguire i test
+  beforeAll(() => {
+    app = new Koa();
+    app.use(koaClassicServer(rootDir, options3));    // Monta il middleware
+    server = app.listen();// Avvia il server in modo che Supertest possa inviare richieste HTTP
+  });
+
+  test('controllo che se l\'indirizzo ricate di un percorso riservato allora venga passato il tutto al midlware successivo e in questo caso errore not ound', async () => {
+    // Effettua una richiesta GET sull'endpoint configurato (il prefisso)
+    const res = await supertest(server).get('/percorso_riservato/ciao.txt');
+    expect(res.status).toBe(404);
+    expect(res.type).toMatch("text/plain");// type sta per mimetype .... restituisce text/plain anche se dovrebbe essere text/html
+    expect(res.text.replace(/\s/g, '')).toBe("Not Found".replace(/\s/g, '')); //.replace(/\s/g, '') --> rimuoce gli spazi bianchi e le tabulazioni , il server agiunge degli spazi all'inizio facendo fallire il controllo 
+  });
+
+/*   test('lo stesso del precedente ma questa volta il percorso riservato con spazi', async () => {
+    // Effettua una richiesta GET sull'endpoint configurato (il prefisso)
+    const res = await supertest(server).get('/percorso riservato con spazi/ciao.txt');
+    expect(res.status).toBe(404);
+    expect(res.type).toMatch("text/plain");// type sta per mimetype .... restituisce text/plain anche se dovrebbe essere text/html
+    expect(res.text.replace(/\s/g, '')).toBe("Not Found".replace(/\s/g, '')); //.replace(/\s/g, '') --> rimuoce gli spazi bianchi e le tabulazioni , il server agiunge degli spazi all'inizio facendo fallire il controllo 
+  }); */
+
+  
+  const testFnCallbacks = testAllPathByFileList(filesAndDirArray, () => server, options2);//Genera l'array di callback per i test
+  testFnCallbacks.forEach(cb => cb());// Esegui ogni callback per registrare il test nello scope del describe
+
+  afterAll(() => {// Chiude il server dopo aver completato tutti i test
+    server.close();
+  });  
+});
+//END option3
+
+/* const options0 = {
+  // Il prefisso URL che il middleware dovrà intercettare
+  urlPrefix: '/public',
+  // I metodi HTTP ammessi (default 'GET')
+  method: ['GET'],
+  // Se mostrare il contenuto della directory in caso di richiesta ad una cartella
+  showDirContents: true,
+  // Nome del file index da cercare all'interno di una directory (se presente)
+  //index: 'index.html',
+}; */
+
+
+
+
+// questa funzione serve per leggere ricorsivamente il contenuto di una cartella in modo da leggere il contenuto oferto via __tests__/publicWwwTest e confrontarlo con quello via http
+//in linux anhe le directory sono file quindi mi salvo  :)
+function getFilesRecursivelySync(dir) {
+  let results = [];
+  // Leggiamo il contenuto della directory, ottenendo anche informazioni sui file e le cartelle
+  const list = fs.readdirSync(dir, { withFileTypes: true });
+  
+  list.forEach((entry) => {
+    const fullPath = path.join(dir, entry.name);
+    entry.fullPath = fullPath;
+    if (entry.isDirectory()) {
+      // Se l'entry è una cartella, la elaboriamo ricorsivamente
+      entry.type = 'directory';
+      results.push(entry);// inserisco anche la directory stessa nell'elenco
+      results = results.concat(getFilesRecursivelySync(fullPath));
+    } else if (entry.isFile()) {
+      // Se l'entry è un file, lo aggiungiamo all'array dei risultati
+      const mimeType = mime.lookup(entry.name) || 'false';//false --> mimetype non riconosciuto , cosi lo trasmette il server , da approfondire
+      entry.type = 'file';
+      entry.mimeType = mimeType;
+      results.push(entry);
+    }
+  });
+  
+  return results;
+}
+
+//ATTENZIONE questa funzione è esattamente identicaa a quella contenuta nel file index.cjs serve per confrontarla e vedere se il risultato combacia
+function requestedUrlNotFound() {
+  return `
+      <!DOCTYPE html>
+          <html>
+          <head>
+              <meta charset="UTF-8">
+              <meta http-equiv="X-UA-Compatible">
+              <meta name="viewport" content="width=device-width, initial-scale=1.0">
+              <title>URL not found</title>
+          </head>
+          <body>
+          <h1>Not Found</h1>
+
+          <h3>The requested URL was not found on this server.</h3>
+
+          </body>
+          </html>
+      `;
+} // function requestedUrlNotFound(){
+
+//ATENZIONE per questa funzione guardare la descrizione sotto : per funzionare deve evvere chiamata nel seguente modo : 
+// const testFnCallbacks = testAllPathByFileList(filesAndDirArray, () => server, options0);//Genera l'array di callback per i test
+// testFnCallbacks.forEach(cb => cb());// Esegui ogni callback per registrare il test nello scope del describe
+
+function testAllPathByFileList(filesAndDirArray, getServer, options) {
+  return filesAndDirArray.map((entry, index) => {
+    const relativePath = path.relative(rootDir, entry.fullPath);
+    // Restituisci una funzione che, se chiamata, definisce un test.
+    return () => {
+      test(
+        `testo l'elemento ${index} (type: ${entry.type}, name: ${entry.name}) con percorso: ${relativePath}`,
+        async () => {
+          const server = getServer(); // Usa il getter per ottenere il server al momento dell'esecuzione
+          const url = path.join(options.urlPrefix || '/', relativePath);
+          const res = await supertest(server).get(url);
+          expect(res.status).toBe(200);
+          // Se l'entry è un file, controlla il contenuto e il MIME type
+          if (entry.type === 'file') {
+            const content = fs.readFileSync(entry.fullPath, 'utf8');
+            expect(res.type).toBe(entry.mimeType);
+            expect(res.text).toBe(content);
+          } else {//è una directory
+            expect(res.type).toBe('text/html');
+            expect(res.text).toContain('<!DOCTYPE html>');
+            if( options.showDirContents === false ){
+              expect(res.text.replace(/\s/g, '')).toBe(requestedUrlNotFound().replace(/\s/g, '')); //.replace(/\s/g, '') --> rimuoce gli spazi bianchi e le tabulazioni , il server agiunge degli spazi all'inizio facendo fallire il controllo 
+            }
+          }
+        }
+      );
+    };
+  });
+}
+
+/* ATTENZIONE QUESTA FUNZIONE [function testAllPathByFileList] È FATTA IN MANIERA STRANA PER AVER RISOLTO IL PROBLEMA DOPO LUNGA DISCUSSIONE CON CHATGPT
+
+Spiegazione
+
+    Incapsulamento:
+    In testAllPathByFileList usiamo map per creare un array in cui ogni elemento è una funzione (callback) che, se invocata, definisce un test usando test().
+    Così facendo, non eseguiamo subito test(), ma ne restituiamo la definizione da chiamare in seguito.
+
+    Uso del Getter:
+    Passando () => server come secondo argomento, assicuriamo che al momento dell'esecuzione di ogni callback il server sia già inizializzato.
+
+    Registrazione dei Test:
+    Quando chiamiamo testFnCallbacks.forEach(cb => cb()); nello scope del blocco describe, ogni callback viene invocata e i test vengono definiti correttamente per Jest.
+
+Idea di Base
+
+    Genera un array di callback:
+    Crea una funzione che, dato l'array dei file e directory (o dati dinamici), restituisca un array di funzioni. Ogni funzione (callback) quando invocata definirà un test tramite test() ed eseguirà le relative asserzioni con expect().
+
+    Esegui le callback nello scope del describe:
+    All'interno del blocco describe (dove Jest raccoglie i test) iteri sull'array di callback e invochi ciascuna, in modo che i test vengano registrati correttamente. In questo modo, l'errore "Your test suite must contain at least one test" non si verificherà perché i test saranno già stati definiti nello scope globale del describe
+
+//END CONSIDERAZIONE IMPORTANTE
+    */
+
+
+/* 
+OLD//
+
+
+function testAllPathByFileList(filesAndDirArray, getServer, options) {
+  return filesAndDirArray.map((entry, index) => {
+    const relativePath = path.relative(rootDir, entry.fullPath);
+    // Restituisci una funzione che, se chiamata, definisce un test.
+    return () => {
+      test(
+        `testo l'elemento ${index} (type: ${entry.type}, name: ${entry.name}) con percorso: ${relativePath}`,
+        async () => {
+          const server = getServer(); // Usa il getter per ottenere il server al momento dell'esecuzione
+          const url = path.join(options.urlPrefix || '/', relativePath);
+          const res = await supertest(server).get(url);
+          expect(res.status).toBe(200);
+          // Se l'entry è un file, controlla il contenuto e il MIME type
+          if (entry.type === 'file') {
+            const content = fs.readFileSync(entry.fullPath, 'utf8');
+            expect(res.type).toBe(entry.mimeType);
+            expect(res.text).toBe(content);
+          } else {
+            expect(res.type).toBe('text/html');
+            expect(res.text).toContain('<!DOCTYPE html>');
+          }
+        }
+      );
+    };
+  });
+}
+*/

package/__tests__/publicWwwTest/cartella/sottocartella/ciao.html

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Document</title>
+</head>
+<body>
+    <h1>hello world</h1>
+</body>
+</html>

package/__tests__/publicWwwTest/cartella/sottocartella/provaEjs/testEjs.ejs

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Document</title>
+</head>
+<body>
+    <h1><%= "hello world" %></h1>
+</body>
+</html>

package/__tests__/publicWwwTest/cartella vuota con spazi nel nome /file con spazio nel nome .txt

@@ -0,0 +1 @@
+hello world

package/__tests__/publicWwwTest/index.html

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Document</title>
+</head>
+<body>
+    <h1>hello world</h1>
+</body>
+</html>

package/__tests__/publicWwwTest/prova file .txt

@@ -0,0 +1,2 @@
+
+hello world

package/__tests__/publicWwwTest/semplicetxt.txt

@@ -0,0 +1 @@
+hello world

package/__tests__/publicWwwTest/test.txt

@@ -0,0 +1 @@
+hello world

package/customTest/README.md

@@ -0,0 +1,6 @@
+## questi ile servono per testare manualmente le vari conigurazioni 
+
+# digitando : 
+### npm run loadConfig
+# potrai sceglire quale configurazione usare per caricare il server e testatarlo la directory puntata è la stessa contenuta nella directory __tests__
+# cioè __tests__/publicWwwTest

package/customTest/loadConfig.util.js

@@ -0,0 +1,41 @@
+// questo script permetterà di scegliere la conigurazione con cui lanciare koa-classic-server al ine di essere testato 
+// ci sarà una lista interattive di configurazione fra cui scegliere :
+
+// chooseCon.js
+const { createServer, configurations } = require('../customTest/serversToLoad.util');
+const inquirer = require('inquirer').default;
+
+async function chooseConfiguration() {
+  // Costruiamo le scelte dall'array delle configurazioni
+  const choices = configurations.map(config => ({
+    name: `${config.name}: ${config.description}`,
+    value: config.name,
+  }));
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'configName',
+      message: 'Seleziona la configurazione da visualizzare:',
+      choices: choices,
+    },
+  ]);
+
+  return answers.configName;
+}
+
+async function main() {
+  const configName = await chooseConfiguration();
+  const app = createServer(configName);
+  const port = process.env.PORT || 3000;
+  
+  app.listen(port, () => {
+    console.log(`Server avviato su http://localhost:${port} con configurazione "${configName}"`);
+  });
+}
+
+main().catch(error => {
+  console.error('Errore durante l\'esecuzione:', error);
+  process.exit(1);
+});
+

package/customTest/serversToLoad.util.js

@@ -0,0 +1,93 @@
+// quivi sarnno elencato in un array le varie possibili configurzioni di koaClassicServer in modo po sa poterle testare
+
+// servers.js
+const Koa = require('koa');
+const koaClassicServer = require('../index.cjs');
+const { join } = require('path');
+
+/**
+ * Array (o raccolta) delle configurazioni disponibili.
+ * Aggiungendo nuovi oggetti qui potrai testare ulteriori configurazioni.
+ */
+rootDir = join(__dirname, '../' , '__tests__','publicWwwTest');
+console.log( 'rootDir', rootDir);
+const configurations = [
+  {
+    name: 'test generico',
+    description: ' urlPrefix: \',',
+    // Per i test, i file da servire sono quelli della cartella __tests__/publicWwwTest
+    rootDir: rootDir,
+    options: {
+      //urlPrefix: '/',
+      method: ['GET'],
+      showDirContents: true,
+    },
+  },
+  {
+    name: 'test indicando l\'index file ',
+    description: "nelle  urlPrefix: \'/public\', : //index: 'index.html',",
+    // In produzione potresti servire i file dalla cartella "public"
+    rootDir: rootDir,
+    options: {
+      urlPrefix: '/public',
+      method: ['GET'],
+      showDirContents: true,
+      index: 'index.html',
+    },
+  },
+  {
+    name: 'test generico',
+    description: ' urlPrefix: \'/public\',',
+    // Per i test, i file da servire sono quelli della cartella __tests__/publicWwwTest
+    rootDir: rootDir,
+    options: {
+      urlPrefix: '/public',
+      method: ['GET'],
+      showDirContents: true,
+    },
+  },
+  {
+    name: 'test con percorso riservato ',
+    description: "urlsReserved : Array('percorso_riservato/', 'percorso riservato con spazi')",
+    // Per i test, i file da servire sono quelli della cartella __tests__/publicWwwTest
+    rootDir: rootDir,
+    options: {
+      urlPrefix: '',
+      method: ['GET'],
+      showDirContents: true,
+      urlsReserved : Array('/percorso_riservato', '/percorso riservato con spazi')
+    },
+  },
+  // Puoi aggiungere ulteriori configurazioni qui
+];
+
+/**
+ * Cerca e restituisce la configurazione in base al nome.
+ * Se non viene trovata, restituisce la prima (default).
+ *
+ * @param {string} configName - Il nome della configurazione da usare.
+ * @returns {object} La configurazione trovata.
+ */
+function getConfig(configName) {
+  return configurations.find(config => config.name === configName) || configurations[0];
+}
+
+/**
+ * Crea un'istanza di Koa configurata in base alla configurazione scelta.
+ *
+ * @param {string} configName - Il nome della configurazione da utilizzare (default: 'default').
+ * @returns {Koa} L'istanza dell'applicazione Koa.
+ */
+function createServer( configName ) {
+  const config = getConfig(configName);
+  const app = new Koa();
+  console.log('config.options', config.options, 'config.rootDir' , config.rootDir);
+  app.use(koaClassicServer(config.rootDir, config.options));
+  return app;
+}
+
+module.exports = {
+  configurations,
+  getConfig,
+  createServer,
+};

package/{index.js → index.cjs}

@@ -1,3 +1,4 @@
+
 const { URL } = require("url");
 const fs = require("fs");
 const mime = require("mime-types");
@@ -6,7 +7,7 @@ const { error } = require("console");
 
 // è la funzione che avierà il server rootDir = cartella dei file statici, UrlPrefix = prefisso del path dove guardare es localhost:3000\views
 // questa funzione deve restituire un midlware
-module.exports = function koaClassicServer(
+module.exports =  function koaClassicServer(
     rootDir,
     opts = {}
 
@@ -270,4 +271,4 @@ module.exports = function koaClassicServer(
             return toReturn;
         } // function show_dir( dir ){
     }; // return (ctx, next) => {
-};
+};

package/index.mjs

@@ -0,0 +1,9 @@
+
+// index.js (ESM)
+// index.esm.js
+
+// Importa il modulo principale (anche se è scritto in CommonJS)
+// Node gestirà l'interoperabilità e restituirà il valore presente in module.exports.
+import koaClassicServer from './index.cjs';
+export default koaClassicServer;
+

package/noteExports.md

@@ -0,0 +1,148 @@
+
+## versione corta
+ Utilizzare Conditional Exports in package.json
+
+Con Node.js (versione 12.20+, 14+ o successive) puoi sfruttare il campo exports nel file package.json per indicare percorsi diversi a seconda del metodo di importazione:
+
+Esempio di package.json:
+
+{
+  "name": "mia-libreria",
+  "version": "1.0.0",
+  "main": "./index.cjs",            // entry point per CommonJS
+  "exports": {
+    "import": "./index.js",         // entry point per ESM
+    "require": "./index.cjs"        // entry point per CommonJS
+  }
+}
+
+Con questa configurazione, puoi scrivere la logica principale in un file (ad esempio lib/koaClassicServer.js) e poi creare due entry point:
+
+    Per ESM (index.js)
+
+// index.js
+export { default } from './lib/koaClassicServer.js';
+
+Per CommonJS (index.cjs)
+
+    // index.cjs
+    module.exports = require('./lib/koaClassicServer.js').default;
+
+In questo modo gli utenti potranno importare il modulo in ESM:
+
+import koaClassicServer from "mia-libreria";
+
+oppure in CommonJS:
+
+const koaClassicServer = require("mia-libreria");
+
+
+
+## versione lunga
+
+ l'uso dei Conditional Exports nel file package.json, è un meccanismo introdotto nelle versioni moderne di Node.js (dalla 12.20 in poi, con supporto stabile a partire dalla 14) che ti permette di specificare percorsi di ingresso diversi a seconda di come il modulo viene importato:
+
+    ESM (quando usi import ... from 'modulo')
+    CommonJS (quando usi require('modulo'))
+
+Questo approccio ti consente di mantenere una singola distribuzione del tuo modulo, fornendo però due "versioni" compatibili in base al sistema di moduli utilizzato dall'ambiente dell'utente.
+Struttura di Base del package.json
+
+Ecco un esempio di configurazione:
+
+{
+  "name": "mia-libreria",
+  "version": "1.0.0",
+  "main": "./index.cjs",            
+  "exports": {
+    "import": "./index.js",
+    "require": "./index.cjs"
+  }
+}
+
+Spiegazione dei campi principali:
+
+    main:
+    Tradizionalmente questo campo specifica il file di ingresso per i moduli CommonJS. Anche se non è obbligatorio se usi il campo exports, è buona pratica inserirlo per mantenere la compatibilità con strumenti o ambienti che non supportano ancora i conditional exports.
+
+    exports:
+    Questo campo permette di definire in modo esplicito quali file (o percorsi) devono essere utilizzati quando il modulo viene importato, in base al contesto. In questo esempio, abbiamo due condizioni:
+        "import": "./index.js": Quando il modulo viene importato in un contesto ECMAScript (ESM), Node.js userà il file index.js.
+        "require": "./index.cjs": Quando il modulo viene importato tramite CommonJS (require()), verrà usato il file index.cjs.
+
+Strutturare il Modulo per Supportare Entrambi gli Stili
+
+Supponiamo di avere una struttura simile a questa:
+
+mia-libreria/
+├── lib/
+│   └── koaClassicServer.js
+├── index.js      // Entry point per ESM
+├── index.cjs     // Entry point per CommonJS
+└── package.json
+
+1. File lib/koaClassicServer.js (la logica principale)
+
+Scrivi qui il tuo modulo in sintassi moderna (ESM). Ad esempio:
+
+// lib/koaClassicServer.js
+export default function koaClassicServer(rootDir, opts = {}) {
+  // ... implementazione del middleware
+}
+
+2. File index.js (entry point per ESM)
+
+Questo file importa il modulo principale e lo re-esporta:
+
+// index.js (ESM)
+export { default } from './lib/koaClassicServer.js';
+
+3. File index.cjs (entry point per CommonJS)
+
+In questo file, importa il modulo in modo compatibile con CommonJS e lo esporta:
+
+// index.cjs (CommonJS)
+module.exports = require('./lib/koaClassicServer.js').default;
+
+Come Funziona in Pratica
+
+    Utilizzando ESM:
+
+    Se un utente importa il modulo in un file ESM:
+
+import koaClassicServer from 'mia-libreria';
+
+Node.js guarderà il campo exports nel package.json e, vedendo la chiave "import", caricherà il file index.js che esporta il modulo definito in koaClassicServer.js.
+
+Utilizzando CommonJS:
+
+Se invece un utente importa il modulo in un file CommonJS:
+
+    const koaClassicServer = require('mia-libreria');
+
+    Node.js, vedendo la chiave "require" nel campo exports, caricherà il file index.cjs che esporta correttamente il modulo.
+
+Vantaggi di Questo Approccio
+
+    Compatibilità Doppia:
+    Permette agli utenti di utilizzare il modulo indipendentemente dal sistema di moduli scelto.
+
+    Manutenzione Centralizzata:
+    La logica principale è scritta in un solo file (koaClassicServer.js), riducendo la duplicazione del codice.
+
+    Supporto ai Nuovi Standard:
+    Utilizzando i conditional exports, ti prepari per il futuro, dove i moduli ESM diventeranno lo standard principale.
+
+    Controllo Esplicito dell'Interfaccia:
+    Il campo exports consente di definire in modo esplicito e sicuro quali file devono essere esposti agli utenti del modulo, evitando accessi accidentali a file interni non destinati alla pubblicazione.
+
+Considerazioni Finali
+
+    Versione di Node.js:
+    Assicurati che i tuoi utenti utilizzino una versione di Node.js che supporti i conditional exports (Node 14+ è consigliato).
+
+    Compatibilità con Strumenti di Build:
+    Se utilizzi strumenti di build o bundler, verifica che siano configurati per gestire correttamente il campo exports.
+
+Utilizzando i Conditional Exports nel package.json potrai distribuire il tuo modulo in modo elegante e compatibile con entrambi gli stili di moduli, offrendo un'esperienza di utilizzo migliore agli sviluppatori che lo importeranno.
+

package/package.json

@@ -1,11 +1,16 @@
 {
   "name": "koa-classic-server",
-  "version": "1.0.6",
+  "version": "1.1.0",
   "description": "a server in style Apache 2",
-  "main": "index.js",
+  "main": "index.cjs",
+  "exports": {
+    "import": "./index.mjs",
+    "require": "./index.cjs"
+  },
   "scripts": {
-    "start": "node index.js",
-    "test": "jest"
+    "start": "node index.cjs",
+    "test": "jest",
+    "loadConfig": "node ./customTest/loadConfig.util.js"
   },
   "keywords": [
     "file",
@@ -14,8 +19,11 @@
   "author": "Italo Paesano",
   "license": "MIT",
   "dependencies": {
-    "jest": "^29.4.2",
-    "koa": "^2.13.4",
-    "supertest": "^6.3.3"
+    "koa": "^2.13.4"
+  },
+  "devDependencies": {
+    "inquirer": "^12.4.1",
+    "jest": "^29.7.0",
+    "supertest": "^7.0.0"
   }
 }

package/index.test.js

@@ -1,63 +0,0 @@
-//const request = require('supertest');
-//const Koa = require('koa');
-const classicServer = require('koa-classic-server');
-
-const testDir = __dirname + '/test' ;
-
-const fakeApp = classicServer( testDir );
-
-const fakeCtx = {
-  method: 'GET',
-  href: 'http://localhost:3000/', // da controllare
-  body: '',
-  response: {} 
-}
-
-const fakeNext = () => {};
-
-///console.log(fakeApp( fakeCtx, fakeNext));
-
-test('prima prova', () => {
-  fakeApp( fakeCtx, fakeNext).then((result) => {
-    console.log('resuuultttttt',result);
-    expect( result ).not.toBe(3);
-  })//)).not.toBe(3);
-});
-
-/* const app = new Koa();
-app.use(classicServer( __dirname + '/test'));
-
-const server = app.listen();
-
-request(server)
-  .get('/')
-  .expect('Content-Type', 'text/html')
-  //.expect('Content-Length', '15')
-  .expect(200)
-  .end(function(err, res) {
-    if (err) throw err;
-  }); */
-
-
-
-/* describe('koa-classic-server', () => {
-  let app;
-
-  beforeEach(() => {
-    app = new Koa();
-    app.use(classicServer());
-  });
-
-  it('should return Hello World!', async () => {
-    const res = await request(app.callback()).get('/');
-    expect(res.status).toBe(200);
-    expect(res.text).toBe('Hello World!');
-  });
-
-  it('should return 404 for invalid route', async () => {
-    const res = await request(app.callback()).get('/invalid');
-    expect(res.status).toBe(404);
-    expect(res.text).toBe('Not Found');
-  });
-});
- */