@linyjs/plugin-docs 0.1.0

package/examples/analytics-plugin/dist/index.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyticsClientModule = exports.analyticsServerModule = void 0;
+const server_1 = require("./server");
+const client_1 = require("./client");
+var server_2 = require("./server");
+Object.defineProperty(exports, "analyticsServerModule", { enumerable: true, get: function () { return server_2.analyticsServerModule; } });
+var client_2 = require("./client");
+Object.defineProperty(exports, "analyticsClientModule", { enumerable: true, get: function () { return client_2.analyticsClientModule; } });
+// 默认导出两个模块（同时适用于服务端和客户端）
+const analyticsPlugin = {
+    server: server_1.analyticsServerModule,
+    client: client_1.analyticsClientModule
+};
+exports.default = analyticsPlugin;
+/**
+ * @module @linyjs/example-analytics-plugin
+ *
+ * Analytics Plugin Example
+ * ===============
+ *
+ * Features:
+ * - 📊 Real-time analytics dashboard
+ * - 📈 User behavior tracking
+ * - 🔄 Hourly data aggregation (cron job)
+ * - 📈 User retention analysis
+ * - 🌊 Live metrics monitoring
+ * - 📱 Responsive web interface
+ *
+ * Server-side:
+ * - AnalyticsService: Core analytics logic
+ * - AnalyticsController: REST API endpoints
+ * - AnalyticsCronService: Background aggregation task
+ *
+ * Client-side:
+ * - AnalyticsDashboard: Main dashboard UI
+ * - AnalyticsTracker: Event tracking utility
+ * - Visual charts and metrics display
+ *
+ * API Endpoints:
+ * - POST /api/analytics/track - Track events
+ * - GET /api/analytics/summary - Get analytics summary
+ * - GET /api/analytics/realtime - Get real-time stats
+ * - GET /api/analytics/retention - Get user retention
+ * - POST /api/analytics/aggregate - Manual aggregation
+ *
+ * Usage:
+ *
+ * 1. Include in your Linyjs app:
+ * ```typescript
+ * import { analyticsServerModule } from '@linyjs/example-analytics-plugin';
+ *
+ * // In server config
+ * plugins: [analyticsServerModule]
+ * ```
+ *
+ * 2. Track events from client:
+ * ```javascript
+ * fetch('/api/analytics/track', {
+ *   method: 'POST',
+ *   headers: { 'Content-Type': 'application/json' },
+ *   body: JSON.stringify({
+ *     eventName: 'page_view',
+ *     userId: 'user123',
+ *     data: { page: '/home' }
+ *   })
+ * });
+ * ```
+ *
+ * 3. View analytics dashboard:
+ * Access at `/analytics` route in your app
+ */ 

package/examples/analytics-plugin/dist/server/index.d.ts

