node-server-engine 1.0.5

package/dist/entities/Sequelize/Sequelize.d.ts

@@ -0,0 +1,14 @@
+import { Sequelize, ModelCtor } from 'sequelize-typescript';
+import { Sequelize as SequelizeInterface } from './Sequelize.types';
+export declare let sequelizeClient: undefined | Sequelize;
+/**
+ * We use a proxy to extend the Sequelize behavior and allow initialization of the client only when needed while keeping the same interface
+ */
+export declare const sequelize: SequelizeInterface;
+/** On init create client and connect */
+export declare function init(): void;
+/** On shutdown close connection and clear client */
+export declare function shutdown(): Promise<void>;
+export declare function addModels(models: Array<ModelCtor>): void;
+/** Create Sequelize client */
+export declare function createSequelizeClient(): Sequelize;

package/dist/entities/Sequelize/Sequelize.js

@@ -0,0 +1,70 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addModels = addModels;
+exports.createSequelizeClient = createSequelizeClient;
+exports.init = init;
+exports.sequelizeClient = exports.sequelize = void 0;
+exports.shutdown = shutdown;
+var _sequelizeTypescript = require("sequelize-typescript");
+var _Sequelize = _interopRequireDefault(require("./Sequelize.config"));
+var _Sequelize2 = require("./Sequelize.validate");
+var _EngineError = require("../EngineError");
+var _LifecycleController = require("../LifecycleController");
+let sequelizeClient = exports.sequelizeClient = void 0;
+
+/**
+ * We use a proxy to extend the Sequelize behavior and allow initialization of the client only when needed while keeping the same interface
+ */
+const sequelize = exports.sequelize = new Proxy(
+// Due to how we do the proxying, we are forced to ignore ts-errors, we could never create an object that respects the interface properly
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+{}, {
+  get: function (target, property) {
+    if (property === 'init') return init;
+    if (property === 'shutdown') return shutdown;
+    if (property === 'addModels') return addModels;
+    // Create the sequelize client if it does not exist
+    if (!sequelizeClient) throw new _EngineError.EngineError({
+      message: 'Sequelize client was not initialized'
+    });
+    // Call the function on the sequelize client
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    return sequelizeClient[property];
+  }
+});
+
+/** On init create client and connect */
+function init() {
+  // Ignore if already initialized
+  if (sequelizeClient) return;
+  exports.sequelizeClient = sequelizeClient = createSequelizeClient();
+  sequelizeClient.authenticate().then(() => console.log('Connected to MySQL database.')).catch(err => console.error('Unable to connect to the database:', err));
+  _LifecycleController.LifecycleController.register(sequelize);
+}
+
+/** On shutdown close connection and clear client */
+async function shutdown() {
+  if (sequelizeClient) await sequelizeClient.close();
+  exports.sequelizeClient = sequelizeClient = undefined;
+}
+function addModels(models) {
+  if (!sequelizeClient) throw new _EngineError.EngineError({
+    message: 'Sequelize client was not initialized'
+  });
+  sequelizeClient.addModels(models);
+  sequelizeClient.sync();
+}
+
+/** Create Sequelize client */
+function createSequelizeClient() {
+  // Throw an error if there is no host initial
+  (0, _Sequelize2.validateSequelizeEnvironment)();
+  return new _sequelizeTypescript.Sequelize(process.env.SQL_DB, process.env.SQL_USER, process.env.SQL_PASSWORD, _Sequelize.default);
+}
+//# sourceMappingURL=Sequelize.js.map

