first

.eslintrc.js

+module.exports = {
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    project: 'tsconfig.json',
+    sourceType: 'module',
+  },
+  plugins: ['@typescript-eslint/eslint-plugin'],
+  extends: [
+    'plugin:@typescript-eslint/recommended',
+    'plugin:prettier/recommended',
+  ],
+  root: true,
+  env: {
+    node: true,
+    jest: true,
+  },
+  ignorePatterns: ['.eslintrc.js'],
+  rules: {
+    '@typescript-eslint/interface-name-prefix': 'off',
+    '@typescript-eslint/explicit-function-return-type': 'off',
+    '@typescript-eslint/explicit-module-boundary-types': 'off',
+    '@typescript-eslint/no-explicit-any': 'off',
+  },
+};

.gitignore

+# compiled output
+/dist
+/node_modules
+
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+
+# OS
+.DS_Store
+
+# Tests
+/coverage
+/.nyc_output
+
+# IDEs and editors
+/.idea
+.project
+.classpath
+.c9/
+*.launch
+.settings/
+*.sublime-workspace
+
+# IDE - VSCode
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+
+/data
+/output
+/config.yaml
+/test
+/dist/test
\ No newline at end of file

.gitlab-ci.yml

+stages:
+  - build
+  - combine
+  - deploy
+variables:
+  GIT_DEPTH: "1"
+  CONTAINER_TEST_IMAGE: $CI_REGISTRY_IMAGE:$CI_COMMIT_REF_SLUG
+  CONTAINER_TEST_ARM_IMAGE: $CI_REGISTRY_IMAGE:$CI_COMMIT_REF_SLUG-arm
+  CONTAINER_TEST_X86_IMAGE: $CI_REGISTRY_IMAGE:$CI_COMMIT_REF_SLUG-x86
+  CONTAINER_RELEASE_IMAGE: $CI_REGISTRY_IMAGE:latest
+before_script:
+  - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
+build-x86:
+  stage: build
+  tags:
+    - docker
+  script:
+    - TARGET_IMAGE=$CONTAINER_TEST_X86_IMAGE
+    - docker build --pull -t $TARGET_IMAGE .
+    - docker push $TARGET_IMAGE
+build-arm:
+  stage: build
+  tags:
+    - docker-arm
+  script:
+    - TARGET_IMAGE=$CONTAINER_TEST_ARM_IMAGE
+    - docker build --pull -t $TARGET_IMAGE .
+    - docker push $TARGET_IMAGE
+combine:
+  stage: combine
+  tags:
+    - docker
+  script:
+    - TARGET_IMAGE=$CONTAINER_TEST_IMAGE
+    - SOURCE_IMAGE_2=$CONTAINER_TEST_ARM_IMAGE
+    - SOURCE_IMAGE_1=$CONTAINER_TEST_X86_IMAGE
+    - docker pull $SOURCE_IMAGE_1
+    - docker pull $SOURCE_IMAGE_2
+    - docker manifest create $TARGET_IMAGE --amend $SOURCE_IMAGE_1 --amend
+      $SOURCE_IMAGE_2
+    - docker manifest push $TARGET_IMAGE
+deploy_latest:
+  stage: deploy
+  tags:
+    - docker
+  script:
+    - TARGET_IMAGE=$CONTAINER_RELEASE_IMAGE
+    - SOURCE_IMAGE=$CONTAINER_TEST_IMAGE
+    - docker pull $SOURCE_IMAGE
+    - docker tag $SOURCE_IMAGE $TARGET_IMAGE
+    - docker push $TARGET_IMAGE
+  only:
+    - master
+deploy_tag:
+  stage: deploy
+  tags:
+    - docker
+  script:
+    - TARGET_IMAGE=$CI_REGISTRY_IMAGE:$CI_COMMIT_TAG
+    - SOURCE_IMAGE=$CONTAINER_TEST_IMAGE
+    - docker pull $SOURCE_IMAGE
+    - docker tag $SOURCE_IMAGE $TARGET_IMAGE
+    - docker push $TARGET_IMAGE
+  only:
+    - tags

.npmignore

+/install-npm.sh
+.git*
+/data
+/output
+/config.yaml
+.idea
+.dockerignore
+Dockerfile
+/test
+/dist/test
\ No newline at end of file

.prettierrc

+{
+  "singleQuote": true,
+  "trailingComma": "all"
+}
\ No newline at end of file

LICENSE

+MIT License
+
+Copyright (c) 2019-present Shigma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

index.ts

+export * from './src/register';
+export * from './src/decorators';
+export * from './src/def';

install-npm.sh

+#!/bin/bash
+
+npm install --save-dev \
+	@types/node \
+	typescript \
+	'@typescript-eslint/eslint-plugin@^4.28.2' \
+	'@typescript-eslint/parser@^4.28.2 '\
+	'eslint@^7.30.0' \
+	'eslint-config-prettier@^8.3.0' \
+	'eslint-plugin-prettier@^3.4.0' \
+	prettier

