@universis/webhooks 1.1.1

package/.gitlab-ci.yml

@@ -0,0 +1,40 @@
+image: node:20
+
+stages:
+  - test
+  - deploy
+
+publish:
+  stage: deploy
+  needs: [lint, audit]
+  rules:
+    - if: $CI_PROJECT_NAMESPACE == "universis" && $CI_COMMIT_REF_PROTECTED == "true"
+      changes:
+        - package.json
+  script:
+    - npm i
+    - npm run build
+    - echo //registry.npmjs.org/:_authToken=$NPM_TOKEN > .npmrc
+    # Extract a few values from package.json
+    - NPM_PACKAGE_NAME=$(node -p "require('./package.json').name")
+    - NPM_PACKAGE_VERSION=$(node -p "require('./package.json').version")
+    # Compare the version in package.json to all published versions.
+    # If the package.json version has not yet been published, run `npm publish`.
+    - |
+      if [[ $(npm view "${NPM_PACKAGE_NAME}" versions) != *"'${NPM_PACKAGE_VERSION}'"* ]]; then
+        npm publish --access public
+      else
+        echo "Version ${NPM_PACKAGE_VERSION} of ${NPM_PACKAGE_NAME} has already been published, so no new version has been published."
+      fi
+
+lint:
+  stage: test
+  script:
+    - npm i
+    - npx eslint src --quiet
+
+audit:
+  stage: test
+  script:
+    - npm i
+    - npm audit --production

package/LICENSE

@@ -0,0 +1,163 @@
+GNU Lesser General Public License
+=================================
+
+_Version 3, 29 June 2007_  
+_Copyright © 2007 Free Software Foundation, Inc. &lt;<http://fsf.org/>&gt;_
+
+Everyone is permitted to copy and distribute verbatim copies
+of this license document, but changing it is not allowed.
+
+
+This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+### 0. Additional Definitions
+
+As used herein, “this License” refers to version 3 of the GNU Lesser
+General Public License, and the “GNU GPL” refers to version 3 of the GNU
+General Public License.
+
+“The Library” refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+An “Application” is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+A “Combined Work” is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the “Linked
+Version”.
+
+The “Minimal Corresponding Source” for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+The “Corresponding Application Code” for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+### 1. Exception to Section 3 of the GNU GPL
+
+You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+### 2. Conveying Modified Versions
+
+If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+* **a)** under this License, provided that you make a good faith effort to
+ensure that, in the event an Application does not supply the
+function or data, the facility still operates, and performs
+whatever part of its purpose remains meaningful, or
+
+* **b)** under the GNU GPL, with none of the additional permissions of
+this License applicable to that copy.
+
+### 3. Object Code Incorporating Material from Library Header Files
+
+The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+* **a)** Give prominent notice with each copy of the object code that the
+Library is used in it and that the Library and its use are
+covered by this License.
+* **b)** Accompany the object code with a copy of the GNU GPL and this license
+document.
+
+### 4. Combined Works
+
+You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+* **a)** Give prominent notice with each copy of the Combined Work that
+the Library is used in it and that the Library and its use are
+covered by this License.
+
+* **b)** Accompany the Combined Work with a copy of the GNU GPL and this license
+document.
+
+* **c)** For a Combined Work that displays copyright notices during
+execution, include the copyright notice for the Library among
+these notices, as well as a reference directing the user to the
+copies of the GNU GPL and this license document.
+
+* **d)** Do one of the following:
+    - **0)** Convey the Minimal Corresponding Source under the terms of this
+License, and the Corresponding Application Code in a form
+suitable for, and under terms that permit, the user to
+recombine or relink the Application with a modified version of
+the Linked Version to produce a modified Combined Work, in the
+manner specified by section 6 of the GNU GPL for conveying
+Corresponding Source.
+    - **1)** Use a suitable shared library mechanism for linking with the
+Library.  A suitable mechanism is one that **(a)** uses at run time
+a copy of the Library already present on the user's computer
+system, and **(b)** will operate properly with a modified version
+of the Library that is interface-compatible with the Linked
+Version.
+
+* **e)** Provide Installation Information, but only if you would otherwise
+be required to provide such information under section 6 of the
+GNU GPL, and only to the extent that such information is
+necessary to install and execute a modified version of the
+Combined Work produced by recombining or relinking the
+Application with a modified version of the Linked Version. (If
+you use option **4d0**, the Installation Information must accompany
+the Minimal Corresponding Source and Corresponding Application
+Code. If you use option **4d1**, you must provide the Installation
+Information in the manner specified by section 6 of the GNU GPL
+for conveying Corresponding Source.)
+
+### 5. Combined Libraries
+
+You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+* **a)** Accompany the combined library with a copy of the same work based
+on the Library, uncombined with any other library facilities,
+conveyed under the terms of this License.
+* **b)** Give prominent notice with the combined library that part of it
+is a work based on the Library, and explaining where to find the
+accompanying uncombined form of the same work.
+
+### 6. Revised Versions of the GNU Lesser General Public License
+
+The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License “or any later version”
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

