0.0.6

* PipeLine支持`Task`和`TaskRaw`
* 新增范例`example/airport-raw.ts`
* 优化日志函数与日志输出格式
* 新增测试模式: `PipeLine.test()`

Author: gavinning

CHANGELOG.md

@@ -1,6 +1,14 @@
 # CHANGELOG
 
 
+## [0.0.6] - 2025-07-03
+
+* PipeLine支持`Task`和`TaskRaw`
+* 新增范例`example/airport-raw.ts`
+* 优化日志函数与日志输出格式
+* 新增测试模式: `PipeLine.test()`
+
+
 ## [0.0.5] - 2025-07-01
 
 * 日志模块更新，增加特殊日志

example/airport-raw.ts

@@ -0,0 +1,39 @@
+import { join } from 'path'
+import { name, version } from '../package.json'
+import { PipeLine, remote, logError } from '../src/airport'
+
+const file = [name, version].join('-') + '.tgz'
+
+// 创建部署任务
+const deployTask = {
+  name: '部署应用',
+  steps: [
+    {
+      name: '构建项目',
+      run: [
+        'mkdir -p .cache',
+        'mv `npm pack` .cache/',
+      ],
+    },
+    {
+      name: '发布到远程服务器',
+      async run() {
+        const ssh = remote('gavin@192.168.5.121')
+        const dir = (path?: string) => join('/home/gavin/test', path ?? '')
+        try {
+          await ssh.run('rm -f', dir('latest'))
+          await ssh.run('mkdir -p', dir(version))
+          await ssh.scp(`.cache/${file}`, dir())
+          await ssh.run('tar -zxvf', dir(file), '-C', dir(version))
+          await ssh.run('ln -s', dir(version), dir('latest'))
+        }
+        catch (e) {
+          logError(e)
+        }
+      },
+    },
+  ],
+}
+
+// 执行流水线
+PipeLine.run([deployTask])

example/airport-test.ts

@@ -0,0 +1,39 @@
+import { join } from 'path'
+import { name, version } from '../package.json'
+import { PipeLine, Task, remote, logError } from '../src/airport'
+
+const file = [name, version].join('-') + '.tgz'
+
+// 创建部署任务
+const deployTask = new Task({
+  name: '部署应用',
+  steps: [
+    {
+      name: '构建项目',
+      run: [
+        'mkdir -p .cache',
+        'mv `npm pack` .cache/',
+      ],
+    },
+    {
+      name: '发布到远程服务器',
+      async run() {
+        const ssh = remote('gavin@192.168.5.121')
+        const dir = (path?: string) => join('/home/gavin/test', path ?? '')
+        try {
+          await ssh.run('rm -f', dir('latest'))
+          await ssh.run('mkdir -p', dir(version))
+          await ssh.scp(`.cache/${file}`, dir())
+          await ssh.run('tar -zxvf', dir(file), '-C', dir(version))
+          await ssh.run('ln -s', dir(version), dir('latest'))
+        }
+        catch (e) {
+          logError(e)
+        }
+      },
+    },
+  ],
+})
+
+// 执行流水线
+PipeLine.test([deployTask])

example/airport.ts