package.json

+{
+  "name": "koishi-thirdeye",
+  "version": "1.0.0",
+  "description": "DI plugin framework for Koishi v4 beta",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://code.mycard.moe/3rdeye/koishi-thirdeye"
+  },
+  "keywords": [
+    "Koishi",
+    "qqbot",
+    "cqbot",
+    "cqhttp",
+    "onebot"
+  ],
+  "author": "Nanahira <nanahira@momobako.com>",
+  "license": "MIT",
+  "devDependencies": {
+    "@koishijs/plugin-adapter-onebot": "^4.0.0-beta.0",
+    "@types/node": "^16.11.7",
+    "@typescript-eslint/eslint-plugin": "^4.33.0",
+    "@typescript-eslint/parser": "^4.33.0",
+    "eslint": "^7.32.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-prettier": "^3.4.1",
+    "koishi": "^4.0.0-beta.0",
+    "prettier": "^2.4.1",
+    "typescript": "^4.4.4",
+    "ws": "^8.2.3"
+  },
+  "peerDependencies": {
+    "koishi": "^4.0.0-beta.0"
+  },
+  "dependencies": {
+    "koishi-utils-schemagen": "^1.1.9",
+    "reflect-metadata": "^0.1.13"
+  }
+}

src/decorators.ts

+import {
+  CommandDefinitionFun,
+  CommandPutConfig,
+  CommandPutConfigMap,
+  EventName,
+  GenerateMappingStruct,
+  KoishiCommandDefinition,
+  KoishiCommandPutDef,
+  KoishiDoRegister,
+  KoishiDoRegisterKeys,
+  KoishiOnContextScope,
+  KoishiServiceInjectSym,
+  KoishiServiceInjectSymKeys,
+  KoishiServiceProvideSym,
+  KoishiSystemInjectSym,
+  KoishiSystemInjectSymKeys,
+  MetadataGenericMap,
+  OnContextFunction,
+  Selection,
+} from './def';
+import 'reflect-metadata';
+import { App, Argv, Command, Context, FieldCollector, Session } from 'koishi';
+import {
+  AppendMetadata,
+  AppendMetadataUnique,
+  ConcatMetadata,
+  SetMetadata,
+} from './meta/metadata.decorators';
+import { PluginClass } from './register';
+
+// Register methods
+export const DoRegister = (
+  value: MetadataGenericMap['KoishiDoRegister'],
+): MethodDecorator =>
+  SetMetadata(KoishiDoRegister, value, KoishiDoRegisterKeys);
+
+export const UseMiddleware = (prepend?: boolean): MethodDecorator =>
+  DoRegister(GenerateMappingStruct('middleware', prepend));
+export const UseEvent = (name: EventName, prepend?: boolean): MethodDecorator =>
+  DoRegister(GenerateMappingStruct('onevent', { name, prepend }));
+export const UsePlugin = (): MethodDecorator =>
+  DoRegister(GenerateMappingStruct('plugin'));
+
+export function UseCommand<D extends string>(
+  def: D,
+  config?: Command.Config,
+): MethodDecorator;
+export function UseCommand<D extends string>(
+  def: D,
+  desc: string,
+  config?: Command.Config,
+): MethodDecorator;
+export function UseCommand(
+  def: string,
+  ...args: [Command.Config?] | [string, Command.Config?]
+): MethodDecorator {
+  const desc = typeof args[0] === 'string' ? (args.shift() as string) : '';
+  const config = args[0] as Command.Config;
+  return (obj, key: string, des) => {
+    const putOptions: CommandPutConfig<keyof CommandPutConfigMap>[] =
+      Reflect.getMetadata(KoishiCommandPutDef, obj.constructor, key) ||
+      undefined;
+    const metadataDec = DoRegister({
+      type: 'command',
+      data: {
+        def,
+        desc,
+        config,
+        putOptions,
+      },
+    });
+    return metadataDec(obj, key, des);
+  };
+}
+
+// Context scopes
+
+export const OnContext = (
+  ctxFun: OnContextFunction,
+): MethodDecorator & ClassDecorator =>
+  AppendMetadata(KoishiOnContextScope, ctxFun);
+
+export const OnUser = (...values: string[]) =>
+  OnContext((ctx) => ctx.user(...values));
+
+export const OnSelf = (...values: string[]) =>
+  OnContext((ctx) => ctx.self(...values));
+
+export const OnGuild = (...values: string[]) =>
+  OnContext((ctx) => ctx.guild(...values));
+
+export const OnChannel = (...values: string[]) =>
+  OnContext((ctx) => ctx.channel(...values));
+
+export const OnPlatform = (...values: string[]) =>
+  OnContext((ctx) => ctx.platform(...values));
+
+export const OnPrivate = (...values: string[]) =>
+  OnContext((ctx) => ctx.private(...values));
+
+export const OnSelection = (selection: Selection) =>
+  OnContext((ctx) => ctx.select(selection));
+
+// Command definition
+
+export const CommandDef = (def: CommandDefinitionFun): MethodDecorator =>
+  AppendMetadata(KoishiCommandDefinition, def);
+
+export const CommandDescription = (desc: string) =>
+  CommandDef((cmd) => {
+    cmd.description = desc;
+    return cmd;
+  });
+
+export const CommandAlias = (...names: string[]) =>
+  CommandDef((cmd) => cmd.alias(...names));
+
+export const CommandShortcut = (
+  name: string | RegExp,
+  config: Command.Shortcut = {},
+) => CommandDef((cmd) => cmd.shortcut(name, config));
+
+export const CommandUsage = (text: string) =>
+  CommandDef((cmd) => cmd.usage(text));
+
+export const CommandExample = (text: string) =>
+  CommandDef((cmd) => cmd.example(text));
+
+export const CommandOption = (
+  name: string,
+  desc: string,
+  config: Argv.OptionConfig = {},
+) => CommandDef((cmd) => cmd.option(name, desc, config));
+
+export const CommandUserFields = (fields: FieldCollector<'user'>) =>
+  CommandDef((cmd) => cmd.userFields(fields));
+
+export const CommandChannelFields = (fields: FieldCollector<'channel'>) =>
+  CommandDef((cmd) => cmd.channelFields(fields));
+
+// Command put config
+
+function PutCommandParam<T extends keyof CommandPutConfigMap>(
+  type: T,
+  data?: CommandPutConfigMap[T],
+): ParameterDecorator {
+  return (obj, key: string, index) => {
+    const objClass = obj.constructor;
+    const list: CommandPutConfig<T>[] =
+      Reflect.getMetadata(KoishiCommandPutDef, objClass, key) || [];
+    list[index] = GenerateMappingStruct(type, data);
+    Reflect.defineMetadata(KoishiCommandPutDef, list, objClass, key);
+  };
+}
+
+export const PutArgv = () => PutCommandParam('argv');
+export const PutSession = (field?: keyof Session) =>
+  field ? PutCommandParam('sessionField', field) : PutCommandParam('session');
+export const PutArg = (i: number) => PutCommandParam('arg', i);
+export const PutOption = (
+  name: string,
+  desc: string,
+  config: Argv.OptionConfig = {},
+) => PutCommandParam('option', { name, desc, config });
+
+export const PutUser = (field: FieldCollector<'user'>) =>
+  PutCommandParam('user', field);
+
+export const PutChannel = (field: FieldCollector<'channel'>) =>
+  PutCommandParam('channel', field);
+
+export const PutUserName = (useDatabase = true) =>
+  PutCommandParam('username', useDatabase);
+
+export const PutUserId = () => PutSession('userId');
+export const PutGuildId = () => PutSession('guildId');
+export const PutGuildName = () => PutSession('guildName');
+export const PutChannelId = () => PutSession('channelId');
+export const PutChannelName = () => PutSession('channelName');
+export const PutSelfId = () => PutSession('selfId');
+export const PutBot = () => PutSession('bot');
+
+// Service
+
+export function Inject(name?: keyof Context.Services): PropertyDecorator {
+  return (obj, key) => {
+    if (!name) {
+      const functionType = Reflect.getMetadata('design:type', obj, key);
+      let dec: PropertyDecorator;
+      if (functionType === Context) {
+        dec = InjectContext();
+      } else if (functionType === App) {
+        dec = InjectApp();
+      }
+      if (dec) {
+        return dec(obj, key);
+      }
+    }
+    const serviceName = name || (key as keyof Context.Services);
+    const dec = SetMetadata(
+      KoishiServiceInjectSym,
+      serviceName,
+      KoishiServiceInjectSymKeys,
+    );
+    return dec(obj, key);
+  };
+}
+
+export function Provide(
+  name: keyof Context.Services,
+  options?: Context.Options,
+): ClassDecorator {
+  Context.service(name, options);
+  return AppendMetadataUnique(KoishiServiceProvideSym, name);
+}
+
+const InjectSystem = (fun: (obj: PluginClass) => any) =>
+  SetMetadata(KoishiSystemInjectSym, fun, KoishiSystemInjectSymKeys);
+
+export const InjectContext = (select?: Selection) =>
+  InjectSystem((obj) => {
+    if (select) {
+      return obj.__ctx.select(select);
+    } else {
+      return obj.__ctx;
+    }
+  });
+export const InjectApp = () => InjectSystem((obj) => obj.__ctx.app);
+export const InjectConfig = (raw = false) =>
+  InjectSystem((obj) => (raw ? obj.__rawConfig : obj.__config));