package/dist/entities/Sequelize/Sequelize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sequelize.js","names":["_sequelizeTypescript","require","_Sequelize","_interopRequireDefault","_Sequelize2","_EngineError","_LifecycleController","sequelizeClient","exports","sequelize","Proxy","get","target","property","init","shutdown","addModels","EngineError","message","createSequelizeClient","authenticate","then","console","log","catch","err","error","LifecycleController","register","close","undefined","models","sync","validateSequelizeEnvironment","Sequelize","process","env","SQL_DB","SQL_USER","SQL_PASSWORD","dbConfig"],"sources":["../../../src/entities/Sequelize/Sequelize.ts"],"sourcesContent":["import { Sequelize, ModelCtor } from 'sequelize-typescript';\nimport dbConfig from './Sequelize.config';\nimport { Sequelize as SequelizeInterface } from './Sequelize.types';\nimport { validateSequelizeEnvironment } from './Sequelize.validate';\nimport { EngineError } from 'entities/EngineError';\nimport { LifecycleController } from 'entities/LifecycleController';\n\nexport let sequelizeClient: undefined | Sequelize;\n\n/**\n * We use a proxy to extend the Sequelize behavior and allow initialization of the client only when needed while keeping the same interface\n */\nexport const sequelize = new Proxy<SequelizeInterface>(\n  // Due to how we do the proxying, we are forced to ignore ts-errors, we could never create an object that respects the interface properly\n  // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n  // @ts-ignore\n  {},\n  {\n    get: function (target, property): unknown {\n      if (property === 'init') return init;\n      if (property === 'shutdown') return shutdown;\n      if (property === 'addModels') return addModels;\n      // Create the sequelize client if it does not exist\n      if (!sequelizeClient)\n        throw new EngineError({\n          message: 'Sequelize client was not initialized'\n        });\n      // Call the function on the sequelize client\n      // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n      // @ts-ignore\n      return sequelizeClient[property] as unknown;\n    }\n  }\n);\n\n/** On init create client and connect */\nexport function init(): void {\n  // Ignore if already initialized\n  if (sequelizeClient) return;\n  sequelizeClient = createSequelizeClient();\n  sequelizeClient\n    .authenticate()\n    .then(() => console.log('Connected to MySQL database.'))\n    .catch((err: Error) =>\n      console.error('Unable to connect to the database:', err)\n    );\n  LifecycleController.register(sequelize);\n}\n\n/** On shutdown close connection and clear client */\nexport async function shutdown(): Promise<void> {\n  if (sequelizeClient) await sequelizeClient.close();\n  sequelizeClient = undefined;\n}\n\nexport function addModels(models: Array<ModelCtor>): void {\n  if (!sequelizeClient)\n    throw new EngineError({\n      message: 'Sequelize client was not initialized'\n    });\n  sequelizeClient.addModels(models);\n  sequelizeClient.sync();\n}\n\n/** Create Sequelize client */\nexport function createSequelizeClient(): Sequelize {\n  // Throw an error if there is no host initial\n  validateSequelizeEnvironment();\n  return new Sequelize(\n    process.env.SQL_DB as string,\n    process.env.SQL_USER as string,\n    process.env.SQL_PASSWORD as string,\n    dbConfig\n  );\n}\n"],"mappings":";;;;;;;;;;;AAAA,IAAAA,oBAAA,GAAAC,OAAA;AACA,IAAAC,UAAA,GAAAC,sBAAA,CAAAF,OAAA;AAEA,IAAAG,WAAA,GAAAH,OAAA;AACA,IAAAI,YAAA,GAAAJ,OAAA;AACA,IAAAK,oBAAA,GAAAL,OAAA;AAEO,IAAIM,eAAsC,GAAAC,OAAA,CAAAD,eAAA;;AAEjD;AACA;AACA;AACO,MAAME,SAAS,GAAAD,OAAA,CAAAC,SAAA,GAAG,IAAIC,KAAK;AAChC;AACA;AACA;AACA,CAAC,CAAC,EACF;EACEC,GAAG,EAAE,SAAAA,CAAUC,MAAM,EAAEC,QAAQ,EAAW;IACxC,IAAIA,QAAQ,KAAK,MAAM,EAAE,OAAOC,IAAI;IACpC,IAAID,QAAQ,KAAK,UAAU,EAAE,OAAOE,QAAQ;IAC5C,IAAIF,QAAQ,KAAK,WAAW,EAAE,OAAOG,SAAS;IAC9C;IACA,IAAI,CAACT,eAAe,EAClB,MAAM,IAAIU,wBAAW,CAAC;MACpBC,OAAO,EAAE;IACX,CAAC,CAAC;IACJ;IACA;IACA;IACA,OAAOX,eAAe,CAACM,QAAQ,CAAC;EAClC;AACF,CACF,CAAC;;AAED;AACO,SAASC,IAAIA,CAAA,EAAS;EAC3B;EACA,IAAIP,eAAe,EAAE;EACrBC,OAAA,CAAAD,eAAA,GAAAA,eAAe,GAAGY,qBAAqB,CAAC,CAAC;EACzCZ,eAAe,CACZa,YAAY,CAAC,CAAC,CACdC,IAAI,CAAC,MAAMC,OAAO,CAACC,GAAG,CAAC,8BAA8B,CAAC,CAAC,CACvDC,KAAK,CAAEC,GAAU,IAChBH,OAAO,CAACI,KAAK,CAAC,oCAAoC,EAAED,GAAG,CACzD,CAAC;EACHE,wCAAmB,CAACC,QAAQ,CAACnB,SAAS,CAAC;AACzC;;AAEA;AACO,eAAeM,QAAQA,CAAA,EAAkB;EAC9C,IAAIR,eAAe,EAAE,MAAMA,eAAe,CAACsB,KAAK,CAAC,CAAC;EAClDrB,OAAA,CAAAD,eAAA,GAAAA,eAAe,GAAGuB,SAAS;AAC7B;AAEO,SAASd,SAASA,CAACe,MAAwB,EAAQ;EACxD,IAAI,CAACxB,eAAe,EAClB,MAAM,IAAIU,wBAAW,CAAC;IACpBC,OAAO,EAAE;EACX,CAAC,CAAC;EACJX,eAAe,CAACS,SAAS,CAACe,MAAM,CAAC;EACjCxB,eAAe,CAACyB,IAAI,CAAC,CAAC;AACxB;;AAEA;AACO,SAASb,qBAAqBA,CAAA,EAAc;EACjD;EACA,IAAAc,wCAA4B,EAAC,CAAC;EAC9B,OAAO,IAAIC,8BAAS,CAClBC,OAAO,CAACC,GAAG,CAACC,MAAM,EAClBF,OAAO,CAACC,GAAG,CAACE,QAAQ,EACpBH,OAAO,CAACC,GAAG,CAACG,YAAY,EACxBC,kBACF,CAAC;AACH","ignoreList":[]}

package/dist/entities/Sequelize/Sequelize.types.d.ts

@@ -0,0 +1,9 @@
+import { Sequelize as SequelizeClass, ModelCtor } from 'sequelize-typescript';
+export type Sequelize = SequelizeClass & {
+    /** Start the sequelize service */
+    init: () => void;
+    /** Stop the sequelize service */
+    shutdown: () => Promise<void>;
+    /** Register a model with sequelize */
+    addModels: (models: Array<ModelCtor>) => void;
+};

package/dist/entities/Sequelize/Sequelize.types.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=Sequelize.types.js.map

package/dist/entities/Sequelize/Sequelize.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sequelize.types.js","names":[],"sources":["../../../src/entities/Sequelize/Sequelize.types.ts"],"sourcesContent":["import { Sequelize as SequelizeClass, ModelCtor } from 'sequelize-typescript';\n\nexport type Sequelize = SequelizeClass & {\n  /** Start the sequelize service */\n  init: () => void;\n  /** Stop the sequelize service */\n  shutdown: () => Promise<void>;\n  /** Register a model with sequelize */\n  addModels: (models: Array<ModelCtor>) => void;\n};\n"],"mappings":"","ignoreList":[]}

package/dist/entities/Sequelize/Sequelize.validate.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Verify that the environment variables to connect to a SQL server are properly set
+ */
+export declare function validateSequelizeEnvironment(): void;

package/dist/entities/Sequelize/Sequelize.validate.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateSequelizeEnvironment = validateSequelizeEnvironment;
+var _checkEnvironment = require("../../utils/checkEnvironment");
+var _envAssert = require("../../utils/envAssert");
+/**
+ * Verify that the environment variables to connect to a SQL server are properly set
+ */
+function validateSequelizeEnvironment() {
+  // We only check if there is at least the host specified
+  if (process.env.SQL_HOST) (0, _checkEnvironment.assertEnvironment)({
+    SQL_HOST: _envAssert.envAssert.isHost()
+  });
+  if (process.env.SQL_PASSWORD) (0, _checkEnvironment.assertEnvironment)({
+    SQL_PASSWORD: _envAssert.envAssert.isString()
+  });
+  if (process.env.SQL_DB) (0, _checkEnvironment.assertEnvironment)({
+    SQL_DB: _envAssert.envAssert.isString()
+  });
+  if (process.env.SQL_USER) (0, _checkEnvironment.assertEnvironment)({
+    SQL_USER: _envAssert.envAssert.isString()
+  });
+}
+//# sourceMappingURL=Sequelize.validate.js.map

package/dist/entities/Sequelize/Sequelize.validate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sequelize.validate.js","names":["_checkEnvironment","require","_envAssert","validateSequelizeEnvironment","process","env","SQL_HOST","assertEnvironment","envAssert","isHost","SQL_PASSWORD","isString","SQL_DB","SQL_USER"],"sources":["../../../src/entities/Sequelize/Sequelize.validate.ts"],"sourcesContent":["import { assertEnvironment } from 'utils/checkEnvironment';\nimport { envAssert } from 'utils/envAssert';\n\n/**\n * Verify that the environment variables to connect to a SQL server are properly set\n */\nexport function validateSequelizeEnvironment(): void {\n  // We only check if there is at least the host specified\n  if (process.env.SQL_HOST) assertEnvironment({ SQL_HOST: envAssert.isHost() });\n  if (process.env.SQL_PASSWORD)\n    assertEnvironment({ SQL_PASSWORD: envAssert.isString() });\n  if (process.env.SQL_DB) assertEnvironment({ SQL_DB: envAssert.isString() });\n  if (process.env.SQL_USER)\n    assertEnvironment({ SQL_USER: envAssert.isString() });\n}\n"],"mappings":";;;;;;AAAA,IAAAA,iBAAA,GAAAC,OAAA;AACA,IAAAC,UAAA,GAAAD,OAAA;AAEA;AACA;AACA;AACO,SAASE,4BAA4BA,CAAA,EAAS;EACnD;EACA,IAAIC,OAAO,CAACC,GAAG,CAACC,QAAQ,EAAE,IAAAC,mCAAiB,EAAC;IAAED,QAAQ,EAAEE,oBAAS,CAACC,MAAM,CAAC;EAAE,CAAC,CAAC;EAC7E,IAAIL,OAAO,CAACC,GAAG,CAACK,YAAY,EAC1B,IAAAH,mCAAiB,EAAC;IAAEG,YAAY,EAAEF,oBAAS,CAACG,QAAQ,CAAC;EAAE,CAAC,CAAC;EAC3D,IAAIP,OAAO,CAACC,GAAG,CAACO,MAAM,EAAE,IAAAL,mCAAiB,EAAC;IAAEK,MAAM,EAAEJ,oBAAS,CAACG,QAAQ,CAAC;EAAE,CAAC,CAAC;EAC3E,IAAIP,OAAO,CAACC,GAAG,CAACQ,QAAQ,EACtB,IAAAN,mCAAiB,EAAC;IAAEM,QAAQ,EAAEL,oBAAS,CAACG,QAAQ,CAAC;EAAE,CAAC,CAAC;AACzD","ignoreList":[]}

package/dist/entities/Sequelize/index.d.ts

@@ -0,0 +1,2 @@
+export { sequelize } from './Sequelize';
+export * from './Sequelize.types';

package/dist/entities/Sequelize/index.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  sequelize: true
+};
+Object.defineProperty(exports, "sequelize", {
+  enumerable: true,
+  get: function () {
+    return _Sequelize.sequelize;
+  }
+});
+var _Sequelize = require("./Sequelize");
+var _Sequelize2 = require("./Sequelize.types");
+Object.keys(_Sequelize2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _Sequelize2[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Sequelize2[key];
+    }
+  });
+});
+//# sourceMappingURL=index.js.map