@@ -0,0 +1,119 @@
+import type { IModule } from '@linyjs/server-module-interface';
+/**
+ * 分析数据服务 - 收集和聚合应用使用数据
+ */
+declare class AnalyticsService {
+    private metrics;
+    private users;
+    /**
+     * 记录用户行为事件
+     */
+    trackEvent(eventName: string, userId: string, data: any): Promise<{
+        success: boolean;
+        eventId: number;
+    }>;
+    /**
+     * 获取指定时间范围内的统计汇总
+     */
+    getAnalytics(startDate: string, endDate: string): Promise<any>;
+    /**
+     * 获取实时在线用户数（模拟）
+     */
+    getRealTimeStats(): Promise<{
+        onlineUsers: number;
+        currentEvents: number;
+        serverTime: string;
+    }>;
+    /**
+     * 定时聚合任务 - 每小时运行一次
+     */
+    runHourlyAggregation(): Promise<{
+        period: string;
+        summary: any;
+    }>;
+    /**
+     * 用户留存率分析
+     */
+    getUserRetention(days?: number): Promise<any>;
+}
+/**
+ * 分析控制器 - 提供API接口
+ */
+declare class AnalyticsController {
+    private analyticsService;
+    constructor();
+    getRoutes(): ({
+        method: "POST";
+        path: string;
+        middlewares: never[];
+        responseType: "json";
+        handler: (params: any, ctx: any) => Promise<{
+            success: boolean;
+            data: {
+                success: boolean;
+                eventId: number;
+            };
+            status?: undefined;
+        } | {
+            status: number;
+            data: {
+                error: any;
+            };
+            success?: undefined;
+        }>;
+    } | {
+        method: "GET";
+        path: string;
+        middlewares: never[];
+        responseType: "json";
+        handler: (params: any, ctx: any) => Promise<any>;
+    } | {
+        method: "POST";
+        path: string;
+        middlewares: never[];
+        responseType: "json";
+        handler: (params: any, ctx: any) => Promise<{
+            success: boolean;
+            data: {
+                period: string;
+                summary: any;
+            };
+            status?: undefined;
+        } | {
+            status: number;
+            data: {
+                error: any;
+            };
+            success?: undefined;
+        }>;
+    })[];
+}
+/**
+ * 定时任务服务
+ */
+declare class AnalyticsCronService {
+    private analyticsService;
+    private intervalId;
+    constructor();
+    /**
+     * 启动定时聚合任务
+     */
+    startHourlyAggregation(): void;
+    /**
+     * 停止定时聚合任务
+     */
+    stopHourlyAggregation(): void;
+    /**
+     * 插件启动时调用
+     */
+    onModuleInit(): void;
+    /**
+     * 插件销毁时调用
+     */
+    onModuleDestroy(): void;
+}
+/**
+ * 服务端模块
+ */
+export declare const analyticsServerModule: IModule;
+export { AnalyticsService, AnalyticsController, AnalyticsCronService };

package/examples/analytics-plugin/dist/server/index.js

