@flancer32/teq-web 0.2.0 → 0.3.1

package/test/unit/Back/Dto/Handler/Source.test.mjs

@@ -0,0 +1,40 @@
+import test from 'node:test';
+import assert from 'assert';
+import {buildTestContainer} from '../../../common.js';
+
+test.describe('Fl32_Web_Back_Dto_Handler_Source', () => {
+  test('should create valid config DTO with casted fields', async () => {
+    const container = buildTestContainer();
+    container.register('Fl32_Web_Back_Helper_Cast$', {
+      string: (d) => typeof d === 'string' ? d : undefined,
+      stringArrayMap: (d) => d,
+      array: (d, item) => Array.isArray(d) ? d.map(item) : [],
+    });
+    const factory = await container.get('Fl32_Web_Back_Dto_Handler_Source$');
+    const dto = factory.create({
+      root: '/abs/path',
+      prefix: '/src/',
+      allow: { vue: ['dist/vue.global.js'] },
+      defaults: ['index.html'],
+    });
+    assert.strictEqual(dto.root, '/abs/path');
+    assert.strictEqual(dto.prefix, '/src/');
+    assert.deepStrictEqual(dto.allow, { vue: ['dist/vue.global.js'] });
+    assert.deepStrictEqual(dto.defaults, ['index.html']);
+  });
+
+  test('should return undefined fields if values are invalid', async () => {
+    const container = buildTestContainer();
+    container.register('Fl32_Web_Back_Helper_Cast$', {
+      string: () => undefined,
+      stringArrayMap: () => ({}),
+      array: () => [],
+    });
+    const factory = await container.get('Fl32_Web_Back_Dto_Handler_Source$');
+    const dto = factory.create({});
+    assert.strictEqual(dto.root, undefined);
+    assert.strictEqual(dto.prefix, undefined);
+    assert.deepStrictEqual(dto.allow, {});
+    assert.deepStrictEqual(dto.defaults, []);
+  });
+});

package/test/unit/Back/Handler/Pre/Log.test.mjs

@@ -0,0 +1,22 @@
+import {describe, it, beforeEach} from 'node:test';
+import assert from 'node:assert/strict';
+import {buildTestContainer} from '../../../common.js';
+
+describe('Fl32_Web_Back_Handler_Pre_Log', () => {
+    let container;
+    const log = [];
+
+    beforeEach(() => {
+        log.length = 0;
+        container = buildTestContainer();
+        container.register('Fl32_Web_Back_Logger$', {
+            debug: (msg) => log.push(msg),
+        });
+    });
+
+    it('logs method and url', async () => {
+        const handler = await container.get('Fl32_Web_Back_Handler_Pre_Log$');
+        await handler.handle({method: 'GET', url: '/path'});
+        assert.deepStrictEqual(log, ['GET /path']);
+    });
+});

package/test/unit/Back/Handler/Static/A/Config.test.mjs

@@ -0,0 +1,52 @@
+import {describe, it} from 'node:test';
+import assert from 'node:assert/strict';
+import {buildTestContainer} from '../../../../common.js';
+
+describe('Fl32_Web_Back_Handler_Static_A_Config', () => {
+    it('normalizes root, prefix, allow and defaults', async () => {
+        const container = buildTestContainer();
+        /** @type {Fl32_Web_Back_Handler_Static_A_Config} */
+        const factory = await container.get('Fl32_Web_Back_Handler_Static_A_Config$');
+
+        const dto = {
+            root: './r',
+            prefix: '/p',
+            allow: {'.': ['.']},
+            defaults: []
+        };
+        const cfg = factory.create(dto);
+
+        // root is resolved via node:path from the container
+        const {resolve} = await import('node:path');
+        assert.strictEqual(cfg.root, resolve('./r'));
+
+        // prefix is normalized to always end with a slash
+        assert.strictEqual(cfg.prefix, '/p/');
+
+        // allowed extensions are preserved
+        assert.deepStrictEqual(cfg.allow, {'.': ['.']});
+
+        // defaults fallback to built-in list when empty
+        assert.deepStrictEqual(
+            cfg.defaults,
+            ['index.html', 'index.htm', 'index.txt']
+        );
+    });
+
+    it('throws on invalid data', async () => {
+        const container = buildTestContainer();
+        const factory = await container.get('Fl32_Web_Back_Handler_Static_A_Config$');
+
+        // missing root should throw an error about root
+        assert.throws(
+            () => factory.create({prefix: '/'}),
+            /Field 'root' must be a string/
+        );
+
+        // non-string prefix should throw an error about prefix
+        assert.throws(
+            () => factory.create({root: 'a', prefix: 5}),
+            /Field 'prefix' must be a string/
+        );
+    });
+});

