@certd/pipeline 1.0.0

package/src/core/storage.ts

@@ -0,0 +1,140 @@
+import fs from "fs";
+import path from "path";
+
+
+
+export interface IStorage {
+  get(scope: string, namespace: string, version: string, key: string): Promise<string | null>;
+  set(scope: string, namespace: string, version: string, key: string, value: string): Promise<void>;
+  remove(scope: string, namespace: string, version: string, key: string): Promise<void>;
+}
+
+export class FileStorage implements IStorage {
+  root: string;
+  constructor(rootDir?: string) {
+    if (rootDir == null) {
+      const userHome = process.env.HOME || process.env.USERPROFILE;
+      rootDir = userHome + "/.certd/storage/";
+    }
+    this.root = rootDir;
+
+    if (!fs.existsSync(this.root)) {
+      fs.mkdirSync(this.root, { recursive: true });
+    }
+  }
+
+  async remove(scope: string, namespace: string, version: string, key: string): Promise<void> {
+    if (key) {
+      fs.unlinkSync(this.buildPath(scope, namespace, version, key));
+    } else if (version) {
+      fs.rmdirSync(this.buildPath(scope, namespace, version));
+    } else if (namespace) {
+      fs.rmdirSync(this.buildPath(scope, namespace));
+    } else {
+      fs.rmdirSync(this.buildPath(scope));
+    }
+  }
+
+  writeFile(filePath: string, value: string) {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(filePath, value);
+    return filePath;
+  }
+
+  readFile(filePath: string) {
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+    return fs.readFileSync(filePath).toString();
+  }
+
+  async get(scope: string, namespace: string, version: string, key: string): Promise<string | null> {
+    const path = this.buildPath(scope, namespace, version, key);
+    return this.readFile(path);
+  }
+
+  async set(scope: string, namespace: string, version: string, key: string, value: string): Promise<void> {
+    const path = this.buildPath(scope, namespace, version, key);
+    this.writeFile(path, value);
+  }
+
+  private buildPath(scope: string, namespace?: string, version?: string, key?: string) {
+    if (key) {
+      return `${this.root}/${scope}/${namespace}/${version}/${key}`;
+    } else if (version) {
+      return `${this.root}/${scope}/${namespace}/${version}`;
+    } else if (namespace) {
+      return `${this.root}/${scope}/${namespace}`;
+    } else {
+      return `${this.root}/${scope}`;
+    }
+  }
+}
+
+export class MemoryStorage implements IStorage {
+  /**
+   * 范围： user / pipeline / runtime / task
+   */
+  scope: any;
+  namespace: any;
+  context: {
+    [scope: string]: {
+      [key: string]: any;
+    };
+  } = {};
+
+  async get(scope: string, namespace: string, version: string, key: string): Promise<string | null> {
+    const scopeContext = this.context[scope];
+    if (scopeContext == null) {
+      return null;
+    }
+    const nsContext = scopeContext[namespace];
+    if (nsContext == null) {
+      return null;
+    }
+    const versionContext = nsContext[version];
+    if (versionContext == null) {
+      return null;
+    }
+    return versionContext[key];
+  }
+
+  async set(scope: string, namespace: string, version: string, key: string, value: string): Promise<void> {
+    let scopeContext = this.context[scope];
+    if (scopeContext == null) {
+      scopeContext = scopeContext[scope];
+    }
+    let nsContext = scopeContext[namespace];
+    if (nsContext == null) {
+      nsContext = {};
+      scopeContext[namespace] = nsContext;
+    }
+    let versionContext = nsContext[version];
+    if (versionContext == null) {
+      versionContext = {};
+      nsContext[version] = versionContext;
+    }
+    versionContext[key] = value;
+  }
+
+  async remove(scope: string, namespace = "", version = "", key = "") {
+    if (key) {
+      if (this.context[scope] && this.context[scope][namespace] && this.context[scope][namespace][version]) {
+        delete this.context[scope][namespace][version][key];
+      }
+    } else if (version) {
+      if (this.context[scope] && this.context[scope][namespace]) {
+        delete this.context[scope][namespace][version];
+      }
+    } else if (namespace) {
+      if (this.context[scope]) {
+        delete this.context[scope][namespace];
+      }
+    } else {
+      delete this.context[scope];
+    }
+  }
+}

package/src/d.ts/fast-crud.ts