@@ -26,6 +26,7 @@ const deployTask = new Task({
           await ssh.scp(`.cache/${file}`, dir())
           await ssh.run('tar -zxvf', dir(file), '-C', dir(version))
           await ssh.run('ln -s', dir(version), dir('latest'))
+          await ssh.run('rm -f', dir(file))
         }
         catch (e) {
           logError(e)

package.json

@@ -1,6 +1,6 @@
 {
   "name": "airport2",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "main": "src/index.ts",
   "type": "module",
   "files": [

src/airport/air/pipeline.ts

@@ -1,36 +1,58 @@
 import { Task } from './task'
-import { log, purple } from '../lib'
-import {
-  START,
-  END,
-  PIPE_TOP_LEFT,
-  PIPE_TOP_RIGHT,
-  PIPE_BOTTOM_LEFT,
-  PIPE_BOTTOM_RIGHT,
-} from '../conf'
+import { logPipeStart, logPipeEnd } from '../lib'
+import type { TaskRaw } from '../types'
 
 export class PipeLine {
   public name?: string
+  // public log: boolean = true // 决定是否打印日志
   private tasks: Task[]
 
-  static run(tasks: Task[]) {
+  static run(tasks: Task[] | TaskRaw[]) {
     return new PipeLine(tasks).run()
   }
 
-  constructor(tasks: Task[]) {
-    this.tasks = tasks
+  static test(tasks: Task[] | TaskRaw[]) {
+    return new PipeLine(tasks).test()
+  }
+
+  constructor(tasks: Task[] | TaskRaw[]) {
+    if (tasks.length > 0 && tasks[0] instanceof Task) {
+      this.tasks = tasks as Task[]
+    } else {
+      this.tasks = (tasks as TaskRaw[]).map((task) => new Task(task))
+    }
   }
 
   /**
    * 执行任务中的所有步骤
    */
   async run() {
-    log(PIPE_TOP_LEFT, purple('Airport PipeLine'), START, PIPE_TOP_RIGHT)
+    this.beforeRun()
+    for (const [index, task] of this.tasks.entries()) {
+      if (!task.skip) {
+        task.index = index + 1
+        await task._runPipeLine()
+      }
+    }
+    this.afterRun()
+  }
 
-    for (const task of this.tasks) {
-      await task.run()
+  test() {
+    this.beforeRun()
+    for (const [index, task] of this.tasks.entries()) {
+      if (!task.skip) {
+        task.index = index + 1
+        task.test()
+      }
     }
+    this.afterRun()
+  }
+
+  private beforeRun() {
+    logPipeStart()
+  }
 
-    log(PIPE_BOTTOM_LEFT, purple('Airport PipeLine'), END, PIPE_BOTTOM_RIGHT)
+  private afterRun() {
+    logPipeEnd()
   }
 }

src/airport/air/step.ts

@@ -1,35 +1,48 @@
-import { log, run } from '../lib'
 import type { StepRaw } from '../types'
+import { log, run, logStepStart, logStepEnd, logTesting } from '../lib'
 
 export class Step {
   public name: string
   public skip: boolean = false
+  public index: number = 1 // 当前索引
   private step: StepRaw
-  private test: boolean
+  private testing: boolean = false
 
-  constructor(step: StepRaw, test: boolean = false) {
-    this.test = test
+  constructor(step: StepRaw) {
     this.step = step
     this.name = step.name
     this.skip = step.skip ?? false
   }
 
+  async run() {
+    this.beforeRun()
+    await this.exec()
+    this.afterRun()
+  }
+
+  async test() {
+    this.testing = true
+    this.beforeRun()
+    if (typeof this.step.run === 'string') {
+      this.runStringTesting()
+    } else if (Array.isArray(this.step.run)) {
+      this.runArrayTesting()
+    } else {
+      logTesting('[async function run]')
+    }
+    this.afterRun()
+  }
+
   /**
    * 执行步骤
    */
-  async run(): Promise<any> {
+  private async exec(): Promise<any> {
     if (typeof this.step.run === 'string') {
       return this.runString()
     } else if (Array.isArray(this.step.run)) {
       return this.runArray()
     } else {
-      // 函数类型的步骤
-      if (this.test) {
-        log(`[TEST MODE] Would execute function: ${this.step.run.name}`)
-      } else {
-        // 实际执行函数
-        return await this.step.run()
-      }
+      return await this.step.run()
     }
   }
 
@@ -38,25 +51,36 @@ export class Step {
    */
   private async runString() {
     const runString = this.step.run as string
-    if (this.test) {
-      log(`[TEST MODE] Would execute: ${runString}`)
-    } else {
-      return await run(runString)
-    }
+    return await run(runString)
   }
 
   /**
    * 处理字符串数组类型的命令执行
    */
   private async runArray() {
     const runArray = this.step.run as string[]
-    if (this.test) {
-      log(`[TEST MODE] Would execute array: ${runArray}`)
-    } else {
-      for (const cmd of runArray) {
-        await run(cmd)
-      }
+    for (const cmd of runArray) {
+      await run(cmd)
     }
   }
-}
 
+  private runStringTesting() {
+    const runString = this.step.run as string
+    logTesting(runString)
+  }
+
+  private runArrayTesting() {
+    const runArray = this.step.run as string[]
+    for (const cmd of runArray) {
+      logTesting(cmd)
+    }
+  }
+
+  private beforeRun() {
+    logStepStart(this)
+  }
+
+  private afterRun() {
+    logStepEnd(this)
+  }
+}

src/airport/air/task.ts

@@ -1,35 +1,74 @@
 import { Step } from './step'
-import { logStart, purple, blue } from '../lib'
-import { START, END } from '../conf'
-import type { TaskOptions, StepRaw } from '../types'
+import { logTaskStart, logTaskEnd } from '../lib'
+import type { TaskRaw, StepRaw } from '../types'
 
 export class Task {
+  // 任务名称
   public name: string
-  public opt: TaskOptions
+
+  /** Task元数据 */
+  public opt: TaskRaw
+
+  /** 在流水线中的任务索引 */
+  public index: number = 1 // 当前索引
+
+  /** 流水线中是否跳过当前任务 */
+  public skip: boolean = false
+
+  // 是否无头模式，是否自调用
+  // true: PipeLine模式，Task由PipeLine.run调用
+  // false: 自调用，独立任务模式，外部直接调用Task.run
+  public inPipeLine: boolean = false
+
+  // 任务步骤
   private steps: StepRaw[]
 
-  constructor(opt: TaskOptions) {
+  constructor(opt: TaskRaw) {
     this.opt = opt
     this.name = opt.name
     this.steps = opt.steps
+    this.skip = opt.skip ?? false
   }
 
   /**
    * 执行任务中的所有步骤
    */
-  async run(test: boolean = false) {
-    const steps = this.steps.map((step) => new Step(step, test))
-
-    logStart(purple('T'), START, blue(this.name))
+  async run() {
+    this.beforeRun()
+    const steps = this.steps.map((step) => new Step(step))
 
-    for (const step of steps) {
+    for (const [index, step] of steps.entries()) {
       if (!step.skip) {
-        logStart(purple('S'), START, blue(step.name))
+        step.index = index + 1
         step.skip || (await step.run())
-        logStart(purple('S'), END, blue(step.name))
       }
     }
+    this.afterRun()
+  }
+
+  test() {
+    this.inPipeLine = true
+    this.beforeRun()
+    const steps = this.steps.map((step) => new Step(step))
+    for (const [index, step] of steps.entries()) {
+      if (!step.skip) {
+        step.index = index + 1
+        step.skip || (step.test())
+      }
+    }
+    this.afterRun()
+  }
+
+  async _runPipeLine() {
+    this.inPipeLine = true
+    await this.run()
+  }
+
+  private beforeRun() {
+    logTaskStart(this)
+  }
 
-    logStart(purple('T'), END, blue(this.name))
+  private afterRun() {
+    logTaskEnd(this)
   }
 }