@steedos/moleculer-bullmq 3.0.0-beta.118

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 LuxChan S.A R.L.-S
+
+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.

package/README.md

@@ -0,0 +1,90 @@
+# moleculer-bullmq
+
+[![Coverage Status](https://coveralls.io/repos/github/LuxChanLu/moleculer-bullmq/badge.svg?branch=master)](https://coveralls.io/github/LuxChanLu/moleculer-bullmq?branch=master)
+[![Codacy Badge](https://api.codacy.com/project/badge/Grade/24c78365441a4e5e99dde311cfa72f18)](https://www.codacy.com/app/LuxChanLu/moleculer-bullmq?utm_source=github.com&utm_medium=referral&utm_content=LuxChanLu/moleculer-bullmq&utm_campaign=Badge_Grade)
+[![Maintainability](https://api.codeclimate.com/v1/badges/e7d4fa4fbe1032b51c77/maintainability)](https://codeclimate.com/github/LuxChanLu/moleculer-bullmq/maintainability)
+![Libraries.io dependency status for latest release](https://img.shields.io/librariesio/release/npm/moleculer-bullmq)
+[![Downloads](https://img.shields.io/npm/dm/moleculer-bullmq.svg)](https://www.npmjs.com/package/moleculer-bullmq)
+
+## How to create job
+You just need to add the `BullMqMixin` and add a `queue` attribute to you action.  
+This action will be call with the params & meta of the scheduler.  
+The return of the action will be the job result.  
+The mixin will add the BullMq `job` into `locals`  
+```js
+module.exports = {
+  name: 'jobs',
+  mixins: [BullMqMixin],
+  settings: {
+    bullmq: {
+      worker: { concurrency: 50 }
+    }
+  },
+  actions: {
+    resize: {
+      queue: true,
+      params: { width: 'number', height: 'number' },
+      async handler(ctx) {
+        const { width, height } = ctx.params
+        const { user } = ctx.meta
+        ctx.locals.job.updateProgress(100)
+        return { user, size: width * height, job: ctx.locals.job.id }
+      }
+    }
+  }
+}
+```
+By default it use the redis cacher, but you can specify a custom client :
+```js
+module.exports = {
+  name: 'jobs',
+  mixins: [BullMqMixin],
+  settings: {
+    bullmq: {
+      client: 'redis://:authpassword@127.0.0.1:6380/4'
+    }
+  }
+}
+The `client` option goes to the `IORedis` constructor.
+```
+## How to queue job
+You can use the `queue` method, with five parameters : Current context, Queue name, Action name, Parameters, Job options
+```js
+module.exports = {
+  name: 'my.service',
+  mixins: [BullMqMixin],
+  actions: {
+    'resize.async': {
+      async handler(ctx) {
+        ctx.meta.user = 'Bob de glace'
+        const job = await this.queue(ctx, 'jobs', 'resize', { width: 42, height: 42 }, { priority: 10 })
+      }
+    }
+  }
+}
+```
+If your in the same service as your scheduling action, you can omit the queue name with the `localQueue` method
+```js
+module.exports = {
+  name: 'my.service',
+  mixins: [BullMqMixin],
+  actions: {
+    resize: {
+      queue: true,
+      params: { width: 'number', height: 'number' },
+      async handler(ctx) {
+        const { width, height } = ctx.params
+        const { user } = ctx.meta
+        ctx.locals.job.updateProgress(100)
+        return { user, size: width * height, job: ctx.locals.job.id }
+      }
+    },
+    'resize.async': {
+      async handler(ctx) {
+        ctx.meta.user = 'Bob de glace'
+        const job = await this.localQueue(ctx, 'resize', { width: 42, height: 42 }, { priority: 10 })
+      }
+    }
+  }
+}
+```

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@steedos/moleculer-bullmq",
+  "version": "3.0.0-beta.118",
+  "description": "Moleculer service for bullmq",
+  "main": "src/index.js",
+  "directories": {
+    "test": "test"
+  },
+  "scripts": {
+    "ci": "jest --watch",
+    "test": "jest",
+    "lint": "eslint --ext=.js src test index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/LuxChanLu/moleculer-bullmq.git"
+  },
+  "keywords": [
+    "moleculer",
+    "queue",
+    "bullmq"
+  ],
+  "author": "Hugo Meyronneinc <hugo@lxc.lu>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/LuxChanLu/moleculer-bullmq/issues"
+  },
+  "homepage": "https://github.com/LuxChanLu/moleculer-bullmq#readme",
+  "jest": {
+    "testEnvironment": "node",
+    "coveragePathIgnorePatterns": [
+      "/node_modules/",
+      "/test/"
+    ]
+  },
+  "engines": {
+    "node": ">= 18.x.x"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "bullmq": "^5.62.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.2.4",
+    "coveralls": "^3.1.1",
+    "eslint": "^8.30.0",
+    "eslint-plugin-jest": "^27.1.7",
+    "jest": "^29.3.1",
+    "jest-cli": "^29.3.1",
+    "moleculer": "^0.14.27",
+    "redis-mock": "^0.56.3",
+    "wait-for-expect": "^3.0.2"
+  },
+  "gitHead": "7511b2250673e97b6b7676aa46c93bd6cb49fd04"
+}

package/src/index.js

@@ -0,0 +1,123 @@
+/*
+ * moleculer-bullmq
+ * Copyright (c) 2022 LuxChan S.A R.L.-S (https://github.com/LuxChanLu/moleculer-bullmq)
+ * MIT Licensed
+ */
+
+'use strict'
+
+const { Worker, Queue, QueueEvents } = require('bullmq')
+
+module.exports = {
+  settings: {
+    bullmq: {
+      worker: {}
+    }
+  },
+  hooks: {
+    before: {
+      '*': '$populateJob'
+    }
+  },
+  created() {
+    this.$queues = Object.entries(this.schema.actions || {}).filter(([, { queue }]) => queue).map(([name]) => name)
+    this.$queueResolved = {}
+    this.$connection = this.settings.bullmq.client ? this.settings.bullmq.client : process.env.B6_CLUSTER_TRANSPORTER
+  },
+  started() {
+    if (this.$queues.length > 0) {
+      this.$worker = new Worker(this.$queueName(), async job => {
+        const { params, meta, parentSpan } = job.data
+        meta.job = { id: job.id, queue: this.$queueName() }
+        return this.broker.call(`${this.$queueName()}.${job.name}`, params, { meta, timeout: 0, parentSpan })
+      }, { ...this.settings.bullmq.worker, connection: this.$connection })
+      this.$events = new QueueEvents(this.$queueName(), { connection: this.$connection })
+      this.$events.on('active', ({ jobId }) => this.$transformEvent(jobId, 'active'))
+      this.$events.on('removed', ({ jobId }) => this.$transformEvent(jobId, 'removed'))
+      this.$events.on('progress', ({ jobId, data }) => this.$transformEvent(jobId, 'progress', { progress: data }))
+      this.$events.on('failed', ({ jobId }) => this.$transformEvent(jobId, 'failed'))
+      this.$events.on('error', ({ jobId }) => this.$transformEvent(jobId, 'error'))
+      this.$events.on('completed', ({ jobId }) => this.$transformEvent(jobId, 'completed'))
+      this.$events.on('drained', () => this.$transformEvent('drained'))
+      this.$events.on('paused', () => this.$transformEvent('paused'))
+      this.$events.on('resumed', () => this.$transformEvent('resumed'))
+      this.$events.on('cleaned', (jobs, type) => this.$transformEvent(null, 'cleaned', { jobs: jobs.map(({ id }) => id), type }))
+    }
+  },
+  async stopped() {
+    if (this.$worker) {
+      await this.$worker.close()
+    }
+    if (this.$events) {
+      await this.$events.close()
+    }
+    await Promise.all(Object.values(this.$queueResolved).map(queue => queue.close()))
+  },
+  methods: {
+    $queueName() {
+      if (this.version != null && !(this.settings || {}).$noVersionPrefix) {
+        return `v${this.version}.${this.name}`
+      }
+      return this.name
+    },
+    $resolve(name) {
+      if (!this.$queueResolved[name]) {
+        this.$queueResolved[name] = new Queue(name, { connection: this.$connection })
+      }
+      return this.$queueResolved[name]
+    },
+    pause(name) {
+      if (name) {
+        return this.$resolve(name).pause()
+      } else if (this.$worker) {
+        return this.$worker.pause()
+      }
+    },
+    resume(name) {
+      if (name) {
+        return this.$resolve(name).resume()
+      } else if (this.$worker) {
+        return this.$worker.resume()
+      }
+    },
+    queue(ctx, name, action, params, options) {
+      return this.$resolve(name).add(action, {
+        params, meta: ctx.meta, parentSpan: {
+          id: ctx.parentID, traceID: ctx.requestID, sampled: ctx.tracing
+        }
+      }, options)
+    },
+    localQueue(ctx, action, params, options) {
+      return this.queue(ctx, this.$queueName(), action, params, options)
+    },
+    job(name, id) {
+      if (arguments.length === 1) {
+        id = name
+        name = this.$queueName()
+      }
+      return this.$resolve(name).getJob(id)
+    },
+    async $populateJob(ctx) {
+      ctx.locals.job = ctx.meta && ctx.meta.job ? await this.job(ctx.meta.job.queue, ctx.meta.job.id) : undefined
+    },
+    async $transformEvent(id, type, params) {
+      const event = arguments.length === 1 ? [id] : [type]
+      let emitOpts = { meta: { job: { queue: this.$queueName() } } }
+      if (arguments.length >= 2 && id) {
+        const job = await this.job(id)
+        if (job && job.name) {
+          event.unshift(job.name)
+          const { meta, parentSpan } = job.data
+          meta.job = { id: job.id, queue: this.$queueName() }
+          emitOpts = { meta, parentSpan }
+        }
+        params = params || {}
+        params.id = id
+      }
+      const name = event.join('.')
+
+      this.broker.emit(`${this.$queueName()}.${name}`, params, emitOpts)
+      this.broker.emit(name, params, this.$queueName(), { ...emitOpts, groups: this.$queueName() })
+    }
+  }
+}