mira-app-core 1.0.0

package/src/LibraryStorage.ts

@@ -0,0 +1,55 @@
+import { LibraryServerDataSQLite } from "./LibraryServerDataSQLite";
+import { MiraBackend } from "./ServerExample";
+import { getLibrarysJson } from './LibraryList';
+
+export class LibraryStorage {
+  libraryServices: LibraryServerDataSQLite[] = [];
+  backend: MiraBackend;
+
+  constructor(backend: MiraBackend) {
+    this.backend = backend;
+  }
+
+  all(): LibraryServerDataSQLite[] {
+    return this.libraryServices;
+  }
+
+  async load(dbConfig: Record<string, any>): Promise<LibraryServerDataSQLite> {
+    const dbServer = new LibraryServerDataSQLite(dbConfig, {webSocketServer: this.backend.webSocketServer, httpServer: this.backend.httpServer} );
+    await dbServer.initialize();
+    this.libraryServices.push(dbServer);
+    return dbServer;
+  }
+
+  async loadAll(): Promise<number> {
+    let success = 0;
+    for (const library of await getLibrarysJson(this.backend.dataPath)) {
+      try {
+        console.log('loading library ', library.name);
+        await this.load(library);
+        success++;
+      } catch(err){
+        console.log(err)
+      }
+    }
+    return success;
+  }
+
+  get(libraryId: string): LibraryServerDataSQLite | undefined {
+    return this.libraryServices.find(
+      (library) => library.getLibraryId() === libraryId
+    );
+  }
+
+  exists(libraryId: string): boolean {
+    return this.libraryServices.some(
+      (library) => library.getLibraryId() === libraryId
+    );
+  }
+
+  find(libraryId: string): LibraryServerDataSQLite | undefined {
+    return this.libraryServices.find((library) => library.getLibraryId() === libraryId);
+  }
+
+
+}

package/src/MessageHandler.ts

@@ -0,0 +1,41 @@
+import { LibraryServerDataSQLite } from './LibraryServerDataSQLite';
+import { WebSocket } from 'ws';
+import { WebSocketMessage } from './WebSocketRouter';
+
+export abstract class MessageHandler {
+  constructor(
+    protected dbService: LibraryServerDataSQLite,
+    protected ws: WebSocket,
+    protected message: WebSocketMessage
+  ) {}
+
+  abstract handle(): Promise<void>;
+
+  protected sendResponse(data: Record<string, any>): void {
+    this.ws.send(JSON.stringify({
+      requestId: this.message.requestId,
+      status: 'ok',
+      data
+    }));
+  }
+
+  protected sendError(error: string): void {
+    this.ws.send(JSON.stringify({
+      requestId: this.message.requestId,
+      status: 'error',
+      error
+    }));
+  }
+
+  protected getLibraryId(): string {
+    return this.message.libraryId;
+  }
+
+  protected getAction(): string {
+    return this.message.action;
+  }
+
+  protected getPayload(): Record<string, any> {
+    return this.message.payload.data || {};
+  }
+}

package/src/ServerExample.ts

