// main.js
const Square = require('./square.js');
const mySquare = new Square(2);
console.log(`The area of mySquare is ${mySquare.area()}`);

// square.js
// Assigning to exports will not modify module, must use module.exports
module.exports = class Square {
  constructor(width) {
    this.width = width;
  }

  area() {
    return this.width ** 2;
  }
};

function processData () {
  var data = fetchData ();
  data += 1;
  return data;
}

function processData (callback) {
  fetchData(function (err, data) {
    if (err) {
      console.log("An error has occurred. Abort everything!");
      return callback(err);
    }
    data += 1;
    callback(data);
  });
}

function asyncOperation ( a, b, c, callback ) {
  // ... lots of hard work ...
  if ( /* an error occurs */ ) {
    return callback(new Error("An error has occurred"));
  }
  // ... more work ...
  callback(null, d, e, f);
}

asyncOperation ( params.., function ( err, returnValues.. ) {
  //This code gets run after the async operation gets run
});

try {
  doAction(); // do some things
 	
  throw 'myException'; // generates an exception
}
catch (e) {
  // statements to handle any exceptions
  logMyErrors(e); // pass exception object to error handler
} finally {
  // do not break gracefully
}

const fs = require('fs');

function errorFirstCallback(err, data) {
  if (err) {
    console.error('There was an error', err);
    return;
  }
  console.log(data);
}

fs.readFile('/some/file/that/does-not-exist', errorFirstCallback);
fs.readFile('/some/file/that/does-exist', errorFirstCallback);

// THIS WILL NOT WORK:
const fs = require('fs');

try {
  fs.readFile('/some/file/that/does-not-exist', (err, data) => {
    // Mistaken assumption: throwing here...
    if (err) {
      throw err;
    }
  });
} catch (err) {
  // This will not catch the throw!
  console.error(err);
}

const fs = require('fs');

fs.unlink('/tmp/hello', (err) => {
  if (err) throw err;
  console.log('successfully deleted /tmp/hello');
});

const fs = require('fs');

try {
  fs.unlinkSync('/tmp/hello');
  console.log('successfully deleted /tmp/hello');
} catch (err) {
  // handle the error
}

fs.rename('/tmp/hello', '/tmp/world', (err) => {
  if (err) throw err;
  console.log('renamed complete');
});

fs.stat('/tmp/world', (err, stats) => {
  if (err) throw err;
  console.log(`stats: ${JSON.stringify(stats)}`);
});

fs.rename('/tmp/hello', '/tmp/world', (err) => {
  if (err) throw err;
  
  fs.stat('/tmp/world', (err, stats) => {
    if (err) throw err;
    console.log(`stats: ${JSON.stringify(stats)}`);
  });
});

var buffer = Buffer.alloc(8);
// This will print out 8 bytes of zero:
// <Buffer 00 00 00 00 00 00 00 00>

var buffer = Buffer.from([ 8, 6, 7, 5, 3, 0, 9]);
// This will print out 8 bytes of certain values:
// <Buffer 08 06 07 05 03 00 09>

var buffer = Buffer.from("I'm a string!", "utf-8");
// This will print out a chain of values in utf-8:
// <Buffer 49 27 6d 20 61 20 73 74 72 69 6e 67 21>

// Create a size 16 empty buffer
const buffer = Buffer.alloc(16)

// Add string to buffer
buffer.write("Hello", "utf-8")
// returns 5 - number of bytes written to the buffer

// Add another string to buffer
buffer.write(" world!", 5, "utf-8")
// returns 7

buffer.toString('utf-8')
// 'Hello world!\u0000�k\t'

buffer.toString("utf-8", 0, 12)
// 'Hello world!'

const readable = getReadableStreamSomehow();

// When receiving data
readable.on('data', (chunk) => {
  console.log(`Received ${chunk.length} bytes of data.`);
});

// End event
readable.on('end', () => {
  console.log('There will be no more data.');
});

const myStream = getWritableStreamSomehow();

myStream.write('some data');
myStream.write('some more data');

myStream.end('done writing data');

const EventEmitter = require('events');

// create a new event emitter
const myEmitter = new EventEmitter();

// listening to an event
myEmitter.on('customEvent', () => {
  console.log('customEvent was received!')
})

// firing an event
myEmitter.emit('customEvents')

const EventEmitter = require('events');

// create a new event emitter
const myEmitter = new EventEmitter();

// listening to an event
myEmitter.on('customEvent', (...params) => {
  console.log('customEvent was received!')
  console.log('we also have params: ', params)
})

// firing an event
myEmitter.emit('customEvents', "value1", {"value2": 2});

const EventEmitter = require('events');

// create a new event emitter
const myEmitter = new EventEmitter();

// listening to an event async
myEmitter.on('customEvent', () => {
  console.log('customEvent was received async!')
})

// listening to an event sync
myEmitter.on('customEvent', () => {
  setImmediate(() => {
   	console.log('customEvent was received sync!')
  });
})

// firing an event
myEmitter.emit('customEvent');

const EventEmitter = require('events');

// create a new event emitter
const myEmitter = new EventEmitter();

