@conduitplatform/module-tools 0.16.26 → 0.17.0-alpha.2

package/dist/index.cjs

@@ -1,1856 +1,2140 @@
-'use strict';
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-var grpcSdk = require('@conduitplatform/grpc-sdk');
-var grpcJs = require('@grpc/grpc-js');
-var protoLoader = require('@grpc/proto-loader');
-var fastJwt = require('fast-jwt');
-var lodash = require('lodash');
-var path = require('path');
-var events = require('events');
-var node_url = require('node:url');
-var convict = require('convict');
-var winston = require('winston');
-var http = require('http');
-var LokiTransport = require('winston-loki');
-var timers = require('timers');
-var promClient = require('prom-client');
-var abortControllerX = require('abort-controller-x');
-var niceGrpcCommon = require('nice-grpc-common');
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ConduitActiveSchema: () => ConduitActiveSchema,
+  ConduitBoolean: () => ConduitBoolean,
+  ConduitDate: () => ConduitDate,
+  ConduitJson: () => ConduitJson,
+  ConduitNumber: () => ConduitNumber,
+  ConduitObjectId: () => ConduitObjectId,
+  ConduitRelation: () => ConduitRelation,
+  ConduitServiceModule: () => ConduitServiceModule,
+  ConduitString: () => ConduitString,
+  ConfigController: () => ConfigController,
+  DEFAULT_STRIP_FIELDS: () => DEFAULT_STRIP_FIELDS,
+  GrpcServer: () => GrpcServer,
+  ManagedModule: () => ManagedModule,
+  ModuleError: () => ModuleError,
+  ModuleLifecycleStage: () => ModuleLifecycleStage,
+  RouteBuilder: () => RouteBuilder,
+  RoutingManager: () => RoutingManager,
+  addServiceToServer: () => addServiceToServer,
+  createParsedRouterRequest: () => createParsedRouterRequest,
+  createServer: () => createServer,
+  exportModel: () => exportModel,
+  importModel: () => importModel,
+  initializeSdk: () => initializeSdk,
+  linearBackoffTimeout: () => linearBackoffTimeout,
+  linearBackoffTimeoutAsync: () => linearBackoffTimeoutAsync,
+  merge: () => merge,
+  readConduitPeersManifest: () => readConduitPeersManifest,
+  sanitizeDocumentsForExport: () => sanitizeDocumentsForExport,
+  stripInternalFields: () => stripInternalFields,
+  wrapFunctionsAsync: () => wrapFunctionsAsync,
+  wrapGrpcFunctions: () => wrapGrpcFunctions,
+  wrapRouterGrpcFunction: () => wrapRouterGrpcFunction
+});
+module.exports = __toCommonJS(index_exports);
 
-var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
-class ConduitActiveSchema extends grpcSdk.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);
-    }
-}
+// src/classes/ConduitActiveSchema.ts
+var import_grpc_sdk = require("@conduitplatform/grpc-sdk");
+var ConduitActiveSchema = class extends import_grpc_sdk.ConduitSchema {
+  dbInstance;
+  constructor(dbInstance, name, fields, modelOptions, collectionName) {
+    super(name, fields ?? {}, modelOptions, collectionName);
+    this.dbInstance = dbInstance;
+  }
+  findOne(query, options) {
+    return this.dbInstance.findOne(this.name, query, options);
+  }
+  findMany(query, options) {
+    return this.dbInstance.findMany(this.name, query, options);
+  }
+  create(query, options) {
+    return this.dbInstance.create(this.name, query, options);
+  }
+  createMany(query, options) {
+    return this.dbInstance.createMany(this.name, query, options);
+  }
+  findByIdAndUpdate(id, document, options) {
+    return this.dbInstance.findByIdAndUpdate(this.name, id, document, options);
+  }
+  findByIdAndReplace(id, document, options) {
+    return this.dbInstance.findByIdAndReplace(this.name, id, document, options);
+  }
+  replaceOne(filterQuery, query, options) {
+    return this.dbInstance.replaceOne(this.name, filterQuery, query, options);
+  }
+  updateOne(filterQuery, query, options) {
+    return this.dbInstance.updateOne(this.name, filterQuery, query, options);
+  }
+  updateMany(filterQuery, query, options) {
+    return this.dbInstance.updateMany(this.name, filterQuery, query, options);
+  }
+  deleteOne(query, options) {
+    return this.dbInstance.deleteOne(this.name, query, options);
+  }
+  deleteMany(query, options) {
+    return this.dbInstance.deleteMany(this.name, query, options);
+  }
+  countDocuments(query, options) {
+    return this.dbInstance.countDocuments(this.name, query, options);
+  }
+};
 
-class ConduitStringConstructor {
-    // private to disallow creating other instances of this type
-    constructor() { }
-    static get Optional() {
-        return grpcSdk.TYPE.String;
-    }
-    static get Required() {
-        return { type: grpcSdk.TYPE.String, required: true };
-    }
-}
-const ConduitString = ConduitStringConstructor;
-class ConduitNumberConstructor {
-    // private to disallow creating other instances of this type
-    constructor() { }
-    static get Optional() {
-        return grpcSdk.TYPE.Number;
-    }
-    static get Required() {
-        return { type: grpcSdk.TYPE.Number, required: true };
-    }
-}
-const ConduitNumber = ConduitNumberConstructor;
-class ConduitBooleanConstructor {
-    // private to disallow creating other instances of this type
-    constructor() { }
-    static get Optional() {
-        return grpcSdk.TYPE.Boolean;
-    }
-    static get Required() {
-        return { type: grpcSdk.TYPE.Boolean, required: true };
-    }
-}
-const ConduitBoolean = ConduitBooleanConstructor;
-class ConduitDateConstructor {
-    // private to disallow creating other instances of this type
-    constructor() { }
-    static get Optional() {
-        return grpcSdk.TYPE.Date;
-    }
-    static get Required() {
-        return { type: grpcSdk.TYPE.Date, required: true };
-    }
-}
-const ConduitDate = ConduitDateConstructor;
-class ConduitObjectIdConstructor {
-    // private to disallow creating other instances of this type
-    constructor() { }
-    static get Optional() {
-        return grpcSdk.TYPE.ObjectId;
-    }
-    static get Required() {
-        return { type: grpcSdk.TYPE.ObjectId, required: true };
-    }
-}
-const ConduitObjectId = ConduitObjectIdConstructor;
-class ConduitJSONConstructor {
-    // private to disallow creating other instances of this type
-    constructor() { }
-    static get Optional() {
-        return grpcSdk.TYPE.JSON;
-    }
-    static get Required() {
-        return { type: grpcSdk.TYPE.JSON, required: true };
-    }
-}
-const ConduitJson = ConduitJSONConstructor;
-class ConduitRelationConstructor {
-    // private to disallow creating other instances of this type
-    constructor() { }
-    static Optional(model) {
-        return { type: grpcSdk.TYPE.Relation, model, required: false };
-    }
-    static Required(model) {
-        return { type: grpcSdk.TYPE.Relation, model, required: true };
-    }
-}
-const ConduitRelation = ConduitRelationConstructor;
+// src/helpers/TypeHelpers.ts
+var import_grpc_sdk2 = require("@conduitplatform/grpc-sdk");
+var ConduitStringConstructor = class {
+  // private to disallow creating other instances of this type
+  constructor() {
+  }
+  static get Optional() {
+    return import_grpc_sdk2.TYPE.String;
+  }
+  static get Required() {
+    return { type: import_grpc_sdk2.TYPE.String, required: true };
+  }
+  static RequiredWith(rules) {
+    return { type: import_grpc_sdk2.TYPE.String, required: true, validate: rules };
+  }
+  static OptionalWith(rules) {
+    return { type: import_grpc_sdk2.TYPE.String, required: false, validate: rules };
+  }
+};
+var ConduitString = ConduitStringConstructor;
+var ConduitNumberConstructor = class {
+  // private to disallow creating other instances of this type
+  constructor() {
+  }
+  static get Optional() {
+    return import_grpc_sdk2.TYPE.Number;
+  }
+  static get Required() {
+    return { type: import_grpc_sdk2.TYPE.Number, required: true };
+  }
+  static RequiredWith(rules) {
+    return { type: import_grpc_sdk2.TYPE.Number, required: true, validate: rules };
+  }
+  static OptionalWith(rules) {
+    return { type: import_grpc_sdk2.TYPE.Number, required: false, validate: rules };
+  }
+};
+var ConduitNumber = ConduitNumberConstructor;
+var ConduitBooleanConstructor = class {
+  // private to disallow creating other instances of this type
+  constructor() {
+  }
+  static get Optional() {
+    return import_grpc_sdk2.TYPE.Boolean;
+  }
+  static get Required() {
+    return { type: import_grpc_sdk2.TYPE.Boolean, required: true };
+  }
+};
+var ConduitBoolean = ConduitBooleanConstructor;
+var ConduitDateConstructor = class {
+  // private to disallow creating other instances of this type
+  constructor() {
+  }
+  static get Optional() {
+    return import_grpc_sdk2.TYPE.Date;
+  }
+  static get Required() {
+    return { type: import_grpc_sdk2.TYPE.Date, required: true };
+  }
+};
+var ConduitDate = ConduitDateConstructor;
+var ConduitObjectIdConstructor = class {
+  // private to disallow creating other instances of this type
+  constructor() {
+  }
+  static get Optional() {
+    return import_grpc_sdk2.TYPE.ObjectId;
+  }
+  static get Required() {
+    return { type: import_grpc_sdk2.TYPE.ObjectId, required: true };
+  }
+};
+var ConduitObjectId = ConduitObjectIdConstructor;
+var ConduitJSONConstructor = class {
+  // private to disallow creating other instances of this type
+  constructor() {
+  }
+  static get Optional() {
+    return import_grpc_sdk2.TYPE.JSON;
+  }
+  static get Required() {
+    return { type: import_grpc_sdk2.TYPE.JSON, required: true };
+  }
+};
+var ConduitJson = ConduitJSONConstructor;
+var ConduitRelationConstructor = class {
+  // private to disallow creating other instances of this type
+  constructor() {
+  }
+  static Optional(model) {
+    return { type: import_grpc_sdk2.TYPE.Relation, model, required: false };
+  }
+  static Required(model) {
+    return { type: import_grpc_sdk2.TYPE.Relation, model, required: true };
+  }
+};
+var ConduitRelation = ConduitRelationConstructor;
 