@@ -0,0 +1,72 @@
+import { MiraWebsocketServer } from './WebSocketServer';
+import { MiraHttpServer } from './HttpServer';
+import { LibraryStorage } from './LibraryStorage';
+import * as path from 'path';
+
+export class MiraBackend {
+  webSocketServer: MiraWebsocketServer;
+  httpServer: MiraHttpServer;
+  libraries: LibraryStorage;
+  dataPath: string;
+
+  constructor(options?: { 
+    dataPath?: string, 
+    httpPort?: number, 
+    wsPort?: number,
+    autoLoad?: boolean,
+    autoStart?: boolean 
+  }) {
+    this.dataPath = options?.dataPath || process.env.DATA_PATH || path.join(process.cwd(), 'data');
+    this.libraries = new LibraryStorage(this);
+    
+    // 只有在明确要求时才自动加载
+    if (options?.autoLoad !== false) {
+      this.libraries.loadAll().then((loaded) => console.log(`${loaded} Libraries loaded`));
+    }
+    
+    this.httpServer = new MiraHttpServer(options?.httpPort || 3000, this);
+    this.webSocketServer = new MiraWebsocketServer(options?.wsPort || 8081, this);
+    
+    // 只有在明确要求时才自动启动
+    if (options?.autoStart === true) {
+      this.start();
+    }
+  }
+
+  /**
+   * 手动启动服务器
+   */
+  start(): void {
+    this.webSocketServer.start('/ws');
+    
+    // 处理退出
+    process.on('SIGINT', async () => {
+      console.log('Shutting down servers...');
+      await this.stop();
+      process.exit();
+    });
+  }
+
+  /**
+   * 停止服务器
+   */
+  async stop(): Promise<void> {
+    await this.webSocketServer.stop();
+    await this.httpServer.stop();
+  }
+
+  /**
+   * 创建并启动服务器的静态方法 (向后兼容)
+   */
+  static createAndStart(options?: { 
+    dataPath?: string, 
+    httpPort?: number, 
+    wsPort?: number 
+  }): MiraBackend {
+    return new MiraBackend({
+      ...options,
+      autoLoad: true,
+      autoStart: true
+    });
+  }
+}

package/src/ServerPlugin.ts

@@ -0,0 +1,56 @@
+import { EventEmitter } from 'events';
+import * as fs from 'fs';
+import * as path from 'path';
+import { ServerPluginManager } from './ServerPluginManager';
+import { ILibraryServerData } from './ILibraryServerData';
+import { MiraHttpServer } from './HttpServer';
+
+export abstract class ServerPlugin {
+    protected configs: Record<string, any> = {};
+    protected readonly eventEmitter: EventEmitter;
+    protected readonly pluginDir: string;
+    protected readonly pluginDataDir: string;
+
+    constructor(protected readonly pluginName: string, pluginManager: ServerPluginManager, dbServer: ILibraryServerData, httpServer: MiraHttpServer) {
+        this.eventEmitter = dbServer.getEventManager()!;
+        this.pluginDir = pluginManager.getPluginDir(pluginName);
+        this.pluginDataDir = path.join(this.pluginDir, 'data');
+        this.ensureDirExists();
+    }
+
+    private ensureDirExists() {
+        if (!fs.existsSync(this.pluginDataDir)) {
+            fs.mkdirSync(this.pluginDataDir, { recursive: true });
+        }
+    }
+
+    protected writeConfig(key: string, value: any) {
+        this.configs[key] = value;
+        this.saveConfig();
+    }
+
+    protected saveConfig() {
+        return this.writeJson('config.json', this.configs);
+    }
+
+    protected readConfig(key: string): any {
+        return this.configs[key];
+    }
+
+    protected loadConfig(defaultConfig: Record<string, any> = {}) {
+       this.configs = {...defaultConfig, ...this.readJson('config.json')};
+    }
+
+    protected writeJson(filename: string, data: any) {
+        const filePath = path.join(this.pluginDataDir, filename);
+        fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+    }
+
+    protected readJson(filename: string): any {
+        const filePath = path.join(this.pluginDataDir, filename);
+        if (fs.existsSync(filePath)) {
+            return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        }
+        return null;
+    }
+}

package/src/ServerPluginManager.ts

