apiforge-analyzer 1.1.0

package/dist/cjs/detect.js

@@ -0,0 +1,68 @@
+"use strict";
+/**
+ * Framework detection utilities
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectFramework = detectFramework;
+/**
+ * Detect which framework is being used
+ */
+function detectFramework(app) {
+    // Express detection
+    if (app && typeof app === 'function') {
+        if (app._router || (app.lazyrouter && typeof app.lazyrouter === 'function')) {
+            return { name: 'express', confidence: 1.0 };
+        }
+    }
+    // Next.js detection
+    try {
+        const fs = require('fs');
+        const path = require('path');
+        // Check for Next.js Pages Router
+        if (fs.existsSync(path.join(process.cwd(), 'pages'))) {
+            const hasApiFolder = fs.existsSync(path.join(process.cwd(), 'pages', 'api'));
+            if (hasApiFolder) {
+                return { name: 'nextjs-pages', confidence: 0.9 };
+            }
+        }
+        // Check for Next.js App Router
+        if (fs.existsSync(path.join(process.cwd(), 'app'))) {
+            return { name: 'nextjs-app', confidence: 0.9 };
+        }
+        // Check for next.config
+        if (fs.existsSync(path.join(process.cwd(), 'next.config.js')) ||
+            fs.existsSync(path.join(process.cwd(), 'next.config.mjs'))) {
+            return { name: 'nextjs-pages', confidence: 0.7 };
+        }
+    }
+    catch (e) {
+        // Ignore fs errors
+    }
+    // Vite detection
+    try {
+        require.resolve('vite');
+        return { name: 'vite', confidence: 0.8 };
+    }
+    catch (e) {
+        // Vite not installed
+    }
+    // React Router detection
+    try {
+        require.resolve('react-router-dom');
+        return { name: 'react-router', confidence: 0.7 };
+    }
+    catch (e) {
+        // React Router not installed
+    }
+    // Node HTTP detection
+    try {
+        const http = require('http');
+        if (http) {
+            return { name: 'node-http', confidence: 0.5 };
+        }
+    }
+    catch (e) {
+        // HTTP module not available
+    }
+    return { name: 'unknown', confidence: 0 };
+}

package/dist/cjs/export.js

