@apiposture/cli 1.0.1

package/dist/core/discovery/fastify-discoverer.js

@@ -0,0 +1,249 @@
+import * as ts from 'typescript';
+import { getLineAndColumn, findNodes } from '../analysis/source-file-loader.js';
+import { createEndpoint } from '../models/endpoint.js';
+import { EndpointType } from '../models/endpoint-type.js';
+import { HttpMethod, parseHttpMethod } from '../models/http-method.js';
+import { createDefaultAuthorizationInfo, determineClassification, } from '../models/authorization-info.js';
+const FASTIFY_HTTP_METHODS = new Set([
+    'get', 'post', 'put', 'delete', 'patch', 'options', 'head', 'all'
+]);
+const FASTIFY_IDENTIFIERS = new Set(['fastify', 'server', 'app', 'instance']);
+const AUTH_HOOK_PATTERNS = [
+    /authenticate/i,
+    /verify/i,
+    /jwt/i,
+    /auth/i,
+    /guard/i,
+    /protected/i,
+];
+export class FastifyDiscoverer {
+    name = 'Fastify';
+    async discover(file) {
+        const endpoints = [];
+        const { sourceFile, filePath } = file;
+        const callExpressions = findNodes(sourceFile, ts.isCallExpression);
+        for (const callExpr of callExpressions) {
+            // Check for fastify.get(), fastify.post(), etc.
+            const shorthandEndpoint = this.processShorthandRoute(callExpr, sourceFile, filePath);
+            if (shorthandEndpoint) {
+                endpoints.push(shorthandEndpoint);
+                continue;
+            }
+            // Check for fastify.route({ method, url, ... })
+            const routeEndpoint = this.processRouteMethod(callExpr, sourceFile, filePath);
+            if (routeEndpoint) {
+                endpoints.push(routeEndpoint);
+            }
+        }
+        return endpoints;
+    }
+    processShorthandRoute(callExpr, sourceFile, filePath) {
+        if (!ts.isPropertyAccessExpression(callExpr.expression)) {
+            return null;
+        }
+        const propAccess = callExpr.expression;
+        const methodName = propAccess.name.text.toLowerCase();
+        if (!FASTIFY_HTTP_METHODS.has(methodName)) {
+            return null;
+        }
+        const callerName = this.getCallerName(propAccess.expression);
+        if (!callerName || !this.isFastifyIdentifier(callerName)) {
+            return null;
+        }
+        const args = callExpr.arguments;
+        if (args.length === 0) {
+            return null;
+        }
+        // First arg is route path
+        const routePath = this.extractStringValue(args[0]);
+        if (!routePath) {
+            return null;
+        }
+        // Extract options/handler
+        let handlerName = 'anonymous';
+        let authorization = createDefaultAuthorizationInfo();
+        // Check for options object: fastify.get('/path', { preHandler: [] }, handler)
+        if (args.length >= 2 && ts.isObjectLiteralExpression(args[1])) {
+            const options = args[1];
+            authorization = this.extractAuthFromOptions(options, sourceFile);
+            if (args.length >= 3) {
+                handlerName = this.extractHandlerName(args[2], sourceFile);
+            }
+        }
+        else if (args.length >= 2) {
+            handlerName = this.extractHandlerName(args[1], sourceFile);
+        }
+        authorization.classification = determineClassification(authorization);
+        const location = getLineAndColumn(sourceFile, callExpr.getStart(sourceFile));
+        return createEndpoint({
+            route: this.normalizePath(routePath),
+            method: parseHttpMethod(methodName.toUpperCase()) ?? HttpMethod.GET,
+            handlerName,
+            type: EndpointType.Fastify,
+            location: {
+                filePath,
+                line: location.line,
+                column: location.column,
+            },
+            authorization,
+        });
+    }
+    processRouteMethod(callExpr, sourceFile, filePath) {
+        if (!ts.isPropertyAccessExpression(callExpr.expression)) {
+            return null;
+        }
+        const propAccess = callExpr.expression;
+        if (propAccess.name.text !== 'route') {
+            return null;
+        }
+        const callerName = this.getCallerName(propAccess.expression);
+        if (!callerName || !this.isFastifyIdentifier(callerName)) {
+            return null;
+        }
+        const args = callExpr.arguments;
+        if (args.length === 0 || !ts.isObjectLiteralExpression(args[0])) {
+            return null;
+        }
+        const options = args[0];
+        let method = null;
+        let url = null;
+        let handlerName = 'handler';
+        const authorization = createDefaultAuthorizationInfo();
+        for (const prop of options.properties) {
+            if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name)) {
+                continue;
+            }
+            const propName = prop.name.text;
+            if (propName === 'method') {
+                const methodStr = this.extractStringValue(prop.initializer);
+                if (methodStr) {
+                    method = parseHttpMethod(methodStr.toUpperCase()) ?? null;
+                }
+            }
+            if (propName === 'url') {
+                url = this.extractStringValue(prop.initializer);
+            }
+            if (propName === 'handler') {
+                handlerName = this.extractHandlerName(prop.initializer, sourceFile);
+            }
+            if (propName === 'preHandler' || propName === 'onRequest') {
+                this.extractHooksAuth(prop.initializer, sourceFile, authorization);
+            }
+        }
+        if (!method || !url) {
+            return null;
+        }
+        authorization.classification = determineClassification(authorization);
+        const location = getLineAndColumn(sourceFile, callExpr.getStart(sourceFile));
+        return createEndpoint({
+            route: this.normalizePath(url),
+            method,
+            handlerName,
+            type: EndpointType.Fastify,
+            location: {
+                filePath,
+                line: location.line,
+                column: location.column,
+            },
+            authorization,
+        });
+    }
+    extractAuthFromOptions(options, sourceFile) {
+        const auth = createDefaultAuthorizationInfo();
+        for (const prop of options.properties) {
+            if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name)) {
+                continue;
+            }
+            const propName = prop.name.text;
+            if (propName === 'preHandler' || propName === 'onRequest') {
+                this.extractHooksAuth(prop.initializer, sourceFile, auth);
+            }
+        }
+        return auth;
+    }
+    extractHooksAuth(node, sourceFile, auth) {
+        const hooks = [];
+        if (ts.isArrayLiteralExpression(node)) {
+            for (const elem of node.elements) {
+                const hookName = this.extractHookName(elem, sourceFile);
+                if (hookName) {
+                    hooks.push(hookName);
+                }
+            }
+        }
+        else {
+            const hookName = this.extractHookName(node, sourceFile);
+            if (hookName) {
+                hooks.push(hookName);
+            }
+        }
+        auth.middlewareChain.push(...hooks);
+        for (const hook of hooks) {
+            if (this.isAuthHook(hook)) {
+                auth.isAuthenticated = true;
+                auth.guardNames.push(hook);
+            }
+        }
+    }
+    extractHookName(node, sourceFile) {
+        if (ts.isIdentifier(node)) {
+            return node.text;
+        }
+        if (ts.isPropertyAccessExpression(node)) {
+            return node.getText(sourceFile);
+        }
+        if (ts.isCallExpression(node)) {
+            if (ts.isIdentifier(node.expression)) {
+                return node.expression.text;
+            }
+            if (ts.isPropertyAccessExpression(node.expression)) {
+                return node.expression.getText(sourceFile);
+            }
+        }
+        return null;
+    }
+    isAuthHook(hookName) {
+        return AUTH_HOOK_PATTERNS.some((pattern) => pattern.test(hookName));
+    }
+    getCallerName(expression) {
+        if (ts.isIdentifier(expression)) {
+            return expression.text;
+        }
+        return null;
+    }
+    isFastifyIdentifier(name) {
+        if (FASTIFY_IDENTIFIERS.has(name.toLowerCase())) {
+            return true;
+        }
+        return name.toLowerCase().includes('fastify');
+    }
+    extractStringValue(node) {
+        if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+            return node.text;
+        }
+        return null;
+    }
+    extractHandlerName(node, sourceFile) {
+        if (ts.isIdentifier(node)) {
+            return node.text;
+        }
+        if (ts.isPropertyAccessExpression(node)) {
+            return node.getText(sourceFile);
+        }
+        if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+            return 'anonymous';
+        }
+        return 'unknown';
+    }
+    normalizePath(path) {
+        if (!path.startsWith('/')) {
+            path = '/' + path;
+        }
+        path = path.replace(/\/+/g, '/');
+        if (path.length > 1 && path.endsWith('/')) {
+            path = path.slice(0, -1);
+        }
+        return path;
+    }
+}
+//# sourceMappingURL=fastify-discoverer.js.map

