module.exports = {
  name: "http",
  
  /**
   * Moleculer settings
   */
  settings: {
    // HTTP client settings
    httpClient: {
      // HTTP methods to include as Moleculer Actions
      includeMethods: null, // ['get', 'post', 'put', 'patch', 'delete' ]
 
      // Boolean value indicating whether request should be logged or not
      logging: true,
 
      // Log request function
      logOutgoingRequest: logOutgoingRequest,
 
      // Log response function
      logIncomingResponse: logIncomingResponse,
 
      // Format the Response
      responseFormatter: "body", // one of "body", "headers", "status", "raw"
 
      // Format the Errors
      errorFormatter: errorFormatter,
 
      // Got Client options
      defaultOptions: {
        // Put here any Got available option that can be used to extend Got client
      }
    }
  },
};

const { ServiceBroker } = require("moleculer");
const HTTPClientService = require("moleculer-http-client");
 
// Create broker
let broker = new ServiceBroker();
 
// Create a service
broker.createService({
  name: "http",
 
  // Load HTTP Client Service  
  mixins: [HTTPClientService],
  
  settings: {
    // Only load HTTP GET action
    httpClient: { includeMethods: ["get"] }
  }
});
 
// Start the broker
broker.start().then(() => {
  broker
    // Make a HTTP GET request
    .call("http.get", {
      url: "https://httpbin.org/json",
      opt: { json: true }
    })
    .then(res => broker.logger.info(res.body))
    .catch(error => broker.logger.error(error));
});

const { ServiceBroker } = require("moleculer");
const HTTPClientService = require("moleculer-http-client");
 
// Create broker
let broker = new ServiceBroker();
 
// Create a service
broker.createService({
  name: "http",
 
  // Load HTTP Client Service
  mixins: [HTTPClientService],
 
  events: {
    // Register an event listener
    async "some.Event"(request) {
      this.logger.info("Caught an Event");
      // Use service method to make a request
      const res = await this._get(request.url, request.opt);
      this.logger.info("Printing Payload");
      // Print the response data
      this.logger.info(res.body);
    }
  }
});
 
// Start the broker
broker.start().then(() => {
  broker
    // Emit an event
    .emit("some.Event", {
      url: "https://httpbin.org/json",
      opt: { json: true }
    });
});

const { ServiceBroker } = require("moleculer");
const HTTPClientService = require("moleculer-http-client");
const fs = require("fs");
 
// Create broker
let broker = new ServiceBroker({
  nodeID: "http-client"
});
 
// Create a service
broker.createService({
  name: "http",
 
  // Load HTTP Client Service
  mixins: [HTTPClientService],
 
  settings: {
    // Only load HTTP GET action
    httpClient: { includeMethods: ["get"] }
  }
});
 
// Start the broker
broker.start().then(() => {
  broker
    // Make a HTTP GET request
    .call("http.get", {
      url: "https://sindresorhus.com/",
      opt: { stream: true }
    })
    .then(res => {
      const filePath = "./examples/stream/file.md";
      // Write stream into file
      res.pipe(fs.createWriteStream(filePath, { encoding: "utf8" }));
 
      res.on("response", response => {
        broker.logger.info(response.statusCode);
      });
    })
    .catch(error => broker.logger.error(error));
});

const { ServiceBroker } = require("moleculer");
const HTTPClientService = require("moleculer-http-client");
const ApiGateway = require("moleculer-web");
const fs = require("fs");
 
// Create broker
let broker = new ServiceBroker({
  nodeID: "http-client"
});
 
// Create a HTTP Client Service
broker.createService({
  name: "http",
 
  // Load HTTP Client Service
  mixins: [HTTPClientService],
 
  settings: {
    // Only load HTTP POST action
    httpClient: { includeMethods: ["post"] }
  }
});
 
// Create HTTP Server Services
broker.createService({
  name: "api",
  mixins: [ApiGateway],
  settings: {
    port: 4000,
    routes: [
      {
        path: "/stream",
        bodyParsers: { json: false, urlencoded: false },
        aliases: { "POST /": "stream:api.postStream" }
      }
    ]
  },
 
  actions: {
    postStream(ctx) {
      return new Promise((resolve, reject) => {
        const stream = fs.createWriteStream(
          "./examples/stream-post/stored-data.md"
        );
 
        stream.on("close", async () => {
          resolve({ fileName: `file.md`, method: "POST" });
        });
 
        // Return error to the user
        stream.on("error", err => {
          reject(err);
        });
 
        // Pipe the data
        ctx.params.pipe(stream);
      });
    }
  }
});
 
