shokupan 0.7.0 → 0.10.0

package/dist/plugins/application/dashboard/static/tables.js

@@ -0,0 +1,92 @@
+
+// --- Table Config Helper ---
+function createTable(id, columns, placeholder = "No data available") {
+    return new Tabulator(id, {
+        layout: "fitColumns",
+        height: "300px",
+        placeholder: placeholder,
+        data: [],
+        columns: columns,
+        layoutColumnsOnNewData: true,
+    });
+}
+
+// --- Top Requests Table ---
+const topRequestsTable = createTable("#top-requests-table", [
+    { title: "Count", field: "count", align: "center", width: 100, sorter: "number" },
+    { title: "Method", field: "method", width: 110 },
+    { title: "URL", field: "url" },
+]);
+
+// --- Top Errors Table ---
+const topErrorsTable = createTable("#top-errors-table", [
+    { title: "Count", field: "count", align: "center", width: 100, sorter: "number" },
+    { title: "Error Message", field: "error" },
+]);
+
+// --- Failing Requests Table ---
+const failingRequestsTable = createTable("#failing-requests-table", [
+    { title: "Failures", field: "count", align: "center", width: 80, sorter: "number" },
+    { title: "Method", field: "method", width: 110 },
+    { title: "URL", field: "url" },
+]);
+
+// --- Slowest Requests Table ---
+const slowestRequestsTable = createTable("#slowest-requests-table", [
+    { title: "Duration (ms)", field: "duration", width: 130, sorter: "number", formatter: (cell) => printDuration(cell.getValue()) },
+    {
+        title: "URL", formatter: (cell) => {
+            const data = cell.getData() ?? {};
+            return data.method?.toUpperCase() + ": " + data.url;
+        }
+    },
+    {
+        title: "Status", field: "status", width: 100, align: "center", formatter: function (cell) {
+            const val = cell.getValue();
+            return `<span style="color: ${val >= 400 ? 'red' : 'green'}">${val}</span>`;
+        }
+    },
+    { title: "Time", field: "timestamp", width: 150, formatter: (cell) => new Date(cell.getValue()).toLocaleTimeString() }
+]);
+
+
+async function fetchTopStats() {
+    // Get request headers from global function if available
+    const headers = typeof getRequestHeaders !== 'undefined' ? getRequestHeaders() : {};
+
+    // Determine base path for API requests  
+    const basePath = window.location.pathname.endsWith('/') ? window.location.pathname.slice(0, -1) : window.location.pathname;
+    const url = basePath + '/';
+    const interval = document.getElementById('time-range-selector')?.value || '1m';
+    try {
+        // Top Requests
+        fetch(url + 'requests/top?interval=' + interval, { headers }).then(r => r.json()).then(d => {
+            if (d.top) topRequestsTable.setData(d.top);
+        });
+
+        // Top Errors
+        fetch(url + 'errors/top?interval=' + interval, { headers }).then(r => r.json()).then(d => {
+            if (d.top) topErrorsTable.setData(d.top);
+        });
+
+        // Failing Requests
+        fetch(url + 'requests/failing?interval=' + interval, { headers }).then(r => r.json()).then(d => {
+            if (d.top) failingRequestsTable.setData(d.top);
+        });
+
+        // Slowest Requests
+        fetch(url + 'requests/slowest?interval=' + interval, { headers }).then(r => r.json()).then(d => {
+            if (d.slowest) slowestRequestsTable.setData(d.slowest);
+        });
+
+    } catch (e) {
+        console.error("Failed to fetch top stats", e);
+    }
+}
+
+document.addEventListener("DOMContentLoaded", () => {
+    fetchTopStats();
+    // Refresh periodically
+    setInterval(fetchTopStats, 10000);
+});
+

package/dist/plugins/application/dashboard/static/tabs.js