+// src/helpers/GrpcHelper.ts
+var import_grpc_js = require("@grpc/grpc-js");
+var import_proto_loader = __toESM(require("@grpc/proto-loader"), 1);
 function createServer(port) {
-    const grpcServer = new grpcJs.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, grpcJs.ServerCredentials.createInsecure(), (err, port) => {
-            if (err) {
-                reject(err);
-            }
-            else {
-                resolve({
-                    server: grpcServer,
-                    port,
-                });
-            }
+  const grpcServer = new import_grpc_js.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, import_grpc_js.ServerCredentials.createInsecure(), (err, port2) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve({
+          server: grpcServer,
+          port: port2
         });
+      }
     });
+  });
 }
 function addServiceToServer(server, protoPath, descriptorObject, functions) {
-    const packageDefinition = protoLoader.loadSync(protoPath, {
-        keepCase: true,
-        longs: String,
-        enums: String,
-        defaults: true,
-        oneofs: true,
-    });
-    const protoDescriptor = grpcJs.loadPackageDefinition(packageDefinition);
-    const objs = descriptorObject.split('.');
-    let descObj = protoDescriptor;
-    objs.forEach((r) => {
-        descObj = descObj[r];
-    });
-    server.addService(descObj.service, functions);
+  const packageDefinition = import_proto_loader.default.loadSync(protoPath, {
+    keepCase: true,
+    longs: String,
+    enums: String,
+    defaults: true,
+    oneofs: true
+  });
+  const protoDescriptor = (0, import_grpc_js.loadPackageDefinition)(packageDefinition);
+  const objs = descriptorObject.split(".");
+  let descObj = protoDescriptor;
+  objs.forEach((r) => {
+    descObj = descObj[r];
+  });
+  server.addService(descObj.service, functions);
 }
 