package/dist/core/discovery/framework-detector.d.ts

@@ -0,0 +1,9 @@
+import { EndpointType } from '../models/endpoint-type.js';
+export interface DetectedFrameworks {
+    frameworks: EndpointType[];
+    confidence: Record<EndpointType, number>;
+}
+export declare class FrameworkDetector {
+    detect(projectPath: string): DetectedFrameworks;
+}
+//# sourceMappingURL=framework-detector.d.ts.map

package/dist/core/discovery/framework-detector.js

@@ -0,0 +1,61 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { EndpointType } from '../models/endpoint-type.js';
+export class FrameworkDetector {
+    detect(projectPath) {
+        const result = {
+            frameworks: [],
+            confidence: {
+                [EndpointType.Express]: 0,
+                [EndpointType.NestJS]: 0,
+                [EndpointType.Fastify]: 0,
+                [EndpointType.Koa]: 0,
+            },
+        };
+        // Read package.json
+        const packageJsonPath = path.join(projectPath, 'package.json');
+        if (!fs.existsSync(packageJsonPath)) {
+            return result;
+        }
+        let packageJson;
+        try {
+            const content = fs.readFileSync(packageJsonPath, 'utf-8');
+            packageJson = JSON.parse(content);
+        }
+        catch {
+            return result;
+        }
+        const deps = {
+            ...packageJson.dependencies,
+            ...packageJson.devDependencies,
+        };
+        // Check for Express
+        if (deps.express) {
+            result.confidence[EndpointType.Express] = 100;
+        }
+        // Check for NestJS
+        if (deps['@nestjs/core'] || deps['@nestjs/common']) {
+            result.confidence[EndpointType.NestJS] = 100;
+        }
+        // Check for Fastify
+        if (deps.fastify) {
+            result.confidence[EndpointType.Fastify] = 100;
+        }
+        // Check for Koa
+        if (deps.koa) {
+            result.confidence[EndpointType.Koa] = 100;
+            // If koa-router is present, increase confidence
+            if (deps['koa-router'] || deps['@koa/router']) {
+                result.confidence[EndpointType.Koa] = 100;
+            }
+        }
+        // Build frameworks list (those with confidence > 0)
+        for (const [framework, confidence] of Object.entries(result.confidence)) {
+            if (confidence > 0) {
+                result.frameworks.push(framework);
+            }
+        }
+        return result;
+    }
+}
+//# sourceMappingURL=framework-detector.js.map

