karin-plugin-mys-core 1.0.11 → 1.0.13

package/lib/chunk-HKSHKXRI.js

@@ -0,0 +1,21 @@
+import {
+  dir
+} from "./chunk-SHLPPEAY.js";
+import {
+  Config
+} from "./chunk-UIPRZFST.js";
+
+// src/core/config/device.ts
+var DefaultDevice = {
+  version: 12,
+  name: "aurora",
+  board: "24031PN0DC",
+  model: "24031PN0DC",
+  product: "aurora",
+  fingerprint: "Xiaomi/aurora/aurora:12/V417IR/813:user/release-keys"
+};
+var DeviceCfg = new Config(`${dir.name}:device`, dir.ConfigDir, DefaultDevice, {}).watch();
+
+export {
+  DeviceCfg
+};

package/lib/chunk-IASM5MM5.js

@@ -0,0 +1,639 @@
+import {
+  dir
+} from "./chunk-SHLPPEAY.js";
+import {
+  common_exports
+} from "./chunk-RX4VMVAI.js";
+
+// src/exports/database/database.ts
+import { logger as logger4 } from "node-karin";
+import { DataTypes as DataTypes2 } from "sequelize";
+
+// src/exports/database/dbs/sqlite3.ts
+import { existsSync, json as json2, logger as logger3, mkdirSync, rmSync as rmSync2 } from "node-karin";
+import fs2 from "fs";
+import path2 from "path";
+import { DataTypes, Op, Sequelize } from "sequelize";
+
+// src/exports/database/types/dbs/base.ts
+import { logger } from "node-karin";
+import lodash from "node-karin/lodash";
+var Dialect = /* @__PURE__ */ ((Dialect2) => {
+  Dialect2["Sqlite"] = "sqlite";
+  Dialect2["MySQL"] = "mysql";
+  Dialect2["MariaDB"] = "mariadb";
+  Dialect2["PostgreSQL"] = "postgres";
+  Dialect2["MSSQL"] = "mssql";
+  Dialect2["Oracle"] = "oracle";
+  Dialect2["DB2"] = "db2";
+  Dialect2["Snowflake"] = "snowflake";
+  return Dialect2;
+})(Dialect || {});
+var DatabaseType = /* @__PURE__ */ ((DatabaseType3) => {
+  DatabaseType3["File"] = "file";
+  DatabaseType3["Dir"] = "dir";
+  DatabaseType3["Db"] = "db";
+  return DatabaseType3;
+})(DatabaseType || {});
+var DatabaseArray = class _DatabaseArray extends Array {
+  constructor(items) {
+    super();
+    Object.setPrototypeOf(this, _DatabaseArray.prototype);
+    if (Array.isArray(items)) {
+      this.push(...items);
+    }
+  }
+  /**
+  * @param element - string | number
+  * @returns
+  */
+  has(element) {
+    return new Set(this).has(element);
+  }
+  /**
+   * @param isEqual 是否不添加重复元素
+   */
+  add(element, isEqual) {
+    if (isEqual) {
+      const existingSet = new Set(this.map((item) => JSON.stringify(item)));
+      if (existingSet.has(JSON.stringify(element))) return this;
+    }
+    this.push(element);
+    return this;
+  }
+  /**
+   * @param isEqual 是否不添加重复元素
+   */
+  addSome(elements, isEqual) {
+    if (isEqual) {
+      const existingSet = new Set(this.map((item) => JSON.stringify(item)));
+      elements = elements.filter((element) => !existingSet.has(JSON.stringify(element)));
+      if (elements.length === 0) return this;
+    }
+    this.push(...elements);
+    return this;
+  }
+  /**
+   * @param isIndex predicate是否为索引
+   */
+  remove(predicate, isIndex = false) {
+    let newArr = [];
+    if (isIndex && lodash.isNumber(predicate)) {
+      if (predicate < 0 || predicate >= this.length) {
+        logger.error(`DatabaseArray\u7D22\u5F15 ${predicate} \u8D85\u51FA\u8303\u56F4`);
+        return this;
+      }
+      newArr = [...this.slice(0, predicate), ...this.slice(predicate + 1)];
+    } else if (lodash.isFunction(predicate)) {
+      newArr = this.filter((item) => !predicate(item));
+    } else {
+      newArr = lodash.without(this, predicate);
+    }
+    this.length = 0;
+    this.push(...newArr);
+    return this;
+  }
+  clear() {
+    this.length = 0;
+    return this;
+  }
+};
+
+// src/exports/database/types/tables/mysAccountInfo.ts
+var MysAccountType = /* @__PURE__ */ ((MysAccountType2) => {
+  MysAccountType2["cn"] = "mihoyo";
+  MysAccountType2["os"] = "hoyolab";
+  return MysAccountType2;
+})(MysAccountType || {});
+
+// src/exports/database/types/tables/mysUserInfo.ts
+var UidPermission = /* @__PURE__ */ ((UidPermission2) => {
+  UidPermission2[UidPermission2["BIND"] = 0] = "BIND";
+  UidPermission2[UidPermission2["CK"] = 1] = "CK";
+  UidPermission2[UidPermission2["ST"] = 2] = "ST";
+  UidPermission2[UidPermission2["CS"] = 3] = "CS";
+  UidPermission2[UidPermission2["DEL"] = 4] = "DEL";
+  return UidPermission2;
+})(UidPermission || {});
+
+// src/exports/database/dbs/base.ts
+import { existToMkdirSync, json, logger as logger2, rmSync } from "node-karin";
+import lodash2 from "node-karin/lodash";
+import fs from "fs";
+import path from "path";
+var DbBase = class {
+  primaryKey;
+  initBase(DataDir, modelName, modelSchema, modelSchemaDefine, type, primaryKey) {
+    this.primaryKey = primaryKey;
+    this.databaseType = type;
+    this.databasePath = path.join(DataDir, modelName);
+    if (type !== "db" /* Db */) {
+      existToMkdirSync(this.databasePath);
+    }
+    this.modelName = modelName;
+    this.modelSchema = modelSchema;
+    this.modelSchemaDefine = modelSchemaDefine;
+  }
+  schemaToJSON(pk) {
+    const primaryKey = this.model?.primaryKeyAttribute || this.primaryKey;
+    const result = {
+      [primaryKey]: pk
+    };
+    lodash2.forEach(this.modelSchema, (value, key) => {
+      if (key !== primaryKey) {
+        const Value = typeof value.defaultValue === "function" ? value.defaultValue() : value.defaultValue;
+        result[key] = value.JsonColumn ? JSON.parse(Value) : value.ArrayColumn ? Value.split(",") : Value;
+      }
+    });
+    return result;
+  }
+  userPath(pk) {
+    if (this.databaseType === "dir" /* Dir */) {
+      return path.join(this.databasePath, pk);
+    }
+    return path.join(this.databasePath, `${pk}.json`);
+  }
+  readSync(path3, pk) {
+    const result = json.readSync(path3);
+    result.save = this.saveFile(pk);
+    result.destroy = () => this.destroyPath(pk);
+    return result;
+  }
+  readDirSync(pk) {
+    const path3 = this.userPath(pk);
+    const files = fs.readdirSync(path3);
+    const result = {
+      save: this.saveDir(pk),
+      destroy: () => this.destroyPath(pk),
+      [this.primaryKey]: pk
+    };
+    const filePromises = files.map(async (file) => {
+      const data = await json.read(`${path3}/${file}`);
+      result[data.key] = data.data;
+    });
+    Promise.all(filePromises).then().catch((err) => {
+      logger2.error(err);
+    });
+    return result;
+  }
+  writeDirSync(pk, data) {
+    const path3 = this.userPath(pk);
+    lodash2.forEach(this.modelSchema, (value, key) => {
+      if (key !== this.primaryKey) {
+        const mergeData = common_exports.filterData(data[key], value.defaultValue, this.modelSchemaDefine[key]);
+        json.writeSync(`${path3}/${key}.json`, {
+          key,
+          [this.primaryKey]: pk,
+          data: mergeData
+        });
+      }
+    });
+    return true;
+  }
+  saveFile(pk) {
+    return async (data) => {
+      const userPath = this.userPath(pk);
+      const mergeData = common_exports.filterData(data, this.schemaToJSON(pk), this.modelSchemaDefine);
+      delete data[this.primaryKey];
+      json.writeSync(userPath, mergeData);
+      return this.readSync(userPath, pk);
+    };
+  }
+  saveDir(pk) {
+    return async (data) => {
+      delete data[this.primaryKey];
+      this.writeDirSync(pk, data);
+      return this.readDirSync(pk);
+    };
+  }
+  destroyPath(pk) {
+    return new Promise((resolve) => {
+      const userPath = this.userPath(pk);
+      try {
+        rmSync(userPath, { recursive: true });
+        resolve(true);
+      } catch (err) {
+        logger2.error(err);
+        resolve(false);
+      }
+    });
+  }
+  saveSql(model, pk) {
+    return async (data) => {
+      delete data[this.model.primaryKeyAttribute];
+      const defData = this.schemaToJSON(pk);
+      const mergeData = {};
+      lodash2.forEach(data, (value, key) => {
+        if (value !== void 0 && value !== null) {
+          mergeData[key] = common_exports.filterData(value, defData[key], this.modelSchemaDefine[key]);
+        }
+      });
+      const result = await model.update(mergeData);
+      return {
+        ...result.toJSON(),
+        save: this.saveSql(result, pk),
+        destroy: () => this.destroySql(pk)
+      };
+    };
+  }
+  destroySql(pk) {
+    return new Promise((resolve) => {
+      const result = this.model.destroy({ where: { [this.model.primaryKeyAttribute]: pk } }).then((count) => count > 0).catch(() => false);
+      resolve(result);
+    });
+  }
+};
+
+// src/exports/database/dbs/sqlite3.ts
+var dialect = "sqlite" /* Sqlite */;
+var sequelize = new Sequelize({
+  storage: path2.join(dir.DataDir, "database", "sqlite3.db"),
+  dialect,
+  logging: false
+});
+var Sqlite3 = class extends DbBase {
+  dialect = dialect;
+  async check() {
+    try {
+      await sequelize.authenticate();
+      return true;
+    } catch (error) {
+      logger3.error(error);
+      return false;
+    }
+  }
+  async init(DataDir, modelName, modelSchema, modelSchemaDefine, type, primaryKey) {
+    this.initBase(DataDir, modelName, modelSchema, modelSchemaDefine, type, primaryKey);
+    if (this.databaseType === "db" /* Db */) {
+      this.model = sequelize.define(this.modelName, this.modelSchema, {
+        timestamps: false,
+        freezeTableName: true
+      });
+      await this.model.sync();
+      const queryInterface = sequelize.getQueryInterface();
+      const tableDescription = await queryInterface.describeTable(this.modelName);
+      for (const key in this.modelSchema) {
+        if (!tableDescription[key]) {
+          await queryInterface.addColumn(this.modelName, key, this.modelSchema[key]);
+          if (typeof this.modelSchema[key] === "string") continue;
+          const defaultValue = this.modelSchema[key].defaultValue;
+          if (defaultValue !== void 0) {
+            await this.model.update({ [key]: defaultValue }, { where: {} });
+          }
+        }
+      }
+    }
+    return this;
+  }
+  async findByPk(pk, create = false) {
+    if (this.databaseType !== "db" /* Db */) {
+      const path3 = this.userPath(pk);
+      if (!existsSync(path3)) {
+        if (create) {
+          const data = this.schemaToJSON(pk);
+          if (this.databaseType === "dir" /* Dir */) {
+            mkdirSync(path3);
+            this.writeDirSync(pk, data);
+            return {
+              ...data,
+              save: this.saveDir(pk),
+              destroy: () => this.destroyPath(pk)
+            };
+          } else {
+            json2.writeSync(path3, data);
+            return {
+              ...data,
+              save: this.saveFile(pk),
+              destroy: () => this.destroyPath(pk)
+            };
+          }
+        }
+        return void 0;
+      }
+      if (this.databaseType === "dir" /* Dir */) {
+        return this.readDirSync(pk);
+      } else {
+        return this.readSync(path3, pk);
+      }
+    } else {
+      let result = await this.model.findByPk(pk);
+      if (!result && create) {
+        result = await this.model.create(this.schemaToJSON(pk));
+      }
+      if (!result) return void 0;
+      return {
+        ...result.toJSON(),
+        save: this.saveSql(result, pk),
+        destroy: () => this.destroySql(pk)
+      };
+    }
+  }
+  async findAllByPks(pks) {
+    if (this.databaseType !== "db" /* Db */) {
+      const result = [];
+      pks.forEach((pk) => {
+        const path3 = this.userPath(pk);
+        if (existsSync(path3)) {
+          if (this.databaseType === "dir" /* Dir */) {
+            result.push(this.readDirSync(pk));
+          } else {
+            result.push(this.readSync(path3, pk));
+          }
+        }
+      });
+      return result;
+    } else {
+      const result = await this.model.findAll({
+        where: {
+          [this.model.primaryKeyAttribute]: pks
+        }
+      });
+      return result.map((item) => ({
+        ...item.toJSON(),
+        save: this.saveSql(item, item[this.model.primaryKeyAttribute]),
+        destroy: () => this.destroySql(item[this.model.primaryKeyAttribute])
+      }));
+    }
+  }
+  async findAll(excludePks) {
+    const excludeSet = new Set(excludePks || []);
+    if (this.databaseType !== "db" /* Db */) {
+      const result = [];
+      const files = fs2.readdirSync(this.databasePath);
+      if (this.databaseType === "dir" /* Dir */) {
+        files.forEach((file) => {
+          if (excludeSet.has(file)) return;
+          const stat = fs2.statSync(path2.join(this.databasePath, file));
+          if (stat.isDirectory()) {
+            result.push(this.readDirSync(file));
+          }
+        });
+      } else {
+        files.forEach((file) => {
+          if (!file.endsWith(".json")) return;
+          const pk = file.replace(".json", "");
+          if (excludeSet.has(pk)) return;
+          result.push(this.readSync(this.userPath(pk), pk));
+        });
+      }
+      return result;
+    } else {
+      const whereClause = excludePks && excludePks.length > 0 ? { [this.model.primaryKeyAttribute]: { [Op.notIn]: excludePks } } : {};
+      const result = await this.model.findAll({ where: whereClause });
+      return result.map((item) => ({
+        ...item.toJSON(),
+        save: this.saveSql(item, item[this.model.primaryKeyAttribute]),
+        destroy: () => this.destroySql(item[this.model.primaryKeyAttribute])
+      }));
+    }
+  }
+  async destroy(pk) {
+    if (this.databaseType !== "db" /* Db */) {
+      rmSync2(this.userPath(pk), { recursive: true });
+      return true;
+    } else {
+      const destroyed = await this.model.destroy({
+        where: { [this.model.primaryKeyAttribute]: pk }
+      });
+      return destroyed > 0;
+    }
+  }
+};
+var Sqlite3Static = new class Sqlite3Static2 {
+  dialect = dialect;
+  description = "\u63D2\u4EF6\u9ED8\u8BA4\u6570\u636E\u5E93";
+  Column(type, def, option) {
+    return {
+      type: DataTypes[type],
+      defaultValue: def,
+      ...option
+    };
+  }
+  ArrayColumn(key, fn) {
+    return {
+      ArrayColumn: true,
+      type: DataTypes.STRING,
+      defaultValue: [].join(","),
+      get() {
+        const data = this.getDataValue(key).split(",").filter(Boolean);
+        return new DatabaseArray(data);
+      },
+      set(data) {
+        const setData = (fn ? fn(data) : data) || [];
+        this.setDataValue(key, setData.join(","));
+      }
+    };
+  }
+  JsonColumn(key, def) {
+    return {
+      JsonColumn: true,
+      type: DataTypes.STRING,
+      defaultValue: JSON.stringify(def),
+      get() {
+        let data = this.getDataValue(key);
+        try {
+          data = JSON.parse(data) || def;
+        } catch (e) {
+          data = def;
+        }
+        return data;
+      },
+      set(data) {
+        this.setDataValue(key, JSON.stringify(data));
+      }
+    };
+  }
+}();
+
+// src/exports/database/database.ts
+var Database = new class DatabaseClass {
+  #defaultDialect = "sqlite" /* Sqlite */;
+  #DatabaseMap = /* @__PURE__ */ new Map();
+  default(dialect2) {
+    const db = this.#DatabaseMap.get(dialect2);
+    if (!db) {
+      logger4.error(`\u672A\u627E\u5230\u6570\u636E\u5E93: ${dialect2}\uFF01\u4F7F\u7528\u9ED8\u8BA4\u6570\u636E\u5E93\u3002`);
+      return;
+    }
+    this.#defaultDialect = dialect2;
+  }
+  /** @description 添加数据库 */
+  async Add(Db, Static) {
+    const db = Db();
+    if (await db.check()) {
+      this.#DatabaseMap.set(Static.dialect, { Database: Db, Static });
+    } else {
+      logger4.error(`${Static.dialect} check failed!`);
+    }
+  }
+  get Db() {
+    const dialect2 = this.#defaultDialect;
+    const db = this.#DatabaseMap.get(dialect2);
+    if (!db) {
+      logger4.error(`\u672A\u627E\u5230\u6570\u636E\u5E93: ${dialect2}\uFF01\u4F7F\u7528\u9ED8\u8BA4\u6570\u636E\u5E93\u3002`);
+      return this.#DatabaseMap.get("sqlite" /* Sqlite */);
+    }
+    return db;
+  }
+  get details() {
+    return Array.from(this.#DatabaseMap.entries()).map(([dialect2, { Static }]) => ({
+      dialect: dialect2,
+      desc: Static.description
+    }));
+  }
+  /** @description 获取当前使用的数据库 */
+  get() {
+    return this.Db.Database();
+  }
+  get PkColumn() {
+    return (type, option) => ({
+      type: DataTypes2[type],
+      primaryKey: true,
+      allowNull: false,
+      ...option
+    });
+  }
+  get Column() {
+    return this.Db.Static.Column;
+  }
+  get ArrayColumn() {
+    return this.Db.Static.ArrayColumn;
+  }
+  get JsonColumn() {
+    return this.Db.Static.JsonColumn;
+  }
+}();
+await Database.Add(
+  () => new Sqlite3(),
+  Sqlite3Static
+);
+
+// src/exports/database/dbs/table.ts
+var Table = class {
+  #dialect;
+  #Database;
+  #DataDir;
+  #tableName;
+  #type;
+  #primaryKey;
+  /**
+   * @param type Db: 直接保存在sqlite数据中、 File: 保存在单个json文件中、 Dir: 保存在多个json文件的目录中、Schema中除pk外每一个键值对应一个文件 e.g tableName/user/key.json
+   */
+  constructor(DataDir, tableName, type, primaryKey) {
+    this.#primaryKey = primaryKey;
+    this.#Database = Database.get();
+    this.#dialect = this.#Database.dialect;
+    this.#DataDir = DataDir;
+    this.#tableName = tableName;
+    this.#type = type;
+  }
+  #cache() {
+    return async () => {
+      const Db = Database.get();
+      if (Db.dialect !== this.#dialect) {
+        this.#dialect = Db.dialect;
+        this.#Database = Db;
+        await this.init(this.modelSchema);
+      }
+      return this.initCache;
+    };
+  }
+  async init(Schema, SchemaDefine = {}) {
+    this.modelSchema = Schema;
+    this.modelSchemaDefine = SchemaDefine;
+    this.initCache = await this.#Database.init(
+      this.#DataDir,
+      this.#tableName,
+      this.modelSchema,
+      this.modelSchemaDefine,
+      this.#type,
+      this.#primaryKey
+    );
+    return this.#cache();
+  }
+  async addSchem(newSchema, SchemaDefine = {}) {
+    this.modelSchema = Object.assign(this.modelSchema, newSchema);
+    this.modelSchemaDefine = Object.assign(this.modelSchemaDefine, SchemaDefine);
+    this.initCache = await this.#Database.init(
+      this.#DataDir,
+      this.#tableName,
+      this.modelSchema,
+      this.modelSchemaDefine,
+      this.#type
+    );
+    return this.#cache();
+  }
+};
+function createTable(DataDir, tableName, type, primaryKey) {
+  return new Table(DataDir, tableName, type, primaryKey);
+}
+
+// src/exports/database/tables/mysAccountInfo.ts
+var MysAccountInfoTable = createTable(
+  dir.DataDir,
+  "mys_account_info_data",
+  "db" /* Db */
+);
+var MysAccountInfoDB = await MysAccountInfoTable.init(
+  {
+    ltuid: Database.PkColumn("STRING"),
+    type: Database.Column("STRING", "mihoyo" /* cn */),
+    cookie: Database.Column("TEXT", ""),
+    stoken: Database.Column("STRING", ""),
+    deviceMd5: Database.Column("STRING", "")
+  }
+);
+
+// src/exports/database/tables/mysDeviceInfo.ts
+var MysDeviceInfoTable = createTable(
+  dir.DataDir,
+  "mys_device_info_data",
+  "db" /* Db */
+);
+var MysDeviceInfoDB = await MysDeviceInfoTable.init(
+  {
+    md5: Database.PkColumn("STRING"),
+    deviceId: Database.Column("STRING", common_exports.getDeviceGuid),
+    deviceFp: Database.Column("STRING", ""),
+    name: Database.Column("STRING", ""),
+    board: Database.Column("STRING", ""),
+    model: Database.Column("STRING", ""),
+    oaid: Database.Column("STRING", ""),
+    version: Database.Column("INTEGER", 12),
+    fingerprint: Database.Column("STRING", ""),
+    product: Database.Column("STRING", "")
+  }
+);
+
+// src/exports/database/tables/mysUserInfo.ts
+var MysUserInfoTable = createTable(
+  dir.DataDir,
+  "mys_user_info_data",
+  "db" /* Db */
+);
+var MysUserInfoDB = await MysUserInfoTable.init(
+  {
+    userId: Database.PkColumn("STRING"),
+    ltuids: Database.ArrayColumn("ltuids"),
+    stuids: Database.ArrayColumn("stuids"),
+    deviceList: Database.ArrayColumn("deviceList")
+  }
+);
+
+export {
+  Dialect,
+  DatabaseType,
+  DatabaseArray,
+  MysAccountType,
+  UidPermission,
+  DbBase,
+  Database,
+  Table,
+  createTable,
+  MysAccountInfoTable,
+  MysAccountInfoDB,
+  MysDeviceInfoTable,
+  MysDeviceInfoDB,
+  MysUserInfoTable,
+  MysUserInfoDB
+};

package/lib/{chunk-5DXIT7UB.js → chunk-RX4VMVAI.js}

@@ -79,10 +79,5 @@ function filterData(user, defaults, Define) {
 }
 
 export {
-  randomString,
-  getDeviceGuid,
-  StrToObj,
-  ObjToStr,
-  filterData,
   common_exports
 };