@oliasoft-open-source/node-json-migrator 2.0.0

package/dist/plan/plan.js

@@ -0,0 +1,266 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.writePlan = exports.sortPlanEntries = exports.readPlan = exports.parsePlan = exports.getPlannedMigrations = exports.getNextSequenceString = exports.generatePlanEntries = void 0;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _fs = require("fs");
+
+var _moduleFromString = require("module-from-string");
+
+var _hash = require("../hash/hash");
+
+var _glob = require("../glob/glob");
+
+var _validator = require("./validator");
+
+var _database = require("../database/database");
+
+var _cachedPlannedVersion = require("./cached-planned-version");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+//https://stackoverflow.com/a/31102605/942635
+const sortEntry = entry => Object.keys(entry).sort().reduce((obj, key) => {
+  obj[key] = entry[key];
+  return obj;
+}, {});
+/**
+ * Sorts the plan entries by sequence string
+ *
+ * @param {Array<Object>} plannedMigrations
+ * returns Array<Object>
+ */
+
+
+const maxSequence = 1000000;
+
+const sortPlanEntries = plannedMigrations => plannedMigrations //dotted sequence sort https://stackoverflow.com/a/40201629/942635
+.sort((a, b) => a.sequence.replace(/\d+/g, n => +n + maxSequence).localeCompare(b.sequence.replace(/\d+/g, n => +n + maxSequence))).map(p => sortEntry(p));
+/**
+ * Get next automatic sequence string
+ *
+ * @param {String} sortedPlannedMigrations
+ * returns String next sequence
+ */
+
+
+exports.sortPlanEntries = sortPlanEntries;
+
+const getNextSequenceString = sortedPlannedMigrations => {
+  const lastMigration = sortedPlannedMigrations[sortedPlannedMigrations.length - 1];
+
+  if (!lastMigration) {
+    return '1';
+  }
+
+  const currentLastSequenceNumber = lastMigration.sequence;
+  return `${parseInt(`${currentLastSequenceNumber}`, 10) + 1}`;
+};
+/**
+ * Read the plan.json file
+ *
+ * @param {String} directory path to migrations directory
+ * returns Promise<String> plan.json string
+ */
+
+
+exports.getNextSequenceString = getNextSequenceString;
+
+const readPlan = async directory => {
+  let plan;
+
+  try {
+    plan = await _fs.promises.readFile(`${directory}/plan.json`, {
+      encoding: 'utf8'
+    });
+    return plan;
+  } catch {
+    return '[]';
+  }
+};
+/**
+ * Parse the plan.json string into a sorted object
+ *
+ * @param {String} plan plan.json string
+ * returns Array<Object> migration entries from plan.json
+ */
+
+
+exports.readPlan = readPlan;
+
+const parsePlan = plan => {
+  let plannedMigrations;
+
+  try {
+    plannedMigrations = JSON.parse(plan);
+  } catch {
+    throw new Error('Invalid JSON for migrator plan.js (unable to parse file)');
+  }
+
+  if (!(0, _validator.validatePlan)(plannedMigrations)) {
+    throw new Error('Invalid JSON for migrator plan.js (does not match schema)');
+  }
+
+  return sortPlanEntries(plannedMigrations);
+};
+/**
+ * Write the plan.json file
+ *
+ * @param {String} directory path to migrations directory
+ * @param {String} content string to be written to file
+ * returns Promise<>
+ */
+
+
+exports.parsePlan = parsePlan;
+
+const writePlan = async (directory, content) => {
+  //todo this is not being written in the correct order
+  await _fs.promises.writeFile(_path.default.resolve(`${directory}/plan.json`), content, {
+    encoding: 'utf8'
+  });
+};
+/**
+ * Generate plan entries
+ *
+ * @param {Array<Object>} sortedMigrationEntries
+ * returns Array<Object>
+ */
+
+
+exports.writePlan = writePlan;
+
+const generatePlanEntries = sortedMigrationEntries => sortedMigrationEntries.map(m => ({
+  fileHash: m.fileHash,
+  fileName: m.fileName,
+  sequence: m.sequence
+}));
+
+exports.generatePlanEntries = generatePlanEntries;
+
+const getPlannedMigrations = async ({
+  config
+}) => {
+  const {
+    directory,
+    database,
+    entity,
+    force,
+    pgpHelpers,
+    dry,
+    importModule = true
+  } = config;
+
+  if (database && !dry) {
+    /*
+      OW-9043 and OW-9238: The tool tries to self-create its own meta tables
+      to simplify setup. That's useful for devs running on local machines,
+      and when running via CLI jobs. But for environments without CREATE
+      privileges, we want this don't want to execute CREATE TABLE IF NOT EXISTS
+      because it throws errors.
+    */
+    const tablesExist = await (0, _database.migrationTablesExist)(database, entity);
+
+    if (!tablesExist) {
+      await (0, _database.createMigrationsTables)(database, entity);
+    }
+  }
+
+  const rawPlan = await readPlan(directory);
+  const parsedPlan = parsePlan(rawPlan);
+  const plannedMigrations = parsedPlan.map(m => ({
+    fileHashFromPlan: m.fileHash,
+    fileName: m.fileName,
+    sequence: m.sequence
+  }));
+  const filePaths = await (0, _glob.getMigrationFilePaths)(directory);
+  const skippedFilePaths = await (0, _glob.getSkippedFilePaths)(directory);
+  const plannedMigrationsWithFileEntries = await Promise.all(plannedMigrations.map(async m => {
+    var _await$importFromStri;
+
+    const {
+      fileName
+    } = m;
+    const isValidFileName = (0, _validator.validateFileName)(fileName);
+    const filePath = filePaths.find(f => _path.default.parse(f).base === m.fileName);
+    const script = filePath ? await _fs.promises.readFile(filePath, {
+      encoding: 'utf8'
+    }) : null;
+    const migrator = script && importModule ? (_await$importFromStri = await (0, _moduleFromString.importFromString)(script)) === null || _await$importFromStri === void 0 ? void 0 : _await$importFromStri.default : null;
+    const fileHash = script ? (0, _hash.hash)(script) : null; //skipped files
+
+    const skipMatch = '(.skip|.skip\\d+).js$';
+
+    const nameMatch = _path.default.parse(m.fileName).name;
+
+    const regex = new RegExp(`${nameMatch}${skipMatch}`, 'g');
+    const matchingSkippedFilePaths = skippedFilePaths.filter(f => {
+      const name = _path.default.parse(f).base;
+
+      return name.match(regex);
+    });
+    const skippedFileHashes = await Promise.all(matchingSkippedFilePaths.map(async skippedFilePath => {
+      const skippedScript = await _fs.promises.readFile(skippedFilePath, {
+        encoding: 'utf8'
+      });
+      return skippedScript ? (0, _hash.hash)(skippedScript) : null;
+    }));
+    return { ...m,
+      filePath,
+      isValidFileName,
+      script,
+      migrator,
+      fileHash,
+      skippedFileHashes
+    };
+  }));
+  const historicalMigrations = database ? await (0, _database.getMigrationRecords)(database, entity) : [];
+  const plannedMigrationsWithHistory = plannedMigrationsWithFileEntries.map(m => {
+    const historicalMigration = historicalMigrations.find(h => h.fileName === m.fileName);
+    return { ...m,
+      fileHashFromHistory: (historicalMigration === null || historicalMigration === void 0 ? void 0 : historicalMigration.fileHash) || null,
+      sequenceFromHistory: (historicalMigration === null || historicalMigration === void 0 ? void 0 : historicalMigration.sequence) || null
+    };
+  });
+  (0, _validator.throwIfFilesNotFound)(plannedMigrationsWithHistory, importModule);
+  (0, _validator.throwIfFileNamesInvalid)(plannedMigrationsWithHistory);
+  (0, _validator.throwIfFileNamesNotUnique)(plannedMigrationsWithHistory);
+  (0, _validator.throwIfSequenceNotUnique)(plannedMigrationsWithHistory);
+
+  if (!force) {
+    (0, _validator.warnIfFilesHaveBeenRemovedFromPlan)(plannedMigrationsWithHistory, historicalMigrations);
+    (0, _validator.throwIfFilesHaveChanged)(plannedMigrationsWithHistory);
+    (0, _validator.throwIfSequenceHasChanged)(plannedMigrationsWithHistory);
+  }
+
+  (0, _validator.throwIfSequenceHasIntegerGaps)(plannedMigrationsWithHistory);
+  const validatedPlannedMigrations = generatePlanEntries(plannedMigrationsWithHistory);
+  const validatedPlan = JSON.stringify(validatedPlannedMigrations, null, 2);
+  const nextVersion = (0, _hash.hash)(validatedPlan);
+  const planHasChanged = validatedPlan !== rawPlan;
+
+  if (!dry && planHasChanged) {
+    await writePlan(directory, validatedPlan);
+  }
+
+  if (database && !dry) {
+    await (0, _database.replaceMigrationsRecords)(database, pgpHelpers, entity, validatedPlannedMigrations);
+    const versionRecord = [{
+      version: nextVersion,
+      plan: validatedPlan
+    }];
+    await (0, _database.insertVersions)(database, pgpHelpers, entity, versionRecord);
+  }
+
+  (0, _cachedPlannedVersion.setCachedPlannedVersion)(nextVersion);
+  return {
+    plannedMigrations: plannedMigrationsWithHistory,
+    nextVersion
+  };
+};
+
+exports.getPlannedMigrations = getPlannedMigrations;