@@ -0,0 +1,113 @@
+// --- Tabs Logic ---
+function switchTab(tabId) {
+    console.log('Switching to tab:', tabId);
+    // Update buttons
+    document.querySelectorAll('.tab-btn').forEach(btn => btn.classList.remove('active'));
+    // Find the button that was clicked
+    const btn = Array.from(document.querySelectorAll('.tab-btn')).find(b => b.getAttribute('onclick') === `switchTab('${tabId}')`);
+    if (btn) btn.classList.add('active');
+
+    // Update content
+    document.querySelectorAll('.tab-content').forEach(content => content.classList.remove('active'));
+    document.getElementById('tab-' + tabId).classList.add('active');
+
+    if (tabId === 'overview') {
+        if (typeof fetchTopStats === 'function') fetchTopStats();
+    }
+    else if (tabId === 'graph') {
+        initGraph();
+    }
+    else if (tabId === 'requests') {
+        if (typeof fetchRequests === 'function') fetchRequests();
+    }
+    else if (tabId === 'failures') {
+        fetchFailures();
+    }
+    else if (tabId === 'middleware') {
+        fetchMiddleware();
+    }
+    else if (tabId === 'registry') {
+        if (typeof fetchRegistry === 'function') fetchRegistry();
+    }
+}
+
+// Middleware fetch function
+async function fetchMiddleware() {
+    try {
+        const headers = getRequestHeaders ? getRequestHeaders() : {};
+        const basePath = window.location.pathname.endsWith('/') ? '' : window.location.pathname;
+        const url = basePath + (basePath.endsWith('/') ? 'middleware' : '/middleware');
+
+        const res = await fetch(url, { headers });
+        if (!res.ok) return;
+        const data = await res.json();
+
+        // Initialize or update table
+        if (!window.middlewareTable) {
+            window.middlewareTable = new Tabulator("#middleware-table-container", {
+                layout: "fitColumns",
+                height: "500px",
+                placeholder: "No middleware executions tracked",
+                data: data.middleware || [],
+                columns: [
+                    {
+                        title: "Timestamp", field: "timestamp", width: 180, formatter: function (cell) {
+                            return new Date(cell.getValue()).toLocaleString();
+                        }
+                    },
+                    {
+                        title: "Name", field: "name", width: 200,
+                        formatter: function (cell) {
+                            const row = cell.getRow().getData();
+                            const isBuiltin = row.metadata?.isBuiltin;
+                            const pluginName = row.metadata?.pluginName;
+                            let badge = '';
+                            if (isBuiltin) {
+                                badge = ' <span style="background: #059669; color: white; padding: 2px 6px; border-radius: 4px; font-size: 0.7em;">BUILTIN</span>';
+                            }
+                            const plugin = pluginName ? ` <span style="color: #6ee7b7;">[${pluginName}]</span>` : '';
+                            return cell.getValue() + badge + plugin;
+                        }
+                    },
+                    { title: "Path", field: "path", headerFilter: "input" },
+                    {
+                        title: "Duration (ms)", field: "duration", width: 120,
+                        formatter: (cell) => cell.getValue() ? cell.getValue().toFixed(2) : 'N/A'
+                    },
+                    {
+                        title: "Status", field: "error", width: 100, formatter: function (cell) {
+                            const error = cell.getValue();
+                            if (error) {
+                                return '<span style="color: #ef4444; font-weight: bold;">ERROR</span>';
+                            }
+                            return '<span style="color: #22c55e; font-weight: bold;">OK</span>';
+                        }
+                    }
+                ],
+                initialSort: [
+                    { column: "timestamp", dir: "desc" }
+                ]
+            });
+        } else {
+            window.middlewareTable.replaceData(data.middleware || []);
+        }
+    } catch (e) {
+        console.error("Failed to fetch middleware", e);
+    }
+}
+
+async function fetchFailures() {
+    try {
+        const headers = getRequestHeaders ? getRequestHeaders() : {};
+        // Handle relative path issue
+        const basePath = window.location.pathname.endsWith('/') ? '' : window.location.pathname;
+        const url = basePath + (basePath.endsWith('/') ? 'failures' : '/failures');
+
+        const res = await fetch(url, { headers });
+        if (!res.ok) return;
+        const data = await res.json();
+        failuresTable.replaceData(data.failures);
+    } catch (e) {
+        console.error("Failed to fetch failures", e);
+    }
+}

package/dist/plugins/application/dashboard/static/tabulator.css

