@certd/pipeline 1.0.0 → 1.0.3

package/dist/d/access/api.d.ts

@@ -0,0 +1,16 @@
+import { Registrable } from "../registry";
+import { FormItemProps } from "../d.ts";
+export type AccessInputDefine = FormItemProps & {
+    title: string;
+    required?: boolean;
+};
+export type AccessDefine = Registrable & {
+    input?: {
+        [key: string]: AccessInputDefine;
+    };
+};
+export interface IAccessService {
+    getById(id: any): Promise<any>;
+}
+export interface IAccess {
+}

package/dist/d/access/decorator.d.ts

@@ -0,0 +1,5 @@
+import { AccessDefine, AccessInputDefine } from "./api";
+export declare const ACCESS_CLASS_KEY = "pipeline:access";
+export declare const ACCESS_INPUT_KEY = "pipeline:access:input";
+export declare function IsAccess(define: AccessDefine): ClassDecorator;
+export declare function AccessInput(input?: AccessInputDefine): PropertyDecorator;

package/{src/plugin/index.ts → dist/d/access/index.d.ts}

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

package/dist/d/access/registry.d.ts

@@ -0,0 +1,2 @@
+import { Registry } from "../registry";
+export declare const accessRegistry: Registry<unknown>;

package/{src/context/index.ts → dist/d/context/index.d.ts}

@@ -1,6 +1,5 @@
-import { AxiosInstance } from "axios";
-import { IContext } from "../core";
-
-export type HttpClient = AxiosInstance;
-export type UserContext = IContext;
-export type PipelineContext = IContext;
+import { AxiosInstance } from "axios";
+import { IContext } from "../core";
+export type HttpClient = AxiosInstance;
+export type UserContext = IContext;
+export type PipelineContext = IContext;

package/dist/d/core/context.d.ts

@@ -0,0 +1,32 @@
+import { IStorage } from "./storage";
+export interface IContext {
+    getInt(key: string): Promise<number>;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    getObj<T = any>(key: string): Promise<T | null>;
+    setObj<T = any>(key: string, value: T): Promise<void>;
+    updateVersion(): Promise<void>;
+    initVersion(): Promise<void>;
+}
+export declare class ContextFactory {
+    storage: IStorage;
+    memoryStorage: IStorage;
+    constructor(storage: IStorage);
+    getContext(scope: string, namespace: string): IContext;
+    getMemoryContext(scope: string, namespace: string): IContext;
+}
+export declare class StorageContext implements IContext {
+    storage: IStorage;
+    namespace: string;
+    scope: string;
+    _version: number;
+    _initialVersion: number;
+    constructor(scope: string, namespace: string, storage: IStorage);
+    initVersion(): Promise<void>;
+    updateVersion(): Promise<void>;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    getInt(key: string): Promise<number>;
+    getObj<T = any>(key: string): Promise<T | null>;
+    setObj<T = any>(key: string, value: T): Promise<void>;
+}

package/dist/d/core/executor.d.ts

@@ -0,0 +1,32 @@
+import { Pipeline, ResultType, Runnable, Stage } from "../d.ts";
+import { RunHistory, RunnableCollection } from "./run-history";
+import { ContextFactory, IContext } from "./context";
+import { IStorage } from "./storage";
+import { Logger } from "log4js";
+import { IAccessService } from "../access";
+export declare class Executor {
+    userId: any;
+    pipeline: Pipeline;
+    runtime: RunHistory;
+    accessService: IAccessService;
+    contextFactory: ContextFactory;
+    logger: Logger;
+    pipelineContext: IContext;
+    lastStatusMap: RunnableCollection;
+    onChanged: (history: RunHistory) => void;
+    constructor(options: {
+        userId: any;
+        pipeline: Pipeline;
+        storage: IStorage;
+        onChanged: (history: RunHistory) => Promise<void>;
+        accessService: IAccessService;
+    });
+    init(): Promise<void>;
+    run(runtimeId: any, triggerType: string): Promise<void>;
+    runWithHistory(runnable: Runnable, runnableType: string, run: () => Promise<void>): Promise<ResultType.success | ResultType.skip>;
+    private runStages;
+    runStage(stage: Stage): Promise<ResultType.success | ResultType.error>;
+    compositionResultType(resList: ResultType[]): ResultType.success | ResultType.error;
+    private runTask;
+    private runStep;
+}

package/{src/core/index.ts → dist/d/core/index.d.ts}

@@ -1,4 +1,4 @@
-export * from "./executor";
-export * from "./run-history";
-export * from "./context";
-export * from "./storage";
+export * from "./executor";
+export * from "./run-history";
+export * from "./context";
+export * from "./storage";