package/dist/entities/Sequelize/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_Sequelize","require","_Sequelize2","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get"],"sources":["../../../src/entities/Sequelize/index.ts"],"sourcesContent":["export { sequelize } from './Sequelize';\nexport * from './Sequelize.types';\n"],"mappings":";;;;;;;;;;;;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AACA,IAAAC,WAAA,GAAAD,OAAA;AAAAE,MAAA,CAAAC,IAAA,CAAAF,WAAA,EAAAG,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAJ,WAAA,CAAAI,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAZ,WAAA,CAAAI,GAAA;IAAA;EAAA;AAAA","ignoreList":[]}

package/dist/entities/Server/Server.const.d.ts

@@ -0,0 +1,5 @@
+import { ErrorRequestHandler, RequestHandler } from 'express';
+export declare const defaultMiddleware: Array<RequestHandler>;
+export declare const defaultErrorMiddleware: Array<RequestHandler | ErrorRequestHandler>;
+export declare const secondaryMiddleware: Array<RequestHandler>;
+export declare const shutdownSignals: string[];

package/dist/entities/Server/Server.const.js

@@ -0,0 +1,45 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.shutdownSignals = exports.secondaryMiddleware = exports.defaultMiddleware = exports.defaultErrorMiddleware = void 0;
+var _express = require("express");
+var _morgan = _interopRequireDefault(require("morgan"));
+var _middleware = require("../../middleware");
+const ACCESS_LOG = JSON.stringify({
+  method: ':method',
+  status: ':status',
+  url: ':url',
+  'http-version': ':http-version',
+  ip: ':remote-addr',
+  'user-agent': ':user-agent',
+  'content-length': ':res[content-length]',
+  referrer: ':referrer',
+  'response-time': ':response-time',
+  severity: 'DEBUG',
+  message: ':method :url [:status]'
+});
+
+// Default middleware that are applied first thing on the primary port, before the business logic endpoints
+const defaultMiddleware = exports.defaultMiddleware = [(0, _middleware.healthCheck)(), (0, _express.json)({
+  limit: process.env.REQUEST_SIZE_LIMIT ?? '1mb'
+}), (0, _express.urlencoded)({
+  extended: true,
+  limit: process.env.REQUEST_SIZE_LIMIT ?? '1mb'
+}), (0, _middleware.metrics)(), (0, _middleware.version)()].filter(val => val);
+
+// Error handling middleware that are run after the main business logic endpoints
+const defaultErrorMiddleware = exports.defaultErrorMiddleware = [_middleware.error, _middleware.fourOhFour];
+
+// Middleware that are served on the secondary port
+const secondaryMiddleware = exports.secondaryMiddleware = [(0, _middleware.metrics)(), (0, _middleware.version)(), (0, _middleware.swaggerDocs)()];
+
+// Add morgan logging to default middleware chain when reporting is not silenced
+if (!process.env.SILENCE_REPORT) {
+  defaultMiddleware.unshift((0, _morgan.default)(ACCESS_LOG));
+  secondaryMiddleware.unshift((0, _morgan.default)(ACCESS_LOG));
+}
+const shutdownSignals = exports.shutdownSignals = ['SIGTERM', 'SIGUSR2', 'SIGINT'];
+//# sourceMappingURL=Server.const.js.map

