@nats-io/services 3.0.0-3 → 3.0.0-5

package/package.json

@@ -1,9 +1,8 @@
 {
   "name": "@nats-io/services",
-  "version": "3.0.0-3",
+  "version": "3.0.0-5",
   "files": [
     "lib/",
-    "build/src/",
     "LICENSE",
     "README.md"
   ],
@@ -33,7 +32,7 @@
   },
   "description": "services library - this library implements all the base functionality for NATS services for javascript clients",
   "dependencies": {
-    "@nats-io/nats-core": "~3.0.0-19"
+    "@nats-io/nats-core": "~3.0.0-24"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",

package/build/src/internal_mod.ts

@@ -1,52 +0,0 @@
-import type { NatsConnection, RequestManyOptions } from "@nats-io/nats-core";
-import { ServiceImpl } from "./service";
-import { ServiceClientImpl } from "./serviceclient";
-import type { Service, ServiceClient, ServiceConfig } from "./types";
-
-export type {
-  Endpoint,
-  EndpointInfo,
-  EndpointOptions,
-  EndpointStats,
-  NamedEndpointStats,
-  Service,
-  ServiceClient,
-  ServiceConfig,
-  ServiceGroup,
-  ServiceHandler,
-  ServiceIdentity,
-  ServiceInfo,
-  ServiceMetadata,
-  ServiceMsg,
-  ServiceResponse,
-  ServiceStats,
-} from "./types";
-
-export {
-  ServiceError,
-  ServiceErrorCodeHeader,
-  ServiceErrorHeader,
-  ServiceResponseType,
-  ServiceVerb,
-} from "./types";
-
-export class Svc {
-  nc: NatsConnection;
-
-  constructor(nc: NatsConnection) {
-    this.nc = nc;
-  }
-
-  add(config: ServiceConfig): Promise<Service> {
-    try {
-      const s = new ServiceImpl(this.nc, config);
-      return s.start();
-    } catch (err) {
-      return Promise.reject(err);
-    }
-  }
-
-  client(opts?: RequestManyOptions, prefix?: string): ServiceClient {
-    return new ServiceClientImpl(this.nc, opts, prefix);
-  }
-}

package/build/src/mod.ts

@@ -1,27 +0,0 @@
-export type {
-  Endpoint,
-  EndpointInfo,
-  EndpointOptions,
-  EndpointStats,
-  NamedEndpointStats,
-  Service,
-  ServiceClient,
-  ServiceConfig,
-  ServiceGroup,
-  ServiceHandler,
-  ServiceIdentity,
-  ServiceInfo,
-  ServiceMetadata,
-  ServiceMsg,
-  ServiceResponse,
-  ServiceStats,
-} from "./internal_mod";
-
-export {
-  ServiceError,
-  ServiceErrorCodeHeader,
-  ServiceErrorHeader,
-  ServiceResponseType,
-  ServiceVerb,
-  Svc,
-} from "./internal_mod";

package/build/src/service.ts

@@ -1,712 +0,0 @@
-/*
- * Copyright 2022-2023 The NATS Authors
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import {
-  deferred,
-  Empty,
-  headers,
-  JSONCodec,
-  nanos,
-  nuid,
-  parseSemVer,
-  QueuedIteratorImpl,
-} from "@nats-io/nats-core/internal";
-import type {
-  Deferred,
-  Msg,
-  MsgHdrs,
-  Nanos,
-  NatsConnection,
-  NatsError,
-  Payload,
-  PublishOptions,
-  QueuedIterator,
-  ReviverFn,
-  Sub,
-} from "@nats-io/nats-core/internal";
-
-import {
-  ServiceError,
-  ServiceErrorCodeHeader,
-  ServiceErrorHeader,
-  ServiceResponseType,
-  ServiceVerb,
-} from "./types";
-
-import type {
-  Endpoint,
-  EndpointInfo,
-  EndpointOptions,
-  NamedEndpointStats,
-  Service,
-  ServiceConfig,
-  ServiceGroup,
-  ServiceHandler,
-  ServiceIdentity,
-  ServiceInfo,
-  ServiceMsg,
-  ServiceStats,
-} from "./types";
-
-function validateName(context: string, name = "") {
-  if (name === "") {
-    throw Error(`${context} name required`);
-  }
-  const m = validName(name);
-  if (m.length) {
-    throw new Error(`invalid ${context} name - ${context} name ${m}`);
-  }
-}
-
-function validName(name = ""): string {
-  if (name === "") {
-    throw Error(`name required`);
-  }
-  const RE = /^[-\w]+$/g;
-  const m = name.match(RE);
-  if (m === null) {
-    for (const c of name.split("")) {
-      const mm = c.match(RE);
-      if (mm === null) {
-        return `cannot contain '${c}'`;
-      }
-    }
-  }
-  return "";
-}
-
-/**
- * Services have common backplane subject pattern:
- *
- * `$SRV.PING|STATS|INFO` - pings or retrieves status for all services
- * `$SRV.PING|STATS|INFO.<name>` - pings or retrieves status for all services having the specified name
- * `$SRV.PING|STATS|INFO.<name>.<id>` - pings or retrieves status of a particular service
- *
- * Note that <name> and <id> are upper-cased.
- */
-export const ServiceApiPrefix = "$SRV";
-
-export class ServiceMsgImpl implements ServiceMsg {
-  msg: Msg;
-  constructor(msg: Msg) {
-    this.msg = msg;
-  }
-
-  get data(): Uint8Array {
-    return this.msg.data;
-  }
-
-  get sid(): number {
-    return this.msg.sid;
-  }
-
-  get subject(): string {
-    return this.msg.subject;
-  }
-
-  get reply(): string {
-    return this.msg.reply || "";
-  }
-
-  get headers(): MsgHdrs | undefined {
-    return this.msg.headers;
-  }
-
-  respond(data?: Payload, opts?: PublishOptions): boolean {
-    return this.msg.respond(data, opts);
-  }
-
-  respondError(
-    code: number,
-    description: string,
-    data?: Uint8Array,
-    opts?: PublishOptions,
-  ): boolean {
-    opts = opts || {};
-    opts.headers = opts.headers || headers();
-    opts.headers?.set(ServiceErrorCodeHeader, `${code}`);
-    opts.headers?.set(ServiceErrorHeader, description);
-    return this.msg.respond(data, opts);
-  }
-
-  json<T = unknown>(reviver?: ReviverFn): T {
-    return this.msg.json(reviver);
-  }
-
-  string(): string {
-    return this.msg.string();
-  }
-}
-
-export class ServiceGroupImpl implements ServiceGroup {
-  subject: string;
-  queue: string;
-  srv: ServiceImpl;
-  constructor(parent: ServiceGroup, name = "", queue = "") {
-    if (name !== "") {
-      validInternalToken("service group", name);
-    }
-    let root = "";
-    if (parent instanceof ServiceImpl) {
-      this.srv = parent as ServiceImpl;
-      root = "";
-    } else if (parent instanceof ServiceGroupImpl) {
-      const sg = parent as ServiceGroupImpl;
-      this.srv = sg.srv;
-      if (queue === "" && sg.queue !== "") {
-        queue = sg.queue;
-      }
-      root = sg.subject;
-    } else {
-      throw new Error("unknown ServiceGroup type");
-    }
-    this.subject = this.calcSubject(root, name);
-    this.queue = queue;
-  }
-
-  calcSubject(root: string, name = ""): string {
-    if (name === "") {
-      return root;
-    }
-    return root !== "" ? `${root}.${name}` : name;
-  }
-  addEndpoint(
-    name = "",
-    opts?: ServiceHandler | EndpointOptions,
-  ): QueuedIterator<ServiceMsg> {
-    opts = opts || { subject: name } as EndpointOptions;
-    const args: EndpointOptions = typeof opts === "function"
-      ? { handler: opts, subject: name }
-      : opts;
-    validateName("endpoint", name);
-    let { subject, handler, metadata, queue } = args;
-    subject = subject || name;
-    queue = queue || this.queue;
-    validSubjectName("endpoint subject", subject);
-    subject = this.calcSubject(this.subject, subject);
-
-    const ne = { name, subject, queue, handler, metadata };
-    return this.srv._addEndpoint(ne);
-  }
-
-  addGroup(name = "", queue = ""): ServiceGroup {
-    return new ServiceGroupImpl(this, name, queue);
-  }
-}
-
-function validSubjectName(context: string, subj: string) {
-  if (subj === "") {
-    throw new Error(`${context} cannot be empty`);
-  }
-  if (subj.indexOf(" ") !== -1) {
-    throw new Error(`${context} cannot contain spaces: '${subj}'`);
-  }
-  const tokens = subj.split(".");
-  tokens.forEach((v, idx) => {
-    if (v === ">" && idx !== tokens.length - 1) {
-      throw new Error(`${context} cannot have internal '>': '${subj}'`);
-    }
-  });
-}
-
-function validInternalToken(context: string, subj: string) {
-  if (subj.indexOf(" ") !== -1) {
-    throw new Error(`${context} cannot contain spaces: '${subj}'`);
-  }
-  const tokens = subj.split(".");
-  tokens.forEach((v) => {
-    if (v === ">") {
-      throw new Error(`${context} name cannot contain internal '>': '${subj}'`);
-    }
-  });
-}
-
-type NamedEndpoint = {
-  name: string;
-} & Endpoint;
-
-type ServiceSubscription<T = unknown> =
-  & NamedEndpoint
-  & {
-    internal: boolean;
-    sub: Sub<T>;
-    qi?: QueuedIterator<T>;
-    stats: NamedEndpointStatsImpl;
-    metadata?: Record<string, string>;
-  };
-
-export class ServiceImpl implements Service {
-  nc: NatsConnection;
-  _id: string;
-  config: ServiceConfig;
-  handlers: ServiceSubscription[];
-  internal: ServiceSubscription[];
-  _stopped: boolean;
-  _done: Deferred<Error | null>;
-  started: string;
-
-  /**
-   * @param verb
-   * @param name
-   * @param id
-   * @param prefix - this is only supplied by tooling when building control subject that crosses an account
-   */
-  static controlSubject(
-    verb: ServiceVerb,
-    name = "",
-    id = "",
-    prefix?: string,
-  ) {
-    // the prefix is used as is, because it is an
-    // account boundary permission
-    const pre = prefix ?? ServiceApiPrefix;
-    if (name === "" && id === "") {
-      return `${pre}.${verb}`;
-    }
-    validateName("control subject name", name);
-    if (id !== "") {
-      validateName("control subject id", id);
-      return `${pre}.${verb}.${name}.${id}`;
-    }
-    return `${pre}.${verb}.${name}`;
-  }
-
-  constructor(
-    nc: NatsConnection,
-    config: ServiceConfig = { name: "", version: "" },
-  ) {
-    this.nc = nc;
-    this.config = Object.assign({}, config);
-    if (!this.config.queue) {
-      this.config.queue = "q";
-    }
-
-    // this will throw if no name
-    validateName("name", this.config.name);
-    validateName("queue", this.config.queue);
-
-    // this will throw if not semver
-    parseSemVer(this.config.version);
-    this._id = nuid.next();
-    this.internal = [] as ServiceSubscription[];
-    this._done = deferred();
-    this._stopped = false;
-    this.handlers = [];
-    this.started = new Date().toISOString();
-    // initialize the stats
-    this.reset();
-
-    // close if the connection closes
-    this.nc.closed()
-      .then(() => {
-        this.close().catch();
-      })
-      .catch((err) => {
-        this.close(err).catch();
-      });
-  }
-
-  get subjects(): string[] {
-    return this.handlers.filter((s) => {
-      return s.internal === false;
-    }).map((s) => {
-      return s.subject;
-    });
-  }
-
-  get id(): string {
-    return this._id;
-  }
-
-  get name(): string {
-    return this.config.name;
-  }
-
-  get description(): string {
-    return this.config.description ?? "";
-  }
-
-  get version(): string {
-    return this.config.version;
-  }
-
-  get metadata(): Record<string, string> | undefined {
-    return this.config.metadata;
-  }
-
-  errorToHeader(err: Error): MsgHdrs {
-    const h = headers();
-    if (err instanceof ServiceError) {
-      const se = err as ServiceError;
-      h.set(ServiceErrorHeader, se.message);
-      h.set(ServiceErrorCodeHeader, `${se.code}`);
-    } else {
-      h.set(ServiceErrorHeader, err.message);
-      h.set(ServiceErrorCodeHeader, "500");
-    }
-    return h;
-  }
-
-  setupHandler(
-    h: NamedEndpoint,
-    internal = false,
-  ): ServiceSubscription {
-    // internals don't use a queue
-    const queue = internal ? "" : (h.queue ? h.queue : this.config.queue);
-    const { name, subject, handler } = h as NamedEndpoint;
-    const sv = h as ServiceSubscription;
-    sv.internal = internal;
-    if (internal) {
-      this.internal.push(sv);
-    }
-    sv.stats = new NamedEndpointStatsImpl(name, subject, queue);
-    sv.queue = queue;
-
-    const callback = handler
-      ? (err: NatsError | null, msg: Msg) => {
-        if (err) {
-          this.close(err);
-          return;
-        }
-        const start = Date.now();
-        try {
-          handler(err, new ServiceMsgImpl(msg));
-        } catch (err) {
-          sv.stats.countError(err);
-          msg?.respond(Empty, { headers: this.errorToHeader(err) });
-        } finally {
-          sv.stats.countLatency(start);
-        }
-      }
-      : undefined;
-
-    sv.sub = this.nc.subscribe(subject, {
-      callback,
-      queue,
-    });
-
-    sv.sub.closed
-      .then(() => {
-        if (!this._stopped) {
-          this.close(new Error(`required subscription ${h.subject} stopped`))
-            .catch();
-        }
-      })
-      .catch((err) => {
-        if (!this._stopped) {
-          const ne = new Error(
-            `required subscription ${h.subject} errored: ${err.message}`,
-          );
-          ne.stack = err.stack;
-          this.close(ne).catch();
-        }
-      });
-    return sv;
-  }
-
-  info(): ServiceInfo {
-    return {
-      type: ServiceResponseType.INFO,
-      name: this.name,
-      id: this.id,
-      version: this.version,
-      description: this.description,
-      metadata: this.metadata,
-      endpoints: this.endpoints(),
-    } as ServiceInfo;
-  }
-
-  endpoints(): EndpointInfo[] {
-    return this.handlers.map((v) => {
-      const { subject, metadata, name, queue } = v;
-      return { subject, metadata, name, queue_group: queue };
-    });
-  }
-
-  async stats(): Promise<ServiceStats> {
-    const endpoints: NamedEndpointStats[] = [];
-    for (const h of this.handlers) {
-      if (typeof this.config.statsHandler === "function") {
-        try {
-          h.stats.data = await this.config.statsHandler(h);
-        } catch (err) {
-          h.stats.countError(err);
-        }
-      }
-      endpoints.push(h.stats.stats(h.qi));
-    }
-    return {
-      type: ServiceResponseType.STATS,
-      name: this.name,
-      id: this.id,
-      version: this.version,
-      started: this.started,
-      metadata: this.metadata,
-      endpoints,
-    };
-  }
-
-  addInternalHandler(
-    verb: ServiceVerb,
-    handler: (err: NatsError | null, msg: Msg) => Promise<void>,
-  ) {
-    const v = `${verb}`.toUpperCase();
-    this._doAddInternalHandler(`${v}-all`, verb, handler);
-    this._doAddInternalHandler(`${v}-kind`, verb, handler, this.name);
-    this._doAddInternalHandler(
-      `${v}`,
-      verb,
-      handler,
-      this.name,
-      this.id,
-    );
-  }
-
-  _doAddInternalHandler(
-    name: string,
-    verb: ServiceVerb,
-    handler: (err: NatsError | null, msg: Msg) => Promise<void>,
-    kind = "",
-    id = "",
-  ) {
-    const endpoint = {} as NamedEndpoint;
-    endpoint.name = name;
-    endpoint.subject = ServiceImpl.controlSubject(verb, kind, id);
-    endpoint.handler = handler;
-    this.setupHandler(endpoint, true);
-  }
-
-  start(): Promise<Service> {
-    const jc = JSONCodec();
-    const statsHandler = (err: Error | null, msg: Msg): Promise<void> => {
-      if (err) {
-        this.close(err);
-        return Promise.reject(err);
-      }
-      return this.stats().then((s) => {
-        msg?.respond(jc.encode(s));
-        return Promise.resolve();
-      });
-    };
-
-    const infoHandler = (err: Error | null, msg: Msg): Promise<void> => {
-      if (err) {
-        this.close(err);
-        return Promise.reject(err);
-      }
-      msg?.respond(jc.encode(this.info()));
-      return Promise.resolve();
-    };
-
-    const ping = jc.encode(this.ping());
-    const pingHandler = (err: Error | null, msg: Msg): Promise<void> => {
-      if (err) {
-        this.close(err).then().catch();
-        return Promise.reject(err);
-      }
-      msg.respond(ping);
-      return Promise.resolve();
-    };
-
-    this.addInternalHandler(ServiceVerb.PING, pingHandler);
-    this.addInternalHandler(ServiceVerb.STATS, statsHandler);
-    this.addInternalHandler(ServiceVerb.INFO, infoHandler);
-
-    // now the actual service
-    this.handlers.forEach((h) => {
-      const { subject } = h as Endpoint;
-      if (typeof subject !== "string") {
-        return;
-      }
-      // this is expected in cases where main subject is just
-      // a root subject for multiple endpoints - user can disable
-      // listening to the root endpoint, by specifying null
-      if (h.handler === null) {
-        return;
-      }
-      this.setupHandler(h as unknown as NamedEndpoint);
-    });
-
-    return Promise.resolve(this);
-  }
-
-  close(err?: Error): Promise<null | Error> {
-    if (this._stopped) {
-      return this._done;
-    }
-    this._stopped = true;
-    let buf: Promise<void>[] = [];
-    if (!this.nc.isClosed()) {
-      buf = this.handlers.concat(this.internal).map((h) => {
-        return h.sub.drain();
-      });
-    }
-    Promise.allSettled(buf)
-      .then(() => {
-        this._done.resolve(err ? err : null);
-      });
-    return this._done;
-  }
-
-  get stopped(): Promise<null | Error> {
-    return this._done;
-  }
-
-  get isStopped(): boolean {
-    return this._stopped;
-  }
-
-  stop(err?: Error): Promise<null | Error> {
-    return this.close(err);
-  }
-
-  ping(): ServiceIdentity {
-    return {
-      type: ServiceResponseType.PING,
-      name: this.name,
-      id: this.id,
-      version: this.version,
-      metadata: this.metadata,
-    };
-  }
-
-  reset(): void {
-    // pretend we restarted
-    this.started = new Date().toISOString();
-    if (this.handlers) {
-      for (const h of this.handlers) {
-        h.stats.reset(h.qi);
-      }
-    }
-  }
-
-  addGroup(name: string, queue?: string): ServiceGroup {
-    return new ServiceGroupImpl(this, name, queue);
-  }
-
-  addEndpoint(
-    name: string,
-    handler?: ServiceHandler | EndpointOptions,
-  ): QueuedIterator<ServiceMsg> {
-    const sg = new ServiceGroupImpl(this);
-    return sg.addEndpoint(name, handler);
-  }
-
-  _addEndpoint(
-    e: NamedEndpoint,
-  ): QueuedIterator<ServiceMsg> {
-    const qi = new QueuedIteratorImpl<ServiceMsg>();
-    qi.noIterator = typeof e.handler === "function";
-    if (!qi.noIterator) {
-      e.handler = (err, msg): void => {
-        err ? this.stop(err).catch() : qi.push(new ServiceMsgImpl(msg));
-      };
-      // close the service if the iterator closes
-      qi.iterClosed.then(() => {
-        this.close().catch();
-      });
-    }
-    // track the iterator for stats
-    const ss = this.setupHandler(e, false);
-    ss.qi = qi;
-    this.handlers.push(ss);
-    return qi;
-  }
-}
-
-class NamedEndpointStatsImpl implements NamedEndpointStats {
-  name: string;
-  subject: string;
-  average_processing_time: Nanos;
-  num_requests: number;
-  processing_time: Nanos;
-  num_errors: number;
-  last_error?: string;
-  data?: unknown;
-  metadata?: Record<string, string>;
-  queue: string;
-
-  constructor(name: string, subject: string, queue = "") {
-    this.name = name;
-    this.subject = subject;
-    this.average_processing_time = 0;
-    this.num_errors = 0;
-    this.num_requests = 0;
-    this.processing_time = 0;
-    this.queue = queue;
-  }
-  reset(qi?: QueuedIterator<unknown>) {
-    this.num_requests = 0;
-    this.processing_time = 0;
-    this.average_processing_time = 0;
-    this.num_errors = 0;
-    this.last_error = undefined;
-    this.data = undefined;
-    const qii = qi as QueuedIteratorImpl<unknown>;
-    if (qii) {
-      qii.time = 0;
-      qii.processed = 0;
-    }
-  }
-  countLatency(start: number) {
-    this.num_requests++;
-    this.processing_time += nanos(Date.now() - start);
-    this.average_processing_time = Math.round(
-      this.processing_time / this.num_requests,
-    );
-  }
-  countError(err: Error): void {
-    this.num_errors++;
-    this.last_error = err.message;
-  }
-
-  _stats(): NamedEndpointStats {
-    const {
-      name,
-      subject,
-      average_processing_time,
-      num_errors,
-      num_requests,
-      processing_time,
-      last_error,
-      data,
-      queue,
-    } = this;
-    return {
-      name,
-      subject,
-      average_processing_time,
-      num_errors,
-      num_requests,
-      processing_time,
-      last_error,
-      data,
-      queue_group: queue,
-    };
-  }
-
-  stats(qi?: QueuedIterator<unknown>): NamedEndpointStats {
-    const qii = qi as QueuedIteratorImpl<unknown>;
-    if (qii?.noIterator === false) {
-      // grab stats in the iterator
-      this.processing_time = qii.time;
-      this.num_requests = qii.processed;
-      this.average_processing_time =
-        this.processing_time > 0 && this.num_requests > 0
-          ? this.processing_time / this.num_requests
-          : 0;
-    }
-    return this._stats();
-  }
-}

package/build/src/serviceclient.ts

@@ -1,106 +0,0 @@
-/*
- * Copyright 2022-2024 The NATS Authors
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import {
-  Empty,
-  JSONCodec,
-  QueuedIteratorImpl,
-  RequestStrategy,
-} from "@nats-io/nats-core/internal";
-
-import type {
-  NatsConnection,
-  QueuedIterator,
-  RequestManyOptions,
-} from "@nats-io/nats-core/internal";
-
-import { ServiceImpl } from "./service";
-import { ServiceVerb } from "./types";
-
-import type {
-  ServiceClient,
-  ServiceIdentity,
-  ServiceInfo,
-  ServiceStats,
-} from "./types";
-
-export class ServiceClientImpl implements ServiceClient {
-  nc: NatsConnection;
-  prefix: string | undefined;
-  opts: RequestManyOptions;
-  constructor(
-    nc: NatsConnection,
-    opts: RequestManyOptions = {
-      strategy: RequestStrategy.JitterTimer,
-      maxWait: 2000,
-    },
-    prefix?: string,
-  ) {
-    this.nc = nc;
-    this.prefix = prefix;
-    this.opts = opts;
-  }
-
-  ping(
-    name = "",
-    id = "",
-  ): Promise<QueuedIterator<ServiceIdentity>> {
-    return this.q<ServiceIdentity>(ServiceVerb.PING, name, id);
-  }
-
-  stats(
-    name = "",
-    id = "",
-  ): Promise<QueuedIterator<ServiceStats>> {
-    return this.q<ServiceStats>(ServiceVerb.STATS, name, id);
-  }
-
-  info(
-    name = "",
-    id = "",
-  ): Promise<QueuedIterator<ServiceInfo>> {
-    return this.q<ServiceInfo>(ServiceVerb.INFO, name, id);
-  }
-
-  async q<T>(
-    v: ServiceVerb,
-    name = "",
-    id = "",
-  ): Promise<QueuedIterator<T>> {
-    const iter = new QueuedIteratorImpl<T>();
-    const jc = JSONCodec<T>();
-    const subj = ServiceImpl.controlSubject(v, name, id, this.prefix);
-    const responses = await this.nc.requestMany(subj, Empty, this.opts);
-    (async () => {
-      for await (const m of responses) {
-        try {
-          const s = jc.decode(m.data);
-          iter.push(s);
-        } catch (err) {
-          // @ts-ignore: pushing fn
-          iter.push(() => {
-            iter.stop(err);
-          });
-        }
-      }
-      //@ts-ignore: push a fn
-      iter.push(() => {
-        iter.stop();
-      });
-    })().catch((err) => {
-      iter.stop(err);
-    });
-    return iter;
-  }
-}

package/build/src/types.ts

@@ -1,300 +0,0 @@
-import type {
-  Msg,
-  Nanos,
-  NatsError,
-  PublishOptions,
-  QueuedIterator,
-} from "@nats-io/nats-core";
-
-export interface ServiceMsg extends Msg {
-  respondError(
-    code: number,
-    description: string,
-    data?: Uint8Array,
-    opts?: PublishOptions,
-  ): boolean;
-}
-
-export type ServiceHandler = (err: NatsError | null, msg: ServiceMsg) => void;
-/**
- * A service Endpoint
- */
-export type Endpoint = {
-  /**
-   * Subject where the endpoint listens
-   */
-  subject: string;
-  /**
-   * An optional handler - if not set the service is an iterator
-   * @param err
-   * @param msg
-   */
-  handler?: ServiceHandler;
-  /**
-   * Optional metadata about the endpoint
-   */
-  metadata?: Record<string, string>;
-  /**
-   * Optional queue group to run this particular endpoint in. The service's configuration
-   * queue configuration will be used. See {@link ServiceConfig}.
-   */
-  queue?: string;
-};
-export type EndpointOptions = Partial<Endpoint>;
-export type EndpointInfo = {
-  name: string;
-  subject: string;
-  metadata?: Record<string, string>;
-  queue_group?: string;
-};
-
-export interface ServiceGroup {
-  /**
-   * The name of the endpoint must be a simple subject token with no wildcards
-   * @param name
-   * @param opts is either a handler or a more complex options which allows a
-   *  subject, handler, and/or schema
-   */
-  addEndpoint(
-    name: string,
-    opts?: ServiceHandler | EndpointOptions,
-  ): QueuedIterator<ServiceMsg>;
-
-  /**
-   * A group is a subject prefix from which endpoints can be added.
-   * Can be empty to allow for prefixes or tokens that are set at runtime
-   * without requiring editing of the service.
-   * Note that an optional queue can be specified, all endpoints added to
-   * the group, will use the specified queue unless the endpoint overrides it.
-   * see {@link EndpointOptions} and {@link ServiceConfig}.
-   * @param subject
-   * @param queue
-   */
-  addGroup(subject?: string, queue?: string): ServiceGroup;
-}
-
-export type ServiceMetadata = {
-  metadata?: Record<string, string>;
-};
-
-export enum ServiceResponseType {
-  STATS = "io.nats.micro.v1.stats_response",
-  INFO = "io.nats.micro.v1.info_response",
-  PING = "io.nats.micro.v1.ping_response",
-}
-
-export interface ServiceResponse {
-  /**
-   * Response type schema
-   */
-  type: ServiceResponseType;
-}
-
-export type ServiceIdentity = ServiceResponse & ServiceMetadata & {
-  /**
-   * The kind of the service reporting the stats
-   */
-  name: string;
-  /**
-   * The unique ID of the service reporting the stats
-   */
-  id: string;
-  /**
-   * A version for the service
-   */
-  version: string;
-};
-export type NamedEndpointStats = {
-  /**
-   * The name of the endpoint
-   */
-  name: string;
-  /**
-   * The subject the endpoint is listening on
-   */
-  subject: string;
-  /**
-   * The number of requests received by the endpoint
-   */
-  num_requests: number;
-  /**
-   * Number of errors that the endpoint has raised
-   */
-  num_errors: number;
-  /**
-   * If set, the last error triggered by the endpoint
-   */
-  last_error?: string;
-  /**
-   * A field that can be customized with any data as returned by stats handler see {@link ServiceConfig}
-   */
-  data?: unknown;
-  /**
-   * Total processing_time for the service
-   */
-  processing_time: Nanos;
-  /**
-   * Average processing_time is the total processing_time divided by the num_requests
-   */
-  average_processing_time: Nanos;
-  /**
-   * The queue group the endpoint is listening on
-   */
-  queue_group?: string;
-};
-/**
- * Statistics for an endpoint
- */
-export type EndpointStats = ServiceIdentity & {
-  endpoints?: NamedEndpointStats[];
-  /**
-   * ISO Date string when the service started
-   */
-  started: string;
-};
-export type ServiceInfo = ServiceIdentity & {
-  /**
-   * Description for the service
-   */
-  description: string;
-  /**
-   * Service metadata
-   */
-  metadata?: Record<string, string>;
-  /**
-   * Information about the Endpoints
-   */
-  endpoints: EndpointInfo[];
-};
-export type ServiceConfig = {
-  /**
-   * A type for a service
-   */
-  name: string;
-  /**
-   * A version identifier for the service
-   */
-  version: string;
-  /**
-   * Description for the service
-   */
-  description?: string;
-  /**
-   * A customized handler for the stats of an endpoint. The
-   * data returned by the endpoint will be serialized as is
-   * @param endpoint
-   */
-  statsHandler?: (
-    endpoint: Endpoint,
-  ) => Promise<unknown | null>;
-
-  /**
-   * Optional metadata about the service
-   */
-  metadata?: Record<string, string>;
-  /**
-   * Optional queue group to run the service in. By default,
-   * then queue name is "q". Note that this configuration will
-   * be the default for all endpoints and groups.
-   */
-  queue?: string;
-};
-/**
- * The stats of a service
- */
-export type ServiceStats = ServiceIdentity & EndpointStats;
-
-export interface Service extends ServiceGroup {
-  /**
-   * A promise that gets resolved to null or Error once the service ends.
-   * If an error, then service exited because of an error.
-   */
-  stopped: Promise<null | Error>;
-  /**
-   * True if the service is stopped
-   */
-  // FIXME: this would be better as stop - but the queued iterator may be an issue perhaps call it `isStopped`
-  isStopped: boolean;
-
-  /**
-   * Returns the stats for the service.
-   */
-  stats(): Promise<ServiceStats>;
-
-  /**
-   * Returns a service info for the service
-   */
-  info(): ServiceInfo;
-
-  /**
-   * Returns the identity used by this service
-   */
-  ping(): ServiceIdentity;
-
-  /**
-   * Resets all the stats
-   */
-  reset(): void;
-
-  /**
-   * Stop the service returning a promise once the service completes.
-   * If the service was stopped due to an error, that promise resolves to
-   * the specified error
-   */
-  stop(err?: Error): Promise<null | Error>;
-}
-
-export const ServiceErrorHeader = "Nats-Service-Error";
-export const ServiceErrorCodeHeader = "Nats-Service-Error-Code";
-
-export class ServiceError extends Error {
-  code: number;
-
-  constructor(code: number, message: string) {
-    super(message);
-    this.code = code;
-  }
-
-  static isServiceError(msg: Msg): boolean {
-    return ServiceError.toServiceError(msg) !== null;
-  }
-
-  static toServiceError(msg: Msg): ServiceError | null {
-    const scode = msg?.headers?.get(ServiceErrorCodeHeader) || "";
-    if (scode !== "") {
-      const code = parseInt(scode) || 400;
-      const description = msg?.headers?.get(ServiceErrorHeader) || "";
-      return new ServiceError(code, description.length ? description : scode);
-    }
-    return null;
-  }
-}
-
-export enum ServiceVerb {
-  PING = "PING",
-  STATS = "STATS",
-  INFO = "INFO",
-}
-
-export interface ServiceClient {
-  /**
-   * Pings services
-   * @param name - optional
-   * @param id - optional
-   */
-  ping(name?: string, id?: string): Promise<QueuedIterator<ServiceIdentity>>;
-
-  /**
-   * Requests all the stats from services
-   * @param name
-   * @param id
-   */
-  stats(name?: string, id?: string): Promise<QueuedIterator<ServiceStats>>;
-
-  /**
-   * Requests info from services
-   * @param name
-   * @param id
-   */
-  info(name?: string, id?: string): Promise<QueuedIterator<ServiceInfo>>;
-}