karin-plugin-mys-core 1.0.1 → 1.0.2

package/lib/chunk-3CNBOOKY.js

@@ -0,0 +1,31 @@
+import {
+  MysDeviceInfoDB
+} from "./chunk-QMSYS77M.js";
+
+// src/exports/mys/user/deviceInfo.ts
+import md5 from "md5";
+var DeviceInfo = class {
+  static async get(Md5) {
+    return await (await MysDeviceInfoDB()).findByPk(Md5);
+  }
+  static async create(userId, deviceInfo) {
+    const deviceMd5 = md5([
+      userId,
+      deviceInfo.deviceId || "",
+      deviceInfo.name || "",
+      deviceInfo.board || "",
+      deviceInfo.model || "",
+      deviceInfo.oaid || "",
+      deviceInfo.version || "",
+      deviceInfo.fingerprint || "",
+      deviceInfo.product || ""
+    ].join("_"));
+    const MysDeviceInfo = await (await MysDeviceInfoDB()).findByPk(deviceMd5, true);
+    await MysDeviceInfo.save(deviceInfo);
+    return deviceMd5;
+  }
+};
+
+export {
+  DeviceInfo
+};

package/lib/chunk-5NA7ZPDS.js

@@ -0,0 +1,54 @@
+import {
+  Database
+} from "./chunk-G547WVGV.js";
+
+// src/exports/database/dbs/table.ts
+var Table = class {
+  #dialect;
+  #Database;
+  #DataDir;
+  #tableName;
+  #type;
+  constructor(DataDir, tableName, type) {
+    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) {
+    this.modelSchema = Schema;
+    this.initCache = await this.#Database.init(
+      this.#DataDir,
+      this.#tableName,
+      this.modelSchema,
+      this.#type
+    );
+    return this.#cache();
+  }
+  async addSchem(newSchema) {
+    this.modelSchema = Object.assign(this.modelSchema, newSchema);
+    this.initCache = await this.#Database.init(
+      this.#DataDir,
+      this.#tableName,
+      this.modelSchema,
+      this.#type
+    );
+    return this.#cache();
+  }
+};
+
+export {
+  Table
+};

package/lib/chunk-6PIXUPZ6.js

@@ -0,0 +1,82 @@
+// src/exports/config/array.ts
+import { logger } from "node-karin";
+import lodash from "node-karin/lodash";
+var EnhancedArray = class _EnhancedArray extends Array {
+  #keyPath;
+  #cfg;
+  constructor(cfg, items, path) {
+    super();
+    Object.setPrototypeOf(this, _EnhancedArray.prototype);
+    if (Array.isArray(items)) {
+      this.push(...items);
+    }
+    this.#cfg = cfg;
+    this.#keyPath = path;
+  }
+  /**
+   * @param element - string | number
+   * @returns
+   */
+  has(element) {
+    return new Set(this).has(element);
+  }
+  /**
+   * @param isEqual 是否不添加重复元素
+   * @param save 是否立即保存
+   */
+  add(element, isEqual, save) {
+    if (isEqual) {
+      const existingSet = new Set(this.map((item) => JSON.stringify(item)));
+      if (existingSet.has(JSON.stringify(element))) return this;
+    }
+    this.push(element);
+    this.#cfg.set(this.#keyPath, this.slice(), save);
+    return this;
+  }
+  /**
+   * @param isEqual 是否不添加重复元素
+   * @param save 是否立即保存
+   */
+  addSome(elements, isEqual, save) {
+    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);
+    this.#cfg.set(this.#keyPath, this.slice(), save);
+    return this;
+  }
+  remove(predicate, save, isIndex = false) {
+    if (isIndex && lodash.isNumber(predicate)) {
+      if (predicate < 0 || predicate >= this.length) {
+        logger.error(`\u7D22\u5F15 ${predicate} \u8D85\u51FA\u8303\u56F4 [0, ${this.length - 1}]`);
+        return this;
+      }
+      lodash.pullAt(this, predicate);
+    } else if (lodash.isFunction(predicate)) {
+      lodash.remove(this, predicate);
+    } else {
+      lodash.pull(this, predicate);
+    }
+    this.#cfg.set(this.#keyPath, this.slice(), save);
+    return this;
+  }
+  /**
+  * @param predicate - 要删除的元素数组
+  * @param save - 是否立即保存
+  */
+  removeSome(elements, save) {
+    lodash.pullAll(this, elements);
+    this.#cfg.set(this.#keyPath, this.slice(), save);
+    return this;
+  }
+  clear() {
+    this.length = 0;
+    return this;
+  }
+};
+
+export {
+  EnhancedArray
+};