@@ -0,0 +1,106 @@
+
+import { MiraHttpServer } from './HttpServer';
+import { ILibraryServerData } from './ILibraryServerData';
+import { MiraWebsocketServer } from './WebSocketServer';
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface PluginConfig {
+    name: string;
+    enabled: boolean;
+    path: string;
+}
+
+export class ServerPluginManager {
+     pluginsDir: string;
+    private server: MiraWebsocketServer;
+    private httpServer: MiraHttpServer;
+    private dbService: ILibraryServerData;
+    private pluginsConfigPath: string;
+    private loadedPlugins: Map<string, any> = new Map();
+    fields: Record<string, any>[] = [];
+
+    constructor({server, dbService, httpServer, pluginsDir}: {server: MiraWebsocketServer, dbService: ILibraryServerData, httpServer: MiraHttpServer, pluginsDir?: string}) {
+        this.pluginsDir = pluginsDir || path.join(__dirname, 'plugins');
+        this.server = server;
+        this.dbService = dbService;
+        this.httpServer = httpServer;
+        this.pluginsConfigPath = path.join(this.pluginsDir, 'plugins.json');
+        
+        // Ensure plugins directory exists
+        if (!fs.existsSync(this.pluginsDir)) {
+            fs.mkdirSync(this.pluginsDir, { recursive: true });
+        }
+        
+        // Initialize plugins.json if it doesn't exist
+        if (!fs.existsSync(this.pluginsConfigPath)) {
+            fs.writeFileSync(this.pluginsConfigPath, JSON.stringify([], null, 2));
+        }
+    }
+
+    // getPluginDir
+    getPluginDir(pluginName: string): string {
+        return path.join(this.pluginsDir, pluginName);
+    }
+
+    async loadPlugins(): Promise<void> {
+        const config: PluginConfig[] = JSON.parse(
+            fs.readFileSync(this.pluginsConfigPath, 'utf-8')
+        );
+
+        for (const pluginConfig of config) {
+            if (pluginConfig.enabled) {
+                try {
+                    const pluginPath = path.join(this.pluginsDir, pluginConfig.path);
+                    delete require.cache[require.resolve(pluginPath)];
+                    const pluginModule = require(pluginPath);
+                    if (typeof pluginModule.init === 'function') {
+                        await pluginModule.init(
+                        {pluginManager: this, server: this.server, dbService: this.dbService, httpServer: this.httpServer})
+                    }
+                    this.loadedPlugins.set(pluginConfig.name, pluginModule);
+                    console.log(`Loaded plugin: ${pluginConfig.name}`);
+                } catch (err) {
+                    console.error(`Failed to load plugin ${pluginConfig.name}:`, err);
+                }
+            }
+        }
+    }
+
+    registerFields(fields: Record<string, any>[]): void {
+        for (const field of fields) {
+            this.registerField(field);
+        }
+    }
+
+    registerField(field: Record<string, any>): void {
+        let {action, type, field: fieldName} = field;
+        if(!fieldName || !action || !type) {
+            throw new Error('Field registration error: action, type, and field are required');
+        }
+        this.fields.push(field);
+    }
+
+    getPlugin<T>(name: string): T | undefined {
+        return this.loadedPlugins.get(name);
+    }
+
+    async addPlugin(config: PluginConfig): Promise<void> {
+        const currentConfig: PluginConfig[] = JSON.parse(
+            fs.readFileSync(this.pluginsConfigPath, 'utf-8')
+        );
+        
+        const existingIndex = currentConfig.findIndex(p => p.name === config.name);
+        if (existingIndex >= 0) {
+            currentConfig[existingIndex] = config;
+        } else {
+            currentConfig.push(config);
+        }
+        
+        fs.writeFileSync(this.pluginsConfigPath, JSON.stringify(currentConfig, null, 2));
+        
+        if (config.enabled) {
+            await this.loadPlugins();
+        }
+    }
+}

package/src/WebSocketRouter.ts