package/dist/core/discovery/index.d.ts

@@ -0,0 +1,8 @@
+export * from './discoverer-interface.js';
+export * from './express-discoverer.js';
+export * from './nestjs-discoverer.js';
+export * from './fastify-discoverer.js';
+export * from './koa-discoverer.js';
+export * from './route-group-registry.js';
+export * from './framework-detector.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/discovery/index.js

@@ -0,0 +1,8 @@
+export * from './discoverer-interface.js';
+export * from './express-discoverer.js';
+export * from './nestjs-discoverer.js';
+export * from './fastify-discoverer.js';
+export * from './koa-discoverer.js';
+export * from './route-group-registry.js';
+export * from './framework-detector.js';
+//# sourceMappingURL=index.js.map

package/dist/core/discovery/koa-discoverer.d.ts

@@ -0,0 +1,16 @@
+import { EndpointDiscoverer } from './discoverer-interface.js';
+import { LoadedSourceFile } from '../analysis/source-file-loader.js';
+import { Endpoint } from '../models/endpoint.js';
+export declare class KoaDiscoverer implements EndpointDiscoverer {
+    readonly name = "Koa";
+    discover(file: LoadedSourceFile): Promise<Endpoint[]>;
+    private processRouteCall;
+    private buildAuthorizationInfo;
+    private isAuthMiddleware;
+    private getCallerName;
+    private isKoaRouterIdentifier;
+    private extractStringValue;
+    private extractMiddlewareName;
+    private normalizePath;
+}
+//# sourceMappingURL=koa-discoverer.d.ts.map

package/dist/core/discovery/koa-discoverer.js