+// src/helpers/wrapGrpcFunctions.ts
+var import_fast_jwt = require("fast-jwt");
+var import_grpc_js2 = require("@grpc/grpc-js");
+var import_grpc_sdk3 = require("@conduitplatform/grpc-sdk");
 function wrapGrpcFunctions(functions, postponeRestart, noAuth = false) {
-    const grpcKey = process.env.GRPC_KEY;
-    const wrappedFunctions = {};
-    Object.keys(functions).forEach(name => {
-        wrappedFunctions[name] = (call, callback) => {
-            grpcSdk.ConduitGrpcSdk.Metrics?.increment('internal_grpc_requests_total');
-            postponeRestart();
-            if (grpcKey && !noAuth) {
-                const verify = fastJwt.createVerifier({ key: grpcKey });
-                const grpcToken = call.metadata.get('grpc-token')[0];
-                if (!grpcToken) {
-                    return throwError(callback, 'No gRPC protection token provided', grpcJs.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', grpcJs.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;
+  const grpcKey = process.env.GRPC_KEY;
+  const wrappedFunctions = {};
+  Object.keys(functions).forEach((name) => {
+    wrappedFunctions[name] = (call, callback) => {
+      import_grpc_sdk3.ConduitGrpcSdk.Metrics?.increment("internal_grpc_requests_total");
+      postponeRestart();
+      if (grpcKey && !noAuth) {
+        const verify = (0, import_fast_jwt.createVerifier)({ key: grpcKey });
+        const grpcToken = call.metadata.get("grpc-token")[0];
+        if (!grpcToken) {
+          return throwError(
+            callback,
+            "No gRPC protection token provided",
+            import_grpc_js2.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",
+            import_grpc_js2.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 = grpcJs.status.INTERNAL) {
-    // Aborting server streams is not yet implemented!
-    if (callback) {
-        callback({ code, message });
-    }
+function throwError(callback, message, code = import_grpc_js2.status.INTERNAL) {
+  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 ?? {},
-        },
-    };
+// src/helpers/GrpcToParsedRouterRequest.ts
+function createParsedRouterRequest(params, urlParams, queryParams, bodyParams, path4, headers, context, cookies) {
+  return {
+    request: {
+      params,
+      urlParams: urlParams ?? {},
+      queryParams: queryParams ?? {},
+      bodyParams: bodyParams ?? {},
+      path: path4 ?? "",
+      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 (!lodash.isNil(this.scheduledRestart)) {
-            await this.wait(200);
-        }
-    }
-    _url;
-    get url() {
-        return this._url;
-    }
-    async createNewServer(useForce = false) {
-        if (lodash.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, noAuth = false) {
-        functions = wrapGrpcFunctions(functions, this.postponeRestart.bind(this), noAuth);
-        if (this._serviceNames.indexOf(protoDescription) !== -1) {
-            grpcSdk.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) {
-                grpcSdk.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 () => {
-            grpcSdk.ConduitGrpcSdk.Logger.log('Begin refresh');
-            await self.refresh();
-            grpcSdk.ConduitGrpcSdk.Logger.log('Refresh complete');
-            clearTimeout(self.scheduledRestart);
-            self.scheduledRestart = undefined;
-            self._postponeRequests = 0;
-        }, 2000);
-    }
-    start() {
-        if (this.started) {
-            grpcSdk.ConduitGrpcSdk.Logger.error('gRPC server is already running!');
-            return;
-        }
-        else if (!this.started && this.startedOnce) {
-            grpcSdk.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++;
+// src/classes/GrpcServer.ts
+var import_lodash_es = require("lodash-es");
+var import_grpc_sdk4 = require("@conduitplatform/grpc-sdk");
+var GrpcServer = class {
+  grpcServer;
+  started = false;
+  startedOnce = false;
+  _serviceNames = [];
+  scheduledRestart;
+  _postponeRequests = 0;
+  _useForce;
+  _services = [];
+  constructor(port) {
+    this._url = `0.0.0.0:${port ?? "5000"}`;
+  }
+  async waitForReady() {
+    while (!(0, import_lodash_es.isNil)(this.scheduledRestart)) {
+      await this.wait(200);
+    }
+  }
+  _url;
+  get url() {
+    return this._url;
+  }
+  async createNewServer(useForce = false) {
+    if ((0, import_lodash_es.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, noAuth = false) {
+    functions = wrapGrpcFunctions(functions, this.postponeRestart.bind(this), noAuth);
+    if (this._serviceNames.indexOf(protoDescription) !== -1) {
+      import_grpc_sdk4.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) {
+        import_grpc_sdk4.ConduitGrpcSdk.Logger.log("Server already started, scheduling refresh..");
         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;
+      } else {
+        if (!this.grpcServer) {
+          await this.wait(1e3);
         }
+        addServiceToServer(this.grpcServer, protoPath, protoDescription, functions);
         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 grpcSdk.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,
-        };
-    }
-}
+  }
+  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 {
+        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 () => {
+      import_grpc_sdk4.ConduitGrpcSdk.Logger.log("Begin refresh");
+      await self.refresh();
+      import_grpc_sdk4.ConduitGrpcSdk.Logger.log("Refresh complete");
+      clearTimeout(self.scheduledRestart);
+      self.scheduledRestart = void 0;
+      self._postponeRequests = 0;
+    }, 2e3);
+  }
+  start() {
+    if (this.started) {
+      import_grpc_sdk4.ConduitGrpcSdk.Logger.error("gRPC server is already running!");
+      return;
+    } else if (!this.started && this.startedOnce) {
+      import_grpc_sdk4.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();
+  }
+};
 
-const mapGrpcStatusToHttp = (code) => {
-    if (!code)
-        return '200 (OK)';
-    switch (code) {
-        case grpcJs.status.OK:
-            return `200 (OK)`;
-        case grpcJs.status.CANCELLED:
-            return `499 (Cancelled)`;
-        case grpcJs.status.INVALID_ARGUMENT:
-            return `400 (Invalid Argument)`;
-        case grpcJs.status.DEADLINE_EXCEEDED:
-            return `504 (Deadline Exceeded)`;
-        case grpcJs.status.NOT_FOUND:
-            return `404 (Not Found)`;
-        case grpcJs.status.ALREADY_EXISTS:
-            return `409 (Already Exists)`;
-        case grpcJs.status.PERMISSION_DENIED:
-            return `403 (Permission Denied)`;
-        case grpcJs.status.UNAUTHENTICATED:
-            return `401 (Unauthenticated)`;
-        case grpcJs.status.OUT_OF_RANGE:
-            return `416 (Out of Range)`;
-        case grpcJs.status.FAILED_PRECONDITION:
-            return `412 (Failed Precondition)`;
-        case grpcJs.status.ABORTED:
-            return `409 (Aborted)`;
-        case grpcJs.status.INTERNAL:
-            return `416 (Internal)`;
-        case grpcJs.status.UNAVAILABLE:
-            return `503 (Service Unavailable)`;
-        case grpcJs.status.DATA_LOSS:
-            return `500 (Data Loss)`;
-        default:
-            return `500 (Unknown)`;
-    }
+// src/classes/ConduitServiceModule.ts
+var import_path = __toESM(require("path"), 1);
+var import_events = require("events");
+var import_lodash_es2 = require("lodash-es");
+var import_grpc_js4 = require("@grpc/grpc-js");
+var import_grpc_sdk8 = require("@conduitplatform/grpc-sdk");
+
+// src/routing/RouteBuilder.ts
+var import_grpc_sdk5 = require("@conduitplatform/grpc-sdk");
+var RouteBuilder = class {
+  constructor(manager) {
+    this.manager = manager;
+    this._options = {};
+  }
+  _options;
+  _returns;
+  _handler;
+  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 !== void 0 && this._options.middlewares?.length !== 0) {
+      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;
+  }
+  path(path4) {
+    this._options.path = path4;
+    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;
+  }
+  strictParams(strict) {
+    this._options.strictParams = strict;
+    return this;
+  }
+  rateLimit(maxRequests, resetInterval) {
+    this._options.rateLimit = { maxRequests, resetInterval };
+    return this;
+  }
+  return(name, fields) {
+    this._returns = new import_grpc_sdk5.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 {
-        const socketReq = call.request;
-        const socketLabel = socketReq.socketId ?? socketReq.socket;
-        log += `(${routerType})  Socket: ${socketReq.event} socket: ${socketLabel}`;
-    }
-    log += ` ${mapGrpcStatusToHttp(status) ?? '200'} ${latency}ms`;
-    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().startsWith('2');
-    grpcSdk.ConduitGrpcSdk.Metrics?.increment(`${routerType}_grpc_response_statuses_total`, 1, {
-        success: successStatus ? 'true' : 'false',
-    });
+
+// src/routing/wrapRouterFunctions.ts
+var import_grpc_sdk6 = require("@conduitplatform/grpc-sdk");
+var import_grpc_js3 = require("@grpc/grpc-js");
+var mapGrpcStatusToHttp = (code) => {
+  if (!code) return "200 (OK)";
+  switch (code) {
+    case import_grpc_js3.status.OK:
+      return `200 (OK)`;
+    case import_grpc_js3.status.CANCELLED:
+      return `499 (Cancelled)`;
+    case import_grpc_js3.status.INVALID_ARGUMENT:
+      return `400 (Invalid Argument)`;
+    case import_grpc_js3.status.DEADLINE_EXCEEDED:
+      return `504 (Deadline Exceeded)`;
+    case import_grpc_js3.status.NOT_FOUND:
+      return `404 (Not Found)`;
+    case import_grpc_js3.status.ALREADY_EXISTS:
+      return `409 (Already Exists)`;
+    case import_grpc_js3.status.PERMISSION_DENIED:
+      return `403 (Permission Denied)`;
+    case import_grpc_js3.status.UNAUTHENTICATED:
+      return `401 (Unauthenticated)`;
+    case import_grpc_js3.status.OUT_OF_RANGE:
+      return `416 (Out of Range)`;
+    case import_grpc_js3.status.FAILED_PRECONDITION:
+      return `412 (Failed Precondition)`;
+    case import_grpc_js3.status.ABORTED:
+      return `409 (Aborted)`;
+    case import_grpc_js3.status.INTERNAL:
+      return `416 (Internal)`;
+    case import_grpc_js3.status.UNAVAILABLE:
+      return `503 (Service Unavailable)`;
+    case import_grpc_js3.status.DATA_LOSS:
+      return `500 (Data Loss)`;
+    default:
+      return `500 (Unknown)`;
+  }
+};
+function generateLog(routerType, routerRequest, requestReceive, call, status6) {
+  let log = "";
+  const latency = Date.now() - requestReceive;
+  if (routerRequest) {
+    log += `(${routerType}) Request: ${call.request.path}`;
+  } else {
+    const socketReq = call.request;
+    const socketLabel = socketReq.socketId ?? socketReq.socket;
+    log += `(${routerType})  Socket: ${socketReq.event} socket: ${socketLabel}`;
+  }
+  log += ` ${mapGrpcStatusToHttp(status6) ?? "200"} ${latency}ms`;
+  import_grpc_sdk6.ConduitGrpcSdk.Logger.log(log);
+  import_grpc_sdk6.ConduitGrpcSdk.Metrics?.set("grpc_request_latency_seconds", latency / 1e3);
+  import_grpc_sdk6.ConduitGrpcSdk.Metrics?.set(
+    `${routerType}_grpc_request_latency_seconds`,
+    latency / 1e3
+  );
+  const successStatus = !status6 || status6.toString().startsWith("2");
+  import_grpc_sdk6.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 {};
-    }
+  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: grpcJs.status.INTERNAL,
-            message: 'Handler did not return a response',
+  if (responded.did) return;
+  responded.did = true;
+  if (!r) {
+    callback({
+      code: import_grpc_js3.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 ?? void 0,
+          result: r.result ? typeof r.result === "string" ? r.result : JSON.stringify(r.result) : void 0
         });
-    }
-    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);
+      } 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, void 0);
 }
 function wrapRouterGrpcFunction(fun, routerType) {
-    return (call, callback) => {
-        const requestReceive = Date.now();
-        let routerRequest = true;
-        grpcSdk.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) {
-            grpcSdk.ConduitGrpcSdk.Metrics?.increment(`${routerType}_grpc_errors_total`);
-            generateLog(routerType, routerRequest, requestReceive, call, grpcJs.status.INTERNAL);
-            grpcSdk.ConduitGrpcSdk.Logger.error(e.message ?? 'Something went wrong');
-            return callback({
-                code: grpcJs.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 => {
-            grpcSdk.ConduitGrpcSdk.Metrics?.increment(`${routerType}_grpc_errors_total`);
-            generateLog(routerType, routerRequest, requestReceive, call, error.code ?? grpcJs.status.INTERNAL);
-            grpcSdk.ConduitGrpcSdk.Logger.error(error.debugLogInfo ?? error.message ?? 'Something went wrong');
-            callback({
-                code: error.code ?? grpcJs.status.INTERNAL,
-                message: error.details ?? error.message ?? 'Something went wrong',
-            });
-        });
-    };
+  return (call, callback) => {
+    const requestReceive = Date.now();
+    let routerRequest = true;
+    import_grpc_sdk6.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) {
+      import_grpc_sdk6.ConduitGrpcSdk.Metrics?.increment(`${routerType}_grpc_errors_total`);
+      generateLog(routerType, routerRequest, requestReceive, call, import_grpc_js3.status.INTERNAL);
+      import_grpc_sdk6.ConduitGrpcSdk.Logger.error(e.message ?? "Something went wrong");
+      return callback({
+        code: import_grpc_js3.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) => {
+      import_grpc_sdk6.ConduitGrpcSdk.Metrics?.increment(`${routerType}_grpc_errors_total`);
+      generateLog(
+        routerType,
+        routerRequest,
+        requestReceive,
+        call,
+        error.code ?? import_grpc_js3.status.INTERNAL
+      );
+      import_grpc_sdk6.ConduitGrpcSdk.Logger.error(
+        error.debugLogInfo ?? error.message ?? "Something went wrong"
+      );
+      callback({
+        code: error.code ?? import_grpc_js3.status.INTERNAL,
+        message: error.details ?? error.message ?? "Something went wrong"
+      });
+    });
+  };
 }
 
+// src/routing/RoutingUtilities.ts
 function wrapFunctionsAsync(functions, routerType) {
-    const modifiedFunctions = {};
-    Object.keys(functions).forEach(key => {
-        modifiedFunctions[key] = wrapRouterGrpcFunction(functions[key], routerType);
-    });
-    return modifiedFunctions;
+  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,
-            },
-        };
-    }
-}
+// src/routing/RoutingManager.ts
+var import_grpc_sdk7 = require("@conduitplatform/grpc-sdk");
+var RoutingManager = class _RoutingManager {
+  constructor(_router, _server) {
+    this._router = _router;
+    this._server = _server;
+    if (_router instanceof import_grpc_sdk7.Admin) {
+      this.isAdmin = true;
+    }
+  }
+  _moduleRoutes = {};
+  static ClientController;
+  static AdminController;
+  _routeHandlers = {};
+  isAdmin = false;
+  get(path4) {
+    return new RouteBuilder(this).method(import_grpc_sdk7.ConduitRouteActions.GET).path(path4);
+  }
+  post(path4) {
+    return new RouteBuilder(this).method(import_grpc_sdk7.ConduitRouteActions.POST).path(path4);
+  }
+  delete(path4) {
+    return new RouteBuilder(this).method(import_grpc_sdk7.ConduitRouteActions.DELETE).path(path4);
+  }
+  update(path4) {
+    return new RouteBuilder(this).method(import_grpc_sdk7.ConduitRouteActions.UPDATE).path(path4);
+  }
+  patch(path4) {
+    return new RouteBuilder(this).method(import_grpc_sdk7.ConduitRouteActions.PATCH).path(path4);
+  }
+  clear() {
+    this._moduleRoutes = {};
+    this._routeHandlers = {};
+  }
+  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;
+  }
+  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(path4) {
+    path4 = path4.replace(/[-:]/g, "/");
+    return path4.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" || option === "errors") continue;
+      if (typeof routeObject.options[option] === "string" || routeObject.options[option] instanceof String)
+        continue;
+      if (typeof routeObject.options[option] === "boolean" || routeObject.options[option] instanceof Boolean)
+        continue;
+      routeObject.options[option] = JSON.stringify(routeObject.options[option]);
+    }
+    return routeObject;
+  }
+};
 
-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 grpcSdk.Admin) {
-            this.isAdmin = true;
-        }
-    }
-    get(path) {
-        return new RouteBuilder(this).method(grpcSdk.ConduitRouteActions.GET).path(path);
-    }
-    post(path) {
-        return new RouteBuilder(this).method(grpcSdk.ConduitRouteActions.POST).path(path);
-    }
-    delete(path) {
-        return new RouteBuilder(this).method(grpcSdk.ConduitRouteActions.DELETE).path(path);
-    }
-    update(path) {
-        return new RouteBuilder(this).method(grpcSdk.ConduitRouteActions.UPDATE).path(path);
-    }
-    patch(path) {
-        return new RouteBuilder(this).method(grpcSdk.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),
+// src/classes/ConduitServiceModule.ts
+var ConduitServiceModule = class {
+  _moduleName;
+  _serviceName;
+  _address;
+  // external address:port of service (LoadBalancer)
+  grpcServer;
+  events = new import_events.EventEmitter();
+  _serviceHealthState = import_grpc_sdk8.HealthCheckStatus.SERVING;
+  // default for health-agnostic modules
+  constructor(moduleName) {
+    this._moduleName = (0, import_lodash_es2.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 === import_grpc_sdk8.HealthCheckStatus.UNKNOWN && !init || state === import_grpc_sdk8.HealthCheckStatus.SERVICE_UNKNOWN) {
+      throw new Error(
+        `Cannot explicitly set gRPC health state to ${import_grpc_sdk8.HealthCheckStatus[state]}`
+      );
+    }
+    if (!init) {
+      import_grpc_sdk8.ConduitGrpcSdk.Metrics?.set(
+        "module_health_state",
+        state === import_grpc_sdk8.HealthCheckStatus.SERVING ? 1 : 0
+      );
+    }
+    if (init) {
+      this._serviceHealthState = state;
+      return;
+    }
+    if (this._serviceHealthState !== state) {
+      this._serviceHealthState = state;
+      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: import_grpc_sdk8.HealthCheckStatus.SERVICE_UNKNOWN
+      });
+    } else {
+      if (!this._registered) {
+        return callback(null, {
+          status: import_grpc_sdk8.HealthCheckResponse_ServingStatus.UNKNOWN
         });
-        this._moduleRoutes[routeObject.grpcFunction] = routeObject;
-        this._routeHandlers[routeObject.grpcFunction] = handler;
+      }
+      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: import_grpc_sdk8.HealthCheckStatus.SERVICE_UNKNOWN
+      });
+    } else {
+      this.events.on(
+        `grpc-health-change:${this._serviceName}`,
+        (status6) => {
+          call.write({
+            status: status6
+          });
+        }
+      );
+    }
+  }
+  /** Override to declare which resource types this module can export/import. Default: none. */
+  getExportableResources() {
+    return [];
+  }
+  /** Override to export resources. resourceTypes empty = export all. Default: empty. */
+  async exportResources(_resourceTypes) {
+    return {};
+  }
+  /** Override to import resources. Default: no-op. */
+  async importResources(_resources) {
+    return {};
+  }
+  getExportableResourcesHandler(_call, callback) {
+    try {
+      const resources = this.getExportableResources();
+      callback(null, { resources: JSON.stringify(resources) });
+    } catch (e) {
+      callback({ code: import_grpc_js4.status.INTERNAL, message: e.message });
     }
-    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;
+  }
+  async exportResourcesHandler(call, callback) {
+    try {
+      const resourceTypes = call.request.resourceTypes ?? [];
+      const data = await this.exportResources(resourceTypes);
+      callback(null, { data: JSON.stringify(data) });
+    } catch (e) {
+      callback({ code: import_grpc_js4.status.INTERNAL, message: e.message });
+    }
+  }
+  async importResourcesHandler(call, callback) {
+    try {
+      const data = JSON.parse(call.request.data);
+      const result = await this.importResources(data);
+      callback(null, { result: JSON.stringify(result) });
+    } catch (e) {
+      const err = e;
+      if (err instanceof SyntaxError) {
+        callback({
+          code: import_grpc_js4.status.INVALID_ARGUMENT,
+          message: "Invalid JSON in import data"
         });
-        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' || option === 'errors')
-                continue;
-            if (typeof routeObject.options[option] === 'string' ||
-                routeObject.options[option] instanceof String)
-                continue;
-            routeObject.options[option] = JSON.stringify(routeObject.options[option]);
-        }
-        return routeObject;
-    }
-}
+      } else {
+        callback({ code: import_grpc_js4.status.INTERNAL, message: err.message });
+      }
+    }
+  }
+  async addHealthCheckService() {
+    await this.grpcServer.addService(
+      import_path.default.resolve(__dirname, "./grpc_health_check.proto"),
+      "grpc.health.v1.Health",
+      {
+        Check: this.healthCheck.bind(this),
+        Watch: this.healthWatch.bind(this)
+      },
+      true
+    );
+  }
+  async addModuleService() {
+    await this.grpcServer.addService(
+      import_path.default.resolve(__dirname, "./module.proto"),
+      "conduit.module.v1.ConduitModule",
+      {
+        SetConfig: this.setConfig.bind(this),
+        GetExportableResources: this.getExportableResourcesHandler.bind(this),
+        ExportResources: this.exportResourcesHandler.bind(this),
+        ImportResources: this.importResourcesHandler.bind(this)
+      }
+    );
+    await this.grpcServer.addService(
+      import_path.default.resolve(__dirname, "./module.proto"),
+      "conduit.module.v1.ClientRouter",
+      {
+        Route: RoutingManager.ClientController.handleRequest.bind(
+          RoutingManager.ClientController
+        ),
+        SocketRoute: RoutingManager.ClientController.handleRequest.bind(
+          RoutingManager.ClientController
+        )
+      }
+    );
+    await this.grpcServer.addService(
+      import_path.default.resolve(__dirname, "./module.proto"),
+      "conduit.module.v1.AdminRouter",
+      {
+        Route: RoutingManager.AdminController.handleRequest.bind(
+          RoutingManager.AdminController
+        ),
+        SocketRoute: RoutingManager.AdminController.handleRequest.bind(
+          RoutingManager.AdminController
+        )
+      }
+    );
+  }
+};
 
-const __filename$2 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
-const __dirname$2 = path.dirname(__filename$2);
-class ConduitServiceModule {
-    _moduleName;
-    _serviceName;
-    _address; // external address:port of service (LoadBalancer)
-    grpcServer;
-    events = new events.EventEmitter();
-    _serviceHealthState = grpcSdk.HealthCheckStatus.SERVING; // default for health-agnostic modules
-    constructor(moduleName) {
-        this._moduleName = lodash.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 === grpcSdk.HealthCheckStatus.UNKNOWN && !init) ||
-            state === grpcSdk.HealthCheckStatus.SERVICE_UNKNOWN) {
-            throw new Error(`Cannot explicitly set gRPC health state to ${grpcSdk.HealthCheckStatus[state]}`);
-        }
-        if (!init) {
-            grpcSdk.ConduitGrpcSdk.Metrics?.set('module_health_state', state === grpcSdk.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: grpcSdk.HealthCheckStatus.SERVICE_UNKNOWN,
-            });
-        }
-        else {
-            if (!this._registered) {
-                return callback(null, {
-                    status: grpcSdk.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: grpcSdk.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$2, './grpc_health_check.proto'), 'grpc.health.v1.Health', {
-            Check: this.healthCheck.bind(this),
-            Watch: this.healthWatch.bind(this),
-        }, true);
-    }
-    async addModuleService() {
-        await this.grpcServer.addService(path.resolve(__dirname$2, './module.proto'), 'conduit.module.v1.ConduitModule', {
-            SetConfig: this.setConfig.bind(this),
-        });
-        await this.grpcServer.addService(path.resolve(__dirname$2, './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$2, './module.proto'), 'conduit.module.v1.AdminRouter', {
-            Route: RoutingManager.AdminController.handleRequest.bind(RoutingManager.AdminController),
-            SocketRoute: RoutingManager.AdminController.handleRequest.bind(RoutingManager.AdminController),
-        });
-    }
-}
+// src/classes/ConfigController.ts
+var ConfigController = class _ConfigController {
+  static instance;
+  _config;
+  get config() {
+    return Object.assign({}, this._config);
+  }
+  set config(config) {
+    this._config = config;
+  }
+  static getInstance() {
+    if (!_ConfigController.instance) {
+      _ConfigController.instance = new _ConfigController();
+    }
+    return _ConfigController.instance;
+  }
+};
 
-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;
-    }
-}
+// src/ManagedModule.ts
+var import_lodash_es6 = require("lodash-es");
+var import_grpc_js6 = require("@grpc/grpc-js");
+var import_convict = __toESM(require("convict"), 1);
 
