v6.x.x

- Implement event driven pattern
- Simplify core logic

Author: ndaidong

README.md

@@ -30,18 +30,14 @@ read(url).then((feed) => {
 })
 ```
 
-##### Note:
-
-> Since Node.js v14, ECMAScript modules [have became the official standard format](https://nodejs.org/docs/latest-v14.x/api/esm.html#esm_modules_ecmascript_modules).
-> Just ensure that you are [using module system](https://nodejs.org/api/packages.html#determining-module-system) and enjoy with ES6 import/export syntax.
-
-
 ## APIs
 
 - [.read(String url)](#readstring-url)
+- [The events](#the-events)
+  - [.resetEvents()](#)
 - [Configuration methods](#configuration-methods)
 
-#### read(String url)
+### read(String url)
 
 Load and extract feed data from given RSS/ATOM source. Return a Promise object.
 
@@ -55,9 +51,10 @@ import {
 const getFeedData = async (url) => {
   try {
     console.log(`Get feed data from ${url}`)
-    const data = await read(url)
-    console.log(data)
-    return data
+    const result = await read(url)
+    // result may be feed data or null
+    console.log(result)
+    return result
   } catch (err) {
     console.trace(err)
   }
@@ -89,27 +86,84 @@ Feed data object retuned by `read()` method should look like below:
 }
 ```
 
-#### Configuration methods
+### The events
 
-In addition, this lib provides some methods to customize default settings. Don't touch them unless you have reason to do that.
+Since v6.0.0, `feed-reader` supports event-driven pattern for easier writing code with more control.
 
-- getRequestOptions()
-- setRequestOptions(Object requestOptions)
+- `onSuccess(Function callback)`
+- `onError(Function callback)`
+- `onComplete(Function callback)`
 
-#### Object `requestOptions`:
+The following example will explain better than any word:
 
 ```js
-{
-  headers: {
-    'user-agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:102.0) Gecko/20100101 Firefox/102.0'
-  },
-  responseType: 'text',
-  responseEncoding: 'utf8',
-  timeout: 6e4, // 1 minute
-  maxRedirects: 3
-}
+import { read, onSuccess, onError, onComplete } from 'feed-reader'
+
+onSuccess((feed, url) => {
+  console.log(`Feed data from ${url} has been parsed successfully`)
+  console.log('`feed` is always an object that contains feed data')
+  console.log(feed)
+})
+
+onError((err, url) => {
+  console.log(`Error occurred while processing ${url}`)
+  console.log('There is a message and reason:')
+  console.log(err)
+})
+
+onComplete((result, url) => {
+  console.log(`Finish processing ${url}`)
+  console.log('There may or may not be an error')
+  console.log('`result` may be feed data or null')
+  console.log(result)
+})
+
+read('https://news.google.com/rss')
+read('https://google.com')
 ```
