@conduitplatform/module-tools 0.16.6 → 0.16.7

package/dist/classes/ConduitServiceModule.d.ts

@@ -2,7 +2,7 @@
 import { EventEmitter } from 'events';
 import { ServerWritableStream } from '@grpc/grpc-js';
 import { GrpcServer } from './GrpcServer.js';
-import ConduitGrpcSdk, { GrpcCallback, GrpcRequest, GrpcResponse, HealthCheckRequest, HealthCheckResponse, HealthCheckStatus, SetConfigRequest, SetConfigResponse } from '@conduitplatform/grpc-sdk';
+import { ConduitGrpcSdk, GrpcCallback, GrpcRequest, GrpcResponse, HealthCheckRequest, HealthCheckResponse, HealthCheckStatus, SetConfigRequest, SetConfigResponse } from '@conduitplatform/grpc-sdk';
 export declare abstract class ConduitServiceModule {
     protected readonly _moduleName: string;
     protected _serviceName?: string;

package/dist/index.cjs

@@ -1,10 +1,10 @@
 'use strict';
 
-var ConduitGrpcSdk = require('@conduitplatform/grpc-sdk');
+var grpcSdk = require('@conduitplatform/grpc-sdk');
 var grpcJs = require('@grpc/grpc-js');
 var protoLoader = require('@grpc/proto-loader');
 var fastJwt = require('fast-jwt');
-var lodashEs = require('lodash-es');
+var lodash = require('lodash');
 var path = require('path');
 var events = require('events');
 var node_url = require('node:url');
@@ -19,7 +19,7 @@ var abortControllerX = require('abort-controller-x');
 var niceGrpcCommon = require('nice-grpc-common');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
-class ConduitActiveSchema extends ConduitGrpcSdk.ConduitSchema {
+class ConduitActiveSchema extends grpcSdk.ConduitSchema {
     dbInstance;
     constructor(dbInstance, name, fields, modelOptions, collectionName) {
         super(name, fields ?? {}, modelOptions, collectionName);
@@ -67,10 +67,10 @@ class ConduitStringConstructor {
     // private to disallow creating other instances of this type
     constructor() { }
     static get Optional() {
-        return ConduitGrpcSdk.TYPE.String;
+        return grpcSdk.TYPE.String;
     }
     static get Required() {
-        return { type: ConduitGrpcSdk.TYPE.String, required: true };
+        return { type: grpcSdk.TYPE.String, required: true };
     }
 }
 const ConduitString = ConduitStringConstructor;
@@ -78,10 +78,10 @@ class ConduitNumberConstructor {
     // private to disallow creating other instances of this type
     constructor() { }
     static get Optional() {
-        return ConduitGrpcSdk.TYPE.Number;
+        return grpcSdk.TYPE.Number;
     }
     static get Required() {
-        return { type: ConduitGrpcSdk.TYPE.Number, required: true };
+        return { type: grpcSdk.TYPE.Number, required: true };
     }
 }
 const ConduitNumber = ConduitNumberConstructor;
@@ -89,10 +89,10 @@ class ConduitBooleanConstructor {
     // private to disallow creating other instances of this type
     constructor() { }
     static get Optional() {
-        return ConduitGrpcSdk.TYPE.Boolean;
+        return grpcSdk.TYPE.Boolean;
     }
     static get Required() {
-        return { type: ConduitGrpcSdk.TYPE.Boolean, required: true };
+        return { type: grpcSdk.TYPE.Boolean, required: true };
     }
 }
 const ConduitBoolean = ConduitBooleanConstructor;
@@ -100,10 +100,10 @@ class ConduitDateConstructor {
     // private to disallow creating other instances of this type
     constructor() { }
     static get Optional() {
-        return ConduitGrpcSdk.TYPE.Date;
+        return grpcSdk.TYPE.Date;
     }
     static get Required() {
-        return { type: ConduitGrpcSdk.TYPE.Date, required: true };
+        return { type: grpcSdk.TYPE.Date, required: true };
     }
 }
 const ConduitDate = ConduitDateConstructor;
@@ -111,10 +111,10 @@ class ConduitObjectIdConstructor {
     // private to disallow creating other instances of this type
     constructor() { }
     static get Optional() {
-        return ConduitGrpcSdk.TYPE.ObjectId;
+        return grpcSdk.TYPE.ObjectId;
     }
     static get Required() {
-        return { type: ConduitGrpcSdk.TYPE.ObjectId, required: true };
+        return { type: grpcSdk.TYPE.ObjectId, required: true };
     }
 }
 const ConduitObjectId = ConduitObjectIdConstructor;
@@ -122,10 +122,10 @@ class ConduitJSONConstructor {
     // private to disallow creating other instances of this type
     constructor() { }
     static get Optional() {
-        return ConduitGrpcSdk.TYPE.JSON;
+        return grpcSdk.TYPE.JSON;
     }
     static get Required() {
-        return { type: ConduitGrpcSdk.TYPE.JSON, required: true };
+        return { type: grpcSdk.TYPE.JSON, required: true };
     }
 }
 const ConduitJson = ConduitJSONConstructor;
@@ -133,10 +133,10 @@ class ConduitRelationConstructor {
     // private to disallow creating other instances of this type
     constructor() { }
     static Optional(model) {
-        return { type: ConduitGrpcSdk.TYPE.Relation, model, required: false };
+        return { type: grpcSdk.TYPE.Relation, model, required: false };
     }
     static Required(model) {
-        return { type: ConduitGrpcSdk.TYPE.Relation, model, required: true };
+        return { type: grpcSdk.TYPE.Relation, model, required: true };
     }
 }
 const ConduitRelation = ConduitRelationConstructor;
@@ -182,7 +182,7 @@ function wrapGrpcFunctions(functions, postponeRestart) {
     const wrappedFunctions = {};
     Object.keys(functions).forEach(name => {
         wrappedFunctions[name] = (call, callback) => {
-            ConduitGrpcSdk.Metrics?.increment('internal_grpc_requests_total');
+            grpcSdk.ConduitGrpcSdk.Metrics?.increment('internal_grpc_requests_total');
             postponeRestart();
             if (grpcKey) {
                 const verify = fastJwt.createVerifier({ key: grpcKey });
@@ -249,7 +249,7 @@ class GrpcServer {
         this._url = `0.0.0.0:${port ?? '5000'}`;
     }
     async waitForReady() {
-        while (!lodashEs.isNil(this.scheduledRestart)) {
+        while (!lodash.isNil(this.scheduledRestart)) {
             await this.wait(200);
         }
     }
@@ -258,7 +258,7 @@ class GrpcServer {
         return this._url;
     }
     async createNewServer(useForce = false) {
-        if (lodashEs.isNil(this._useForce)) {
+        if (lodash.isNil(this._useForce)) {
             this._useForce = useForce;
         }
         const serverResult = await createServer(this._url);
@@ -269,7 +269,7 @@ class GrpcServer {
     async addService(protoPath, protoDescription, functions) {
         functions = wrapGrpcFunctions(functions, this.postponeRestart.bind(this));
         if (this._serviceNames.indexOf(protoDescription) !== -1) {
-            ConduitGrpcSdk.Logger.log('Service already exists, performing replace');
+            grpcSdk.ConduitGrpcSdk.Logger.log('Service already exists, performing replace');
             this._services[this._serviceNames.indexOf(protoDescription)] = {
                 protoPath,
                 protoDescription,
@@ -282,7 +282,7 @@ class GrpcServer {
             this._services.push({ protoPath, protoDescription, functions });
             this._serviceNames.push(protoDescription);
             if (this.started) {
-                ConduitGrpcSdk.Logger.log('Server already started, scheduling refresh..');
+                grpcSdk.ConduitGrpcSdk.Logger.log('Server already started, scheduling refresh..');
                 this.scheduleRefresh();
                 return this;
             }
@@ -329,9 +329,9 @@ class GrpcServer {
         }
         const self = this;
         this.scheduledRestart = setTimeout(async () => {
-            ConduitGrpcSdk.Logger.log('Begin refresh');
+            grpcSdk.ConduitGrpcSdk.Logger.log('Begin refresh');
             await self.refresh();
-            ConduitGrpcSdk.Logger.log('Refresh complete');
+            grpcSdk.ConduitGrpcSdk.Logger.log('Refresh complete');
             clearTimeout(self.scheduledRestart);
             self.scheduledRestart = undefined;
             self._postponeRequests = 0;
@@ -339,11 +339,11 @@ class GrpcServer {
     }
     start() {
         if (this.started) {
-            ConduitGrpcSdk.Logger.error('gRPC server is already running!');
+            grpcSdk.ConduitGrpcSdk.Logger.error('gRPC server is already running!');
             return;
         }
         else if (!this.started && this.startedOnce) {
-            ConduitGrpcSdk.Logger.error('gRPC server is down for refresh!');
+            grpcSdk.ConduitGrpcSdk.Logger.error('gRPC server is down for refresh!');
         }
         this.started = true;
         this.startedOnce = true;
@@ -418,7 +418,7 @@ class RouteBuilder {
         return this;
     }
     return(name, fields) {
-        this._returns = new ConduitGrpcSdk.ConduitRouteReturnDefinition(name, fields);
+        this._returns = new grpcSdk.ConduitRouteReturnDefinition(name, fields);
         return this;
     }
     handler(fn) {
@@ -469,11 +469,11 @@ function generateLog(routerType, routerRequest, requestReceive, call, status) {
         log += `(${routerType})  Socket: ${call.request.event} socket: ${call.request.socket}`;
     }
     log += ` ${status ?? '200'} ${latency}`;
-    ConduitGrpcSdk.Logger.log(log);
-    ConduitGrpcSdk.Metrics?.set('grpc_request_latency_seconds', latency / 1000);
-    ConduitGrpcSdk.Metrics?.set(`${routerType}_grpc_request_latency_seconds`, latency / 1000);
+    grpcSdk.ConduitGrpcSdk.Logger.log(log);
+    grpcSdk.ConduitGrpcSdk.Metrics?.set('grpc_request_latency_seconds', latency / 1000);
+    grpcSdk.ConduitGrpcSdk.Metrics?.set(`${routerType}_grpc_request_latency_seconds`, latency / 1000);
     const successStatus = !status || status.toString().charAt(0) === '2';
-    ConduitGrpcSdk.Metrics?.increment(`${routerType}_grpc_response_statuses_total`, 1, {
+    grpcSdk.ConduitGrpcSdk.Metrics?.increment(`${routerType}_grpc_response_statuses_total`, 1, {
         success: successStatus ? 'true' : 'false',
     });
 }
@@ -534,7 +534,7 @@ function wrapRouterGrpcFunction(fun, routerType) {
     return (call, callback) => {
         const requestReceive = Date.now();
         let routerRequest = true;
-        ConduitGrpcSdk.Metrics?.increment(`${routerType}_grpc_requests_total`);
+        grpcSdk.ConduitGrpcSdk.Metrics?.increment(`${routerType}_grpc_requests_total`);
         try {
             call.request.context = parseRequestData(call.request.context);
             call.request.params = parseRequestData(call.request.params);
@@ -548,9 +548,9 @@ function wrapRouterGrpcFunction(fun, routerType) {
             }
         }
         catch (e) {
-            ConduitGrpcSdk.Metrics?.increment(`${routerType}_grpc_errors_total`);
+            grpcSdk.ConduitGrpcSdk.Metrics?.increment(`${routerType}_grpc_errors_total`);
             generateLog(routerType, routerRequest, requestReceive, call, grpcJs.status.INTERNAL);
-            ConduitGrpcSdk.Logger.error(e.message ?? 'Something went wrong');
+            grpcSdk.ConduitGrpcSdk.Logger.error(e.message ?? 'Something went wrong');
             return callback({
                 code: grpcJs.status.INTERNAL,
                 message: e.message ?? 'Something went wrong',
@@ -562,9 +562,9 @@ function wrapRouterGrpcFunction(fun, routerType) {
         })
             .then(r => parseResponseData(r, routerRequest, requestReceive, call, callback, responded, routerType))
             .catch(error => {
-            ConduitGrpcSdk.Metrics?.increment(`${routerType}_grpc_errors_total`);
+            grpcSdk.ConduitGrpcSdk.Metrics?.increment(`${routerType}_grpc_errors_total`);
             generateLog(routerType, routerRequest, requestReceive, call, error.code ?? grpcJs.status.INTERNAL);
-            ConduitGrpcSdk.Logger.error(error.message ?? 'Something went wrong');
+            grpcSdk.ConduitGrpcSdk.Logger.error(error.message ?? 'Something went wrong');
             callback({
                 code: error.code ?? grpcJs.status.INTERNAL,
                 message: error.details ?? error.message ?? 'Something went wrong',
@@ -668,24 +668,24 @@ class RoutingManager {
     constructor(_router, _server) {
         this._router = _router;
         this._server = _server;
-        if (_router instanceof ConduitGrpcSdk.Admin) {
+        if (_router instanceof grpcSdk.Admin) {
             this.isAdmin = true;
         }
     }
     get(path) {
-        return new RouteBuilder(this).method(ConduitGrpcSdk.ConduitRouteActions.GET).path(path);
+        return new RouteBuilder(this).method(grpcSdk.ConduitRouteActions.GET).path(path);
     }
     post(path) {
-        return new RouteBuilder(this).method(ConduitGrpcSdk.ConduitRouteActions.POST).path(path);
+        return new RouteBuilder(this).method(grpcSdk.ConduitRouteActions.POST).path(path);
     }
     delete(path) {
-        return new RouteBuilder(this).method(ConduitGrpcSdk.ConduitRouteActions.DELETE).path(path);
+        return new RouteBuilder(this).method(grpcSdk.ConduitRouteActions.DELETE).path(path);
     }
     update(path) {
-        return new RouteBuilder(this).method(ConduitGrpcSdk.ConduitRouteActions.UPDATE).path(path);
+        return new RouteBuilder(this).method(grpcSdk.ConduitRouteActions.UPDATE).path(path);
     }
     patch(path) {
-        return new RouteBuilder(this).method(ConduitGrpcSdk.ConduitRouteActions.PATCH).path(path);
+        return new RouteBuilder(this).method(grpcSdk.ConduitRouteActions.PATCH).path(path);
     }
     proxy() {
         return new ProxyRouteBuilder(this);
@@ -803,9 +803,9 @@ class ConduitServiceModule {
     _address; // external address:port of service (LoadBalancer)
     grpcServer;
     events = new events.EventEmitter();
-    _serviceHealthState = ConduitGrpcSdk.HealthCheckStatus.SERVING; // default for health-agnostic modules
+    _serviceHealthState = grpcSdk.HealthCheckStatus.SERVING; // default for health-agnostic modules
     constructor(moduleName) {
-        this._moduleName = lodashEs.camelCase(moduleName);
+        this._moduleName = lodash.camelCase(moduleName);
     }
     _registered = false;
     set registered(registered) {
@@ -830,12 +830,12 @@ class ConduitServiceModule {
         return this._serviceHealthState;
     }
     updateHealth(state, init = false) {
-        if ((state === ConduitGrpcSdk.HealthCheckStatus.UNKNOWN && !init) ||
-            state === ConduitGrpcSdk.HealthCheckStatus.SERVICE_UNKNOWN) {
-            throw new Error(`Cannot explicitly set gRPC health state to ${ConduitGrpcSdk.HealthCheckStatus[state]}`);
+        if ((state === grpcSdk.HealthCheckStatus.UNKNOWN && !init) ||
+            state === grpcSdk.HealthCheckStatus.SERVICE_UNKNOWN) {
+            throw new Error(`Cannot explicitly set gRPC health state to ${grpcSdk.HealthCheckStatus[state]}`);
         }
         if (!init) {
-            ConduitGrpcSdk.Metrics?.set('module_health_state', state === ConduitGrpcSdk.HealthCheckStatus.SERVING ? 1 : 0);
+            grpcSdk.ConduitGrpcSdk.Metrics?.set('module_health_state', state === grpcSdk.HealthCheckStatus.SERVING ? 1 : 0);
         }
         if (init) {
             this._serviceHealthState = state;
@@ -854,13 +854,13 @@ class ConduitServiceModule {
         const service = call.request.service.substring(call.request.service.indexOf('.') + 1);
         if (service && service !== this._serviceName) {
             callback(null, {
-                status: ConduitGrpcSdk.HealthCheckStatus.SERVICE_UNKNOWN,
+                status: grpcSdk.HealthCheckStatus.SERVICE_UNKNOWN,
             });
         }
         else {
             if (!this._registered) {
                 return callback(null, {
-                    status: ConduitGrpcSdk.HealthCheckResponse_ServingStatus.UNKNOWN,
+                    status: grpcSdk.HealthCheckResponse_ServingStatus.UNKNOWN,
                 });
             }
             callback(null, {
@@ -872,7 +872,7 @@ class ConduitServiceModule {
         const service = call.request.service.substring(call.request.service.indexOf('.') + 1);
         if (service && service !== this._serviceName) {
             call.write({
-                status: ConduitGrpcSdk.HealthCheckStatus.SERVICE_UNKNOWN,
+                status: grpcSdk.HealthCheckStatus.SERVICE_UNKNOWN,
             });
         }
         else {
@@ -946,7 +946,7 @@ const createFormat = (logMeta = true) => {
             return `[${info.timestamp}] [${info.level.toUpperCase()}]: ${info.message} ${info.stack}`;
         }
         if (logMeta) {
-            return `[${info.timestamp}] [${info.level.toUpperCase()}]: ${info.message} ${!lodashEs.isEmpty(info.meta) ? processMeta(info.meta) : ''}`;
+            return `[${info.timestamp}] [${info.level.toUpperCase()}]: ${info.message} ${!lodash.isEmpty(info.meta) ? processMeta(info.meta) : ''}`;
         }
         else {
             return `[${info.timestamp}] [${info.level.toUpperCase()}]: ${info.message}`;
@@ -1026,7 +1026,7 @@ async function setupLoki(module, instance) {
         const onTry = async () => {
             return await lokiReadyCheck(lokiUrl)
                 .then(() => {
-                ConduitGrpcSdk.Logger.addTransport(new LokiTransport({
+                grpcSdk.ConduitGrpcSdk.Logger.addTransport(new LokiTransport({
                     level: 'debug',
                     host: lokiUrl,
                     batching: false,
@@ -1044,7 +1044,7 @@ async function setupLoki(module, instance) {
                 .catch(() => true); // retry
         };
         const onFailure = () => {
-            ConduitGrpcSdk.Logger.error(`Failed to connect to Loki on '${lokiUrl}'`);
+            grpcSdk.ConduitGrpcSdk.Logger.error(`Failed to connect to Loki on '${lokiUrl}'`);
         };
         await linearBackoffTimeoutAsync(onTry, 250, 15, onFailure, true);
     }
@@ -1064,7 +1064,7 @@ class MetricsServer {
         const port = this.getHttpPort();
         const url = '0.0.0.0:' + port.toString();
         server.listen(port, () => {
-            ConduitGrpcSdk.Logger.info(`Metrics server listening on: ${url}`);
+            grpcSdk.ConduitGrpcSdk.Logger.info(`Metrics server listening on: ${url}`);
         });
         server.get('/', (req, res) => {
             return res
@@ -1080,12 +1080,12 @@ class MetricsServer {
     getHttpPort() {
         const value = process.env['METRICS_PORT'];
         if (!value) {
-            ConduitGrpcSdk.Logger.error(`Metrics HTTP port not set`);
+            grpcSdk.ConduitGrpcSdk.Logger.error(`Metrics HTTP port not set`);
             process.exit(-1);
         }
         const port = parseInt(value, 10);
-        if (lodashEs.isNaN(port) || port < 1 || port > 65535) {
-            ConduitGrpcSdk.Logger.error(`Invalid HTTP port value: ${port}`);
+        if (lodash.isNaN(port) || port < 1 || port > 65535) {
+            grpcSdk.ConduitGrpcSdk.Logger.error(`Invalid HTTP port value: ${port}`);
             process.exit(-1);
         }
         return port;
@@ -1094,70 +1094,70 @@ class MetricsServer {
 
 var defaultMetrics = {
     internalGrpcRequests: {
-        type: ConduitGrpcSdk.MetricType.Counter,
+        type: grpcSdk.MetricType.Counter,
         config: {
             name: 'internal_grpc_requests_total',
             help: "Tracks the total number of Conduit's internal gRPC requests",
         },
     },
     clientGrpcRequests: {
-        type: ConduitGrpcSdk.MetricType.Counter,
+        type: grpcSdk.MetricType.Counter,
         config: {
             name: 'client_grpc_requests_total',
             help: 'Tracks the total number of the client gRPC requests',
         },
     },
     adminGrpcRequests: {
-        type: ConduitGrpcSdk.MetricType.Counter,
+        type: grpcSdk.MetricType.Counter,
         config: {
             name: 'admin_grpc_requests_total',
             help: 'Tracks the total number of the admin gRPC requests',
         },
     },
     clientGrpcErrors: {
-        type: ConduitGrpcSdk.MetricType.Counter,
+        type: grpcSdk.MetricType.Counter,
         config: {
             name: 'client_grpc_errors_total',
             help: 'Tracks the total number of client grpc errors',
         },
     },
     adminGrpcErrors: {
-        type: ConduitGrpcSdk.MetricType.Counter,
+        type: grpcSdk.MetricType.Counter,
         config: {
             name: 'admin_grpc_errors_total',
             help: 'Tracks the total number of admin grpc errors',
         },
     },
     moduleHealthState: {
-        type: ConduitGrpcSdk.MetricType.Gauge,
+        type: grpcSdk.MetricType.Gauge,
         config: {
             name: 'module_health_state',
             help: 'Tracks the health state of the module',
         },
     },
     grpcRequestLatency: {
-        type: ConduitGrpcSdk.MetricType.Gauge,
+        type: grpcSdk.MetricType.Gauge,
         config: {
             name: 'grpc_request_latency_seconds',
             help: 'Tracks the latency of grpc requests in seconds',
         },
     },
     adminGrpcRequestLatency: {
-        type: ConduitGrpcSdk.MetricType.Gauge,
+        type: grpcSdk.MetricType.Gauge,
         config: {
             name: 'admin_grpc_request_latency_seconds',
             help: 'Tracks the latency of admin grpc requests in seconds',
         },
     },
     clientGrpcRequestLatency: {
-        type: ConduitGrpcSdk.MetricType.Gauge,
+        type: grpcSdk.MetricType.Gauge,
         config: {
             name: 'client_grpc_request_latency_seconds',
             help: 'Tracks the latency of client grpc requests in seconds',
         },
     },
     grpcResponseStatuses: {
-        type: ConduitGrpcSdk.MetricType.Counter,
+        type: grpcSdk.MetricType.Counter,
         config: {
             name: 'grpc_response_statuses_total',
             help: 'Tracks the total number of grpc response codes',
@@ -1165,7 +1165,7 @@ var defaultMetrics = {
         },
     },
     adminGrpcResponseStatuses: {
-        type: ConduitGrpcSdk.MetricType.Counter,
+        type: grpcSdk.MetricType.Counter,
         config: {
             name: 'admin_grpc_response_statuses_total',
             help: 'Tracks the total number of admin grpc response codes',
@@ -1173,7 +1173,7 @@ var defaultMetrics = {
         },
     },
     clientGrpcResponseStatuses: {
-        type: ConduitGrpcSdk.MetricType.Counter,
+        type: grpcSdk.MetricType.Counter,
         config: {
             name: 'client_grpc_response_statuses_total',
             help: 'Tracks the total number  of client grpc response codes',
@@ -1210,16 +1210,16 @@ class ConduitMetrics {
         const metricConfig = JSON.parse(JSON.stringify(config));
         metricConfig.name = this.addPrefix(config.name);
         switch (type) {
-            case ConduitGrpcSdk.MetricType.Counter:
+            case grpcSdk.MetricType.Counter:
                 this.createCounter(metricConfig);
                 break;
-            case ConduitGrpcSdk.MetricType.Gauge:
+            case grpcSdk.MetricType.Gauge:
                 this.createGauge(metricConfig);
                 break;
-            case ConduitGrpcSdk.MetricType.Histogram:
+            case grpcSdk.MetricType.Histogram:
                 this.createHistogram(metricConfig);
                 break;
-            case ConduitGrpcSdk.MetricType.Summary:
+            case grpcSdk.MetricType.Summary:
                 this.createSummary(metricConfig);
                 break;
         }
@@ -1410,7 +1410,7 @@ function clientMiddleware() {
 
 const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
 const __dirname$1 = path.dirname(__filename$1);
-const initializeSdk = (coreUrl, moduleName, watchModules = true, serviceHealthStatusGetter = () => ConduitGrpcSdk.HealthCheckStatus.SERVING) => {
+const initializeSdk = (coreUrl, moduleName, watchModules = true, serviceHealthStatusGetter = () => grpcSdk.HealthCheckStatus.SERVING) => {
     let logger;
     try {
         logger = new ConduitLogger([
@@ -1427,13 +1427,13 @@ const initializeSdk = (coreUrl, moduleName, watchModules = true, serviceHealthSt
     catch (e) {
         logger = new ConduitLogger();
     }
-    const grpcSdk = new ConduitGrpcSdk(coreUrl, moduleName, watchModules, logger, serviceHealthStatusGetter);
-    setupLoki(grpcSdk.name, grpcSdk.instance).then();
+    const grpcSdk$1 = new grpcSdk.ConduitGrpcSdk(coreUrl, moduleName, watchModules, logger, serviceHealthStatusGetter);
+    setupLoki(grpcSdk$1.name, grpcSdk$1.instance).then();
     if (process.env.METRICS_PORT) {
-        ConduitGrpcSdk.Metrics = new ConduitMetrics(grpcSdk.name, grpcSdk.instance);
-        grpcSdk.addMiddleware(clientMiddleware());
+        grpcSdk.ConduitGrpcSdk.Metrics = new ConduitMetrics(grpcSdk$1.name, grpcSdk$1.instance);
+        grpcSdk$1.addMiddleware(clientMiddleware());
     }
-    return grpcSdk;
+    return grpcSdk$1;
 };
 
 /**
@@ -1499,7 +1499,7 @@ function merge(objA, objB) {
             return srcValue;
         }
     };
-    return lodashEs.mergeWith({}, objA, objB, customizer);
+    return lodash.mergeWith({}, objA, objB, customizer);
 }
 
 const convictConfigParser = (config) => {
@@ -1574,13 +1574,13 @@ class ManagedModule extends ConduitServiceModule {
             await this.grpcSdk.config.registerModule(this.name, this.address, this.healthState);
         }
         catch (err) {
-            ConduitGrpcSdk.Logger.error('Failed to initialize server');
-            ConduitGrpcSdk.Logger.error(err);
+            grpcSdk.ConduitGrpcSdk.Logger.error('Failed to initialize server');
+            grpcSdk.ConduitGrpcSdk.Logger.error(err);
             process.exit(-1);
         }
         await this.postRegisterLifecycle().catch((err) => {
-            ConduitGrpcSdk.Logger.error('Failed to activate module');
-            ConduitGrpcSdk.Logger.error(err);
+            grpcSdk.ConduitGrpcSdk.Logger.error('Failed to activate module');
+            grpcSdk.ConduitGrpcSdk.Logger.error(err);
             process.exit(-1);
         });
     }
@@ -1642,11 +1642,11 @@ class ManagedModule extends ConduitServiceModule {
      * Registers common and module-specific metric types.
      */
     async registerMetrics() {
-        if (ConduitGrpcSdk.Metrics) {
-            ConduitGrpcSdk.Metrics.initializeDefaultMetrics();
+        if (grpcSdk.ConduitGrpcSdk.Metrics) {
+            grpcSdk.ConduitGrpcSdk.Metrics.initializeDefaultMetrics();
             if (this.metricsSchema) {
                 Object.values(this.metricsSchema).forEach(metric => {
-                    ConduitGrpcSdk.Metrics.registerMetric(metric.type, metric.config);
+                    grpcSdk.ConduitGrpcSdk.Metrics.registerMetric(metric.type, metric.config);
                 });
             }
         }
@@ -1670,7 +1670,7 @@ class ManagedModule extends ConduitServiceModule {
         await this.addHealthCheckService();
         await this.addModuleService();
         await this.grpcServer.start();
-        ConduitGrpcSdk.Logger.log('gRPC server listening on ' + this._port);
+        grpcSdk.ConduitGrpcSdk.Logger.log('gRPC server listening on ' + this._port);
     }
     async setConfig(call, callback) {
         try {
@@ -1701,7 +1701,7 @@ class ManagedModule extends ConduitServiceModule {
             }
             ConfigController.getInstance().config = config;
             await this.onConfig();
-            this.grpcSdk.bus?.publish(lodashEs.kebabCase(this.name) + ':config:update', JSON.stringify(config));
+            this.grpcSdk.bus?.publish(lodash.kebabCase(this.name) + ':config:update', JSON.stringify(config));
         }
         catch (e) {
             return callback({ code: grpcJs.status.INTERNAL, message: e.message });
@@ -1711,7 +1711,7 @@ class ManagedModule extends ConduitServiceModule {
     async handleConfigSyncUpdate() {
         if (!this.config)
             return;
-        this.grpcSdk.bus.subscribe(`${lodashEs.kebabCase(this.name)}:config:update`, async (message) => {
+        this.grpcSdk.bus.subscribe(`${lodash.kebabCase(this.name)}:config:update`, async (message) => {
             ConfigController.getInstance().config = await this.preConfig(JSON.parse(message));
             await this.onConfig();
         });