@@ -0,0 +1,46 @@
+import { LibraryServerDataSQLite } from './LibraryServerDataSQLite';
+import { WebSocket, WebSocketServer } from 'ws';
+import { MessageHandler } from './handlers/MessageHandler';
+import { FileHandler } from './handlers/FileHandler';
+import { TagHandler } from './handlers/TagHandler';
+import { FolderHandler } from './handlers/FolderHandler';
+import { LibraryHandler } from './handlers/LibraryHandler';
+import { PluginMessageHandler } from './handlers/PluginMessageHandler';
+
+export interface WebSocketMessage {
+  action: string;
+  requestId: string;
+  libraryId: string;
+  clientId: string;
+  payload: {
+    type: string;
+    data: Record<string, any>;
+  };
+}
+
+export class WebSocketRouter {
+  static async route(
+    server: any,  // 修改为any类型避免类型冲突
+    dbService: LibraryServerDataSQLite, 
+    ws: WebSocket,
+    message: WebSocketMessage
+  ): Promise<MessageHandler | null> {
+    const { payload } = message;
+
+    // 根据资源类型路由到不同的处理器
+    switch (payload.type) {
+      case 'plugin':
+        return new PluginMessageHandler(server, dbService, ws, message);
+      case 'file':
+        return new FileHandler(server, dbService, ws, message);
+      case 'tag':
+        return new TagHandler(server, dbService, ws, message);
+      case 'folder':
+        return new FolderHandler(server, dbService, ws, message);
+      case 'library':
+        return new LibraryHandler(server, dbService, ws, message);
+      default:
+        return null;
+    }
+  }
+}

package/src/WebSocketServer.ts