@@ -0,0 +1,118 @@
+/* Tabulator Theme Overrides - Merged with Layout */
+.tabulator {
+    height: 100%;
+    width: 100%;
+    background-color: var(--bg-card);
+    border: 1px solid var(--card-border);
+    color: var(--text-primary);
+}
+
+/* Header */
+.tabulator .tabulator-header {
+    background-color: var(--bg-card);
+    border-top: 0;
+    border-bottom: 2px solid var(--table-header-border-color);
+    color: var(--primary);
+    font-weight: bold;
+}
+
+.tabulator .tabulator-header .tabulator-col {
+    background-color: var(--bg-card);
+    border-right: 1px solid var(--card-border);
+}
+
+.tabulator .tabulator-header .tabulator-col:hover {
+    background-color: var(--bg-primary);
+}
+
+.tabulator .tabulator-header .tabulator-col-content {
+    padding: 12px;
+}
+
+/* Sortable Columns */
+.tabulator .tabulator-header .tabulator-col.tabulator-sortable[aria-sort=none] .tabulator-col-content .tabulator-col-sorter {
+    color: var(--text-secondary);
+}
+
+.tabulator .tabulator-header .tabulator-col.tabulator-sortable.tabulator-col-sorter-element:hover {
+    background-color: var(--bg-primary);
+}
+
+/* Filter Inputs */
+.tabulator .tabulator-header .tabulator-col .tabulator-header-filter input {
+    background-color: var(--bg-primary);
+    color: var(--text-primary);
+    border: 1px solid var(--card-border);
+}
+
+.tabulator .tabulator-header .tabulator-col .tabulator-header-filter input:focus {
+    background-color: var(--bg-secondary);
+    color: var(--text-primary);
+    border-color: var(--primary);
+    outline: none;
+}
+
+/* Rows */
+.tabulator .tabulator-row {
+    background-color: var(--bg-card);
+    border-bottom: 1px solid var(--card-border);
+    color: var(--text-primary);
+    transition: background-color 100ms ease;
+}
+
+/* Higher specificity to override Tabulator default themes */
+.tabulator .tabulator-row.tabulator-row-even,
+.tabulator-row.tabulator-row-even {
+    background-color: var(--bg-primary) !important;
+}
+
+.tabulator .tabulator-row.tabulator-row-odd,
+.tabulator-row.tabulator-row-odd {
+    background-color: var(--bg-card) !important;
+}
+
+.tabulator .tabulator-row.tabulator-selected {
+    background-color: var(--bg-primary) !important;
+    color: var(--text-primary);
+}
+
+.tabulator .tabulator-row:hover {
+    background-color: var(--bg-primary) !important;
+    color: var(--text-primary);
+    cursor: pointer;
+}
+
+/* Cells */
+.tabulator .tabulator-row .tabulator-cell {
+    border-right: 1px solid var(--card-border);
+    padding: 10px;
+    align-content: center;
+}
+
+/* Footer / Pagination */
+.tabulator .tabulator-footer {
+    background-color: var(--bg-card);
+    border-top: 2px solid var(--table-header-border-color);
+}
+
+.tabulator .tabulator-footer .tabulator-page {
+    background-color: var(--bg-primary);
+    color: var(--text-primary);
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+}
+
+.tabulator .tabulator-footer .tabulator-page:hover {
+    background-color: var(--table-header-border-color);
+    color: var(--text-primary);
+}
+
+.tabulator .tabulator-footer .tabulator-page.active {
+    background-color: var(--primary);
+    color: var(--bg-card);
+}
+
+/* Sorting Icons */
+.tabulator .tabulator-header .tabulator-col .tabulator-col-content .tabulator-arrow {
+    border-bottom-color: var(--text-secondary);
+}

package/dist/plugins/application/dashboard/static/theme.css