-exports.ModuleLifecycleStage = void 0;
-(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";
-})(exports.ModuleLifecycleStage || (exports.ModuleLifecycleStage = {}));
+// src/interfaces/ModuleLifecycleStage.ts
+var ModuleLifecycleStage = /* @__PURE__ */ ((ModuleLifecycleStage2) => {
+  ModuleLifecycleStage2["CREATE_GRPC"] = "creat-grpc-server";
+  ModuleLifecycleStage2["PRE_SERVER_START"] = "pre-grpc-start";
+  ModuleLifecycleStage2["SERVER_STARTED"] = "grpc-server-started";
+  ModuleLifecycleStage2["PRE_REGISTER"] = "pre-register";
+  ModuleLifecycleStage2["POST_REGISTER"] = "post-register";
+  return ModuleLifecycleStage2;
+})(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);
-    }
+// src/ManagedModule.ts
+var import_grpc_sdk14 = require("@conduitplatform/grpc-sdk");
+
+// src/utilities/initializeSdk.ts
+var import_grpc_sdk13 = require("@conduitplatform/grpc-sdk");
+
+// src/logging/index.ts
+var import_grpc_sdk9 = require("@conduitplatform/grpc-sdk");
+var import_winston = __toESM(require("winston"), 1);
+var import_lodash_es3 = require("lodash-es");
+var import_http = require("http");
+var import_winston_loki = __toESM(require("winston-loki"), 1);
+
+// src/utilities/linearBackoffTimeout.ts
+var import_timers = require("timers");
+function linearBackoffTimeout(onTry, delay, reps, onFailure) {
+  const nextRep = () => reps === void 0 || --reps > 0;
+  let stopSignal = false;
+  const stop = () => {
+    stopSignal = true;
+  };
+  let timeout;
+  const invoker = async () => {
+    if (stopSignal) {
+      return timeout ? (0, import_timers.clearTimeout)(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) {
+        (0, import_timers.clearTimeout)(timeout);
+        timeout = null;
+      }
+    }
+  };
+}
+async function linearBackoffTimeoutAsync(onTry, delay, reps, onFailure, startNow = false) {
+  const nextRep = () => reps === void 0 || --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);
+}
+
+// src/logging/index.ts
+var processMeta = (meta) => {
+  if (Array.isArray(meta)) {
+    return meta.reduce(
+      (message, meta2) => `${message} 
+  ${JSON.stringify(meta2, null, 2)}`,
+      ""
+    );
+  } else {
+    return JSON.stringify(meta, null, 2);
+  }
 };