@@ -0,0 +1,115 @@
+/**
+ * [x]-col的配置
+ */
+export type ColProps = {
+  span?: number;
+  [props: string]: any;
+};
+
+export type FormItemProps = {
+  /**
+   * 字段label
+   */
+  title?: string;
+  /**
+   * 表单字段组件配置
+   */
+  component?: ComponentProps;
+  /**
+   * 表单字段 [a|el|n]-col的配置
+   * 一般用来配置跨列：{span:24} 占满一行
+   */
+  col?: ColProps;
+  /**
+   * 默认值
+   */
+  value?: any;
+  /**
+   * 帮助提示配置
+   */
+  helper?: string | FormItemHelperProps;
+  /**
+   * 排序号
+   */
+  order?: number;
+  /**
+   * 是否显示此字段
+   */
+  show?: boolean;
+  /**
+   * 是否是空白占位栏
+   */
+  blank?: boolean;
+
+  [key: string]: any;
+};
+
+/**
+ * 表单字段帮助说明配置
+ */
+export type FormItemHelperProps = {
+  /**
+   * 自定义渲染帮助说明
+   * @param scope
+   */
+  render?: (scope: any) => any;
+  /**
+   * 帮助文本
+   */
+  text?: string;
+  /**
+   * 帮助说明所在的位置，[ undefined | label]
+   */
+  position?: string;
+  /**
+   * [a|el|n]-tooltip配置
+   */
+  tooltip?: object;
+
+  [key: string]: any;
+};
+
+/**
+ * 组件配置
+ */
+export type ComponentProps = {
+  /**
+   * 组件的名称
+   */
+  name?: string | object;
+  /**
+   * vmodel绑定的目标属性名
+   */
+  vModel?: string;
+
+  /**
+   * 当原始组件名的参数被以上属性名占用时，可以配置在这里
+   * 例如:原始组件有一个叫name的属性，你想要配置它，则可以按如下配置
+   * ```
+   * component:{
+   *   name:"组件的名称"
+   *   props:{
+   *     name:"组件的name属性"  <-----------
+   *   }
+   * }
+   * ```
+   */
+  props?: {
+    [key: string]: any;
+  };
+
+  /**
+   * 组件事件监听
+   */
+  on?: {
+    [key: string]: (context?: any) => void;
+  };
+
+  /**
+   * 组件其他参数
+   * 事件：onXxx:(event)=>void 组件原始事件监听
+   *      on.onXxx:(context)=>void 组件事件监听(对原始事件包装)
+   * 样式：style、class等
+   */
+  [key: string]: any;
+};

package/src/d.ts/index.ts

@@ -0,0 +1,2 @@
+export * from "./pipeline";
+export * from "./fast-crud";

package/src/d.ts/pipeline.ts

@@ -0,0 +1,119 @@
+export enum RunStrategy {
+  AlwaysRun,
+  SkipWhenSucceed,
+}
+
+export enum ConcurrencyStrategy {
+  Serial,
+  Parallel,
+}
+
+export enum NextStrategy {
+  AllSuccess,
+  OneSuccess,
+}
+
+export enum HandlerType {
+  //清空后续任务的状态
+  ClearFollowStatus,
+  SendEmail,
+}
+
+export type EventHandler = {
+  type: HandlerType;
+  params: {
+    [key: string]: any;
+  };
+};
+
+export type RunnableStrategy = {
+  runStrategy?: RunStrategy;
+  onSuccess?: EventHandler[];
+  onError?: EventHandler[];
+};
+
+export type Step = Runnable & {
+  type: string; //插件类型
+  input: {
+    [key: string]: any;
+  };
+};
+export type Task = Runnable & {
+  steps: Step[];
+};
+
+export type Stage = Runnable & {
+  tasks: Task[];
+  concurrency: ConcurrencyStrategy;
+  next: NextStrategy;
+};
+
+export type Trigger = {
+  id: string;
+  title: string;
+  cron: string;
+  type: string;
+};
+
+export type Runnable = {
+  id: string;
+  title: string;
+  strategy?: RunnableStrategy;
+  runnableType?: string; // pipeline, stage, task , step
+  status?: HistoryResult;
+  default?: {
+    [key: string]: any;
+  };
+};
+
+export type Pipeline = Runnable & {
+  version?: number;
+  userId: any;
+  stages: Stage[];
+  triggers: Trigger[];
+};
+
+export type Context = {
+  [key: string]: any;
+};
+
+export type Log = {
+  title: string;
+  time: number;
+  level: string;
+  text: string;
+};
+
+export enum ResultType {
+  start = "start",
+  success = "success",
+  error = "error",
+  skip = "skip",
+  none = "none",
+}
+
+export type HistoryResultGroup = {
+  [key: string]: {
+    runnable: Runnable;
+    res: HistoryResult;
+  };
+};
+export type HistoryResult = {
+  input: any;
+  output: any;
+  /**
+   * 任务状态
+   */
+  status: ResultType;
+  startTime: number;
+  endTime?: number;
+  /**
+   * 处理结果
+   */
+  result?: ResultType; //success, error,skip
+  message?: string;
+};
+
+export type RunnableMap = {
+  [id: string]: Runnable;
+};

package/src/decorator/common.ts

