@interopio/gateway-server/dist/gateway-ent.js

## `@glue42/gateway-ent` compatibility

// src/gateway/ent/logging.ts
import { format } from "node:util";
var LogInfoAdapter = class {
  constructor(event) {
    this.event = event;
  }
  _parsed;
  _timestamp;
  _output;
  parsed() {
    if (this._parsed === void 0) {
      let err = void 0;
      let vargs = this.event.data;
      if (this.event.data[0] instanceof Error) {
        err = this.event.data[0];
        vargs = vargs.slice(1);
      }
      const msg = format(this.event.message, ...vargs);
      this._parsed = { err, msg };
    }
    return this._parsed;
  }
  get time() {
    return this.event.time;
  }
  get level() {
    return this.event.level;
  }
  get namespace() {
    return this.event.name;
  }
  get file() {
    return void 0;
  }
  get line() {
    return void 0;
  }
  get message() {
    return this.parsed().msg;
  }
  get stacktrace() {
    return this.parsed().err;
  }
  get timestamp() {
    if (this._timestamp === void 0) {
      this._timestamp = this.time.toISOString();
    }
    return this._timestamp;
  }
  get output() {
    if (this._output === void 0) {
      const err = this.parsed().err;
      const stacktrace = err ? `
${err.stack ?? err}` : "";
      this._output = `${this.timestamp} ${this.level.toUpperCase()} [${this.namespace}] - ${this.message}${stacktrace}`;
    }
    return this._output;
  }
};
function toLogConfig(config) {
  let level = "info";
  if (config?.level) {
    if (config.level === "fatal") {
      level = "error";
    } else if (config.level !== "report") {
      level = config.level;
    }
  }
  const result = { level };
  const appenderFn = config?.appender;
  if (appenderFn) {
    result.appender = (event) => {
      appenderFn(new LogInfoAdapter(event));
    };
  }
  return result;
}

// src/gateway/ent/server.ts
import { GatewayServer } from "@interopio/gateway-server";
var ServerDelegate = class {
  constructor(config) {
    this.config = config;
  }
  server;
  async connect(cb) {
    if (!this.server) {
      throw new Error(`not started`);
    }
    const client = await this.server.gateway.connect((c, m) => cb(c, m));
    return client;
  }
  info() {
    return this.server?.gateway.info();
  }
  async start() {
    if (!this.server) {
      this.server = await GatewayServer.Factory(this.config);
    }
    return this;
  }
  async stop() {
    await this.server?.close();
    delete this.server;
    return this;
  }
};

