karin-plugin-mys-core 1.0.0

package/lib/chunk-7QISGXVH.js

@@ -0,0 +1,347 @@
+import {
+  dir
+} from "./chunk-JML6VYXN.js";
+
+// src/database/dbs/base.ts
+import { json, logger } from "node-karin";
+import lodash from "node-karin/lodash";
+import fs from "fs";
+import path from "path";
+var DbBase = class {
+  schemaToJSON(pk) {
+    const result = {
+      [this.model.primaryKeyAttribute]: pk
+    };
+    lodash.forEach(this.modelSchema, (value, key) => {
+      if (key !== this.model.primaryKeyAttribute) {
+        result[key] = typeof value.defaultValue === "function" ? value.defaultValue() : value.defaultValue;
+      }
+    });
+    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);
+    return result;
+  }
+  readDirSync(pk) {
+    const path3 = this.userPath(pk);
+    const files = fs.readdirSync(path3);
+    const result = {
+      _save: this.saveDir(pk),
+      [this.model.primaryKeyAttribute]: 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) => {
+      logger.error(err);
+    });
+    return result;
+  }
+  writeFileSync(pk, data) {
+    const defData = this.schemaToJSON(pk);
+    for (const key in data) {
+      !(key in defData) && delete data[key];
+    }
+    json.writeSync(this.userPath(pk), lodash.merge({}, defData, data));
+    return true;
+  }
+  writeDirSync(pk, data) {
+    const path3 = this.userPath(pk);
+    lodash.forEach(this.modelSchema, (value, key) => {
+      if (key !== this.model.primaryKeyAttribute) {
+        const result = {
+          key,
+          [this.model.primaryKeyAttribute]: pk,
+          data: data[key] || value.defaultValue
+        };
+        json.writeSync(`${path3}/${key}.json`, result);
+      }
+    });
+    return true;
+  }
+  saveFile(pk) {
+    return async (data) => {
+      delete data[this.model.primaryKeyAttribute];
+      this.writeFileSync(pk, data);
+    };
+  }
+  saveDir(pk) {
+    return async (data) => {
+      delete data[this.model.primaryKeyAttribute];
+      this.writeDirSync(pk, data);
+    };
+  }
+  saveSql(model, pk) {
+    return async (data) => {
+      delete data[this.model.primaryKeyAttribute];
+      const Attributes = this.schemaToJSON(pk);
+      for (const key in data) {
+        !(key in Attributes) && delete data[key];
+      }
+      await model.update(data);
+    };
+  }
+};
+
+// src/database/database.ts
+import { logger as logger3 } from "node-karin";
+import { DataTypes as DataTypes2 } from "sequelize";
+
+// src/database/dbs/sqlite3.ts
+import { json as json2, logger as logger2 } from "node-karin";
+import fs2 from "fs";
+import path2 from "path";
+import { DataTypes, Sequelize } from "sequelize";
+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) {
+      logger2.error(error);
+      return false;
+    }
+  }
+  async init(DataDir, modelName, modelSchema, type) {
+    this.databaseType = type;
+    this.databasePath = path2.join(DataDir, modelName);
+    if (type !== "db" /* Db */) {
+      fs2.mkdirSync(this.databasePath);
+    }
+    this.modelName = modelName;
+    this.modelSchema = modelSchema;
+    if (this.databaseType === "db" /* Db */) {
+      this.model = sequelize.define(this.modelName, this.modelSchema, {
+        timestamps: false
+      });
+      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 (!fs2.existsSync(path3)) {
+        if (create) {
+          const data = this.schemaToJSON(pk);
+          if (this.databaseType === "dir" /* Dir */) {
+            fs2.mkdirSync(path3);
+            this.writeDirSync(pk, data);
+          } else {
+            json2.writeSync(path3, data);
+          }
+          return {
+            ...data,
+            _save: this.saveFile(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)
+      };
+    }
+  }
+  async findAllByPks(pks) {
+    if (this.databaseType !== "db" /* Db */) {
+      const result = [];
+      pks.forEach((pk) => {
+        const path3 = this.userPath(pk);
+        if (fs2.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])
+      }));
+    }
+  }
+  async destroy(pk) {
+    if (this.databaseType !== "db" /* Db */) {
+      const path3 = this.userPath(pk);
+      if (this.databaseType === "dir" /* Dir */) {
+        fs2.rmdirSync(path3, { recursive: true });
+      } else {
+        fs2.unlinkSync(path3);
+      }
+      return true;
+    } else {
+      const destroyed = await this.model.destroy({
+        where: { [this.model.primaryKeyAttribute]: pk }
+      });
+      return destroyed > 0;
+    }
+  }
+};
+var Sqlite3Static = new class Sqlite3Static2 {
+  Column(type, def, option) {
+    return {
+      type: DataTypes[type],
+      defaultValue: def,
+      ...option
+    };
+  }
+  ArrayColumn(key, fn) {
+    return {
+      type: DataTypes.STRING,
+      defaultValue: [].join(","),
+      get() {
+        return this.getDataValue(key).split(",").filter(Boolean);
+      },
+      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));
+      }
+    };
+  }
+}();
+
+// src/database/database.ts
+var DatabaseClass = class {
+  #defaultDatabase;
+  #defaultDatabaseStatic;
+  constructor() {
+    this.#defaultDatabase = () => new Sqlite3();
+    this.#defaultDatabaseStatic = Sqlite3Static;
+  }
+  /** 设置默认数据库 */
+  async default(Database2, Static) {
+    const db = Database2();
+    if (await db.check()) {
+      this.#defaultDatabase = Database2;
+      this.#defaultDatabaseStatic = Static;
+    } else {
+      logger3.error();
+    }
+  }
+  /** 获取当前使用的数据库 */
+  get() {
+    return this.#defaultDatabase();
+  }
+  get PkColumn() {
+    return (type, option) => ({
+      type: DataTypes2[type],
+      primaryKey: true,
+      allowNull: false,
+      ...option
+    });
+  }
+  get Column() {
+    return this.#defaultDatabaseStatic.Column;
+  }
+  get ArrayColumn() {
+    return this.#defaultDatabaseStatic.ArrayColumn;
+  }
+  get JsonColumn() {
+    return this.#defaultDatabaseStatic.JsonColumn;
+  }
+};
+var Database = new DatabaseClass();
+
+// src/database/tables/mysAccountInfo.ts
+var DB = Database.get();
+var MysAccountInfoDB = await DB.init(
+  dir.DataDir,
+  "mysAccountInfoData",
+  {
+    ltuid: Database.PkColumn("STRING"),
+    type: Database.Column("STRING", "mihoyo" /* cn */),
+    cookie: Database.Column("TEXT", ""),
+    stoken: Database.Column("STRING", ""),
+    deviceMd5: Database.Column("STRING", "")
+  },
+  "db" /* Db */
+);
+
+// src/database/tables/mysUserInfo.ts
+var DB2 = Database.get();
+var BaseMysUserInfoSchema = {
+  userId: Database.PkColumn("STRING"),
+  ltuids: Database.ArrayColumn("ltuids"),
+  stuids: Database.ArrayColumn("stuids"),
+  deviceList: Database.ArrayColumn("deviceList")
+};
+var MysUserInfoDB = await DB2.init(
+  dir.DataDir,
+  "mysUserInfoData",
+  BaseMysUserInfoSchema,
+  "db" /* Db */
+);
+
+export {
+  DbBase,
+  Database,
+  MysAccountInfoDB,
+  BaseMysUserInfoSchema,
+  MysUserInfoDB
+};