src/def/constants.ts

+// metadatas
+import { Context } from 'koishi';
+import {
+  CommandDefinitionFun,
+  DoRegisterConfig,
+  OnContextFunction,
+} from './interfaces';
+import { PluginClass } from '../register';
+
+export const KoishiOnContextScope = 'KoishiOnContextScope';
+export const KoishiDoRegister = 'KoishiDoRegister';
+export const KoishiDoRegisterKeys = 'KoishiDoRegisterKeys';
+export const KoishiCommandDefinition = 'KoishiCommandDefinition';
+export const KoishiCommandPutDef = 'KoishiCommandPutDef';
+
+export const KoishiServiceInjectSym = 'KoishiServiceInjectSym';
+export const KoishiServiceInjectSymKeys = 'KoishiServiceInjectSymKeys';
+export const KoishiServiceProvideSym = 'KoishiServiceProvideSym';
+export const KoishiSystemInjectSym = 'KoishiSystemInjectSym';
+export const KoishiSystemInjectSymKeys = 'KoishiSystemInjectSymKeys';
+
+// metadata map
+
+export interface MetadataArrayMap {
+  KoishiOnContextScope: OnContextFunction;
+  KoishiCommandDefinition: CommandDefinitionFun;
+  KoishiServiceProvideSym: keyof Context.Services;
+  KoishiDoRegisterKeys: string;
+  KoishiServiceInjectSymKeys: string;
+  KoishiSystemInjectSymKeys: string;
+}
+
+export interface MetadataMap {
+  KoishiDoRegister: DoRegisterConfig;
+  KoishiServiceInjectSym: keyof Context.Services;
+  KoishiSystemInjectSym: (obj: PluginClass) => any;
+}