package/dist/entities/Server/Server.const.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Server.const.js","names":["_express","require","_morgan","_interopRequireDefault","_middleware","ACCESS_LOG","JSON","stringify","method","status","url","ip","referrer","severity","message","defaultMiddleware","exports","healthCheck","json","limit","process","env","REQUEST_SIZE_LIMIT","urlencoded","extended","metrics","version","filter","val","defaultErrorMiddleware","error","fourOhFour","secondaryMiddleware","swaggerDocs","SILENCE_REPORT","unshift","morgan","shutdownSignals"],"sources":["../../../src/entities/Server/Server.const.ts"],"sourcesContent":["import { json, urlencoded, ErrorRequestHandler, RequestHandler } from 'express';\nimport morgan from 'morgan';\nimport {\n  metrics,\n  error,\n  fourOhFour,\n  healthCheck,\n  version,\n  swaggerDocs\n} from 'middleware';\n\nconst ACCESS_LOG = JSON.stringify({\n  method: ':method',\n  status: ':status',\n  url: ':url',\n  'http-version': ':http-version',\n  ip: ':remote-addr',\n  'user-agent': ':user-agent',\n  'content-length': ':res[content-length]',\n  referrer: ':referrer',\n  'response-time': ':response-time',\n  severity: 'DEBUG',\n  message: ':method :url [:status]'\n});\n\n// Default middleware that are applied first thing on the primary port, before the business logic endpoints\nexport const defaultMiddleware: Array<RequestHandler> = [\n  healthCheck(),\n  json({ limit: process.env.REQUEST_SIZE_LIMIT ?? '1mb' }),\n  urlencoded({\n    extended: true,\n    limit: process.env.REQUEST_SIZE_LIMIT ?? '1mb'\n  }),\n  metrics(),\n  version()\n].filter((val) => val);\n\n// Error handling middleware that are run after the main business logic endpoints\nexport const defaultErrorMiddleware: Array<\n  RequestHandler | ErrorRequestHandler\n> = [error, fourOhFour];\n\n// Middleware that are served on the secondary port\nexport const secondaryMiddleware: Array<RequestHandler> = [\n  metrics(),\n  version(),\n  swaggerDocs()\n];\n\n// Add morgan logging to default middleware chain when reporting is not silenced\nif (!process.env.SILENCE_REPORT) {\n  defaultMiddleware.unshift(morgan(ACCESS_LOG));\n  secondaryMiddleware.unshift(morgan(ACCESS_LOG));\n}\n\nexport const shutdownSignals = ['SIGTERM', 'SIGUSR2', 'SIGINT'];\n"],"mappings":";;;;;;;AAAA,IAAAA,QAAA,GAAAC,OAAA;AACA,IAAAC,OAAA,GAAAC,sBAAA,CAAAF,OAAA;AACA,IAAAG,WAAA,GAAAH,OAAA;AASA,MAAMI,UAAU,GAAGC,IAAI,CAACC,SAAS,CAAC;EAChCC,MAAM,EAAE,SAAS;EACjBC,MAAM,EAAE,SAAS;EACjBC,GAAG,EAAE,MAAM;EACX,cAAc,EAAE,eAAe;EAC/BC,EAAE,EAAE,cAAc;EAClB,YAAY,EAAE,aAAa;EAC3B,gBAAgB,EAAE,sBAAsB;EACxCC,QAAQ,EAAE,WAAW;EACrB,eAAe,EAAE,gBAAgB;EACjCC,QAAQ,EAAE,OAAO;EACjBC,OAAO,EAAE;AACX,CAAC,CAAC;;AAEF;AACO,MAAMC,iBAAwC,GAAAC,OAAA,CAAAD,iBAAA,GAAG,CACtD,IAAAE,uBAAW,EAAC,CAAC,EACb,IAAAC,aAAI,EAAC;EAAEC,KAAK,EAAEC,OAAO,CAACC,GAAG,CAACC,kBAAkB,IAAI;AAAM,CAAC,CAAC,EACxD,IAAAC,mBAAU,EAAC;EACTC,QAAQ,EAAE,IAAI;EACdL,KAAK,EAAEC,OAAO,CAACC,GAAG,CAACC,kBAAkB,IAAI;AAC3C,CAAC,CAAC,EACF,IAAAG,mBAAO,EAAC,CAAC,EACT,IAAAC,mBAAO,EAAC,CAAC,CACV,CAACC,MAAM,CAAEC,GAAG,IAAKA,GAAG,CAAC;;AAEtB;AACO,MAAMC,sBAEZ,GAAAb,OAAA,CAAAa,sBAAA,GAAG,CAACC,iBAAK,EAAEC,sBAAU,CAAC;;AAEvB;AACO,MAAMC,mBAA0C,GAAAhB,OAAA,CAAAgB,mBAAA,GAAG,CACxD,IAAAP,mBAAO,EAAC,CAAC,EACT,IAAAC,mBAAO,EAAC,CAAC,EACT,IAAAO,uBAAW,EAAC,CAAC,CACd;;AAED;AACA,IAAI,CAACb,OAAO,CAACC,GAAG,CAACa,cAAc,EAAE;EAC/BnB,iBAAiB,CAACoB,OAAO,CAAC,IAAAC,eAAM,EAAC/B,UAAU,CAAC,CAAC;EAC7C2B,mBAAmB,CAACG,OAAO,CAAC,IAAAC,eAAM,EAAC/B,UAAU,CAAC,CAAC;AACjD;AAEO,MAAMgC,eAAe,GAAArB,OAAA,CAAAqB,eAAA,GAAG,CAAC,SAAS,EAAE,SAAS,EAAE,QAAQ,CAAC","ignoreList":[]}