-const createFormat = (logMeta = true) => {
-    return winston.format.combine(winston.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} ${!lodash.isEmpty(info.meta) ? processMeta(info.meta) : ''}`;
-        }
-        else {
-            return `[${info.timestamp}] [${info.level.toUpperCase()}]: ${info.message}`;
-        }
-    }));
+var createFormat = (logMeta = true) => {
+  return import_winston.format.combine(
+    import_winston.format.printf((info) => {
+      if (info.stack) {
+        return `[${info.timestamp}] [${info.level.toUpperCase()}]: ${info.message} ${info.stack}`;
+      }
+      if (logMeta) {
+        return `[${info.timestamp}] [${info.level.toUpperCase()}]: ${info.message} ${!(0, import_lodash_es3.isEmpty)(info.meta) ? processMeta(info.meta) : ""}`;
+      } else {
+        return `[${info.timestamp}] [${info.level.toUpperCase()}]: ${info.message}`;
+      }
+    })
+  );
 };
-const defaultTransport = new winston.transports.Console({
-    level: 'debug',
-    format: winston.format.combine(winston.format.prettyPrint(), winston.format.errors({ stack: true }), winston.format.timestamp({
-        format: 'YYYY-MM-DD HH:mm:ss',
-    }), createFormat(false), winston.format.colorize({
-        all: true,
-    })),
+var defaultTransport = new import_winston.default.transports.Console({
+  level: "debug",
+  format: import_winston.format.combine(
+    import_winston.format.prettyPrint(),
+    import_winston.format.errors({ stack: true }),
+    import_winston.format.timestamp({
+      format: "YYYY-MM-DD HH:mm:ss"
+    }),
+    createFormat(false),
+    import_winston.format.colorize({
+      all: true
+    })
+  )
 });
-class ConduitLogger {
-    _winston;
-    constructor(transports) {
-        this._winston = winston.createLogger({
-            format: winston.format.combine(winston.format.prettyPrint(), winston.format.errors({ stack: true }), winston.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);
-    }
-}
+var ConduitLogger = class {
+  _winston;
+  constructor(transports) {
+    this._winston = import_winston.default.createLogger({
+      format: import_winston.format.combine(
+        import_winston.format.prettyPrint(),
+        import_winston.format.errors({ stack: true }),
+        import_winston.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") {
+    return this._winston.log(level, message);
+  }
+  logObject(object, message = "", level = "info") {
+    return this._winston.log(level, message, object);
+  }
+  info(message) {
+    return this._winston.info(message);
+  }
+  warn(message) {
+    return this._winston.warn(message);
+  }
+  error(message, error) {
+    if (typeof message === "object") {
+      return this._winston.error(message);
+    }
+    return this._winston.error(message, error);
+  }
+  http(message) {
+    return this._winston.http(message);
+  }
+  verbose(message) {
+    return this._winston.verbose(message);
+  }
+};
 async function lokiReadyCheck(lokiUrl) {
-    return new Promise((resolve, reject) => {
-        const data = [];
-        http.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);
-        });
+  return new Promise((resolve, reject) => {
+    const data = [];
+    (0, import_http.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(() => {
-                grpcSdk.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 = () => {
-            grpcSdk.ConduitGrpcSdk.Logger.error(`Failed to connect to Loki on '${lokiUrl}'`);
-        };
-        await linearBackoffTimeoutAsync(onTry, 250, 15, onFailure, true);
-    }
+async function setupLoki(module2, 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(() => {
+        import_grpc_sdk9.ConduitGrpcSdk.Logger.addTransport(
+          new import_winston_loki.default({
+            level: "debug",
+            host: lokiUrl,
+            batching: false,
+            replaceTimestamp: true,
+            labels: {
+              module: module2,
+              instance,
+              ...process.env.CONDUIT_NAMESPACE && {
+                namespace: process.env.CONDUIT_NAMESPACE
+              }
+            }
+          })
+        );
+        return false;
+      }).catch(() => true);
+    };
+    const onFailure = () => {
+      import_grpc_sdk9.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 port = this.getHttpPort();
-        const url = '0.0.0.0:' + port.toString();
-        const server = http.createServer(this.requestHandler.bind(this));
-        server.listen(port, () => {
-            grpcSdk.ConduitGrpcSdk.Logger.info(`Metrics server listening on: ${url}`);
-        });
-        return server;
-    }
-    async requestHandler(req, res) {
-        if (req.url === '/' && req.method === 'GET') {
-            res.writeHead(200, { 'Content-Type': 'text/plain' });
-            res.end(`Conduit Metrics for module: ${this.moduleName}, instance: ${this.instance}`);
-        }
-        else if (req.url === '/metrics' && req.method === 'GET') {
-            const metrics = await this.Registry.metrics();
-            res.writeHead(200, { 'Content-Type': 'text/plain' });
-            res.end(metrics);
-        }
-        else {
-            res.writeHead(404, { 'Content-Type': 'text/plain' });
-            res.end('Not Found');
-        }
-    }
-    getHttpPort() {
-        const value = process.env['METRICS_PORT'];
-        if (!value) {
-            grpcSdk.ConduitGrpcSdk.Logger.error(`Metrics HTTP port not set`);
-            process.exit(-1);
-        }
-        const port = parseInt(value, 10);
-        if (lodash.isNaN(port) || port < 1 || port > 65535) {
-            grpcSdk.ConduitGrpcSdk.Logger.error(`Invalid HTTP port value: ${port}`);
-            process.exit(-1);
-        }
-        return port;
-    }
-}
+// src/utilities/initializeSdk.ts
+var import_winston2 = __toESM(require("winston"), 1);
+var import_path2 = __toESM(require("path"), 1);
 
-var defaultMetrics = {
-    internalGrpcRequests: {
-        type: grpcSdk.MetricType.Counter,
-        config: {
-            name: 'internal_grpc_requests_total',
-            help: "Tracks the total number of Conduit's internal gRPC requests",
-        },
-    },
-    clientGrpcRequests: {
-        type: grpcSdk.MetricType.Counter,
-        config: {
-            name: 'client_grpc_requests_total',
-            help: 'Tracks the total number of the client gRPC requests',
-        },
-    },
-    adminGrpcRequests: {
-        type: grpcSdk.MetricType.Counter,
-        config: {
-            name: 'admin_grpc_requests_total',
-            help: 'Tracks the total number of the admin gRPC requests',
-        },
-    },
-    clientGrpcErrors: {
-        type: grpcSdk.MetricType.Counter,
-        config: {
-            name: 'client_grpc_errors_total',
-            help: 'Tracks the total number of client grpc errors',
-        },
-    },
-    adminGrpcErrors: {
-        type: grpcSdk.MetricType.Counter,
-        config: {
-            name: 'admin_grpc_errors_total',
-            help: 'Tracks the total number of admin grpc errors',
-        },
-    },
-    moduleHealthState: {
-        type: grpcSdk.MetricType.Gauge,
-        config: {
-            name: 'module_health_state',
-            help: 'Tracks the health state of the module',
-        },
-    },
-    grpcRequestLatency: {
-        type: grpcSdk.MetricType.Gauge,
-        config: {
-            name: 'grpc_request_latency_seconds',
-            help: 'Tracks the latency of grpc requests in seconds',
-        },
-    },
-    adminGrpcRequestLatency: {
-        type: grpcSdk.MetricType.Gauge,
-        config: {
-            name: 'admin_grpc_request_latency_seconds',
-            help: 'Tracks the latency of admin grpc requests in seconds',
-        },
-    },
-    clientGrpcRequestLatency: {
-        type: grpcSdk.MetricType.Gauge,
-        config: {
-            name: 'client_grpc_request_latency_seconds',
-            help: 'Tracks the latency of client grpc requests in seconds',
-        },
-    },
-    grpcResponseStatuses: {
-        type: grpcSdk.MetricType.Counter,
-        config: {
-            name: 'grpc_response_statuses_total',
-            help: 'Tracks the total number of grpc response codes',
-            labelNames: ['success'],
-        },
-    },
-    adminGrpcResponseStatuses: {
-        type: grpcSdk.MetricType.Counter,
-        config: {
-            name: 'admin_grpc_response_statuses_total',
-            help: 'Tracks the total number of admin grpc response codes',
-            labelNames: ['success'],
-        },
-    },
-    clientGrpcResponseStatuses: {
-        type: grpcSdk.MetricType.Counter,
-        config: {
-            name: 'client_grpc_response_statuses_total',
-            help: 'Tracks the total number  of client grpc response codes',
-            labelNames: ['success'],
-        },
-    },
+// src/metrics/index.ts
+var import_prom_client = require("prom-client");
+
+// src/metrics/MetricsServer.ts
+var import_http2 = require("http");
+var import_lodash_es4 = require("lodash-es");
+var import_grpc_sdk10 = require("@conduitplatform/grpc-sdk");
+var MetricsServer = class {
+  moduleName;
+  instance;
+  Registry;
+  constructor(moduleName, instance, registry2) {
+    this.moduleName = moduleName;
+    this.instance = instance;
+    this.Registry = registry2;
+  }
+  initialize() {
+    const port = this.getHttpPort();
+    const url = "0.0.0.0:" + port.toString();
+    const server = (0, import_http2.createServer)(this.requestHandler.bind(this));
+    server.listen(port, () => {
+      import_grpc_sdk10.ConduitGrpcSdk.Logger.info(`Metrics server listening on: ${url}`);
+    });
+    return server;
+  }
+  async requestHandler(req, res) {
+    if (req.url === "/" && req.method === "GET") {
+      res.writeHead(200, { "Content-Type": "text/plain" });
+      res.end(
+        `Conduit Metrics for module: ${this.moduleName}, instance: ${this.instance}`
+      );
+    } else if (req.url === "/metrics" && req.method === "GET") {
+      const metrics = await this.Registry.metrics();
+      res.writeHead(200, { "Content-Type": "text/plain" });
+      res.end(metrics);
+    } else {
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("Not Found");
+    }
+  }
+  getHttpPort() {
+    const value = process.env["METRICS_PORT"];
+    if (!value) {
+      import_grpc_sdk10.ConduitGrpcSdk.Logger.error(`Metrics HTTP port not set`);
+      process.exit(-1);
+    }
+    const port = parseInt(value, 10);
+    if ((0, import_lodash_es4.isNaN)(port) || port < 1 || port > 65535) {
+      import_grpc_sdk10.ConduitGrpcSdk.Logger.error(`Invalid HTTP port value: ${port}`);
+      process.exit(-1);
+    }
+    return port;
+  }
 };
 
-const METRICS_PREFIX = 'cnd_';
-class ConduitMetrics {
-    moduleName;
-    instance;
-    _registry;
-    _httpServer;
-    constructor(moduleName, instance) {
-        this.moduleName = moduleName;
-        this.instance = instance;
-        this._registry = new promClient.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();
-    }
-    get registry() {
-        return this._registry;
-    }
-    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 grpcSdk.MetricType.Counter:
-                this.createCounter(metricConfig);
-                break;
-            case grpcSdk.MetricType.Gauge:
-                this.createGauge(metricConfig);
-                break;
-            case grpcSdk.MetricType.Histogram:
-                this.createHistogram(metricConfig);
-                break;
-            case grpcSdk.MetricType.Summary:
-                this.createSummary(metricConfig);
-                break;
-        }
-    }
-    collectDefaultMetrics() {
-        promClient.collectDefaultMetrics({
-            register: this._registry,
-            prefix: METRICS_PREFIX,
-            // probably not needed
-            labels: {
-                module_name: this.moduleName,
-                instance_instance: this.instance,
-            },
-        });
-    }
-    createCounter(config) {
-        return new promClient.Counter({
-            ...config,
-            name: this.addPrefix(config.name),
-            registers: [this._registry],
-        });
-    }
-    createSummary(config) {
-        return new promClient.Summary({
-            ...config,
-            name: this.addPrefix(config.name),
-            registers: [this._registry],
-        });
-    }
-    createHistogram(config) {
-        return new promClient.Histogram({
-            ...config,
-            name: this.addPrefix(config.name),
-            registers: [this._registry],
-        });
-    }
-    createGauge(config) {
-        return new promClient.Gauge({
-            ...config,
-            name: this.addPrefix(config.name),
-            registers: [this._registry],
-        });
-    }
-    getMetric(name) {
-        return this._registry.getSingleMetric(this.addPrefix(name));
-    }
-    increment(metric, increment = 1, labels) {
-        const metricInstance = this.getMetric(metric);
-        if (!(metricInstance instanceof promClient.Counter) && !(metricInstance instanceof promClient.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.getMetric(metric);
-        if (!(metricInstance instanceof promClient.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.getMetric(metric);
-        if (!(metricInstance instanceof promClient.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.getMetric(metric);
-        if (!(metricInstance instanceof promClient.Histogram) && !(metricInstance instanceof promClient.Summary)) {
-            throw new Error(`Metric ${metric} is not a Histogram`);
-        }
-        return labels
-            ? metricInstance.labels({ ...labels }).observe(value)
-            : metricInstance.observe(value);
-    }
-    addPrefix(metric) {
-        if (!metric.includes(METRICS_PREFIX)) {
-            return `${METRICS_PREFIX}${metric}`;
-        }
-        return metric;
-    }
-}
+// src/metrics/config/defaults.ts
+var import_grpc_sdk11 = require("@conduitplatform/grpc-sdk");
+var defaults_default = {
+  internalGrpcRequests: {
+    type: import_grpc_sdk11.MetricType.Counter,
+    config: {
+      name: "internal_grpc_requests_total",
+      help: "Tracks the total number of Conduit's internal gRPC requests"
+    }
+  },
+  clientGrpcRequests: {
+    type: import_grpc_sdk11.MetricType.Counter,
+    config: {
+      name: "client_grpc_requests_total",
+      help: "Tracks the total number of the client gRPC requests"
+    }
+  },
+  adminGrpcRequests: {
+    type: import_grpc_sdk11.MetricType.Counter,
+    config: {
+      name: "admin_grpc_requests_total",
+      help: "Tracks the total number of the admin gRPC requests"
+    }
+  },
+  clientGrpcErrors: {
+    type: import_grpc_sdk11.MetricType.Counter,
+    config: {
+      name: "client_grpc_errors_total",
+      help: "Tracks the total number of client grpc errors"
+    }
+  },
+  adminGrpcErrors: {
+    type: import_grpc_sdk11.MetricType.Counter,
+    config: {
+      name: "admin_grpc_errors_total",
+      help: "Tracks the total number of admin grpc errors"
+    }
+  },
+  moduleHealthState: {
+    type: import_grpc_sdk11.MetricType.Gauge,
+    config: {
+      name: "module_health_state",
+      help: "Tracks the health state of the module"
+    }
+  },
+  grpcRequestLatency: {
+    type: import_grpc_sdk11.MetricType.Gauge,
+    config: {
+      name: "grpc_request_latency_seconds",
+      help: "Tracks the latency of grpc requests in seconds"
+    }
+  },
+  adminGrpcRequestLatency: {
+    type: import_grpc_sdk11.MetricType.Gauge,
+    config: {
+      name: "admin_grpc_request_latency_seconds",
+      help: "Tracks the latency of admin grpc requests in seconds"
+    }
+  },
+  clientGrpcRequestLatency: {
+    type: import_grpc_sdk11.MetricType.Gauge,
+    config: {
+      name: "client_grpc_request_latency_seconds",
+      help: "Tracks the latency of client grpc requests in seconds"
+    }
+  },
+  grpcResponseStatuses: {
+    type: import_grpc_sdk11.MetricType.Counter,
+    config: {
+      name: "grpc_response_statuses_total",
+      help: "Tracks the total number of grpc response codes",
+      labelNames: ["success"]
+    }
+  },
+  adminGrpcResponseStatuses: {
+    type: import_grpc_sdk11.MetricType.Counter,
+    config: {
+      name: "admin_grpc_response_statuses_total",
+      help: "Tracks the total number of admin grpc response codes",
+      labelNames: ["success"]
+    }
+  },
+  clientGrpcResponseStatuses: {
+    type: import_grpc_sdk11.MetricType.Counter,
+    config: {
+      name: "client_grpc_response_statuses_total",
+      help: "Tracks the total number  of client grpc response codes",
+      labelNames: ["success"]
+    }
+  }
+};
+
+// src/metrics/index.ts
+var import_grpc_sdk12 = require("@conduitplatform/grpc-sdk");
+var METRICS_PREFIX = "cnd_";
+var ConduitMetrics = class {
+  moduleName;
+  instance;
+  _registry;
+  _httpServer;
+  constructor(moduleName, instance) {
+    this.moduleName = moduleName;
+    this.instance = instance;
+    this._registry = new import_prom_client.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();
+  }
+  get registry() {
+    return this._registry;
+  }
+  initializeDefaultMetrics() {
+    for (const metric of Object.values(defaults_default)) {
+      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 import_grpc_sdk12.MetricType.Counter:
+        this.createCounter(metricConfig);
+        break;
+      case import_grpc_sdk12.MetricType.Gauge:
+        this.createGauge(metricConfig);
+        break;
+      case import_grpc_sdk12.MetricType.Histogram:
+        this.createHistogram(metricConfig);
+        break;
+      case import_grpc_sdk12.MetricType.Summary:
+        this.createSummary(metricConfig);
+        break;
+    }
+  }
+  collectDefaultMetrics() {
+    (0, import_prom_client.collectDefaultMetrics)({
+      register: this._registry,
+      prefix: METRICS_PREFIX,
+      // probably not needed
+      labels: {
+        module_name: this.moduleName,
+        instance_instance: this.instance
+      }
+    });
+  }
+  createCounter(config) {
+    return new import_prom_client.Counter({
+      ...config,
+      name: this.addPrefix(config.name),
+      registers: [this._registry]
+    });
+  }
+  createSummary(config) {
+    return new import_prom_client.Summary({
+      ...config,
+      name: this.addPrefix(config.name),
+      registers: [this._registry]
+    });
+  }
+  createHistogram(config) {
+    return new import_prom_client.Histogram({
+      ...config,
+      name: this.addPrefix(config.name),
+      registers: [this._registry]
+    });
+  }
+  createGauge(config) {
+    return new import_prom_client.Gauge({
+      ...config,
+      name: this.addPrefix(config.name),
+      registers: [this._registry]
+    });
+  }
+  getMetric(name) {
+    return this._registry.getSingleMetric(this.addPrefix(name));
+  }
+  increment(metric, increment = 1, labels) {
+    const metricInstance = this.getMetric(metric);
+    if (!(metricInstance instanceof import_prom_client.Counter) && !(metricInstance instanceof import_prom_client.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.getMetric(metric);
+    if (!(metricInstance instanceof import_prom_client.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.getMetric(metric);
+    if (!(metricInstance instanceof import_prom_client.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.getMetric(metric);
+    if (!(metricInstance instanceof import_prom_client.Histogram) && !(metricInstance instanceof import_prom_client.Summary)) {
+      throw new Error(`Metric ${metric} is not a Histogram`);
+    }
+    return labels ? metricInstance.labels({ ...labels }).observe(value) : metricInstance.observe(value);
+  }
+  addPrefix(metric) {
+    if (!metric.includes(METRICS_PREFIX)) {
+      return `${METRICS_PREFIX}${metric}`;
+    }
+    return metric;
+  }
+};
 
-// Forked from nice-grpc-prometheus
-const registry = new promClient.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 = promClient.exponentialBuckets(0.001, 4, 12);
+// src/metrics/clientMiddleware.ts
+var import_abort_controller_x = require("abort-controller-x");
+var import_nice_grpc_common = require("nice-grpc-common");
+var import_prom_client2 = require("prom-client");
+var registry = new import_prom_client2.Registry();
+var typeLabel = "grpc_type";
+var serviceLabel = "grpc_service";
+var methodLabel = "grpc_method";
+var pathLabel = "grpc_path";
+var codeLabel = "grpc_code";
+var latencySecondsBuckets = (0, import_prom_client2.exponentialBuckets)(1e-3, 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,
-    };
+  const callType = method.requestStream ? method.responseStream ? "bidi_stream" : "client_stream" : method.responseStream ? "server_stream" : "unary";
+  const { path: path4 } = method;
+  const [serviceName, methodName] = path4.split("/").slice(1);
+  return {
+    [typeLabel]: callType,
+    [serviceLabel]: serviceName,
+    [methodLabel]: methodName,
+    [pathLabel]: path4
+  };
 }
 async function* incrementStreamMessagesCounter(iterable, counter) {
-    for await (const item of iterable) {
-        counter.inc();
-        yield item;
-    }
+  for await (const item of iterable) {
+    counter.inc();
+    yield item;
+  }
 }
-const clientStartedMetric = new promClient.Counter({
-    registers: [registry],
-    name: 'cnd_grpc_client_started_total',
-    help: 'Total number of RPCs started on the client.',
-    labelNames: [typeLabel, serviceLabel, methodLabel, pathLabel],
+var clientStartedMetric = new import_prom_client2.Counter({
+  registers: [registry],
+  name: "cnd_grpc_client_started_total",
+  help: "Total number of RPCs started on the client.",
+  labelNames: [typeLabel, serviceLabel, methodLabel, pathLabel]
 });
-const clientHandledMetric = new promClient.Counter({
-    registers: [registry],
-    name: 'cnd_grpc_client_handled_total',
-    help: 'Total number of RPCs completed on the client, regardless of success or failure.',
-    labelNames: [typeLabel, serviceLabel, methodLabel, pathLabel, codeLabel],
+var clientHandledMetric = new import_prom_client2.Counter({
+  registers: [registry],
+  name: "cnd_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 promClient.Counter({
-    registers: [registry],
-    name: 'cnd_grpc_client_msg_received_total',
-    help: 'Total number of RPC stream messages received by the client.',
-    labelNames: [typeLabel, serviceLabel, methodLabel, pathLabel],
+var clientStreamMsgReceivedMetric = new import_prom_client2.Counter({
+  registers: [registry],
+  name: "cnd_grpc_client_msg_received_total",
+  help: "Total number of RPC stream messages received by the client.",
+  labelNames: [typeLabel, serviceLabel, methodLabel, pathLabel]
 });
-const clientStreamMsgSentMetric = new promClient.Counter({
-    registers: [registry],
-    name: 'cnd_grpc_client_msg_sent_total',
-    help: 'Total number of gRPC stream messages sent by the client.',
-    labelNames: [typeLabel, serviceLabel, methodLabel, pathLabel],
+var clientStreamMsgSentMetric = new import_prom_client2.Counter({
+  registers: [registry],
+  name: "cnd_grpc_client_msg_sent_total",
+  help: "Total number of gRPC stream messages sent by the client.",
+  labelNames: [typeLabel, serviceLabel, methodLabel, pathLabel]
 });
-const clientHandlingSecondsMetric = new promClient.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,
+var clientHandlingSecondsMetric = new import_prom_client2.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 = niceGrpcCommon.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 niceGrpcCommon.ClientError) {
-                status = err.code;
-            }
-            else if (abortControllerX.isAbortError(err)) {
-                status = niceGrpcCommon.Status.ABORTED;
-            }
-            else {
-                status = niceGrpcCommon.Status.UNKNOWN;
-            }
-            throw err;
-        }
-        finally {
-            if (!settled) {
-                status = niceGrpcCommon.Status.CANCELLED;
-            }
-            stopTimer({ [codeLabel]: niceGrpcCommon.Status[status] });
-            clientHandledMetric.inc({
-                ...labels,
-                [codeLabel]: niceGrpcCommon.Status[status],
-            });
-        }
-    };
+  return async function* prometheusClientMiddlewareGenerator(call, options) {
+    const labels = getLabels(call.method);
+    clientStartedMetric.inc(labels);
+    const stopTimer = clientHandlingSecondsMetric.startTimer(labels);
+    let settled = false;
+    let status6 = import_nice_grpc_common.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 import_nice_grpc_common.ClientError) {
+        status6 = err.code;
+      } else if ((0, import_abort_controller_x.isAbortError)(err)) {
+        status6 = import_nice_grpc_common.Status.ABORTED;
+      } else {
+        status6 = import_nice_grpc_common.Status.UNKNOWN;
+      }
+      throw err;
+    } finally {
+      if (!settled) {
+        status6 = import_nice_grpc_common.Status.CANCELLED;
+      }
+      stopTimer({ [codeLabel]: import_nice_grpc_common.Status[status6] });
+      clientHandledMetric.inc({
+        ...labels,
+        [codeLabel]: import_nice_grpc_common.Status[status6]
+      });
+    }
+  };
 }
 
-const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
-const __dirname$1 = path.dirname(__filename$1);
-const initializeSdk = (coreUrl, moduleName, watchModules = true, serviceHealthStatusGetter = () => grpcSdk.HealthCheckStatus.SERVING) => {
-    let logger;
-    try {
-        logger = new ConduitLogger([
-            new winston.transports.File({
-                filename: path.join(__dirname$1, '.logs/combined.log'),
-                level: 'info',
-            }),
-            new winston.transports.File({
-                filename: path.join(__dirname$1, '.logs/errors.log'),
-                level: 'error',
-            }),
-        ]);
-    }
-    catch (e) {
-        logger = new ConduitLogger();
-    }
-    const grpcSdk$1 = new grpcSdk.ConduitGrpcSdk(coreUrl, moduleName, watchModules, logger, serviceHealthStatusGetter);
-    setupLoki(grpcSdk$1.name, grpcSdk$1.instance).then();
-    if (process.env.METRICS_PORT) {
-        grpcSdk.ConduitGrpcSdk.Metrics = new ConduitMetrics(grpcSdk$1.name, grpcSdk$1.instance);
-        grpcSdk$1.addMiddleware(clientMiddleware());
-    }
-    return grpcSdk$1;
+// src/utilities/initializeSdk.ts
+var initializeSdk = (coreUrl, moduleName, watchModules = true, serviceHealthStatusGetter = () => import_grpc_sdk13.HealthCheckStatus.SERVING) => {
+  let logger;
+  try {
+    logger = new ConduitLogger([
+      new import_winston2.default.transports.File({
+        filename: import_path2.default.join(__dirname, ".logs/combined.log"),
+        level: "info"
+      }),
+      new import_winston2.default.transports.File({
+        filename: import_path2.default.join(__dirname, ".logs/errors.log"),
+        level: "error"
+      })
+    ]);
+  } catch (e) {
+    logger = new ConduitLogger();
+  }
+  const grpcSdk = new import_grpc_sdk13.ConduitGrpcSdk(
+    coreUrl,
+    moduleName,
+    watchModules,
+    logger,
+    serviceHealthStatusGetter
+  );
+  setupLoki(grpcSdk.name, grpcSdk.instance).then();
+  if (process.env.METRICS_PORT) {
+    import_grpc_sdk13.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 ? timers.clearTimeout(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) {
-                timers.clearTimeout(timeout);
-                timeout = null;
-            }
-        },
-    };
+// src/utilities/merge.ts
+var import_lodash_es5 = require("lodash-es");
+function merge(objA, objB) {
+  const customizer = (objValue, srcValue) => {
+    if (Array.isArray(objValue)) {
+      return srcValue;
+    }
+  };
+  return (0, import_lodash_es5.mergeWith)({}, objA, objB, customizer);
 }
-/**
- * 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);
+
+// src/utilities/exportHelpers.ts
+var DEFAULT_STRIP_FIELDS = ["_id", "createdAt", "updatedAt", "__v"];
+function stripInternalFields(obj, additionalFields = []) {
+  const strip = /* @__PURE__ */ new Set([...DEFAULT_STRIP_FIELDS, ...additionalFields]);
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (!strip.has(k)) out[k] = v;
+  }
+  return out;
+}
+function sanitizeDocumentsForExport(documents, options = {}) {
+  const exclude = options.excludeFields ?? [];
+  return documents.map((doc) => stripInternalFields(doc, exclude));
+}
+async function exportModel(adapter, options = {}) {
+  const { query, select, excludeFields, ...rest } = options;
+  const docs = await adapter.findMany(query ?? {}, select ? { select } : {});
+  return sanitizeDocumentsForExport(docs, { excludeFields, ...rest });
+}
+async function importModel(adapter, records, options = {}) {
+  const entry = { created: 0, updated: 0, failed: 0, errors: [] };
+  const keyField = adapter.keyField;
+  for (const record of records) {
+    const key = record[keyField];
+    if (key == null || key === "") {
+      entry.failed += 1;
+      entry.errors.push(`Missing or empty key "${keyField}" in record`);
+      continue;
+    }
+    try {
+      const existing = await adapter.findOne({ [keyField]: key });
+      const sanitized = stripInternalFields(record, options.excludeFields ?? []);
+      if (existing) {
+        await adapter.updateOne({ [keyField]: key }, sanitized);
+        entry.updated += 1;
+      } else {
+        await adapter.create(sanitized);
+        entry.created += 1;
+      }
+    } catch (err) {
+      entry.failed += 1;
+      entry.errors.push(`${String(key)}: ${err.message}`);
+    }
+  }
+  return entry;
 }
 
-function merge(objA, objB) {
-    const customizer = (objValue, srcValue) => {
-        if (Array.isArray(objValue)) {
-            // don't merge arrays
-            return srcValue;
-        }
-    };
-    return lodash.mergeWith({}, objA, objB, customizer);
+// src/utilities/conduitPeers.ts
+var import_node_fs = require("fs");
+var import_node_path = __toESM(require("path"), 1);
+function readConduitPeersManifest(moduleRootDir = process.cwd()) {
+  const pkgPath = import_node_path.default.join(moduleRootDir, "package.json");
+  if (!(0, import_node_fs.existsSync)(pkgPath)) return null;
+  try {
+    const pkg = JSON.parse((0, import_node_fs.readFileSync)(pkgPath, "utf8"));
+    if (!pkg.conduit?.peers) return null;
+    return pkg.conduit;
+  } catch (e) {
+    console.warn(`[conduitPeers] Failed to parse ${pkgPath}: ${e.message}`);
+    return null;
+  }
 }
 
-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;
+// src/utilities/convictConfigParser.ts
+var 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: grpcJs.status.NOT_FOUND,
-                message: 'Not found',
-            });
-        }
-    }
-    setRoutes(routes) {
-        this._routeHandlers = routes;
-    }
-}
+// src/routing/RoutingController.ts
+var import_grpc_js5 = require("@grpc/grpc-js");
+var RoutingController = class {
+  _routeHandlers = {};
+  handleRequest(call, callback) {
+    if (this._routeHandlers[call.request.functionName]) {
+      this._routeHandlers[call.request.functionName](call, callback);
+    } else {
+      callback({
+        code: import_grpc_js5.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 = exports.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) {
-            grpcSdk.ConduitGrpcSdk.Logger.error('Failed to initialize server');
-            grpcSdk.ConduitGrpcSdk.Logger.error(err);
-            process.exit(-1);
-        }
-        await this.postRegisterLifecycle().catch((err) => {
-            grpcSdk.ConduitGrpcSdk.Logger.error('Failed to activate module');
-            grpcSdk.ConduitGrpcSdk.Logger.error(err);
-            process.exit(-1);
+// src/ManagedModule.ts
+var ManagedModule = class extends ConduitServiceModule {
+  config;
+  configOverride = false;
+  service;
+  serviceAddress;
+  servicePort;
+  _moduleState;
+  _declaredPeerWatchDisposers = [];
+  _cachedPeersManifest;
+  _lastPeerBatchStates = {};
+  _peerManifestRoot;
+  _configInitialized = false;
+  _pendingConfigUpdates = [];
+  _processingConfig = false;
+  constructor(moduleName, peerManifestRoot) {
+    super(moduleName);
+    this._peerManifestRoot = peerManifestRoot;
+    this._moduleState = "creat-grpc-server" /* 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) {
+      import_grpc_sdk14.ConduitGrpcSdk.Logger.error("Failed to initialize server");
+      import_grpc_sdk14.ConduitGrpcSdk.Logger.error(err);
+      process.exit(-1);
+    }
+    await this.postRegisterLifecycle().catch((err) => {
+      import_grpc_sdk14.ConduitGrpcSdk.Logger.error("Failed to activate module");
+      import_grpc_sdk14.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 = (0, import_convict.default)(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 (import_grpc_sdk14.ConduitGrpcSdk.Metrics) {
+      import_grpc_sdk14.ConduitGrpcSdk.Metrics.initializeDefaultMetrics();
+      if (this.metricsSchema) {
+        Object.values(this.metricsSchema).forEach((metric) => {
+          import_grpc_sdk14.ConduitGrpcSdk.Metrics.registerMetric(metric.type, metric.config);
         });
-    }
-    /**
-     * 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 (grpcSdk.ConduitGrpcSdk.Metrics) {
-            grpcSdk.ConduitGrpcSdk.Metrics.initializeDefaultMetrics();
-            if (this.metricsSchema) {
-                Object.values(this.metricsSchema).forEach(metric => {
-                    grpcSdk.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();
-        grpcSdk.ConduitGrpcSdk.Logger.log('gRPC server listening on ' + this._port);
-    }
-    async setConfig(call, callback) {
-        try {
-            if (!this.config) {
-                return callback({
-                    code: grpcJs.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: grpcJs.status.INVALID_ARGUMENT,
-                    message: 'Invalid configuration values: ' + e.message,
-                });
-            }
-            ConfigController.getInstance().config = config;
-            await this.onConfig();
-            this.grpcSdk.bus?.publish(lodash.kebabCase(this.name) + ':config:update', JSON.stringify(config));
-        }
-        catch (e) {
-            return callback({ code: grpcJs.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(`${lodash.kebabCase(this.name)}:config:update`, async (message) => {
-            ConfigController.getInstance().config = await this.preConfig(JSON.parse(message));
-            await this.onConfig();
+      }
+    }
+  }
+  /**
+   * Initializes metric startup values.
+   * Implemented by individual modules.
+   */
+  async initializeMetrics() {
+  }
+  getPeerManifestRoot() {
+    return this._peerManifestRoot ?? process.cwd();
+  }
+  loadConduitPeersManifest() {
+    if (this._cachedPeersManifest === void 0) {
+      this._cachedPeersManifest = readConduitPeersManifest(this.getPeerManifestRoot());
+    }
+    return this._cachedPeersManifest;
+  }
+  validateDeclaredPeerNames(names) {
+    const known = new Set(this.grpcSdk.getKnownModuleNames());
+    for (const n of names) {
+      if (!known.has(n)) {
+        import_grpc_sdk14.ConduitGrpcSdk.Logger.warn(
+          `Declared Conduit peer "${n}" is not a known built-in module (see ConduitGrpcSdk.getKnownModuleNames).`
+        );
+      }
+    }
+  }
+  async awaitPeersFromManifest() {
+    const manifest = this.loadConduitPeersManifest();
+    const peers = manifest?.peers?.await;
+    if (!peers?.length) return;
+    this.validateDeclaredPeerNames(peers);
+    await Promise.all(peers.map((m) => this.grpcSdk.awaitPeer(m)));
+  }
+  registerDeclaredPeerWatches() {
+    this.disposeDeclaredPeerWatches();
+    const manifest = this.loadConduitPeersManifest();
+    const watch = manifest?.peers?.watch;
+    if (!watch?.length) return;
+    this.validateDeclaredPeerNames(watch.map((w) => w.module));
+    const specs = watch.map((entry) => ({
+      module: entry.module,
+      edge: entry.edge ?? "rising"
+    }));
+    const dispose = this.grpcSdk.watchPeers(
+      specs,
+      (statuses) => {
+        for (const [mod, s] of Object.entries(statuses)) {
+          if (this._lastPeerBatchStates[mod] !== s) {
+            this.onDeclaredPeerConnectionUpdate(mod, s);
+            this._lastPeerBatchStates[mod] = s;
+          }
+        }
+      },
+      { debounceMs: 100, syncInitialState: true }
+    );
+    this._declaredPeerWatchDisposers.push(dispose);
+  }
+  disposeDeclaredPeerWatches() {
+    for (const d of this._declaredPeerWatchDisposers) {
+      d();
+    }
+    this._declaredPeerWatchDisposers = [];
+    this._lastPeerBatchStates = {};
+  }
+  onDeclaredPeerConnectionUpdate(_moduleName, _serving) {
+  }
+  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();
+    import_grpc_sdk14.ConduitGrpcSdk.Logger.log("gRPC server listening on " + this._port);
+  }
+  async setConfig(call, callback) {
+    try {
+      if (!this.config) {
+        return callback({
+          code: import_grpc_js6.status.INVALID_ARGUMENT,
+          message: "Module is not configurable"
         });
-    }
-    async preRegisterLifecycle() {
-        await this.createGrpcServer();
-        this._moduleState = exports.ModuleLifecycleStage.PRE_SERVER_START;
-        await this.preServerStart();
-        await this.grpcSdk.initializeEventBus();
-        await this.handleConfigSyncUpdate();
-        await this.registerMetrics();
-        await this.startGrpcServer();
-        this._moduleState = exports.ModuleLifecycleStage.SERVER_STARTED;
-        await this.onServerStart();
-        await this.initializeMetrics();
-        this._moduleState = exports.ModuleLifecycleStage.PRE_REGISTER;
-        await this.preRegister();
-    }
-    async postRegisterLifecycle() {
-        this._moduleState = exports.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();
-        }
-    }
-}
-
-class ModuleError extends grpcSdk.GrpcError {
-    debugLogInfo;
-    constructor(errorDefinition, debugLogInfo) {
-        const { grpcCode, conduitCode, message } = errorDefinition;
-        super(grpcCode, JSON.stringify({
-            message,
-            conduitCode: conduitCode,
-        }));
-        if (debugLogInfo)
-            this.debugLogInfo = debugLogInfo;
-    }
-}
+      }
+      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 = (0, import_convict.default)(this.configSchema);
+        this.config.load(previousConfig);
+        return callback({
+          code: import_grpc_js6.status.INVALID_ARGUMENT,
+          message: "Invalid configuration values: " + e.message
+        });
+      }
+      const configJson = JSON.stringify(config);
+      this._pendingConfigUpdates.push(configJson);
+      await this._drainConfigQueue();
+      this.grpcSdk.bus?.publish((0, import_lodash_es6.kebabCase)(this.name) + ":config:update", configJson);
+    } catch (e) {
+      return callback({ code: import_grpc_js6.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(
+      `${(0, import_lodash_es6.kebabCase)(this.name)}:config:update`,
+      async (message) => {
+        this._pendingConfigUpdates.push(message);
+        await this._drainConfigQueue();
+      }
+    );
+  }
+  /** Serializes config updates; waits for initial lifecycle before draining. */
+  async _drainConfigQueue() {
+    if (!this._configInitialized || this._processingConfig) return;
+    this._processingConfig = true;
+    try {
+      while (this._pendingConfigUpdates.length > 0) {
+        const message = this._pendingConfigUpdates.shift();
+        ConfigController.getInstance().config = await this.preConfig(JSON.parse(message));
+        await this.onConfig();
+      }
+    } finally {
+      this._processingConfig = false;
+    }
+  }
+  async preRegisterLifecycle() {
+    await this.createGrpcServer();
+    this._moduleState = "pre-grpc-start" /* PRE_SERVER_START */;
+    await this.preServerStart();
+    await this.grpcSdk.initializeEventBus();
+    await this.handleConfigSyncUpdate();
+    await this.registerMetrics();
+    await this.startGrpcServer();
+    this._moduleState = "grpc-server-started" /* SERVER_STARTED */;
+    await this.onServerStart();
+    await this.initializeMetrics();
+    this._moduleState = "pre-register" /* PRE_REGISTER */;
+    await this.preRegister();
+  }
+  async postRegisterLifecycle() {
+    this._moduleState = "post-register" /* 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();
+    }
+    this._configInitialized = true;
+    await this._drainConfigQueue();
+  }
+};
 
-exports.ConduitActiveSchema = ConduitActiveSchema;
-exports.ConduitBoolean = ConduitBoolean;
-exports.ConduitDate = ConduitDate;
-exports.ConduitJson = ConduitJson;
-exports.ConduitNumber = ConduitNumber;
-exports.ConduitObjectId = ConduitObjectId;
-exports.ConduitRelation = ConduitRelation;
-exports.ConduitServiceModule = ConduitServiceModule;
-exports.ConduitString = ConduitString;
-exports.ConfigController = ConfigController;
-exports.GrpcServer = GrpcServer;
-exports.ManagedModule = ManagedModule;
-exports.ModuleError = ModuleError;
-exports.ProxyRouteBuilder = ProxyRouteBuilder;
-exports.RouteBuilder = RouteBuilder;
-exports.RoutingManager = RoutingManager;
-exports.addServiceToServer = addServiceToServer;
-exports.createParsedRouterRequest = createParsedRouterRequest;
-exports.createServer = createServer;
-exports.initializeSdk = initializeSdk;
-exports.linearBackoffTimeout = linearBackoffTimeout;
-exports.linearBackoffTimeoutAsync = linearBackoffTimeoutAsync;
-exports.merge = merge;
-exports.wrapFunctionsAsync = wrapFunctionsAsync;
-exports.wrapGrpcFunctions = wrapGrpcFunctions;
-exports.wrapRouterGrpcFunction = wrapRouterGrpcFunction;
-//# sourceMappingURL=index.cjs.map
+// src/classes/ModuleError.ts
+var import_grpc_sdk15 = require("@conduitplatform/grpc-sdk");
+var ModuleError = class extends import_grpc_sdk15.GrpcError {
+  debugLogInfo;
+  constructor(errorDefinition, debugLogInfo) {
+    const { grpcCode, conduitCode, message } = errorDefinition;
+    super(
+      grpcCode,
+      JSON.stringify({
+        message,
+        conduitCode
+      })
+    );
+    if (debugLogInfo) this.debugLogInfo = debugLogInfo;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConduitActiveSchema,
+  ConduitBoolean,
+  ConduitDate,
+  ConduitJson,
+  ConduitNumber,
+  ConduitObjectId,
+  ConduitRelation,
+  ConduitServiceModule,
+  ConduitString,
+  ConfigController,
+  DEFAULT_STRIP_FIELDS,
+  GrpcServer,
+  ManagedModule,
+  ModuleError,
+  ModuleLifecycleStage,
+  RouteBuilder,
+  RoutingManager,
+  addServiceToServer,
+  createParsedRouterRequest,
+  createServer,
+  exportModel,
+  importModel,
+  initializeSdk,
+  linearBackoffTimeout,
+  linearBackoffTimeoutAsync,
+  merge,
+  readConduitPeersManifest,
+  sanitizeDocumentsForExport,
+  stripInternalFields,
+  wrapFunctionsAsync,
+  wrapGrpcFunctions,
+  wrapRouterGrpcFunction
+});
+//# sourceMappingURL=index.cjs.map