src/def/index.ts

+export * from './interfaces';
+export * from './constants';

src/def/interfaces.ts

+import {
+  App,
+  Argv,
+  Channel,
+  Command,
+  Context,
+  EventMap,
+  FieldCollector,
+  MaybeArray,
+  Modules,
+  Plugin,
+  Session,
+  User,
+} from 'koishi';
+import { MetadataArrayMap, MetadataMap } from './constants';
+
+export interface Type<T = any> extends Function {
+  new (...args: any[]): T;
+}
+
+const selectors = [
+  'user',
+  'guild',
+  'channel',
+  'self',
+  'private',
+  'platform',
+] as const;
+
+type SelectorType = typeof selectors[number];
+type SelectorValue = boolean | MaybeArray<string | number>;
+type BaseSelection = { [K in SelectorType as `$${K}`]?: SelectorValue };
+
+export interface Selection extends BaseSelection {
+  $and?: Selection[];
+  $or?: Selection[];
+  $not?: Selection;
+}
+
+export interface ContextSelector {
+  select?: Selection;
+  useSelector?: OnContextFunction;
+}
+
+export type KoishiPluginOptions<T extends keyof Modules | Plugin> =
+  | boolean
+  | (T extends keyof Modules
+      ? Plugin.ModuleConfig<Modules[T]>
+      : T extends Plugin
+      ? Plugin.Config<T>
+      : never);
+
+export interface KoishiModulePlugin<T extends keyof Modules | Plugin>
+  extends ContextSelector {
+  plugin: T;
+  options?: boolean | KoishiPluginOptions<T>;
+}
+
+export function PluginDef<T extends keyof Modules>(
+  plugin: T,
+  options?: boolean | Plugin.ModuleConfig<Modules[T]>,
+  select?: Selection,
+): KoishiModulePlugin<T>;
+export function PluginDef<T extends Plugin>(
+  plugin: T,
+  options?: boolean | Plugin.Config<T>,
+  select?: Selection,
+): KoishiModulePlugin<T>;
+export function PluginDef<T extends keyof Modules | Plugin>(
+  plugin: T,
+  options?: KoishiPluginOptions<T>,
+  select?: Selection,
+): KoishiModulePlugin<T> {
+  return { plugin, options, select };
+}
+
+export type EventName = keyof EventMap;
+export interface EventNameAndPrepend {
+  name: EventName;
+  prepend?: boolean;
+}
+
+export type ContextFunction<T> = (ctx: Context) => T;
+export type OnContextFunction = ContextFunction<Context>;
+export interface DoRegisterConfigDataMap {
+  middleware: boolean; // prepend
+  onevent: EventNameAndPrepend;
+  plugin: never;
+  command: CommandRegisterConfig;
+}
+
+export interface MappingStruct<
+  T extends Record<string | number | symbol, any>,
+  K extends keyof T
+> {
+  type: K;
+  data?: T[K];
+}
+
+export function GenerateMappingStruct<
+  T extends Record<string | number | symbol, any>,
+  K extends keyof T
+>(type: K, data?: T[K]): MappingStruct<T, K> {
+  return {
+    type,
+    data,
+  };
+}
+
+export type DoRegisterConfig<
+  K extends keyof DoRegisterConfigDataMap = keyof DoRegisterConfigDataMap
+> = MappingStruct<DoRegisterConfigDataMap, K>;
+
+// Command stuff
+
+export interface CommandRegisterConfig<D extends string = string> {
+  def: D;
+  desc?: string;
+  config?: Command.Config;
+  putOptions?: CommandPutConfig<keyof CommandPutConfigMap>[];
+}
+
+export interface CommandOptionConfig {
+  name: string;
+  desc: string;
+  config?: Argv.OptionConfig;
+}
+
+export interface CommandPutConfigMap {
+  arg: number;
+  argv: never;
+  session: never;
+  option: CommandOptionConfig;
+  user: FieldCollector<'user'>;
+  channel: FieldCollector<'channel'>;
+  username: boolean;
+  sessionField: keyof Session;
+}
+
+export type CommandPutConfig<
+  K extends keyof CommandPutConfigMap = keyof CommandPutConfigMap
+> = MappingStruct<CommandPutConfigMap, K>;
+
+export type CommandDefinitionFun = (cmd: Command) => Command;
+
+// metadata map
+export type MetadataArrayValueMap = {
+  [K in keyof MetadataArrayMap]: MetadataArrayMap[K][];
+};
+
+export type MetadataGenericMap = MetadataArrayValueMap & MetadataMap;
+
+export type MetadataArrayValue<
+  K extends keyof MetadataArrayValueMap
+> = MetadataArrayValueMap[K];
+
+export type MetadataKey = keyof MetadataArrayMap | keyof MetadataMap;
+
+export type MetadataMapValue<
+  K extends MetadataKey
+> = K extends keyof MetadataArrayValueMap
+  ? MetadataArrayValue<K>
+  : K extends keyof MetadataMap
+  ? MetadataMap[K]
+  : never;
+
+// command interceptor
+
+export interface KoishiCommandInterceptor<
+  U extends User.Field = never,
+  G extends Channel.Field = never,
+  A extends any[] = any[],
+  O extends {} = {}
+> {
+  intercept: Command.Action<U, G, A, O>;
+}
+
+export type KoishiCommandInterceptorRegistration<
+  U extends User.Field = never,
+  G extends Channel.Field = never,
+  A extends any[] = any[],
+  O extends {} = {}
+> =
+  | KoishiCommandInterceptor<U, G, A, O>
+  | Type<KoishiCommandInterceptor<U, G, A, O>>
+  | string
+  | symbol;

