init

.gitignore

@@ -0,0 +1,4 @@
+node_modules
+dist 
+
+app.config.json5

.npmrc

@@ -0,0 +1,2 @@
+//npm.xiongxiao.me/:_authToken=${ME_NPM_TOKEN}
+//registry.npmjs.org/:_authToken=${NPM_TOKEN}

package.json

@@ -0,0 +1,55 @@
+{
+  "name": "code-center-module",
+  "version": "0.0.1",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "watch": "rollup -c rollup.config.mjs -w",
+    "dev": "cross-env NODE_ENV=development nodemon --delay 2.5 -e js,cjs,mjs --exec node dist/app.mjs",
+    "test": "tsx  test/**/*.ts",
+    "dev:watch": "cross-env NODE_ENV=development concurrently -n \"Watch,Dev\" -c \"green,blue\" \"npm run watch\" \"sleep 1 && npm run dev\" ",
+    "build": "rimraf dist && rollup -c rollup.config.mjs"
+  },
+  "keywords": [],
+  "author": "abearxiong <xiongxiao@xiongxiao.me>",
+  "license": "MIT",
+  "type": "module",
+  "dependencies": {
+    "@kevisual/auth": "1.0.5",
+    "@kevisual/router": "^0.0.7",
+    "@kevisual/use-config": "^1.0.8",
+    "ioredis": "^5.5.0",
+    "pg": "^8.13.3",
+    "sequelize": "^6.37.5",
+    "socket.io": "^4.8.1",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@kevisual/types": "^0.0.6",
+    "@rollup/plugin-alias": "^5.1.1",
+    "@rollup/plugin-commonjs": "^28.0.2",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.0",
+    "@rollup/plugin-replace": "^6.0.2",
+    "@rollup/plugin-typescript": "^12.1.2",
+    "rollup-plugin-esbuild": "^6.2.0",
+    "@types/archiver": "^6.0.3",
+    "@types/crypto-js": "^4.2.2",
+    "@types/formidable": "^3.4.5",
+    "@types/jsonwebtoken": "^9.0.9",
+    "@types/lodash-es": "^4.17.12",
+    "@types/node": "^22.13.5",
+    "@types/react": "^19.0.10",
+    "@types/uuid": "^10.0.0",
+    "concurrently": "^9.1.2",
+    "cross-env": "^7.0.3",
+    "nodemon": "^3.1.9",
+    "rimraf": "^6.0.1",
+    "rollup": "^4.34.8",
+    "rollup-plugin-copy": "^3.5.0",
+    "rollup-plugin-dts": "^6.1.1",
+    "tape": "^5.9.0",
+    "tsx": "^4.19.3",
+    "typescript": "^5.7.3"
+  }
+}

rollup.config.mjs

@@ -0,0 +1,84 @@
+import resolve from '@rollup/plugin-node-resolve';
+import commonjs from '@rollup/plugin-commonjs';
+import json from '@rollup/plugin-json';
+import * as glob from 'fast-glob';
+import path from 'path';
+import esbuild from 'rollup-plugin-esbuild';
+import alias from '@rollup/plugin-alias';
+import replace from '@rollup/plugin-replace';
+import pkgs from './package.json' with { type: 'json' };
+
+const isDev = process.env.NODE_ENV === 'development';
+const version = pkgs.version|| '1.0.0';
+/**
+ * @type {import('rollup').RollupOptions}
+ */
+const config = {
+  input: './src/index.ts',
+  output: {
+    dir: './dist',
+    entryFileNames: 'app.mjs',
+    chunkFileNames: '[name]-[hash].mjs',
+    format: 'esm',
+  },
+  plugins: [
+    replace({
+      preventAssignment: true, // 防止意外赋值
+      DEV_SERVER: JSON.stringify(isDev), // 替换 process.env.NODE_ENV
+      VERSION: JSON.stringify(version), // 替换版本号
+    }),
+    alias({
+      // only esbuild needs to be configured
+      entries: [
+        { find: '@', replacement: path.resolve('src') }, // 配置 @ 为 src 目录
+        { find: 'http', replacement: 'node:http' },
+        { find: 'https', replacement: 'node:https' },
+        { find: 'fs', replacement: 'node:fs' },
+        { find: 'path', replacement: 'node:path' },
+        { find: 'crypto', replacement: 'node:crypto' },
+        { find: 'zlib', replacement: 'node:zlib' },
+        { find: 'stream', replacement: 'node:stream' },
+        { find: 'net', replacement: 'node:net' },
+        { find: 'tty', replacement: 'node:tty' },
+        { find: 'tls', replacement: 'node:tls' },
+        { find: 'buffer', replacement: 'node:buffer' },
+        { find: 'timers', replacement: 'node:timers' },
+        // { find: 'string_decoder', replacement: 'node:string_decoder' },
+        { find: 'dns', replacement: 'node:dns' },
+        { find: 'domain', replacement: 'node:domain' },
+        { find: 'os', replacement: 'node:os' },
+        { find: 'events', replacement: 'node:events' },
+        { find: 'url', replacement: 'node:url' },
+        { find: 'assert', replacement: 'node:assert' },
+        { find: 'util', replacement: 'node:util' },
+      ],
+    }),
+    resolve({
+      preferBuiltins: true, // 强制优先使用内置模块
+    }),
+    commonjs(),
+    esbuild({
+      target: 'node22', // 目标为 Node.js 14
+      minify: false, // 启用代码压缩
+      tsconfig: 'tsconfig.json',
+    }),
+    json(),
+  ],
+  external: [
+    /@kevisual\/router(\/.*)?/, //, // 路由
+    /@kevisual\/use-config(\/.*)?/, //
+
+    'sequelize', // 数据库 orm
+    'ioredis', // redis
+    'socket.io', // socket.io
+    'minio', // minio
+    
+    'pm2',
+    
+    'pg', // pg
+    'pino', // pino
+    'pino-pretty', // pino-pretty
+    '@msgpack/msgpack', // msgpack
+  ],
+};
+export default config;

