mm_os 4.0.0 → 4.0.2

package/README.md

@@ -1,4 +1,4 @@
-# MOS 服务端架构
+# MM_OS 服务端架构
 
 [![npm version](https://badge.fury.io/js/mm_os.svg)](https://badge.fury.io/js/mm_os)
 [![npm downloads](https://img.shields.io/npm/dm/mm_os.svg)](https://www.npmjs.com/package/mm_os)
@@ -6,9 +6,16 @@
 
 ## 项目简介
 
-MOS 是一个轻量级的服务端架构，提供了完整的服务端开发框架，包括 Web、WebSocket、MQTT、Socket 等多种通信协议支持，以及丰富的组件和模块。
+MM_OS 是一个轻量级的服务端架构，提供了完整的服务端开发框架，包括 Web、WebSocket、MQTT、Socket 等多种通信协议支持，以及丰富的组件和模块。
 
-适用于快速构建网站、小程序后台、AI应用、物联网应用、中小型游戏服务端。
+**适用场景：**
+- **网站建设**：快速构建企业网站、电商平台、内容管理系统
+- **小程序**：微信小程序、支付宝小程序等小程序后台服务
+- **AI 应用**：AI 接口服务、智能助手、机器学习推理服务
+- **物联网 (IOT/AIOT)**：物联网设备管理、传感器数据采集、智能硬件控制
+- **游戏服务端**：中小型游戏服务端、实时对战游戏、游戏后台管理
+
+支持 **AI、GAME、IOT、AIOT、游戏、物联网、小程序、网站建设** 等多种应用场景。
 
 ## 核心功能
 
@@ -20,7 +27,7 @@ MOS 是一个轻量级的服务端架构，提供了完整的服务端开发框
 
 ## 设计理念：配置与逻辑分离
 
-MOS 框架的核心设计原则是 **配置与逻辑分离**。无论是 `core` 核心模块还是 `com` 公共组件，每个功能模块都遵循统一的结构：
+MM_OS 框架的核心设计原则是 **配置与逻辑分离**。无论是 `core` 核心模块还是 `com` 公共组件，每个功能模块都遵循统一的结构：
 
 ### 模块组成
 
@@ -110,7 +117,7 @@ startServer();
 
 ## 项目目录结构
 
-基于 MOS 框架开发的项目采用标准化目录结构：
+基于 MM_OS 框架开发的项目采用标准化目录结构：
 
 ```
 ├── app/                    # 应用目录，包含多个独立应用
@@ -205,7 +212,7 @@ startServer();
 
 ### 创建 API 接口
 
-API 是 MOS 框架的核心组件，每个 API 包含三个文件：
+API 是 MM_OS 框架的核心组件，每个 API 包含三个文件：
 
 #### 1. api.json - API 配置
 
@@ -404,7 +411,7 @@ exports.main = main;
 
 ## 配置说明
 
-MOS 支持多种配置选项，包括：
+MM_OS 支持多种配置选项，包括：
 
 - **web**：Web 服务器配置
 - **mysql**：MySQL 数据库配置
@@ -460,7 +467,7 @@ MOS 支持多种配置选项，包括：
 
 ## 全局对象
 
-MOS 提供了丰富的全局对象供开发使用：
+MM_OS 提供了丰富的全局对象供开发使用：
 
 ### `$` 对象
 

package/README_EN.md

@@ -1,4 +1,4 @@
-# MOS Server Architecture
+# MM_OS Server Architecture
 
 [![npm version](https://badge.fury.io/js/mm_os.svg)](https://badge.fury.io/js/mm_os)
 [![npm downloads](https://img.shields.io/npm/dm/mm_os.svg)](https://www.npmjs.com/package/mm_os)
@@ -6,9 +6,16 @@
 
 ## Project Introduction
 
-MOS is a lightweight server architecture that provides a complete server development framework, including support for multiple communication protocols such as Web, WebSocket, MQTT, Socket, as well as rich components and modules.
+MM_OS is a lightweight server architecture that provides a complete server development framework, including support for multiple communication protocols such as Web, WebSocket, MQTT, Socket, as well as rich components and modules.
 
-Suitable for quickly building websites, mini-program backends, AI applications, IoT applications, and small-to-medium game servers.
+**Use Cases:**
+- **Website Development**: Quickly build enterprise websites, e-commerce platforms, content management systems
+- **Mini Programs**: Backend services for WeChat Mini Programs, Alipay Mini Programs, etc.
+- **AI Applications**: AI API services, intelligent assistants, machine learning inference services
+- **IoT/AIoT**: IoT device management, sensor data collection, smart hardware control
+- **Game Servers**: Small-to-medium game servers, real-time battle games, game backend management
+
+Supports **AI, GAME, IOT, AIOT, Games, Internet of Things, Mini Programs, Website Development** and other application scenarios.
 
 ## Core Features
 
@@ -20,7 +27,7 @@ Suitable for quickly building websites, mini-program backends, AI applications,
 
 ## Design Philosophy: Configuration and Logic Separation
 
-The core design principle of MOS framework is **separation of configuration and logic**. Both `core` modules and `com` components follow a unified structure:
+The core design principle of MM_OS framework is **separation of configuration and logic**. Both `core` modules and `com` components follow a unified structure:
 
 ### Module Composition
 
@@ -111,7 +118,7 @@ startServer();
 
 ## Project Directory Structure
 
-Projects developed with MOS framework follow a standardized directory structure:
+Projects developed with MM_OS framework follow a standardized directory structure:
 
 ```
 ├── app/                    # Application directory containing multiple apps
@@ -206,7 +213,7 @@ Define application routing rules:
 
 ### Create API Interface
 
-API is the core component of MOS framework. Each API consists of three files:
+API is the core component of MM_OS framework. Each API consists of three files:
 
 #### 1. api.json - API Configuration
 
@@ -405,7 +412,7 @@ exports.main = main;
 
 ## Configuration
 
-MOS supports multiple configuration options:
+MM_OS supports multiple configuration options:
 
 - **web**: Web server configuration
 - **mysql**: MySQL database configuration
@@ -461,7 +468,7 @@ MOS supports multiple configuration options:
 
 ## Global Objects
 
-MOS provides rich global objects for development:
+MM_OS provides rich global objects for development:
 
 ### `$` Object
 

package/package.json

@@ -1,8 +1,24 @@
 {
 	"name": "mm_os",
-	"description": "超级美眉服务端框架，用于快速构建应用程序，可快速构建网站、小程序后台、AI应用、物联网应用、中小型游戏服务端。",
-	"version": "4.0.0",
+	"description": "MM_OS服务端架构，用于快速构建应用程序，支持网站建设、小程序后台、AI应用、物联网(IOT/AIOT)、游戏服务端等多种场景。",
+	"version": "4.0.2",
 	"main": "index.js",
+	"keywords": [
+		"AI",
+		"GAME",
+		"IOT",
+		"AIOT",
+		"游戏",
+		"物联网",
+		"小程序",
+		"网站建设",
+		"服务端框架",
+		"NodeJS",
+		"WebSocket",
+		"MQTT",
+		"Socket",
+		"koa"
+	],
 	"author": "qww",
 	"license": "ISC",
 	"scripts": {
@@ -36,13 +52,7 @@
 		"mm_statics": "^1.8.4",
 		"mm_xml": "^1.1.7",
 		"mqtt": "^5.15.1",
-		"openai": "^6.39.0",
-		"sharp": "^0.34.5",
-		"cos-nodejs-sdk-v5": "^2.15.4",
-		"jimp": "^1.6.1",
-		"qq-guild-bot": "^2.9.5",
-		"tencentcloud-sdk-nodejs-faceid": "^4.1.233",
-		"tinify": "^1.8.2"
+		"openai": "^6.39.0"
 	},
 	"devDependencies": {
 		"@types/jest": "^30.0.0",
@@ -66,6 +76,7 @@
 		"adapter/",
 		"com/",
 		"common/",
-		"core/"
+		"core/",
+		"ulits/"
 	]
 }

package/ulits/id_gen.js

@@ -0,0 +1,134 @@
+/**
+ * ID生成器
+ * 基于雪花算法实现，生成唯一ID
+ */
+class IdGen {
+  /**
+   * 构造函数
+   * @param {object} config 配置参数
+   * @param {number} config.worker_id 工作机器ID (0-31)
+   * @param {number} config.dc_id 数据中心ID (0-31)
+   * @param {number} config.sequence 序列号
+   */
+  constructor(config = {}) {
+    this.worker_id = config.worker_id || 0;
+    this.dc_id = config.dc_id || 0;
+    this.sequence = config.sequence || 0;
+
+    this.worker_id_bits = 5;
+    this.dc_id_bits = 5;
+    this.max_worker_id = -1 ^ (-1 << this.worker_id_bits);
+    this.max_dc_id = -1 ^ (-1 << this.dc_id_bits);
+    this.sequence_bits = 12;
+
+    this.worker_id_shift = this.sequence_bits;
+    this.dc_id_shift = this.sequence_bits + this.worker_id_bits;
+    this.timestamp_left_shift = this.sequence_bits + this.worker_id_bits + this.dc_id_bits;
+    this.sequence_mask = -1 ^ (-1 << this.sequence_bits);
+
+    this.last_timestamp = -1;
+
+    this.twepoch = 1288834974657;
+
+    if (this.worker_id > this.max_worker_id || this.worker_id < 0) {
+      throw new TypeError(`工作机器ID必须在0-${this.max_worker_id}之间`);
+    }
+    if (this.dc_id > this.max_dc_id || this.dc_id < 0) {
+      throw new TypeError(`数据中心ID必须在0-${this.max_dc_id}之间`);
+    }
+  }
+}
+
+/**
+ * 获取当前时间戳
+ * @returns {number} 当前时间戳
+ */
+IdGen.prototype._timeGen = function () {
+  return Date.now();
+};
+
+/**
+ * 等待下一毫秒
+ * @param {number} last_timestamp 上次时间戳
+ * @returns {number} 新的时间戳
+ */
+IdGen.prototype._tilNextMillis = function (last_timestamp) {
+  var timestamp = this._timeGen();
+  while (timestamp <= last_timestamp) {
+    timestamp = this._timeGen();
+  }
+  return timestamp;
+};
+
+/**
+ * 生成下一个ID
+ * @returns {string} 唯一ID
+ */
+IdGen.prototype.nextId = function () {
+  var timestamp = this._timeGen();
+
+  if (timestamp < this.last_timestamp) {
+    throw new Error('时钟回拨，拒绝生成ID');
+  }
+
+  if (this.last_timestamp === timestamp) {
+    this.sequence = (this.sequence + 1) & this.sequence_mask;
+    if (this.sequence === 0) {
+      timestamp = this._tilNextMillis(this.last_timestamp);
+    }
+  } else {
+    this.sequence = 0;
+  }
+
+  this.last_timestamp = timestamp;
+
+  var id = (BigInt(timestamp - this.twepoch) << BigInt(this.timestamp_left_shift))
+    | (BigInt(this.dc_id) << BigInt(this.dc_id_shift))
+    | (BigInt(this.worker_id) << BigInt(this.worker_id_shift))
+    | BigInt(this.sequence);
+
+  return id.toString();
+};
+
+/**
+ * 生成带前缀的ID
+ * @param {string} prefix 前缀
+ * @returns {string} 带前缀的唯一ID
+ */
+IdGen.prototype.genId = function (prefix) {
+  if (typeof prefix !== 'string') {
+    throw new TypeError('前缀必须是字符串');
+  }
+  return prefix + '_' + this.nextId();
+};
+
+/**
+ * 解析ID信息
+ * @param {string} id ID字符串
+ * @returns {object} ID信息对象
+ */
+IdGen.prototype.parseId = function (id) {
+  if (typeof id !== 'string') {
+    throw new TypeError('ID必须是字符串');
+  }
+  var num = BigInt(id.replace(/^[a-zA-Z_]+_/, ''));
+  var timestamp = Number((num >> 22n) + BigInt(this.twepoch));
+  var dc_id = Number((num >> 17n) & 31n);
+  var worker_id = Number((num >> 12n) & 31n);
+  var sequence = Number(num & 4095n);
+
+  return {
+    timestamp: timestamp,
+    datetime: new Date(timestamp).toISOString(),
+    dc_id: dc_id,
+    worker_id: worker_id,
+    sequence: sequence
+  };
+};
+
+var idGen = new IdGen();
+
+module.exports = {
+  IdGen,
+  idGen
+};

package/ulits/word.js

@@ -0,0 +1,206 @@
+/**
+ * 单词工具类
+ * @class Word
+ */
+class Word {
+  /**
+   * 构造函数
+   */
+  constructor() {
+
+  }
+}
+
+/**
+ * 分割单词
+ * @param {string} name 名称
+ * @returns {Array} 单词数组
+ */
+Word.prototype.splitWords = function (name) {
+  if (!name || name.length === 0) {
+    return [];
+  }
+
+  var words = [];
+  var current_word = '';
+  var last_char_type = null;
+
+  for (var i = 0; i < name.length; i++) {
+    var char = name[i];
+    var char_info = this._getCharInfo(char);
+
+    // 处理下划线和数字
+    if (char_info.is_under || char_info.is_digit) {
+      last_char_type = this._handleSepa(words, current_word, char, char_info);
+      current_word = '';
+      continue;
+    }
+
+    // 处理第一个字符
+    if (current_word.length === 0) {
+      current_word = char;
+      last_char_type = char_info.type;
+      continue;
+    }
+
+    // 处理字符转换
+    var result = this._handleCharTran(words, current_word, char, last_char_type, char_info.type);
+    words = result.words;
+    current_word = result.current_word;
+    last_char_type = char_info.type;
+  }
+
+  // 添加最后一个单词
+  if (current_word.length > 0) {
+    words.push(current_word);
+  }
+
+  return words;
+};
+
+/**
+ * 获取字符信息
+ * @param {string} char 字符
+ * @returns {object} 字符信息
+ * @private
+ */
+Word.prototype._getCharInfo = function (char) {
+  var is_upper = char >= 'A' && char <= 'Z';
+  var is_lower = char >= 'a' && char <= 'z';
+  var is_digit = char >= '0' && char <= '9';
+  var type = is_upper ? 'upper' : (is_lower ? 'lower' : (is_digit ? 'digit' : 'other'));
+  return { is_upper, is_lower, is_digit, is_under: char === '_', type };
+};
+
+/**
+ * 处理分隔符
+ * @param {Array} words 单词数组
+ * @param {string} current_word 当前单词
+ * @param {string} char 字符
+ * @param {object} char_info 字符信息
+ * @returns {string} 新的字符类型
+ * @private
+ */
+Word.prototype._handleSepa = function (words, current_word, char, char_info) {
+  if (current_word.length > 0) {
+    words.push(current_word);
+  }
+  if (char_info.is_digit) {
+    words.push(char);
+    return 'digit';
+  }
+  return 'underscore';
+};
+
+/**
+ * 处理字符转换
+ * @param {Array} words 单词数组
+ * @param {string} current_word 当前单词
+ * @param {string} char 字符
+ * @param {string} last_type 上一个字符类型
+ * @param {string} current_type 当前字符类型
+ * @returns {object} 处理结果
+ * @private
+ */
+Word.prototype._handleCharTran = function (
+  words, current_word, char, last_type, current_type
+) {
+  var is_last_letter = last_type === 'upper' || last_type === 'lower';
+  var is_current_letter = current_type === 'upper' || current_type === 'lower';
+
+  if (!is_last_letter || !is_current_letter) {
+    return { words, current_word: current_word + char };
+  }
+
+  if (last_type === 'upper' && current_type === 'lower') {
+    // 大写转小写
+    if (current_word.length > 1) {
+      var last_char = current_word[current_word.length - 1];
+      words.push(current_word.substring(0, current_word.length - 1));
+      return { words, current_word: last_char + char };
+    }
+    return { words, current_word: current_word + char };
+  }
+
+  if (last_type === 'lower' && current_type === 'upper') {
+    // 小写转大写
+    words.push(current_word);
+    return { words, current_word: char };
+  }
+
+  // 相同类型
+  return { words, current_word: current_word + char };
+};
+
+/**
+ * 将名称改为帕斯卡命名法
+ * @param {string} name 名称
+ * @returns {string} 帕斯卡命名法的名称
+ */
+Word.prototype.toPascalCase = function (name) {
+  var words = this.splitWords(name);
+  for (let i = 0; i < words.length; i++) {
+    words[i] = words[i].toLowerCase();
+    words[i] = words[i].charAt(0).toUpperCase() + words[i].substring(1);
+  }
+  return words.join('');
+};
+
+/**
+ * 将名称改为驼峰命名法
+ * @param {string} name 名称
+ * @returns {string} 驼峰命名法的名称
+ */
+Word.prototype.toCamelCase = function (name) {
+  var words = this.splitWords(name);
+  for (let i = 0; i < words.length; i++) {
+    words[i] = words[i].toLowerCase();
+    if (i > 0) {
+      words[i] = words[i].charAt(0).toUpperCase() + words[i].substring(1);
+    }
+  }
+  return words.join('');
+};
+
+/**
+ * 将名称改为小写蛇形(下划线)命名法
+ * @param {string} name 名称
+ * @returns {string} 小写蛇形(下划线)命名法的名称
+ */
+Word.prototype.toSnakeCase = function (name) {
+  var words = this.splitWords(name);
+  for (let i = 0; i < words.length; i++) {
+    words[i] = words[i].toLowerCase();
+  }
+  return words.join('_');
+};
+
+/**
+ * 将名称改为大写蛇形(下划线)命名法
+ * @param {string} name 名称
+ * @returns {string} 大写蛇形(下划线)命名法的名称
+ */
+Word.prototype.toUpperSnakeCase = function (name) {
+  var words = this.splitWords(name);
+  for (let i = 0; i < words.length; i++) {
+    words[i] = words[i].toUpperCase();
+  }
+  return words.join('_');
+};
+
+/**
+ * 将名称改为小写短横线(短横线)命名法
+ * @param {string} name 名称
+ * @returns {string} 小写短横线(短横线)命名法的名称
+ */
+Word.prototype.toKebabCase = function (name) {
+  var words = this.splitWords(name);
+  for (let i = 0; i < words.length; i++) {
+    words[i] = words[i].toLowerCase();
+  }
+  return words.join('-');
+};
+
+module.exports = {
+  Word
+};