// listening to an event
myEmitter.once('customEvent', () => {
  console.log('customEvent was received!')
})

// firing an event
myEmitter.emit('customEvent');

myEmitter.emit('customEvent');

myEmitter.emit('customEvent');

myEmitter.emit('customEvent');

const EventEmitter = require('events');

// create a new event emitter
const myEmitter = new EventEmitter();

// listening to an event
myEmitter.on('error', (err) => {
  console.error(err)
})

// firing an event
myEmitter.emit('error', new Error());

const EventEmitter = require('events');
const express = require('express')

const eventEmitter = new EventEmitter();

const app = express();

// set event emitter on express app
app.set('eventEmitter', eventEmitter);

// access it from any module of the application
console.log(app.get('eventEmitter'));

const {
  Worker, isMainThread, parentPort, workerData
} = require('worker_threads');

if (isMainThread) {
  module.exports = function parseJSAsync(script) {
    return new Promise((resolve, reject) => {
      const worker = new Worker(__filename, {
        workerData: script
      });
      worker.on('message', resolve);
      worker.on('error', reject);
      worker.on('exit', (code) => {
        if (code !== 0)
          reject(new Error(`Worker stopped with exit code ${code}`));
      });
    });
  };
} else {
  const { parse } = require('some-js-parsing-library');
  const script = workerData;
  parentPort.postMessage(parse(script));
}

var express = require('express')
var app = express()

app.use(function (req, res, next) {
  console.log('Time:', Date.now())
  next()
})

app.use('/user/:id', function (req, res, next) {
  console.log('Request Type:', req.method)
  next()
})

app.use('/user/:id', function (req, res, next) {
  console.log('Request URL:', req.originalUrl)
  next()
}, function (req, res, next) {
  console.log('Request Type:', req.method)
  next()
})

var express = require('express')
var app = express()
var router = express.Router()

// a middleware function with no mount path. 
// This code is executed for every request to the router
router.use(function (req, res, next) {
  console.log('Time:', Date.now())
  next()
})

// a middleware sub-stack shows request info 
// for any type of HTTP request to the /user/:id path
router.use('/user/:id', function (req, res, next) {
  console.log('Request URL:', req.originalUrl)
  next()
}, function (req, res, next) {
  console.log('Request Type:', req.method)
  next()
})

var express = require('express')
var app = express()

app.use(function (err, req, res, next) {
  console.error(err.stack)
  res.status(500).send('Something broke!')
})

var express = require('express')
var app = express()
var cookieParser = require('cookie-parser')

// load the cookie-parsing middleware
app.use(cookieParser())

var express = require('express')
var app = express()

// respond with "hello world" when a GET request is made to the homepage
app.get('/', function (req, res) {
  res.send('hello world')
})

var express = require('express')
var app = express()

// GET method route
app.get('/', function (req, res) {
  res.send('GET request to the homepage')
})

// POST method route
app.post('/', function (req, res) {
  res.send('POST request to the homepage')
})

app.get('/', function (req, res) {
  res.send('root')
})

app.get('/about', function (req, res) {
  res.send('about')
})


app.get('/ab*cd', function (req, res) {
  res.send('ab*cd')
})

app.get('/ab(cd)?e', function (req, res) {
  res.send('ab(cd)?e')
})

app.get(/.*fly$/, function (req, res) {
  res.send('/.*fly$/')
})

app.get('/users/:userId/books/:bookId', function (req, res) {
  res.send(req.params)
})

app.route('/book')
  .get(function (req, res) {
    res.send('Get a random book')
  })
  .post(function (req, res) {
    res.send('Add a book')
  })
  .put(function (req, res) {
    res.send('Update the book')
  })

var express = require('express')
var router = express.Router()

// middleware that is specific to this router
router.use(function timeLog (req, res, next) {
  console.log('Time: ', Date.now())
  next()
})
// define the home page route
router.get('/', function (req, res) {
  res.send('Birds home page')
})
// define the about route
router.get('/about', function (req, res) {
  res.send('About birds')
})

module.exports = router

const { Sequelize } = require('sequelize');

// Option 1: Passing a connection URI
const sequelize = new Sequelize('postgres://user:pass@example.com:5432/dbname') 
// Example for postgres

// Option 2: Passing parameters separately
const sequelize = new Sequelize({
  dialect: 'postgres',
  storage: 'path/to/database.sqlite'
});

// Option 2: Passing parameters separately (other dialects)
const sequelize = new Sequelize('database', 'username', 'password', {
  host: 'localhost',
  dialect: 'postgres'
});

try {
  await sequelize.authenticate();
  console.log('Connection has been established successfully.');
} catch (error) {
  console.error('Unable to connect to the database:', error);
}

const { Sequelize, DataTypes } = require('sequelize');
const sequelize = new Sequelize('sqlite::memory:');

const User = sequelize.define('User', {
  // Model attributes are defined here
  firstName: {
    type: DataTypes.STRING,
    allowNull: false
  },
  lastName: {
    type: DataTypes.STRING
    // allowNull defaults to true
  }
}, {
  // Other model options go here
});

// `sequelize.define` also returns the model
console.log(User === sequelize.models.User); // true