src/app.ts

@@ -0,0 +1,13 @@
+import { App } from '@kevisual/router';
+import { useContextKey, useContext } from '@kevisual/use-config/context';
+
+const init = () => {
+  return new App({
+    serverOptions: {
+      cors: {
+        origin: '*',
+      },
+    },
+  });
+};
+export const app = useContextKey('app', init);

src/index.ts

@@ -0,0 +1,14 @@
+import { app } from './app.ts';
+import { UserServices } from './models/user.ts';
+import { Org } from './models/org.ts';
+import { useContextKey } from '@kevisual/use-config/context';
+import { Sequelize } from 'sequelize';
+import { Redis } from 'ioredis';
+export const User = UserServices;
+export { Org };
+
+export const redis = useContextKey<Redis>('redis');
+export const sequelize = useContextKey<Sequelize>('sequelize');
+export const UserModel = useContextKey<typeof UserServices>('UserModel');
+export const OrgModel = useContextKey<typeof Org>('OrgModel');
+export { app };

src/models/org.ts

@@ -0,0 +1,44 @@
+import { DataTypes, Model, Sequelize } from 'sequelize';
+import { useContextKey } from '@kevisual/use-config/context';
+const sequelize = useContextKey<Sequelize>('sequelize');
+export class Org extends Model {
+  declare id: string;
+  declare username: string;
+  declare description: string;
+  declare users: { role: string; uid: string }[];
+}
+
+Org.init(
+  {
+    id: {
+      type: DataTypes.UUID,
+      primaryKey: true,
+      defaultValue: DataTypes.UUIDV4,
+    },
+    username: {
+      type: DataTypes.STRING,
+      allowNull: false,
+      unique: true,
+    },
+    description: {
+      type: DataTypes.STRING,
+      allowNull: true,
+    },
+    users: {
+      type: DataTypes.JSONB,
+      allowNull: true,
+      defaultValue: [],
+    },
+  },
+  {
+    sequelize,
+    modelName: 'cf_org',
+    paranoid: true,
+  },
+);
+
+Org.sync({ alter: true, logging: false }).catch((e) => {
+  console.error('Org sync', e);
+});
+
+useContextKey('OrgModel', () => Org);

src/models/user.ts