package/lib/chunk-7WESXE4X.js

@@ -0,0 +1,29 @@
+import {
+  Table
+} from "./chunk-5NA7ZPDS.js";
+import {
+  Database
+} from "./chunk-G547WVGV.js";
+import {
+  dir
+} from "./chunk-SHLPPEAY.js";
+
+// src/exports/database/tables/mysUserInfo.ts
+var MysUserInfoTable = new Table(
+  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 {
+  MysUserInfoTable,
+  MysUserInfoDB
+};

package/lib/chunk-7YZHHLS5.js

@@ -0,0 +1,130 @@
+import {
+  EnhancedArray
+} from "./chunk-6PIXUPZ6.js";
+
+// src/exports/config/config.ts
+import { existsSync, logger, requireFileSync, watch, writeJsonSync } from "node-karin";
+import lodash from "node-karin/lodash";
+var Config = class {
+  #cfgName;
+  /**
+   * @description 配置缓存
+   */
+  #ConfigCache = null;
+  /**
+   * @description 默认配置
+   */
+  #DefaultConfig;
+  #IgnoreConfig;
+  /**
+   * @description 配置保存路径
+   */
+  #ConfigPath;
+  /**
+   * @param name 插件名称:配置名称
+   */
+  constructor(name, ConfigPath, DefaultConfig, IgnoreConfig) {
+    this.#cfgName = name;
+    this.#ConfigPath = ConfigPath;
+    this.#DefaultConfig = DefaultConfig;
+    this.#IgnoreConfig = IgnoreConfig;
+    !existsSync(ConfigPath) && writeJsonSync(ConfigPath, DefaultConfig);
+    this.loadConfig();
+  }
+  loadConfig() {
+    const config = requireFileSync(this.#ConfigPath);
+    const mergedConfig = this.mergeWithDefaults(config, this.#DefaultConfig, this.#IgnoreConfig);
+    this.#ConfigCache = mergedConfig;
+    return mergedConfig;
+  }
+  mergeWithDefaults(userConfig, defaultConfig, IgnoreConfig) {
+    const filterUserConfig = (user, defaults, Ignore) => {
+      if (Array.isArray(user) && Array.isArray(defaults)) {
+        if (Ignore?.defaultConfigItem) {
+          const filtered = [];
+          const required = Ignore.defaultConfigItem.required;
+          user.forEach((value, key) => {
+            if (required && lodash.isPlainObject(value)) {
+              const hasAllRequired = required.every((requiredKey) => requiredKey in value && value[requiredKey] !== void 0 && value[requiredKey] !== null && value[requiredKey] !== "");
+              if (!hasAllRequired) return;
+            }
+            filtered[key] = filterUserConfig(value, Ignore.defaultConfigItem.defaultConfig, Ignore.defaultConfigItem.defaultConfig);
+          });
+          return filtered;
+        }
+        return user;
+      } else if (lodash.isPlainObject(user) && lodash.isPlainObject(defaults)) {
+        const filtered = {};
+        const mergedValue = lodash.merge({}, defaults, user);
+        if (Ignore?.defaultConfig) {
+          lodash.forEach(user, (value, key) => {
+            const mergedValue2 = lodash.merge(Array.isArray(value) ? [] : {}, Ignore.defaultConfig, value);
+            filtered[key] = filterUserConfig(mergedValue2, Ignore.defaultConfig, Array.isArray(value) ? Ignore : Ignore[key]);
+          });
+        }
+        lodash.forEach(defaults, (value, key) => {
+          filtered[key] = filterUserConfig(mergedValue[key], value, Ignore?.[key]);
+        });
+        return filtered;
+      }
+      return user;
+    };
+    const filteredUserConfig = filterUserConfig(userConfig, defaultConfig, IgnoreConfig);
+    const result = lodash.merge({}, defaultConfig, filteredUserConfig);
+    if (!lodash.isEqual(result, userConfig)) {
+      try {
+        writeJsonSync(this.#ConfigPath, result);
+      } catch (err) {
+        logger.error(err);
+      }
+    }
+    return result;
+  }
+  /**
+   * @description 获取配置路径对应的默认配置
+   */
+  getDef(path) {
+    const defConfig = JSON.parse(JSON.stringify(this.#DefaultConfig));
+    return lodash.get(defConfig, path);
+  }
+  get(path, isArray = false, def) {
+    const conf = JSON.parse(JSON.stringify(this.#ConfigCache));
+    const result = path ? lodash.get(conf, path, def) : conf;
+    if (isArray) {
+      if (!Array.isArray(result)) {
+        logger.error(`\u914D\u7F6E\u8DEF\u5F84 ${path} \u4E0D\u662F\u6570\u7EC4\u7C7B\u578B`);
+        return new EnhancedArray(this, [], path);
+      }
+      return new EnhancedArray(this, result, path);
+    }
+    return result;
+  }
+  /**
+   * @param save 是否立即保存
+   */
+  set(path, value, save) {
+    lodash.set(this.#ConfigCache, path, value);
+    save && this.save();
+  }
+  /**
+   * @description 立即保存配置
+   */
+  save() {
+    try {
+      logger.debug(`[${this.#cfgName}] \u4FDD\u5B58\u914D\u7F6E`, this.#ConfigCache);
+      writeJsonSync(this.#ConfigPath, this.#ConfigCache);
+    } catch (err) {
+      logger.error(err);
+    }
+  }
+  watch() {
+    watch(this.#ConfigPath, () => {
+      this.loadConfig();
+    });
+    return this;
+  }
+};
+
+export {
+  Config
+};

package/lib/chunk-EMAUATE3.js

@@ -0,0 +1,217 @@
+import {
+  DbBase
+} from "./chunk-Y3J3J5B2.js";
+import {
+  DatabaseArray
+} from "./chunk-JVJQKRJ4.js";
+import {
+  dir
+} from "./chunk-SHLPPEAY.js";
+
+// src/exports/database/dbs/sqlite3.ts
+import { existsSync, json, logger, mkdirSync, rmSync } from "node-karin";
+import fs from "fs";
+import path from "path";
+import { DataTypes, Op, Sequelize } from "sequelize";
+var dialect = "sqlite" /* Sqlite */;
+var sequelize = new Sequelize({
+  storage: path.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) {
+      logger.error(error);
+      return false;
+    }
+  }
+  async init(DataDir, modelName, modelSchema, type) {
+    this.initBase(DataDir, modelName, modelSchema, type);
+    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 path2 = this.userPath(pk);
+      if (!existsSync(path2)) {
+        if (create) {
+          const data = this.schemaToJSON(pk);
+          if (this.databaseType === "dir" /* Dir */) {
+            mkdirSync(path2);
+            this.writeDirSync(pk, data);
+            return {
+              ...data,
+              save: this.saveDir(pk),
+              destroy: () => this.destroyPath(pk)
+            };
+          } else {
+            json.writeSync(path2, 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(path2, 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 path2 = this.userPath(pk);
+        if (existsSync(path2)) {
+          if (this.databaseType === "dir" /* Dir */) {
+            result.push(this.readDirSync(pk));
+          } else {
+            result.push(this.readSync(path2, 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 = fs.readdirSync(this.databasePath);
+      if (this.databaseType === "dir" /* Dir */) {
+        files.forEach((file) => {
+          if (excludeSet.has(file)) return;
+          const stat = fs.statSync(path.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 */) {
+      rmSync(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 {
+      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 {
+      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));
+      }
+    };
+  }
+}();
+
+export {
+  Sqlite3,
+  Sqlite3Static
+};

package/lib/chunk-G547WVGV.js

@@ -0,0 +1,73 @@
+import {
+  Sqlite3,
+  Sqlite3Static
+} from "./chunk-EMAUATE3.js";
+
+// src/exports/database/database.ts
+import { logger } from "node-karin";
+import { DataTypes } from "sequelize";
+var Database = new class DatabaseClass {
+  #defaultDialect = "sqlite" /* Sqlite */;
+  #DatabaseMap = /* @__PURE__ */ new Map();
+  default(dialect) {
+    const db = this.#DatabaseMap.get(dialect);
+    if (!db) {
+      logger.error(`\u672A\u627E\u5230\u6570\u636E\u5E93: ${dialect}\uFF01\u4F7F\u7528\u9ED8\u8BA4\u6570\u636E\u5E93\u3002`);
+      return;
+    }
+    this.#defaultDialect = dialect;
+  }
+  /** @description 添加数据库 */
+  async Add(Db, Static) {
+    const db = Db();
+    if (await db.check()) {
+      this.#DatabaseMap.set(Static.dialect, { Database: Db, Static });
+    } else {
+      logger.error(`${Static.dialect} check failed!`);
+    }
+  }
+  get Db() {
+    const dialect = this.#defaultDialect;
+    const db = this.#DatabaseMap.get(dialect);
+    if (!db) {
+      logger.error(`\u672A\u627E\u5230\u6570\u636E\u5E93: ${dialect}\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(([dialect, { Static }]) => ({
+      dialect,
+      desc: Static.description
+    }));
+  }
+  /** @description 获取当前使用的数据库 */
+  get() {
+    return this.Db.Database();
+  }
+  get PkColumn() {
+    return (type, option) => ({
+      type: DataTypes[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
+);
+
+export {
+  Database
+};

package/lib/chunk-G5W5WAY5.js

@@ -0,0 +1,64 @@
+// src/exports/mys/api/app.ts
+var version = { cn: "2.70.1", os: "1.5.0" };
+var appId = 2;
+var salt = {
+  os: "6cqshh5dhw73bzxn20oexa9k516chk7s",
+  "4X": "xV8v4Qu54lUKrEYFZkJhB8cuOh9Asafs",
+  "6X": "t0qEgfub6cvueAPgR5m9aQWWVciEer7v",
+  K2: "S9Hrn38d2b55PamfIR9BNA3Tx9sQTOem",
+  LK2: "sjdNFJB7XxyDWGIAk0eTV8AOCfMJmyEo",
+  PROD: "JwYDpKvLj6MrMqqYU6jTKF17KNO2PXoS"
+};
+var MysApp = Object.freeze({
+  version,
+  appId,
+  salt
+});
+var MysHosts = Object.freeze({
+  bbs: {
+    ["mihoyo" /* cn */]: "https://bbs-api.miyoushe.com/",
+    ["hoyolab" /* os */]: "https://bbs-api-os.mihoyo.com/"
+  },
+  web: {
+    ["mihoyo" /* cn */]: "https://api-takumi.mihoyo.com/",
+    ["hoyolab" /* os */]: "https://api-os-takumi.mihoyo.com/",
+    /** new web host */
+    miyoushe: "https://api-takumi.miyoushe.com/"
+  },
+  static: "https://api-takumi-static.mihoyo.com/",
+  record: {
+    ["mihoyo" /* cn */]: "https://api-takumi-record.mihoyo.com/",
+    ["hoyolab" /* os */]: "https://bbs-api-os.mihoyo.com/"
+  },
+  hk4e: {
+    ["mihoyo" /* cn */]: "https://hk4e-api.mihoyo.com/",
+    ["hoyolab" /* os */]: "https://hk4e-api-os.hoyoverse.com/"
+  },
+  hk4eGacha: "https://public-operation-hk4e.mihoyo.com/",
+  hk4eSdk: "https://hk4e-sdk.mihoyo.com/",
+  napGacha: {
+    ["mihoyo" /* cn */]: "https://public-operation-nap.mihoyo.com/",
+    ["hoyolab" /* os */]: "https://public-operation-nap-sg.hoyoverse.com/"
+  },
+  publicData: {
+    ["mihoyo" /* cn */]: "https://public-data-api.mihoyo.com/",
+    ["hoyolab" /* os */]: "https://sg-public-data-api.hoyoverse.com/"
+  },
+  napAct: {
+    ["mihoyo" /* cn */]: "https://act-nap-api.mihoyo.com/",
+    ["hoyolab" /* os */]: "https://sg-act-nap-api.mihoyo.com/"
+  },
+  passport: "https://passport-api.mihoyo.com/",
+  hk4eSg: {
+    ["hoyolab" /* os */]: "https://sg-hk4e-api.hoyolab.com/"
+  },
+  publicSg: {
+    ["hoyolab" /* os */]: "https://sg-public-api.hoyolab.com/",
+    hoyoverse: "https://sg-public-api.hoyoverse.com/"
+  }
+});
+
+export {
+  MysApp,
+  MysHosts
+};