-Read [axios' request config](https://axios-http.com/docs/req_config) for more info.
+
+We can mix both style together, for example to handle the error:
+
+```js
+import { read, onError } from 'feed-reader'
+
+onError((err, url) => {
+  console.log(`Error occurred while processing ${url}`)
+  console.log('There is a message and reason:')
+  console.log(err)
+})
+
+const getFeedData = async (url) => {
+  const result = await read(url)
+  // `result` may be feed data or null
+  return result
+}
+
+getFeedData('https://news.google.com/rss')
+````
+
+#### Reset event listeners
+
+Use method `resetEvents()` when you want to clear registered listeners from all events.
+
+```js
+import { resetEvents } from 'feed-reader'
+
+resetEvents()
+````
+
+### Configuration methods
+
+#### `setRequestOptions(Object requestOptions)`
+
+Affect to the way how `axios` works. Please refer [axios' request config](https://axios-http.com/docs/req_config) for more info.
+
+#### `getRequestOptions()`
+
+Return current request options.
+
+Default values can be found [here](https://github.com/ndaidong/feed-reader/blob/main/src/config.js#L5).
+
 
 ## Test
 

cjs-eval.js

@@ -2,21 +2,28 @@
 
 const { writeFileSync } = require('fs')
 
-const { read } = require('./dist/cjs/feed-reader.js')
+const { read, onSuccess, onError, onComplete } = require('./dist/cjs/feed-reader.js')
 
 const extractFromUrl = async (url) => {
-  try {
-    const art = await read(url)
-    console.log(art)
-    writeFileSync('./output.json', JSON.stringify(art), 'utf8')
-  } catch (err) {
-    console.trace(err)
-  }
+  onComplete((result, url) => {
+    console.log('onComplete', url)
+  })
+  onSuccess((feed, url) => {
+    console.log('onSuccess', url)
+    writeFileSync('./output.json', JSON.stringify(feed, undefined, 2), 'utf8')
+  })
+  onError((e, url) => {
+    console.log('onError', url)
+    console.log(e)
+  })
+  const feed = await read(url)
+  console.log(feed)
 }
 
 const init = (argv) => {
   if (argv.length === 3) {
-    return extractFromUrl(argv[2])
+    const isUrl = argv[2]
+    return isUrl ? extractFromUrl(isUrl) : false
   }
   return 'Nothing to do!'
 }

eval.js

@@ -1,36 +1,29 @@
 // eval.js
 
-import { readFileSync, writeFileSync, existsSync } from 'fs'
+import { writeFileSync } from 'fs'
 
-import isValidUrl from './src/utils/isValidUrl.js'
-import { read } from './src/main.js'
+import { read, onComplete, onSuccess, onError } from './src/main.js'
 
 const extractFromUrl = async (url) => {
-  try {
-    const art = await read(url)
-    console.log(art)
-    writeFileSync('./output.json', JSON.stringify(art), 'utf8')
-  } catch (err) {
-    console.trace(err)
-  }
-}
-
-const extractFromFile = async (fpath) => {
-  try {
-    const xml = readFileSync(fpath, 'utf8')
-    const art = await read(xml)
-    console.log(art)
-    writeFileSync('./output.json', JSON.stringify(art), 'utf8')
-  } catch (err) {
-    console.trace(err)
-  }
+  onComplete((result, url) => {
+    console.log('onComplete', url)
+  })
+  onSuccess((feed, url) => {
+    console.log('onSuccess', url)
+    writeFileSync('./output.json', JSON.stringify(feed, undefined, 2), 'utf8')
+  })
+  onError((e, url) => {
+    console.log('onError', url)
+    console.log(e)
+  })
+  const feed = await read(url)
+  console.log(feed)
 }
 
 const init = (argv) => {
   if (argv.length === 3) {
-    const input = argv[2]
-    const isUrl = isValidUrl(input)
-    return isUrl ? extractFromUrl(input) : existsSync(input) ? extractFromFile(input) : false
+    const isUrl = argv[2]
+    return isUrl ? extractFromUrl(isUrl) : false
   }
   return 'Nothing to do!'
 }

src/config.js

@@ -9,7 +9,7 @@ const requestOptions = {
   },
   responseType: 'text',
   responseEncoding: 'utf8',
-  timeout: 6e4, // 1 minute
+  timeout: 3e4, // 30 seconds
   maxRedirects: 5
 }
 

src/main.js

@@ -3,36 +3,84 @@
  * @ndaidong
  **/
 
-import { info } from './utils/logger.js'
+import EventEmitter from 'events'
 
 import getXML from './utils/retrieve.js'
-import xml2obj from './utils/xml2obj.js'
-import { parseRSS, parseAtom } from './utils/parser.js'
+import { parse } from './utils/parser.js'
 
-import {
-  validate,
-  isRSS,
-  isAtom
-} from './utils/validator.js'
+import isValidUrl from './utils/isValidUrl.js'
+import { validate } from './utils/validator.js'
 
 export {
   getRequestOptions,
   setRequestOptions
 } from './config.js'
 
+const eventEmitter = new EventEmitter()
+
+const runWhenComplete = (result, url) => {
+  eventEmitter.emit('complete', result, url)
+  return result
+}
+
 export const read = async (url) => {
-  const xmldata = await getXML(url)
+  try {
+    if (!isValidUrl(url)) {
+      eventEmitter.emit('error', {
+        error: 'Error occurred while verifying feed URL',
+        reason: 'Invalid URL'
+      }, url)
 
-  const { xml, error } = xmldata
-  if (error) {
-    throw error
-  }
+      return runWhenComplete(null, url)
+    }
+    const xml = await getXML(url)
+
+    if (!validate(xml)) {
+      eventEmitter.emit('error', {
+        error: 'Error occurred while validating XML format',
+        reason: 'The XML document is not well-formed'
+      }, url)
+
+      return runWhenComplete(null, url)
+    }
+
+    try {
+      const feed = parse(xml)
+      if (feed) {
+        eventEmitter.emit('success', feed, url)
+      }
+
+      return runWhenComplete(feed, url)
+    } catch (er) {
+      eventEmitter.emit('error', {
+        error: 'Error occurred while parsing XML structure',
+        reason: er.message
+      }, url)
 
-  if (!validate(xml)) {
-    throw new Error(`Failed while validating XML format from "${url}"`)
+      return runWhenComplete(null, url)
+    }
+  } catch (err) {
+    eventEmitter.emit('error', {
+      error: 'Error occurred while retrieving remote XML data',
+      reason: err.message
+    }, url)
+
+    return runWhenComplete(null, url)
   }
+}
+
+export const onComplete = (fn) => {
+  eventEmitter.on('complete', fn)
+}
+
+export const onSuccess = (fn) => {
+  eventEmitter.on('success', fn)
+}
+
+export const onError = (fn) => {
+  eventEmitter.on('error', fn)
+}
 
-  info('Parsing XML data...')
-  const jsonObj = xml2obj(xml)
-  return isRSS(jsonObj) ? parseRSS(jsonObj) : isAtom(jsonObj) ? parseAtom(jsonObj) : null
+export const resetEvents = () => {
+  eventEmitter.removeAllListeners()
 }