@@ -0,0 +1,313 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalyticsCronService = exports.AnalyticsController = exports.AnalyticsService = exports.analyticsServerModule = void 0;
+/**
+ * 分析数据服务 - 收集和聚合应用使用数据
+ */
+class AnalyticsService {
+    constructor() {
+        this.metrics = new Map();
+        this.users = new Map();
+    }
+    /**
+     * 记录用户行为事件
+     */
+    async trackEvent(eventName, userId, data) {
+        const event = {
+            id: Date.now(),
+            eventName,
+            userId,
+            timestamp: new Date().toISOString(),
+            data
+        };
+        if (!this.metrics.has(eventName)) {
+            this.metrics.set(eventName, []);
+        }
+        this.metrics.get(eventName).push(event);
+        return { success: true, eventId: event.id };
+    }
+    /**
+     * 获取指定时间范围内的统计汇总
+     */
+    async getAnalytics(startDate, endDate) {
+        const start = new Date(startDate);
+        const end = new Date(endDate);
+        const result = {
+            totalEvents: 0,
+            eventsByDay: {},
+            eventTypes: {},
+            activeUsers: 0,
+            topEvents: []
+        };
+        // 统计各类事件
+        for (const [eventName, events] of this.metrics.entries()) {
+            const filtered = events.filter(event => {
+                const eventDate = new Date(event.timestamp);
+                return eventDate >= start && eventDate <= end;
+            });
+            if (filtered.length > 0) {
+                result.eventTypes[eventName] = filtered.length;
+                result.totalEvents += filtered.length;
+                // 统计每日事件
+                filtered.forEach(event => {
+                    const day = event.timestamp.split('T')[0];
+                    result.eventsByDay[day] = (result.eventsByDay[day] || 0) + 1;
+                });
+                // 记录活跃用户
+                const uniqueUsers = new Set(filtered.map(e => e.userId));
+                result.activeUsers = Math.max(result.activeUsers, uniqueUsers.size);
+            }
+        }
+        // 计算热门事件
+        result.topEvents = Object.entries(result.eventTypes)
+            .sort(([, a], [, b]) => b - a)
+            .slice(0, 10)
+            .map(([name, count]) => ({ name, count }));
+        return result;
+    }
+    /**
+     * 获取实时在线用户数（模拟）
+     */
+    async getRealTimeStats() {
+        // 模拟实时数据
+        const onlineUsers = Math.floor(Math.random() * 100) + 50;
+        const currentEvents = Math.floor(Math.random() * 20) + 5;
+        return {
+            onlineUsers,
+            currentEvents,
+            serverTime: new Date().toISOString()
+        };
+    }
+    /**
+     * 定时聚合任务 - 每小时运行一次
+     */
+    async runHourlyAggregation() {
+        const now = new Date();
+        const hourStart = new Date(now.getFullYear(), now.getMonth(), now.getDate(), now.getHours());
+        const hourEnd = new Date(hourStart.getTime() + 60 * 60 * 1000);
+        const hourData = await this.getAnalytics(hourStart.toISOString(), hourEnd.toISOString());
+        // 这里可以将聚合数据保存到数据库，现在只返回
+        return {
+            period: `${hourStart.toISOString()} to ${hourEnd.toISOString()}`,
+            summary: hourData
+        };
+    }
+    /**
+     * 用户留存率分析
+     */
+    async getUserRetention(days = 7) {
+        const now = new Date();
+        const retentionData = {
+            dayIntervals: [],
+            newUsers: [],
+            returningUsers: []
+        };
+        // 模拟留存率数据
+        for (let i = 0; i < days; i++) {
+            const date = new Date(now.getTime() - i * 24 * 60 * 60 * 1000);
+            const dayKey = date.toISOString().split('T')[0];
+            retentionData.dayIntervals.push(dayKey);
+            retentionData.newUsers.push(Math.floor(Math.random() * 50) + 10);
+            retentionData.returningUsers.push(Math.floor(Math.random() * 30) + 5);
+        }
+        // 计算留存率
+        retentionData.retentionRates = retentionData.returningUsers.map((returning, index) => {
+            const newUsers = retentionData.newUsers[index] || 1;
+            return ((returning / newUsers) * 100).toFixed(1);
+        });
+        return retentionData;
+    }
+}
+exports.AnalyticsService = AnalyticsService;
+/**
+ * 分析控制器 - 提供API接口
+ */
+class AnalyticsController {
+    constructor() {
+        this.analyticsService = new AnalyticsService();
+    }
+    getRoutes() {
+        return [
+            // POST /api/analytics/track - 记录事件
+            {
+                method: 'POST',
+                path: '/api/analytics/track',
+                middlewares: [],
+                responseType: 'json',
+                handler: async (params, ctx) => {
+                    try {
+                        const { eventName, userId, data } = params.body;
+                        if (!eventName || !userId) {
+                            return {
+                                status: 400,
+                                data: { error: 'eventName and userId are required' }
+                            };
+                        }
+                        const result = await this.analyticsService.trackEvent(eventName, userId, data);
+                        return { success: true, data: result };
+                    }
+                    catch (error) {
+                        return {
+                            status: 500,
+                            data: { error: error.message }
+                        };
+                    }
+                }
+            },
+            // GET /api/analytics/summary - 获取分析摘要
+            {
+                method: 'GET',
+                path: '/api/analytics/summary',
+                middlewares: [],
+                responseType: 'json',
+                handler: async (params, ctx) => {
+                    var _a, _b;
+                    try {
+                        const startDate = ((_a = params.query) === null || _a === void 0 ? void 0 : _a.start) || new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
+                        const endDate = ((_b = params.query) === null || _b === void 0 ? void 0 : _b.end) || new Date().toISOString();
+                        const result = await this.analyticsService.getAnalytics(startDate, endDate);
+                        return result;
+                    }
+                    catch (error) {
+                        return {
+                            status: 500,
+                            data: { error: error.message }
+                        };
+                    }
+                }
+            },
+            // GET /api/analytics/realtime - 获取实时统计
+            {
+                method: 'GET',
+                path: '/api/analytics/realtime',
+                middlewares: [],
+                responseType: 'json',
+                handler: async (params, ctx) => {
+                    try {
+                        const result = await this.analyticsService.getRealTimeStats();
+                        return result;
+                    }
+                    catch (error) {
+                        return {
+                            status: 500,
+                            data: { error: error.message }
+                        };
+                    }
+                }
+            },
+            // GET /api/analytics/retention - 用户留存分析
+            {
+                method: 'GET',
+                path: '/api/analytics/retention',
+                middlewares: [],
+                responseType: 'json',
+                handler: async (params, ctx) => {
+                    var _a;
+                    try {
+                        const days = parseInt(((_a = params.query) === null || _a === void 0 ? void 0 : _a.days) || '7');
+                        const result = await this.analyticsService.getUserRetention(days);
+                        return result;
+                    }
+                    catch (error) {
+                        return {
+                            status: 500,
+                            data: { error: error.message }
+                        };
+                    }
+                }
+            },
+            // POST /api/analytics/aggregate - 手动触发聚合 (管理员用)
+            {
+                method: 'POST',
+                path: '/api/analytics/aggregate',
+                middlewares: [],
+                responseType: 'json',
+                handler: async (params, ctx) => {
+                    try {
+                        const result = await this.analyticsService.runHourlyAggregation();
+                        return { success: true, data: result };
+                    }
+                    catch (error) {
+                        return {
+                            status: 500,
+                            data: { error: error.message }
+                        };
+                    }
+                }
+            }
+        ];
+    }
+}
+exports.AnalyticsController = AnalyticsController;
+/**
+ * 定时任务服务
+ */
+class AnalyticsCronService {
+    constructor() {
+        this.intervalId = null;
+        this.analyticsService = new AnalyticsService();
+    }
+    /**
+     * 启动定时聚合任务
+     */
+    startHourlyAggregation() {
+        // 每小时执行一次聚合
+        this.intervalId = setInterval(async () => {
+            try {
+                const result = await this.analyticsService.runHourlyAggregation();
+                console.log('Analytics aggregation completed:', result.period);
+            }
+            catch (error) {
+                console.error('Analytics aggregation failed:', error);
+            }
+        }, 60 * 60 * 1000); // 1小时
+        console.log('Started analytics hourly aggregation');
+    }
+    /**
+     * 停止定时聚合任务
+     */
+    stopHourlyAggregation() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+            console.log('Stopped analytics hourly aggregation');
+        }
+    }
+    /**
+     * 插件启动时调用
+     */
+    onModuleInit() {
+        this.startHourlyAggregation();
+    }
+    /**
+     * 插件销毁时调用
+     */
+    onModuleDestroy() {
+        this.stopHourlyAggregation();
+    }
+}
+exports.AnalyticsCronService = AnalyticsCronService;
+/**
+ * 服务端模块
+ */
+exports.analyticsServerModule = {
+    name: 'analyticsServer',
+    serviceDefs: [
+        {
+            serviceTag: 'analyticsController',
+            serviceImpl: AnalyticsController,
+            meta: { usageType: 'controller' }
+        },
+        {
+            serviceTag: 'analyticsCron',
+            serviceImpl: AnalyticsCronService,
+            meta: {
+                usageType: 'service',
+                lifecycle: {
+                    init: 'onModuleInit',
+                    destroy: 'onModuleDestroy'
+                }
+            }
+        }
+    ]
+};

package/examples/analytics-plugin/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@linyjs/example-analytics-plugin",
+  "version": "1.0.0",
+  "description": "Analytics plugin example - Dashboard and metrics collection for Linyjs apps",
+  "main": "src/index.ts",
+  "scripts": {
+    "dev": "tsc --watch",
+    "build": "tsc",
+    "serve": "node dist/index.js",
+    "test": "echo \"No tests yet\""
+  },
+  "keywords": ["linyjs", "example", "plugin", "analytics", "dashboard"],
+  "author": "Linyjs Team",
+  "license": "MIT",
+  "peerDependencies": {
+    "@linyjs/server-module-interface": "0.0.3",
+    "@linyjs/client-module-interface": "0.0.3",
+    "@linyjs/ui-slots-interface": "0.0.3"
+  },
+  "devDependencies": {
+    "@linyjs/server-module-interface": "0.0.3",
+    "@linyjs/client-module-interface": "0.0.3"
+  },
+  "linyjs": {
+    "compatibleVersions": ["0.8.x"],
+    "type": "plugin"
+  }
+}