@@ -0,0 +1,17 @@
+import { Decorator } from "./index";
+
+export type AutowireProp = {
+  name?: string;
+  type?: any;
+};
+export const AUTOWIRE_KEY = "pipeline:autowire";
+
+export function Autowire(props?: AutowireProp): PropertyDecorator {
+  return (target, propertyKey) => {
+    const _type = Reflect.getMetadata("design:type", target, propertyKey);
+    target = Decorator.target(target, propertyKey);
+    props = props || {};
+    props.type = _type;
+    Reflect.defineMetadata(AUTOWIRE_KEY, props || {}, target, propertyKey);
+  };
+}

package/src/decorator/index.ts

@@ -0,0 +1,2 @@
+export * from "./utils";
+export * from "./common";

package/src/decorator/utils.ts

@@ -0,0 +1,42 @@
+import _ from "lodash";
+
+const propertyMap: any = {};
+function attachProperty(target: any, propertyKey: string | symbol) {
+  let props = propertyMap[target];
+  if (props == null) {
+    props = {};
+    propertyMap[target] = props;
+  }
+  props[propertyKey] = true;
+}
+
+function getClassProperties(target: any) {
+  return propertyMap[target] || {};
+}
+
+function target(target: any, propertyKey?: string | symbol) {
+  if (typeof target === "object" && target.constructor) {
+    target = target.constructor;
+  }
+  if (propertyKey != null) {
+    attachProperty(target, propertyKey);
+  }
+  return target;
+}
+
+function inject(define: any, instance: any, context: any, preHandler?: (item: any, key: string, instance: any, context: any) => void) {
+  _.forEach(define, (item, key) => {
+    if (preHandler) {
+      preHandler(item, key, instance, context);
+    }
+    if (context[key] != undefined) {
+      instance[key] = context[key];
+    }
+  });
+}
+export const Decorator = {
+  target,
+  attachProperty,
+  getClassProperties,
+  inject,
+};

package/src/index.ts

@@ -0,0 +1,9 @@
+export * from "./core";
+export * from "./d.ts";
+export * from "./access";
+export * from "./registry";
+export * from "./plugin";
+export * from "./utils";
+export * from "./midway";
+export * from "./context";
+export * from "./decorator";

package/src/midway/configuration.ts

@@ -0,0 +1,52 @@
+import { Config, Configuration, Inject, Logger } from "@midwayjs/decorator";
+// @ts-ignore
+import { ILogger } from "@midwayjs/logger";
+import { IMidwayContainer, MidwayDecoratorService } from "@midwayjs/core";
+
+// ... (see below) ...
+@Configuration({
+  namespace: "pipeline",
+  //importConfigs: [join(__dirname, './config')],
+})
+export class PipelineConfiguration {
+  @Config()
+  // @ts-ignore
+  config;
+  @Logger()
+  // @ts-ignore
+  logger: ILogger;
+
+  @Inject()
+  // @ts-ignore
+  decoratorService: MidwayDecoratorService;
+
+  async onReady(container: IMidwayContainer) {
+    this.logger.info("pipeline install");
+
+    //this.implPropertyDecorator(container);
+    this.logger.info("pipeline installed");
+  }
+
+  // implPropertyDecorator(container: IMidwayContainer) {
+  //   this.logger.info("初始化 property decorator");
+  //   // 实现装饰器
+  //   this.decoratorService.registerPropertyHandler(CLASS_INPUTS_KEY, (propertyName, meta) => {
+  //     return undefined;
+  //   });
+  //
+  //   const autowireWhiteList: any = {
+  //     logger: true,
+  //   };
+  //   this.decoratorService.registerPropertyHandler(CLASS_AUTOWIRE_KEY, (propertyName, meta) => {
+  //     // eslint-disable-next-line no-debugger
+  //     debugger;
+  //     const className = meta.name;
+  //     if (autowireWhiteList[className]) {
+  //       //在白名单里面，注入
+  //       return container.get(className);
+  //     }
+  //     this.logger.warn(`autowire failed:${className} class is not in white list`);
+  //     return undefined;
+  //   });
+  // }
+}

package/src/midway/index.ts

@@ -0,0 +1,5 @@
+// src/index.ts
+export { PipelineConfiguration } from "./configuration";
+// export * from './controller/user';
+// export * from './controller/api';
+// export * from './service/user';

package/src/plugin/api.ts

