@conduitplatform/module-tools 0.16.4 → 0.16.6

package/dist/index.esm.js

@@ -0,0 +1,1749 @@
+import ConduitGrpcSdk, { ConduitSchema, TYPE, ConduitRouteReturnDefinition, Admin, ConduitRouteActions, HealthCheckStatus, HealthCheckResponse_ServingStatus, MetricType } from '@conduitplatform/grpc-sdk';
+import { Server, ServerCredentials, loadPackageDefinition, status } from '@grpc/grpc-js';
+import protoLoader from '@grpc/proto-loader';
+import { createVerifier } from 'fast-jwt';
+import { isNil, camelCase, isEmpty, isNaN, mergeWith, kebabCase } from 'lodash-es';
+import path from 'path';
+import { EventEmitter } from 'events';
+import { fileURLToPath } from 'node:url';
+import convict from 'convict';
+import winston, { format } from 'winston';
+import { get } from 'http';
+import LokiTransport from 'winston-loki';
+import { clearTimeout as clearTimeout$1 } from 'timers';
+import { Registry, collectDefaultMetrics, Counter, Summary, Histogram, Gauge, exponentialBuckets } from 'prom-client';
+import express from 'express';
+import { isAbortError } from 'abort-controller-x';
+import { Status, ClientError } from 'nice-grpc-common';
+
+class ConduitActiveSchema extends ConduitSchema {
+    dbInstance;
+    constructor(dbInstance, name, fields, modelOptions, collectionName) {
+        super(name, fields ?? {}, modelOptions, collectionName);
+        this.dbInstance = dbInstance;
+    }
+    findOne(query, select, populate, userId, scope) {
+        return this.dbInstance.findOne(this.name, query, select, populate, userId, scope);
+    }
+    findMany(query, select, skip, limit, sort, populate, userId, scope) {
+        return this.dbInstance.findMany(this.name, query, select, skip, limit, sort, populate, userId, scope);
+    }
+    create(query, userId, scope) {
+        return this.dbInstance.create(this.name, query, userId, scope);
+    }
+    createMany(query, userId, scope) {
+        return this.dbInstance.createMany(this.name, query, userId, scope);
+    }
+    findByIdAndUpdate(id, document, populate, userId, scope) {
+        return this.dbInstance.findByIdAndUpdate(this.name, id, document, populate, userId, scope);
+    }
+    findByIdAndReplace(id, document, populate, userId, scope) {
+        return this.dbInstance.findByIdAndReplace(this.name, id, document, populate, userId, scope);
+    }
+    replaceOne(filterQuery, query, populate, userId, scope) {
+        return this.dbInstance.replaceOne(this.name, filterQuery, query, populate, userId, scope);
+    }
+    updateOne(filterQuery, query, populate, userId, scope) {
+        return this.dbInstance.updateOne(this.name, filterQuery, query, populate, userId, scope);
+    }
+    updateMany(filterQuery, query, populate, userId, scope) {
+        return this.dbInstance.updateMany(this.name, filterQuery, query, populate, userId, scope);
+    }
+    deleteOne(query, userId, scope) {
+        return this.dbInstance.deleteOne(this.name, query, userId, scope);
+    }
+    deleteMany(query, userId, scope) {
+        return this.dbInstance.deleteMany(this.name, query, userId, scope);
+    }
+    countDocuments(query, userId, scope) {
+        return this.dbInstance.countDocuments(this.name, query, userId, scope);
+    }
+}
+
+class ConduitStringConstructor {
+    // private to disallow creating other instances of this type
+    constructor() { }
+    static get Optional() {
+        return TYPE.String;
+    }
+    static get Required() {
+        return { type: TYPE.String, required: true };
+    }
+}
+const ConduitString = ConduitStringConstructor;
+class ConduitNumberConstructor {
+    // private to disallow creating other instances of this type
+    constructor() { }
+    static get Optional() {
+        return TYPE.Number;
+    }
+    static get Required() {
+        return { type: TYPE.Number, required: true };
+    }
+}
+const ConduitNumber = ConduitNumberConstructor;
+class ConduitBooleanConstructor {
+    // private to disallow creating other instances of this type
+    constructor() { }
+    static get Optional() {
+        return TYPE.Boolean;
+    }
+    static get Required() {
+        return { type: TYPE.Boolean, required: true };
+    }
+}
+const ConduitBoolean = ConduitBooleanConstructor;
+class ConduitDateConstructor {
+    // private to disallow creating other instances of this type
+    constructor() { }
+    static get Optional() {
+        return TYPE.Date;
+    }
+    static get Required() {
+        return { type: TYPE.Date, required: true };
+    }
+}
+const ConduitDate = ConduitDateConstructor;
+class ConduitObjectIdConstructor {
+    // private to disallow creating other instances of this type
+    constructor() { }
+    static get Optional() {
+        return TYPE.ObjectId;
+    }
+    static get Required() {
+        return { type: TYPE.ObjectId, required: true };
+    }
+}
+const ConduitObjectId = ConduitObjectIdConstructor;
+class ConduitJSONConstructor {
+    // private to disallow creating other instances of this type
+    constructor() { }
+    static get Optional() {
+        return TYPE.JSON;
+    }
+    static get Required() {
+        return { type: TYPE.JSON, required: true };
+    }
+}
+const ConduitJson = ConduitJSONConstructor;
+class ConduitRelationConstructor {
+    // private to disallow creating other instances of this type
+    constructor() { }
+    static Optional(model) {
+        return { type: TYPE.Relation, model, required: false };
+    }
+    static Required(model) {
+        return { type: TYPE.Relation, model, required: true };
+    }
+}
+const ConduitRelation = ConduitRelationConstructor;
+
+function createServer(port) {
+    const grpcServer = new Server({
+        'grpc.max_receive_message_length': 1024 * 1024 * 100,
+        'grpc.max_send_message_length': 1024 * 1024 * 100,
+    });
+    return new Promise((resolve, reject) => {
+        grpcServer.bindAsync(port, ServerCredentials.createInsecure(), (err, port) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve({
+                    server: grpcServer,
+                    port,
+                });
+            }
+        });
+    });
+}
+function addServiceToServer(server, protoPath, descriptorObject, functions) {
+    const packageDefinition = protoLoader.loadSync(protoPath, {
+        keepCase: true,
+        longs: String,
+        enums: String,
+        defaults: true,
+        oneofs: true,
+    });
+    const protoDescriptor = loadPackageDefinition(packageDefinition);
+    const objs = descriptorObject.split('.');
+    let descObj = protoDescriptor;
+    objs.forEach((r) => {
+        descObj = descObj[r];
+    });
+    server.addService(descObj.service, functions);
+}
+
+function wrapGrpcFunctions(functions, postponeRestart) {
+    const grpcKey = process.env.GRPC_KEY;
+    const wrappedFunctions = {};
+    Object.keys(functions).forEach(name => {
+        wrappedFunctions[name] = (call, callback) => {
+            ConduitGrpcSdk.Metrics?.increment('internal_grpc_requests_total');
+            postponeRestart();
+            if (grpcKey) {
+                const verify = createVerifier({ key: grpcKey });
+                const grpcToken = call.metadata.get('grpc-token')[0];
+                if (!grpcToken) {
+                    return throwError(callback, 'No gRPC protection token provided', status.PERMISSION_DENIED);
+                }
+                try {
+                    const jwt = verify(grpcToken);
+                    call.metadata.set('module-name', jwt.moduleName);
+                }
+                catch {
+                    return throwError(callback, 'Failed to verify gRPC protection token. GRPC_KEY value differs', status.PERMISSION_DENIED);
+                }
+            }
+            let invoked;
+            try {
+                invoked = functions[name](call, callback);
+            }
+            catch (error) {
+                return throwError(callback, error.message);
+            }
+            if (typeof invoked?.then === 'function') {
+                invoked.then().catch((error) => {
+                    return throwError(callback, error.message);
+                });
+            }
+        };
+    });
+    return wrappedFunctions;
+}
+function throwError(callback, message, code = status.INTERNAL) {
+    // Aborting server streams is not yet implemented!
+    if (callback) {
+        callback({ code, message });
+    }
+}
+
+function createParsedRouterRequest(params, urlParams, queryParams, bodyParams, path, headers, context, cookies) {
+    return {
+        request: {
+            params,
+            urlParams: urlParams ?? {},
+            queryParams: queryParams ?? {},
+            bodyParams: bodyParams ?? {},
+            path: path ?? '',
+            headers: headers,
+            context: context ?? {},
+            cookies: cookies ?? {},
+        },
+    };
+}
+
+class GrpcServer {
+    grpcServer;
+    started = false;
+    startedOnce = false;
+    _serviceNames = [];
+    scheduledRestart;
+    _postponeRequests = 0;
+    _useForce;
+    _services = [];
+    constructor(port) {
+        this._url = `0.0.0.0:${port ?? '5000'}`;
+    }
+    async waitForReady() {
+        while (!isNil(this.scheduledRestart)) {
+            await this.wait(200);
+        }
+    }
+    _url;
+    get url() {
+        return this._url;
+    }
+    async createNewServer(useForce = false) {
+        if (isNil(this._useForce)) {
+            this._useForce = useForce;
+        }
+        const serverResult = await createServer(this._url);
+        this.grpcServer = serverResult.server;
+        this._url = this._url.split(':')[0] + ':' + serverResult.port.toString();
+        return serverResult.port;
+    }
+    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');
+            this._services[this._serviceNames.indexOf(protoDescription)] = {
+                protoPath,
+                protoDescription,
+                functions,
+            };
+            this.scheduleRefresh();
+            return this;
+        }
+        else {
+            this._services.push({ protoPath, protoDescription, functions });
+            this._serviceNames.push(protoDescription);
+            if (this.started) {
+                ConduitGrpcSdk.Logger.log('Server already started, scheduling refresh..');
+                this.scheduleRefresh();
+                return this;
+            }
+            else {
+                if (!this.grpcServer) {
+                    await this.wait(1000);
+                }
+                addServiceToServer(this.grpcServer, protoPath, protoDescription, functions);
+                return this;
+            }
+        }
+    }
+    async wait(time) {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                clearTimeout(timeout);
+                resolve();
+            }, time);
+        });
+    }
+    async refresh() {
+        if (this.started) {
+            this.started = false;
+            if (this._useForce) {
+                this.grpcServer.forceShutdown();
+            }
+            else {
+                //gracefully shutdown so that there are no service disruption
+                await new Promise(resolve => this.grpcServer.tryShutdown(() => resolve()));
+            }
+        }
+        await this.createNewServer();
+        this._services.forEach(service => {
+            addServiceToServer(this.grpcServer, service.protoPath, service.protoDescription, service.functions);
+        });
+        if (!this.started && this.startedOnce) {
+            this.grpcServer.start();
+            this.started = true;
+        }
+    }
+    scheduleRefresh() {
+        if (this.scheduledRestart) {
+            clearTimeout(this.scheduledRestart);
+        }
+        const self = this;
+        this.scheduledRestart = setTimeout(async () => {
+            ConduitGrpcSdk.Logger.log('Begin refresh');
+            await self.refresh();
+            ConduitGrpcSdk.Logger.log('Refresh complete');
+            clearTimeout(self.scheduledRestart);
+            self.scheduledRestart = undefined;
+            self._postponeRequests = 0;
+        }, 2000);
+    }
+    start() {
+        if (this.started) {
+            ConduitGrpcSdk.Logger.error('gRPC server is already running!');
+            return;
+        }
+        else if (!this.started && this.startedOnce) {
+            ConduitGrpcSdk.Logger.error('gRPC server is down for refresh!');
+        }
+        this.started = true;
+        this.startedOnce = true;
+        this.grpcServer?.start();
+    }
+    postponeRestart() {
+        if (!this.scheduledRestart || this._postponeRequests > 5)
+            return;
+        this._postponeRequests++;
+        this.scheduleRefresh();
+    }
+}
+
+class RouteBuilder {
+    manager;
+    _options;
+    _returns;
+    _handler;
+    constructor(manager) {
+        this.manager = manager;
+        this._options = {};
+    }
+    method(action) {
+        this._options.action = action;
+        return this;
+    }
+    name(name) {
+        this._options.name = name;
+        return this;
+    }
+    description(description) {
+        this._options.description = description;
+        return this;
+    }
+    cacheControl(cache) {
+        this._options.cacheControl = cache;
+        return this;
+    }
+    middleware(middleware, allowDuplicates = false) {
+        if (!Array.isArray(middleware)) {
+            middleware = [middleware];
+        }
+        if (this._options.middlewares !== undefined &&
+            this._options.middlewares?.length !== 0) {
+            if (allowDuplicates) {
+                this._options.middlewares = this._options.middlewares?.concat(middleware);
+            }
+            else {
+                // add to existing middlewares and filter out potential duplicates
+                this._options.middlewares = this._options.middlewares?.concat(middleware.filter(mid => this._options.middlewares?.indexOf(mid) === -1));
+            }
+        }
+        else {
+            this._options.middlewares = middleware;
+        }
+        return this;
+    }
+    path(path) {
+        this._options.path = path;
+        return this;
+    }
+    queryParams(params) {
+        this._options.queryParams = params;
+        return this;
+    }
+    urlParams(params) {
+        this._options.urlParams = params;
+        return this;
+    }
+    bodyParams(params) {
+        this._options.bodyParams = params;
+        return this;
+    }
+    return(name, fields) {
+        this._returns = new ConduitRouteReturnDefinition(name, fields);
+        return this;
+    }
+    handler(fn) {
+        this._handler = fn;
+        return this;
+    }
+    add() {
+        if (!this.manager)
+            throw new Error('Builder not setup with manager');
+        if (!this._options)
+            throw new Error('Cannot build route without options');
+        if (!this._options.action)
+            throw new Error('Cannot build route without action');
+        if (!this._options.path)
+            throw new Error('Cannot build route without action');
+        if (!this._returns)
+            throw new Error('Cannot build route without return');
+        if (!this._handler)
+            throw new Error('Cannot build route without handler');
+        this.manager.route(this._options, this._returns, this._handler);
+    }
+    build() {
+        if (!this._options)
+            throw new Error('Cannot build route without options');
+        if (!this._options.action)
+            throw new Error('Cannot build route without action');
+        if (!this._options.path)
+            throw new Error('Cannot build route without action');
+        if (!this._returns)
+            throw new Error('Cannot build route without return');
+        if (!this._handler)
+            throw new Error('Cannot build route without handler');
+        return {
+            input: this._options,
+            returnType: this._returns,
+            handler: this._handler,
+        };
+    }
+}
+
+function generateLog(routerType, routerRequest, requestReceive, call, status) {
+    let log = '';
+    const latency = Date.now() - requestReceive;
+    if (routerRequest) {
+        log += `(${routerType}) Request: ${call.request.path}`;
+    }
+    else {
+        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);
+    const successStatus = !status || status.toString().charAt(0) === '2';
+    ConduitGrpcSdk.Metrics?.increment(`${routerType}_grpc_response_statuses_total`, 1, {
+        success: successStatus ? 'true' : 'false',
+    });
+}
+function parseRequestData(data) {
+    if (data && data.length !== 0) {
+        return JSON.parse(data);
+    }
+    else {
+        return {};
+    }
+}
+function parseResponseData(r, routerRequest, requestReceive, call, callback, responded, routerType) {
+    if (responded.did)
+        return;
+    responded.did = true;
+    if (!r) {
+        callback({
+            code: status.INTERNAL,
+            message: 'Handler did not return a response',
+        });
+    }
+    if (routerRequest) {
+        if (typeof r === 'string') {
+            callback(null, { result: r });
+        }
+        else {
+            let respObject;
+            if (r.removeCookies || r.setCookies) {
+                respObject = {
+                    removeCookies: r.removeCookies,
+                    setCookies: r.setCookies,
+                };
+            }
+            if (r.result || r.redirect) {
+                callback(null, {
+                    ...respObject,
+                    redirect: r.redirect ?? undefined,
+                    result: r.result
+                        ? typeof r.result === 'string'
+                            ? r.result
+                            : JSON.stringify(r.result)
+                        : undefined,
+                });
+            }
+            else {
+                callback(null, { ...respObject, result: JSON.stringify(r) });
+            }
+        }
+    }
+    else {
+        if (r.hasOwnProperty('data'))
+            r.data = JSON.stringify(r.data);
+        callback(null, r);
+    }
+    generateLog(routerType, routerRequest, requestReceive, call, undefined);
+}
+function wrapRouterGrpcFunction(fun, routerType) {
+    return (call, callback) => {
+        const requestReceive = Date.now();
+        let routerRequest = true;
+        ConduitGrpcSdk.Metrics?.increment(`${routerType}_grpc_requests_total`);
+        try {
+            call.request.context = parseRequestData(call.request.context);
+            call.request.params = parseRequestData(call.request.params);
+            call.request.cookies = parseRequestData(call.request.cookies);
+            call.request.urlParams = parseRequestData(call.request.urlParams);
+            call.request.queryParams = parseRequestData(call.request.queryParams);
+            call.request.bodyParams = parseRequestData(call.request.bodyParams);
+            routerRequest = !call.request.hasOwnProperty('event');
+            if (routerRequest) {
+                call.request.headers = parseRequestData(call.request.headers);
+            }
+        }
+        catch (e) {
+            ConduitGrpcSdk.Metrics?.increment(`${routerType}_grpc_errors_total`);
+            generateLog(routerType, routerRequest, requestReceive, call, status.INTERNAL);
+            ConduitGrpcSdk.Logger.error(e.message ?? 'Something went wrong');
+            return callback({
+                code: status.INTERNAL,
+                message: e.message ?? 'Something went wrong',
+            });
+        }
+        const responded = { did: false };
+        fun(call, r => {
+            parseResponseData(r, routerRequest, requestReceive, call, callback, responded, routerType);
+        })
+            .then(r => parseResponseData(r, routerRequest, requestReceive, call, callback, responded, routerType))
+            .catch(error => {
+            ConduitGrpcSdk.Metrics?.increment(`${routerType}_grpc_errors_total`);
+            generateLog(routerType, routerRequest, requestReceive, call, error.code ?? status.INTERNAL);
+            ConduitGrpcSdk.Logger.error(error.message ?? 'Something went wrong');
+            callback({
+                code: error.code ?? status.INTERNAL,
+                message: error.details ?? error.message ?? 'Something went wrong',
+            });
+        });
+    };
+}
+
+function wrapFunctionsAsync(functions, routerType) {
+    const modifiedFunctions = {};
+    Object.keys(functions).forEach(key => {
+        modifiedFunctions[key] = wrapRouterGrpcFunction(functions[key], routerType);
+    });
+    return modifiedFunctions;
+}
+
+class ProxyRouteBuilder {
+    manager;
+    _options = { path: '' };
+    _proxy = { target: '' };
+    constructor(manager) {
+        this.manager = manager;
+    }
+    method(action) {
+        this._options.action = action;
+        return this;
+    }
+    path(path) {
+        this._options.path = path;
+        return this;
+    }
+    target(target) {
+        this._proxy.target = target;
+        return this;
+    }
+    options(options) {
+        this._options = options;
+        return this;
+    }
+    proxy(proxy) {
+        this._proxy = proxy;
+        return this;
+    }
+    middleware(middleware, allowDuplicates = false) {
+        if (!Array.isArray(middleware)) {
+            middleware = [middleware];
+        }
+        if (this._options.middlewares) {
+            if (allowDuplicates) {
+                this._options.middlewares = this._options.middlewares.concat(middleware);
+            }
+            else {
+                this._options.middlewares = this._options.middlewares.concat(middleware.filter(mid => this._options.middlewares?.indexOf(mid) === -1));
+            }
+        }
+        else {
+            this._options.middlewares = middleware;
+        }
+        return this;
+    }
+    add() {
+        if (!this.manager)
+            throw new Error('Builder not setup with manager');
+        if (!this._options.path)
+            throw new Error('Cannot build route without path');
+        if (!this._proxy.target)
+            throw new Error('Cannot build route without target');
+        const input = {
+            options: this._options,
+            proxy: this._proxy,
+        };
+        this.manager.proxyRoute(input);
+    }
+    build() {
+        if (!this.manager)
+            throw new Error('Builder not setup with manager');
+        if (!this._options.path)
+            throw new Error('Cannot build route without path');
+        if (!this._proxy.target)
+            throw new Error('Cannot build route without target');
+        if (!this._options.action)
+            throw new Error('Cannot build route without action');
+        return {
+            input: {
+                options: this._options,
+                proxy: this._proxy,
+            },
+        };
+    }
+}
+
+class RoutingManager {
+    _router;
+    _server;
+    _moduleRoutes = {};
+    _moduleProxyRoutes = {};
+    static ClientController;
+    static AdminController;
+    _routeHandlers = {};
+    isAdmin = false;
+    constructor(_router, _server) {
+        this._router = _router;
+        this._server = _server;
+        if (_router instanceof Admin) {
+            this.isAdmin = true;
+        }
+    }
+    get(path) {
+        return new RouteBuilder(this).method(ConduitRouteActions.GET).path(path);
+    }
+    post(path) {
+        return new RouteBuilder(this).method(ConduitRouteActions.POST).path(path);
+    }
+    delete(path) {
+        return new RouteBuilder(this).method(ConduitRouteActions.DELETE).path(path);
+    }
+    update(path) {
+        return new RouteBuilder(this).method(ConduitRouteActions.UPDATE).path(path);
+    }
+    patch(path) {
+        return new RouteBuilder(this).method(ConduitRouteActions.PATCH).path(path);
+    }
+    proxy() {
+        return new ProxyRouteBuilder(this);
+    }
+    clear() {
+        this._moduleRoutes = {};
+        this._routeHandlers = {};
+        this._moduleProxyRoutes = {};
+    }
+    middleware(input, handler) {
+        const routeObject = this.parseRouteObject({
+            options: input,
+            grpcFunction: input.name,
+        });
+        this._moduleRoutes[routeObject.grpcFunction] = routeObject;
+        this._routeHandlers[routeObject.grpcFunction] = handler;
+    }
+    route(input, type, handler) {
+        const routeObject = this.parseRouteObject({
+            options: input,
+            returns: {
+                name: type.name,
+                fields: JSON.stringify(type.fields),
+            },
+            grpcFunction: this.generateGrpcName(input),
+        });
+        this._moduleRoutes[routeObject.grpcFunction] = routeObject;
+        this._routeHandlers[routeObject.grpcFunction] = handler;
+    }
+    proxyRoute(input) {
+        const routeObject = this.parseRouteObject({
+            options: input,
+        });
+        this._moduleProxyRoutes[routeObject.options.path + routeObject.proxy.target] =
+            routeObject;
+    }
+    socket(input, events) {
+        const eventsObj = {};
+        const routeObject = this.parseRouteObject({
+            options: input,
+            events: '',
+        });
+        let primary;
+        Object.keys(events).forEach((eventName) => {
+            if (!primary)
+                primary = eventName;
+            const event = events[eventName];
+            eventsObj[eventName] = {
+                grpcFunction: eventName,
+                params: JSON.stringify(event.params),
+                returns: {
+                    name: event.returnType?.name ?? '',
+                    fields: JSON.stringify(event.returnType?.fields),
+                },
+            };
+            this._routeHandlers[eventName] = event.handler;
+        });
+        routeObject.events = JSON.stringify(eventsObj);
+        this._moduleRoutes[primary] = routeObject;
+    }
+    async registerRoutes() {
+        if (Object.keys(this._routeHandlers).length === 0)
+            return;
+        const modifiedFunctions = wrapFunctionsAsync(this._routeHandlers, this.isAdmin ? 'admin' : 'client');
+        if (this.isAdmin) {
+            RoutingManager.AdminController.setRoutes(modifiedFunctions);
+        }
+        else {
+            RoutingManager.ClientController.setRoutes(modifiedFunctions);
+        }
+        const paths = Object.values(this._moduleRoutes);
+        return this._router.register(paths);
+    }
+    generateGrpcName(options) {
+        if (options.name) {
+            return options.name.charAt(0).toUpperCase() + options.name.slice(1);
+        }
+        else {
+            const name = options.action.charAt(0) +
+                options.action.slice(1).toLowerCase() +
+                this.extractNameFromPath(options.path);
+            return name.charAt(0).toUpperCase() + name.slice(1);
+        }
+    }
+    extractNameFromPath(path) {
+        path = path.replace(/[-:]/g, '/');
+        return path
+            .split('/')
+            .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+            .join('');
+    }
+    parseRouteObject(routeObject) {
+        if (!routeObject.options.middlewares) {
+            routeObject.options.middlewares = [];
+        }
+        for (const option in routeObject.options) {
+            if (!routeObject.options.hasOwnProperty(option))
+                continue;
+            if (option === 'middlewares')
+                continue;
+            if (typeof routeObject.options[option] === 'string' ||
+                routeObject.options[option] instanceof String)
+                continue;
+            routeObject.options[option] = JSON.stringify(routeObject.options[option]);
+        }
+        return routeObject;
+    }
+}
+
+const __filename$1 = fileURLToPath(import.meta.url);
+const __dirname$1 = path.dirname(__filename$1);
+class ConduitServiceModule {
+    _moduleName;
+    _serviceName;
+    _address; // external address:port of service (LoadBalancer)
+    grpcServer;
+    events = new EventEmitter();
+    _serviceHealthState = HealthCheckStatus.SERVING; // default for health-agnostic modules
+    constructor(moduleName) {
+        this._moduleName = camelCase(moduleName);
+    }
+    _registered = false;
+    set registered(registered) {
+        this._registered = registered;
+    }
+    _port; // port to bring up gRPC service
+    get port() {
+        return this._port;
+    }
+    _grpcSdk;
+    get grpcSdk() {
+        if (!this._grpcSdk)
+            throw new Error('grpcSdk not defined yet');
+        return this._grpcSdk;
+    }
+    set grpcSdk(grpcSdk) {
+        if (this._grpcSdk)
+            throw new Error('grpcSdk already defined');
+        this._grpcSdk = grpcSdk;
+    }
+    get healthState() {
+        return this._serviceHealthState;
+    }
+    updateHealth(state, init = false) {
+        if ((state === HealthCheckStatus.UNKNOWN && !init) ||
+            state === HealthCheckStatus.SERVICE_UNKNOWN) {
+            throw new Error(`Cannot explicitly set gRPC health state to ${HealthCheckStatus[state]}`);
+        }
+        if (!init) {
+            ConduitGrpcSdk.Metrics?.set('module_health_state', state === HealthCheckStatus.SERVING ? 1 : 0);
+        }
+        if (init) {
+            this._serviceHealthState = state;
+            return;
+        }
+        if (this._serviceHealthState !== state) {
+            this._serviceHealthState = state;
+            // do not emit health updates until registered
+            if (this._registered) {
+                this.events.emit(`grpc-health-change:${this._serviceName}`, state);
+                this._grpcSdk?.config.moduleHealthProbe(this._moduleName, this._address);
+            }
+        }
+    }
+    healthCheck(call, callback) {
+        const service = call.request.service.substring(call.request.service.indexOf('.') + 1);
+        if (service && service !== this._serviceName) {
+            callback(null, {
+                status: HealthCheckStatus.SERVICE_UNKNOWN,
+            });
+        }
+        else {
+            if (!this._registered) {
+                return callback(null, {
+                    status: HealthCheckResponse_ServingStatus.UNKNOWN,
+                });
+            }
+            callback(null, {
+                status: this._serviceHealthState,
+            });
+        }
+    }
+    healthWatch(call) {
+        const service = call.request.service.substring(call.request.service.indexOf('.') + 1);
+        if (service && service !== this._serviceName) {
+            call.write({
+                status: HealthCheckStatus.SERVICE_UNKNOWN,
+            });
+        }
+        else {
+            this.events.on(`grpc-health-change:${this._serviceName}`, (status) => {
+                call.write({
+                    status: status,
+                });
+            });
+        }
+    }
+    async addHealthCheckService() {
+        await this.grpcServer.addService(path.resolve(__dirname$1, './grpc_health_check.proto'), 'grpc.health.v1.Health', {
+            Check: this.healthCheck.bind(this),
+            Watch: this.healthWatch.bind(this),
+        });
+    }
+    async addModuleService() {
+        await this.grpcServer.addService(path.resolve(__dirname$1, './module.proto'), 'conduit.module.v1.ConduitModule', {
+            SetConfig: this.setConfig.bind(this),
+        });
+        await this.grpcServer.addService(path.resolve(__dirname$1, './module.proto'), 'conduit.module.v1.ClientRouter', {
+            Route: RoutingManager.ClientController.handleRequest.bind(RoutingManager.ClientController),
+            SocketRoute: RoutingManager.ClientController.handleRequest.bind(RoutingManager.ClientController),
+        });
+        await this.grpcServer.addService(path.resolve(__dirname$1, './module.proto'), 'conduit.module.v1.AdminRouter', {
+            Route: RoutingManager.AdminController.handleRequest.bind(RoutingManager.AdminController),
+            SocketRoute: RoutingManager.AdminController.handleRequest.bind(RoutingManager.AdminController),
+        });
+    }
+}
+
+class ConfigController {
+    static instance;
+    _config;
+    get config() {
+        // return copy of config and not the original object;
+        return Object.assign({}, this._config);
+    }
+    set config(config) {
+        this._config = config;
+    }
+    static getInstance() {
+        if (!ConfigController.instance) {
+            ConfigController.instance = new ConfigController();
+        }
+        return ConfigController.instance;
+    }
+}
+
+var ModuleLifecycleStage;
+(function (ModuleLifecycleStage) {
+    ModuleLifecycleStage["CREATE_GRPC"] = "creat-grpc-server";
+    ModuleLifecycleStage["PRE_SERVER_START"] = "pre-grpc-start";
+    ModuleLifecycleStage["SERVER_STARTED"] = "grpc-server-started";
+    ModuleLifecycleStage["PRE_REGISTER"] = "pre-register";
+    ModuleLifecycleStage["POST_REGISTER"] = "post-register";
+})(ModuleLifecycleStage || (ModuleLifecycleStage = {}));
+
+const processMeta = (meta) => {
+    if (Array.isArray(meta)) {
+        return meta.reduce((message, meta) => `${message} \n  ${JSON.stringify(meta, null, 2)}`, '');
+    }
+    else {
+        return JSON.stringify(meta, null, 2);
+    }
+};
+const createFormat = (logMeta = true) => {
+    return format.combine(format.printf(info => {
+        // This will customize the Error Message
+        if (info.stack) {
+            return `[${info.timestamp}] [${info.level.toUpperCase()}]: ${info.message} ${info.stack}`;
+        }
+        if (logMeta) {
+            return `[${info.timestamp}] [${info.level.toUpperCase()}]: ${info.message} ${!isEmpty(info.meta) ? processMeta(info.meta) : ''}`;
+        }
+        else {
+            return `[${info.timestamp}] [${info.level.toUpperCase()}]: ${info.message}`;
+        }
+    }));
+};
+const defaultTransport = new winston.transports.Console({
+    level: 'debug',
+    format: format.combine(format.prettyPrint(), format.errors({ stack: true }), format.timestamp({
+        format: 'YYYY-MM-DD HH:mm:ss',
+    }), createFormat(false), format.colorize({
+        all: true,
+    })),
+});
+class ConduitLogger {
+    _winston;
+    constructor(transports) {
+        this._winston = winston.createLogger({
+            format: format.combine(format.prettyPrint(), format.errors({ stack: true }), format.timestamp({
+                format: 'YYYY-MM-DD HH:mm:ss',
+            }), createFormat()),
+            transports: transports ? [...transports, defaultTransport] : [defaultTransport],
+        });
+    }
+    get winston() {
+        return this._winston;
+    }
+    addTransport(transport) {
+        this._winston.add(transport);
+    }
+    log(message, level = 'info', cb) {
+        return this._winston.log(level, message, cb);
+    }
+    logObject(object, message = '', level = 'info', cb) {
+        return this._winston.log(level, message, object, cb);
+    }
+    info(message, cb) {
+        return this._winston.info(message, cb);
+    }
+    warn(message, cb) {
+        return this._winston.warn(message, cb);
+    }
+    error(message, cb) {
+        if (typeof message === 'object') {
+            return this._winston.error(message);
+        }
+        return this._winston.error(message, cb);
+    }
+    http(message, cb) {
+        return this._winston.http(message, cb);
+    }
+    verbose(message, cb) {
+        return this._winston.verbose(message, cb);
+    }
+}
+async function lokiReadyCheck(lokiUrl) {
+    return new Promise((resolve, reject) => {
+        const data = [];
+        get(`${lokiUrl}/ready`, r => {
+            r.on('data', chunk => data.push(chunk));
+            r.on('end', () => {
+                if (Buffer.concat(data).toString() === 'ready\n')
+                    resolve();
+                else
+                    reject(false);
+            });
+        }).on('error', err => {
+            reject(err.message);
+        });
+    });
+}
+async function setupLoki(module, instance) {
+    let lokiUrl = process.env.LOKI_URL;
+    if (lokiUrl && lokiUrl !== '') {
+        if (lokiUrl.endsWith('/'))
+            lokiUrl = lokiUrl.slice(0, -1);
+        const onTry = async () => {
+            return await lokiReadyCheck(lokiUrl)
+                .then(() => {
+                ConduitGrpcSdk.Logger.addTransport(new LokiTransport({
+                    level: 'debug',
+                    host: lokiUrl,
+                    batching: false,
+                    replaceTimestamp: true,
+                    labels: {
+                        module,
+                        instance,
+                        ...(process.env.CONDUIT_NAMESPACE && {
+                            namespace: process.env.CONDUIT_NAMESPACE,
+                        }),
+                    },
+                }));
+                return false;
+            })
+                .catch(() => true); // retry
+        };
+        const onFailure = () => {
+            ConduitGrpcSdk.Logger.error(`Failed to connect to Loki on '${lokiUrl}'`);
+        };
+        await linearBackoffTimeoutAsync(onTry, 250, 15, onFailure, true);
+    }
+}
+
+class MetricsServer {
+    moduleName;
+    instance;
+    Registry;
+    constructor(moduleName, instance, registry) {
+        this.moduleName = moduleName;
+        this.instance = instance;
+        this.Registry = registry;
+    }
+    initialize() {
+        const server = express();
+        const port = this.getHttpPort();
+        const url = '0.0.0.0:' + port.toString();
+        server.listen(port, () => {
+            ConduitGrpcSdk.Logger.info(`Metrics server listening on: ${url}`);
+        });
+        server.get('/', (req, res) => {
+            return res
+                .status(200)
+                .send(`Conduit Metrics for module: ${this.moduleName}, instance: ${this.instance}`);
+        });
+        server.get('/metrics', async (req, res) => {
+            const metrics = await this.Registry.metrics();
+            return res.status(200).send(metrics);
+        });
+        return server;
+    }
+    getHttpPort() {
+        const value = process.env['METRICS_PORT'];
+        if (!value) {
+            ConduitGrpcSdk.Logger.error(`Metrics HTTP port not set`);
+            process.exit(-1);
+        }
+        const port = parseInt(value, 10);
+        if (isNaN(port) || port < 1 || port > 65535) {
+            ConduitGrpcSdk.Logger.error(`Invalid HTTP port value: ${port}`);
+            process.exit(-1);
+        }
+        return port;
+    }
+}
+
+var defaultMetrics = {
+    internalGrpcRequests: {
+        type: MetricType.Counter,
+        config: {
+            name: 'internal_grpc_requests_total',
+            help: "Tracks the total number of Conduit's internal gRPC requests",
+        },
+    },
+    clientGrpcRequests: {
+        type: MetricType.Counter,
+        config: {
+            name: 'client_grpc_requests_total',
+            help: 'Tracks the total number of the client gRPC requests',
+        },
+    },
+    adminGrpcRequests: {
+        type: MetricType.Counter,
+        config: {
+            name: 'admin_grpc_requests_total',
+            help: 'Tracks the total number of the admin gRPC requests',
+        },
+    },
+    clientGrpcErrors: {
+        type: MetricType.Counter,
+        config: {
+            name: 'client_grpc_errors_total',
+            help: 'Tracks the total number of client grpc errors',
+        },
+    },
+    adminGrpcErrors: {
+        type: MetricType.Counter,
+        config: {
+            name: 'admin_grpc_errors_total',
+            help: 'Tracks the total number of admin grpc errors',
+        },
+    },
+    moduleHealthState: {
+        type: MetricType.Gauge,
+        config: {
+            name: 'module_health_state',
+            help: 'Tracks the health state of the module',
+        },
+    },
+    grpcRequestLatency: {
+        type: MetricType.Gauge,
+        config: {
+            name: 'grpc_request_latency_seconds',
+            help: 'Tracks the latency of grpc requests in seconds',
+        },
+    },
+    adminGrpcRequestLatency: {
+        type: MetricType.Gauge,
+        config: {
+            name: 'admin_grpc_request_latency_seconds',
+            help: 'Tracks the latency of admin grpc requests in seconds',
+        },
+    },
+    clientGrpcRequestLatency: {
+        type: MetricType.Gauge,
+        config: {
+            name: 'client_grpc_request_latency_seconds',
+            help: 'Tracks the latency of client grpc requests in seconds',
+        },
+    },
+    grpcResponseStatuses: {
+        type: MetricType.Counter,
+        config: {
+            name: 'grpc_response_statuses_total',
+            help: 'Tracks the total number of grpc response codes',
+            labelNames: ['success'],
+        },
+    },
+    adminGrpcResponseStatuses: {
+        type: MetricType.Counter,
+        config: {
+            name: 'admin_grpc_response_statuses_total',
+            help: 'Tracks the total number of admin grpc response codes',
+            labelNames: ['success'],
+        },
+    },
+    clientGrpcResponseStatuses: {
+        type: MetricType.Counter,
+        config: {
+            name: 'client_grpc_response_statuses_total',
+            help: 'Tracks the total number  of client grpc response codes',
+            labelNames: ['success'],
+        },
+    },
+};
+
+class ConduitMetrics {
+    moduleName;
+    instance;
+    _registry;
+    _httpServer;
+    constructor(moduleName, instance) {
+        this.moduleName = moduleName;
+        this.instance = instance;
+        this._registry = new Registry();
+        this._registry.setDefaultLabels({
+            module_name: this.moduleName,
+            module_instance: this.instance,
+        });
+        this.collectDefaultMetrics();
+        this._httpServer = new MetricsServer(moduleName, instance, this._registry);
+        this._httpServer.initialize();
+    }
+    initializeDefaultMetrics() {
+        for (const metric of Object.values(defaultMetrics)) {
+            this.registerMetric(metric.type, metric.config);
+        }
+    }
+    registerMetric(type, config) {
+        if (this.getMetric(config.name))
+            return;
+        const metricConfig = JSON.parse(JSON.stringify(config));
+        metricConfig.name = this.addPrefix(config.name);
+        switch (type) {
+            case MetricType.Counter:
+                this.createCounter(metricConfig);
+                break;
+            case MetricType.Gauge:
+                this.createGauge(metricConfig);
+                break;
+            case MetricType.Histogram:
+                this.createHistogram(metricConfig);
+                break;
+            case MetricType.Summary:
+                this.createSummary(metricConfig);
+                break;
+        }
+    }
+    collectDefaultMetrics() {
+        collectDefaultMetrics({
+            register: this._registry,
+            prefix: 'conduit_',
+            // probably not needed
+            labels: {
+                module_name: this.moduleName,
+                instance_instance: this.instance,
+            },
+        });
+    }
+    createCounter(config) {
+        return new Counter({ ...config, registers: [this._registry] });
+    }
+    createSummary(config) {
+        return new Summary({ ...config, registers: [this._registry] });
+    }
+    createHistogram(config) {
+        return new Histogram({ ...config, registers: [this._registry] });
+    }
+    createGauge(config) {
+        return new Gauge({ ...config, registers: [this._registry] });
+    }
+    getMetric(name) {
+        return this._registry.getSingleMetric(this.addPrefix(name));
+    }
+    increment(metric, increment = 1, labels) {
+        const metricInstance = this._registry.getSingleMetric(this.addPrefix(metric));
+        if (!(metricInstance instanceof Counter) && !(metricInstance instanceof Gauge)) {
+            throw new Error(`Metric ${metric} is not an incrementable metric`);
+        }
+        return labels
+            ? metricInstance.labels({ ...labels }).inc(increment)
+            : metricInstance.inc(increment);
+    }
+    decrement(metric, decrement = 1, labels) {
+        const metricInstance = this._registry.getSingleMetric(this.addPrefix(metric));
+        if (!(metricInstance instanceof Gauge)) {
+            throw new Error(`Metric ${metric} is not a decrementable metric`);
+        }
+        return labels
+            ? metricInstance.labels({ ...labels }).dec(decrement)
+            : metricInstance.dec(decrement);
+    }
+    set(metric, value, labels) {
+        const metricInstance = this._registry.getSingleMetric(this.addPrefix(metric));
+        if (!(metricInstance instanceof Gauge)) {
+            throw new Error(`Metric ${metric} is not a Gauge`);
+        }
+        return labels
+            ? metricInstance.labels({ ...labels }).set(value)
+            : metricInstance.set(value);
+    }
+    observe(metric, value, labels) {
+        const metricInstance = this._registry.getSingleMetric(this.addPrefix(metric));
+        if (!(metricInstance instanceof Histogram) && !(metricInstance instanceof Summary)) {
+            throw new Error(`Metric ${metric} is not a Histogram`);
+        }
+        return labels
+            ? metricInstance.labels({ ...labels }).observe(value)
+            : metricInstance.observe(value);
+    }
+    addPrefix(metric) {
+        return `conduit_${metric}`;
+    }
+}
+
+// Forked from nice-grpc-prometheus
+const registry = new Registry();
+const typeLabel = 'grpc_type';
+const serviceLabel = 'grpc_service';
+const methodLabel = 'grpc_method';
+const pathLabel = 'grpc_path';
+const codeLabel = 'grpc_code';
+/**
+ * 1ms, 4ms, 16ms, ..., ~1 hour in seconds
+ */
+const latencySecondsBuckets = exponentialBuckets(0.001, 4, 12);
+function getLabels(method) {
+    const callType = method.requestStream
+        ? method.responseStream
+            ? 'bidi_stream'
+            : 'client_stream'
+        : method.responseStream
+            ? 'server_stream'
+            : 'unary';
+    const { path } = method;
+    const [serviceName, methodName] = path.split('/').slice(1);
+    return {
+        [typeLabel]: callType,
+        [serviceLabel]: serviceName,
+        [methodLabel]: methodName,
+        [pathLabel]: path,
+    };
+}
+async function* incrementStreamMessagesCounter(iterable, counter) {
+    for await (const item of iterable) {
+        counter.inc();
+        yield item;
+    }
+}
+const clientStartedMetric = new Counter({
+    registers: [registry],
+    name: 'conduit_grpc_client_started_total',
+    help: 'Total number of RPCs started on the client.',
+    labelNames: [typeLabel, serviceLabel, methodLabel, pathLabel],
+});
+const clientHandledMetric = new Counter({
+    registers: [registry],
+    name: 'conduit_grpc_client_handled_total',
+    help: 'Total number of RPCs completed on the client, regardless of success or failure.',
+    labelNames: [typeLabel, serviceLabel, methodLabel, pathLabel, codeLabel],
+});
+const clientStreamMsgReceivedMetric = new Counter({
+    registers: [registry],
+    name: 'conduit_grpc_client_msg_received_total',
+    help: 'Total number of RPC stream messages received by the client.',
+    labelNames: [typeLabel, serviceLabel, methodLabel, pathLabel],
+});
+const clientStreamMsgSentMetric = new Counter({
+    registers: [registry],
+    name: 'conduit_grpc_client_msg_sent_total',
+    help: 'Total number of gRPC stream messages sent by the client.',
+    labelNames: [typeLabel, serviceLabel, methodLabel, pathLabel],
+});
+const clientHandlingSecondsMetric = new Histogram({
+    registers: [registry],
+    name: 'grpc_client_handling_seconds',
+    help: 'Histogram of response latency (seconds) of the gRPC until it is finished by the application.',
+    labelNames: [typeLabel, serviceLabel, methodLabel, pathLabel, codeLabel],
+    buckets: latencySecondsBuckets,
+});
+function clientMiddleware() {
+    return async function* prometheusClientMiddlewareGenerator(call, options) {
+        const labels = getLabels(call.method);
+        clientStartedMetric.inc(labels);
+        const stopTimer = clientHandlingSecondsMetric.startTimer(labels);
+        let settled = false;
+        let status = Status.OK;
+        try {
+            let request;
+            if (!call.requestStream) {
+                request = call.request;
+            }
+            else {
+                request = incrementStreamMessagesCounter(call.request, clientStreamMsgSentMetric.labels(labels));
+            }
+            if (!call.responseStream) {
+                const response = yield* call.next(request, options);
+                settled = true;
+                return response;
+            }
+            else {
+                yield* incrementStreamMessagesCounter(call.next(request, options), clientStreamMsgReceivedMetric.labels(labels));
+                settled = true;
+                return;
+            }
+        }
+        catch (err) {
+            settled = true;
+            if (err instanceof ClientError) {
+                status = err.code;
+            }
+            else if (isAbortError(err)) {
+                status = Status.ABORTED;
+            }
+            else {
+                status = Status.UNKNOWN;
+            }
+            throw err;
+        }
+        finally {
+            if (!settled) {
+                status = Status.CANCELLED;
+            }
+            stopTimer({ [codeLabel]: Status[status] });
+            clientHandledMetric.inc({
+                ...labels,
+                [codeLabel]: Status[status],
+            });
+        }
+    };
+}
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const initializeSdk = (coreUrl, moduleName, watchModules = true, serviceHealthStatusGetter = () => HealthCheckStatus.SERVING) => {
+    let logger;
+    try {
+        logger = new ConduitLogger([
+            new winston.transports.File({
+                filename: path.join(__dirname, '.logs/combined.log'),
+                level: 'info',
+            }),
+            new winston.transports.File({
+                filename: path.join(__dirname, '.logs/errors.log'),
+                level: 'error',
+            }),
+        ]);
+    }
+    catch (e) {
+        logger = new ConduitLogger();
+    }
+    const grpcSdk = new ConduitGrpcSdk(coreUrl, moduleName, watchModules, logger, serviceHealthStatusGetter);
+    setupLoki(grpcSdk.name, grpcSdk.instance).then();
+    if (process.env.METRICS_PORT) {
+        ConduitGrpcSdk.Metrics = new ConduitMetrics(grpcSdk.name, grpcSdk.instance);
+        grpcSdk.addMiddleware(clientMiddleware());
+    }
+    return grpcSdk;
+};
+
+/**
+ * Registers a timeout with linear backoff.
+ * onFailure() only runs on rep exhaustion.
+ * Timeout can be cleared through returned clear() or inside onTry().
+ */
+function linearBackoffTimeout(onTry, delay, reps, onFailure) {
+    const nextRep = () => reps === undefined || --reps > 0;
+    let stopSignal = false;
+    const stop = () => {
+        stopSignal = true;
+    };
+    let timeout;
+    const invoker = async () => {
+        if (stopSignal) {
+            return timeout ? clearTimeout$1(timeout) : null;
+        }
+        delay = Math.floor(delay * 2);
+        if (delay > 0 && nextRep()) {
+            timeout = setTimeout(invoker, delay);
+            onTry(stop);
+        }
+        else {
+            timeout = null;
+            onFailure && onFailure();
+        }
+    };
+    timeout = setTimeout(invoker, delay);
+    return {
+        clear: () => {
+            if (timeout) {
+                clearTimeout$1(timeout);
+                timeout = null;
+            }
+        },
+    };
+}
+/**
+ * Registers a timeout with linear backoff.
+ * onFailure() only runs on rep exhaustion.
+ * @param {() => Promise<boolean>} onTry - Async handler, returns 'continue' boolean flag
+ */
+async function linearBackoffTimeoutAsync(onTry, delay, reps, onFailure, startNow = false) {
+    const nextRep = () => reps === undefined || --reps > 0;
+    const invoker = async () => {
+        delay = Math.floor(delay * 2);
+        if (delay > 0 && nextRep()) {
+            if (await onTry())
+                setTimeout(invoker, delay);
+        }
+        else {
+            onFailure && (await onFailure());
+        }
+    };
+    setTimeout(invoker, startNow ? 0 : delay);
+}
+
+function merge(objA, objB) {
+    const customizer = (objValue, srcValue) => {
+        if (Array.isArray(objValue)) {
+            // don't merge arrays
+            return srcValue;
+        }
+    };
+    return mergeWith({}, objA, objB, customizer);
+}
+
+const convictConfigParser = (config) => {
+    if (typeof config === 'object') {
+        Object.keys(config).forEach(key => {
+            if (key === '_cvtProperties') {
+                config = convictConfigParser(config._cvtProperties);
+            }
+            else {
+                config[key] = convictConfigParser(config[key]);
+            }
+        });
+    }
+    return config;
+};
+
+class RoutingController {
+    _routeHandlers = {};
+    handleRequest(call, callback) {
+        if (this._routeHandlers[call.request.functionName]) {
+            this._routeHandlers[call.request.functionName](call, callback);
+        }
+        else {
+            callback({
+                code: status.NOT_FOUND,
+                message: 'Not found',
+            });
+        }
+    }
+    setRoutes(routes) {
+        this._routeHandlers = routes;
+    }
+}
+
+class ManagedModule extends ConduitServiceModule {
+    config;
+    configOverride = false;
+    service;
+    serviceAddress;
+    servicePort;
+    _moduleState;
+    constructor(moduleName) {
+        super(moduleName);
+        this._moduleState = ModuleLifecycleStage.CREATE_GRPC;
+        if (!process.env.CONDUIT_SERVER) {
+            throw new Error('CONDUIT_SERVER is undefined, specify Conduit server URL');
+        }
+        this.servicePort = process.env.GRPC_PORT ?? '5000';
+        this.serviceAddress =
+            // @compat (v0.15): SERVICE_IP -> SERVICE_URL
+            process.env.SERVICE_URL || process.env.SERVICE_IP || '0.0.0.0:' + this.servicePort;
+        try {
+            this.grpcSdk = initializeSdk(process.env.CONDUIT_SERVER, this.name, true, () => {
+                return this.healthState;
+            });
+        }
+        catch (e) {
+            throw new Error('Failed to initialize grpcSdk');
+        }
+    }
+    get name() {
+        return this._moduleName;
+    }
+    get address() {
+        return this._address;
+    }
+    async start() {
+        await this.grpcSdk.initialize();
+        this.initialize(this.serviceAddress, this.servicePort);
+        try {
+            await this.preRegisterLifecycle();
+            await this.grpcSdk.config.registerModule(this.name, this.address, this.healthState);
+        }
+        catch (err) {
+            ConduitGrpcSdk.Logger.error('Failed to initialize server');
+            ConduitGrpcSdk.Logger.error(err);
+            process.exit(-1);
+        }
+        await this.postRegisterLifecycle().catch((err) => {
+            ConduitGrpcSdk.Logger.error('Failed to activate module');
+            ConduitGrpcSdk.Logger.error(err);
+            process.exit(-1);
+        });
+    }
+    /**
+     * This is the first function triggered on module spin up.
+     * @param address {string} external address:port of service (LoadBalancer)
+     * @param port {string} port to bring up gRPC service
+     */
+    initialize(address, port) {
+        this._address = address;
+        this._port = port;
+        if (this.configSchema) {
+            this.config = convict(this.configSchema);
+        }
+    }
+    /**
+     * This is triggered before spinning up the Grpc Server
+     * of the module. On this stage, the redis bus and state have
+     * not yet been initialized, and only communications with Conduit core
+     * have been established.
+     */
+    async preServerStart() { }
+    /**
+     * This is triggered right after Grpc Server start.
+     * At this stage the core module will communicate with your service
+     * for health checks, and the Bus and State management mechanics
+     * are online and available.
+     */
+    async onServerStart() { }
+    /**
+     * Triggers right before registering the module with Conduit Core.
+     */
+    async preRegister() { }
+    /**
+     * Triggers when module has been registered with Conduit Core
+     * This is the step where you should initialize your
+     * module's general routing (admin or client) and any other operation,
+     * that would require other modules being able to reach you
+     */
+    async onRegister() { }
+    /**
+     * This is triggered when the module receives new configuration.
+     * At this step the configuration has not been checked yet,
+     * and has only been parsed.
+     * @param config
+     */
+    async preConfig(config) {
+        return config;
+    }
+    /**
+     * This is triggered when new configuration has been applied.
+     * This happens either when changes are being made on the configuration,
+     * or on module start up, where the config is recovered from the database.
+     * In either case the configuration is now available through the
+     * Config Controller of the sdk.
+     */
+    async onConfig() { }
+    /**
+     * Registers common and module-specific metric types.
+     */
+    async registerMetrics() {
+        if (ConduitGrpcSdk.Metrics) {
+            ConduitGrpcSdk.Metrics.initializeDefaultMetrics();
+            if (this.metricsSchema) {
+                Object.values(this.metricsSchema).forEach(metric => {
+                    ConduitGrpcSdk.Metrics.registerMetric(metric.type, metric.config);
+                });
+            }
+        }
+    }
+    /**
+     * Initializes metric startup values.
+     * Implemented by individual modules.
+     */
+    async initializeMetrics() { }
+    async createGrpcServer() {
+        this.grpcServer = new GrpcServer(this._port);
+        this._port = (await this.grpcServer.createNewServer()).toString();
+    }
+    async startGrpcServer() {
+        if (this.service) {
+            this._serviceName = this.service.protoDescription.substring(this.service.protoDescription.indexOf('.') + 1);
+            await this.grpcServer.addService(this.service.protoPath, this.service.protoDescription, this.service.functions);
+        }
+        RoutingManager.ClientController = new RoutingController();
+        RoutingManager.AdminController = new RoutingController();
+        await this.addHealthCheckService();
+        await this.addModuleService();
+        await this.grpcServer.start();
+        ConduitGrpcSdk.Logger.log('gRPC server listening on ' + this._port);
+    }
+    async setConfig(call, callback) {
+        try {
+            if (!this.config) {
+                return callback({
+                    code: status.INVALID_ARGUMENT,
+                    message: 'Module is not configurable',
+                });
+            }
+            let config = JSON.parse(call.request.newConfig);
+            config = merge(this.config.getProperties(), config);
+            config = await this.preConfig(config);
+            const previousConfig = this.config.getProperties();
+            try {
+                this.config.load(config).validate({
+                    allowed: 'warn',
+                });
+                config = this.config.getProperties();
+                callback(null, { updatedConfig: JSON.stringify(config) });
+            }
+            catch (e) {
+                this.config = convict(this.configSchema);
+                this.config.load(previousConfig);
+                return callback({
+                    code: status.INVALID_ARGUMENT,
+                    message: 'Invalid configuration values: ' + e.message,
+                });
+            }
+            ConfigController.getInstance().config = config;
+            await this.onConfig();
+            this.grpcSdk.bus?.publish(kebabCase(this.name) + ':config:update', JSON.stringify(config));
+        }
+        catch (e) {
+            return callback({ code: status.INTERNAL, message: e.message });
+        }
+    }
+    /** Used to update the module's configuration on initial Redis/DB reconciliation. */
+    async handleConfigSyncUpdate() {
+        if (!this.config)
+            return;
+        this.grpcSdk.bus.subscribe(`${kebabCase(this.name)}:config:update`, async (message) => {
+            ConfigController.getInstance().config = await this.preConfig(JSON.parse(message));
+            await this.onConfig();
+        });
+    }
+    async preRegisterLifecycle() {
+        await this.createGrpcServer();
+        this._moduleState = ModuleLifecycleStage.PRE_SERVER_START;
+        await this.preServerStart();
+        await this.grpcSdk.initializeEventBus();
+        await this.handleConfigSyncUpdate();
+        await this.registerMetrics();
+        await this.startGrpcServer();
+        this._moduleState = ModuleLifecycleStage.SERVER_STARTED;
+        await this.onServerStart();
+        await this.initializeMetrics();
+        this._moduleState = ModuleLifecycleStage.PRE_REGISTER;
+        await this.preRegister();
+    }
+    async postRegisterLifecycle() {
+        this._moduleState = ModuleLifecycleStage.POST_REGISTER;
+        this.registered = true;
+        await this.onRegister();
+        if (this.config) {
+            const configSchema = this.config.getSchema();
+            let config = this.config.getProperties();
+            config = await this.preConfig(config);
+            config = await this.grpcSdk.config.configure(config, convictConfigParser(configSchema), this.configOverride);
+            ConfigController.getInstance();
+            if (config)
+                ConfigController.getInstance().config = config;
+            if (!config || config.active || !config.hasOwnProperty('active'))
+                await this.onConfig();
+        }
+    }
+}
+
+export { ConduitActiveSchema, ConduitBoolean, ConduitDate, ConduitJson, ConduitNumber, ConduitObjectId, ConduitRelation, ConduitServiceModule, ConduitString, ConfigController, GrpcServer, ManagedModule, ModuleLifecycleStage, ProxyRouteBuilder, RouteBuilder, RoutingManager, addServiceToServer, createParsedRouterRequest, createServer, initializeSdk, linearBackoffTimeout, linearBackoffTimeoutAsync, merge, wrapFunctionsAsync, wrapGrpcFunctions, wrapRouterGrpcFunction };
+//# sourceMappingURL=index.esm.js.map