Add solutions for 7,8 chapters

Author: kasymbayaman

07-creational-dpatterns/7.1-console-color-factory.js

@@ -0,0 +1,48 @@
+import chalk from 'chalk';
+
+class ColorConsole {
+  log(text) {
+    console.log(text);
+  };
+}
+
+
+class RedConsole extends ColorConsole {
+  log(text) {
+      console.log(chalk.red(text));
+  }
+}
+
+class BlueConsole extends ColorConsole {
+  log(text) {
+      console.log(chalk.blue(text));
+  }
+}
+
+class GreenConsole extends ColorConsole {
+  log(text) {
+      console.log(chalk.green(text));
+  }
+}
+
+function createColorConsole(color) {
+  switch(color) {
+    case 'blue':
+      return new BlueConsole();
+    case 'green':
+      return new GreenConsole();
+    case 'red':
+    default:
+      return new RedConsole()          
+  }
+}
+
+// =========== USAGE ==============
+
+const readConsole = createColorConsole('red');
+const greenConsole = createColorConsole('green');
+const blueConsole = createColorConsole('blue');
+
+readConsole.log("I'M RED");
+greenConsole.log("I'M GREEN");
+blueConsole.log("I'M BLUE");

07-creational-dpatterns/7.2-request-builder.js

@@ -0,0 +1,84 @@
+import { request } from 'https';
+import { URL } from 'url';
+
+class BuildRequest {
+  constructor() {
+    this.body = '';
+  }
+
+  setMethod(method) {
+    if (!method) {
+      throw new Error('Provided wrong http method');
+    }
+
+    this.method = method;
+    return this;
+  }
+
+  setUrl(urlStr) {
+    this.url = new URL(urlStr);
+    return this;
+  }
+
+  setQueryParams(query) {
+    Object.entries(query).forEach(([key, val]) => this.url.searchParams.set(key, val));
+    return this;
+  }
+
+  setHeaders(headers) {
+    this.headers = headers;
+    return this;
+  }
+
+  setBody(body) {
+    this.body = JSON.stringify(body) || '';
+    return this;
+  }
+
+  validateRequestParams() {
+    return this.url && this.method;
+  }
+  setPort(port) {
+    this.port = port;
+    return this;
+  }
+
+  invoke() {
+    const options = {
+      host: this.url.host,
+      path: `${this.url.pathname}?${this.url.searchParams.toString()}`,
+      method: this.method,
+      headers: {
+        Accept: 'application/json',
+        ...this.headers,
+      }
+    };
+
+    if (!this.validateRequestParams()) throw Error('Please provide at least method and url');
+
+    return new Promise((resolve, reject) => {
+      const req = request(options, (res) => {
+        let resAccum = '';
+        res.on('data', (chunk) => {
+          resAccum += chunk.toString();
+        });
+        res.on('end', () => resolve(JSON.parse(resAccum)));
+        res.on('error', reject);
+      });
+
+      req.on('error', reject);
+      req.write(this.body);
+      req.end();
+    })
+  }
+}
+
+new BuildRequest()
+  .setMethod('GET')
+  .setUrl('https://api.urbandictionary.com/v0/define')
+  .setQueryParams({ term: 'wat' })
+  .invoke()
+  .then((res) => {
+    console.log('REQUEST finished', res);
+  })
+

07-creational-dpatterns/7.3-tamper-free-queue.js

@@ -0,0 +1,46 @@
+class Queue {
+  constructor(executor) {
+    const queue = [];
+    let resolveQueue = [];
+
+    const enqueue = (item) => {
+      queue.push(item);
+      if (resolveQueue.length) {
+        const resolve = resolveQueue.shift();
+        resolve(queue.shift());
+      }
+    }
+
+    executor(enqueue);
+
+    this.dequeue = () => {
+      if (queue.length) {
+        const item = queue.shift();
+        if (resolveQueue.length) {
+          const resolve = resolveQueue.shift();
+        resolve(queue.shift());
+        }
+        return Promise.resolve(item);
+      }
+
+      return new Promise((resolve, reject) => {
+        resolveQueue.push(resolve);
+      });
+    }
+  }
+}
+
+
+const queue = new Queue((enqueue) => {
+  enqueue(1);
+  enqueue(3);
+
+  setTimeout(() => enqueue(6), 2000);
+  setTimeout(() => enqueue(3), 0);
+})
+
+console.log(await queue.dequeue());
+console.log(await queue.dequeue());
+console.log(await queue.dequeue());
+console.log(await queue.dequeue());
+

08-structural-dpatterns/8.1-http-client-cache.js