package/lib/chunk-JIO4GOQA.js

@@ -0,0 +1,31 @@
+// src/types/database/dbs/base.ts
+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__ */ ((DatabaseType2) => {
+  DatabaseType2["File"] = "file";
+  DatabaseType2["Dir"] = "dir";
+  DatabaseType2["Db"] = "db";
+  return DatabaseType2;
+})(DatabaseType || {});
+
+// src/types/database/tables/mysAccountInfo.ts
+var MysAccountType = /* @__PURE__ */ ((MysAccountType2) => {
+  MysAccountType2["cn"] = "mihoyo";
+  MysAccountType2["os"] = "hoyolab";
+  return MysAccountType2;
+})(MysAccountType || {});
+
+export {
+  Dialect,
+  DatabaseType,
+  MysAccountType
+};

package/lib/chunk-JML6VYXN.js

@@ -0,0 +1,47 @@
+// src/dir.ts
+import { karinPathBase, requireFileSync } from "node-karin";
+import path from "path";
+import { URL, fileURLToPath } from "url";
+var pluginDir = fileURLToPath(new URL("../", import.meta.url));
+var pluginName = path.basename(pluginDir);
+var pkg = requireFileSync(path.join(pluginDir, "package.json"));
+var dir = {
+  /** 根目录绝对路径 */
+  pluginDir,
+  /** 插件目录名称 */
+  pluginName,
+  /** package.json */
+  pkg,
+  /** 插件版本 package.json 的 version */
+  get version() {
+    return pkg.version;
+  },
+  /** 插件名称 package.json 的 name */
+  get name() {
+    return pkg.name;
+  },
+  /** 插件默认配置目录 */
+  get defConfigDir() {
+    return path.join(pluginDir, "config");
+  },
+  /** 在`@karinjs`中的绝对路径 */
+  get karinPath() {
+    return path.join(karinPathBase, pluginName);
+  },
+  /** 插件配置目录 `@karinjs/karin-plugin-xxx/config` */
+  get ConfigDir() {
+    return path.join(this.karinPath, "config");
+  },
+  /** 插件数据目录 `@karinjs/karin-plugin-xxx/data` */
+  get DataDir() {
+    return path.join(this.karinPath, "data");
+  },
+  /** 插件资源目录 `@karinjs/karin-plugin-xxx/resources` */
+  get defResourcesDir() {
+    return path.join(this.karinPath, "resources");
+  }
+};
+
+export {
+  dir
+};

