@fuzionx/framework 0.1.30 → 0.1.31

package/cli/index.js

@@ -1,7 +1,7 @@
 /**
  * CLI — fx 명령어 핸들러
  *
- * fx make:app <name>               앱 디렉토리 생성
+ * fx make:app --type=ssr|spa       앱 디렉토리 생성 (고정 이름)
  * fx make:controller <Name>        컨트롤러 생성
  * fx make:service <Name>           서비스 생성
  * fx make:model <Name>             모델 생성
@@ -12,6 +12,8 @@
  * fx make:event <Name>              이벤트 핸들러 생성
  * fx make:worker <Name>             Worker 생성
  * fx make:test <Name>               테스트 생성
+ * fx dev:spa                       FuzionX + Vite 동시 실행
+ * fx build:spa                     Vite 프로덕션 빌드
  *
  * @see docs/framework/16-cli.md
  */
@@ -157,21 +159,41 @@ export async function run(args) {
     }
 
     if (command === 'make:app') {
-        const name = rest[0];
-        if (!name) { console.error('Usage: fx make:app <appName>'); process.exit(1); }
-        const appDir = path.join('.', 'app', name);
+        const typeFlag = rest.find(a => a.startsWith('--type='));
+        const type = typeFlag?.split('=')[1] || rest[0];
+        const validTypes = ['ssr', 'spa'];
+
+        if (!type || !validTypes.includes(type)) {
+            console.error(`Usage: fx make:app --type=ssr|spa`);
+            console.error(`  Available types: ${validTypes.join(', ')}`);
+            process.exit(1);
+        }
+
+        // 앱 이름은 타입에 따라 고정
+        const appName = type;
+        const appDir = path.join('.', 'app', appName);
+
+        // 기존 앱 확인
+        try {
+            await fs.access(appDir);
+            console.error(`❌ app/${appName}/ already exists.`);
+            process.exit(1);
+        } catch { /* 없으면 정상 */ }
+
         // 빈 디렉토리 생성
         for (const d of ['services', 'middleware', 'ws']) {
             const fullDir = path.join(appDir, d);
             await fs.mkdir(fullDir, { recursive: true });
             await fs.writeFile(path.join(fullDir, '.gitkeep'), '');
         }
+
         // 기본 파일 복사 (HomeController, routes, views)
         const appTplDir = path.join(TPL_DIR, 'make/app');
         await copyDirRecursive(appTplDir, appDir);
-        console.log(`✅ Created app/${name}/`);
+
+        console.log(`✅ Created app/${appName}/ (type: ${type})`);
         console.log(`\n   fuzionx.yaml의 apps에 추가하세요:`);
-        console.log(`   "127.0.0.1:49080": ${name}\n`);
+        console.log(`   "127.0.0.1:49080": ${appName}\n`);
         return;
     }
 
@@ -199,6 +221,45 @@ export async function run(args) {
         return;
     }
 