package/README.md

@@ -0,0 +1,113 @@
+# @universis/hooks
+
+Universis API Server module providing webhook functionality.
+
+## Installation
+
+```bash
+npm install @universis/webhooks
+```
+
+## Usage
+
+Install service in your Universis API Server configuration:
+
+```json
+{
+  "services": [
+    {
+      "serviceType": "@universis/webhooks#WebHookService"
+    }
+  ]
+}
+```
+
+## Configuration
+
+The service can be configured with the following options:
+```json
+{
+  "settings": {
+    "universis": {
+      "webhooks": {
+        "logLevel": "info",
+        "logDir": "./log"
+      }
+    }
+  }
+}
+```
+
+where `logLevel` can be one of `error`, `warn`, `info`, `verbose`, or `debug` and `logDir` is the directory where logs will be stored.
+
+## Features
+
+- Create, read, update, and delete webhooks.
+- Trigger webhooks on specific events.
+
+## API Endpoints
+
+- `GET /api/webHookActions`: Retrieve a list of available webhook actions. The operation requires `webhooks:read` permission.
+- `POST /api/webhooks`: Create a new webhook. The operation requires `webhooks:write` permission.
+- `GET /api/webhooks`: Retrieve a list of webhooks. The operation requires `webhooks:read` permission.
+- `GET /api/webhooks/:id`: Retrieve a specific webhook by ID. The operation requires `webhooks:read` permission.
+- `PUT /api/webhooks/:id`: Update a specific webhook by ID. The operation requires `webhooks:write` permission.
+- `DELETE /api/webhooks/:id`: Delete a specific webhook by ID. The operation requires `webhooks
+
+## Create a new webhook
+
+To create a new webhook, send a POST request to `/api/webhooks` with the following JSON body:
+
+```json
+{
+  "action": "update_user",
+  "active": true,
+  "config": {
+    "url": "https://example.com/webhook",
+    "contentType": "application/json"
+}
+```
+
+## Delete a webhook
+
+To delete a webhook, send a DELETE request to `/api/webhooks/:id`, where `:id` is the unique identifier of the webhook you want to delete. 
+The operation requires `webhooks:write` permission.
+
+## Update a webhook
+
+To update a webhook, send a POST request to `/api/webhooks/` containing the updated fields in the JSON body.
+
+```json
+{
+  "id": "7085b05b-8da6-4004-b5cc-7b204725d63f",
+  "action": "update_action",
+  "active": false,
+  "config": {
+    "url": "https://newexample.com/webhook",
+    "contentType": "application/xml"
+  }
+}
+```
+
+The operation requires `webhooks:write` permission. The `active` field can be used to enable or disable the webhook wihout deleting it.
+An inactive webhook will not be triggered during events.
+
+## Triggering Webhooks
+
+Webhooks are triggered automatically when the specified action occurs in the system. The payload sent will contain relevant data about the event.
+
+```json
+{
+  "event": "update_user",
+  "entityType": "User",
+  "entitySet": "Users",
+  "origin": "https://api.example.com",
+  "target": {
+    "id": "12345"
+  }
+}
+```
+
+where `event` is the action that triggered the webhook, `entityType` is the type of entity involved, `entitySet` is the collection the entity belongs to, and `target` contains details about the specific entity.
+
+The payload does not include other metadata except for the target identifier. The webhook receiver can use this identifier to fetch additional details if needed.

package/dist/SchemaLoader.d.ts

@@ -0,0 +1,4 @@
+import { FileSchemaLoaderStrategy } from '@themost/data';
+export declare class SchemaLoader extends FileSchemaLoaderStrategy {
+
+}

package/dist/SchemaLoader.js

@@ -0,0 +1,46 @@
+"use strict";Object.defineProperty(exports, "__esModule", { value: true });exports.SchemaLoader = void 0;var _data = require("@themost/data");
+var _path = _interopRequireDefault(require("path"));function _interopRequireDefault(e) {return e && e.__esModule ? e : { default: e };}
+
+
+if (typeof _data.ValueDialect.prototype.$literal === 'undefined') {
+  /**
+   * Add $literal support to ValueDialect
+   */
+  _data.ValueDialect.prototype.$literal = async function (value) {
+    return value;
+  };
+}
+
+/**
+ * A schema loader for loading extra data models
+ */
+class SchemaLoader extends _data.FileSchemaLoaderStrategy {
+
+  /**
+   * @param {import('@themost/data').ConfigurationBase} config
+   */
+  constructor(config) {
+    super(config);
+    // set model path
+    this.setModelPath(_path.default.resolve(__dirname, 'config/models'));
+  }
+
+  getModelDefinition(name) {
+    const model = super.getModelDefinition.bind(this)(name);
+    if (model) {
+      if (Array.isArray(model.eventListeners)) {
+        model.eventListeners.forEach((eventListener) => {
+          if (eventListener.type.indexOf('.') === 0) {
+            eventListener.type = _path.default.resolve(__dirname, eventListener.type);
+          }
+        });
+      }
+      if (model.classPath && model.classPath.indexOf('.') === 0) {
+        model.classPath = _path.default.resolve(__dirname, model.classPath);
+      }
+    }
+    return model;
+  }
+
+}exports.SchemaLoader = SchemaLoader;
+//# sourceMappingURL=SchemaLoader.js.map

package/dist/SchemaLoader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SchemaLoader.js","names":["_data","require","_path","_interopRequireDefault","e","__esModule","default","ValueDialect","prototype","$literal","value","SchemaLoader","FileSchemaLoaderStrategy","constructor","config","setModelPath","path","resolve","__dirname","getModelDefinition","name","model","bind","Array","isArray","eventListeners","forEach","eventListener","type","indexOf","classPath","exports"],"sources":["../src/SchemaLoader.js"],"sourcesContent":["import {FileSchemaLoaderStrategy} from '@themost/data';\nimport path from 'path';\nimport { ValueDialect } from '@themost/data';\n\nif (typeof ValueDialect.prototype.$literal === 'undefined') {\n    /**\n     * Add $literal support to ValueDialect\n     */\n    ValueDialect.prototype.$literal = async function (value) {\n        return value;\n    }\n}\n\n/**\n * A schema loader for loading extra data models\n */\nexport class SchemaLoader extends FileSchemaLoaderStrategy {\n\n    /**\n     * @param {import('@themost/data').ConfigurationBase} config\n     */\n    constructor(config) {\n        super(config);\n        // set model path\n        this.setModelPath(path.resolve(__dirname, 'config/models'));\n    }\n\n    getModelDefinition(name) {\n        const model = super.getModelDefinition.bind(this)(name);\n        if (model) {\n            if (Array.isArray(model.eventListeners) ) {\n                model.eventListeners.forEach(eventListener => {\n                    if (eventListener.type.indexOf('.') === 0) {\n                        eventListener.type = path.resolve(__dirname,  eventListener.type);\n                    }\n                });\n            }\n            if (model.classPath && model.classPath.indexOf('.')===0) {\n                model.classPath= path.resolve(__dirname, model.classPath);\n            }\n        }\n        return model;\n    }\n\n}\n\n"],"mappings":"yGAAA,IAAAA,KAAA,GAAAC,OAAA;AACA,IAAAC,KAAA,GAAAC,sBAAA,CAAAF,OAAA,UAAwB,SAAAE,uBAAAC,CAAA,UAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;;;AAGxB,IAAI,OAAOG,kBAAY,CAACC,SAAS,CAACC,QAAQ,KAAK,WAAW,EAAE;EACxD;AACJ;AACA;EACIF,kBAAY,CAACC,SAAS,CAACC,QAAQ,GAAG,gBAAgBC,KAAK,EAAE;IACrD,OAAOA,KAAK;EAChB,CAAC;AACL;;AAEA;AACA;AACA;AACO,MAAMC,YAAY,SAASC,8BAAwB,CAAC;;EAEvD;AACJ;AACA;EACIC,WAAWA,CAACC,MAAM,EAAE;IAChB,KAAK,CAACA,MAAM,CAAC;IACb;IACA,IAAI,CAACC,YAAY,CAACC,aAAI,CAACC,OAAO,CAACC,SAAS,EAAE,eAAe,CAAC,CAAC;EAC/D;;EAEAC,kBAAkBA,CAACC,IAAI,EAAE;IACrB,MAAMC,KAAK,GAAG,KAAK,CAACF,kBAAkB,CAACG,IAAI,CAAC,IAAI,CAAC,CAACF,IAAI,CAAC;IACvD,IAAIC,KAAK,EAAE;MACP,IAAIE,KAAK,CAACC,OAAO,CAACH,KAAK,CAACI,cAAc,CAAC,EAAG;QACtCJ,KAAK,CAACI,cAAc,CAACC,OAAO,CAAC,CAAAC,aAAa,KAAI;UAC1C,IAAIA,aAAa,CAACC,IAAI,CAACC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;YACvCF,aAAa,CAACC,IAAI,GAAGZ,aAAI,CAACC,OAAO,CAACC,SAAS,EAAGS,aAAa,CAACC,IAAI,CAAC;UACrE;QACJ,CAAC,CAAC;MACN;MACA,IAAIP,KAAK,CAACS,SAAS,IAAIT,KAAK,CAACS,SAAS,CAACD,OAAO,CAAC,GAAG,CAAC,KAAG,CAAC,EAAE;QACrDR,KAAK,CAACS,SAAS,GAAEd,aAAI,CAACC,OAAO,CAACC,SAAS,EAAEG,KAAK,CAACS,SAAS,CAAC;MAC7D;IACJ;IACA,OAAOT,KAAK;EAChB;;AAEJ,CAACU,OAAA,CAAApB,YAAA,GAAAA,YAAA","ignoreList":[]}

package/dist/WebHookService.d.ts

@@ -0,0 +1,11 @@
+import { ApplicationService } from '@themost/common';
+import {DataEventArgs} from '@themost/data';
+import {JsonLogger} from '@themost/json-logger';
+
+export declare class WebHookService extends ApplicationService {
+    readonly logger: JsonLogger;
+    refresh(): Promise<void>;
+    emit(event: DataEventArgs, extraArgs?: {
+        action?: string
+    }): void;
+}

package/dist/WebHookService.js

@@ -0,0 +1,272 @@
+"use strict";Object.defineProperty(exports, "__esModule", { value: true });exports.WebHookService = void 0;
+
+var _common = require("@themost/common");
+var _scope = require("./config/scope.access");
+var _data = require("@themost/data");
+
+
+
+
+
+var _SchemaLoader = require("./SchemaLoader");
+var _superagent = _interopRequireDefault(require("superagent"));
+var _query = require("@themost/query");
+var _jsonLogger = require("@themost/json-logger");
+var _path = _interopRequireDefault(require("path"));
+var _rotatingFileStream = require("rotating-file-stream");
+var _dataModelFilter = require("@themost/data/data-model-filter.parser");
+var _OnWebHookAction = require("./listeners/OnWebHookAction");function _interopRequireDefault(e) {return e && e.__esModule ? e : { default: e };} // noinspection NpmUsedModulesInstalled
+
+class WebHookService extends _common.ApplicationService {
+  constructor(app) {
+    super(app);
+    /**
+     * @type {import('@themost/data').DefaultSchemaLoaderStrategy}
+     */
+    const schemaLoader = app.getConfiguration().getStrategy(_data.SchemaLoaderStrategy);
+    schemaLoader.loaders.push(new _SchemaLoader.SchemaLoader(app.getConfiguration()));
+    /**
+     * @type {import('@themost/data').ODataModelBuilder}
+     */
+    const builder = app.getService(_data.ODataModelBuilder);
+    if (builder) {
+      builder.clean(true);
+    }
+    // extend universis api scope access configuration
+    if (app && app.container) {
+      app.container.subscribe((container) => {
+        if (container) {
+          // add extra scope access elements
+          const scopeAccess = app.getConfiguration().getStrategy(function ScopeAccessConfiguration() {
+          });
+          if (scopeAccess != null) {
+            scopeAccess.elements.unshift(..._scope.WebHookScopeAccessElements);
+          }
+        }
+      });
+    }
+
+    // configure logger
+    // get options from configuration
+    const options = Object.assign({
+      logLevel: 'info',
+      logFormat: 'raw',
+      logDir: _path.default.join(process.cwd(), 'log')
+    }, app.getConfiguration().getSourceAt('settings/universis/webhooks'));
+    const logDir = options.logDir ? _path.default.resolve(options.logDir) : _path.default.join(process.cwd(), 'log');
+    const logFile = 'webhooks.log';
+    // create a rotating write stream
+    // noinspection JSValidateTypes
+    const logStream = (0, _rotatingFileStream.createStream)(logFile, {
+      interval: '1d', // rotate daily
+      path: logDir
+    });
+    this.logger = new _jsonLogger.JsonLogger({
+      level: options.logLevel,
+      format: options.logFormat,
+      stdout: logStream,
+      stderr: logStream
+    });
+    this.logger.info(`Universis WebHookService initialized with log level "${options.logLevel}"`);
+
+    if (app) {
+      const self = this;
+      setTimeout(() => {
+        (async () => {
+          await self.refresh();
+        })();
+      }, 1000);
+    }
+
+  }
+
+  /**
+   * Refresh web hook actions
+   * @returns {Promise<void>}
+   */
+  async refresh() {
+    /**
+     * @type {import('@themost/data').DataContext}
+     */
+    let context;
+    try {
+      // noinspection JSUnresolvedReference
+      context = this.getApplication().createContext();
+      this.logger.info('Registering existing web hook actions');
+      const items = await context.model('WebHookAction').asQueryable().take(-1).silent().getAllItems();
+      if (items.length > 0) {
+        this.logger.info(`Found ${items.length} web hook action(s). The operation will automatically register event listeners to the underlying data models.`);
+      }
+      for (const item of items) {
+        const model = context.model(item.about);
+        if (model) {
+          await new Promise((resolve, reject) => {
+            (0, _OnWebHookAction.afterSave)({ state: _data.DataObjectState.Insert, target: item, model }, (err) => {
+              if (err) {
+                return reject(err);
+              }
+              return resolve();
+            });
+          });
+        } else {
+          this.logger.warn(`Cannot register web hook action with name "${item.name || 'unknown'}" because model "${item.about}" does not exist.`);
+        }
+      }
+    } catch (err) {
+      this.logger.error('An error occurred when registering existing web hooks');
+      this.logger.error(err);
+    } finally {
+      if (context) {
+        await context.finalizeAsync();
+      }
+    }
+  }
+
+  /**
+   *
+   * @param {import('@themost/data').DataModel} model
+   * @param {*} target
+   * @param {string} filter
+   * @param {number} state
+   * @returns {Promise<boolean>}
+   */
+  async filterObjectAsync(model, target, filter, state) {
+    const parser = new _dataModelFilter.DataModelFilterParser(model);
+    const { $expand, $where } = await parser.parseAsync(filter);
+    const q = new _data.DataQueryable(model);
+    Object.assign(q.query, {
+      $where,
+      $expand
+    });
+    const { primaryKey } = model;
+    const id = target[primaryKey];
+    q.prepare();
+    if (state !== _data.DataObjectState.Delete) {
+      q.where(primaryKey).equal(id);
+    }
+    const exists = await q.count();
+    return exists > 0;
+  }
+
+  /**
+   * Emit web hook events
+   * @param {import('@themost/data').DataEventArgs} event
+   * @param {{action?: string, emit?: boolean}} extraArgs
+   */
+  emit(event, extraArgs) {
+    const context = event.model.context;
+    // get previous and current state of the entity
+    const { previous, target, state, model } = event;
+    /**
+     * @type {import('@themost/express').ExpressDataApplication|import('@themost/common').ApplicationBase}
+     */
+    const application = context.application;
+    // noinspection JSUnresolvedReference
+    /**
+     * @type {import('@themost/express').ExpressDataContext|import('@themost/data').DataContext}
+     */
+    const newContext = application.createContext();
+    const about = model.name;
+    const self = this;
+    (async function () {
+      // noinspection JSUnresolvedReference
+      const q = newContext.model('WebHook').asQueryable().where((x, about, state) => {
+        // noinspection JSBitwiseOperatorUsage
+        return x.action.about === about && x.action.state === state && x.active === true;
+      }, about, state).select((x) => {
+        return {
+          id: x.id,
+          config: x.config,
+          action: x.action,
+          about: x.action.about,
+          emit: x.emit,
+          username: x.owner.name,
+          filter: x.action.filter,
+          when: x.action.when
+        };
+      }).silent().take(25).skip(0);
+      // apply extra arguments for finding web hooks
+      const findArgs = Object.assign({ emit: true }, extraArgs || {});
+      q.prepare();
+      Object.keys(findArgs).forEach((key) => {
+        const value = findArgs[key];
+        q.query.$where ? q.and(key).equal(value) : q.where(key).equal(value);
+      });
+
+      const { viewAdapter: WebHooks } = newContext.model('WebHook');
+      const targetModel = newContext.model(about);
+      // get entity set
+      const builder = application.getService(_data.ODataModelBuilder);
+      const entitySet = builder.getEntityTypeEntitySet(targetModel.name);
+      const { primaryKey: key } = targetModel;
+      // get origin
+      const origin = context.getConfiguration().getSourceAt('settings/universis/api/origin');
+      /**
+       * @type {{total: number, skip: number, value: Array<{ id: string,config: { url: string, insecure: boolean, secret?: string, contentType: string }, emit: boolean, username: string,action: string,about: string,filter: string,when: string}>}} list
+       */
+      let list = await q.getList();
+      if (list.total > 0) {
+        while (list.total >= list.skip + list.value.length) {
+          for (const item of list.value) {
+            // set context user
+            newContext.user = {
+              name: item.username || 'anonymous'
+            };
+            try {
+              let send = true;
+              if (state === _data.DataObjectState.Insert) {
+                // validate the current state of a new object
+                const filter = item.when || item.filter;
+                send = await self.filterObjectAsync(targetModel, target, filter, state);
+              } else {
+                // validate previous state
+                send = await self.filterObjectAsync(targetModel, previous, item.when, state);
+                // validate current state
+                if (send && item.filter) {
+                  if (state === _data.DataObjectState.Delete) {
+                    send = await self.filterObjectAsync(targetModel, previous, item.filter, state);
+                  } else {
+                    send = await self.filterObjectAsync(targetModel, target, item.filter, state);
+                  }
+                }
+              }
+              if (send) {
+                self.logger.info(`Sending web hook for model "${about}" to url "${item.config.url}"`);
+                // send web hook request
+                const result = await (0, _superagent.default)('post', item.config.url).
+                set('Content-Type', item.config.contentType).
+                send({
+                  event: item.action,
+                  entityType: targetModel.name,
+                  entitySet: entitySet && entitySet.name,
+                  origin: origin,
+                  target: {
+                    id: state === _data.DataObjectState.Insert ? target[key] : previous[key]
+                  }
+                });
+                const lastResponse = {
+                  status: result.status
+                };
+                self.logger.info(`Web hook for model "${about}" to url ${item.config.url} returned status ${result.status}`);
+                // update last response with an ad-hoc query
+                await newContext.db.executeAsync(
+                  new _query.QueryExpression().update(WebHooks).set({
+                    lastResponse: JSON.stringify(lastResponse)
+                  }).where('id').equal(item.id),
+                  []);
+              } else {
+                self.logger.debug(`Web hook for model "${about}" and object with identifier ${target[key]} to url "${item.config.url}" was filtered and not sent`);
+              }
+            } catch (err) {
+              self.logger.error(`Error sending web hook for model "${about}" to url "${item.config.url}"`);
+              self.logger.error(err);
+            }
+          }
+          list = await q.take(25).skip(list.skip + list.value.length);
+        }
+      }
+    })();
+  }
+
+}exports.WebHookService = WebHookService;
+//# sourceMappingURL=WebHookService.js.map