src/meta/meta-fetch.ts

+import {
+  MetadataArrayMap,
+  MetadataArrayValue,
+  MetadataGenericMap,
+  MetadataMapValue,
+} from '../def';
+
+export function getMetadata<K extends keyof MetadataGenericMap>(
+  metadataKey: K,
+  instance: any,
+  key?: string | symbol,
+): MetadataMapValue<K> {
+  const instanceClass = instance.constructor;
+  if (key) {
+    return Reflect.getMetadata(metadataKey, instanceClass, key);
+  } else {
+    return Reflect.getMetadata(metadataKey, instanceClass);
+  }
+}
+
+export function getMetadataArray<K extends keyof MetadataArrayMap>(
+  metadataKey: K,
+  instance: any,
+  key?: string | symbol,
+): MetadataArrayValue<K> {
+  return getMetadata(metadataKey, instance, key) || [];
+}
+
+export function getPropertyMetadata<K extends keyof MetadataArrayMap, I = any>(
+  metadataKey: K,
+  instance: I,
+  originalClass: any,
+  key: keyof I & (string | symbol),
+): MetadataArrayValue<K> {
+  const valueFromClass = getMetadataArray(metadataKey, originalClass);
+  const valueFromProperty = getMetadataArray(metadataKey, instance, key);
+  return [...valueFromClass, ...valueFromProperty] as MetadataArrayValue<K>;
+}

src/meta/metadata.decorators.ts