package/dist/d/core/run-history.d.ts

@@ -0,0 +1,39 @@
+import { Context, HistoryResult, Pipeline, Runnable } from "../d.ts";
+import { Logger } from "log4js";
+export type HistoryStatus = {
+    result: HistoryResult;
+    logs: string[];
+};
+export type RunTrigger = {
+    type: string;
+};
+export declare function NewRunHistory(obj: any): RunHistory;
+export declare class RunHistory {
+    id: string;
+    context: Context;
+    pipeline: Pipeline;
+    logs: {
+        [runnableId: string]: string[];
+    };
+    _loggers: {
+        [runnableId: string]: Logger;
+    };
+    trigger: RunTrigger;
+    constructor(runtimeId: any, trigger: RunTrigger, pipeline: Pipeline);
+    start(runnable: Runnable): HistoryResult;
+    success(runnable: Runnable): void;
+    skip(runnable: Runnable): void;
+    error(runnable: Runnable, e: Error): void;
+    log(runnable: Runnable, text: string): void;
+    logError(runnable: Runnable, e: Error): void;
+    finally(runnable: Runnable): void;
+}
+export declare class RunnableCollection {
+    private collection;
+    private pipeline;
+    constructor(pipeline?: Pipeline);
+    private each;
+    private toMap;
+    get(id: string): Runnable | undefined;
+    clear(): void;
+}

package/dist/d/core/storage.d.ts

@@ -0,0 +1,30 @@
+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 declare class FileStorage implements IStorage {
+    root: string;
+    constructor(rootDir?: string);
+    remove(scope: string, namespace: string, version: string, key: string): Promise<void>;
+    writeFile(filePath: string, value: string): string;
+    readFile(filePath: string): string | null;
+    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>;
+    private buildPath;
+}
+export declare class MemoryStorage implements IStorage {
+    /**
+     * 范围： user / pipeline / runtime / task
+     */
+    scope: any;
+    namespace: any;
+    context: {
+        [scope: string]: {
+            [key: string]: any;
+        };
+    };
+    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>;
+}

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