@@ -0,0 +1,321 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportToJSON = exportToJSON;
+exports.enrichRoutes = enrichRoutes;
+exports.enrichRoute = enrichRoute;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Export routes to JSON file
+ */
+async function exportToJSON(routes, projectName, filePath, baseUrl) {
+    const enrichedRoutes = enrichRoutes(routes);
+    const exportData = {
+        projectName,
+        timestamp: new Date().toISOString(),
+        schemaVersion: 'apiforge.route-export.v2',
+        framework: enrichedRoutes[0]?.framework || 'unknown',
+        baseUrl,
+        routes: enrichedRoutes,
+        metadata: {
+            totalRoutes: enrichedRoutes.length,
+            tags: Array.from(new Set(enrichedRoutes.map(r => r.tag))),
+            extractedAt: new Date().toISOString(),
+            routeIds: enrichedRoutes.map(r => ({ id: r.id, routeKey: r.routeKey, method: r.method, path: r.path })),
+        },
+    };
+    const fullPath = path.join(process.cwd(), filePath);
+    try {
+        fs.writeFileSync(fullPath, JSON.stringify(exportData, null, 2), 'utf-8');
+        console.log(`💾 Saved API export to: ${fullPath}`);
+    }
+    catch (error) {
+        console.error('Failed to save JSON:', error.message);
+        throw error;
+    }
+}
+function enrichRoutes(routes) {
+    const withIds = routes.map((route, index) => enrichRoute(route, index + 1));
+    return withIds.map(route => ({
+        ...route,
+        linkedPaths: route.linkedPaths?.length ? route.linkedPaths : inferLinkedPaths(route, withIds),
+    }));
+}
+function enrichRoute(route, index) {
+    const id = route.id || index;
+    const routeKey = route.routeKey || `api-${String(id).padStart(3, '0')}`;
+    const pathParams = unique([...(route.pathParams || []), ...extractPathParams(route.path)]);
+    const queryParams = unique(route.queryParams || []);
+    const requestBodyFields = unique(route.requestBodyFields || []);
+    const headerParams = unique(route.headerParams || []);
+    const tag = route.tag || inferTag(route.path);
+    const parameters = buildParameters(route.parameters, pathParams, queryParams, headerParams);
+    const requestBody = route.requestBody || buildRequestBody(route.method, requestBodyFields);
+    const responses = route.responses || buildResponses(route.method, route.path, tag, route.responseStatuses);
+    const authRequired = Boolean(route.authRequired || route.hasAuth || detectAuth(route.middleware || []));
+    return {
+        ...route,
+        id,
+        routeKey,
+        tag,
+        tags: route.tags?.length ? route.tags : [tag],
+        summary: route.summary || generateSummary(route.method, route.path),
+        description: route.description || generateDescription(route.method, route.path, tag),
+        authRequired,
+        hasAuth: authRequired,
+        pathParams,
+        queryParams,
+        requestBodyFields,
+        headerParams,
+        parameters,
+        requestBody,
+        responses,
+        sourceContext: {
+            framework: route.framework,
+            routeKey,
+            detectedFrom: route.framework,
+            confidence: confidenceFor(route, parameters, requestBody, responses),
+            middleware: route.middleware || [],
+            authRequired,
+            pathParams,
+            queryParams,
+            requestBodyFields,
+            headerParams,
+            responseStatuses: route.responseStatuses || [],
+            notes: buildNotes(route, requestBodyFields, queryParams, headerParams),
+        },
+    };
+}
+function buildParameters(existing, pathParams, queryParams, headerParams = []) {
+    const params = new Map();
+    (existing || []).forEach(param => params.set(`${param.in}:${param.name}`, param));
+    pathParams.forEach(name => params.set(`path:${name}`, {
+        name,
+        in: 'path',
+        required: true,
+        type: 'string',
+        schema: { type: 'string' },
+        description: `Required path parameter: ${name}.`,
+    }));
+    queryParams.forEach(name => {
+        const key = `query:${name}`;
+        if (!params.has(key))
+            params.set(key, {
+                name,
+                in: 'query',
+                required: false,
+                type: 'string',
+                schema: { type: 'string' },
+                description: `Optional query parameter: ${name}.`,
+            });
+    });
+    headerParams.forEach(name => {
+        const key = `header:${name}`;
+        if (!params.has(key))
+            params.set(key, {
+                name,
+                in: 'header',
+                required: name.toLowerCase() === 'authorization',
+                type: 'string',
+                schema: { type: 'string' },
+                description: `Request header: ${name}.`,
+            });
+    });
+    return Array.from(params.values());
+}
+function buildRequestBody(method, fields) {
+    if (!['POST', 'PUT', 'PATCH'].includes(method.toUpperCase()) || !fields.length)
+        return undefined;
+    const properties = {};
+    fields.forEach(field => {
+        properties[field] = {
+            type: inferFieldType(field),
+            description: `Detected request body field: ${field}.`,
+            example: exampleForField(field),
+        };
+    });
+    return {
+        required: true,
+        content: {
+            'application/json': {
+                schema: {
+                    type: 'object',
+                    required: fields,
+                    properties,
+                },
+            },
+        },
+    };
+}
+function buildResponses(method, path, tag, detectedStatuses) {
+    // Prefer statuses seen in the source; fall back to method-based inference
+    const m = method.toUpperCase();
+    const inferredPrimary = m === 'POST' ? 201 : m === 'DELETE' ? 204 : 200;
+    const primaryStatus = detectedStatuses?.find(s => s >= 200 && s < 300) ?? inferredPrimary;
+    const status = String(primaryStatus);
+    const successBody = status === '204' ? undefined : {
+        'application/json': {
+            schema: {
+                type: 'object',
+                properties: {
+                    success: { type: 'boolean', example: true },
+                    endpoint: { type: 'string', example: `${m} ${path}` },
+                    resource: { type: 'string', example: tag.toLowerCase() },
+                },
+            },
+        },
+    };
+    const base = {
+        [status]: {
+            description: status === '204' ? 'Deleted successfully' : 'Successful response',
+            content: successBody,
+        },
+    };
+    (detectedStatuses || []).forEach(s => {
+        if (s >= 200 && s < 300)
+            return; // already covered
+        base[String(s)] = { description: statusDescription(s) };
+    });
+    // Always include standard errors if not already present
+    if (!base['400'])
+        base['400'] = { description: 'Invalid request input' };
+    if (!base['401'])
+        base['401'] = { description: 'Authentication required or invalid credentials' };
+    if (!base['500'])
+        base['500'] = { description: 'Unexpected server error' };
+    return base;
+}
+function statusDescription(code) {
+    const map = {
+        400: 'Invalid request input',
+        401: 'Authentication required or invalid credentials',
+        403: 'Forbidden — insufficient permissions',
+        404: 'Resource not found',
+        409: 'Conflict — resource already exists',
+        422: 'Unprocessable entity',
+        429: 'Too many requests — rate limit exceeded',
+        500: 'Unexpected server error',
+        503: 'Service unavailable',
+    };
+    return map[code] || `HTTP ${code}`;
+}
+function inferLinkedPaths(route, routes) {
+    return routes
+        .filter(other => other.id !== route.id)
+        .filter(other => other.tag === route.tag || shareResource(route.path, other.path))
+        .slice(0, 5)
+        .map(other => `${other.method.toUpperCase()} ${other.path}`);
+}
+function extractPathParams(routePath) {
+    return unique([...(routePath.matchAll(/:(\w+)/g))].map(match => match[1]));
+}
+function detectAuth(middleware) {
+    const authNames = ['authenticateToken', 'authenticate', 'verifyToken', 'requireAuth', 'auth', 'protect', 'isAuth', 'checkAuth', 'jwtAuth', 'bearerAuth'];
+    return middleware.some(name => authNames.some(authName => name.toLowerCase().includes(authName.toLowerCase())));
+}
+function inferTag(routePath) {
+    const skip = new Set(['api', 'v1', 'v2', 'v3']);
+    return routePath.split('/').filter(Boolean).find(part => !skip.has(part) && !part.startsWith(':')) || 'general';
+}
+function generateSummary(method, routePath) {
+    const resource = routePath.split('/').filter(Boolean).filter(part => !part.startsWith(':')).pop() || 'resource';
+    const action = {
+        GET: `Get ${resource}`,
+        POST: `Create ${resource}`,
+        PUT: `Replace ${resource}`,
+        PATCH: `Update ${resource}`,
+        DELETE: `Delete ${resource}`,
+    };
+    return action[method.toUpperCase()] || `${method.toUpperCase()} ${routePath}`;
+}
+function generateDescription(method, routePath, tag) {
+    return `${method.toUpperCase()} ${routePath} in the ${tag} API group. Generated from runtime route metadata, middleware names, path parameters, query reads, and request body reads.`;
+}
+function shareResource(a, b) {
+    const clean = (value) => value.split('/').filter(Boolean).filter(part => !part.startsWith(':') && !['api', 'v1', 'v2', 'v3'].includes(part));
+    return clean(a).some(part => clean(b).includes(part));
+}
+function confidenceFor(route, parameters, requestBody, responses) {
+    let score = 0.55;
+    if (parameters.length)
+        score += 0.15;
+    if (requestBody)
+        score += 0.15;
+    if (responses)
+        score += 0.1;
+    if (route.middleware?.length)
+        score += 0.05;
+    return Math.min(score, 0.95);
+}
+function buildNotes(route, bodyFields, queryParams, headerParams = []) {
+    const notes = [];
+    if (bodyFields.length)
+        notes.push(`Detected request body fields: ${bodyFields.join(', ')}.`);
+    if (queryParams.length)
+        notes.push(`Detected query parameters: ${queryParams.join(', ')}.`);
+    if (headerParams.length)
+        notes.push(`Detected request headers: ${headerParams.join(', ')}.`);
+    if (route.responseStatuses?.length)
+        notes.push(`Detected response status codes: ${route.responseStatuses.join(', ')}.`);
+    if (route.middleware?.length)
+        notes.push(`Middleware chain: ${route.middleware.join(', ')}.`);
+    return notes;
+}
+function inferFieldType(name) {
+    if (/^(is|has|can|should)[A-Z_]/.test(name) || /active|enabled|verified/i.test(name))
+        return 'boolean';
+    if (/count|total|amount|price|limit|offset|page|age|qty|quantity/i.test(name))
+        return 'number';
+    return 'string';
+}
+function exampleForField(name) {
+    if (/email/i.test(name))
+        return 'user@example.com';
+    if (/password/i.test(name))
+        return 'SecurePass123!';
+    if (/name/i.test(name))
+        return 'Jane Developer';
+    if (/id$/i.test(name))
+        return 'id_123';
+    if (/count|total|amount|price|limit|offset|page|age|qty|quantity/i.test(name))
+        return 10;
+    if (/active|enabled|verified/i.test(name))
+        return true;
+    return `example_${name}`;
+}
+function unique(items) {
+    return Array.from(new Set(items.filter(Boolean)));
+}