package/lib/chunk-MLKGABMK.js

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};

package/lib/database-BDHrI6Vm.d.ts

@@ -0,0 +1,5 @@
+import { c as DatabaseClassInstance } from './base-B1BvQ4ol.js';
+
+type DatabaseFn = <T extends Record<string, any>>() => DatabaseClassInstance<T>;
+
+export type { DatabaseFn as D };

package/lib/define-CrfHwHnK.d.ts

@@ -0,0 +1,163 @@
+import { AxiosHeaders } from 'node-karin/axios';
+import { f as MysAccountType } from './base-B1BvQ4ol.js';
+
+interface BaseltuidInfo {
+    ltuid: string;
+    type: MysAccountType;
+}
+interface UidInfo extends BaseltuidInfo {
+    uid?: string;
+    cookie?: string;
+    stoken?: string;
+    owner?: boolean;
+}
+interface DeviceInfo {
+    id: string;
+    name: string;
+}
+interface BaseMysRes {
+    retcode: number;
+    message: string;
+    error?: string[];
+    isCache?: boolean;
+}
+type MysApiInfoFn<R extends BaseMysRes & Record<string, any> | undefined = undefined, D extends Record<string, any> = {}> = (self: DefineMysApi<R, D>, data: D) => {
+    Method: 'GET' | 'POST';
+    Url: URL;
+    Body?: any;
+    HeaderFn: (options: {
+        query: string;
+        body: any;
+    }, data?: D) => Record<string, string> | Promise<Record<string, string>>;
+};
+
+interface UserGameRoleItem {
+    game_biz: string;
+    region: string;
+    game_uid: string;
+    nickname: string;
+    is_chosen: boolean;
+}
+
+interface RefreshUidData {
+    data: {
+        [key: string]: string[];
+    };
+    names: {
+        [key: string]: string;
+    };
+}
+interface StokenParms {
+    stuid: string;
+    stoken: string;
+    mid: string;
+}
+
+interface Config {
+}
+
+declare const MysApp: Readonly<{
+    version: {
+        cn: string;
+        os: string;
+    };
+    appId: 2;
+    salt: {
+        os: string;
+        '4X': string;
+        '6X': string;
+        K2: string;
+        LK2: string;
+        PROD: string;
+    };
+}>;
+
+declare class DefineMysApi<R extends BaseMysRes & Record<string, any> | undefined = undefined, D extends Record<string, any> = {}> {
+    #private;
+    uidInfo: UidInfo;
+    Device: DeviceInfo;
+    constructor(apiInfo: MysApiInfoFn<R, D>, uidInfo?: UidInfo, opt?: {
+        deviceFp?: boolean;
+        checkCode?: boolean;
+    });
+    get isHoyolab(): boolean;
+    getApi(data: D): Promise<{
+        Method: "POST" | "GET";
+        Url: URL;
+        Body: any;
+        Headers: AxiosHeaders;
+    }>;
+    getDevice(): Promise<DeviceInfo>;
+    request(data: D, checkCode?: boolean): Promise<R>;
+    checkRetCode(res: R, data?: D, validate?: boolean): Promise<R>;
+    getDS1(saltKey: keyof typeof MysApp.salt, query?: string, body?: string): string;
+    getDS2(saltKey: keyof typeof MysApp.salt, query?: string, body?: string): string;
+    NoHeaders: (options?: {
+        query?: string;
+        body?: any;
+    }) => {};
+    BaseCnHeaders: () => Promise<{
+        'x-rpc-app_version': string;
+        'x-rpc-client_type': string;
+        'x-rpc-device_id': string;
+        'User-Agent': string;
+        Referer: string;
+    }>;
+    BaseOsHeaders: () => {
+        'x-rpc-app_version': string;
+        'x-rpc-client_type': string;
+        'x-rpc-language': string;
+    };
+    PassportHeaders: (options?: {
+        query?: string;
+        body?: any;
+    }) => {
+        'x-rpc-app_version': string;
+        'x-rpc-game_biz': string;
+        'x-rpc-client_type': string;
+        'User-Agent': string;
+        'x-rpc-app_id': string;
+        DS: string;
+    };
+    CookieHeaders: (options?: {
+        query?: string;
+        body?: any;
+    }) => {
+        'x-rpc-app_version': string;
+        'x-rpc-client_type': string;
+        'x-rpc-language': string;
+        Cookie: string;
+    } | {
+        then<TResult1 = {
+            'x-rpc-app_version': string;
+            'x-rpc-client_type': string;
+            'x-rpc-device_id': string;
+            'User-Agent': string;
+            Referer: string;
+        }, TResult2 = never>(onfulfilled?: ((value: {
+            'x-rpc-app_version': string;
+            'x-rpc-client_type': string;
+            'x-rpc-device_id': string;
+            'User-Agent': string;
+            Referer: string;
+        }) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): Promise<TResult1 | TResult2>;
+        catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined): Promise<{
+            'x-rpc-app_version': string;
+            'x-rpc-client_type': string;
+            'x-rpc-device_id': string;
+            'User-Agent': string;
+            Referer: string;
+        } | TResult>;
+        finally(onfinally?: (() => void) | null | undefined): Promise<{
+            'x-rpc-app_version': string;
+            'x-rpc-client_type': string;
+            'x-rpc-device_id': string;
+            'User-Agent': string;
+            Referer: string;
+        }>;
+        [Symbol.toStringTag]: string;
+        Cookie: string;
+    };
+}
+
+export { type BaseltuidInfo as B, type Config as C, type DeviceInfo as D, type MysApiInfoFn as M, type RefreshUidData as R, type StokenParms as S, type UidInfo as U, type BaseMysRes as a, type UserGameRoleItem as b, DefineMysApi as c, MysApp as d };

package/lib/dir.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 插件目录信息
+ */
+declare const dir: {
+    /** 根目录绝对路径 */
+    pluginDir: string;
+    /** 插件目录名称 */
+    pluginName: string;
+    /** package.json */
+    pkg: any;
+    /** 插件版本 package.json 的 version */
+    readonly version: any;
+    /** 插件名称 package.json 的 name */
+    readonly name: any;
+    /** 插件默认配置目录 */
+    readonly defConfigDir: string;
+    /** 在`@karinjs`中的绝对路径 */
+    readonly karinPath: string;
+    /** 插件配置目录 `@karinjs/karin-plugin-xxx/config` */
+    readonly ConfigDir: string;
+    /** 插件数据目录 `@karinjs/karin-plugin-xxx/data` */
+    readonly DataDir: string;
+    /** 插件资源目录 `@karinjs/karin-plugin-xxx/resources` */
+    readonly defResourcesDir: string;
+};
+
+export { dir };

package/lib/dir.js

@@ -0,0 +1,7 @@
+import {
+  dir
+} from "./chunk-JML6VYXN.js";
+import "./chunk-MLKGABMK.js";
+export {
+  dir
+};