package/test/unit/Back/Handler/Static/A/Fallback.test.mjs

@@ -0,0 +1,60 @@
+import {describe, it, beforeEach} from 'node:test';
+import assert from 'node:assert/strict';
+import {buildTestContainer} from '../../../../common.js';
+
+describe('Fl32_Web_Back_Handler_Static_A_Fallback', () => {
+    /** @type {{ promises: { stat: (p: string) => Promise<any> }, _add: (p: string, isFile: boolean) => void }} */
+    let mockFs;
+
+    beforeEach(() => {
+        const storage = new Map();
+
+        mockFs = {
+            promises: {
+                stat: async p => {
+                    // normalize path: backslashes → slashes, remove duplicate and trailing slash
+                    const key = p.replace(/\\/g, '/').replace(/\/+/g, '/').replace(/\/$/, '');
+                    if (!storage.has(key)) throw new Error('ENOENT');
+                    return storage.get(key);
+                }
+            },
+            /** Adds a file or directory into the mock storage */
+            _add: (p, isFile) => {
+                const key = p.replace(/\\/g, '/').replace(/\/+/g, '/').replace(/\/$/, '');
+                storage.set(key, {
+                    isFile: () => isFile,
+                    isDirectory: () => !isFile
+                });
+            }
+        };
+    });
+
+    function addFile(p) { mockFs._add(p, true); }
+
+    function addDir(p) { mockFs._add(p, false); }
+
+    /** Creates and returns a configured Fallback instance */
+    async function getFallback() {
+        const container = buildTestContainer();
+        container.register('node:fs', mockFs);
+        /** @type {Fl32_Web_Back_Handler_Static_A_Fallback} */
+        return container.get('Fl32_Web_Back_Handler_Static_A_Fallback$');
+    }
+
+    it('returns index file for a directory', async () => {
+        addDir('/d');
+        addFile('/d/index.html');
+
+        const fb = await getFallback();
+        const result = await fb.apply('/d', ['index.html']);
+        assert.strictEqual(result, '/d/index.html');
+    });
+
+    it('returns null when nothing found', async () => {
+        addDir('/x');
+
+        const fb = await getFallback();
+        const result = await fb.apply('/x', ['a.html']);
+        assert.strictEqual(result, null);
+    });
+});

package/test/unit/Back/Handler/Static/A/FileService.test.mjs