+import {
+  MetadataArrayMap,
+  MetadataArrayValue,
+  MetadataArrayValueMap,
+  MetadataGenericMap,
+  MetadataKey,
+} from '../def';
+
+export type AllDecorators = MethodDecorator &
+  ClassDecorator &
+  PropertyDecorator;
+
+function getMetadataInDecorator<
+  K extends MetadataKey,
+  VM extends Partial<MetadataGenericMap> = MetadataGenericMap
+>(metaKey: K, target: any, key?: any): VM[K] {
+  const targetClass = target.constructor;
+  if (key) {
+    return Reflect.getMetadata(metaKey, targetClass, key);
+  } else {
+    return Reflect.getMetadata(metaKey, targetClass);
+  }
+}
+
+function setMetadataInDecorator<
+  K extends MetadataKey,
+  VM extends Partial<MetadataGenericMap> = MetadataGenericMap
+>(metaKey: K, value: VM[K], target: any, key?: any) {
+  const targetClass = target.constructor;
+  if (key) {
+    return Reflect.defineMetadata(metaKey, value, targetClass, key);
+  } else {
+    return Reflect.defineMetadata(metaKey, value, targetClass);
+  }
+}
+
+function TransformMetadata<
+  K extends MetadataKey,
+  VM extends Partial<MetadataGenericMap> = MetadataGenericMap
+>(
+  metadataKey: K,
+  metadataValueFun: (oldValue: VM[K]) => VM[K],
+  keysIndexMeta?: keyof MetadataArrayMap,
+): AllDecorators {
+  return (target: any, key?: any, descriptor?: any) => {
+    const oldValue: VM[K] = getMetadataInDecorator(metadataKey, target, key);
+    const newValue = metadataValueFun(oldValue);
+    setMetadataInDecorator(metadataKey, newValue, target, key);
+    if (keysIndexMeta) {
+      const keysDec = AppendMetadataUnique(keysIndexMeta, key);
+      keysDec(target);
+    }
+    if (descriptor) {
+      return descriptor;
+    }
+    return target;
+  };
+}
+
+export const SetMetadata = <K extends keyof MetadataGenericMap>(
+  metadataKey: K,
+  metadataValue: MetadataGenericMap[K],
+  keysIndexMeta?: keyof MetadataArrayMap,
+): AllDecorators =>
+  TransformMetadata<K>(metadataKey, () => metadataValue, keysIndexMeta);
+
+export const AppendMetadata = <K extends keyof MetadataArrayMap>(
+  metadataKey: K,
+  metadataValue: MetadataArrayMap[K],
+  keysIndexMeta?: keyof MetadataArrayMap,
+): AllDecorators =>
+  TransformMetadata<K, MetadataArrayValueMap>(
+    metadataKey,
+    (arr) => {
+      const newArr = arr || [];
+      newArr.push(metadataValue);
+      return newArr;
+    },
+    keysIndexMeta,
+  );
+
+export const AppendMetadataUnique = <K extends keyof MetadataArrayMap>(
+  metadataKey: K,
+  metadataValue: MetadataArrayMap[K],
+  keysIndexMeta?: keyof MetadataArrayMap,
+): AllDecorators =>
+  TransformMetadata<K, MetadataArrayValueMap>(
+    metadataKey,
+    (arr) => {
+      const newArr = arr || [];
+      if (newArr.includes(metadataValue)) {
+        return newArr;
+      }
+      newArr.push(metadataValue);
+      return newArr;
+    },
+    keysIndexMeta,
+  );
+
+export const ConcatMetadata = <K extends keyof MetadataArrayValueMap>(
+  metadataKey: K,
+  metadataValue: MetadataArrayValue<K>,
+  keysIndexMeta?: keyof MetadataArrayMap,
+): AllDecorators =>
+  TransformMetadata<K, MetadataArrayValueMap>(
+    metadataKey,
+    (arr) => ((arr || []) as any[]).concat(metadataValue),
+    keysIndexMeta,
+  );

src/register.ts