@@ -0,0 +1,287 @@
+import { useConfig } from '@kevisual/use-config';
+import { DataTypes, Model, Op, Sequelize } from 'sequelize';
+import { createToken, checkToken } from '@kevisual/auth';
+import { cryptPwd } from '@kevisual/auth';
+import { customRandom, nanoid, customAlphabet } from 'nanoid';
+import { CustomError } from '@kevisual/router';
+import { Org } from './org.ts';
+
+import { useContextKey } from '@kevisual/use-config/context';
+import { Redis } from 'ioredis';
+export const redis = useContextKey<Redis>('redis');
+const sequelize = useContextKey<Sequelize>('sequelize');
+const config = useConfig<{ tokenSecret: string }>();
+
+type UserData = {
+  orgs?: string[];
+};
+export class User extends Model {
+  declare id: string;
+  declare username: string;
+  declare nickname: string; // 昵称
+  declare alias: string; // 别名
+  declare password: string;
+  declare salt: string;
+  declare needChangePassword: boolean;
+  declare description: string;
+  declare data: UserData;
+  declare type: string; // user | org | visitor
+  declare owner: string;
+  declare orgId: string;
+  declare email: string;
+  declare avatar: string;
+  tokenUser: any;
+  setTokenUser(tokenUser: any) {
+    this.tokenUser = tokenUser;
+  }
+  /**
+   * uid 是用于 orgId 的用户id 真实用户的id
+   * @param uid
+   * @returns
+   */
+  async createToken(uid?: string, loginType?: 'default' | 'plugin' | 'month' | 'season' | 'year') {
+    const { id, username, type } = this;
+    let expireTime = 60 * 60 * 24 * 7; // 7 days
+    switch (loginType) {
+      case 'plugin':
+        expireTime = 60 * 60 * 24 * 30 * 12; // 365 days
+        break;
+      case 'month':
+        expireTime = 60 * 60 * 24 * 30; // 30 days
+        break;
+      case 'season':
+        expireTime = 60 * 60 * 24 * 30 * 3; // 90 days
+        break;
+      case 'year':
+        expireTime = 60 * 60 * 24 * 30 * 12; // 365 days
+        break;
+    }
+    const now = new Date().getTime();
+    const token = await createToken({ id, username, uid, type }, config.tokenSecret);
+    return { token, expireTime: now + expireTime };
+  }
+  static async verifyToken(token: string) {
+    const ct = await checkToken(token, config.tokenSecret);
+    const tokenUser = ct.payload;
+    return tokenUser;
+  }
+  static async createUser(username: string, password?: string, description?: string) {
+    const user = await User.findOne({ where: { username } });
+    if (user) {
+      throw new CustomError('User already exists');
+    }
+    const salt = nanoid(6);
+    let needChangePassword = !password;
+    password = password || '123456';
+    const cPassword = cryptPwd(password, salt);
+    return await User.create({ username, password: cPassword, description, salt, needChangePassword });
+  }
+  static async createOrg(username: string, owner: string, description?: string) {
+    const user = await User.findOne({ where: { username } });
+    if (user) {
+      throw new CustomError('User already exists');
+    }
+    const me = await User.findByPk(owner);
+    if (!me) {
+      throw new CustomError('Owner not found');
+    }
+    if (me.type !== 'user') {
+      throw new CustomError('Owner type is not user');
+    }
+    const org = await Org.create({ username, description, users: [{ uid: owner, role: 'owner' }] });
+    const newUser = await User.create({ username, password: '', description, type: 'org', owner, orgId: org.id });
+    // owner add
+    await redis.del(`user:${me.id}:orgs`);
+    return newUser;
+  }
+  createPassword(password: string) {
+    const salt = this.salt;
+    const cPassword = cryptPwd(password, salt);
+    this.password = cPassword;
+    return cPassword;
+  }
+  checkPassword(password: string) {
+    const salt = this.salt;
+    const cPassword = cryptPwd(password, salt);
+    return this.password === cPassword;
+  }
+  async getInfo() {
+    const orgs = await this.getOrgs();
+    return {
+      id: this.id,
+      username: this.username,
+      nickname: this.nickname,
+      description: this.description,
+      needChangePassword: this.needChangePassword,
+      type: this.type,
+      avatar: this.avatar,
+      orgs,
+    };
+  }
+  async getOrgs() {
+    let id = this.id;
+    if (this.type === 'org') {
+      if (this.tokenUser && this.tokenUser.uid) {
+        id = this.tokenUser.uid;
+      } else {
+        console.log('getOrgs', 'no uid', this.id, this.username);
+        throw new CustomError('Permission denied');
+      }
+    }
+    const cache = await redis.get(`user:${id}:orgs`);
+    if (cache) {
+      return JSON.parse(cache) as string[];
+    }
+    const orgs = await Org.findAll({
+      order: [['updatedAt', 'DESC']],
+      where: {
+        users: {
+          [Op.contains]: [
+            {
+              uid: id,
+            },
+          ],
+        },
+      },
+    });
+    const orgNames = orgs.map((org) => org.username);
+    if (orgNames.length > 0) {
+      await redis.set(`user:${id}:orgs`, JSON.stringify(orgNames), 'EX', 60 * 60); // 1 hour
+    }
+    return orgNames;
+  }
+  async expireOrgs() {
+    await redis.del(`user:${this.id}:orgs`);
+  }
+}
+User.init(
+  {
+    id: {
+      type: DataTypes.UUID,
+      primaryKey: true,
+      defaultValue: DataTypes.UUIDV4,
+    },
+    username: {
+      type: DataTypes.STRING,
+      allowNull: false,
+      unique: true,
+      // 用户名或者手机号
+      // 创建后避免修改的字段，当注册用户后，用户名注册则默认不能用手机号
+    },
+    nickname: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+    },
+    alias: {
+      type: DataTypes.TEXT,
+      allowNull: true, // 别名，网络请求的别名，需要唯一，不能和username重复
+    },
+    password: {
+      type: DataTypes.STRING,
+      allowNull: true,
+    },
+    email: {
+      type: DataTypes.STRING,
+      allowNull: true,
+    },
+    avatar: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+    },
+    salt: {
+      type: DataTypes.STRING,
+      allowNull: true,
+    },
+    description: {
+      type: DataTypes.TEXT,
+    },
+    type: {
+      type: DataTypes.STRING,
+      defaultValue: 'user',
+    },
+    owner: {
+      type: DataTypes.UUID,
+    },
+    orgId: {
+      type: DataTypes.UUID,
+    },
+    needChangePassword: {
+      type: DataTypes.BOOLEAN,
+      defaultValue: false,
+    },
+    data: {
+      type: DataTypes.JSON,
+      defaultValue: {},
+    },
+  },
+  {
+    sequelize,
+    tableName: 'cf_user', // codeflow user
+    paranoid: true,
+  },
+);
+User.sync({ alter: true, logging: false })
+  .then((res) => {
+    initializeUser();
+  })
+  .catch((err) => {
+    console.error('Sync User error', err);
+  });
+
+const letter = 'abcdefghijklmnopqrstuvwxyz';
+const custom = customAlphabet(letter, 6);
+export const initializeUser = async (pwd = custom()) => {
+  const w = await User.findOne({ where: { username: 'root' }, logging: false });
+  if (!w) {
+    const root = await User.createUser('root', pwd, '系统管理员');
+    const org = await User.createOrg('admin', root.id, '管理员');
+    console.info(' new Users name', root.username, org.username);
+    console.info('new Users root password', pwd);
+    console.info('new Users id', root.id, org.id);
+    const demo = await createDemoUser();
+    return {
+      code: 200,
+      data: { root, org, pwd: pwd, demo },
+    };
+  } else {
+    return {
+      code: 500,
+      message: 'Users has been created',
+    };
+  }
+};
+export const createDemoUser = async (username = 'demo', pwd = custom()) => {
+  const u = await User.findOne({ where: { username }, logging: false });
+  if (!u) {
+    const user = await User.createUser(username, pwd, 'demo');
+    console.info('new Users name', user.username, pwd);
+    return {
+      code: 200,
+      data: { user, pwd: pwd },
+    };
+  } else {
+    console.info('Users has been created', u.username);
+    return {
+      code: 500,
+      message: 'Users has been created',
+    };
+  }
+};
+// initializeUser();
+
+export class UserServices extends User {
+  static async loginByPhone(phone: string) {
+    let user = await User.findOne({ where: { username: phone } });
+    let isNew = false;
+    if (!user) {
+      user = await User.createUser(phone, phone.slice(-6));
+      isNew = true;
+    }
+    const token = await user.createToken(null, 'season');
+    return { ...token, isNew };
+  }
+  static initializeUser = initializeUser;
+  static createDemoUser = createDemoUser;
+}
+
+useContextKey('UserModel', () => UserServices);

tsconfig.json

@@ -0,0 +1,40 @@
+{
+  "compilerOptions": {
+    "module": "nodenext",
+    "target": "esnext",
+    "noImplicitAny": false,
+    "outDir": "./dist",
+    "sourceMap": false,
+    "allowJs": true,
+    "newLine": "LF",
+    "baseUrl": "./",
+    "typeRoots": [
+      "node_modules/@types",
+      "//node_modules/@kevisual/types"
+    ],
+    "declaration": true,
+    "noEmit": false,
+    "allowImportingTsExtensions": true,
+    "emitDeclarationOnly": true,
+    "moduleResolution": "NodeNext",
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "esModuleInterop": true,
+    "paths": {
+      "@/*": [
+        "src/*"
+      ]
+    }
+  },
+  "include": [
+    "typings.d.ts",
+    "src/**/*.ts",
+    "test/**/*.ts",
+    "src-apps/**/*.ts",
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "src/**/*.test.ts"
+  ],
+}