soontao / cds-nats Goto Github PK

/* eslint-disable @typescript-eslint/ban-ts-comment */
import { ApplicationService, cwdRequireCDS, TransactionMix } from "cds-internal-tool";
import { Subscription } from "nats";
import path from "path";
import process from "process";
import { RFCError } from "./errors";
import { NatsService } from "./NatsService";
import { RFCInvocationInfo, RFCService } from "./types";
import { createNatsHeaders, extractUserAndTenant, toHeader, toNatsHeaders } from "./utils";


// TODO: single instance validation

/**
 * NatsRFCService
 * 
 * enable RFC/RPC capability for CAP/Nats
 */
class NatsRFCService extends NatsService {

  /**
   * the app name of current app

import { cwdRequireCDS, User } from "cds-internal-tool";
import { headers as MsgHeaders, JSONCodec, Msg } from "nats";
import os from "os";
import { FatalError } from "./errors";
import { NatsService } from "./NatsService";


interface HeaderObject {

  id?: string;
  type?: string;
  source?: string;
  time?: string;
  datacontenttype?: string;
  specversion?: string;
  tenant?: string;
  "user-class"?: string;
  "user-attributes"?: string;

  [key: string]: string | undefined

}

export class NatsMQBaseService extends NatsService {

  protected codec = JSONCodec<any>();

  // >> utils

  /**
   * convert nats `Headers` to general object
   * 
   * @param msg nats message
   * @returns 
   */
  protected _toHeader(msg: Msg): HeaderObject {
    const headers: any = {};
    if (msg.headers !== undefined) {
      for (const key of msg.headers.keys()) {
        headers[key] = msg.headers.get(key);
      }
    }
    return headers;
  }

  protected _extractUserAndTenant(headers: HeaderObject): { user: User, id: string, tenant?: string } {
    if ("user-class" in headers && "user-attributes" in headers) {
      const cds = cwdRequireCDS() as any;
      let user;
      const tenant = headers["tenant"]; // TODO: warn if undefined
      const className = headers["user-class"];
      const id = headers["id"] ?? cds.utils.uuid();
      const userAttrs = JSON.parse(headers["user-attributes"] ?? "{}");
      if (className !== undefined) {
        if (className === "User") {
          user = new cds.User(userAttrs);
        } else {
          user = new cds.User[className](userAttrs);
        }
      }
      return { user, tenant, id };
    } else {
      throw new FatalError("fatal: user context lost from mq");
    }
  }

  /**
   * convert `cds.Event` to nats `Headers`
   * 
   * @param headers 
   * @param event 
   * @returns 
   */
  protected _toNatsHeaders(headers: any = {}, event?: string) {

    const msgHeaders = MsgHeaders();

    for (const [key, value] of Object.entries(headers)) {
      msgHeaders.set(key, String(value));
    }

    const cds = cwdRequireCDS();

    function setIfNotExit(key: string, value: () => string) {
      if (!msgHeaders.has(key)) msgHeaders.set(key, value());
    }

    setIfNotExit("id", () => cds.context?.id ?? cds.utils.uuid());
    setIfNotExit("type", () => event ?? "unknown");
    setIfNotExit("source", () => `/default/community.cap/${os.hostname()}/${process.pid}`);
    setIfNotExit("time", () => new Date().toISOString());
    setIfNotExit("datacontenttype", () => "application/json");
    setIfNotExit("specversion", () => "1.0");
    setIfNotExit("user-class", () => {
      let className = cds.context?.user?.constructor?.name;
      if (className === undefined) className = "Anonymous";
      return className;
    });
    setIfNotExit("user-attributes", () => JSON.stringify(cds.context?.user ?? "{}"));
    if (cds.context?.tenant !== undefined) {
      setIfNotExit("tenant", () => cds.context?.tenant);
    }

    return msgHeaders;
  }
}

   * execute invocation remotely 
   * 
   * @param appName remote app name
   * @param invocationInfo remote invocation info (full qualified name)
   * @throws {RFCError|object} remote thrown message
   * @returns result value from remote
   */
  public async execute(appName: string, invocationInfo: RFCInvocationInfo) {
    const msg = await this.nc.request(
      this._toAppQueueGroup(appName),
      this.codec.encode(invocationInfo),
      {
        headers: toNatsHeaders(),
        timeout: this.timeout,
      },
    );

    // process error
    if (msg.headers?.get?.("throw") === "true") {
      const throwObject = this.codec.decode(msg.data)

      if (msg.headers?.get?.("error") === "true") {
        const error = new RFCError(
          throwObject?.message ?? "Unknown Error",
          appName
        );
        Object.assign(error, throwObject)
        throw error
      }
      else {
        throw throwObject
      }

    }
    return this.codec.decode(msg.data);
  }

  /**
   * create an application proxy 
   * 
   * @param appName 
   * @returns 
   */
  public app(appName: string) {
    return {
      /**
       * create a RFC service with limited methods
       * 
       * @param serviceName the service name in remote app
       * @returns {RFCService}
       */
      service: (serviceName: string): RFCService => new Proxy({}, {
        get: (_, prop) => {
          if (typeof prop === "string") {
            // emit/run/send
            const methodName = prop;
            return (...args: Array<any>) => {
              return this.execute(appName, { methodName, serviceName, args });
            };
          }
          // TODO: throw error
        }
      }) as any
    };

  }
}