package/dist/cjs/frameworks/express.js

@@ -0,0 +1,245 @@
+"use strict";
+/**
+ * Express analyzer — accurate route + payload extraction
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeExpress = analyzeExpress;
+// ─── Path normalisation ───────────────────────────────────────────────────────
+function normalizePath(raw) {
+    return raw
+        .replace(/\\\//g, '/')
+        .replace(/\(\?[^)]*\)/g, '')
+        .replace(/\([^)]*\)/g, '')
+        .replace(/\\\w/g, '')
+        .replace(/[\^\$\?\\]/g, '')
+        .replace(/\/+/g, '/')
+        .replace(/\/$/, '')
+        || '/';
+}
+function tagFromPath(path) {
+    const skip = new Set(['api', 'v1', 'v2', 'v3', 'v4']);
+    const meaningful = path
+        .split('/')
+        .filter(Boolean)
+        .find(s => !skip.has(s) && !s.startsWith(':'));
+    return meaningful || 'general';
+}
+function generateSummary(method, path) {
+    const parts = path.split('/').filter(s => s && !s.startsWith(':'));
+    const action = parts[parts.length - 1] || '';
+    const resource = parts[parts.length - 2] || '';
+    const map = {
+        GET: action ? `Get ${action}` : `List ${resource}`,
+        POST: action ? `Create ${action}` : `Create ${resource}`,
+        PUT: action ? `Update ${action}` : `Update ${resource}`,
+        PATCH: action ? `Patch ${action}` : `Patch ${resource}`,
+        DELETE: action ? `Delete ${action}` : `Delete ${resource}`,
+    };
+    const base = map[method] || `${method} ${path}`;
+    return (base.charAt(0).toUpperCase() + base.slice(1)).replace(/[-_]/g, ' ');
+}
+// ─── Main analyser ────────────────────────────────────────────────────────────
+function analyzeExpress(app) {
+    const routes = [];
+    const seen = new Set();
+    if (typeof app.lazyrouter === 'function')
+        app.lazyrouter();
+    const stack = app._router?.stack ??
+        app.router?.stack ??
+        app.layerStack ??
+        app.stack ??
+        null;
+    if (!stack?.length) {
+        console.warn('⚠️  No routes found — ensure routes are registered before analyze()');
+        return routes;
+    }
+    for (const layer of stack) {
+        if (layer.route) {
+            const r = buildRoute(layer.route, '');
+            if (r && !seen.has(r.method + r.path)) {
+                routes.push(r);
+                seen.add(r.method + r.path);
+            }
+        }
+        else if (layer.handle?.stack) {
+            let base = '';
+            if (layer.regexp?.source)
+                base = normalizePath(layer.regexp.source);
+            else if (layer.path)
+                base = normalizePath(layer.path);
+            else if (typeof layer.route === 'string')
+                base = normalizePath(layer.route);
+            for (const sub of layer.handle.stack) {
+                if (sub.route) {
+                    const r = buildRoute(sub.route, base);
+                    if (r && !seen.has(r.method + r.path)) {
+                        routes.push(r);
+                        seen.add(r.method + r.path);
+                    }
+                }
+            }
+        }
+    }
+    return routes;
+}
+// ─── Route builder ────────────────────────────────────────────────────────────
+function buildRoute(route, basePath) {
+    if (!route.path)
+        return null;
+    const methods = Object.keys(route.methods || {})
+        .filter(m => route.methods[m])
+        .map(m => m.toUpperCase());
+    if (!methods.length)
+        return null;
+    const cleanBase = normalizePath(basePath);
+    const cleanRoute = normalizePath(route.path);
+    let fullPath = (cleanBase === '/' ? '' : cleanBase) + cleanRoute;
+    if (!fullPath.startsWith('/'))
+        fullPath = '/' + fullPath;
+    if (fullPath !== '/' && fullPath.endsWith('/'))
+        fullPath = fullPath.slice(0, -1);
+    const stack = route.stack || [];
+    // ── Middleware names ───────────────────────────────────────────────────────
+    const middleware = stack
+        .map((l) => l.name)
+        .filter((n) => n && n !== '<anonymous>' && n !== 'bound dispatch' && n !== 'bound ');
+    // ── Join all handler source text ───────────────────────────────────────────
+    const src = stack.map((l) => l.handle?.toString() ?? '').join('\n');
+    // ── Path params (from route pattern) ──────────────────────────────────────
+    const pathParams = unique([...fullPath.matchAll(/:(\w+)/g)].map(m => m[1]));
+    // ── Query params ───────────────────────────────────────────────────────────
+    const queryParams = unique([
+        // req.query.foo
+        ...matchAll(src, /req\.query\.([a-zA-Z0-9_$]+)/g),
+        // { foo, bar } = req.query  /  { foo: renamed } = req.query
+        ...destructured(src, /(?:const|let|var)\s+\{([^}]+)\}\s*=\s*req\.query/g),
+        // req.query['foo']
+        ...matchAll(src, /req\.query\[['"]([a-zA-Z0-9_$]+)['"]\]/g),
+    ]);
+    // ── Request body fields ────────────────────────────────────────────────────
+    const requestBodyFields = unique([
+        // req.body.foo
+        ...matchAll(src, /req\.body\.([a-zA-Z0-9_$]+)/g),
+        // { foo, bar: alias, baz = default } = req.body
+        ...destructured(src, /(?:const|let|var)\s+\{([^}]+)\}\s*=\s*req\.body/g),
+        // req.body['foo']
+        ...matchAll(src, /req\.body\[['"]([a-zA-Z0-9_$]+)['"]\]/g),
+        // body.foo (when `const body = req.body`)
+        ...bodyAliasFields(src),
+        // Zod: z.object({ field: z.string() }).parse(req.body)
+        ...zodFields(src),
+        // Joi: Joi.object({ field: Joi.string() }).validate(req.body)
+        ...joiFields(src),
+    ]);
+    // ── Header params ──────────────────────────────────────────────────────────
+    const headerParams = unique([
+        ...matchAll(src, /req\.headers\[['"]([a-zA-Z0-9_$-]+)['"]\]/g),
+        ...matchAll(src, /req\.get\s*\(\s*['"]([a-zA-Z0-9_$-]+)['"]\s*\)/g),
+        // req.headers.authorization, req.headers['x-api-key'], etc.
+        ...matchAll(src, /req\.headers\.([a-zA-Z0-9_$]+)/g),
+    ]);
+    // ── Response status codes from `res.status(nnn)` ──────────────────────────
+    const responseStatuses = unique([...src.matchAll(/res\.status\s*\(\s*(\d{3})\s*\)/g)].map(m => parseInt(m[1], 10)));
+    // ── Auth detection ─────────────────────────────────────────────────────────
+    const AUTH_NAMES = new Set([
+        'authenticateToken', 'authenticate', 'verifyToken', 'requireAuth', 'auth',
+        'protect', 'isAuth', 'checkAuth', 'jwtAuth', 'bearerAuth', 'isAuthenticated',
+        'requireLogin', 'ensureAuth', 'verifyJWT', 'checkToken', 'authMiddleware',
+        'passport.authenticate', 'jwt', 'bearer',
+    ]);
+    const hasAuth = middleware.some(m => AUTH_NAMES.has(m) || [...AUTH_NAMES].some(a => m.toLowerCase().includes(a.toLowerCase()))) ||
+        /req\.user|req\.auth|verifyToken|jwt\.verify|passport\.authenticate/.test(src);
+    const method = methods[0];
+    const tag = tagFromPath(fullPath);
+    const summary = generateSummary(method, fullPath);
+    const operationId = `${method.toLowerCase()}_${fullPath
+        .replace(/[^a-zA-Z0-9]/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_|_$/g, '')}`;
+    return {
+        method,
+        path: fullPath,
+        tag,
+        operationId,
+        summary,
+        middleware,
+        authRequired: hasAuth,
+        pathParams,
+        queryParams,
+        requestBodyFields,
+        linkedPaths: [],
+        hasAuth,
+        framework: 'express',
+        responseStatuses: responseStatuses.length ? responseStatuses : undefined,
+        headerParams: headerParams.length ? headerParams : undefined,
+    };
+}
+// ─── Extraction helpers ───────────────────────────────────────────────────────
+/** Run a global regex and return capture group 1 for every match. */
+function matchAll(src, re) {
+    return [...src.matchAll(re)].map(m => m[1]).filter(Boolean);
+}
+/**
+ * Extract field names from all destructuring patterns like:
+ *   const { a, b: alias, c = default, d: alias2 = default } = req.body
+ * Runs ALL occurrences of the given regex, not just the first.
+ */
+function destructured(src, re) {
+    const results = [];
+    for (const match of src.matchAll(re)) {
+        match[1]
+            .split(',')
+            .map(s => s.trim())
+            // handle "alias: original" — we want the local binding (left side)
+            .map(s => s.split(':')[0].trim())
+            // strip default value
+            .map(s => s.split('=')[0].trim())
+            .filter(Boolean)
+            .forEach(f => results.push(f));
+    }
+    return results;
+}
+/**
+ * When a developer writes `const body = req.body` and then accesses `body.foo`.
+ */
+function bodyAliasFields(src) {
+    const aliasMatch = src.match(/(?:const|let|var)\s+(\w+)\s*=\s*req\.body\b/);
+    if (!aliasMatch)
+        return [];
+    const alias = aliasMatch[1];
+    if (alias === 'body')
+        return matchAll(src, /body\.([a-zA-Z0-9_$]+)/g);
+    const re = new RegExp(`\\b${alias}\\.([a-zA-Z0-9_$]+)`, 'g');
+    return matchAll(src, re);
+}
+/** Extract field names from Zod object schemas. */
+function zodFields(src) {
+    const results = [];
+    // z.object({ field: z.xxx(), ... }).parse(req.body) or .safeParse
+    const zodRe = /z\.object\s*\(\s*\{([^}]+)\}/g;
+    for (const match of src.matchAll(zodRe)) {
+        match[1]
+            .split(',')
+            .map(s => s.trim().split(':')[0].trim())
+            .filter(s => /^[a-zA-Z_$]/.test(s))
+            .forEach(f => results.push(f));
+    }
+    return results;
+}
+/** Extract field names from Joi object schemas. */
+function joiFields(src) {
+    const results = [];
+    // Joi.object({ field: Joi.xxx() }) or yup.object().shape({ field: ... })
+    const joiRe = /(?:Joi|yup)\.object\s*\(?\s*(?:\.shape\s*\()?\s*\{([^}]+)\}/g;
+    for (const match of src.matchAll(joiRe)) {
+        match[1]
+            .split(',')
+            .map(s => s.trim().split(':')[0].trim())
+            .filter(s => /^[a-zA-Z_$]/.test(s))
+            .forEach(f => results.push(f));
+    }
+    return results;
+}
+function unique(items) {
+    return Array.from(new Set(items.filter(Boolean)));
+}