@@ -0,0 +1,128 @@
+:root {
+    /* Raw Palette - Dark (Now Default) */
+    --palette-dark-primary: #FFB380;
+    /* Warm Filament */
+    --palette-dark-secondary: #7B5E7B;
+    /* Yeast Purple */
+    --palette-dark-accent: #D6D3D1;
+    /* Flour Dust */
+    --palette-dark-bg: #1A1614;
+    /* Oven Depth */
+    --palette-dark-card: #2A2421;
+
+    --palette-dark-header: rgb(39, 27, 19);
+    /* Proofing Drawer */
+
+    /* Universal defaults (tokens) */
+    --shokupan-font: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
+
+    /* Theme Variables - Enforced Dark Mode */
+    --bg-primary: var(--palette-dark-bg);
+    --bg-secondary: var(--palette-dark-card);
+    --bg-card: var(--palette-dark-card);
+    --bg-header: var(--palette-dark-header);
+
+    --text-primary: #F0F0F0;
+    --text-secondary: var(--palette-dark-accent);
+    --text-muted: rgba(214, 211, 209, 0.5);
+
+    --primary: var(--palette-dark-primary);
+    --secondary: var(--palette-dark-secondary);
+    --accent: var(--palette-dark-accent);
+
+    --border-color: rgba(214, 211, 209, 0.2);
+    --card-border: rgba(214, 211, 209, 0.2);
+
+    --table-header-border-color: rgba(214, 211, 209, 0.2);
+
+    --link-color: var(--palette-dark-primary);
+    --link-hover: #FFCBA0;
+
+    --button-bg: var(--palette-dark-primary);
+    --button-text: #1A1614;
+}
+
+::-webkit-scrollbar {
+    width: 8px;
+    height: 8px;
+    background-color: var(--bg-primary);
+}
+
+::-webkit-scrollbar-thumb {
+    border-radius: 10px;
+    background-color: var(--primary);
+    box-shadow: inset 0 0 6px rgba(0, 0, 0, 0.3);
+}
+
+::-webkit-scrollbar-track {
+    border-radius: 10px;
+    background-color: var(--bg-secondary);
+}
+
+::-webkit-scrollbar-corner {
+    box-shadow: inset 0 0 6px rgba(0, 0, 0, 0.3);
+}
+
+.badge-SEND {
+    background: rgba(59, 130, 246, 0.15);
+    color: #60a5fa;
+    border: 1px solid rgba(59, 130, 246, 0.3);
+}
+
+.badge-RECV {
+    background: rgba(16, 185, 129, 0.15);
+    color: #34d399;
+    border: 1px solid rgba(16, 185, 129, 0.3);
+}
+
+.badge-GET {
+    background: #0f172a;
+    color: #3b82f6;
+    border: 1px solid #3b82f6;
+}
+
+.badge-POST {
+    background: #0f172a;
+    color: #22c55e;
+    border: 1px solid #22c55e;
+}
+
+.badge-PUT {
+    background: #0f172a;
+    color: #eab308;
+    border: 1px solid #eab308;
+}
+
+.badge-PATCH {
+    background: #0f172a;
+    color: #08d3ea;
+    border: 1px solid #08eae6;
+}
+
+.badge-HEAD {
+    background: #0f172a;
+    color: #e3ea08;
+    border: 1px solid #e3ea08;
+}
+
+.badge-OPTIONS {
+    background: #0f172a;
+    color: #838383;
+    border: 1px solid #838383;
+}
+
+.badge-DELETE {
+    background: #0f172a;
+    color: #ef4444;
+    border: 1px solid #ef4444;
+}
+
+.badge-ROUTER {
+    background: #334155;
+    color: #f8fafc;
+}
+
+.badge-CONTROLLER {
+    background: #475569;
+    color: #f8fafc;
+}

package/dist/plugins/application/graphql-apollo.d.ts

@@ -0,0 +1,33 @@
+import { ApolloServer } from '@apollo/server';
+import { ShokupanRouter } from '../../router';
+import { Shokupan } from '../../shokupan';
+import { ShokupanPlugin, ShokupanPluginOptions } from '../../util/types';
+export interface GraphQLPluginOptions {
+    /**
+     * Path to mount the GraphQL endpoint to.
+     * @default '/graphql'
+     */
+    path?: string;
+    /**
+     * GraphQL Type Definitions
+     */
+    typeDefs: any;
+    /**
+     * GraphQL Resolvers
+     */
+    resolvers: any;
+    /**
+     * Optional Apollo Server configuration
+     */
+    apolloConfig?: Omit<ConstructorParameters<typeof ApolloServer>[0], 'typeDefs' | 'resolvers'>;
+}
+/**
+ * GraphQL Apollo Server Plugin for Shokupan.
+ * Enables serving GraphQL APIs using Apollo Server 4.
+ */
+export declare class GraphQLApolloPlugin extends ShokupanRouter<any> implements ShokupanPlugin {
+    private pluginOptions;
+    private apolloServer;
+    constructor(pluginOptions: GraphQLPluginOptions);
+    onInit(app: Shokupan, options?: ShokupanPluginOptions): Promise<void>;
+}

package/dist/plugins/application/graphql-yoga.d.ts

@@ -0,0 +1,25 @@
+import { YogaServerOptions } from 'graphql-yoga';
+import { ShokupanRouter } from '../../router';
+import { Shokupan } from '../../shokupan';
+import { ShokupanPlugin, ShokupanPluginOptions } from '../../util/types';
+export interface GraphQLYogaPluginOptions {
+    /**
+     * Path to mount the GraphQL endpoint to.
+     * @default '/graphql'
+     */
+    path?: string;
+    /**
+     * Yoga Server configuration
+     */
+    yogaConfig: YogaServerOptions<any, any>;
+}
+/**
+ * GraphQL Yoga Plugin for Shokupan.
+ * Enables serving GraphQL APIs using GraphQL Yoga.
+ */
+export declare class GraphQLYogaPlugin extends ShokupanRouter<any> implements ShokupanPlugin {
+    private pluginOptions;
+    private yoga;
+    constructor(pluginOptions: GraphQLYogaPluginOptions);
+    onInit(app: Shokupan, options?: ShokupanPluginOptions): Promise<void>;
+}