+import { Argv, Command, Context, Schema, User } from 'koishi';
+import {
+  CommandPutConfig,
+  DoRegisterConfig,
+  KoishiCommandDefinition,
+  KoishiDoRegister,
+  KoishiDoRegisterKeys,
+  KoishiModulePlugin,
+  KoishiOnContextScope,
+  KoishiServiceInjectSym,
+  KoishiServiceInjectSymKeys,
+  KoishiServiceProvideSym,
+  KoishiSystemInjectSym,
+  KoishiSystemInjectSymKeys,
+  OnContextFunction,
+  Type,
+} from './def';
+import { schemaFromClass, schemaTransform } from 'koishi-utils-schemagen';
+import { getMetadata, getMetadataArray } from './meta/meta-fetch';
+import { applySelector } from './utility/utility';
+
+export interface KoishiPluginRegistrationOptions<T = any> {
+  name?: string;
+  schema?: Schema<T> | Type<T>;
+}
+
+export interface PluginClass<T = any> {
+  __ctx: Context;
+  __config: T;
+  __rawConfig: T;
+}
+
+export interface OnApply {
+  onApply(): void | Promise<void>;
+}
+
+export interface OnConnect {
+  onConnect(): void | Promise<void>;
+}
+
+export interface OnDisconnect {
+  onDisconnect(): void | Promise<void>;
+}
+
+export function KoishiPlugin<T = any>(
+  options: KoishiPluginRegistrationOptions<T> = {},
+) {
+  return function <C extends { new (...args: any[]): any }>(originalClass: C) {
+    const newClass = class extends originalClass implements PluginClass {
+      __ctx: Context;
+      __config: T;
+      __rawConfig: T;
+
+      _getContextFromFilters(ctx: Context, filters: OnContextFunction[]) {
+        let targetCtx = ctx;
+        for (const fun of filters) {
+          targetCtx = fun(targetCtx) || targetCtx;
+        }
+        return targetCtx;
+      }
+
+      _handleSystemInjections() {
+        // console.log('Handling system injection');
+        const injectKeys = getMetadataArray(KoishiSystemInjectSymKeys, this);
+        for (const key of injectKeys) {
+          // console.log(`Processing ${key}`);
+          const valueFunction = getMetadata(KoishiSystemInjectSym, this, key);
+          Object.defineProperty(this, key, {
+            configurable: true,
+            enumerable: true,
+            get: () => valueFunction(this),
+          });
+        }
+      }
+
+      _handleServiceInjections() {
+        // console.log('Handling service injection');
+        const injectKeys = getMetadataArray(KoishiServiceInjectSymKeys, this);
+        for (const key of injectKeys) {
+          // console.log(`Processing ${key}`);
+          const name = getMetadata(KoishiServiceInjectSym, this, key);
+          Object.defineProperty(this, key, {
+            enumerable: true,
+            configurable: true,
+            get: () => {
+              return this.__ctx[name];
+            },
+            set: (val: any) => {
+              this.__ctx[name] = val;
+            },
+          });
+        }
+      }
+
+      _preRegisterCommandActionArg(config: CommandPutConfig, cmd: Command) {
+        if (!config) {
+          return;
+        }
+        switch (config.type) {
+          case 'option':
+            const { data: optionData } = config as CommandPutConfig<'option'>;
+            cmd.option(optionData.name, optionData.desc, optionData.config);
+            break;
+          case 'user':
+            const { data: userFields } = config as CommandPutConfig<'user'>;
+            if (userFields) {
+              cmd.userFields(userFields);
+            }
+            break;
+          case 'channel':
+            const {
+              data: channelFields,
+            } = config as CommandPutConfig<'channel'>;
+            if (channelFields) {
+              cmd.channelFields(channelFields);
+            }
+            break;
+          case 'username':
+            const {
+              data: useDatabase,
+            } = config as CommandPutConfig<'username'>;
+            if (useDatabase) {
+              cmd.userFields(['name']);
+            }
+            break;
+          default:
+            break;
+        }
+        return;
+      }
+
+      _getCommandActionArg(config: CommandPutConfig, argv: Argv, args: any[]) {
+        if (!config) {
+          return;
+        }
+        switch (config.type) {
+          case 'arg':
+            const { data: index } = config as CommandPutConfig<'arg'>;
+            return args[index];
+          case 'argv':
+            return argv;
+          case 'session':
+            return argv.session;
+          case 'option':
+            const { data: optionData } = config as CommandPutConfig<'option'>;
+            return argv.options[optionData.name];
+          case 'user':
+            return argv.session.user;
+          case 'channel':
+            return argv.session.channel;
+          case 'username':
+            const {
+              data: useDatabase,
+            } = config as CommandPutConfig<'username'>;
+            if (useDatabase) {
+              const user = argv.session.user as User.Observed<'name'>;
+              if (user?.name) {
+                return user?.name;
+              }
+            }
+            return (
+              argv.session.author?.nickname || argv.session.author?.username
+            );
+          case 'sessionField':
+            const { data: field } = config as CommandPutConfig<'sessionField'>;
+            return argv.session[field];
+          default:
+            return;
+        }
+      }
+
+      async _registerDeclarationsFor(methodKey: keyof C & string) {
+        // console.log(`Handling declaration for ${methodKey}`);
+        const regData = getMetadata(KoishiDoRegister, this, methodKey);
+        if (!regData) {
+          return;
+        }
+        // console.log(`Type: ${regData.type}`);
+        const baseContext = this._getContextFromFilters(
+          this.__ctx,
+          getMetadataArray(KoishiOnContextScope, this, methodKey),
+        );
+        switch (regData.type) {
+          case 'middleware':
+            const {
+              data: midPrepend,
+            } = regData as DoRegisterConfig<'middleware'>;
+            baseContext.middleware(
+              (session, next) => this[methodKey](session, next),
+              midPrepend,
+            );
+            break;
+          case 'onevent':
+            const { data: eventData } = regData as DoRegisterConfig<'onevent'>;
+            const eventName = eventData.name;
+            baseContext.on(eventData.name, (...args: any[]) =>
+              this[methodKey](...args),
+            );
+            // special events
+            if (
+              typeof eventName === 'string' &&
+              eventName.startsWith('service/')
+            ) {
+              const serviceName = eventName.slice(8);
+              if (baseContext[serviceName] != null) {
+                this[methodKey]();
+              }
+            }
+            break;
+          case 'plugin':
+            const pluginDesc: KoishiModulePlugin<any> = await this[methodKey];
+            if (!pluginDesc || !pluginDesc.plugin) {
+              throw new Error(`Invalid plugin from method ${methodKey}.`);
+            }
+            const pluginCtx = applySelector(baseContext, pluginDesc);
+            pluginCtx.plugin(pluginDesc.plugin, pluginDesc.options);
+            break;
+          case 'command':
+            const {
+              data: commandData,
+            } = regData as DoRegisterConfig<'command'>;
+            let command = baseContext.command(
+              commandData.def,
+              commandData.desc,
+              commandData.config,
+            );
+            const commandDefs = getMetadataArray(
+              KoishiCommandDefinition,
+              this,
+              methodKey,
+            );
+            for (const commandDef of commandDefs) {
+              command = commandDef(command) || command;
+            }
+            if (!commandData.putOptions) {
+              command.action((argv: Argv, ...args: any[]) =>
+                this[methodKey](argv, ...args),
+              );
+            } else {
+              for (const _optionToRegister of commandData.putOptions) {
+                this._preRegisterCommandActionArg(_optionToRegister, command);
+              }
+              command.action((argv: Argv, ...args: any[]) => {
+                const params = commandData.putOptions.map((o) =>
+                  this._getCommandActionArg(o, argv, args),
+                );
+                return this[methodKey](...params);
+              });
+            }
+            break;
+          default:
+            throw new Error(`Unknown operation type ${regData.type}`);
+        }
+      }
+
+      async _registerDeclarations() {
+        const methodKeys = getMetadataArray(
+          KoishiDoRegisterKeys,
+          this,
+        ) as (keyof C & string)[];
+        // console.log(methodKeys);
+        await Promise.all(
+          methodKeys.map((methodKey) =>
+            this._registerDeclarationsFor(methodKey),
+          ),
+        );
+      }
+
+      _handleServiceProvide(connect = true) {
+        // console.log(`Handling service provide`);
+        const providingServices = getMetadataArray(
+          KoishiServiceProvideSym,
+          originalClass,
+        );
+        for (const key of providingServices) {
+          // console.log(`Processing ${key}`);
+          this.__ctx[key] = connect ? (this as any) : null;
+        }
+      }
+
+      _registerAfterInit() {
+        // console.log(`Handling after init.`);
+        this.__ctx.on('connect', async () => {
+          if (typeof this.onConnect === 'function') {
+            await this.onConnect();
+          }
+          this._handleServiceProvide(true);
+        });
+        this.__ctx.on('disconnect', async () => {
+          if (typeof this.onDisconnect === 'function') {
+            await this.onDisconnect();
+          }
+          this._handleServiceProvide(false);
+        });
+      }
+
+      async _initializePluginClass(ctx: Context) {
+        const contextFilters = getMetadataArray(
+          KoishiOnContextScope,
+          originalClass,
+        );
+        this.__ctx = this._getContextFromFilters(ctx, contextFilters);
+        this.__config =
+          typeof options.schema === 'function'
+            ? schemaTransform(options.schema, this.__rawConfig)
+            : options.schema
+            ? Schema.validate(this.__rawConfig, options.schema)
+            : this.__rawConfig;
+        this._handleSystemInjections();
+        this._handleServiceInjections();
+        this._registerAfterInit();
+        await this._registerDeclarations();
+        if (typeof this.onApply === 'function') {
+          await this.onApply();
+        }
+      }
+
+      constructor(...args: any[]) {
+        super(...args);
+        const ctx: Context = args[0];
+        this.__rawConfig = args[1];
+        this._initializePluginClass(ctx).then();
+      }
+    };
+    if (options.name) {
+      Object.defineProperty(newClass, 'name', {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: options.name,
+      });
+    }
+    if (options.schema) {
+      const schema =
+        typeof options.schema === 'function'
+          ? schemaFromClass(options.schema)
+          : options.schema;
+      Object.defineProperty(newClass, 'schema', {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: schema,
+      });
+    }
+    return newClass;
+  };
+}