@@ -0,0 +1,27 @@
+import axios from 'axios';
+
+const cache = {};
+
+const axiosWithCache = new Proxy(axios, {
+  get: (target, prop) => {
+    if (prop !== 'get') return target[prop];
+    
+    return async (url, config) => {
+      if (cache[url]) {
+        console.log(`Get request ${url} is found in cache`);
+        return Promise.resolve(cache[url]);
+      }
+
+      const { data } = await target.get(url, config);
+      // request object is too big to store
+      cache[url] = { data };
+      return cache[url];
+    }
+  }
+})
+
+// TESTING
+console.log(await axiosWithCache.get('https://api.urbandictionary.com/v0/define?term=wat', {}));
+console.log(await axiosWithCache.get('https://api.urbandictionary.com/v0/define?term=help', {}));
+console.log(await axiosWithCache.get('https://api.urbandictionary.com/v0/define?term=wat', {}));
+

08-structural-dpatterns/8.2-timestamped-logs.js

@@ -0,0 +1,18 @@
+import chalk from 'chalk';
+
+const logMethods = ['log', 'debug', 'info', 'error'];
+
+const consoleWithTimestamp = new Proxy(console, {
+  get: (target, prop) => {
+    if (!logMethods.includes(prop)) return target[prop];
+
+    return (...args) => {
+      const timestamp = chalk.green(new Date().toLocaleString());
+      target[prop](timestamp, ...args);
+    }
+  }
+});
+
+// TESTING
+consoleWithTimestamp.log('Foo', 'And', 'Bar', 'Went', 'To', 'A', 'Bar');
+consoleWithTimestamp.error('ERROR');

08-structural-dpatterns/8.3-colored-console-output.js

@@ -0,0 +1,13 @@
+import chalk from 'chalk';
+
+const decorateConsole = (console) => {
+  console.red = msg => console.log(chalk.red(msg));
+  console.yellow = msg => console.log(chalk.yellow(msg));
+  console.green = msg => console.log(chalk.green(msg));
+}
+
+decorateConsole(console);
+
+console.red('I AM RED');
+console.green('I AM GREEN');
+console.yellow('I AM YELLOW');

08-structural-dpatterns/8.4-virtual-filesystem.js

@@ -0,0 +1,70 @@
+import { resolve } from 'path'
+
+// In-Memory Cache
+class Cache {
+  constructor() {
+    this.cache = new Map();
+  }
+
+  async putEntry(key, value) {
+    return Promise.resolve(this.cache.set(key, value));
+  }
+
+  async getValue(key, options, callback) {
+    const val = await Promise.resolve(this.cache.get(key));
+    if (!val) {
+      const err = new Error(`ENOENT, open "${key}"`)
+      err.code = 'ENOENT'
+      err.errno = 34
+      err.path = key
+      throw err;
+    }
+    return val;
+  }
+}
+
+// FS Adapter
+const createFSAdapter = cache => ({
+  readFile(filename, options, callback) {
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    } else if (typeof options === 'string') {
+      options = { encoding: options }
+    }
+
+    cache.getValue(resolve(filename))
+      .then(val => callback(null, val))
+      .catch(callback);
+  },
+
+  writeFile(filename, contents, options, callback) {
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    } else if (typeof options === 'string') {
+      options = { encoding: options }
+    }
+
+    cache.putEntry(resolve(filename), contents)
+      .then((res) => callback(null, res))
+      .catch(callback)
+  }
+})
+
+const cache = new Cache();
+const fs = createFSAdapter(cache)
+
+fs.writeFile('file.txt', 'Hello!', () => {
+  fs.readFile('file.txt', { encoding: 'utf8' }, (err, res) => {
+    if (err) {
+      return console.error(err)
+    }
+    console.log('Read result', res)
+  })
+})
+
+// try to read a missing file
+fs.readFile('missing.txt', { encoding: 'utf8' }, (err, res) => {
+  console.error(err)
+})

08-structural-dpatterns/8.5-lazy-buffer.js

@@ -0,0 +1,40 @@
+import { Buffer } from 'buffer';
+
+function createLazyBuffer(size) {
+  let actualBuffer = null;
+
+  // use {} as a placeholder
+  return new Proxy({}, {
+    get: (target, prop) => {
+      if (actualBuffer) {
+        return actualBuffer[prop].bind(actualBuffer);
+      }
+
+      if (prop !== 'write') {
+        // since Buffer has only method properties
+        return () => {
+          throw new Error(`${prop} method cannot be called. Please write to buffer first`);
+        }
+      }
+
+      // If it's first write
+      actualBuffer = Buffer.allocUnsafe(size);
+      return (data) => {
+        actualBuffer.write(data);
+      }
+    },
+  });
+}
+
+// TESTING
+const buffer = createLazyBuffer(20);
+
+try {
+  console.log('Log buffer:', buffer.toString()); // throws an error
+} catch(e) {
+  console.error('Error', e);
+}
+
+buffer.write('Hello to buffer');
+
+console.log('Log buffer:', buffer.toString()); // success