export = NatsRFCService

/* eslint-disable @typescript-eslint/ban-ts-comment */
import { cwdRequireCDS } from "cds-internal-tool";
import { QueryObject } from "cds-internal-tool/lib/types/ql";
import { Subscription } from "nats";
import path from "path";
import process from "process";
import { NatsMQBaseService } from "./NatsMQBaseService";

const HEADER_SERVICE_NAME = "servicename";


export class NatsRFCService extends NatsMQBaseService {

  /**
   * the app name of current app
   */
  private appName!: string;

  private appQueueGroup!: string;

  async init(): Promise<any> {
    await super.init();
    if (this.options?.rfc?.enabled === true || this.options?.rfc?.enabled === "true") {
      this.logger.info("rfc service enabled");
      this.appName = this.options?.rfc?.name ?? path.basename(process.cwd());
      this.appQueueGroup = this._toAppQueueGroup(this.appName);
      this._listenServiceQueue();
    }
  }

  private _toAppQueueGroup(serviceName: string) {
    return [this.options.prefix ?? "", serviceName].join("");
  }

  private _listenServiceQueue() {
    const sub = this.nc.subscribe(this.appQueueGroup, { queue: this.appQueueGroup });
    this.logger.info("subscribe subject (Queue Group)", this.appQueueGroup, "for RFC");
    this
      ._handleInboundCall(sub)
      .catch(err => this.logger.error("receive error for subscription", "error", err));
  }

  private async _handleInboundCall(sub: Subscription) {
    // use the service local event name, otherwise, framework could not found the handlers
    const cds = cwdRequireCDS();
    for await (const msg of sub) {
      try {
        const query = this.codec.decode(msg.data);
        const headers = this._toHeader(msg);
        const serviceName = headers[HEADER_SERVICE_NAME];

        if (serviceName === undefined) {
          this.logger.error("service name is not found for subject", msg.subject, "sid", msg.sid);
          return;
        }

        const { user, tenant, id } = this._extractUserAndTenant(headers);
        const srv = await cds.connect.to(serviceName);
        // @ts-ignore
        const tx = cds.context = srv.tx({ tenant, user, id });

        try {
          const response = await tx.run(query);
          await tx.commit();
          msg.respond(this.codec.encode(response));
        }
        catch (error) {
          await tx.rollback();
        }
      }
      catch (error) {
        this.logger.error("process subject", msg.subject, "sid", msg.sid, "failed", error);
      }

    }
  }

  public async execute(appName: string, serviceName: string, query: QueryObject) {
    const msg = await this.nc.request(
      this._toAppQueueGroup(appName),
      this.codec.encode(query),
      {
        headers: this._toNatsHeaders({ [HEADER_SERVICE_NAME]: serviceName }),
        timeout: 60 * 1000, // TODO: options
      },
    );
    return this.codec.decode(msg.data);
  }

}