broker.js

// broker.js
"use strict";

const { ServiceBroker } = require("moleculer");
const Sequelize = require("./middlewares/sequelize");
const broker = new ServiceBroker({
	middlewares: [Sequelize()]
});
broker.createService({
	name: "service",
	actions: {
	    action() {
	      return this.models.user.findAll();
	    }
  	},
});

sequelize.js

// middlewares/sequelize.js
"use strict";

const Sequelize = require("sequelize");
const fs = require("fs");
const path = require("path");

module.exports = function SequelizeDbMiddleware(options = {}) {

	options = {
		dialect: "postgres",
		define: {
			timestamps: false
		},
		logging: process.env.LOGLEVEL === "debug",
		pool: {
			max: 5,
			min: 0,
			acquire: 60000,
			idle: 30000
		},
		...options
	};
	const connection = new Sequelize(process.env.DATABASE, options);
	const models = {};

	return {
		name: "Sequelize",

		created() {
			this.logger.info("Sequelize middleware ready");
			const dir = __dirname + "/../models";
			fs
				.readdirSync(dir)
				.filter(file => file.endsWith(".js"))
				.map(file => {
					const model = require(path.join(dir, file))(connection, Sequelize.DataTypes);
					models[model.name] = model;
					return model;
				}).forEach(model => {
					if ("associate" in model) model.associate(models);
				});
			this.logger.info("Sequelize all models loaded!");
		},

		async stopping () {
			if(connection) await connection.close();
		},

		serviceCreating(service, schema) {
			if(!schema.name.startsWith("$")) {
				service.Sequelize = connection;
				service.Sequelize.Op = Sequelize.Op;
				service.models = models;
			}
		}
	};
};

user.js

// models/user.js
"use strict";

module.exports = (sequelize, DataTypes) => {

	const User = sequelize.define("user", {
		email: {
			type: DataTypes.STRING,
			unique: true
		},
		password: DataTypes.STRING,
		role: {
			type: DataTypes.ENUM,
			values: ["user", "admin"]
		},
		username: {
			type: DataTypes.STRING,
			unique: true
		},
		settings: DataTypes.JSONB,
		status: DataTypes.INTEGER,
		activation_code: DataTypes.STRING,
		passwordRecoveryToken: DataTypes.STRING,
		secret2fa: DataTypes.STRING,
		referer: DataTypes.UUID,
		uuid: {
			type: DataTypes.UUID,
			primaryKey: true
		},
		registration_date: DataTypes.DATE,
		last_login_date:  DataTypes.DATE
	}, {

	});

	User.associate = function (models) {
		User.hasMany(models.worker, {foreignKey: "username", sourceKey: "username"});
	};

	return User;
};