@qrvey/function-gateway/dist/cjs/index.js

 

'use strict';

var clientLambda = require('@aws-sdk/client-lambda');
var fetch = require('@qrvey/fetch');

var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
  for (var prop in b || (b = {}))
    if (__hasOwnProp.call(b, prop))
      __defNormalProp(a, prop, b[prop]);
  if (__getOwnPropSymbols)
    for (var prop of __getOwnPropSymbols(b)) {
      if (__propIsEnum.call(b, prop))
        __defNormalProp(a, prop, b[prop]);
    }
  return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));

// src/helper/errors.ts
var FunctionMappingNotFound = class extends Error {
  constructor(functionName) {
    super(
      `Function Config not found for ${functionName} in the functionMapping param`
    );
    this.name = "FunctionMappingNotFound";
  }
};

// src/helper/functionMappingHelper.ts
function readFunctionMapping(functionName, functionMapping, params, functionMappingType) {
  const fnMapping = functionMapping[functionName];
  if (!fnMapping)
    throw new FunctionMappingNotFound(functionName);
  const functionConfig = fnMapping(params);
  return functionConfig == null ? void 0 : functionConfig[functionMappingType];
}
function existFunctionMappingTypeConfig(functionName, functionMapping, params, functionMappingType) {
  const fnMapping = functionMapping[functionName];
  if (!fnMapping)
    return false;
  const functionConfig = fnMapping(params);
  return !!(functionConfig == null ? void 0 : functionConfig[functionMappingType]);
}

// src/services/gateways/aws-lambda/model-invocation-template.json
var model_invocation_template_default = {
  resource: "/{proxy+}",
  path: "/$PATH",
  httpMethod: "$HTTP_METHOD",
  body: null,
  headers: null,
  isBase64Encoded: false,
  queryStringParameters: null,
  multiValueQueryStringParameters: null,
  pathParameters: {
    proxy: "$PATH"
  },
  requestContext: {
    resourcePath: "/{proxy+}",
    httpMethod: "$HTTP_METHOD",
    path: "/prod/$PATH"
  }
};

// src/services/gateways/aws-lambda/httpPayloadBuilder.ts
function createLambdaPayload(httpConfig = {}) {
  const queryParams = httpConfig.queryParams || {};
  const queryStringParameters = {};
  for (const key in queryParams) {
    if (Object.hasOwnProperty.call(queryParams, key)) {
      const value = queryParams[key];
      queryStringParameters[key] = Array.isArray(value) ? value[0] : value;
    }
  }
  const payload = __spreadProps(__spreadValues({}, model_invocation_template_default), {
    body: httpConfig.body,
    headers: httpConfig.headers,
    multiValueQueryStringParameters: queryParams,
    queryStringParameters
  });
  let payloadString = JSON.stringify(payload);
  payloadString = payloadString.replace(/\$PATH/g, httpConfig.path || "/").replace(/\$HTTP_METHOD/g, httpConfig.method || "GET");
  return payloadString;
}

// src/services/gateways/aws-lambda/lambdaInvoke.ts
var lambdaClient = new clientLambda.LambdaClient({
  region: process.env.AWS_DEFAULT_REGION
});
async function invokeLambda(functionName, payload = {}, options = {}, callback) {
  const lambdaParams = __spreadProps(__spreadValues({}, options.invocationParams), {
    Payload: options.asHttp ? createLambdaPayload(payload) : JSON.stringify(payload),
    FunctionName: functionName
  });
  const lambdaResult = await lambdaClient.send(
    new clientLambda.InvokeCommand(lambdaParams)
  );
  const res = {
    Payload: lambdaResult.Payload ? Buffer.from(lambdaResult.Payload).toString() : void 0
  };
  return callback ? callback(res) : res;
}

// src/services/gateways/aws-lambda/lambdaGateway.service.ts
var LambdaGatewayService = class {
  invoke(functionName, params, fnMapping) {
    const lambdaConfig = readFunctionMapping(
      functionName,
      fnMapping,
      params,
      "lambda"
    );
    return invokeLambda(
      lambdaConfig.name,
      lambdaConfig.payload,
      lambdaConfig.options,
      lambdaConfig.callback
    );
  }
};
var RestGatewayService = class {
  invoke(functionName, params, fnMapping) {
    const restConfig = readFunctionMapping(
      functionName,
      fnMapping,
      params,
      "rest"
    );
    const options = __spreadProps(__spreadValues({}, restConfig.options), {
      method: restConfig.method
    });
    return fetch.FetchService.sendRequest(
      restConfig.endpoint,
      restConfig.body,
      options
    );
  }
};

// src/services/functionGatewayFactory.service.ts
var FunctionGatewayFactory = class {
  static gateway(functionName, params, functionMapping, options = {}) {
    var _a;
    const isMultiPlatformMode = ((_a = process.env.PLATFORM_TYPE) == null ? void 0 : _a.toLowerCase()) === "container";
    if (options.mappingType === "rest")
      return new RestGatewayService();
    if (options.mappingType === "lambda")
      return new LambdaGatewayService();
    if (isMultiPlatformMode) {
      const hasRestConfig = existFunctionMappingTypeConfig(
        functionName,
        functionMapping,
        params,
        "rest"
      );
      if (hasRestConfig)
        return new RestGatewayService();
    }
    return new LambdaGatewayService();
  }
};

// src/services/functionGateway.service.ts
var FunctionGatewayService = class {
  /**
   * Invokes a function with the specified parameters and options.
   *
   * @param functionName - The name of the function to invoke.
   * @param params - This parameters is passed to the functionMapping config.
   * @param functionMapping - An object that maps function names to function implementations. This object should conform to the `IFunctionMapping` interface.
   * @param options - An object containing additional options for invoking the function. This may include settings such as the mappingType ('lambda' or 'rest').
   *
   * @returns - Returns a promise that resolves with the result of the invoked function or rejects with an error if the invocation fails.
   */
  static invoke(functionName, params, functionMapping, options = {}) {
    const service = FunctionGatewayFactory.gateway(
      functionName,
      params,
      functionMapping,
      options
    );
    return service.invoke(functionName, params, functionMapping);
  }
};

exports.FunctionGatewayService = FunctionGatewayService;
//# sourceMappingURL=out.js.map
//# sourceMappingURL=index.js.map