package/dist/plan/plan.schema.json

@@ -0,0 +1,20 @@
+{
+  "type": "array",
+  "items": {
+    "type": "object",
+    "properties": {
+      "fileHash": {
+        "type": ["string"]
+      },
+      "fileName": {
+        "type": "string"
+      },
+      "sequence": {
+        "type": "string",
+        "pattern": "^[1-9][0-9]*(.[1-9][0-9]*)*$"
+      }
+    },
+    "required": ["fileHash", "fileName", "sequence"],
+    "additionalProperties": false
+  }
+}

package/dist/plan/planned-version.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPlannedVersion = void 0;
+
+var _fs = require("fs");
+
+var _hash = require("../hash/hash");
+
+var _plan = require("./plan");
+
+var _cachedPlannedVersion = require("./cached-planned-version");
+
+const getPlannedVersion = async ({
+  config
+}) => {
+  const {
+    directory
+  } = config;
+  const currentPlan = await _fs.promises.readFile(`${directory}/plan.json`, {
+    encoding: 'utf8'
+  });
+  const plannedVersion = (0, _hash.hash)(currentPlan);
+  const cachedPlannedVersion = (0, _cachedPlannedVersion.getCachedPlannedVersion)();
+  return cachedPlannedVersion === plannedVersion ? cachedPlannedVersion : (await (0, _plan.getPlannedMigrations)({
+    config: { ...config,
+      importModule: false
+    }
+  })).nextVersion;
+};
+
+exports.getPlannedVersion = getPlannedVersion;

