mappersmith/client-builder.js

It is a lightweight rest client for node.js and the browser

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var client_builder_exports = {};
__export(client_builder_exports, {
  ClientBuilder: () => ClientBuilder,
  default: () => client_builder_default
});
module.exports = __toCommonJS(client_builder_exports);
var import_manifest = require("./manifest");
var import_request = require("./request");
const isFactoryConfigured = (factory) => {
  if (!factory || !factory()) {
    return false;
  }
  return true;
};
class ClientBuilder {
  Promise;
  manifest;
  GatewayClassFactory;
  maxMiddlewareStackExecutionAllowed;
  constructor(manifestDefinition, GatewayClassFactory, configs) {
    if (!manifestDefinition) {
      throw new Error(`[Mappersmith] invalid manifest (${manifestDefinition})`);
    }
    if (!isFactoryConfigured(GatewayClassFactory)) {
      throw new Error("[Mappersmith] gateway class not configured (configs.gateway)");
    }
    if (!configs.Promise) {
      throw new Error("[Mappersmith] Promise not configured (configs.Promise)");
    }
    this.Promise = configs.Promise;
    this.manifest = new import_manifest.Manifest(manifestDefinition, configs);
    this.GatewayClassFactory = GatewayClassFactory;
    this.maxMiddlewareStackExecutionAllowed = configs.maxMiddlewareStackExecutionAllowed;
  }
  build() {
    const client = { _manifest: this.manifest };
    this.manifest.eachResource((resourceName, methods) => {
      client[resourceName] = this.buildResource(resourceName, methods);
    });
    return client;
  }
  buildResource(resourceName, methods) {
    const initialResourceValue = {};
    const resource = methods.reduce((resource2, method) => {
      const resourceMethod = (requestParams, context) => {
        const request = new import_request.Request(method.descriptor, requestParams, context);
        return this.invokeMiddlewares(String(resourceName), method.name, request);
      };
      return {
        ...resource2,
        [method.name]: resourceMethod
      };
    }, initialResourceValue);
    return resource;
  }
  invokeMiddlewares(resourceName, resourceMethod, initialRequest) {
    const middleware = this.manifest.createMiddleware({ resourceName, resourceMethod });
    const GatewayClass = this.GatewayClassFactory();
    const gatewayConfigs = this.manifest.gatewayConfigs;
    const requestPhaseFailureContext = {
      middleware: null,
      returnedInvalidRequest: false,
      abortExecution: false
    };
    const getInitialRequest = () => this.Promise.resolve(initialRequest);
    const chainRequestPhase = (next, middleware2) => () => {
      const abort = (error) => {
        requestPhaseFailureContext.abortExecution = true;
        throw error;
      };
      return this.Promise.resolve().then(() => middleware2.prepareRequest(next, abort)).then((request) => {
        if (request instanceof import_request.Request) {
          return request;
        }
        requestPhaseFailureContext.returnedInvalidRequest = true;
        const typeValue = typeof request;
        const prettyType = typeValue === "object" || typeValue === "function" ? (
          // eslint-disable-next-line @typescript-eslint/no-explicit-any
          request.name || typeValue
        ) : typeValue;
        throw new Error(
          `[Mappersmith] middleware "${middleware2.__name}" should return "Request" but returned "${prettyType}"`
        );
      }).catch((e) => {
        requestPhaseFailureContext.middleware = middleware2.__name || null;
        throw e;
      });
    };
    const prepareRequest = middleware.reduce(chainRequestPhase, getInitialRequest);
    let executions = 0;
    const executeMiddlewareStack = () => prepareRequest().catch((e) => {
      const { returnedInvalidRequest, abortExecution, middleware: middleware2 } = requestPhaseFailureContext;
      if (returnedInvalidRequest || abortExecution) {
        throw e;
      }
      const error = new Error(
        `[Mappersmith] middleware "${middleware2}" failed in the request phase: ${e.message}`
      );
      error.stack = e.stack;
      throw error;
    }).then((finalRequest) => {
      executions++;
      if (executions > this.maxMiddlewareStackExecutionAllowed) {
        throw new Error(
          `[Mappersmith] infinite loop detected (middleware stack invoked ${executions} times). Check the use of "renew" in one of the middleware.`
        );
      }
      const renew = executeMiddlewareStack;
      const chainResponsePhase = (previousValue, currentValue) => () => {
        const nextValue = currentValue.response(previousValue, renew, finalRequest);
        return nextValue;
      };
      const callGateway = () => new GatewayClass(finalRequest, gatewayConfigs).call();
      const execute = middleware.reduce(chainResponsePhase, callGateway);
      return execute();
    });
    return new this.Promise((resolve, reject) => {
      executeMiddlewareStack().then((response) => resolve(response)).catch(reject);
    });
  }
}
var client_builder_default = ClientBuilder;
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  ClientBuilder
});
//# sourceMappingURL=client-builder.js.map