+    // ── fx dev:spa — FuzionX + Vite HMR 동시 실행 ──
+    if (command === 'dev:spa') {
+        const { execSync } = await import('node:child_process');
+        const spaDir = path.resolve('app/spa/views/default/spa');
+        try {
+            await fs.access(spaDir);
+        } catch {
+            console.error('❌ app/spa/views/default/spa/ 디렉토리가 없습니다.');
+            console.error('   fx make:app --type=spa 로 SPA 앱을 먼저 생성하세요.');
+            process.exit(1);
+        }
+        console.log(`🚀 Starting dev server + Vite HMR...`);
+        try {
+            execSync(
+                'npx concurrently "node --watch app.js" "cd app/spa/views/default/spa && npx vite"',
+                { stdio: 'inherit', cwd: process.cwd() },
+            );
+        } catch {}
+        return;
+    }
+
+    // ── fx build:spa — Vite 프로덕션 빌드 ──
+    if (command === 'build:spa') {
+        const { execSync } = await import('node:child_process');
+        const spaDir = path.resolve('app/spa/views/default/spa');
+        try {
+            await fs.access(spaDir);
+        } catch {
+            console.error('❌ app/spa/views/default/spa/ 디렉토리가 없습니다.');
+            process.exit(1);
+        }
+        console.log(`📦 Building SPA for production...`);
+        try {
+            execSync('npx vite build', { stdio: 'inherit', cwd: spaDir });
+            console.log('\n✅ Build complete → public/dist/');
+        } catch { process.exit(1); }
+        return;
+    }
+
     // ── fx stop — 서버 종료 ──
     if (command === 'stop') {
         const pidFile = path.resolve('fuzionx.pid');
@@ -315,18 +376,90 @@ export async function run(args) {
             const modelsDir = path.resolve('database/models');
             const files = await fs.readdir(modelsDir);
             const jsFiles = files.filter(f => f.endsWith('.js'));
+            const apply = rest.includes('--apply');
+
+            // fuzionx.yaml에서 DB 경로 읽기
+            let dbPath = './storage/database.sqlite';
+            try {
+                const yaml = await fs.readFile(path.resolve('fuzionx.yaml'), 'utf8');
+                const dbMatch = yaml.match(/database:\s*(.+\.sqlite)/);
+                if (dbMatch) dbPath = dbMatch[1].trim();
+            } catch {}
+
             console.log('\n📊 Model Schema Status:\n');
+            const models = [];
+
             for (const file of jsFiles) {
                 const mod = await import(path.join(modelsDir, file));
                 const Model = mod.default;
                 if (!Model) continue;
                 const name = path.basename(file, '.js');
                 const table = Model.table || name.toLowerCase() + 's';
-                const cols = Object.keys(Model.columns || {});
-                const status = rest.includes('--apply') ? '✅ synced' : '⏳ pending';
-                console.log(`  ${name.padEnd(20)} table: ${table.padEnd(20)} columns: ${cols.length}  ${status}`);
+                const cols = Model.columns || {};
+                models.push({ name, table, cols });
             }
-            if (!rest.includes('--apply')) {
+
+            if (apply) {
+                // SQLite DB 열기
+                const resolvedDbPath = path.resolve(dbPath);
+                await fs.mkdir(path.dirname(resolvedDbPath), { recursive: true });
+                const { default: Database } = await import('better-sqlite3');
+                const db = new Database(resolvedDbPath);
+
+                for (const { name, table, cols } of models) {
+                    const colDefs = [];
+                    for (const [col, def] of Object.entries(cols)) {
+                        if (def.type === 'increments') {
+                            colDefs.push(`\`${col}\` INTEGER PRIMARY KEY AUTOINCREMENT`);
+                        } else if (def.type === 'integer') {
+                            colDefs.push(`\`${col}\` INTEGER NOT NULL DEFAULT 0`);
+                        } else if (def.type === 'text') {
+                            colDefs.push(`\`${col}\` TEXT NOT NULL DEFAULT ''`);
+                        } else if (def.type === 'datetime') {
+                            colDefs.push(`\`${col}\` DATETIME DEFAULT CURRENT_TIMESTAMP`);
+                        } else if (def.type === 'boolean') {
+                            colDefs.push(`\`${col}\` INTEGER NOT NULL DEFAULT 0`);
+                        } else {
+                            // string, etc.
+                            const unique = def.unique ? ' UNIQUE' : '';
+                            const dflt = def.default != null ? ` DEFAULT '${def.default}'` : " DEFAULT ''";
+                            colDefs.push(`\`${col}\` TEXT NOT NULL${dflt}${unique}`);
+                        }
+                    }
+                    const sql = `CREATE TABLE IF NOT EXISTS \`${table}\` (\n  ${colDefs.join(',\n  ')}\n)`;
+                    db.exec(sql);
+
+                    // ── 기존 테이블에 누락된 컬럼 추가 (ALTER TABLE) ──
+                    const existingCols = db.pragma(`table_info(${table})`).map(c => c.name);
+                    let addedCols = 0;
+                    for (const [col, def] of Object.entries(cols)) {
+                        if (existingCols.includes(col)) continue;
+
+                        let colSql;
+                        if (def.type === 'integer') {
+                            colSql = `INTEGER NOT NULL DEFAULT 0`;
+                        } else if (def.type === 'text') {
+                            colSql = `TEXT NOT NULL DEFAULT ''`;
+                        } else if (def.type === 'datetime') {
+                            colSql = `DATETIME DEFAULT NULL`;
+                        } else if (def.type === 'boolean') {
+                            colSql = `INTEGER NOT NULL DEFAULT 0`;
+                        } else {
+                            const dflt = def.default != null ? `'${def.default}'` : "''";
+                            colSql = `TEXT DEFAULT ${dflt}`;
+                        }
+                        db.exec(`ALTER TABLE \`${table}\` ADD COLUMN \`${col}\` ${colSql}`);
+                        addedCols++;
+                    }
+                    const status = addedCols > 0 ? `✅ synced (+${addedCols} columns)` : '✅ synced';
+                    console.log(`  ${name.padEnd(20)} table: ${table.padEnd(20)} columns: ${Object.keys(cols).length}  ${status}`);
+                }
+                db.close();
+                console.log(`\n  Database: ${path.resolve(dbPath)}`);
+            } else {
+                for (const { name, table, cols } of models) {
+                    console.log(`  ${name.padEnd(20)} table: ${table.padEnd(20)} columns: ${Object.keys(cols).length}  ⏳ pending`);
+                }
                 console.log('\n  Run with --apply to sync changes to database.');
             }
             console.log('');
@@ -336,7 +469,7 @@ export async function run(args) {
 
     console.log(`
   npx create-fuzionx <name>         Create new project
-  fx make:app <name>               Create new app directory structure
+  fx make:app --type=ssr|spa       Create app (fixed name: app/ssr or app/spa)
   fx make:controller <Name> --app=  Create controller (app-specific)
   fx make:service <Name> --app=     Create service (app-specific)
   fx make:model <Name>              Create model (database/models)
@@ -348,6 +481,8 @@ export async function run(args) {
   fx make:worker <Name>             Create worker (shared/workers)
   fx make:test <Name>               Create test
   fx dev                            Start dev server (--watch)
+  fx dev:spa                        Start dev server + Vite HMR
+  fx build:spa                      Build SPA for production
   fx stop                            Stop server (graceful)
   fx restart                         Restart server (graceful)
   fx test                           Run tests

package/index.js

@@ -60,5 +60,8 @@ export { default as FileHelper } from './lib/helpers/FileHelper.js';
 export { default as View } from './lib/view/View.js';
 export { default as OpenAPI } from './lib/view/OpenAPI.js';
 
+// ── Utilities (Stateless) ──
+export { PaginationUtil, StrUtil, NumUtil, DateUtil, ArrUtil, FunctionUtil, ObjectUtil } from './lib/utilities/index.js';
+
 // ── Built-in Middleware ──
 export { bodyParser, cors, auth, apiAuth, csrf, session, theme } from './lib/middleware/index.js';

package/lib/core/Application.js

@@ -9,6 +9,7 @@
  */
 import path from 'node:path';
 import { promises as fs } from 'node:fs';
+import cluster from 'node:cluster';
 import Config from './Config.js';
 import Context from './Context.js';
 import Router from '../http/Router.js';
@@ -429,13 +430,20 @@ export default class Application {
         if (!this._booted) await this.boot();
 
         // PID 파일 생성 (primary만)
-        const cluster = await import('node:cluster');
-        if (!cluster.default?.isWorker) {
+        if (!cluster.isWorker) {
             await this._checkPort(port);
             const pidPath = path.join(this.baseDir, 'fuzionx.pid');
             await fs.writeFile(pidPath, String(process.pid));
         }
 
+        // process.title 설정 (ps에서 보이는 프로세스 이름)
+        const appName = this.config.get('app.name', 'fuzionx');
+        if (cluster.isWorker) {
+            process.title = `${appName}-worker-${cluster.worker.id}`;
+        } else {
+            process.title = `${appName}-primary`;
+        }
+
         await this.emit('ready');
 
         // Bridge 연동 — _coreApp은 boot()에서 이미 생성됨
@@ -461,6 +469,14 @@ export default class Application {
         }
 
         await this.emit('listening');
+
+        // Scheduler 시작 — primary 프로세스에서만 (워커 중복 실행 방지)
+        // fuzionx 상위 레이어가 cluster.fork()로 워커를 생성하므로
+        // cluster.isPrimary로 단일 프로세스 보장
+        if (this._scheduler && this._scheduler._jobs.length > 0 && !cluster.isWorker) {
+            this._scheduler.start();
+        }
+
         return this;
     }
 
@@ -622,9 +638,15 @@ export default class Application {
                 // 미들웨어 체인 사전 구성
                 const middlewareFns = [...this._globalMiddleware];
                 if (route.middleware?.length) {
-                    for (const mwName of route.middleware) {
-                        const fn = this.resolveMiddleware(mwName, appName);
-                        if (fn) middlewareFns.push(fn);
+                    for (const mw of route.middleware) {
+                        // 함수면 직접 사용 (built-in: auth(), cors() 등)
+                        // 문자열이면 resolveMiddleware로 클래스 기반 조회
+                        if (typeof mw === 'function') {
+                            middlewareFns.push(mw);
+                        } else if (typeof mw === 'string') {
+                            const fn = this.resolveMiddleware(mw, appName);
+                            if (fn) middlewareFns.push(fn);
+                        }
                     }
                 }
 

package/lib/core/Context.js

@@ -28,6 +28,7 @@ export default class Context {
         this.body = rawReq.body || null;
         this.ip = rawReq.remoteIp || '';
         this.files = rawReq.files || null;
+        this.uploadError = rawReq.uploadError || null;
         this.formFields = rawReq.formFields || null;
         this.handlerId = rawReq.handlerId;
 
@@ -306,6 +307,22 @@ export default class Context {
 
     render(view, data) {
         // 글로벌 변수 주입 (03-views-templates.md)
+        const bridge = this.app?._bridge;
+        let aspVars = {};
+        if (bridge?.getAspConfig && bridge?.cryptoEncryptCustom) {
+            try {
+                const aspCfg = JSON.parse(bridge.getAspConfig());
+                const clientSecret = this.app?.config?.get('app.client_secret') || '';
+                if (clientSecret && aspCfg.masterSecret) {
+                    aspVars = {
+                        _fx_client_secret: clientSecret,
+                        _fx_asp_secret: bridge.cryptoEncryptCustom(clientSecret, aspCfg.masterSecret),
+                        _fx_asp_header: aspCfg.headerSignal || 'Ruxy-Enc-Mode',
+                    };
+                }
+            } catch {}
+        }
+
         const globals = {
             session: this._rawSession,
             auth: { user: this.user },
@@ -315,6 +332,7 @@ export default class Context {
             flash: this.session?.getFlash() || {},
             theme: this.theme || this.app?.config?.get('themes.default', 'default') || 'default',
             locale: this.locale,
+            ...aspVars,
             ...data,
         };
 
@@ -336,11 +354,18 @@ export default class Context {
     /** @private */
     _createSession(rawReq, app) {
         const data = rawReq.session || {};
+        // Flash 추출 + 세션에서 삭제 (one-time read)
         const flash = { ...(data._flash || {}) };
+        const hadFlash = !!data._flash;
         delete data._flash;
         const sessionId = rawReq.sessionId || null;
         const bridge = app?._bridge || null;
 
+        // Flash 소비 후 세션 저장소에 즉시 반영
+        if (hadFlash && sessionId && bridge?.sessionSet) {
+            try { bridge.sessionSet(sessionId, { ...data }); } catch {}
+        }
+
         return {
             /** 세션 값 조회 */
             get: (key) => key ? (data[key] ?? null) : { ...data },
@@ -350,7 +375,11 @@ export default class Context {
                 data[key] = value;
                 // Core SessionProto 참조: bridge.sessionSet(id, { ...data })
                 if (sessionId && bridge?.sessionSet) {
-                    try { bridge.sessionSet(sessionId, { ...data }); } catch {}
+                    try {
+                        bridge.sessionSet(sessionId, { ...data });
+                    } catch (e) {
+                        console.error('[Session] sessionSet failed:', e?.message || e);
+                    }
                 }
             },
 

package/lib/helpers/I18nHelper.js

@@ -60,7 +60,6 @@ export default class I18nHelper {
      */
     translate(locale, key, vars = {}) {
         // ── Bridge N-API 위임 ──
-        // Core i18n.js 참조: bridge.i18NTranslate(locale, key)
         if (this._bridge && typeof this._bridge.i18NTranslate === 'function') {
             try {
                 const result = this._bridge.i18NTranslate(locale, key);
@@ -72,12 +71,18 @@ export default class I18nHelper {
         const messages = this._messages.get(locale)
             || this._messages.get(this.fallback)
             || this._messages.get(this.defaultLocale);
-        if (!messages) return vars.default || key;
 
-        const value = messages[key];
-        if (value == null) return vars.default || key;
+        const value = messages?.[key];
+        if (value != null) return this._substitute(value, vars);
 
-        return this._substitute(value, vars);
+        // ── auto_complete: 누락 키 자동 등록 ──
+        // default 값이 제공된 경우, Bridge에 누락 키를 보고하여
+        // 모든 locale 파일에 자동으로 추가한다.
+        if (vars.default) {
+            this.updateMissing(key, vars.default);
+        }
+
+        return vars.default || key;
     }
 
     /**
@@ -86,7 +91,6 @@ export default class I18nHelper {
      * @returns {object}
      */
     all(locale) {
-        // Bridge: i18NGetLocales() 는 locale 목록만 반환, 전체 데이터 API 없음
         const messages = this._messages.get(locale) || this._messages.get(this.defaultLocale);
         if (!messages) return {};
         return { ...messages };

package/lib/middleware/apiAuth.js

@@ -0,0 +1,79 @@
+/**
+ * apiAuth — JWT Bearer 토큰 인증 미들웨어
+ *
+ * Authorization: Bearer <token> → 검증 → ctx.user
+ *
+ * @see docs/framework/14-authentication.md
+ *
+ * @param {object} [opts]
+ * @param {string} [opts.secret] - JWT 시크릿
+ * @param {string} [opts.model='User']
+ */
+import { createHmac, timingSafeEqual } from 'node:crypto';
+
+export function apiAuth(opts = {}) {
+    const modelName = opts.model || 'User';
+
+    return async (ctx, next) => {
+        const authHeader = ctx.get('authorization') || '';
+
+        if (!authHeader.startsWith('Bearer ')) {
+            ctx.status(401).json({ error: { message: 'Token required', status: 401 } });
+            return;
+        }
+
+        const token = authHeader.slice(7);
+
+        try {
+            const secret = opts.secret || ctx.app?.config?.get('app.auth.secret', 'fuzionx');
+            const payload = decodeJwtPayload(token, secret);
+
+            if (!payload || !payload.sub) {
+                ctx.status(401).json({ error: { message: 'Invalid token', status: 401 } });
+                return;
+            }
+
+            if (ctx.app?.db?.[modelName]) {
+                ctx.user = await ctx.app.db[modelName].find(payload.sub);
+            } else {
+                ctx.user = { id: payload.sub, ...payload };
+            }
+        } catch {
+            ctx.status(401).json({ error: { message: 'Invalid token', status: 401 } });
+            return;
+        }
+
+        await next();
+    };
+}
+
+/**
+ * JWT 디코드 + HMAC-SHA256 서명 검증
+ * @private
+ */
+function decodeJwtPayload(token, secret) {
+    try {
+        const parts = token.split('.');
+        if (parts.length !== 3) return null;
+
+        const [headerB64, payloadB64, signatureB64] = parts;
+
+        const signingInput = `${headerB64}.${payloadB64}`;
+        const expectedSig = createHmac('sha256', secret)
+            .update(signingInput)
+            .digest();
+
+        const actualSig = Buffer.from(signatureB64, 'base64url');
+        if (expectedSig.length !== actualSig.length) return null;
+        if (!timingSafeEqual(expectedSig, actualSig)) return null;
+
+        const payload = JSON.parse(Buffer.from(payloadB64, 'base64url').toString());
+
+        if (payload.exp !== undefined && Date.now() / 1000 > payload.exp) return null;
+        if (payload.nbf !== undefined && Date.now() / 1000 < payload.nbf) return null;
+
+        return payload;
+    } catch {
+        return null;
+    }
+}

package/lib/middleware/auth.js

@@ -0,0 +1,42 @@
+/**
+ * auth — 세션 인증 미들웨어
+ *
+ * ctx.session.userId → db.User.find() → ctx.user
+ *
+ * @see docs/framework/14-authentication.md
+ *
+ * @param {object} [opts]
+ * @param {string} [opts.sessionKey='userId']
+ * @param {string} [opts.model='User']
+ * @param {string} [opts.redirectTo='/login']
+ */
+export function auth(opts = {}) {
+    const sessionKey = opts.sessionKey || 'userId';
+    const modelName = opts.model || 'User';
+    const redirectTo = opts.redirectTo || null;
+
+    return async (ctx, next) => {
+        const userId = ctx._rawSession?.[sessionKey] || ctx.get('x-test-user-id');
+
+        if (!userId) {
+            if (redirectTo) {
+                ctx.redirect(redirectTo);
+            } else {
+                ctx.status(401).json({ error: { message: 'Unauthorized', status: 401 } });
+            }
+            return;
+        }
+
+        if (ctx.app?.db?.[modelName]) {
+            try {
+                ctx.user = await ctx.app.db[modelName].find(userId);
+            } catch {
+                ctx.user = { id: userId };
+            }
+        } else {
+            ctx.user = { id: userId };
+        }
+
+        await next();
+    };
+}

package/lib/middleware/bodyParser.js

@@ -0,0 +1,19 @@
+/**
+ * bodyParser — JSON/Form body 파싱 미들웨어
+ *
+ * Bridge가 이미 파싱한 body를 보장.
+ * 추가 파싱이 필요한 경우 처리.
+ *
+ * @see docs/framework/12-middleware.md
+ */
+export function bodyParser() {
+    return async (ctx, next) => {
+        if (typeof ctx.body === 'string' && ctx.body) {
+            const ct = ctx.get('content-type') || '';
+            if (ct.includes('application/json')) {
+                try { ctx.body = JSON.parse(ctx.body); } catch {}
+            }
+        }
+        await next();
+    };
+}

package/lib/middleware/cors.js

@@ -0,0 +1,47 @@
+/**
+ * cors — CORS 미들웨어
+ *
+ * @see docs/framework/12-middleware.md
+ *
+ * @param {object} [opts]
+ * @param {string|string[]} [opts.origin='*']
+ * @param {string} [opts.methods='GET,POST,PUT,PATCH,DELETE,OPTIONS']
+ * @param {string} [opts.headers='Content-Type,Authorization']
+ * @param {boolean} [opts.credentials=false]
+ * @param {number} [opts.maxAge=86400]
+ */
+export function cors(opts = {}) {
+    const origin = opts.origin || '*';
+    const methods = opts.methods || 'GET,POST,PUT,PATCH,DELETE,OPTIONS';
+    const headers = opts.headers || 'Content-Type,Authorization';
+    const credentials = opts.credentials || false;
+    const maxAge = opts.maxAge || 86400;
+
+    return async (ctx, next) => {
+        const reqOrigin = ctx.get('origin') || '*';
+        let allowOrigin;
+
+        if (credentials && origin === '*') {
+            allowOrigin = reqOrigin !== '*' ? reqOrigin : '';
+        } else {
+            allowOrigin = origin === '*' ? '*' : (
+                Array.isArray(origin)
+                    ? (origin.includes(reqOrigin) ? reqOrigin : origin[0])
+                    : origin
+            );
+        }
+
+        ctx.header('Access-Control-Allow-Origin', allowOrigin);
+        ctx.header('Access-Control-Allow-Methods', methods);
+        ctx.header('Access-Control-Allow-Headers', headers);
+        if (credentials) ctx.header('Access-Control-Allow-Credentials', 'true');
+
+        if (ctx.method === 'OPTIONS') {
+            ctx.header('Access-Control-Max-Age', String(maxAge));
+            ctx.status(204).end();
+            return;
+        }
+
+        await next();
+    };
+}

package/lib/middleware/csrf.js

@@ -0,0 +1,32 @@
+/**
+ * csrf — CSRF 보호 미들웨어
+ *
+ * GET/HEAD/OPTIONS 는 통과, 나머지는 토큰 검증.
+ *
+ * @see docs/framework/12-middleware.md
+ *
+ * @param {object} [opts]
+ * @param {string} [opts.headerName='x-csrf-token']
+ * @param {string} [opts.sessionKey='_csrfToken']
+ */
+export function csrf(opts = {}) {
+    const headerName = opts.headerName || 'x-csrf-token';
+    const sessionKey = opts.sessionKey || '_csrfToken';
+
+    return async (ctx, next) => {
+        if (['GET', 'HEAD', 'OPTIONS'].includes(ctx.method)) {
+            await next();
+            return;
+        }
+
+        const token = ctx.get(headerName);
+        const expected = ctx._rawSession?.[sessionKey];
+
+        if (!token || !expected || token !== expected) {
+            ctx.status(403).json({ error: { message: 'CSRF token mismatch', status: 403 } });
+            return;
+        }
+
+        await next();
+    };
+}