Next.js has been my go-to React framework for applications where SEO, server-side rendering, and performance matter. Next.js 13 introduced one of the biggest changes to the framework with the App Router, React Server Components, and a much clearer separation between server and client-side code.

When I originally started working with the App Router, though, it still felt fairly early. The architecture made a lot of sense, but there were definitely rough edges—especially around third-party libraries, serverless deployments, and figuring out where the server/client boundary should live.

After working with it, here are a few things I learned and some practices I found useful.

Proceed with Caution

1. Prisma and Serverless

If you're using Prisma with a serverless Next.js application, it's worth understanding how your database connections are being managed.

Traditional database connection pooling doesn't always map cleanly to serverless environments. When functions scale horizontally, it's possible to create significantly more database connections than expected.

This isn't necessarily a Next.js-specific problem, but the App Router makes it very easy to perform database operations directly inside server components, route handlers, and server-side functions, so it's something you need to think about early.

For production applications, make sure your database architecture is designed for the environment you're deploying into rather than assuming the same configuration you would use on a long-running Node.js server.

2. Cloudflare Pages Compatibility

Another issue I ran into early was deployment compatibility with Cloudflare Pages.

Next.js tends to move quickly and historically many hosting platforms haven't supported every Next.js feature at exactly the same time. Features that work seamlessly on Vercel may require additional configuration—or may not immediately be supported—on other platforms.

If you're deploying Next.js outside of Vercel, I recommend verifying support for the specific features you're using, especially:

• Server Components
• Route Handlers
• Middleware
• Edge Runtime
• Server-side rendering
• Image optimization

The framework may support something, but that doesn't automatically mean every hosting environment supports it in exactly the same way.

Handling CSS Frameworks and React Libraries

One of the bigger mental shifts with the App Router is understanding the separation between Server Components and Client Components.

A lot of existing React libraries were originally designed around the assumption that everything runs in the browser. That assumption doesn't always work with Server Components.

1. Using "use client"

Certain component libraries require the "use client" directive because they depend on browser APIs, React state, context, or other client-side functionality.

For example:

```tsx "use client";

import { Button } from "@mui/material";

export default function MyButton() {
return Click Me; }

Luckily for most coming from a functional programming background, (in JS, those familiar with lodash or underscore) the conceptual mental models and DSL's are relatively the same in Immutable.js.

First we have to understand the two main data structures: Map and List

Map

const map = Immutable.Map({ id: 1, name: 'John' });  
map.get('name') == 'John'; // true  
map.set('name', 'Mike');  
map.get('name') == 'Mike'; // true  

List

const list = Immutable.List([5, 20, 101];  
list.get(1) == 20; // true  
list.set(0, 9);  
list.get(0) == 9; // true  
list.set(4, 30);  
list.toJS(); // [9, 20, 101, undefined, 30]  

Converting to Immutable.js, fromJS magically detects the proper data structure to convert to. In this example, Immutable.js knows to create a List of Map from an Array of Objects.

const data = [ { id: 1, name: "John" }, { id: 2, name: "Adam" } ];  
const magic = Immutable.fromJS(data);

Immutable.List.isList(magic); // true  
Immutable.Map.isMap(magic.get(0)); // true

Of course, this can done manually as shown below

const result = [ { id: 1, name: "John" }, { id: 2, name: "Adam" } ];

const magic = Immutable.fromJS(result);

let list = Immutable.List();  
result.map((item, index) => { list = list.set(index, Immutable.Map(item))});  
Immutable.is(list, magic); // true,  

Okay, with these basic data structure building blocks, lets build a basic redux store using Immutable.js

Let's take a look at this Person reducer using List and Map

const initialState = Immutable.List([  
  Immutable.Map({ id: 1, name: "John Snow", title: "King of the North" }), 
  Immutable.Map({ id: 2, name: "Adam", title: "Butcher" })
]);
function personReducer(state = initialState, action) {  
  switch (action.type) {
    case FETCH_ALL_PEOPLE:  // O(n)
      action.payload.map((item, index) => { 
        state = state.set(index, Immutable.Map(item));
      });
      // OR state = Immutable.fromJS(action.payload);
      return state;
    case FETCH_ALL_KINGS: // O(n^2)
      action.payload.map((king, index) => {
        const index = state.findIndex((item) => {
          return item.get('id') === king.id;
        });
        if ( index >= 0 ) {
          state = state.set(index, Immutable.Map(king));
        } else {
          state.push(Immutable.Map(king));
        }
      });
      return state;
    case CREATE_PERSON: // O(1)
      return state.push(Immutable.Map(action.payload));
    case GET_PERSON: // O(n)
      const index = state.findIndex((item) => {
        return item.get('id') === action.payload.id;
      });
      if ( index >= 0 ) {
        return state.update(index, (person) => {
          return person.set('name', action.payload.name);
        });
      } else {
        state.push(Immutable.Map(action.payload));
      }
      return state;
    case DELETE_PERSON: // O(n)
      const index = state.findIndex((item) => {
        return item.get('id') === action.payload.id;
      });
      return state.delete(index);
    case UPDATE_PERSON: // O(n)
      const index = state.findIndex((item) => {
        return item.get('id') === action.payload.id;
      });
      if ( index >= 0 ) {
        state = state.set(index, Immutable.Map(action.payload));
      }
      return state;
    default:
      return state;
  }
}

Things are okay here except when we FETCH_ALL_KINGS and get O(n^2) by trying to combine an Array with a List. We also have the following sprinkled in the code to check for duplicates which makes those cases a minimum of O(n) complexity

const index = state.findIndex((item) => {  
  return item.get('id') === action.payload.id;
});

Set

Set duplicate checks are done very efficiently. Lets rewrite the above code using Set instead of List

const initialState = Immutable.Set([  
  Immutable.Map({ id: 1, name: "John Snow", title: "King of the North" }), 
  Immutable.Map({ id: 2, name: "Adam", title: "Butcher" })
]);
function personReducer(state = initialState, action) {  
  switch (action.type) {
    case FETCH_ALL_PEOPLE:  // O(nlogn)
    case FETCH_ALL_KINGS:  // O(nlogn)
      action.payload.map((item, index) => { 
        state = state.add(Immutable.Map(item));
      });
      return state;
    case CREATE_PERSON: // O(logn)
    case GET_PERSON: // O(logn)
      return state.add(Immutable.Map(action.payload));
    case DELETE_PERSON: // O(n)
      return state.delete(Immutable.Map(action.payload));
    case UPDATE_PERSON: // O(n)
      // This is a combo of DELETE_PERSON then CREATE_PERSON
      const found = state.find((person) => {
        return action.payload.id == person.get('id');
      });
      if (found) {
       state = state.delete(Immutable.Map(found));
       state = state.add(Immutable.Map(action.payload));
      }
      return state;
    default:
      return state;
  }
}

The code state.add(Immutable.Map(action.payload)); checks for duplicates and if it does't exist, it adds it to the Set. Similarly, state.delete(Immutable.Map(action.payload)) is able to find the same data objects and delete it properly.

With this, you'll notice that the worse efficiency is at O(nlogn) which is a great trade off vs O(n^2). The code is also more clean and readable. A drawback of Set is that it isn't ordered like List so if order isn't important, the tradeoffs are worth it.

Record

If you noticed with Map person.get('name') isn't nearly as elegant as person.name in vanilla javascript on top of also losing a lot of the object syntactic sugar ES6+ provides. Luckily Immutable.js provides the data structure Record, which is essentially Map but can be treated like a javascript object

const Person = Immutable.Record({ id: "", name: "" });  
const person = new Person({ id: 1, name: "John Snow" });

person.name // "John Snow"  
const { name } = person;  // name = "John Snow"  

We just covered the basics of Map, List, Set and Record. These data structures is just the tip of the iceberg but should be a great starting point for Immutable.js

We created a simple simulation where a "muncher" would randomly move either left, right or jump to eat the randomly placed falling food. Through many iterations, the muncher would figure out the most efficient way to eat the most amount of food.

In the beginning, the muncher would aimlessly move around as shown below (muncher is the green dot, food is the falling blue dot):

But after sometime, the muncher started to figure out a more efficient way to get more and more food:

Example of a shared JSON between the backend and frontend:

// file: shared/models/player.js
var Player {  
  league: { type: 'id', ref: 'League' },
  division: { type: 'id', ref: 'Division' },
  team: { type: 'id', ref: 'Team' },
  name: { type: 'string', default: '' },  
  created: { type: 'date', default: Date.now },
  updated: { type: 'date', default: Date.now }
};
export default Player;  

In case if you didn't notice, this looks exceptional similar to a Mongoose Schema Model. The main difference is the ObjectId is replaced with the string 'id' and all the other types are now relagated to strings too for consistency:

// file: api/utils.js
import mongoose from 'mongoose';  
var Schema = mongoose.Schema;  
import _ from 'lodash';

let mongooseify = function(json) {

  let result = {};
  _.map(Object.keys(json), (key) => {
    let property = _.cloneDeep(json[key]);
    let type;
    switch(property.type) {
      case 'id':
        type = Schema.ObjectId;
        break;
      case 'number':
        type = Number;
        break;
      case 'string':
        type = String;
        break;
      case 'date':
        type = Date;
        break;
      default:
        break;
    }
    result[key] = _.assign({}, property, {type});
  });

  return result;
};

Note: (This can be extended to add additional types)
And finally, create the Mongoose Model:

// file: api/models/player.model.js
'use strict';  
import mongoose from 'mongoose';  
var Schema = mongoose.Schema;  
import player from '../../shared/models/player';  
import utils from '../utils';

/**
 * Player Schema
 */
var PlayerSchema = new Schema(utils.mongooseify(player));

module.exports = mongoose.model('Player', PlayerSchema);

Given the simple object of a Sports Team

{
  "name": "Knights",
  "city": "Los Angeles",
  "state": "CA"
}

We want to remove all duplicates that have the same combination of name, city and state. To view all duplicates of this combination, run a map reduce in MongoDB:

db.getCollection('teams').aggregate(  
    { $match: { 
        name: { $ne: ''},
        city: { $ne: ''},
        state: { $ne: ''}
    }},
    { $group: {
        _id: { name: "$name", city: "$city", state: "$state"},
        count: { $sum: 1},
        dups: { $push: "$_id"}
    }},
    { $match: {
        count: { $gt: 1}
    }}
)

The results should show if there are any duplicate combinations.

To remove the duplicates run:

var duplicates = [];

db.getCollection('teams').aggregate([  
  { $match: { 
      name: { $ne: ''},
      city: { $ne: ''},
      state: { $ne: ''}
  }},
  { $group: { 
      _id: { name: "$name", city: "$city", state: "$state"},
      count: { $sum: 1},
      dups: { $push: "$_id"}, 

  }}, 
  { $match: { 
      count: { $gt: 1}
  }}
])               
.forEach(function(doc) {
    doc.dups.shift();      
    doc.dups.forEach( function(dupId){ 
        duplicates.push(dupId);
        }
    )    
})


db.getCollection('teams').remove({_id:{$in:duplicates}})  

A caution to note, this script does not check the dependencies before deleting. So use at your own risk.

Fetching for a list of teams then fetching for their list of players returns a list of promises in the below example:

async function getTeams() {  
  var teamList = _.map(await getTeamList(), async (team) => {
    team.players = await getPlayerList(team.teamId);
  });

  return teamList;
}

getTeams().then((data)=> {  
  console.log('Array of promises...', data);
});

This isn't too surprising since async functions returns a promise and mapping through them simple just returns the list of them. But the problem lies in the way Lodash/Underscore implements iterating through lists. If you need to run an await, it needs to be inside an async function and cannot be inside a normal function(or arrow function for that matter). So iterating through a list and handling promises through a callback function becomes much more of an issue.

The best way I found to handle this issue to to iterate without callback functions using the old school For Loops.

async function getTeams() {  
  var teamList = await getTeamList();
  for(let i=0; i<teamList.length; i++) {
    let team = teamList[i];
    team.players = await getPlayerList(team.teamId);
  }
  return teamList;
}

getTeams().then((data)=> {  
  console.log('Array of teams with players!', data);
});

Why we should

Writing tests help write more testable code which usually translates to more simple code and allows for easier refactoring. It also instills confidence in the developers to deploy their code that are unit tested.

• Reduce time to first "it"

• Maintainability

• Readability while being more declarative instead of imperative

Tooling

• Karma
• Jasmine

Ways to reduce boilerplate

• if using Jasmine, nested describes helps write clearer tests. By nesting describes, we can bundle similar tests as well as bundle similar boilerplate in the beforeEach and write leaner "it" statements. (http://devchat.tv/adventures-in-angular/026-aia-testing-tools)
• reduce mocks (refer to post on TDD is dead?)
  • Less global states
  • More modular code
• automate ways to run tests
  • karma TDD, by using PhantomJS. Setup to run on file save.

Plugins

• promote ng-html2js
• promote your ng-request2js
• promote your html-to-json-array

Testing directives (general)

//directive someDirective
angular.module('someDirective')  
  .directive('someDirective', someDirective);
function someDirective() {  
  return {
    restrict: 'E',
    scope: {
      personName: '='
    },
    template: '<div>{{welcomeMessage}}</div>',
    link: function(scope, element, attrs) {
      scope.welcomeMessage = 'Hello ' + scope.personName;
    }
  }
};

// typical Directive boilerplate should go here
describe('someDirective', function () {  
  beforeEach(module('app'));
  var $scope, $compile, $rootScope, element;

  beforeEach(inject(function($injector) {
    $rootScope = $injector.get('$rootScope');
    $compile = $injector.get('$compile');
    $scope = $rootScope.$new();

    element = angular.element('<some-directive person-name="John"></some-directive>');
    $compile(element)($scope);
  }));

  it('should welcome the user', function() {
      expect(element.html()).toContain('Hello John');
  });

});

Testing directives (controller)

// directive someDirective
angular.module('app', []);  
angular.module('app')  
  .directive('someDirective', someDirective);

function someDirective() {  
  return {
    restrict: 'E',
    scope: {},
    template: '<div>{{welcomeMessage}}</div>',
    controller: function($scope) {
      $scope.welcome = function(name) {
        $scope.welcomeMessage = 'Hello ' + name;
      }
    }
  }
}

test directive controller scope

describe('someDirective', function () {  
  beforeEach(module('app'));
  var $scope, $compile, $rootScope, element;

  beforeEach(inject(function($injector) {
    $rootScope = $injector.get('$rootScope');
    $compile = $injector.get('$compile');
    $scope = $rootScope.$new();

    element = angular.element('<some-directive ></some-directive>');
    $compile(element)($scope);
  }));

  it('should welcome the user', function() {
      var scope = element.isolateScope();
      scope.welcome('John');
      $scope.$digest();
      expect(element.html()).toContain('Hello John');
  });

test directive controller this

// directive someDirective
angular.module('app', []);  
angular.module('app')  
  .directive('someDirective', someDirective);

function someDirective() {  
  return {
    restrict: 'E',
    scope: {},
    template: '<div>{{welcomeMessage}}</div>',
    controller: function($scope) {
      this.welcome = function(name) {
        $scope.welcomeMessage = 'Hello ' + name;
      }
    }
  }
};

describe('someDirective', function () {  
  beforeEach(module('app'));
  var $scope, $compile, $rootScope, element, controller;

  beforeEach(inject(function($injector) {
    $rootScope = $injector.get('$rootScope');
    $compile = $injector.get('$compile');
    $scope = $rootScope.$new();

    element = angular.element('<some-directive ></some-directive>');
    $compile(element)($scope);

    $rootScope.$apply();
    controller = element.controller('someDirective');
  }));

  it('should welcome the user', function() {
      controller.welcome('John');
      $scope.$digest();
      expect(element.html()).toContain('Hello John');
  });

Testing Services

// someService code here
angular.module('app', []);  
angular.module('app')  
  .factory('someService', someService);

function someService() {  
  var welcomeMessage = '';
  var MessageCreator = function() {
    this.welcome = function(name) {
      welcomeMessage = 'Hello ' + name;
    };

    this.getWelcomeMessage = function() {
      return welcomeMessage;
    };
  }
  return MessageCreator;
};

// test code here
describe('someService', function() {  
  beforeEach(module('app'));
  var $rootScope, $scope, $scope;
  beforeEach(inject( function ($injector) {
    $rootScope = $injector.get('$rootScope');
    someService = $injector.get('someService');
    $scope = $rootScope.$new();
  }));

  it('should create new someService object', function() {
    var service = new someService();
    expect(someService).toBeDefined();
    expect(typeof someService).toBe('object');
  });

  it('should create a welcome message', function() {
    var service = new someService();
    service.welcome('John');
    expect(service.getWelcomeMessage()).toEqual('Hello John');
  });
}

Testing Controllers

// someController code here

angular.module('app', []);  
angular.module('app')  
  .controller('SomeController', SomeController);
function SomeController($scope) {  
  $scope.welcome = "Welcome " + $scope.name;
}

// test code here
describe('someController', function(){  
  beforeEach(module('app'));
  var scope, ctrl;

  beforeEach(inject(function($controller, $rootScope) {
    $cope = $rootScope.$new();
    ctrl = $controller(someController, { $scope: scope });
  }));

  it('should change welcome message when name is set', function() {
    scope.name = "John";
    scope.$digest();
    expect(scope.welcome).toBe("Welcome John");
  });
});

Arrow Function

Without a doubt, the arrow function is my favorite and probably one of the most commonly seen peppered around in github source code. It's pure syntactic sugar but it's simplicity in how it handles the clunkiness of the this keyword definitely makes this my favorite.

Before:

var User: {  
  name: "John",
  welcome: function() {
    var that = this;
    request.get(url, function(res) {
      that.name = res.name;
    });
  }
}

With ES6:

var User: {  
  name: "John",
  welcome: function() {
    request.get(url, res => this.name = res.name );
  }
}

Promises

There's a lot of libraries provide the promises functionality like Q, Bluebird and in AngularJS but I was hoping for a more native implementation to quiet all the naysayers in regards to callback hell. Finally, that day has come.

Before:

async1(function () {  
  async2(function () {
    async3(function () {
      async4(function () {
      })
    })
  })
})

With ES6:

var async1 = new Promise(function(resolve, reject) {  
  resolve(1);
});
var async2 = new Promise(function(resolve, reject) {  
  resolve(1);
});
var async3 = new Promise(function(resolve, reject) {  
  resolve(1);
});
var async4 = function() {console.log('async4');}

async1.then(nosync).then(async3).then(async4);

Let

Javascript has an uncanny valley effect for most developers coming from a C and Java background. It looks like Java but it doesn't behave like it. Most developers learn the hard way through hard to find bugs. One of the bugs that get most developers is scoping

Before:

for(var i=0; i<10; i++) {  
// some implementation
}

console.log(i);  
// 10;

With ES6:

for(let i=0; i<10; i++) {  
// some implementation
}

console.log(i);  
// i is not defined

Default parameters

Although I wasn't too fond of CoffeeScript (I prefer TypeScript), one feature I liked a lot about CoffeeScript was the ability to set default parameters. It was more declarative and reduced some plumbing when passing in parameters.

Before:

function handler(name, message) {  
  if (typeof name === "undefined") name = "John";
  if (typeof message === "undefined") message = "Hello";

  console.log(message + " " + name);
}

With ES6:

function handler(name = "John", message = "Hello") {  
  console.log(message + " " + name);
}

Destructuring

Once upon a time, I used to write in Perl. It was bashed for it's archaic and unreadable syntax (Write once, read never!). But quite honestly, if your developers had enough discipline, you can pump out pretty maintainable code. One such feature that I missed from Perl was Destructuring.

Before:

var list = [1,2,3];  
var a = list.shift();  
list.shift();  
var b = list.shift();  
console.log(a,b);  
// 1 3

With ES6:

var [a, , b] = [1,2,3];  
console.log(a,b);  
// 1 3

Show and rate schools K through elementary schools as well as language schools. Site built using the MEAN stack. Build with a CMS, scraper, OAuth login, search, rating and review features.

Leaguer [Node, Express, MongoDB, React, Reflux, Bootstrap]

Isomorphic web application built with both server-side rendering and a single page application. Display player and team trending strengths and other teams weaknesses.

NPM Modules

html-scripts-to-array

Extracts HTML scripts source links to a JSON array.

karma-ng-request2js-preprocessor

A Karma plugin. Save AngularJS $http JSON requests to JavaScript

Getting Started

Ghost uses something called Markdown for writing. Essentially, it's a shorthand way to manage your post formatting as you write!

Writing in Markdown is really easy. In the left hand panel of Ghost, you simply write as you normally would. Where appropriate, you can use shortcuts to style your content. For example, a list:

• Item number one
• Item number two
  • A nested item
• A final item

or with numbers!

1. Remember to buy some milk
2. Drink the milk
3. Tweet that I remembered to buy the milk, and drank it

Links

Want to link to a source? No problem. If you paste in url, like http://ghost.org - it'll automatically be linked up. But if you want to customise your anchor text, you can do that too! Here's a link to the Ghost website. Neat.

What about Images?

Images work too! Already know the URL of the image you want to include in your article? Simply paste it in like this to make it show up:

Not sure which image you want to use yet? That's ok too. Leave yourself a descriptive placeholder and keep writing. Come back later and drag and drop the image in to upload:

Quoting

Sometimes a link isn't enough, you want to quote someone on what they've said. It was probably very wisdomous. Is wisdomous a word? Find out in a future release when we introduce spellcheck! For now - it's definitely a word.

Wisdomous - it's definitely a word.

Working with Code

Got a streak of geek? We've got you covered there, too. You can write inline <code> blocks really easily with back ticks. Want to show off something more comprehensive? 4 spaces of indentation gets you there.

.awesome-thing {
    display: block;
    width: 100%;
}

Ready for a Break?

Throw 3 or more dashes down on any new line and you've got yourself a fancy new divider. Aw yeah.

Advanced Usage

There's one fantastic secret about Markdown. If you want, you can write plain old HTML and it'll still work! Very flexible.

That should be enough to get you started. Have fun - and let us know what you think :)