package/dist/plugins/application/openapi/analyzer.d.ts

@@ -1,133 +1,27 @@
+import { ApplicationInstance } from './analyzer.impl';
+export type { ApplicationInstance, RouteInfo } from './analyzer.impl';
 /**
- * Route information extracted from AST
- */
-export interface RouteInfo {
-    method: string;
-    path: string;
-    handlerName?: string;
-    handlerSource?: string;
-    requestTypes?: {
-        body?: any;
-        query?: Record<string, string>;
-        params?: Record<string, string>;
-        headers?: Record<string, string>;
-    };
-    responseType?: string;
-    responseSchema?: any;
-    summary?: string;
-    description?: string;
-    tags?: string[];
-    operationId?: string;
-}
-/**
- * Dependency information
- */
-interface DependencyInfo {
-    packageName: string;
-    version?: string;
-    importPath: string;
-    isExternal: boolean;
-}
-/**
- * Application/Router instance found in code
- */
-export interface ApplicationInstance {
-    name: string;
-    filePath: string;
-    className: 'Shokupan' | 'ShokupanRouter' | 'Controller';
-    routes: RouteInfo[];
-    mounted: MountInfo[];
-}
-interface MountInfo {
-    prefix: string;
-    target: string;
-    dependency?: DependencyInfo;
-}
-/**
- * Main analyzer class
+ * OpenAPI Analyzer Wrapper.
+ *
+ * This class wraps the actual OpenAPIAnalyzer implementation to facilitate
+ * lazy loading of the 'typescript' peer dependency. The actual implementation
+ * and the 'typescript' module are only loaded when `analyze()` is called.
  */
 export declare class OpenAPIAnalyzer {
     private rootDir;
-    private files;
-    private applications;
-    private program?;
     private entrypoint?;
+    private analyzerImpl;
     constructor(rootDir: string, entrypoint?: string);
     /**
-     * Main analysis entry point
-     */
-    /**
-     * Main analysis entry point
+     * Main analysis entry point.
+     * Dynamically imports the implementation and runs the analysis.
      */
     analyze(): Promise<{
         applications: ApplicationInstance[];
     }>;
     /**
-     * Recursively scan directory for TypeScript/JavaScript files
-     */
-    private scanDirectory;
-    /**
-     * Process source maps to reconstruct TypeScript
-     */
-    private processSourceMaps;
-    /**
-     * Parse TypeScript files and create AST
-     */
-    private parseTypeScriptFiles;
-    /**
-     * Find all Shokupan/ShokupanRouter instances
-     */
-    private findApplications;
-    /**
-     * Visit AST node to find application instances
-     */
-    private visitNode;
-    /**
-     * Extract route information from applications
-     */
-    private extractRoutes;
-    /**
-     * Extract routes from a Controller class
-     */
-    private extractRoutesFromController;
-    /**
-     * Extract routes from a specific file
-     */
-    private extractRoutesFromFile;
-    /**
-     * Extract route information from a route call (e.g., app.get('/path', handler))
-     */
-    private extractRouteFromCall;
-    /**
-     * Analyze a route handler to extract type information
-     */
-    private analyzeHandler;
-    /**
-     * Convert an Expression node to an OpenAPI schema (best effort)
-     */
-    private convertExpressionToSchema;
-    /**
-     * Check if an expression is a call to ctx.body()
-     */
-    private isCtxBodyCall;
-    /**
-     * Convert a TypeScript TypeNode to an OpenAPI schema
-     */
-    private convertTypeNodeToSchema;
-    /**
-     * Extract mount information from mount call
-     */
-    private extractMountFromCall;
-    /**
-     * Check if a reference is to an external dependency
-     */
-    private checkIfExternalDependency;
-    /**
-     * Get package version from package.json
-     */
-    private getPackageVersion;
-    /**
-     * Generate OpenAPI specification
+     * Generate OpenAPI specification.
+     * Must be called after analyze().
      */
     generateOpenAPISpec(): any;
 }
@@ -135,4 +29,3 @@ export declare class OpenAPIAnalyzer {
  * Analyze a directory and generate OpenAPI spec
  */
 export declare function analyzeDirectory(directory: string): Promise<any>;
-export {};