@@ -0,0 +1,60 @@
+import { Registrable } from "../registry";
+import { FormItemProps } from "../d.ts";
+
+export enum ContextScope {
+  global,
+  pipeline,
+  runtime,
+}
+
+export type Storage = {
+  scope: ContextScope;
+  path: string;
+};
+
+export type TaskOutputDefine = {
+  title: string;
+  value?: any;
+  storage?: Storage;
+};
+export type TaskInputDefine = FormItemProps;
+
+export type PluginDefine = Registrable & {
+  default?: any;
+  input?: {
+    [key: string]: TaskInputDefine;
+  };
+  output?: {
+    [key: string]: TaskOutputDefine;
+  };
+
+  autowire?: {
+    [key: string]: any;
+  };
+};
+
+export type ITaskPlugin = {
+  onInstance(): Promise<void>;
+  execute(): Promise<void>;
+  [key: string]: any;
+};
+
+export type TaskResult = {
+  clearLastStatus?: boolean;
+};
+export abstract class AbstractTaskPlugin implements ITaskPlugin {
+  result: TaskResult = {};
+  clearLastStatus() {
+    this.result.clearLastStatus = true;
+  }
+  async onInstance(): Promise<void> {
+    return;
+  }
+  abstract execute(): Promise<void>;
+}
+
+export type OutputVO = {
+  key: string;
+  title: string;
+  value: any;
+};

package/src/plugin/decorator.ts

@@ -0,0 +1,63 @@
+import _ from "lodash";
+import { pluginRegistry } from "./registry";
+import { PluginDefine, TaskInputDefine, TaskOutputDefine } from "./api";
+import { Decorator } from "../decorator";
+import { AUTOWIRE_KEY } from "../decorator";
+
+// 提供一个唯一 key
+export const PLUGIN_CLASS_KEY = "pipeline:plugin";
+
+export function IsTaskPlugin(define: PluginDefine): ClassDecorator {
+  console.log("IsTaskPlugin");
+  return (target: any) => {
+    target = Decorator.target(target);
+
+    const inputs: any = {};
+    const autowires: any = {};
+    const outputs: any = {};
+    const properties = Decorator.getClassProperties(target);
+    for (const property in properties) {
+      const input = Reflect.getMetadata(PLUGIN_INPUT_KEY, target, property);
+      if (input) {
+        inputs[property] = input;
+      }
+
+      const autowire = Reflect.getMetadata(AUTOWIRE_KEY, target, property);
+      if (autowire) {
+        autowires[property] = autowire;
+      }
+
+      const output = Reflect.getMetadata(PLUGIN_OUTPUT_KEY, target, property);
+      if (output) {
+        outputs[property] = output;
+      }
+    }
+    _.merge(define, { input: inputs, autowire: autowires, output: outputs });
+
+    Reflect.defineMetadata(PLUGIN_CLASS_KEY, define, target);
+
+    target.define = define;
+    pluginRegistry.register(define.name, {
+      define,
+      target,
+    });
+  };
+}
+
+export const PLUGIN_INPUT_KEY = "pipeline:plugin:input";
+
+export function TaskInput(input?: TaskInputDefine): PropertyDecorator {
+  return (target, propertyKey) => {
+    target = Decorator.target(target, propertyKey);
+    Reflect.defineMetadata(PLUGIN_INPUT_KEY, input, target, propertyKey);
+  };
+}
+
+// 装饰器内部的唯一 id
+export const PLUGIN_OUTPUT_KEY = "pipeline:plugin:output";
+export function TaskOutput(output?: TaskOutputDefine): PropertyDecorator {
+  return (target, propertyKey) => {
+    target = Decorator.target(target, propertyKey);
+    Reflect.defineMetadata(PLUGIN_OUTPUT_KEY, output, target, propertyKey);
+  };
+}

package/src/plugin/index.ts

@@ -0,0 +1,3 @@
+export * from "./api";
+export * from "./registry";
+export * from "./decorator";

package/src/plugin/registry.ts

@@ -0,0 +1,4 @@
+import { Registry } from "../registry";
+import { AbstractTaskPlugin } from "./api";
+
+export const pluginRegistry = new Registry<AbstractTaskPlugin>();

package/src/plugin/test/echo-plugin.ts

@@ -0,0 +1,31 @@
+import { ILogger } from "@midwayjs/logger";
+import { ITaskPlugin } from "../api";
+import { IsTaskPlugin, TaskInput } from "../decorator";
+import { Autowire } from "../../decorator";
+
+@IsTaskPlugin({
+  name: "EchoPlugin",
+  title: "测试插件",
+  desc: "test",
+})
+export class EchoPlugin implements ITaskPlugin {
+  @TaskInput({
+    title: "测试属性",
+    component: {
+      name: "text",
+    },
+  })
+  test?: string;
+
+  @Autowire()
+  // @ts-ignore
+  logger: ILogger;
+
+  onInstance(): Promise<void> {
+    throw new Error("Method not implemented.");
+  }
+
+  async execute(): Promise<void> {
+    return Promise.resolve(undefined);
+  }
+}

package/src/registry/index.ts

@@ -0,0 +1 @@
+export * from "./registry";