package/dist/entities/Server/Server.d.ts

@@ -0,0 +1,61 @@
+import { Application } from 'express';
+import { ServerOptions } from './Server.types';
+/** Main server class */
+export declare class Server {
+    /** The express application powering the main endpoints */
+    private app;
+    /** The node HTTP(S) server, serving the main express application */
+    private httpServer;
+    /** The express application powering the support endpoints */
+    private secondaryApp;
+    /** The node HTTP(S) server, serving the secondary express application */
+    private secondaryHttpServer;
+    /** List of endpoint instances that the server should handle */
+    private endpoints;
+    /** Mapping of env variable name with functions that should run to check their validity */
+    private checkEnvironment;
+    /** Middleware that should run on every request before the endpoint specific logic */
+    private globalMiddleware;
+    /** Error middleware that should run on every request after the endpoint specific logic, but before the generic global middleware */
+    private errorMiddleware;
+    /** Functions that should be called on server startup */
+    private initCallbacks;
+    /** Functions that should be called on server shutdown */
+    private shutdownCallbacks;
+    /** When set to true, this indicates that init callbacks should run synchronously in the order they are declared. By default they all run in parallel */
+    private syncCallbacks;
+    /** Config to set regularly running jobs on the server */
+    private cron?;
+    /** Global auth related configuration */
+    private auth;
+    /** WebSocket server instance, if configured */
+    private wss?;
+    /** Abort controller that handles signals for the server */
+    private abortController;
+    /** Create a server */
+    constructor(config: ServerOptions);
+    /** Start the server */
+    init(): Promise<void>;
+    /** Graceful shutdown */
+    shutdown(): Promise<void>;
+    /** Get the express app instance of the server */
+    getApp(): Application;
+    /** Get the express app instance of the server */
+    getSecondaryApp(): Application;
+    /** Registers all the middleware with the express app */
+    private registerMiddleware;
+    /** Add a handler for WebSocket connections */
+    private attachWebSocket;
+    /** Call shutdown if signal gets sent to the process */
+    private handleSignal;
+    /** Watch the TLS certificate change event */
+    private watchTlsCaFileChange;
+    /** Executes a recurring job */
+    private runCronJob;
+    /** Run a shutdown/init callback */
+    private runCallback;
+    /**
+     * Validate the Server constructor configuration
+     */
+    private validate;
+}