src/utility/utility.ts

+import { Context } from 'koishi';
+import { ContextSelector } from '../def';
+
+export function getStringFromNativeType(nativeType: any) {
+  if (!nativeType) {
+    return;
+  }
+  const nativeTypeString = nativeType.toString() as string;
+  if (!nativeTypeString) {
+    return;
+  }
+  if (nativeTypeString.startsWith('class')) {
+    return 'class';
+  }
+  if (!nativeTypeString.startsWith('function ')) {
+    return;
+  }
+  return nativeType.name?.toLowerCase();
+}
+
+export function applySelector(
+  ctx: Context,
+  selector: ContextSelector,
+): Context {
+  if (!selector) {
+    return ctx;
+  }
+  let targetCtx = ctx;
+  if (selector.select) {
+    targetCtx = targetCtx.select(selector.select);
+  }
+  if (selector.useSelector) {
+    targetCtx = selector.useSelector(targetCtx) || targetCtx;
+  }
+  return targetCtx;
+}

tsconfig.json

+{
+	"compilerOptions": {
+		"outDir": "dist",
+		"module": "commonjs",
+		"target": "es2021",
+		"esModuleInterop": true,
+		"emitDecoratorMetadata": true,
+		"experimentalDecorators": true,
+		"declaration": true,
+		"sourceMap": true
+	},
+	"compileOnSave": true,
+	"allowJs": true,
+	"include": [
+		"*.ts",
+		"src/**/*.ts",
+		"test/**/*.ts"
+	]
+}