@@ -0,0 +1,225 @@
+import { describe, it, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import { buildTestContainer } from '../../../../common.js';
+
+const normalize = p => p.replace(/\\/g, '/').replace(/\/+/g, '/').replace(/\/$/, '');
+
+class MockRes extends EventEmitter {
+  constructor() {
+    super();
+    this.data = '';
+    this.status = undefined;
+    this.headers = undefined;
+    this._hs = false;
+    this._ended = false;
+  }
+  get headersSent() {
+    return this._hs;
+  }
+  get writableEnded() {
+    return this._ended;
+  }
+  writeHead(status, headers) {
+    this.status = status;
+    this.headers = headers;
+    this._hs = true;
+  }
+  write(chunk) {
+    this.data += chunk;
+  }
+  end(chunk) {
+    if (chunk) this.write(chunk);
+    this._ended = true;
+    this.emit('finish');
+  }
+}
+
+describe('Fl32_Web_Back_Handler_Static_A_FileService', () => {
+  let storage, mockFs, mime, logger, logs, addFile, addDir;
+
+  beforeEach(() => {
+    storage = new Map();
+
+    // mock fs.promises.stat and createReadStream
+    mockFs = {
+      promises: {
+        stat: async p => {
+          const key = normalize(p);
+          if (!storage.has(key)) throw new Error('ENOENT');
+          const entry = storage.get(key);
+          return {
+            isFile: entry.isFile,
+            isDirectory: entry.isDirectory,
+            size: entry.size,
+            mtime: entry.mtime
+          };
+        }
+      },
+      createReadStream: p => ({
+        pipe: res => {
+          setImmediate(() => {
+            const key = normalize(p);
+            const entry = storage.get(key);
+            if (entry && entry.content != null) res.write(entry.content);
+            res.end();
+          });
+        }
+      })
+    };
+
+    // simple mime helper
+    mime = {
+      getByExt: () => 'text/plain'
+    };
+
+    logs = [];
+    // simple logger collecting calls
+    logger = {
+      info: (...args) => logs.push(['info', ...args]),
+      warn: (...args) => logs.push(['warn', ...args]),
+      exception: (...args) => logs.push(['exception', ...args])
+    };
+
+    // helpers to populate mock FS
+    addFile = (p, content) => {
+      const key = normalize(p);
+      storage.set(key, {
+        isFile: () => true,
+        isDirectory: () => false,
+        size: Buffer.byteLength(content),
+        mtime: new Date(),
+        content
+      });
+    };
+    addDir = p => {
+      const key = normalize(p);
+      storage.set(key, {
+        isFile: () => false,
+        isDirectory: () => true,
+        size: 0,
+        mtime: new Date()
+      });
+    };
+  });
+
+  it('serves existing file', async () => {
+    addFile('/root/a.txt', 'A');
+
+    /** @type {{ root: string, prefix: string, defaults: string[] }} */
+    const config = { root: '/root', prefix: '/p/', defaults: ['index.html'] };
+    const res = new MockRes();
+
+    const container = buildTestContainer();
+    container.register('node:fs', mockFs);
+    container.register('Fl32_Web_Back_Helper_Mime$', mime);
+    container.register('Fl32_Web_Back_Logger$', logger);
+
+    /** @type {Fl32_Web_Back_Handler_Static_A_FileService} */
+    const service = await container.get('Fl32_Web_Back_Handler_Static_A_FileService$');
+
+    const ok = await service.serve(config, 'a.txt', {}, res);
+    await new Promise(r => res.on('finish', r));
+
+    assert.ok(ok);
+    assert.strictEqual(res.status, 200);
+    assert.strictEqual(res.data, 'A');
+  });
+
+  it('returns false when file not found', async () => {
+    addDir('/root');
+
+    /** @type {{ root: string, prefix: string, defaults: string[] }} */
+    const config = { root: '/root', prefix: '/p/', defaults: ['index.html'] };
+    const res = new MockRes();
+
+    const container = buildTestContainer();
+    container.register('node:fs', mockFs);
+    container.register('Fl32_Web_Back_Helper_Mime$', mime);
+    container.register('Fl32_Web_Back_Logger$', logger);
+
+    /** @type {Fl32_Web_Back_Handler_Static_A_FileService} */
+    const service = await container.get('Fl32_Web_Back_Handler_Static_A_FileService$');
+
+    const ok = await service.serve(config, 'missing.txt', {}, res);
+    assert.strictEqual(ok, false);
+  });
+
+  it('logs info when file is missing during stat', async () => {
+    mockFs.promises.stat = async () => {
+      const err = new Error('ENOENT');
+      err.code = 'ENOENT';
+      throw err;
+    };
+    /** @type {{ root: string, prefix: string, defaults: string[] }} */
+    const config = { root: '/root', prefix: '/p/', defaults: [] };
+    const res = new MockRes();
+
+    const container = buildTestContainer();
+    container.register('node:fs', mockFs);
+    container.register('Fl32_Web_Back_Helper_Mime$', mime);
+    container.register('Fl32_Web_Back_Logger$', logger);
+    container.register('Fl32_Web_Back_Handler_Static_A_Fallback$', { apply: async p => p });
+
+    /** @type {Fl32_Web_Back_Handler_Static_A_FileService} */
+    const service = await container.get('Fl32_Web_Back_Handler_Static_A_FileService$');
+
+    const ok = await service.serve(config, 'missing.txt', {}, res);
+
+    assert.strictEqual(ok, false);
+    assert.strictEqual(logs.length, 1);
+    assert.strictEqual(logs[0][0], 'info');
+  });
+
+  it('logs warn on access errors', async () => {
+    /** force EACCES error */
+    mockFs.promises.stat = async () => {
+      const err = new Error('EACCES');
+      err.code = 'EACCES';
+      throw err;
+    };
+
+    /** @type {{ root: string, prefix: string, defaults: string[] }} */
+    const config = { root: '/root', prefix: '/p/', defaults: [] };
+    const res = new MockRes();
+
+    const container = buildTestContainer();
+    container.register('node:fs', mockFs);
+    container.register('Fl32_Web_Back_Helper_Mime$', mime);
+    container.register('Fl32_Web_Back_Logger$', logger);
+    container.register('Fl32_Web_Back_Handler_Static_A_Fallback$', { apply: async p => p });
+
+    /** @type {Fl32_Web_Back_Handler_Static_A_FileService} */
+    const service = await container.get('Fl32_Web_Back_Handler_Static_A_FileService$');
+
+    const ok = await service.serve(config, 'denied.txt', {}, res);
+
+    assert.strictEqual(ok, false);
+    assert.strictEqual(logs.length, 1);
+    assert.strictEqual(logs[0][0], 'warn');
+  });
+
+  it('logs exception on unexpected errors', async () => {
+    addFile('/root/x.txt', 'X');
+    mockFs.createReadStream = () => { throw new Error('boom'); };
+
+    /** @type {{ root: string, prefix: string, defaults: string[] }} */
+    const config = { root: '/root', prefix: '/p/', defaults: [] };
+    const res = new MockRes();
+
+    const container = buildTestContainer();
+    container.register('node:fs', mockFs);
+    container.register('Fl32_Web_Back_Helper_Mime$', mime);
+    container.register('Fl32_Web_Back_Logger$', logger);
+    container.register('Fl32_Web_Back_Handler_Static_A_Fallback$', { apply: async p => p });
+
+    /** @type {Fl32_Web_Back_Handler_Static_A_FileService} */
+    const service = await container.get('Fl32_Web_Back_Handler_Static_A_FileService$');
+
+    const ok = await service.serve(config, 'x.txt', {}, res);
+
+    assert.strictEqual(ok, false);
+    assert.strictEqual(logs.length, 1);
+    assert.strictEqual(logs[0][0], 'exception');
+  });
+});

package/test/unit/Back/Handler/Static/A/Registry.test.mjs

@@ -0,0 +1,83 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { buildTestContainer } from '../../../../common.js';
+
+/** Simple config factory mock */
+function getMockFactory() {
+    return { create: dto => ({ root: dto.root, prefix: dto.prefix }) };
+}
+
+describe('Fl32_Web_Back_Handler_Static_A_Registry', () => {
+    it('stores initial config', async () => {
+        const container = buildTestContainer();
+        container.register('Fl32_Web_Back_Handler_Static_A_Config$', getMockFactory());
+        /** @type {Fl32_Web_Back_Handler_Static_A_Registry} */
+        const registry = await container.get('Fl32_Web_Back_Handler_Static_A_Registry$');
+
+        registry.addConfigs([{ root: '/a', prefix: '/p/' }]);
+        const match = registry.find('/p/file.txt');
+
+        assert.ok(match);
+        assert.strictEqual(match.config.root, '/a');
+    });
+
+    it('adds config with new prefix', async () => {
+        const container = buildTestContainer();
+        container.register('Fl32_Web_Back_Handler_Static_A_Config$', getMockFactory());
+        const registry = await container.get('Fl32_Web_Back_Handler_Static_A_Registry$');
+
+        registry.addConfigs([{ root: '/a', prefix: '/p/' }]);
+        registry.addConfigs([{ root: '/b', prefix: '/p/s/' }]);
+
+        const match = registry.find('/p/s/file.txt');
+        assert.ok(match);
+        assert.strictEqual(match.config.root, '/b');
+    });
+
+    it('ignores config with existing prefix', async () => {
+        const container = buildTestContainer();
+        container.register('Fl32_Web_Back_Handler_Static_A_Config$', getMockFactory());
+        const registry = await container.get('Fl32_Web_Back_Handler_Static_A_Registry$');
+
+        registry.addConfigs([{ root: '/a', prefix: '/p/' }]);
+        registry.addConfigs([{ root: '/b', prefix: '/p/s/' }]);
+        registry.addConfigs([{ root: '/c', prefix: '/p/s/' }]);
+
+        const match = registry.find('/p/s/test.txt');
+        assert.ok(match);
+        assert.strictEqual(match.config.root, '/b');
+    });
+
+    it('logs warning when prefix already exists', async () => {
+        const log = [];
+        const container = buildTestContainer();
+        container.register('Fl32_Web_Back_Handler_Static_A_Config$', getMockFactory());
+        container.register('Fl32_Web_Back_Logger$', {
+            warn: (...args) => log.push(args)
+        });
+        const registry = await container.get('Fl32_Web_Back_Handler_Static_A_Registry$');
+
+        registry.addConfigs([{ root: '/a', prefix: '/p/' }]);
+        registry.addConfigs([{ root: '/b', prefix: '/p/' }]);
+
+        assert.strictEqual(log.length, 1);
+        assert.ok(log[0][0].includes('/p/'));
+    });
+
+    it('prefers longer prefix when matching', async () => {
+        const container = buildTestContainer();
+        container.register('Fl32_Web_Back_Handler_Static_A_Config$', getMockFactory());
+        const registry = await container.get('Fl32_Web_Back_Handler_Static_A_Registry$');
+
+        registry.addConfigs([
+            { root: '/a', prefix: '/p/' },
+            { root: '/b', prefix: '/p/s/' }
+        ]);
+
+        const match1 = registry.find('/p/s/x.txt');
+        const match2 = registry.find('/p/y.txt');
+
+        assert.strictEqual(match1.config.root, '/b');
+        assert.strictEqual(match2.config.root, '/a');
+    });
+});

package/test/unit/Back/Handler/Static/A/Resolver.test.mjs

@@ -0,0 +1,73 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { buildTestContainer } from '../../../../common.js';
+
+describe('Fl32_Web_Back_Handler_Static_A_Resolver', () => {
+    it('resolves allowed path', async () => {
+        const container = buildTestContainer();
+        /** @type {Fl32_Web_Back_Handler_Static_A_Resolver} */
+        const resolver = await container.get('Fl32_Web_Back_Handler_Static_A_Resolver$');
+
+        const { resolve } = await import('node:path');
+        const config = {
+            root: resolve('/root'),
+            prefix: '/p/',
+            allow: { pkg: ['a.txt'] }
+        };
+
+        const fsPath = resolver.resolve(config, 'pkg/a.txt');
+        assert.strictEqual(fsPath, resolve('/root/pkg/a.txt'));
+    });
+
+    it('returns null for disallowed path', async () => {
+        const container = buildTestContainer();
+        /** @type {Fl32_Web_Back_Handler_Static_A_Resolver} */
+        const resolver = await container.get('Fl32_Web_Back_Handler_Static_A_Resolver$');
+
+        const { resolve } = await import('node:path');
+        const config = {
+            root: resolve('/root'),
+            prefix: '/p/',
+            allow: { pkg: ['a.txt'] }
+        };
+
+        const result = resolver.resolve(config, 'pkg/b.txt');
+        assert.strictEqual(result, null);
+    });
+
+    it('throws on path traversal attempts', async () => {
+        const container = buildTestContainer();
+        /** @type {Fl32_Web_Back_Handler_Static_A_Resolver} */
+        const resolver = await container.get('Fl32_Web_Back_Handler_Static_A_Resolver$');
+
+        const { resolve } = await import('node:path');
+        const config = {
+            root: resolve('/root'),
+            prefix: '/p/',
+            allow: { pkg: ['a.txt'] }
+        };
+
+        assert.throws(
+            () => resolver.resolve(config, '../x'),
+            /Static access denied/
+        );
+    });
+
+    it('throws on absolute rel paths', async () => {
+        const container = buildTestContainer();
+        /** @type {Fl32_Web_Back_Handler_Static_A_Resolver} */
+        const resolver = await container.get('Fl32_Web_Back_Handler_Static_A_Resolver$');
+
+        const { resolve } = await import('node:path');
+        const config = {
+            root: resolve('/root'),
+            prefix: '/p/',
+            allow: { pkg: ['a.txt'] }
+        };
+
+        assert.throws(
+            () => resolver.resolve(config, '/etc/passwd'),
+            /Static access denied/
+        );
+    });
+});