@@ -0,0 +1,107 @@
+/**
+ * [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 → dist/d/d.ts/index.d.ts}

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

package/dist/d/d.ts/pipeline.d.ts

@@ -0,0 +1,103 @@
+export declare enum RunStrategy {
+    AlwaysRun = 0,
+    SkipWhenSucceed = 1
+}
+export declare enum ConcurrencyStrategy {
+    Serial = 0,
+    Parallel = 1
+}
+export declare enum NextStrategy {
+    AllSuccess = 0,
+    OneSuccess = 1
+}
+export declare enum HandlerType {
+    ClearFollowStatus = 0,
+    SendEmail = 1
+}
+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;
+    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 declare 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;
+    message?: string;
+};
+export type RunnableMap = {
+    [id: string]: Runnable;
+};

package/dist/d/decorator/common.d.ts

@@ -0,0 +1,6 @@
+export type AutowireProp = {
+    name?: string;
+    type?: any;
+};
+export declare const AUTOWIRE_KEY = "pipeline:autowire";
+export declare function Autowire(props?: AutowireProp): PropertyDecorator;

package/{src/decorator/index.ts → dist/d/decorator/index.d.ts}

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

package/dist/d/decorator/utils.d.ts

@@ -0,0 +1,11 @@
+declare function attachProperty(target: any, propertyKey: string | symbol): void;
+declare function getClassProperties(target: any): any;
+declare function target(target: any, propertyKey?: string | symbol): any;
+declare function inject(define: any, instance: any, context: any, preHandler?: (item: any, key: string, instance: any, context: any) => void): void;
+export declare const Decorator: {
+    target: typeof target;
+    attachProperty: typeof attachProperty;
+    getClassProperties: typeof getClassProperties;
+    inject: typeof inject;
+};
+export {};

package/{src/index.ts → dist/d/index.d.ts}

@@ -1,9 +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";
+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/dist/d/midway/configuration.d.ts

@@ -0,0 +1,8 @@
+import { ILogger } from "@midwayjs/logger";
+import { IMidwayContainer, MidwayDecoratorService } from "@midwayjs/core";
+export declare class PipelineConfiguration {
+    config: any;
+    logger: ILogger;
+    decoratorService: MidwayDecoratorService;
+    onReady(container: IMidwayContainer): Promise<void>;
+}

package/dist/d/midway/index.d.ts

@@ -0,0 +1 @@
+export { PipelineConfiguration } from "./configuration";

package/dist/d/plugin/api.d.ts

@@ -0,0 +1,48 @@
+import { Registrable } from "../registry";
+import { FormItemProps } from "../d.ts";
+export declare enum ContextScope {
+    global = 0,
+    pipeline = 1,
+    runtime = 2
+}
+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 declare abstract class AbstractTaskPlugin implements ITaskPlugin {
+    result: TaskResult;
+    clearLastStatus(): void;
+    onInstance(): Promise<void>;
+    abstract execute(): Promise<void>;
+}
+export type OutputVO = {
+    key: string;
+    title: string;
+    value: any;
+};

package/dist/d/plugin/decorator.d.ts

@@ -0,0 +1,7 @@
+import { PluginDefine, TaskInputDefine, TaskOutputDefine } from "./api";
+export declare const PLUGIN_CLASS_KEY = "pipeline:plugin";
+export declare function IsTaskPlugin(define: PluginDefine): ClassDecorator;
+export declare const PLUGIN_INPUT_KEY = "pipeline:plugin:input";
+export declare function TaskInput(input?: TaskInputDefine): PropertyDecorator;
+export declare const PLUGIN_OUTPUT_KEY = "pipeline:plugin:output";
+export declare function TaskOutput(output?: TaskOutputDefine): PropertyDecorator;

package/{src/access/index.ts → dist/d/plugin/index.d.ts}

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

package/{src/plugin/registry.ts → dist/d/plugin/registry.d.ts}

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

package/dist/d/plugin/test/echo-plugin.d.ts

@@ -0,0 +1,8 @@
+import { ILogger } from "@midwayjs/logger";
+import { ITaskPlugin } from "../api";
+export declare class EchoPlugin implements ITaskPlugin {
+    test?: string;
+    logger: ILogger;
+    onInstance(): Promise<void>;
+    execute(): Promise<void>;
+}

package/{src/registry/index.ts → dist/d/registry/index.d.ts}

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

package/dist/d/registry/registry.d.ts

@@ -0,0 +1,26 @@
+export type Registrable = {
+    name: string;
+    title: string;
+    desc?: string;
+};
+export type RegistryItem<T> = {
+    define: Registrable;
+    target: T;
+};
+export declare class Registry<T> {
+    storage: {
+        [key: string]: RegistryItem<T>;
+    };
+    register(key: string, value: RegistryItem<T>): void;
+    get(name: string): RegistryItem<T>;
+    getStorage(): {
+        [key: string]: RegistryItem<T>;
+    };
+    getDefineList(): {
+        key: string;
+        name: string;
+        title: string;
+        desc?: string | undefined;
+    }[];
+    getDefine(key: string): Registrable | undefined;
+}

package/dist/d/utils/index.d.ts

@@ -0,0 +1,6 @@
+import sleep from "./util.sleep";
+export * from "./util.log";
+export declare const utils: {
+    sleep: typeof sleep;
+    http: import("axios").AxiosInstance;
+};

package/dist/d/utils/util.log.d.ts

@@ -0,0 +1,4 @@
+import log4js, { Logger } from "log4js";
+export declare const logger: log4js.Logger;
+export declare function buildLogger(write: (text: string) => void): log4js.Logger;
+export type ILogger = Logger;

package/dist/d/utils/util.request.d.ts

@@ -0,0 +1 @@
+export declare const request: import("axios").AxiosInstance;

package/dist/d/utils/util.sleep.d.ts

@@ -0,0 +1 @@
+export default function (timeout: number): Promise<unknown>;

package/dist/pipeline.mjs

@@ -0,0 +1,11 @@
+Object.defineProperty(exports, "__esModule", { value: !0 });
+const r = require("tslib");
+r.__exportStar(require("./core"), exports);
+r.__exportStar(require("./d.ts"), exports);
+r.__exportStar(require("./access"), exports);
+r.__exportStar(require("./registry"), exports);
+r.__exportStar(require("./plugin"), exports);
+r.__exportStar(require("./utils"), exports);
+r.__exportStar(require("./midway"), exports);
+r.__exportStar(require("./context"), exports);
+r.__exportStar(require("./decorator"), exports);

package/dist/pipeline.umd.js

@@ -0,0 +1 @@
+(function(e){typeof define=="function"&&define.amd?define(e):e()})(function(){"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const e=require("tslib");e.__exportStar(require("./core"),exports),e.__exportStar(require("./d.ts"),exports),e.__exportStar(require("./access"),exports),e.__exportStar(require("./registry"),exports),e.__exportStar(require("./plugin"),exports),e.__exportStar(require("./utils"),exports),e.__exportStar(require("./midway"),exports),e.__exportStar(require("./context"),exports),e.__exportStar(require("./decorator"),exports)});