// Start the broker
broker.start().then(() => {
  const streamFile = "./examples/stream-post/data-to-stream.md";
  const stream = fs.createReadStream(streamFile, { encoding: "utf8" });
 
  // Pass stream as ctx.params
  // Pass URL and options in ctx.meta
  const req = broker.call("http.post", stream, {
    meta: { url: "http://localhost:4000/stream", stream: true }
  });
 
  req.then(res => {
    broker.logger.info(res.statusCode);
  });
});

const { ServiceBroker } = require("moleculer");
const HTTPClientService = require("moleculer-http-client");
 
// Create broker
let broker = new ServiceBroker({
  nodeID: "http-client",
  // Enable Moleculer Cache
  cacher: "Memory"
});
 
// Create a service
broker.createService({
  name: "http",
 
  // Load HTTP Client Service
  mixins: [HTTPClientService],
 
  settings: {
    // Only load HTTP GET action
    httpClient: { includeMethods: ["get"] }
  },
 
  actions: {
    get: {
      // Enable cache for GET action
      // More info: https://moleculer.services/docs/0.13/caching.html
      cache: true
    }
  }
});
 
// Start the broker
broker.start().then(() => {
  broker
    // Make a HTTP GET request
    .call("http.get", {
      url: "https://httpbin.org/json",
      opt: { json: true }
    })
    .then(res => broker.logger.info(res.body))
    .then(() =>
      broker.call("http.get", {
        url: "https://httpbin.org/json",
        opt: { json: true }
      })
    )
    .then(res => broker.logger.info(res.body))
    .catch(error => broker.logger.error(error));
});

const { ServiceBroker } = require("moleculer");
const HTTPClientService = require("moleculer-http-client");
 
// Using JS Map as cache
const cacheMap = new Map();
 
// Create broker
let broker = new ServiceBroker({
  nodeID: "http-client"
});
 
// Create a service
broker.createService({
  name: "http",
 
  // Load HTTP Client Service
  mixins: [HTTPClientService],
 
  settings: {
    // Only load HTTP GET action
    httpClient: {
      includeMethods: ["get"],
 
      defaultOptions: {
        // Set Got's built-in cache
        // More info: https://www.npmjs.com/package/got#cache-1
        cache: cacheMap
      }
    }
  }
});
 
// Start the broker
broker.start().then(() => {
  broker
    // Make a HTTP GET request
    .call("http.get", {
      url: "https://httpbin.org/cache/150",
      opt: { json: true }
    })
    .then(res => broker.logger.info(res.fromCache))
    .then(() =>
      broker.call("http.get", {
        url: "https://httpbin.org/cache/150",
        opt: { json: true }
      })
    )
    .then(res => broker.logger.info(res.fromCache))
    .catch(error => broker.logger.error(error));
});

const { ServiceBroker } = require("moleculer");
const HTTPClientService = require("moleculer-http-client");
 
// Create broker
let broker = new ServiceBroker({
  nodeID: "http-client"
});
 
// Create a service
broker.createService({
  name: "http",
 
  // Load HTTP Client Service
  mixins: [HTTPClientService],
 
  actions: {
    async fancyRequest(ctx) {
      try {
        // Direct call to Got Client
        // Can be any Got supported HTTP Method
        return await this._client(ctx.params.url, ctx.params.opt);
      } catch (error) {
        throw error;
      }
    }
  }
});
 
// Start the broker
broker.start().then(() => {
  broker
    // Make a fancy request
    .call("http.fancyRequest", {
      url: "https://httpbin.org/json",
      opt: { method: "GET", json: true }
    })
    .then(res => broker.logger.info(res.body))
    .catch(error => broker.logger.error(error));
});

    const service = broker.createService({
      name: "http",
 
      mixins: [MoleculerHTTP],
 
      settings: {
        httpClient: {
          includeMethods: ["get"],
 
          // Input is Got's options object. More info: https://www.npmjs.com/package/got#options
          logOutgoingRequest: options => {
            console.log(`-----> Request ${options.href}`);
          },
 
          // Input is Got's response object: More info: https://www.npmjs.com/package/got#response
          logIncomingResponse: response => {
            console.log(`<----- Response Status Code ${response.statusCode}`);
          }
        }
      }
    });

    const service = broker.createService({
      name: "http",
 
      mixins: [MoleculerHTTP],
 
      settings: {
        httpClient: {
          includeMethods: ["get"],
 
          // Custom error handler function
          // Input error is Got's error. More info: https://www.npmjs.com/package/got#errors
          errorFormatter: error => {
            return new Error("Custom Error");
          }
        }
      }
    });