// src/gateway/ent/config.ts
function toMetricsFilters(legacy) {
  if (legacy) {
    const publishers = legacy.publishers.map((publisher) => {
      return { identity: publisher.publisher, metrics: publisher.metrics };
    });
    const non_matched = legacy["non-matched"];
    return { publishers, non_matched };
  }
}
function toMetricsPublisherConfig(legacy) {
  const filters = toMetricsFilters(legacy?.filters);
  const conflation = toConflation(legacy?.conflation);
  return { ...legacy, filters, conflation };
}
function toConflation(legacy) {
  if (legacy) {
    return { interval: legacy.interval };
  }
}
function toMetricsConfig(legacy) {
  const metrics = { publishers: [] };
  legacy?.publishers?.forEach((publisher) => {
    if (typeof publisher === "string") {
      if (publisher === "rest") {
        metrics.publishers.push("rest");
        if (legacy.rest) {
          const conf = { ...legacy.rest };
          const userAgent = conf["user-agent"];
          delete conf["user-agent"];
          const headers = { ...conf.headers, ...userAgent ? { "user-agent": userAgent } : {} };
          delete conf.headers;
          metrics.rest = {
            endpoint: conf.endpoint,
            headers,
            ...toMetricsPublisherConfig(conf)
          };
          metrics.rest["publishFn"] ??= "@interopio/gateway-server/metrics-rest";
        }
      } else if (publisher === "file") {
        metrics.publishers.push("file");
        if (legacy.file) {
          const conf = { ...legacy.file };
          const status = conf["skip-status"] === void 0 ? true : !conf["skip-status"];
          delete conf["skip-status"];
          metrics.file = {
            location: conf.location,
            status,
            ...toMetricsPublisherConfig(conf)
          };
        }
      } else {
      }
    } else {
      const configuration = { ...publisher.configuration };
      const splitSize = configuration["split-size"];
      delete configuration["split-size"];
      const file = publisher["file"];
      const custom = {
        split_size: splitSize,
        publisher: { file, configuration },
        ...toMetricsPublisherConfig(configuration)
      };
      metrics.publishers.push(custom);
    }
  });
  if (legacy?.filters) {
    metrics.filters = toMetricsFilters(legacy?.filters);
  }
  return metrics;
}
function toCluster(legacy) {
  if (legacy?.directory) {
    const legacyDirectory = legacy.directory;
    const config = { endpoint: legacy?.["endpoint"] };
    if (legacyDirectory.type === "rest") {
      let directory = void 0;
      if (config.endpoint === void 0) {
        config.endpoint = legacyDirectory.config.directory_uri;
      } else {
        directory = { uri: legacyDirectory.config.directory_uri };
      }
      if (legacyDirectory.config?.announce_interval) {
        directory ??= {};
        directory.interval = Number(legacyDirectory.config.announce_interval);
      }
      if (directory !== void 0) {
        config.directory = directory;
      }
      return config;
    } else if (legacyDirectory.type === "static") {
      config.directory = { members: legacyDirectory.members ?? [] };
      return config;
    }
  }
}
function toMeshConfig(legacy) {
  const mesh = {};
  if (legacy?.configuration?.node_id) mesh.node = legacy.configuration.node_id;
  if (legacy?.type === "broker") mesh.broker = { endpoint: legacy.broker.endpoint };
  if (legacy?.type === "p2p") {
    const cluster = toCluster(legacy.p2p);
    if (cluster) {
      mesh.cluster = cluster;
    }
  }
  return mesh;
}
function toServerConfig(config) {
  const gateway = {
    route: config.route,
    limits: config.limits,
    origins: config.security?.origin_filters,
    clients: config["clients"] ?? { inactive_seconds: 0, buffer_size: 100 },
    contexts: {
      lifetime: "retained",
      visibility: [
        { context: /___channel___.+/, restrictions: "cluster" },
        { context: /T42\..+/, restrictions: "local" }
      ]
    },
    methods: {
      visibility: [
        { method: /T42\..+/, restrictions: "local" }
      ]
    },
    peers: {
      visibility: [
        { domain: "context", restrictions: "cluster" },
        { domain: "agm", restrictions: "local" }
      ]
    },
    metrics: { publishers: [] }
  };
  if (config.authentication?.token_ttl) gateway.token = { ttl: config.authentication?.token_ttl };
  if (config["contexts"]) {
    gateway.contexts = config["contexts"];
  }
  if (config["methods"]) {
    gateway.methods = config["methods"];
  }
  if (config["peers"]) {
    gateway.peers = config["peers"];
  }
  if (config.cluster?.enabled) {
    gateway.mesh = toMeshConfig(config.cluster);
  }
  if (config.metrics?.publishers) gateway.metrics = toMetricsConfig(config.metrics);
  return {
    port: config.port ?? 3434,
    host: config.ip ?? config["host"],
    memory: config["memory"],
    gateway
  };
}

// src/gateway/ent/index.ts
import { IOGateway } from "@interopio/gateway";
function create(config) {
  return new ServerDelegate(toServerConfig(config));
}
function configure_logging(config) {
  IOGateway.Logging.configure(toLogConfig(config));
}
export {
  configure_logging,
  create
};
//# sourceMappingURL=gateway-ent.js.map