// Create a new user
const jane = await User.create({ firstName: "Jane", lastName: "Doe" });
console.log("Jane's auto-generated ID:", jane.id);

// Find all users
const users = await User.findAll();

// Where clauses
const users = await UserfindAll({
  where: { lastName: "Doe" }
})

// Operators
const { Op } = require("sequelize");
Users.findAll({
  where: {
    [Op.and]: [
      { firstName: "Jane" }, { lastName: "Doe" }
    ]
  }
});

const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost/test');

const mongoose = require('mongoose');

// mongoose module is singleton
console.log(mongoose.connection.readyState);

const mongoose = require('mongoose');

const schema = new mongoose.Schema({ 
  firstName: 'string', 
  lastName: 'string' 
});

// // The first param defines also the collection name
const User = mongoose.model('User', schema);

const mongoose = require('mongoose');

// Create a user
var jane = new User({ firstName: 'Jane', lastName: 'Doe' });
jane.save(function (err) {
  if (err) return handleError(err);
  // saved!
});

User.create({ firstName: 'Jane', lastName: 'Doe' }, function (err, small) {
  if (err) return handleError(err);
  // saved!
});

Tank.insertMany([{ lastName: 'Doe' }], function(err) {
	// handle error here
});

// Find a user
User.find({ lastName: 'Doe' })
  	.where('createdDate')
  	.gt(oneYearAgo)
  	.exec(callback);

const socket = new WebSocket('ws://localhost:3000');

socket.onopen(() => {
  socket.send('Hello!');
});

socket.onmessage(data => {
  console.log(data);
});

const socket = io('ws://localhost:3000');

socket.on('connect', () => {
  // either with send()
  socket.send('Hello!');

  // or with emit() and custom event names
  socket.emit('salutations', 'Hello!', { 'mr': 'john' });
});

// handle the event sent with socket.send()
socket.on('message', data => {
  console.log(data);
});

// handle the event sent with socket.emit()
socket.on('greetings', (elem1, elem2, elem3) => {
  console.log(elem1, elem2, elem3);
});

const io = require('socket.io')(3000);

io.on('connect', socket => {
  // either with send()
  socket.send('Hello!');

  // or with emit() and custom event names
  socket.emit('greetings', 'Hey!', { 'ms': 'jane' });

  // handle the event sent with socket.send()
  socket.on('message', (data) => {
    console.log(data);
  });

  // handle the event sent with socket.emit()
  socket.on('salutations', (elem1, elem2, elem3) => {
    console.log(elem1, elem2, elem3);
  });
});

var app = require('express')();
var http = require('http').createServer(app);
var io = require('socket.io')(http);

app.get('/', (req, res) => {
  res.sendFile(__dirname + '/index.html');
});

io.on('connection', (socket) => {
  console.log('a user connected');
});

http.listen(3000, () => {
  console.log('listening on *:3000');
});

const express = require("express");
const helmet = require("helmet");

const app = express();

// This...
app.use(helmet());

// ...is equivalent to this:
app.use(helmet.contentSecurityPolicy());
app.use(helmet.dnsPrefetchControl());
app.use(helmet.expectCt());
app.use(helmet.frameguard());
app.use(helmet.hidePoweredBy());
app.use(helmet.hsts());
app.use(helmet.ieNoOpen());
app.use(helmet.noSniff());
app.use(helmet.permittedCrossDomainPolicies());
app.use(helmet.referrerPolicy());
app.use(helmet.xssFilter());

const express = require('express')
const cors = require('cors')

const app = express()

app.use(cors())

// Load express module with `require` directive
const express = require('express')
const app = express()

// Define request response in root URL (/)
app.get('/', function (req, res) {
  res.send('Hello World')
})

// Launch listening server on port 8080
app.listen(8080, function () {
  console.log('App listening on port 8080!')
})

const chai = require('chai');
const chaiHttp = require('chai-http');
const app = require('../app.js');

const expect  = chai.expect;

chai.use(chaiHttp)

it('Should fetch data', (done) => {
    chai.request(app)
	.get('/')
	.end((err, res) => {
	    if(err) done(err);
      		
	    expect(res).to.have.status(200);
	    expect(res).to.be.an('object');
	    expect(res.body).to.deep.equals('Hello World');
	})
});

// package.json
"scripts": {
  "test": "mocha ./**/*.test.js"
}

// terminal
npm test

const path = require('path');

module.exports = {
  entry: './path/to/my/entry/file.js',
  output: {
    path: path.resolve(__dirname, 'dist'),
    filename: 'my-first-webpack.bundle.js'
  }
};

const path = require('path')
const webpack = require('webpack')
const nodeExternals = require('webpack-node-externals')

module.exports = {
  entry: {
    server: './app.js',
  },
  output: {
    path: path.join(__dirname, 'dist'),
    publicPath: '/',
    filename: '[name].js'
  },
  target: 'node',
  node: {
    // Need this when working with express, otherwise the build fails
    __dirname: false,   // if you don't put this is, __dirname
    __filename: false,  // and __filename return blank or /
  },
  externals: [nodeExternals()], // Need this to avoid error when working with Express
}