@@ -0,0 +1,151 @@
+import * as ts from 'typescript';
+import { getLineAndColumn, findNodes } from '../analysis/source-file-loader.js';
+import { createEndpoint } from '../models/endpoint.js';
+import { EndpointType } from '../models/endpoint-type.js';
+import { HttpMethod, parseHttpMethod } from '../models/http-method.js';
+import { createDefaultAuthorizationInfo, determineClassification, } from '../models/authorization-info.js';
+const KOA_HTTP_METHODS = new Set([
+    'get', 'post', 'put', 'delete', 'patch', 'options', 'head', 'all'
+]);
+const KOA_ROUTER_IDENTIFIERS = new Set(['router', 'koaRouter', 'apiRouter']);
+const AUTH_MIDDLEWARE_PATTERNS = [
+    /authenticate/i,
+    /auth/i,
+    /jwt/i,
+    /passport/i,
+    /protect/i,
+    /guard/i,
+    /verify/i,
+];
+export class KoaDiscoverer {
+    name = 'Koa';
+    async discover(file) {
+        const endpoints = [];
+        const { sourceFile, filePath } = file;
+        const callExpressions = findNodes(sourceFile, ts.isCallExpression);
+        for (const callExpr of callExpressions) {
+            const endpoint = this.processRouteCall(callExpr, sourceFile, filePath);
+            if (endpoint) {
+                endpoints.push(endpoint);
+            }
+        }
+        return endpoints;
+    }
+    processRouteCall(callExpr, sourceFile, filePath) {
+        if (!ts.isPropertyAccessExpression(callExpr.expression)) {
+            return null;
+        }
+        const propAccess = callExpr.expression;
+        const methodName = propAccess.name.text.toLowerCase();
+        if (!KOA_HTTP_METHODS.has(methodName)) {
+            return null;
+        }
+        const callerName = this.getCallerName(propAccess.expression);
+        if (!callerName || !this.isKoaRouterIdentifier(callerName)) {
+            return null;
+        }
+        const args = callExpr.arguments;
+        if (args.length === 0) {
+            return null;
+        }
+        // First arg is route path
+        const routePath = this.extractStringValue(args[0]);
+        if (!routePath) {
+            return null;
+        }
+        // Extract middleware chain and handler
+        const middlewares = [];
+        let handlerName = 'anonymous';
+        for (let i = 1; i < args.length; i++) {
+            const arg = args[i];
+            const name = this.extractMiddlewareName(arg, sourceFile);
+            if (i === args.length - 1) {
+                // Last argument is the handler
+                handlerName = name ?? 'anonymous';
+            }
+            else if (name) {
+                middlewares.push(name);
+            }
+        }
+        // Build authorization info
+        const authorization = this.buildAuthorizationInfo(middlewares);
+        const location = getLineAndColumn(sourceFile, callExpr.getStart(sourceFile));
+        return createEndpoint({
+            route: this.normalizePath(routePath),
+            method: parseHttpMethod(methodName.toUpperCase()) ?? HttpMethod.GET,
+            handlerName,
+            type: EndpointType.Koa,
+            location: {
+                filePath,
+                line: location.line,
+                column: location.column,
+            },
+            authorization,
+        });
+    }
+    buildAuthorizationInfo(middlewares) {
+        const auth = createDefaultAuthorizationInfo();
+        auth.middlewareChain = middlewares;
+        for (const middleware of middlewares) {
+            if (this.isAuthMiddleware(middleware)) {
+                auth.isAuthenticated = true;
+                auth.guardNames.push(middleware);
+            }
+        }
+        auth.classification = determineClassification(auth);
+        return auth;
+    }
+    isAuthMiddleware(name) {
+        return AUTH_MIDDLEWARE_PATTERNS.some((pattern) => pattern.test(name));
+    }
+    getCallerName(expression) {
+        if (ts.isIdentifier(expression)) {
+            return expression.text;
+        }
+        return null;
+    }
+    isKoaRouterIdentifier(name) {
+        if (KOA_ROUTER_IDENTIFIERS.has(name)) {
+            return true;
+        }
+        const lower = name.toLowerCase();
+        return lower.includes('router') || lower.includes('koa');
+    }
+    extractStringValue(node) {
+        if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+            return node.text;
+        }
+        return null;
+    }
+    extractMiddlewareName(node, sourceFile) {
+        if (ts.isIdentifier(node)) {
+            return node.text;
+        }
+        if (ts.isPropertyAccessExpression(node)) {
+            return node.getText(sourceFile);
+        }
+        if (ts.isCallExpression(node)) {
+            if (ts.isIdentifier(node.expression)) {
+                return node.expression.text;
+            }
+            if (ts.isPropertyAccessExpression(node.expression)) {
+                return node.expression.getText(sourceFile);
+            }
+        }
+        if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+            return null; // Anonymous function
+        }
+        return null;
+    }
+    normalizePath(path) {
+        if (!path.startsWith('/')) {
+            path = '/' + path;
+        }
+        path = path.replace(/\/+/g, '/');
+        if (path.length > 1 && path.endsWith('/')) {
+            path = path.slice(0, -1);
+        }
+        return path;
+    }
+}
+//# sourceMappingURL=koa-discoverer.js.map

package/dist/core/discovery/nestjs-discoverer.d.ts

@@ -0,0 +1,16 @@
+import { EndpointDiscoverer } from './discoverer-interface.js';
+import { LoadedSourceFile } from '../analysis/source-file-loader.js';
+import { Endpoint } from '../models/endpoint.js';
+export declare class NestJSDiscoverer implements EndpointDiscoverer {
+    readonly name = "NestJS";
+    private authExtractor;
+    constructor();
+    discover(file: LoadedSourceFile): Promise<Endpoint[]>;
+    private processClass;
+    private processMethod;
+    private extractControllerPath;
+    private extractRoutePath;
+    private buildRoute;
+    private extractClassAuthInfo;
+}
+//# sourceMappingURL=nestjs-discoverer.d.ts.map