@@ -0,0 +1,206 @@
+import { WebSocketServer as WSServer, WebSocket } from 'ws';
+import { Server } from 'http';
+import { LibraryServerDataSQLite } from './LibraryServerDataSQLite';
+import { WebSocketRouter } from './WebSocketRouter';
+import { ServerPluginManager } from './ServerPluginManager';
+import { EventArgs } from './event-manager';
+import { LibraryStorage } from './LibraryStorage';
+import { MiraHttpServer } from './HttpServer';
+import { MiraBackend } from './ServerExample';
+
+interface LibraryClient {
+  [libraryId: string]: WebSocket[];
+}
+
+
+export class MiraWebsocketServer {
+  private port: number;
+  private libraryClients: LibraryClient = {};
+  private wss?: WSServer;
+  libraries: LibraryStorage;
+  private httpServer: MiraHttpServer;
+  backend: MiraBackend;
+
+  constructor(port: number, backend: MiraBackend) {
+    this.port = port;
+    this.backend = backend;
+    this.httpServer = this.backend.httpServer;
+    this.libraries = this.backend.libraries;
+  }
+
+  async start(basePath: string): Promise<void> {
+    this.wss = new WSServer({ port: this.port });
+    this.wss.on('connection', (ws: WebSocket, request) => {
+      const urlString = request.url ?? '';
+      const url = new URL(urlString, `ws://${request.headers.host}`);
+      const clientId = url.searchParams.get('clientId');
+      const libraryId = url.searchParams.get('libraryId');
+      if (clientId == null || libraryId == null) {
+        console.error('Missing clientId or libraryId in WebSocket connection');
+        return ws.close();
+      }
+
+      // 将请求信息保存到 ws 对象上
+      Object.assign(ws, {
+        clientId: clientId,
+        libraryId: libraryId,
+        requestInfo: {
+          url: request.url,
+          headers: request.headers,
+          remoteAddress: request.socket.remoteAddress
+        }
+      });
+
+      // 保存连接
+      if (!this.libraryClients[libraryId]) {
+        this.libraryClients[libraryId] = [];
+      }
+      if (!this.libraryClients[libraryId].includes(ws)) {
+        this.libraryClients[libraryId].push(ws);
+      }
+
+      this.handleConnection(ws);
+    });
+
+    console.log(`[!]Serving at ws://localhost:${this.port}`);
+  }
+
+  broadcastToClients(eventName: string, eventData: Record<string, any>): void {
+    const dbService = this.libraries.all().find(
+      (library) => library.getLibraryId() === eventData.libraryId
+    );
+    if (dbService) {
+      const eventManager = dbService.getEventManager();
+      eventManager!.broadcast(
+        eventName,
+        new EventArgs(eventName, eventData)
+      );
+    }
+  }
+
+  getWsClientById(libraryId: string, clientId: string): WebSocket | undefined {
+    const clients = this.libraryClients[libraryId];
+    if (clients) {
+      return clients.find((client) => (client as any).clientId === clientId);
+    }
+  }
+
+  showDialogToWeboscket(ws: WebSocket, data: Record<string, any>): void {
+    this.sendToWebsocket(ws, {
+      eventName: 'dialog', data: Object.assign({
+        title: '提示',
+        message: '',
+        url: ''
+      }, data)
+    });
+  }
+
+  sendToWebsocket(ws: WebSocket, data: Record<string, any>): void {
+    console.log({ response: data });
+    ws.send(JSON.stringify(data));
+  }
+
+  broadcastPluginEvent(eventName: string, data: Record<string, any>): Promise<boolean> {
+    const libraryId = data?.libraryId ?? data?.message?.libraryId;
+    const dbService = this.libraries.all().find(
+      (library) => library.getLibraryId() === libraryId
+    );
+    if (dbService) {
+      const eventManager = dbService.getEventManager();
+      return eventManager!.broadcast(
+        eventName,
+        new EventArgs(eventName, data)
+      );
+    }
+    return Promise.resolve(false);
+  }
+
+  private handleConnection(ws: WebSocket): void {
+    ws.on('message', async (message: string) => {
+      try {
+        const data = JSON.parse(message);
+        console.log('Incoming message:', data)
+        await this.handleMessage(ws, data);
+      } catch (e) {
+        this.sendToWebsocket(ws, {
+          error: 'Invalid message format',
+          details: e instanceof Error ? e.message : String(e)
+        });
+      }
+    });
+
+    ws.on('close', () => {
+      // Remove from all library client lists
+      Object.keys(this.libraryClients).forEach(libraryId => {
+        const index = this.libraryClients[libraryId].findIndex(
+          client => client === ws
+        );
+        console.log({ index });
+        if (index !== -1) {
+          this.libraryClients[libraryId].splice(index, 1);
+        }
+      });
+    });
+  }
+
+  private async handleMessage(ws: WebSocket, row: Record<string, any>): Promise<void> {
+    const payload = row.payload || {};
+    const action = row.action;
+    const requestId = row.requestId;
+    const libraryId = row.libraryId;
+    const data = payload.data || {};
+    const recordType = payload.type;
+    const exists = this.libraries.exists(libraryId);
+    if (!exists) {
+      this.sendToWebsocket(ws, {
+        status: 'error',
+        msg: 'Library not found!'
+      });
+      return;
+    }
+
+    const dbService = this.libraries.all().find(
+      (library) => library.getLibraryId() === libraryId
+    );
+
+    if (!dbService) {
+      this.sendToWebsocket(ws, {
+        status: 'error',
+        msg: 'Library service not found'
+      });
+      return;
+    }
+
+    const handler = await WebSocketRouter.route(this, dbService, ws, {
+      ...row,
+      ...payload
+    });
+
+    if (handler) {
+      await handler.handle();
+    } else {
+      this.sendToWebsocket(ws, {
+        status: 'error',
+        message: `Unsupported action: ${action} and record type: ${recordType}`,
+        requestId
+      });
+    }
+  }
+
+  broadcastLibraryEvent(libraryId: string, eventName: string, data: Record<string, any>): void {
+    const message = JSON.stringify({ eventName: eventName, data: data });
+    if (this.libraryClients[libraryId]) {
+      this.libraryClients[libraryId].forEach(client => {
+        if (client.readyState === WebSocket.OPEN) {
+          client.send(message);
+        }
+      });
+    }
+  }
+
+  async stop(): Promise<void> {
+    this.libraries.all().map(dbService => dbService.close());
+    this.wss?.close();
+    console.log('WebSocket server stopped');
+  }
+}