package/dist/plan/validator.js

@@ -0,0 +1,254 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.warnIfFilesHaveBeenRemovedFromPlan = exports.validatePlan = exports.validateFileName = exports.validateFileDescription = exports.throwIfSequenceNotUnique = exports.throwIfSequenceHasIntegerGaps = exports.throwIfSequenceHasChanged = exports.throwIfFilesNotFound = exports.throwIfFilesHaveChanged = exports.throwIfFileNamesNotUnique = exports.throwIfFileNamesInvalid = void 0;
+
+var _chalk = _interopRequireDefault(require("chalk"));
+
+var _lodash = require("lodash");
+
+var _ajv = _interopRequireDefault(require("ajv"));
+
+var _ajvErrors = _interopRequireDefault(require("ajv-errors"));
+
+var _planSchema = _interopRequireDefault(require("./plan.schema.json"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const isNonEmptyString = input => (0, _lodash.isString)(input) && input.length > 0;
+
+const ajv = new _ajv.default({
+  allErrors: true
+});
+(0, _ajvErrors.default)(ajv); //sequence pattern: https://regex101.com/r/4qHZLm/1
+
+const planValidator = ajv.compile(_planSchema.default);
+/**
+ * Validates if a plan matches the schema
+ *
+ * @param {Array<Object>} plan
+ * @returns {Boolean} valid
+ */
+
+const validatePlan = plan => {
+  const valid = planValidator(plan);
+  const {
+    errors
+  } = planValidator;
+
+  if (errors !== null && errors !== void 0 && errors.length) {
+    errors.forEach(e => console.error(`${e.message}${e.instancePath ? `at ${e.instancePath}` : ''}`));
+  }
+
+  return valid;
+};
+/**
+ * Validates if file description format is valid
+ *
+ * @param {String} description
+ * @returns {Boolean} valid
+ */
+
+
+exports.validatePlan = validatePlan;
+
+const validateFileDescription = description => {
+  if (!description) {
+    return false;
+  } //https://regex101.com/r/IO0dzF/1
+
+
+  const validFileName = /^([a-z]+|(([a-z]+-)+[a-z]+))$/g;
+  return validFileName.test(description);
+};
+/**
+ * Validates if fileName format is valid
+ *
+ * @param {String} fileName
+ * @returns {Boolean} valid
+ */
+
+
+exports.validateFileDescription = validateFileDescription;
+
+const validateFileName = fileName => {
+  //https://regex101.com/r/EX2RlS/1
+  const validFileName = /^([a-z]+|(([a-z]+-)+[a-z]+))(.js|.skip.js)$/g;
+  return validFileName.test(fileName);
+};
+/**
+ * Throws if file names are invalid
+ *
+ * @param {Array<Object>} migrationEntries
+ */
+
+
+exports.validateFileName = validateFileName;
+
+const throwIfFileNamesInvalid = fileEntries => {
+  const invalidFileNames = fileEntries.filter(f => !f.isValidFileName).map(f => f.fileName);
+
+  if (invalidFileNames.length) {
+    invalidFileNames.forEach(name => console.error(_chalk.default.red(name)));
+    throw new Error('Invalid migration filename format (use kebab-case)');
+  }
+};
+/**
+ * Warns if files have been removed
+ *
+ * @param {Array<Object>} migrationEntries
+ * @param {Array<Object>} historicalMigrations
+ */
+
+
+exports.throwIfFileNamesInvalid = throwIfFileNamesInvalid;
+
+const warnIfFilesHaveBeenRemovedFromPlan = (migrationEntries, historicalMigrations) => {
+  const fileNames = migrationEntries.map(f => f.fileName);
+  const deletedFilesNames = historicalMigrations.filter(e => !fileNames.includes(e.fileName)).map(e => e.fileName);
+
+  if (deletedFilesNames.length) {
+    deletedFilesNames.forEach(name => console.warn(_chalk.default.yellow(name)));
+    console.warn(_chalk.default.yellow('Previously executed migration files have been deleted from plan.json (rename file to .skip.js and replace with a new file instead)'));
+  }
+};
+/**
+ * Throws error if any pre-existing file has changed
+ *
+ * @param {Array<Object>} migrationEntries
+ */
+
+
+exports.warnIfFilesHaveBeenRemovedFromPlan = warnIfFilesHaveBeenRemovedFromPlan;
+
+const throwIfFilesHaveChanged = migrationEntries => {
+  const changedFilesNames = migrationEntries.filter(m => {
+    const {
+      fileHash,
+      fileHashFromPlan,
+      fileHashFromHistory,
+      skippedFileHashes
+    } = m;
+    const matchesHistory = !isNonEmptyString(fileHashFromHistory) || [fileHash].concat(skippedFileHashes).includes(fileHashFromHistory);
+    const matchesPlan = !isNonEmptyString(fileHashFromPlan) || [fileHash].concat(skippedFileHashes).includes(fileHashFromPlan);
+    return !(matchesHistory && matchesPlan);
+  }).map(f => f.fileName);
+
+  if (changedFilesNames.length) {
+    changedFilesNames.forEach(name => console.error(_chalk.default.red(name)));
+    throw new Error('Not allowed to change migration files (for unreleased local work, you can use the `force` option)');
+  }
+};
+/**
+ * Throws error if previous sequence numbers have changed
+ *
+ * @param {Array<Object>} migrationEntries
+ */
+
+
+exports.throwIfFilesHaveChanged = throwIfFilesHaveChanged;
+
+const throwIfSequenceHasChanged = migrationEntries => {
+  const changeSequences = migrationEntries.filter(m => {
+    const {
+      sequence,
+      sequenceFromHistory
+    } = m;
+    const changed = (0, _lodash.isString)(sequenceFromHistory) && sequenceFromHistory !== sequence;
+    return changed;
+  }).map(f => f.fileName);
+
+  if (changeSequences.length) {
+    changeSequences.forEach(name => console.error(_chalk.default.red(name)));
+    throw new Error('Not allowed to change migration sequences in plan.json');
+  }
+};
+/**
+ * Throws error if sequence numbers are not unique
+ *
+ * @param {Array<Object>} migrationEntries
+ */
+
+
+exports.throwIfSequenceHasChanged = throwIfSequenceHasChanged;
+
+const throwIfSequenceNotUnique = migrationEntries => {
+  const sequenceNumbers = migrationEntries.map(f => f.sequence);
+  const repeatedSequenceNumbers = sequenceNumbers.filter( //https://stackoverflow.com/a/59517965/942635
+  (s => v => s.has(v) || !s.add(v))(new Set()));
+  const duplicates = migrationEntries.filter(f => repeatedSequenceNumbers.includes(f.sequence)).map(f => f.fileName);
+
+  if (duplicates.length) {
+    duplicates.forEach(fileName => console.error(_chalk.default.red(fileName)));
+    throw new Error('Migrations must have unique sequence numbers in plan.json');
+  }
+};
+/**
+ * Throws error if sequence numbers are not unique
+ *
+ * @param {Array<Object>} migrationEntries
+ */
+
+
+exports.throwIfSequenceNotUnique = throwIfSequenceNotUnique;
+
+const throwIfSequenceHasIntegerGaps = migrationEntries => {
+  const toInteger = sequence => parseInt(sequence.split('.')[0], 10);
+
+  const unique = arr => Array.from(new Set(arr));
+
+  const sequences = migrationEntries.map(s => s.sequence);
+  const sequenceIntegers = sequences.map(s => toInteger(s));
+  const uniqueSequenceIntegers = unique(sequenceIntegers);
+  const orderedUniqueSequenceIntegers = uniqueSequenceIntegers.sort((a, b) => a - b);
+  const max = orderedUniqueSequenceIntegers[orderedUniqueSequenceIntegers.length - 1];
+  const expected = Array.from({
+    length: max
+  }, (v, k) => k + 1);
+  const missing = (0, _lodash.xor)(orderedUniqueSequenceIntegers, expected);
+
+  if (missing.length) {
+    throw new Error(`Migration sequence numbers in plan.json have unexpected gaps: ${missing.join(', ')}`);
+  }
+};
+/**
+ * Throws error if file names are not unique
+ *
+ * @param {Array<Object>} migrationEntries
+ */
+
+
+exports.throwIfSequenceHasIntegerGaps = throwIfSequenceHasIntegerGaps;
+
+const throwIfFileNamesNotUnique = migrationEntries => {
+  const fileNames = migrationEntries.map(f => f.fileName);
+  const repeatedFileNames = fileNames.filter( //https://stackoverflow.com/a/59517965/942635
+  (s => v => s.has(v) || !s.add(v))(new Set()));
+
+  if (repeatedFileNames.length) {
+    repeatedFileNames.forEach(fileName => console.error(_chalk.default.red(fileName)));
+    throw new Error('Migration file names must be unique');
+  }
+};
+/**
+ * Throws error if files listed in plan.json are found
+ *
+ * @param {Array<Object>} migrationEntries
+ * @param {Boolean} importModule
+ */
+
+
+exports.throwIfFileNamesNotUnique = throwIfFileNamesNotUnique;
+
+const throwIfFilesNotFound = (migrationEntries, importModule) => {
+  const migrationsWithoutFiles = migrationEntries.filter(m => !m.script || importModule && !m.script && !m.migrator);
+
+  if (migrationsWithoutFiles.length) {
+    migrationsWithoutFiles.forEach(migration => console.error(_chalk.default.red(migration.fileName)));
+    throw new Error('Migration files from plan.json are missing from filesystem');
+  }
+};
+
+exports.throwIfFilesNotFound = throwIfFilesNotFound;

package/index.js

@@ -0,0 +1 @@
+module.exports = require('./dist/index.js');

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@oliasoft-open-source/node-json-migrator",
+  "version": "2.0.0",
+  "description": "A library for JSON migrations",
+  "scripts": {
+    "build": "npx babel src --ignore 'src/**/*.test.js' --out-dir dist --copy-files --no-copy-ignored",
+    "test": "npm run prettier:check && npm run lint:check && npm run test:unit:coverage",
+    "test:unit": "jest --silent=true",
+    "test:unit:coverage": "jest --silent=true --collectCoverage=true",
+    "test:unit:verbose": "jest --silent=false --verbose",
+    "lint:check": "eslint \"**/*.{js,jsx}\"",
+    "lint:fix": "eslint --fix \"**/*.{js,jsx}\"",
+    "prettier:check": "prettier --check \"**/*.{js,jsx,json,css,less}\"",
+    "prettier:fix": "prettier --write \"**/*.{js,jsx,json,css,less}\"",
+    "prepare": "husky install"
+  },
+  "lint-staged": {
+    "*.js": "eslint --cache --fix",
+    "*.{js,jsx,json,css,less}": [
+      "prettier --write"
+    ]
+  },
+  "homepage": "https://oliasoft-open-source.gitlab.io/node-postgresql-migrator",
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.com/oliasoft-open-source/node-postgresql-migrator.git"
+  },
+  "author": "Oliasoft AS and contributors",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://https://gitlab.com/oliasoft-open-source/node-postgresql-migrator/issues"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.15.7",
+    "@babel/core": "^7.15.0",
+    "@babel/eslint-parser": "^7.15.0",
+    "@babel/node": "^7.14.9",
+    "@babel/plugin-proposal-class-properties": "^7.14.5",
+    "@babel/plugin-proposal-decorators": "^7.14.5",
+    "@babel/plugin-proposal-export-namespace-from": "^7.14.5",
+    "@babel/plugin-proposal-function-sent": "^7.14.5",
+    "@babel/plugin-proposal-json-strings": "^7.14.5",
+    "@babel/plugin-proposal-numeric-separator": "^7.14.5",
+    "@babel/plugin-proposal-object-rest-spread": "^7.14.7",
+    "@babel/plugin-proposal-throw-expressions": "^7.14.5",
+    "@babel/plugin-syntax-dynamic-import": "^7.8.3",
+    "@babel/plugin-syntax-import-meta": "^7.10.4",
+    "@babel/preset-env": "^7.15.0",
+    "@babel/runtime": "^7.15.3",
+    "@types/lodash": "^4.14.172",
+    "babel-eslint": "^10.1.0",
+    "babel-jest": "^27.1.0",
+    "babel-loader": "^8.2.2",
+    "eslint": "^7.32.0",
+    "eslint-config-airbnb": "^18.2.1",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-import-resolver-alias": "^1.1.2",
+    "eslint-plugin-import": "^2.24.2",
+    "husky": "^7.0.2",
+    "jest": "^27.1.0",
+    "jest-diff": "^27.3.1",
+    "jest-matcher-utils": "^27.3.1",
+    "lint-staged": "^11.1.2",
+    "mock-fs": "^5.1.1",
+    "pg-mem": "^1.9.17",
+    "prettier": "2.3.2"
+  },
+  "dependencies": {
+    "ajv": "^8.6.3",
+    "ajv-errors": "^3.0.0",
+    "chalk": "^4.1.2",
+    "glob-promise": "^4.2.0",
+    "immer": "^9.0.6",
+    "lodash": "^4.17.21",
+    "module-from-string": "^3.1.1",
+    "pg-promise": "^10.11.0"
+  }
+}

package/scripts/send-mattermost-message.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+set -eEuo pipefail
+
+# This script requires the following things to be installed:
+#  - bash
+#  - curl
+
+# Required inputs:
+MATTERMOST_BOT_KEY=$1
+MSG=$2
+
+# Optional inputs:
+CHANNEL=${3:-'#releases'}
+USERNAME=${4:-'Gitlab CI/CD'}
+ICON_URL=${5:-'https://oliasoftstaticwebsite.blob.core.windows.net/helpguideimages/robot-icon.png'}
+MATTERMOST_URL=${6:-'https://mm.oliasoft.com/hooks/'}
+
+curl -X POST \
+  --data-urlencode \
+  "payload={\"channel\": \"$CHANNEL\", \"username\": \"$USERNAME\", \"icon_url\": \"$ICON_URL\", \"text\": \"$MSG\"}" \
+  $MATTERMOST_URL$MATTERMOST_BOT_KEY