Hermann  Frami

Hermann Frami

1673556360

Generic Authentication Boilerplate for Serverless Framework

Serverless Authentication

This project is aimed to be a generic authentication boilerplate for the Serverless framework.

This boilerplate is compatible with the Serverless v.1.30.3+, to install Serverless framework run npm install -g serverless.

Installation

The installation will create one DynamoDB table for OAuth state and refresh tokens.

  1. Run serverless install --url https://github.com/laardee/serverless-authentication-boilerplate, clone or download the repository
  2. Change directory to authentication and rename example.env.yml in authentication to env.yml and set environmental variables.
  3. Run npm install.
  4. Run serverless deploy on the authentication folder to deploy authentication service to AWS.
  5. (optional) Change directory to ../test-token and run serverless deploy to deploy test-token service.

If you wish to change the cache db name, change CACHE_DB_NAME in .env file and TableName in serverless.yml in Dynamo resource.

Set up Authentication Provider Application Settings

The redirect URI that needs to be defined in OAuth provider's application settings is the callback endpoint of the API. For example, if you use facebook login, the redirect URI is https://API-ID.execute-api.us-east-1.amazonaws.com/dev/authentication/callback/facebook and for google https://API-ID.execute-api.us-east-1.amazonaws.com/dev/authentication/callback/google.

If you have a domain that you can use, the configuration is explained in the custom domain name section.

Services

In this example project authentication and authorization services are separated from the content API (test-token).

Authentication

Authentication service and authorization function for content API. These can also be separated if needed.

Functions:

  • authentication/signin
    • endpoint: /authentication/signin/{provider}, redirects to oauth provider login page
    • handler: signin function creates redirect url to oauth provider and saves state to DynamoDB
  • authentication/callback
    • endpoint: /authentication/callback/{provider}, redirects back to client webapp with token url parameter
    • handler: function is called by oauth provider with code and state parameters and it creates authorization and refresh tokens
  • authentication/refresh
    • endpoint: /authentication/refresh/{refresh_token}, returns new authentication token and refresh token
    • handler: function revokes refresh token
  • authentication/authorize
    • endpoint: no endpoint
    • handler: is used by Api Gateway custom authorizer

Test-token

Simulates content API.

Functions:

  • test-token/test-token
    • endpoint: /test-token
    • handler: test-token function can be used to test custom authorizer, it returns principalId of custom authorizer policy. It is mapped as the username in request template.

Environmental Variables

Open authentication/env.yml, fill in what you use and other ones can be deleted.

dev:
# General
  SERVICE: ${self:service}
  STAGE: ${opt:stage, self:provider.stage}
  REGION: ${opt:region, self:provider.region}
  REDIRECT_CLIENT_URI: http://127.0.0.1:3000/
# Custom Redirect Domain
# REDIRECT_DOMAIN_NAME: ${opt:stage, self:provider.stage}.my-custom-domain-for-callback.com
# REDIRECT_CERTIFICATE_ARN: arn:aws:acm:us-east-1:111122223333:certificate/fb1b9770-a305-495d-aefb-27e5e101ff3
# REDIRECT_URI: https://${self:provider.environment.REDIRECT_DOMAIN_NAME}/authentication/callback/{provider}
# REDIRECT_HOSTED_ZONE_ID: XXXXXXXX
  TOKEN_SECRET: token-secret-123
# Database
  FAUNADB_SECRET: SERVER_SECRET_FOR_YOUR_FAUNADB_DATABASE
  CACHE_DB_NAME: ${self:service}-cache-${opt:stage, self:provider.stage}
  USERS_DB_NAME: ${self:service}-users-${opt:stage, self:provider.stage}
# Cognito
  USER_POOL_ID: user-pool-id
# Providers
  PROVIDER_FACEBOOK_ID: "fb-mock-id"
  PROVIDER_FACEBOOK_SECRET: "fb-mock-secret"
  PROVIDER_GOOGLE_ID: "g-mock-id"
  PROVIDER_GOOGLE_SECRET: "cg-mock-secret"
  PROVIDER_MICROSOFT_ID: "ms-mock-id"
  PROVIDER_MICROSOFT_SECRET: "ms-mock-secret"
  PROVIDER_CUSTOM_GOOGLE_ID: "cg-mock-id"
  PROVIDER_CUSTOM_GOOGLE_SECRET: "cg-mock-secret"

Example Provider Packages

Custom Provider

Package contains example /authentication/lib/custom-google.js how to implement a custom authentication provider using generic Provider class. To test custom provider go to http://laardee.github.io/serverless-authentication-gh-pages and click 'custom-google' button.

User database

To use FaunaDB to save user data. First create a database here, then:

  1. configure FAUNADB_SECRET in authentication/env.yml with a server secret for your database
  2. uncomment return faunaUser.saveUser(profile); from authentication/lib/storage/usersStorage.js
  3. change the last line of authentication/lib/storage/cacheStorage.js to module.exports = faunaCache;
  4. Run STAGE=dev npm run setup:fauna

To use DynamoBD to save user data:

  1. uncomment UsersTable block from authentication/serverless.yml resources
  2. uncomment return dynamoUser.saveUser(profile); from authentication/lib/storage/usersStorage.js

To use Cognito User Pool as user database:

  1. create new user pool (http://docs.aws.amazon.com/cognito/latest/developerguide/setting-up-cognito-user-identity-pools.html)
  2. copy user pool id to authentication/env.yml
  3. uncomment return saveCognito(profile); from authentication/lib/storage/usersStorage.js

API Gateway Custom Domain Name

If you have a domain, a hosted zone, and a certificate for the domain defined in your AWS account, you may use API Gateway Custom Domain Name in your setup.

Your domain name goes to the REDIRECT_DOMAIN_NAME environment variable, if this is set, CloudFormation will create a custom domain name to API Gateway and recordset to the Route 53

REDIRECT_DOMAIN_NAME: "authentication.my-domain.com"

Certificate ARN for your domain,

REDIRECT_CERTIFICATE_ARN: "arn:aws:acm:us-east-1:111122223333:certificate/fb1b9770-a305-495d-aefb-27e5e101ff3"

Callback path, leave this like it is

REDIRECT_URI: "https://${self:provider.environment.REDIRECT_DOMAIN_NAME}/authentication/callback/{provider}"

Route 53 hosted zone id, go to Route 53 and get the id from there or with CLI aws route53 list-hosted-zones --query 'HostedZones[*].[Name,Id]' --output text. The CLI will output something like this authentication.my-domain.com. /hostedzone/Z10QEETUEETUAO copy the Z10QEETUEETUAO part to the REDIRECT_HOSTED_ZONE_ID environment variable.

REDIRECT_HOSTED_ZONE_ID: "Z10QEETUEETUAO"

Running Tests

  • Run npm install in project root directory
  • Run npm test

Web app demo that uses this boilerplate: http://laardee.github.io/serverless-authentication-gh-pages

If you are using Serverless framework v.0.5, see branch https://github.com/laardee/serverless-authentication-boilerplate/tree/serverless-0.5


Download Details:

Author: laardee
Source Code: https://github.com/laardee/serverless-authentication-boilerplate 
License: MIT license

#serverless #authentication #boilerplate 

Generic Authentication Boilerplate for Serverless Framework
Lawrence  Lesch

Lawrence Lesch

1672813440

A Delightful Way to Building A RESTful API with Nodejs & TypeScript

Express Typescript Boilerplate

A delightful way to building a Node.js RESTful API Services with beautiful code written in TypeScript.

❯ Why

Our main goal with this project is a feature complete server application. We like you to be focused on your business and not spending hours in project configuration.

Try it!! We are happy to hear your feedback or any kind of new features.

Features

  • Beautiful Code thanks to the awesome annotations of the libraries from pleerock.
  • Easy API Testing with included e2e testing.
  • Dependency Injection done with the nice framework from TypeDI.
  • Simplified Database Query with the ORM TypeORM.
  • Clear Structure with different layers such as controllers, services, repositories, models, middlewares...
  • Easy Exception Handling thanks to routing-controllers.
  • Smart Validation thanks to class-validator with some nice annotations.
  • Custom Validators to validate your request even better and stricter. custom-validation-classes.
  • API Documentation thanks to swagger.
  • API Monitoring thanks to express-status-monitor.
  • Integrated Testing Tool thanks to Jest.
  • E2E API Testing thanks to supertest.
  • Basic Security Features thanks to Helmet.
  • Easy event dispatching thanks to event-dispatch.
  • Fast Database Building with simple migration from TypeORM.
  • Easy Data Seeding with our own factories.
  • GraphQL provides as a awesome query language for our api GraphQL.
  • TypeGraphQL thanks to TypeGraphQL we have a some cool decorators to simplify the usage of GraphQL.
  • DataLoaders helps with performance thanks to caching and batching DataLoaders.

❯ Getting Started

Step 1: Set up the Development Environment

You need to set up your development environment before you can do anything.

Install Node.js and NPM

Install yarn globally

yarn install yarn -g

Install a MySQL database.

If you work with a mac, we recommend to use homebrew for the installation.

Step 2: Create new Project

Fork or download this project. Configure your package.json for your new project.

Then copy the .env.example file and rename it to .env. In this file you have to add your database connection information.

Create a new database with the name you have in your .env-file.

Then setup your application environment.

yarn run setup

This installs all dependencies with yarn. After that it migrates the database and seeds some test data into it. So after that your development environment is ready to use.

Step 3: Serve your App

Go to the project dir and start your app with this yarn script.

yarn start serve

This starts a local server using nodemon, which will watch for any file changes and will restart the sever according to these changes. The server address will be displayed to you as http://0.0.0.0:3000.

❯ Scripts and Tasks

All script are defined in the package-scripts.js file, but the most important ones are listed here.

Install

  • Install all dependencies with yarn install

Linting

  • Run code quality analysis using yarn start lint. This runs tslint.
  • There is also a vscode task for this called lint.

Tests

  • Run the unit tests using yarn start test (There is also a vscode task for this called test).
  • Run the integration tests using yarn start test.integration.
  • Run the e2e tests using yarn start test.e2e.

Running in dev mode

  • Run yarn start serve to start nodemon with ts-node, to serve the app.
  • The server address will be displayed to you as http://0.0.0.0:3000

Building the project and run it

  • Run yarn start build to generated all JavaScript files from the TypeScript sources (There is also a vscode task for this called build).
  • To start the builded app located in dist use yarn start.

Database Migration

  • Run typeorm migration:create -n <migration-file-name> to create a new migration file.
  • Try typeorm -h to see more useful cli commands like generating migration out of your models.
  • To migrate your database run yarn start db.migrate.
  • To revert your latest migration run yarn start db.revert.
  • Drops the complete database schema yarn start db.drop.

Database Seeding

  • Run yarn start db.seed to seed your seeds into the database.

❯ Debugger in VSCode

To debug your code run yarn start build or hit cmd + b to build your app. Then, just set a breakpoint and hit F5 in your Visual Studio Code.

❯ API Routes

The route prefix is /api by default, but you can change this in the .env file. The swagger and the monitor route can be altered in the .env file.

RouteDescription
/apiShows us the name, description and the version of the package.json
/graphqlRoute to the graphql editor or your query/mutations requests
/swaggerThis is the Swagger UI with our API documentation
/monitorShows a small monitor page for the server
/api/usersExample entity endpoint
/api/petsExample entity endpoint

❯ Project Structure

NameDescription
.vscode/VSCode tasks, launch configuration and some other settings
dist/Compiled source files will be placed here
src/Source files
src/api/controllers/REST API Controllers
src/api/controllers/requestsRequest classes with validation rules if the body is not equal with a model
src/api/controllers/responsesResponse classes or interfaces to type json response bodies
src/api/errors/Custom HttpErrors like 404 NotFound
src/api/interceptors/Interceptors are used to change or replace the data returned to the client.
src/api/middlewares/Express Middlewares like helmet security features
src/api/models/Bookshelf Models
src/api/repositories/Repository / DB layer
src/api/services/Service layer
src/api/subscribers/Event subscribers
src/api/validators/Custom validators, which can be used in the request classes
src/api/resolvers/GraphQL resolvers (query, mutation & field-resolver)
src/api/types/GraphQL types ,input-types and scalar types
src/api/ schema.gqlGenerated GraphQL schema
src/api/ swagger.jsonSwagger documentation
src/auth/Authentication checkers and services
src/core/The core features like logger and env variables
src/database/factoriesFactory the generate fake entities
src/database/migrationsDatabase migration scripts
src/database/seedsSeeds to create some data in the database
src/decorators/Custom decorators like @Logger & @EventDispatch
src/loaders/Loader is a place where you can configure your app
src/public/Static assets (fonts, css, js, img).
src/types/ *.d.tsCustom type definitions and files that aren't on DefinitelyTyped
testTests
test/e2e/ *.test.tsEnd-2-End tests (like e2e)
test/integration/ *.test.tsIntegration test with SQLite3
test/unit/ *.test.tsUnit tests
.env.exampleEnvironment configurations
.env.testTest environment configurations
mydb.sqlSQLite database for integration tests. Ignored by git and only available after integration tests

❯ Logging

Our logger is winston. To log http request we use the express middleware morgan. We created a simple annotation to inject the logger in your service (see example below).

import { Logger, LoggerInterface } from '../../decorators/Logger';

@Service()
export class UserService {

    constructor(
        @Logger(__filename) private log: LoggerInterface
    ) { }

    ...

❯ Event Dispatching

We use this awesome repository event-dispatch for event dispatching. We created a simple annotation to inject the EventDispatcher in your service (see example below). All events are listed in the events.ts file.

import { events } from '../subscribers/events';
import { EventDispatcher, EventDispatcherInterface } from '../../decorators/EventDispatcher';

@Service()
export class UserService {

    constructor(
        @EventDispatcher() private eventDispatcher: EventDispatcherInterface
    ) { }

    public async create(user: User): Promise<User> {
        ...
        this.eventDispatcher.dispatch(events.user.created, newUser);
        ...
    }

❯ Seeding

Isn't it exhausting to create some sample data for your database, well this time is over!

How does it work? Just create a factory for your entities (models) and a seed script.

1. Create a factory for your entity

For all entities we want to seed, we need to define a factory. To do so we give you the awesome faker library as a parameter into your factory. Then create your "fake" entity and return it. Those factory files should be in the src/database/factories folder and suffixed with Factory like src/database/factories/UserFactory.ts.

Settings can be used to pass some static value into the factory.

define(User, (faker: typeof Faker, settings: { roles: string[] }) => {
    const gender = faker.random.number(1);
    const firstName = faker.name.firstName(gender);
    const lastName = faker.name.lastName(gender);
    const email = faker.internet.email(firstName, lastName);

    const user = new User();
    user.firstName = firstName;
    user.lastName = lastName;
    user.email = email;
    user.roles = settings.roles;
    return user;
});

Handle relation in the entity factory like this.

define(Pet, (faker: typeof Faker, settings: undefined) => {
    const gender = faker.random.number(1);
    const name = faker.name.firstName(gender);

    const pet = new Pet();
    pet.name = name;
    pet.age = faker.random.number();
    pet.user = factory(User)({ roles: ['admin'] })
    return pet;
});

2. Create a seed file

The seeds files define how much and how the data are connected with each other. The files will be executed alphabetically. With the second function, accepting your settings defined in the factories, you are able to create different variations of entities.

export class CreateUsers implements Seed {

    public async seed(factory: Factory, connection: Connection): Promise<any> {
        await factory(User)({ roles: [] }).createMany(10);
    }

}

Here an example with nested factories. You can use the .map() function to alter the generated value before they get persisted.

...
await factory(User)()
    .map(async (user: User) => {
        const pets: Pet[] = await factory(Pet)().createMany(2);
        const petIds = pets.map((pet: Pet) => pet.Id);
        await user.pets().attach(petIds);
    })
    .createMany(5);
...

To deal with relations you can use the entity manager like this.

export class CreatePets implements SeedsInterface {

    public async seed(factory: FactoryInterface, connection: Connection): Promise<any> {
        const connection = await factory.getConnection();
        const em = connection.createEntityManager();

        await times(10, async (n) => {
            // This creates a pet in the database
            const pet = await factory(Pet)().create();
            // This only returns a entity with fake data
            const user = await factory(User)({ roles: ['admin'] }).make();
            user.pets = [pet];
            await em.save(user);
        });
    }

}

3. Run the seeder

The last step is the easiest, just hit the following command in your terminal, but be sure you are in the projects root folder.

yarn start db.seed

CLI Interface

CommandDescription
yarn start "db.seed"Run all seeds
yarn start "db.seed --run CreateBruce,CreatePets"Run specific seeds (file names without extension)
yarn start "db.seed -L"Log database queries to the terminal
yarn start "db.seed --factories <path>"Add a different path to your factories (Default: src/database/)
yarn start "db.seed --seeds <path>"Add a different path to your seeds (Default: src/database/seeds/)

❯ GraphQL

For the GraphQL part we used the library TypeGraphQL to build awesome GraphQL API's.

The context(shown below) of the GraphQL is builded in the graphqlLoader.ts file. Inside of this loader we create a scoped container for each incoming request.

export interface Context {
  requestId: number;
  request: express.Request;
  response: express.Response;
  container: ContainerInstance;
}

DataLoader

For the usage of the DataLoaders we created a annotation, which automatically creates and registers a new DataLoader to the scoped container.

Here is an example of the PetResolver.

import DataLoader from 'dataloader';
import { DLoader } from '../../decorators/DLoader';
    ...
    constructor(
        private petService: PetService,
        @Logger(__filename) private log: LoggerInterface,
        @DLoader(UserModel) private userLoader: DataLoader<string, UserModel>
    ) { }
    ...

Or you could use the repository too.

@DLoader(UserRepository) private userLoader: DataLoader<string, UserModel>

Or even use a custom method of your given repository.

@DLoader(PetRepository, {
    method: 'findByUserIds',
    key: 'userId',
    multiple: true,
}) private petLoader: DataLoader<string, PetModel>

❯ Docker

Install Docker

Before you start, make sure you have a recent version of Docker installed

Build Docker image

docker build -t <your-image-name> .

Run Docker image in container and map port

The port which runs your application inside Docker container is either configured as PORT property in your .env configuration file or passed to Docker container via environment variable PORT. Default port is 3000.

Run image in detached mode

docker run -d -p <port-on-host>:<port-inside-docker-container> <your-image-name>

Run image in foreground mode

docker run -i -t -p <port-on-host>:<port-inside-docker-container> <your-image-name>

Stop Docker container

Detached mode

docker stop <container-id>

You can get a list of all running Docker container and its ids by following command

docker images

Foreground mode

Go to console and press + C at any time.

Docker environment variables

There are several options to configure your app inside a Docker container

project .env file

You can use .env file in project root folder which will be copied inside Docker image. If you want to change a property inside .env you have to rebuild your Docker image.

run options

You can also change app configuration by passing environment variables via docker run option -e or --env.

docker run --env DB_HOST=localhost -e DB_PORT=3306

environment file

Last but not least you can pass a config file to docker run.

docker run --env-file ./env.list

env.list example:

# this is a comment
DB_TYPE=mysql
DB_HOST=localhost
DB_PORT=3306

❯ Further Documentations

Name & LinkDescription
ExpressExpress is a minimal and flexible Node.js web application framework that provides a robust set of features for web and mobile applications.
MicroframeworkMicroframework is a simple tool that allows you to execute your modules in a proper order, helping you to organize bootstrap code in your application.
TypeDIDependency Injection for TypeScript.
routing-controllersCreate structured, declarative and beautifully organized class-based controllers with heavy decorators usage in Express / Koa using TypeScript and Routing Controllers Framework.
TypeORMTypeORM is highly influenced by other ORMs, such as Hibernate, Doctrine and Entity Framework.
class-validatorValidation made easy using TypeScript decorators.
class-transformerProper decorator-based transformation / serialization / deserialization of plain javascript objects to class constructors
event-dispatcherDispatching and listening for application events in Typescript
HelmetHelmet helps you secure your Express apps by setting various HTTP headers. It’s not a silver bullet, but it can help!
Auth0 API DocumentationAuthentification service
JestDelightful JavaScript Testing Library for unit and e2e tests
supertestSuper-agent driven library for testing node.js HTTP servers using a fluent API
nockHTTP mocking and expectations library
swagger DocumentationAPI Tool to describe and document your api.
SQLite DocumentationGetting Started with SQLite3 – Basic Commands.
GraphQL DocumentationA query language for your API.
DataLoader DocumentationDataLoader is a generic utility to be used as part of your application's data fetching layer to provide a consistent API over various backends and reduce requests to those backends via batching and caching.

❯ Related Projects


Inspired by the awesome framework laravel in PHP and of the repositories from pleerock
Made with ❤️ by w3tech, Gery Hirschfeld and contributors


Download Details:

Author: w3tecch
Source Code: https://github.com/w3tecch/express-typescript-boilerplate 
License: MIT license

#express #typescript #boilerplate #node 

A Delightful Way to Building A RESTful API with Nodejs & TypeScript
Lawrence  Lesch

Lawrence Lesch

1672773000

Boilerplate & Starter for Next.js 13+, Tailwind CSS 3.2 and TypeScript

Boilerplate and Starter for Next JS 13+, Tailwind CSS 3.2 and TypeScript

🚀 Boilerplate and Starter for Next.js, Tailwind CSS and TypeScript ⚡️ Made with developer experience first: Next.js, TypeScript, ESLint, Prettier, Husky, Lint-Staged, Jest, Testing Library, Commitlint, VSCode, Netlify, PostCSS, Tailwind CSS.

Clone this project and use it to create your own Next.js project. You can check a Next js templates demo.

Features

Developer experience first:

  • Next.js for Static Site Generator
  • 🔥 Type checking TypeScript
  • 💎 Integrate with Tailwind CSS
  • ✅ Strict Mode for TypeScript and React 18
  • 📏 Linter with ESLint (default NextJS, NextJS Core Web Vitals, Tailwind CSS and Airbnb configuration)
  • 💖 Code Formatter with Prettier
  • 🦊 Husky for Git Hooks
  • 🚫 Lint-staged for running linters on Git staged files
  • 🚓 Lint git commit with Commitlint
  • 📓 Write standard compliant commit messages with Commitizen
  • 🦺 Unit Testing with Jest and React Testing Library
  • 🧪 E2E Testing with Cypress
  • 👷 Run tests on pull request with GitHub Actions
  • 🎁 Automatic changelog generation with Semantic Release
  • 🔍 Visual testing with Percy (Optional)
  • 💡 Absolute Imports using @ prefix
  • 🗂 VSCode configuration: Debug, Settings, Tasks and extension for PostCSS, ESLint, Prettier, TypeScript, Jest
  • 🤖 SEO metadata, JSON-LD and Open Graph tags with Next SEO
  • 🗺️ Sitemap.xml and robots.txt with next-sitemap
  • ⚙️ Bundler Analyzer
  • 🖱️ One click deployment with Vercel or Netlify (or manual deployment to any hosting services)
  • 🌈 Include a FREE minimalist theme
  • 💯 Maximize lighthouse score

Built-in feature from Next.js:

  • ☕ Minify HTML & CSS
  • 💨 Live reload
  • ✅ Cache busting

Philosophy

  • All the Next.js pages are statically generated by default. You can easily switch to SSR adding getServerSideProps to your page.
  • Nothing is hidden from you, so you have the freedom to make the necessary adjustments to fit your needs and preferences.
  • Minimal code
  • SEO-friendly
  • 🚀 Production-ready

Nextless.js SaaS Boilerplate

Build your SaaS product faster with React SaaS Boilerplate.

React SaaS Boilerplate Next.js

Premium Themes

Green Nextjs Landing Page TemplatePurple Saas Nextjs Theme
Green Nextjs Landing Page TemplateBlue Landing Page Nextjs Theme

Find more Nextjs Themes.

Requirements

  • Node.js 14+ and npm

Getting started

Run the following command on your local environment:

git clone --depth=1 https://github.com/ixartz/Next-js-Boilerplate.git my-project-name
cd my-project-name
npm install

Then, you can run locally in development mode with live reload:

npm run dev

Open http://localhost:3000 with your favorite browser to see your project.

.
├── README.md                       # README file
├── __mocks__                       # Mocks for testing
├── .github                         # GitHub folder
├── .husky                          # Husky configuration
├── .vscode                         # VSCode configuration
├── public                          # Public assets folder
├── src
│   ├── layouts                     # Layouts components
│   ├── pages                       # Next JS Pages
│   ├── pages.test                  # Next JS Pages tests (this avoid test to treated as a Next.js pages)
│   ├── styles                      # Styles folder
│   ├── templates                   # Default template
│   └── utils                       # Utility functions
├── tailwind.config.js              # Tailwind CSS configuration
└── tsconfig.json                   # TypeScript configuration

Customization

You can easily configure Next js Boilerplate by making a search in the whole project with FIXME: for making quick customization. Here is some of the most important files to customize:

  • public/apple-touch-icon.png, public/favicon.ico, public/favicon-16x16.png and public/favicon-32x32.png: your website favicon, you can generate from https://favicon.io/favicon-converter/
  • src/styles/global.css: your CSS file using Tailwind CSS
  • src/utils/AppConfig.ts: configuration file
  • src/templates/Main.tsx: default theme
  • next-sitemap.config.js: sitemap configuration

You have access to the whole code source if you need further customization. The provided code is only example for you to start your project. The sky is the limit 🚀.

Commit Message Format

The project enforces Conventional Commits specification. This means that all your commit messages must be formatted according to the specification. To help you write commit messages, the project uses Commitizen, an interactive CLI that guides you through the commit process. To use it, run the following command:

npm run commit

One of the benefits of using Conventional Commits is that it allows us to automatically generate a CHANGELOG file. It also allows us to automatically determine the next version number based on the types of commits that are included in a release.

Deploy to production

You can see the results locally in production mode with:

$ npm run build
$ npm run start

The generated HTML and CSS files are minified (built-in feature from Next js). It will also removed unused CSS from Tailwind CSS.

You can create an optimized production build with:

npm run build-prod

Now, your blog is ready to be deployed. All generated files are located at out folder, which you can deploy with any hosting service.

Testing

All tests are colocated with the source code inside the same directory. So, it makes it easier to find them. Unfortunately, it is not possible with the pages folder which is used by Next.js for routing. So, what is why we have a pages.test folder to write tests from files located in pages folder.

Deploy to Netlify

Clone this repository on own GitHub account and deploy to Netlify:

Netlify Deploy button

Deploy to Vercel

Deploy this Next JS Boilerplate on Vercel in one click:

Deploy with Vercel

VSCode information (optional)

If you are VSCode users, you can have a better integration with VSCode by installing the suggested extension in .vscode/extension.json. The starter code comes up with Settings for a seamless integration with VSCode. The Debug configuration is also provided for frontend and backend debugging experience.

With the plugins installed on your VSCode, ESLint and Prettier can automatically fix the code and show you the errors. Same goes for testing, you can install VSCode Jest extension to automatically run your tests and it also show the code coverage in context.

Pro tips: if you need a project wide type checking with TypeScript, you can run a build with Cmd + Shift + B on Mac.

Contributions

Everyone is welcome to contribute to this project. Feel free to open an issue if you have question or found a bug. Totally open to any suggestions and improvements.

License

Licensed under the MIT License, Copyright © 2022

See LICENSE for more information.


Made with ♥ by CreativeDesignsGuru Twitter

React SaaS Boilerplate

Download Details:

Author: ixartz
Source Code: https://github.com/ixartz/Next-js-Boilerplate 
License: MIT license

#typescript #boilerplate #eslint #nextjs 

Boilerplate & Starter for Next.js 13+, Tailwind CSS 3.2 and TypeScript
Lawrence  Lesch

Lawrence Lesch

1672736116

Saas: Build your own SaaS business with SaaS boilerplate

SaaS Boilerplate

Open source web app that saves you many days of work when building your own SaaS product. The boilerplate comes with many basic SaaS features (see Features below) so that you can focus on features that differentiate your product.

Features

  • Server-side rendering for fast initial load and SEO.
  • User authentication with Google OAuth API and Passwordless, cookie, and session.
  • Production-ready Express server with compression, parser, and helmet.
  • Transactional emails (AWS SES): welcome, team invitation, and payment.
  • Adding email addresses to newsletter lists (Mailchimp): new users, paying users.
  • File upload, load, and deletion (AWS S3) with pre-signed request for: Posts, Team Profile, and User Profile.
  • Websockets with socket.io v3.
  • Team creation, Team Member invitation, and settings for Team and User.
  • Opinionated architecture:
    • keeping babel and webpack configurations under the hood,
    • striving to minimize number of configurations,
    • withAuth HOC to pass user prop and control user access to pages,
    • HOC extensions MyApp and MyDocument
    • server-side rendering with Material-UI,
    • model-specific components in addition to common components.
  • Universally-available environmental variables at runtime.
  • Custom logger (configure what not to print in production).
  • Useful components for any web app: ActiveLink, Confirm, Notifier, MenuWithLinks, and more.
  • Analytics with Google Analytics.
  • Production-ready, scalable architecture:
    • app - user-facing web app with Next/Express server, responsible for rendering pages (either client-side or server-side rendered). app sends requests via API methods to api Express server.
    • api - server-only code, Express server, responsible for processing requests for internal and external API infrastructures.
  • Subscriptions with Stripe:
    • subscribe/unsubscribe Team to plan,
    • update card information,
    • verified Stripe webhook for failed payment for subscription.

Running api locally:

  • Before running, create a .env file inside the api folder with the environmental variables as shown below. These variables are also listed in .env.example, which you can use as a template to create your own .env file inside the api foler.

api/.env:

# Used in api/server/server.ts
MONGO_URL_TEST=
MONGO_URL=
SESSION_NAME=
SESSION_SECRET=
COOKIE_DOMAIN=

# Used in api/server/google.ts
GOOGLE_CLIENTID=
GOOGLE_CLIENTSECRET=

# Used in api/server/aws-s3.ts and api/server/aws-ses.ts
AWS_REGION=
AWS_ACCESSKEYID=
AWS_SECRETACCESSKEY=

# Used in api/server/models/Invitation.ts and api/server/models/User.ts
EMAIL_SUPPORT_FROM_ADDRESS=

# Used in api/server/mailchimp.ts
MAILCHIMP_API_KEY=
MAILCHIMP_REGION=
MAILCHIMP_SAAS_ALL_LIST_ID=

----------
# All env variables above this line are needed for successful user signup

# Used in api/server/stripe.ts
STRIPE_TEST_SECRETKEY=sk_test_xxxxxx
STRIPE_LIVE_SECRETKEY=sk_live_xxxxxx

STRIPE_TEST_PLANID=plan_xxxxxx
STRIPE_LIVE_PLANID=plan_xxxxxx

STRIPE_LIVE_ENDPOINTSECRET=whsec_xxxxxx

# Optionally determine the URL
URL_APP="http://localhost:3000"
URL_API="http://localhost:8000"
PRODUCTION_URL_APP="https://saas-app.async-await.com"
PRODUCTION_URL_API="https://saas-api.async-await.com"

Your .env file file must have values for the required variables. To use all features and third-party integrations, also add the optional variables.

IMPORTANT: do not publish your actual values for environmentable variables in .env.example; this file is public and only meant to show you how your .env should look.
 

IMPORTANT: use your values for PRODUCTION_URL_APP and PRODUCTION_URL_API. These are values for domain name that you own.

IMPORTANT: The above environmental variables are available on the server only. You should add your .env file to .gitignore inside the api folder so that your secret keys are not stored on a remote Github repo.

To get value for MONGO_URL_TEST, we recommend you use a free MongoDB at MongoDB Atlas or $15/month MongoDB at Digital Ocean

Specify your own name and secret keys for Express session: SESSION_NAME and SESSION_SECRET

Get GOOGLE_CLIENTID and GOOGLE_CLIENTSECRET by following the official OAuth tutorial
Important: For Google OAuth app, callback URL is: http://localhost:8000/oauth2callback 
Important: You have to enable Google+ API in your Google Cloud Platform account.

Once .env is created, you can run the api app. Navigate to the api folder, run yarn install to add all packages, then run the command below:

yarn dev

Running app locally:

Navigate to the app folder, run yarn to add all packages, then run yarn dev and navigate to http://localhost:3000:

  • A .env file in the app folder is not required to run, but you can create one to override the default variables. The environmental variables for .env in the app folder are shown below. You can also refer .env.example for creating your own .env file in the app folder.
     

IMPORTANT: do not publish your actual values for environmentable variables in .env.example; this file is public and only meant to show you how your .env should look.
 

IMPORTANT: use your values for PRODUCTION_URL_APP and PRODUCTION_URL_API. These are values for domain name that you own.

To get NEXT_PUBLIC_GA_MEASUREMENT_ID, set up Google Analytics and follow these instructions to find your tracking ID.

To get NEXT_PUBLIC_STRIPE_TEST_PUBLISHABLEKEY, go to your Stripe dashboard, click Developers, then click API keys.

For successful file uploading, make sure your buckets have proper CORS configuration. Go to your AWS account, find your bucket, go to Permissions > CORS configuration, add:

[
  {
    "AllowedHeaders":[
      "*"
    ],
    "AllowedMethods":[
      "PUT",
      "POST",
      "GET",
      "HEAD",
      "DELETE"
    ],
    "AllowedOrigins":[
      "http://localhost:3000",
      "https://saas-app.async-await.com"
    ],
    "ExposeHeaders":[
      "ETag",
      "x-amz-meta-custom-header"
    ]
  }
]

Make sure to update allowed origin with your actual values for NEXT_PUBLIC_URL_APP and NEXT_PUBLIC_PRODUCTION_URL_APP.

Once .env is created, you can run the app app. Navigate to the app folder, run yarn install to add all packages, then run the command below:

Symlink api in lambda:

yarn dev

In lambda directory we are symlinking api directory. You can run symlink command in lambda folder as mentioned below:

bash symlink ../api

Deploy to Heroku, AWS Elastic Beanstalk, API Gateway and AWS Lambda

We give detailed instructions inside Chapter 9 and 10 of our SaaS Boilerplate book: https://builderbook.org/book

Built with

For more detail, check package.json files in both app and api folders and project's root.

To customize styles, check this guide.

Screenshots

Google or passwordless login: 1_SaaS_login

Dropdown menu for settings: 2_SaaS_DropdownMenu

Personal settings: 3_SaaS_PersonalSettings

Team settings: 4_SaaS_TeamSettings

Creating a Discussion: 5_SaaS_Discussion_Creation

Writing a Post, Markdown vs. HTML view: 6_SaaS_Discussion_Markdown

7_SaaS_Discussion_HTML

Discussion between team members: 8_SaaS_Discussion_Dark

Billing settings: 9_SaaS_Billing

Purchasing a subscription: 10_SaaS_BuySubscription

Payment history: 12_SaaS_PaymentHistory

Contributing

Want to support this project? Consider buying our books.

Team

You can contact us at team@async-labs.com.

If you are interested in working with us, check out Async Labs.

License

All code in this repository is provided under the MIT License.

Project structure

├── .elasticbeanstalk
│   └── config.yml
├── .github
│   └── FUNDING.yml
├── .vscode
│   ├── extensions.json
│   ├── launch.json
│   └── settings.json
├── api
│   ├── .elasticbeanstalk
│   │   └── config.yml
│   ├── server
│   │   ├── api
│   │   │   ├── index.ts
│   │   │   ├── public.ts
│   │   │   ├── team-leader.ts
│   │   │   └── team-member.ts
│   │   ├── models
│   │   │   ├── Discussion.ts
│   │   │   ├── EmailTemplate.ts
│   │   │   ├── Invitation.ts
│   │   │   ├── Post.ts
│   │   │   ├── Team.ts
│   │   │   └── User.ts
│   │   ├── utils
│   │   │   ├── slugify.ts
│   │   │   └── sum.ts
│   │   ├── aws-s3.ts
│   │   ├── aws-ses.ts
│   │   ├── google-auth.ts
│   │   ├── logger.ts
│   │   ├── mailchimp.ts
│   │   ├── passwordless-auth.ts
│   │   ├── passwordless-token-mongostore.ts
│   │   ├── server.ts
│   │   ├── sockets.ts
│   │   └── stripe.ts
│   ├── static
│   │   └── robots.txt
│   ├── test/server/utils
│   │   ├── slugify.test.ts
│   │   └── sum.test.ts
│   ├── .eslintignore
│   ├── .eslintrc.js
│   ├── .gitignore
│   ├── package.json
│   ├── tsconfig.json
│   ├── tsconfig.server.json
│   └── yarn.lock
├── app
│   ├── .elasticbeanstalk
│   │   └── config.yml
│   ├── components
│   │   ├── common
│   │   │   ├── Confirmer.tsx
│   │   │   ├── LoginButton.tsx
│   │   │   ├── MemberChooser.tsx
│   │   │   ├── MenuWithLinks.tsx
│   │   │   ├── MenuWithMenuItems.tsx
│   │   │   └── Notifier.tsx
│   │   ├── discussions
│   │   │   ├── CreateDiscussionForm.tsx
│   │   │   ├── DiscussionActionMenu.tsx
│   │   │   ├── DiscussionList.tsx
│   │   │   ├── DiscussionListItem.tsx
│   │   │   └── EditDiscussionForm.tsx
│   │   ├── layout
│   │   │   ├── index.tsx
│   │   ├── posts
│   │   │   ├── PostContent.tsx
│   │   │   ├── PostDetail.tsx
│   │   │   ├── PostEditor.tsx
│   │   │   └── PostForm.tsx
│   │   ├── teams
│   │   │   └── InviteMember.tsx
│   ├── lib
│   │   ├── api
│   │   │   ├── makeQueryString.ts
│   │   │   ├── public.ts
│   │   │   ├── sendRequestAndGetResponse.ts
│   │   │   ├── team-leader.ts
│   │   │   └── team-member.ts
│   │   ├── store
│   │   │   ├── discussion.ts
│   │   │   ├── index.ts
│   │   │   ├── invitation.ts
│   │   │   ├── post.ts
│   │   │   ├── team.ts
│   │   │   └── user.ts
│   │   ├── confirm.ts
│   │   ├── isMobile.ts
│   │   ├── notify.ts
│   │   ├── resizeImage.ts
│   │   ├── sharedStyles.ts
│   │   ├── theme.ts
│   │   └── withAuth.tsx
│   ├── pages
│   │   ├── _app.tsx
│   │   ├── _document.tsx
│   │   ├── billing.tsx
│   │   ├── create-team.tsx
│   │   ├── discussion.tsx
│   │   ├── invitation.tsx
│   │   ├── login-cached.tsx
│   │   ├── login.tsx
│   │   ├── team-settings.tsx
│   │   └── your-settings.tsx
│   ├── public
│   │   └── pepe.jpg
│   ├── server
│   │   ├── robots.txt
│   │   ├── routesWithCache.ts
│   │   ├── server.ts
│   │   └── setupSitemapAndRobots.ts
│   ├── .babelrc
│   ├── .eslintignore
│   ├── .eslintrc.js
│   ├── .gitignore
│   ├── next.env.d.ts
│   ├── next.config.js
│   ├── package.json
│   ├── tsconfig.json
│   ├── tsconfig.server.json
│   └── yarn.lock
├── book
├── lambda
│   ├── .estlintignore
│   ├── .eslintrc.js
│   ├── .gitignore
│   ├── api
│   ├── handler.ts
│   ├── package.json
│   ├── serverless.yml
│   ├── tsconfig.json
│   └── yarn.lock
├── .gitignore
├── LICENSE.md
├── README.md
├── package.json
├── yarn.lock

If you want to learn how to build this project from scratch, check out our book: https://builderbook.org/book

The open source project is located in the saas folder. If you purchased our book, codebases for each of the book's chapters are located in the book folder.

Live demo:

Sponsors

aws-activate-logo

1password-logo

Showcase

Check out projects built with the help of this open source app. Feel free to add your own project by creating a pull request.

  • Async: Open source web app for team communication, separate urgent vs. non-urgent conversations.
  • workinbiotech.com: Work in biotech, job board for small and young biotech companies
  • Retaino by Earl Lee: Save, annotate, review, and share great web content. Receive smart email digests to retain key information.
  • Builder Book: Open source web app to publish documentation or books.

Download Details:

Author: Async-labs
Source Code: https://github.com/async-labs/saas 
License: MIT license

#typescript #react #boilerplate #express 

Saas: Build your own SaaS business with SaaS boilerplate
Lawrence  Lesch

Lawrence Lesch

1672196340

A React Native Template for Building Solid Applications

TheCodingMachine React Native boilerplate

This project is a React Native boilerplate that can be used to kickstart a mobile application.

The boilerplate provides an optimized architecture for building solid cross-platform mobile applications through separation of concerns between the UI and business logic. It is fully documented so that each piece of code that lands in your application can be understood and used.

If you love this boilerplate, give us a star, you will be a ray of sunshine in our lives :)

Requirements

Node 12 or greater is required. Development for iOS requires a Mac and Xcode 10 or up, and will target iOS 11 and up.

You also need to install the dependencies required by React Native.
Go to the React Native environment setup, then select React Native CLI Quickstart tab.
Follow instructions for your given development OS and target OS.

Quick start

To create a new project using the boilerplate simply run :

npx react-native init MyApp --template @thecodingmachine/react-native-boilerplate

Assuming you have all the requirements installed, you can run the project by running:

  • yarn start to start the metro bundler, in a dedicated terminal
  • yarn <platform> to run the platform application (remember to start a simulator or connect a device)

Digging Deeper

To learn more about this boilerplate, go to full documentation

About us

TheCodingMachine is a web and mobile agency based in Paris and Lyon, France. We are constantly looking for new developers and team leaders and we love working with freelancers. You'll find an overview of all our open source projects on our website and on Github.

Download Details:

Author: Thecodingmachine
Source Code: https://github.com/thecodingmachine/react-native-boilerplate 
License: MIT license

#typescript #javascript #redux #boilerplate #reactnative 

A React Native Template for Building Solid Applications
Lawrence  Lesch

Lawrence Lesch

1668114180

Prisma-examples: Ready-to-run Prisma Example Projects

Prisma Examples

Ready-to-run Prisma example projects 🚀


This repository contains a number of ready-to-run example projects demonstrating various use cases of Prisma. Pick an example and follow the instructions in the corresponding README.

You can also find links to real-world and production ready examples further below in this README.

Are you missing an example? Please feel free to open an issue (read the contribution guidelines for more info).

TypeScript

Fullstack

DemoDescription
rest-nextjs-api-routesNext.js app with a REST API (using Next.js API routes)
rest-nextjs-api-routes-authNext.js app with a REST API (using Next.js API routes) and authentication (using NextAuth.js)
rest-nextjs-expressNext.js app with a REST API (using Express)
graphql-nextjsNext.js app with a GraphQL API (using Apollo Server and GraphQL Nexus)

Backend only

DemoDescription
graphql-apollo-serverGraphQL server based on apollo-server and Nexus Schema
graphql-authGraphQL server with email-password authentication & permissions
graphql-sdl-firstGraphQL server based on the SDL-first approach of graphql-tools
graphql-subscriptionsGraphQL server with realtime subscriptions based on apollo-server and Nexus Schema
graphql-typegraphqlGraphQL server based on apollo-server and TypeGraphQL
graphql-typegraphql-crudCRUD GraphQL API based on apollo-server and TypeGraphQL
graphql-expressGraphQL server based on Express and Nexus Schema
graphql-express-sdl-firstGraphQL server based on Express and the SDL-first approach of graphql-tools
graphql-fastifyGraphQL server based on Fastify, Mercurius, and the SDL-first approach of graphql-tools
graphql-fastify-sdl-firstGraphQL server based on Fastify, Mercurius, and the SDL-first approach of graphql-tools
graphql-hapiGraphQL server based on Hapi and Nexus Schema
graphql-hapi-sdl-firstGraphQL server based on Hapi and the SDL-first approach of Apollo Server Hapi
graphql-nestjsGraphQL server based on NestJS (code-first)
graphql-nestjs-sdl-firstGraphQL server based on NestJS and the SDL-first approach of graphql-tools
graphqlGraphQL server based on apollo-server and Nexus Schema
grpcgRPC API including runnable client scripts for testing
postgis-expressDemo of spatial queries using Postgis and Express
rest-expressREST API with Express
rest-fastifyREST API with Fastify
rest-koaREST API with Koa
rest-hapiREST API with hapi
rest-nestjsREST API with NestJS
scriptUsage of Prisma Client JS in a TypeScript script
testing-expressDemo of integration tests with Jest, Supertest and Express

JavaScript (Node.js)

Fullstack

DemoDescription
rest-nextjsNext.js app with a REST API (using Next.js API routes)
rest-nuxtjsNuxtJS app with a REST API

Backend only

DemoDescription
graphql-apollo-serverGraphQL server based on apollo-server
graphql-authGraphQL server with email-password authentication & permissions
graphql-sdl-firstGraphQL server based on the SDL-first approach of graphql-tools
grpcgRPC API including runnable client scripts for testing
rest-expressREST API with Express
rest-fastifyREST API with Fastify
rest-koaREST API with Koa
scriptUsage of Prisma Client JS in a Node.js script

Deployment platforms

The projects in the deployment-platforms directory show what "Prisma Client"-based deployment setups look like for various deployment providers. Learn more about deployment in the Prisma documentation.

Real-world & production-ready example projects with Prisma

  • reduced.to: An open-source link shortener
  • Linen: An open-source alternative to Slack and Discord with lots of great features
  • Coolify: An open-source & self-hostable Heroku / Netlify alternative
  • dub: An open-source link shortener with built-in analytics and free custom domains
  • Umami: A simple, fast, privacy-focused alternative to Google Analytics
  • Rallly: A self-hostable doodle poll alternative (based on Next.js, tRPC, and TailwindCSS)
  • snoopForms: An open-source alternative to Typeform (easy online surveys)
  • Typebot: A conversational form builder that you can self-host
  • Cal.com: An open-source alternative to Calendly (calender-based event scheduling service)
  • Beam: A simple tool that allows members to write posts to share across your organization (based on Next.js)
  • ironfish-api: Public API for Iron Fish (A novel cryptocurrency focused on privacy and accessibility)
  • Indie Stack: Remix Stack for deploying to Fly with SQLite, authentication, testing, linting, formatting
  • Blues Stack: Remix Stack for deploying to Fly with PostgreSQL, authentication, testing, linting, formatting
  • Tottem: Fullstack app for "social library management" (based on Next.js)

About this repository

The latest branch of this repository contains the examples with the latest stable version of Prisma CLI and Prisma Client (@latest on npm). These dependencies are kept up to date with a GitHub Action workflow, which updates them every time a new version of Prisma is released.

There are also the automated branches dev and patch-dev, which mirror the code from latest (synced via a GitHub Action workflow), but they use the respective development channels of Prisma CLI and Prisma Client from npm instead (@dev and @patch-dev, also updated via a GitHub Action workflow). Thanks to the test coverage of all projects, this can point us to incompatibilities early.

Security

If you have a security issue to report, please contact us at security@prisma.io

CI status

CI StatusBranch
test latestlatest
test devdev
test patch-devpatch-dev
CI Status
keep-prisma-dependencies-updated
keep-dev-branches-in-sync-with-latest

View full CI status


Download Details:

Author: Prisma
Source Code: https://github.com/prisma/prisma-examples 
License: Apache-2.0 license

#typescript #nodejs #graphql #boilerplate 

Prisma-examples: Ready-to-run Prisma Example Projects
Hermann  Frami

Hermann Frami

1667982807

Boilerplate Project for Creating Web Apps with React.js, GraphQL.js

React Starter Kit for Firebase   a.k.a. Serverless Edition

React Starter Kit for Firebase is a popular project template (aka, boilerplate) for building modern, scalable web applications with React, Relay, and GraphQL using serverless infrastructure provided by Google Cloud (Cloud SQL, Cloud Functions, CDN hosting, and file storage). It allows you to save time and build upon a solid foundation and design patterns.


This project was bootstrapped with React Starter Kit for Firebase by Kriasoft.

Tech Stack

Also, you need to be familiar with HTML, CSS, JavaScript (ES2015) and React.

Directory Layout

├── build/                         # Compiled output
├── migrations/                    # Database schema migration files
├── node_modules/                  # 3rd-party libraries and utilities
├── public/                        # Static files such as favicon.ico etc.
├── scripts/                       # Automation scripts (yarn update-schema etc.)
├── src/                           # Application source code
│   ├── admin/                     # Admin section (Dashboard, User Management etc.)
│   ├── common/                    # Shared React components and HOCs
│   ├── hooks/                     # React.js hooks and Context providers
│   ├── icons/                     # Icon components
│   ├── legal/                     # Terms of Use, Privacy Policy, etc.
│   ├── misc/                      # Other pages (about us, contacts, etc.)
│   ├── mutations/                 # GraphQL mutations to be used on the client
│   ├── news/                      # News section (example)
│   ├── server/                    # Server-side code (API, authentication, etc.)
│   │   ├── mutations/             # GraphQL mutations
│   │   ├── queries/               # The top-level GraphQL query fields
│   │   ├── templates/             # HTML templates for server-side rendering
│   │   ├── types/                 # GraphQL types: User, UserRole, UserIdentity etc.
│   │   ├── api.js                 # GraphQL API middleware
│   │   ├── app.js                 # Express.js application
│   │   ├── config.js              # Configuration settings to be passed to the client
│   │   ├── context.js             # GraphQL context wrapper
│   │   ├── db.js                  # PostgreSQL database client (Knex.js)
│   │   ├── relay.js               # Relay factory method for Node.js environment
│   │   ├── index.js               # Node.js app entry point
│   │   ├── login.js               # Authentication middleware (e.g. /login/facebook)
│   │   ├── schema.js              # GraphQL schema
│   │   └── ssr.js                 # Server-side rendering, e.g. ReactDOMServer.renderToString(<App />)
│   ├── user/                      # User pages (login, account settings, user profile, etc)
│   ├── utils/                     # Utility functions
│   ├── relay.js                   # Relay factory method for browser environment
│   ├── index.js                   # Client-side entry point, e.g. ReactDOM.render(<App />, container)
│   ├── router.js                  # Universal application router
│   ├── serviceWorker.js           # Service worker helper methods
│   └── theme.js                   # Overrides for Material UI default styles
├── ssl/                           # SSL certificates for connecting to Cloud SQL instance
├── .env                           # Environment variables for local development
├── .env.production                # Environment variables for the production build
├── .env.test                      # Environment variables for the test build
├── graphql.schema                 # GraphQL schema (auto-generated, used by Relay)
└── package.json                   # The list of project dependencies + NPM scripts

Prerequisites

Getting Started

Just clone the repo, update environment variables in .env and/or .env.local file, and start hacking:

$ git clone https://github.com/kriasoft/react-firebase-starter.git MyApp
$ cd MyApp
$ yarn setup                       # Installs dependencies; creates PostgreSQL database
$ yarn start                       # Compile the app and opens it in a browser with "live reload"

Then open http://localhost:3000/ to see your app.
 

npm start

In order to re-compile GraphQL fragments, run yarn relay or yarn relay --watch (in watch mode).

How to Migrate Database Schema

While the app is in development, you can use a simplified migration workflow by creating a backup of your existing database, making changes to the existing migration file (see migrations/20180101000000_initial.js), re-apply the migration and restore data from the backup file (backup.sql):

$ yarn db-backup --env=dev         # Or, yarn db-backup --env=test
$ yarn db-reset-dev                # Or, yarn db-reset-test

Upon deployment to production, switch to normal migration workflow:

$ yarn db-change <name>            # Create a new database migration file
$ yarn db-migrate --env=dev        # Migrate database to the latest version

HINT: Test your migration thoroughly with a local instance of the DB first (by using --env=local or --env=dev (default) flag) then apply it to your test or prod database instance using --env=test or --env=prod command argument.

Other helpful database scripts:

$ yarn db-version --env=dev        # Print the version number of the last migration
$ yarn db-rollback --env=dev       # Rollback the latest migration
$ yarn db-restore --env=dev        # Restore database from backup.sql
$ yarn db-seed --env=dev           # Seed database with test data
$ yarn db --env=dev                # Open Knex.js REPL shell (type ".exit" for exit)
$ yarn psql --env=dev              # Open PostgreSQL shell (type "\q" for exit)

How to Test

$ yarn lint                        # Check JavaScript and CSS code for potential issues
$ yarn lint-fix                    # Attempt to automatically fix ESLint warnings
$ yarn test                        # Run unit tests. Or, `yarn test -- --watch`

How to Deploy

$ yarn build                       # Build the in production mode (NODE_ENV=production)
$ yarn deploy-test                 # Deploy the app to TEST environment
$ yarn deploy-prod                 # Deploy the app to PROD environment

For more information refer to the Deployment guide in the project's Wiki.

How to Update

If you keep the original Git history after cloning this repo, you can always fetch and merge the recent updates back into your project by running:

$ git remote add rsk https://github.com/kriasoft/react-firebase-starter.git
$ git checkout master
$ git fetch rsk
$ git merge rsk/master
$ yarn install

NOTE: Try to merge as soon as the new changes land on the master branch in the upstream repository, otherwise your project may differ too much from the base/upstream repo. Alternatively, you can use a folder diff tool like Beyond Compare for keeping your project up to date with the base repository.

Backers

             

How to Contribute

Anyone and everyone is welcome to contribute to this project. The best way to start is by checking our open issues, submit a new issues or feature request, participate in discussions, upvote or downvote the issues you like or dislike, send pull requests.

Learn React.js and ES6

:mortar_board:   React for Beginners and ES6 Training Course by Wes Bos
:green_book:   React: Up & Running: Building Web Applications by Stoyan Stefanov (Aug, 2016)
:green_book:   Getting Started with React by Doel Sengupta and Manu Singhal (Apr, 2016)
:green_book:   You Don't Know JS: ES6 & Beyond by Kyle Simpson (Dec, 2015)
 

Related Projects

  • React App SDK — Create React App modification that unlocks server-side rendering
  • React Starter Kit — Boilerplate and tooling for building isomorphic web apps with React and Relay
  • Node.js API Starter Kit — Boilerplate and tooling for building data APIs with Docker, Node.js and GraphQL

Made with ♥ by Konstantin Tarkus (@koistya, blog) and contributors 👋 Get in touch!

Download Details:

Author: Kriasoft
Source Code: https://github.com/kriasoft/react-firebase-starter 
License: MIT license

#serverless #react #javascript #graphql #boilerplate 

Boilerplate Project for Creating Web Apps with React.js, GraphQL.js
Reid  Rohan

Reid Rohan

1667055369

A Foundation for Scalable Cross-Platform Apps

Electron React Boilerplate

Electron React Boilerplate uses Electron, React, React Router, Webpack and React Fast Refresh.

Install

Clone the repo and install dependencies:

git clone --depth 1 --branch main https://github.com/electron-react-boilerplate/electron-react-boilerplate.git your-project-name
cd your-project-name
npm install

Having issues installing? See our debugging guide

Starting Development

Start the app in the dev environment:

npm start

Packaging for Production

To package apps for the local platform:

npm run package

Docs

See our docs and guides here

Community

Join our Discord: https://discord.gg/Fjy3vfgy5q

Maintainers

Download Details:

Author: Electron-react-boilerplate
Source Code: https://github.com/electron-react-boilerplate/electron-react-boilerplate 
License: MIT license

#typescript #electron #react #javascript #boilerplate 

A Foundation for Scalable Cross-Platform Apps

A Simple Boilerplate for Creating Statics PWA using Webpack, Pug

Kratos Boilerplate

A simple boilerplate for creating a static PWA using Webpack, Pug, PostCSS and CSS Modules

Generate a new project with Yeoman

To make easy create a new projects, Kratos has a generator using Yeoman

To use it:

# install yeoman
$ npm install -g yo

# install kratos generator
$ npm install -g generator-kratos-boilerplate

# generate a new project
$ yo kratos-boilerplate

Getting Started

# install dependencies
$ npm i

# run the project
$ npm start

With the commands above, you have everything to start.

The app.config.json file has all minimal config to create your scaffolding.

About CSS

This project use Sass as CSS preprocessor 😁

Post CSS libs

For grid system uses Autoprefixer to make easy use browser prefixes, Lost with some help from, Rucksack for animations, reset and a lot of great mixins, Rupture for responsive utilities. And Font Magician to get the webfonts.

CSS Modules

To make easier create your components and avoid a lot of problems, it boilerplate use CSS Modules.

Example

.host text-align center .title font-size 4rem .description font-size 2rem;

After the transformation it will become like this

._host_4897k_1 {
  text-align: center;
}

._title_4897k_9 {
  font-size: 4rem;
}

._description_4897k_12 {
  font-size: 2rem;
}

Tasks

  • npm start: run all tasks and initialize watch for changes and a server
  • npm run build: run all production tasks create a dist folder to deploy
  • npm run lint: lint javascript and css
  • npm run fix: command to fix all eslint errors
  • npm run deploy: run all tasks to build and deploy on gh-pages

Download Details:

Author: felipefialho
Source Code: https://github.com/felipefialho/kratos-boilerplate 
License: MIT license

#javascript #boilerplate #css #sass 

A Simple Boilerplate for Creating Statics PWA using Webpack, Pug

Boilerplate for Npm Modules with ES6 Features & All The Best Practices

NPM Module Boilerplate 

NOTE: This setup is pretty old and outdated for 2022. I need to update it to use Microbundle. In the meanwhile, do yourself a favour and setup your lib with Microbundle directly (it's pretty simple and straightforward) instead of using the boilerplate code.

Start developing your NPM module in seconds

Readymade boilerplate setup with all the best practices to kick start your npm/node module development.

Happy hacking =)

Features

  • ES6/ESNext - Write ES6 code and Babel will transpile it to ES5 for backwards compatibility
  • Test - Mocha with Istanbul coverage
  • Lint - Preconfigured ESlint with Airbnb config
  • CI - TravisCI configuration setup
  • Minify - Built code will be minified for performance

Commands

  • npm run clean - Remove lib/ directory
  • npm test - Run tests with linting and coverage results.
  • npm test:only - Run tests without linting or coverage.
  • npm test:watch - You can even re-run tests on file changes!
  • npm test:prod - Run tests with minified code.
  • npm run test:examples - Test written examples on pure JS for better understanding module usage.
  • npm run lint - Run ESlint with airbnb-config
  • npm run cover - Get coverage report for your code.
  • npm run build - Babel will transpile ES6 => ES5 and minify the code.
  • npm run prepublish - Hook for npm. Do all the checks before publishing your module.

Installation

Just clone this repo and remove .git folder.

Download Details:

Author: flexdinesh
Source Code: https://github.com/flexdinesh/npm-module-boilerplate 
License: MIT license

#javascript #npm #modules #boilerplate 

Boilerplate for Npm Modules with ES6 Features & All The Best Practices

A Simple & Stupid Boilerplate Project Wrapping Around Boltdb

boltdb-boilerplate

boltdb-boilerplate is a simple & stupid boilerplate project wrapping around boltdb, and aim to make simple calls as one-liners.

Methods Summary

  • InitBolt: Init the database
  • Close: Close the database
  • Get: Retrieve a value by key
  • Put: Put a key/value pair into a bucket
  • Delete: Delete a key/value pair from a bucket
  • GetAllKeys: Get all keys from a bucket in [][]byte fromat
  • GetAllKeyValues: Get all key/value pairs from a bucket in []BoltPair fromat

Usage Demo

// import
import "github.com/bobintornado/boltdb-boilerplate"

// Init
buckets := []string{"ownerBucket", "sensors"}

err := boltdbboilerplate.InitBolt("./database.boltdb", buckets)
if err != nil {
  log.Fatal("Can't init boltDB")
}

// Put
err = boltdbboilerplate.Put([]byte("ownerBucket"), []byte("ownerKey"), []byte("username"))

// Get owner 
value := boltdbboilerplate.Get([]byte("ownerBucket"), []byte("ownerKey"))

// Delete
err = boltdbboilerplate.Delete([]byte("ownerBucket"), []byte("ownerKey"))

// Insert two key/value
err = boltdbboilerplate.Put([]byte("sensors"), []byte("key1"), []byte("value1"))
err = boltdbboilerplate.Put([]byte("sensors"), []byte("key2"), []byte("value2"))

// Get all keys
keys := boltdbboilerplate.GetAllKeys([]byte("sensors"))
// keys = [key1, key2]

// Get all key/value pairs
pairs := boltdbboilerplate.GetAllKeyValues([]byte("sensors"))
// pairs = [{Key:key1, Value:value1}, {Key: key2, Value:value2}]

// Close
boltdbboilerplate.Close()

Docs

GoDoc

Download Details:

Author: Bobintornado
Source Code: https://github.com/bobintornado/boltdb-boilerplate 
License: CC0-1.0 license

#go #golang #boilerplate 

A Simple & Stupid Boilerplate Project Wrapping Around Boltdb
Dexter  Goodwin

Dexter Goodwin

1659337740

Dojo.js: Coding Dojo Boilerplate for JavaScript

dojo.js

Minimalistic Coding Dojo Boilerpalte

How to use?

npm install generator-dojo-js -gdojojs [name] [dir]

After generate boilerplate using generator-dojo-js, go to the directory and install its dependencies using npm install. To run, type npm start.

Dependencies

  • Ava

🦄

Author: gpedro
Source Code: https://github.com/gpedro/dojo.js 
License: 

#javascript #boilerplate 

Dojo.js: Coding Dojo Boilerplate for JavaScript
Dexter  Goodwin

Dexter Goodwin

1659322920

Dojo-boilerplate: A starting point for developing with Dojo

Dojo Boilerplate: A Starter Kit for Dojo Development

The Dojo Boilerplate is a set of files to help you rapidly get up and running with the Dojo Toolkit. It illustrates some basic best practices when working with Dojo.

Quick Start

  1. Make sure you have Node.js and a Java runtime installed.
  2. Clone the repository using git clone --recursive.
  3. Run npm install to install additional Node.js dependencies.
  4. Develop your project in src/ until it is amazing.
  5. Run build.sh, which will create an awesome optimised build in dist/.
  6. Upload dist/ for millions of people the world over to enjoy.
  7. Hapyness.

Windows Users

If you have msysgit installed, run Git Bash and verify some dependencies by running the following commands:

which java
which node

A brief tour

  • All of the application's source goes in src. It will be built into dist.
  • Build profiles for the build system go in profiles.
  • The entrypoint of the demo application is the HTML file at src/index.html.
  • The build.sh script takes your application files and builds them for production use using Stylus and the Dojo build system. It depends on the presence of an application build profile at profiles/app.profile.js.
  • The file src/app/resources/app.styl contains all the CSS for the application.
  • Tests using Intern exist in the tests directory. They can be run with tests/run.sh. The test configuration is at tests/intern.js and defaults to using a Sauce Labs tunnel.

Useful resources

About the boilerplate

This boilerplate is occasionally updated to try to reflect the latest and greatest features and design patterns for writing Web apps with Dojo, but it relies heavily on information and contributions from other users. If you have an idea, suggestion, or problem, please report it or create a pull request! (Please note that you will need to have signed the Dojo CLA before your pull requests are accepted, for the good of us all!)

Author: csnover
Source Code: https://github.com/csnover/dojo-boilerplate 
License: BSD license

#javascript #boilerplate 

Dojo-boilerplate: A starting point for developing with Dojo

Hackathon Starter: A Boilerplate for Node.js Web Applications

 Hackathon Starter 

Jump to What's new?

A boilerplate for Node.js web applications.

If you have attended any hackathons in the past, then you know how much time it takes to get a project started: decide on what to build, pick a programming language, pick a web framework, pick a CSS framework. A while later, you might have an initial project up on GitHub, and only then can other team members start contributing. Or how about doing something as simple as Sign in with Facebook authentication? You can spend hours on it if you are not familiar with how OAuth 2.0 works.

When I started this project, my primary focus was on simplicity and ease of use. I also tried to make it as generic and reusable as possible to cover most use cases of hackathon web apps, without being too specific. In the worst case, you can use this as a learning guide for your projects, if for example you are only interested in Sign in with Google authentication and nothing else.

Testimonials

“Nice! That README alone is already gold!”
— Adrian Le Bas

“Awesome. Simply awesome.”
— Steven Rueter

“I'm using it for a year now and many projects, it's an awesome boilerplate and the project is well maintained!”
— Kevin Granger

“Small world with Sahat's project. We were using his hackathon starter for our hackathon this past weekend and got some prizes. Really handy repo!”
— Interview candidate for one of the companies I used to work with.

Modern Theme

Flatly Bootstrap Theme

API Examples

Table of Contents

Features

  • Local Authentication using Email and Password
  • OAuth 1.0a Authentication via Twitter
  • OAuth 2.0 Authentication via Facebook, Google, GitHub, LinkedIn, Instagram
  • Flash notifications
  • MVC Project Structure
  • Node.js clusters support
  • Sass stylesheets (auto-compiled via middleware)
  • Bootstrap 4 + Extra Themes
  • Contact Form (powered by Mailgun, Sendgrid or Mandrill)
  • Account Management
  • Gravatar
  • Profile Details
  • Change Password
  • Forgot Password
  • Reset Password
  • Link multiple OAuth strategies to one account
  • Delete Account
  • CSRF protection
  • API Examples: Facebook, Foursquare, Last.fm, Tumblr, Twitter, Stripe, LinkedIn, and more.

Prerequisites

Note: If you are new to Node or Express, you may find Node.js & Express From Scratch series helpful for learning the basics of Node and Express. Alternatively, here is another great tutorial for complete beginners - Getting Started With Node.js, Express, MongoDB.

Getting Started

The easiest way to get started is to clone the repository:

# Get the latest snapshot
git clone https://github.com/sahat/hackathon-starter.git myproject

# Change directory
cd myproject

# Install NPM dependencies
npm install

# Then simply start your app
node app.js

Warning: If you want to use some API that needs HTTPS to work (for example Pinterest or Facebook), you will need to download ngrok. You must start ngrok after starting the project.

# start ngrok to intercept the data exchanged on port 8080
./ngrok http 8080

Next, you must use the https URL defined by ngrok, for example, https://hackaton.ngrok.io

Note: I highly recommend installing Nodemon. It watches for any changes in your node.js app and automatically restarts the server. Once installed, instead of node app.js use nodemon app.js. It will save you a lot of time in the long run, because you won't need to manually restart the server each time you make a small change in code. To install, run sudo npm install -g nodemon.

Obtaining API Keys

To use any of the included APIs or OAuth authentication methods, you will need to obtain appropriate credentials: Client ID, Client Secret, API Key, or Username & Password. You will need to go through each provider to generate new credentials.

  • Visit Google reCAPTCHA Admin Console
  • Enter your application's name as the Label
  • Choose reCAPTCHA v2, "I'm not a robot" Checkbox
  • Enter localhost as the domain. You can have other domains added in addition to localhost
  • Accept the terms and submit the form
  • Copy the Site Key and the Secret key into .env. These keys will be accessible under Settings, reCAPTCHA keys drop down if you need them again later

  • Visit Google Cloud Console
  • Click on the Create Project button
  • Enter Project Name, then click on Create button
  • Then click on APIs & auth in the sidebar and select API tab
  • Click on Google+ API under Social APIs, then click Enable API
  • Click on Google Drive API under G Suite, then click Enable API
  • Click on Google Sheets API under G Suite, then click Enable API
  • Next, under APIs & auth in the sidebar click on Credentials tab
  • Click on Create new Client ID button
  • Select Web Application and click on Configure Consent Screen
  • Fill out the required fields then click on Save
  • In the Create Client ID modal dialog:
  • Application Type: Web Application
  • Authorized Javascript origins: http://localhost:8080
  • Authorized redirect URI: http://localhost:8080/auth/google/callback
  • Click on Create Client ID button
  • Copy and paste Client ID and Client secret keys into .env

Note: When you ready to deploy to production don't forget to add your new URL to Authorized Javascript origins and Authorized redirect URI, e.g. http://my-awesome-app.herokuapp.com and http://my-awesome-app.herokuapp.com/auth/google/callback respectively. The same goes for other providers.


  • Visit Snap Kit Developer Portal
  • Click on the + button to create an app
  • Enter a name for your app
  • Enable the scopes that you will want to use in your app
  • Click on the Continue button
  • Find the Kits section and make sure that Login Kit is enabled
  • Find the Redirect URLs section, click the + Add button, and enter http://localhost:8080/auth/snapchat/callback
  • Find the Development Environment section. Click the Generate button next to the Confidential OAuth2 Client heading within it.
  • Copy and paste the generated Private Key and OAuth2 Client ID keys into .env
  • Note: OAuth2 Client ID is SNAPCHAT_ID, Private Key is SNAPCHAT_SECRET in .env
  • To prepare the app for submission, fill out the rest of the required fields: Category, Description, Privacy Policy Url, and App Icon

Note: For production use, don't forget to:

  • generate a Confidential OAuth2 Client in the Production Environment and use the production Private Key and OAuth2 Client ID
  • add the production URL to Redirect URLs section, e.g. http://my-awesome-app.herokuapp.com/auth/snapchat/callback
  • submit the app for review and wait for approval

  • Visit Facebook Developers
  • Click My Apps, then select *Add a New App from the dropdown menu
  • Enter a new name for your app
  • Click on the Create App ID button
  • Find the Facebook Login Product and click on Facebook Login
  • Instead of going through their Quickstart, click on Settings for your app in the top left corner
  • Copy and paste App ID and App Secret keys into .env
  • Note: App ID is FACEBOOK_ID, App Secret is FACEBOOK_SECRET in .env
  • Enter localhost under App Domains
  • Choose a Category that best describes your app
  • Click on + Add Platform and select Website
  • Enter http://localhost:8080 under Site URL
  • Click on the Settings tab in the left nav under Facebook Login
  • Enter http://localhost:8080/auth/facebook/callback under Valid OAuth redirect URIs

Note: After a successful sign-in with Facebook, a user will be redirected back to the home page with appended hash #_=_ in the URL. It is not a bug. See this Stack Overflow discussion for ways to handle it.


  • Go to Account Settings
  • Select Developer settings from the sidebar
  • Then click on OAuth Apps and then on Register new application
  • Enter Application Name and Homepage URL
  • For Authorization Callback URL: http://localhost:8080/auth/github/callback
  • Click Register application
  • Now copy and paste Client ID and Client Secret keys into .env file

  • Sign in at https://apps.twitter.com
  • Click Create a new application
  • Enter your application name, website and description
  • For Callback URL: http://127.0.0.1:8080/auth/twitter/callback
  • Go to Settings tab
  • Under Application Type select Read and Write access
  • Check the box Allow this application to be used to Sign in with Twitter
  • Click Update this Twitter's applications settings
  • Copy and paste Consumer Key and Consumer Secret keys into .env file

  • Sign in at LinkedIn Developer Network
  • From the account name dropdown menu select API Keys
  • It may ask you to sign in once again
  • Click + Add New Application button
  • Fill out all the required fields
  • OAuth 2.0 Redirect URLs: http://localhost:8080/auth/linkedin/callback
  • JavaScript API Domains: http://localhost:8080
  • For Default Application Permissions make sure at least the following is checked:
  • r_basicprofile
  • Finish by clicking Add Application button
  • Copy and paste API Key and Secret Key keys into .env file
  • API Key is your clientID
  • Secret Key is your clientSecret

  • Sign up or log into your dashboard
  • Click on your profile and click on Account Settings
  • Then click on API Keys
  • Copy the Secret Key. and add this into .env file

  • Visit PayPal Developer
  • Log in to your PayPal account
  • Click Applications > Create App in the navigation bar
  • Enter Application Name, then click Create app
  • Copy and paste Client ID and Secret keys into .env file
  • App ID is client_id, App Secret is client_secret
  • Change host to api.paypal.com if you want to test against production and use the live credentials


  • Go to http://www.tumblr.com/oauth/apps
  • Once signed in, click +Register application
  • Fill in all the details
  • For Default Callback URL: http://localhost:8080/auth/tumblr/callback
  • Click ✔Register
  • Copy and paste OAuth consumer key and OAuth consumer secret keys into .env file


  • Visit the Twitch developer dashboard
  • If prompted, authorize the dashboard to access your twitch account
  • In the Console, click on Register Your Application
  • Enter the name of your application
  • Use OAuth Redirect URLs enter http://localhost:8080/auth/twitch/callback
  • Set Category to Website Integration and press the Create button
  • After the application has been created, click on the Manage button
  • Copy and paste Client ID into .env
  • If there is no Client Secret displayed, click on the New Secret button and then copy and paste the Client secret into .env

You can use SendGrid for sending emails. The developer tier allows you to send 100 free emails per day. As an Alternative to SendGrid, you may also choose to use an SMTP service provider. If using SendGrid:

  • Go to https://sendgrid.com/user/signup
  • Sign up and confirm your account via the activation email
  • Then enter your SendGrid API Key into .env file as SENDGRID_API_KEY

If using an SMTP service provider instead of SendGrid:

  • Set SMTP_USER and SMTP_PASSWORD in .env, and remove SENDGRID_API_KEY

  • Go to http://www.mailgun.com
  • Sign up and add your Domain Name
  • From the domain overview, copy and paste the default SMTP Login and Password into .env file

  • Go to https://developer.here.com
  • Sign up and create a Freemium project
  • Create JAVASCRIPT/REST credentials. Copy and paste the APP_ID and APP into .env file.
  • Note that these credentials are available on the client-side, and you need to create a domain whitelist for your app credentials when you are publicly launching the app.

  • Go to https://www.twilio.com/try-twilio
  • Sign up for an account.
  • Once logged into the dashboard, expand the link 'show api credentials'
  • Copy your Account Sid and Auth Token

Project Structure

NameDescription
config/passport.jsPassport Local and OAuth strategies, plus login middleware.
controllers/api.jsController for /api route and all api examples.
controllers/contact.jsController for contact form.
controllers/home.jsController for home page (index).
controllers/user.jsController for user account management.
models/User.jsMongoose schema and model for User.
public/Static assets (fonts, css, js, img).
public/js/application.jsSpecify client-side JavaScript dependencies.
public/js/app.jsPlace your client-side JavaScript here.
public/css/main.scssMain stylesheet for your app.
public/css/themes/default.scssSome Bootstrap overrides to make it look prettier.
views/account/Templates for login, password reset, signup, profile.
views/api/Templates for API Examples.
views/partials/flash.pugError, info and success flash notifications.
views/partials/header.pugNavbar partial template.
views/partials/footer.pugFooter partial template.
views/layout.pugBase template.
views/home.pugHome page template.
.dockerignoreFolder and files ignored by docker usage.
.env.exampleYour API keys, tokens, passwords and database URI.
.eslintrcRules for eslint linter.
.gitignoreFolder and files ignored by git.
.travis.ymlConfiguration files for continuous integration.
app.jsThe main application file.
docker-compose.ymlDocker compose configuration file.
DockerfileDocker configuration file.
package.jsonNPM dependencies.
package-lock.jsonContains exact versions of NPM dependencies in package.json.

Note: There is no preference for how you name or structure your views. You could place all your templates in a top-level views directory without having a nested folder structure if that makes things easier for you. Just don't forget to update extends ../layout and corresponding res.render() paths in controllers.

List of Packages

PackageDescription
@octokit/restGitHub API library.
bcryptLibrary for hashing and salting user passwords.
body-parserNode.js body parsing middleware.
chaiBDD/TDD assertion library.
chalkTerminal string styling done right.
cheerioScrape web pages using jQuery-style syntax.
compressionNode.js compression middleware.
connect-mongoMongoDB session store for Express.
dotenvLoads environment variables from .env file.
errorhandlerDevelopment-only error handler middleware.
eslintLinter JavaScript.
eslint-config-airbnb-baseConfiguration eslint by airbnb.
eslint-plugin-chai-friendlyMakes eslint friendly towards Chai.js 'expect' and 'should' statements.
eslint-plugin-importESLint plugin with rules that help validate proper imports.
expressNode.js web framework.
express-flashProvides flash messages for Express.
express-sessionSimple session middleware for Express.
instagram-nodeInstagram API library.
lastfmLast.fm API library.
lobLob API library.
lodashA utility library for working with arrays, numbers, objects, strings.
luscaCSRF middleware.
mailcheckerVerifies that an email address is valid and not a disposable address.
mochaTest framework.
momentParse, validate, compute dates and times.
mongooseMongoDB ODM.
morganHTTP request logger middleware for node.js.
multerNode.js middleware for handling multipart/form-data.
node-foursquareFoursquare API library.
node-sassNode.js bindings to libsass.
node-sass-middlewareSass middleware compiler.
nycCoverage test.
nodemailerNode.js library for sending emails.
node-quickbooksQuickbooks API library.
passportSimple and elegant authentication library for node.js.
passport-facebookSign-in with Facebook plugin.
passport-githubSign-in with GitHub plugin.
passport-google-oauthSign-in with Google plugin.
passport-instagramSign-in with Instagram plugin.
passport-linkedin-oauth2Sign-in with LinkedIn plugin.
passport-localSign-in with Username and Password plugin.
passport-openidSign-in with OpenId plugin.
passport-oauthAllows you to set up your own OAuth 1.0a and OAuth 2.0 strategies.
passport-oauth2-refreshA library to refresh OAuth 2.0 access tokens using refresh tokens.
passport-snapchatSign-in with Snapchat plugin.
passport-twitterSign-in with Twitter plugin.
passport-twitch-newSign-in with Twitch plugin.
paypal-rest-sdkPayPal APIs library.
pugTemplate engine for Express.
sinonTest spies, stubs and mocks for JavaScript.
stripeOffical Stripe API library.
supertestHTTP assertion library.
tumblr.jsTumblr API library.
twilioTwilio API library.
twitter-liteTwitter API library.
validatorA library of string validators and sanitizers.

Useful Tools and Resources

  • JavaScripting - The Database of JavaScript Libraries
  • JS Recipes - JavaScript tutorials for backend and frontend development.
  • HTML to Pug converter - HTML to PUG is a free online converter helping you to convert HTML files to pug syntax in real-time.
  • JavascriptOO - A directory of JavaScript libraries with examples, CDN links, statistics, and videos.
  • Favicon Generator - Generate favicons for PC, Android, iOS, Windows 8.

Recommended Design Resources

Recommended Node.js Libraries

  • Nodemon - Automatically restart Node.js server on code changes.
  • geoip-lite - Geolocation coordinates from IP address.
  • Filesize.js - Pretty file sizes, e.g. filesize(265318); // "265.32 kB".
  • Numeral.js - Library for formatting and manipulating numbers.
  • Node Inspector - Node.js debugger based on Chrome Developer Tools.
  • node-taglib - Library for reading the meta-data of several popular audio formats.
  • sharp - Node.js module for resizing JPEG, PNG, WebP and TIFF images.

Recommended Client-side Libraries

  • Framework7 - Full Featured HTML Framework For Building iOS7 Apps.
  • InstantClick - Makes your pages load instantly by pre-loading them on mouse hover.
  • NProgress.js - Slim progress bars like on YouTube and Medium.
  • Hover - Awesome CSS3 animations on mouse hover.
  • Magnific Popup - Responsive jQuery Lightbox Plugin.
  • jQuery Raty - Star Rating Plugin.
  • Headroom.js - Hide your header until you need it.
  • X-editable - Edit form elements inline.
  • Offline.js - Detect when user's internet connection goes offline.
  • Alertify.js - Sweet looking alerts and browser dialogs.
  • selectize.js - Styleable select elements and input tags.
  • drop.js - Powerful Javascript and CSS library for creating dropdowns and other floating displays.
  • scrollReveal.js - Declarative on-scroll reveal animations.

Pro Tips

  • Use async.parallel() when you need to run multiple asynchronous tasks, and then render a page, but only when all tasks are completed. For example, you might want to scrape three different websites for some data and render the results in a template after all three websites have been scraped.
  • Need to find a specific object inside an Array? Use _.find function from Lodash. For example, this is how you would retrieve a Twitter token from database: var token = _.find(req.user.tokens, { kind: 'twitter' });, where 1st parameter is an array, and a 2nd parameter is an object to search for.

FAQ

Why do I get 403 Error: Forbidden when submitting a form?

You need to add the following hidden input element to your form. This has been added in the pull request #40 as part of the CSRF protection.

input(type='hidden', name='_csrf', value=_csrf)

Note: It is now possible to whitelist certain URLs. In other words, you can specify a list of routes that should bypass the CSRF verification check.

Note 2: To whitelist dynamic URLs use regular expression tests inside the CSRF middleware to see if req.originalUrl matches your desired pattern.

I am getting MongoDB Connection Error, how do I fix it?

That's a custom error message defined in app.js to indicate that there was a problem connecting to MongoDB:

mongoose.connection.on('error', (err) => {
  console.error(err);
  console.log('%s MongoDB connection error. Please make sure MongoDB is running.', chalk.red('✗'));
  process.exit();
});

You need to have a MongoDB server running before launching app.js. You can download MongoDB here, or install it via a package manager. Windows users, read Install MongoDB on Windows.

Tip: If you are always connected to the internet, you could just use MongoDB Atlas or Compose instead of downloading and installing MongoDB locally. You will only need to update database credentials in .env file.

I get an error when I deploy my app, why?

Chances are you haven't changed the Database URI in .env. If MONGODB is set to localhost, it will only work on your machine as long as MongoDB is running. When you deploy to Heroku, OpenShift, or some other provider, you will not have MongoDB running on localhost. You need to create an account with MongoDB Atlas or Compose, then create a free tier database. See Deployment for more information on how to set up an account and a new database step-by-step with MongoDB Atlas.

Why Pug (Jade) instead of Handlebars?

When I first started this project I didn't have any experience with Handlebars. Since then I have worked on Ember.js apps and got myself familiar with the Handlebars syntax. While it is true Handlebars is easier, because it looks like good old HTML, I have no regrets picking Jade over Handlebars. First off, it's the default template engine in Express, so someone who has built Express apps in the past already knows it. Secondly, I find extends and block to be indispensable, which as far as I know, Handlebars do not have out of the box. And lastly, subjectively speaking, Jade looks much cleaner and shorter than Handlebars, or any non-HAML style for that matter.

Why do you have all routes defined in app.js?

For the sake of simplicity. While there might be a better approach, such as passing app context to each controller as outlined in this blog, I find such a style to be confusing for beginners. It took me a long time to grasp the concept of exports and module.exports, let alone having a global app reference in other files. That to me is backward thinking. The app.js is the "heart of the app", it should be the one referencing models, routes, controllers, etc. When working solo on small projects, I prefer to have everything inside app.js as is the case with this REST API server.

How do I switch SendGrid for another email delivery service, like Mailgun or SparkPost?

Inside the nodemailer.createTransport method arguments, change the service from 'Sendgrid' to some other email service. Also, be sure to update both username and password below that. See the list of all supported services by Nodemailer.

How It Works (mini guides)

This section is intended for giving you a detailed explanation of how a particular functionality works. Maybe you are just curious about how it works, or perhaps you are lost and confused while reading the code, I hope it provides some guidance to you.

Custom HTML and CSS Design 101

HTML5 UP has many beautiful templates that you can download for free.

When you download the ZIP file, it will come with index.html, images, CSS and js folders. So, how do you integrate it with Hackathon Starter? Hackathon Starter uses the Bootstrap CSS framework, but these templates do not. Trying to use both CSS files at the same time will likely result in undesired effects.

Note: Using the custom templates approach, you should understand that you cannot reuse any of the views I have created: layout, the home page, API browser, login, signup, account management, contact. Those views were built using Bootstrap grid and styles. You will have to manually update the grid using a different syntax provided in the template. Having said that, you can mix and match if you want to do so: Use Bootstrap for the main app interface, and a custom template for a landing page.

Let's start from the beginning. For this example I will use Escape Velocity template: Alt

Note: For the sake of simplicity I will only consider index.html, and skip left-sidebar.html, no-sidebar.html, right-sidebar.html.

Move all JavaScript files from html5up-escape-velocity/js to public/js. Then move all CSS files from html5up-escape-velocity/css to public/css. And finally, move all images from html5up-escape-velocity/images to public/images. You could move it to the existing img folder, but that would require manually changing every img reference. Grab the contents of index.html and paste it into HTML To Pug.

Note: Do not forget to update all the CSS and JS paths accordingly.

Create a new file escape-velocity.pug and paste the Pug markup in views folder. Whenever you see the code res.render('account/login') - that means it will search for views/account/login.pug file.

Let's see how it looks. Create a new controller escapeVelocity inside controllers/home.js:

exports.escapeVelocity = (req, res) => {
  res.render('escape-velocity', {
    title: 'Landing Page'
  });
};

And then create a route in app.js. I placed it right after the index controller:

app.get('/escape-velocity', homeController.escapeVelocity);

Restart the server (if you are not using nodemon); then you should see the new template at http://localhost:8080/escape-velocity.

I will stop right here, but if you would like to use this template as more than just a single page, take a look at how these Pug templates work: layout.pug - base template, index.pug - home page, partials/header.pug - Bootstrap navbar, partials/footer.pug - sticky footer. You will have to manually break it apart into smaller pieces. Figure out which part of the template you want to keep the same on all pages - that's your new layout.pug. Then, each page that changes, be it index.pug, about.pug, contact.pug will be embedded in your new layout.pug via block content. Use existing templates as a reference.

This is a rather lengthy process, and templates you get from elsewhere might have yet another grid system. That's why I chose Bootstrap for the Hackathon Starter. Many people are already familiar with Bootstrap, plus it's easy to get started with it if you have never used Bootstrap. You can also buy many beautifully designed Bootstrap themes at Themeforest, and use them as a drop-in replacement for Hackathon Starter. However, if you would like to go with a completely custom HTML/CSS design, this should help you to get started!


How do flash messages work in this project?

Flash messages allow you to display a message at the end of the request and access it on the next request and only the next request. For instance, on a failed login attempt, you would display an alert with some error message, but as soon as you refresh that page or visit a different page and come back to the login page, that error message will be gone. It is only displayed once. This project uses express-flash module for flash messages. And that module is built on top of connect-flash, which is what I used in this project initially. With express-flash you don't have to explicitly send a flash message to every view inside res.render(). All flash messages are available in your views via messages object by default, thanks to express-flash.

Flash messages have a two-step process. You use req.flash('errors', { msg: 'Error messages goes here' } to create a flash message in your controllers, and then display them in your views:

if messages.errors
  .alert.alert-danger.fade.in
    for error in messages.errors
      div= error.msg

In the first step, 'errors' is the name of a flash message, which should match the name of the property on messages object in your views. You place alert messages inside if message.errors because you don't want to show them flash messages are present. The reason why you pass an error like { msg: 'Error message goes here' } instead of just a string - 'Error message goes here', is for the sake of consistency. To clarify that, express-validator module which is used for validating and sanitizing user's input, returns all errors as an array of objects, where each object has a msg property with a message why an error has occurred. Here is a more general example of what express-validator returns when there are errors present:

[
  { param: "name", msg: "Name is required", value: "<received input>" },
  { param: "email", msg: "A valid email is required", value: "<received input>" }
]

To keep consistent with that style, you should pass all flash messages as { msg: 'My flash message' } instead of a string. Otherwise, you will see an alert box without an error message. That is because in partials/flash.pug template it will try to output error.msg (i.e. "My flash message".msg), in other words, it will try to call a msg method on a String object, which will return undefined. Everything I just mentioned about errors, also applies to "info" and "success" flash messages, and you could even create a new one yourself, such as:

Data Usage Controller (Example)

req.flash('warning', { msg: 'You have exceeded 90% of your data usage' });

User Account Page (Example)

if messages.warning
  .alert.alert-warning.fade.in
    for warning in messages.warning
      div= warning.msg

partials/flash.pug is a partial template that contains how flash messages are formatted. Previously, flash messages were scattered throughout each view that used flash messages (contact, login, signup, profile), but now, thankfully it uses a DRY approach.

The flash messages partial template is included in the layout.pug, along with footer and navigation.

body
    include partials/header

    .container
      include partials/flash
      block content

    include partials/footer

If you have any further questions about flash messages, please feel free to open an issue, and I will update this mini-guide accordingly, or send a pull request if you would like to include something that I missed.


How do I create a new page?

A more correct way to say this would be "How do I create a new route?" The main file app.js contains all the routes. Each route has a callback function associated with it. Sometimes you will see three or more arguments for a route. In a case like that, the first argument is still a URL string, while middle arguments are what's called middleware. Think of middleware as a door. If this door prevents you from continuing forward, you won't get to your callback function. One such example is a route that requires authentication.

app.get('/account', passportConfig.isAuthenticated, userController.getAccount);

It always goes from left to right. A user visits /account page. Then isAuthenticated middleware checks if you are authenticated:

exports.isAuthenticated = (req, res, next) => {
  if (req.isAuthenticated()) {
    return next();
  }
  res.redirect('/login');
};

If you are authenticated, you let this visitor pass through your "door" by calling return next();. It then proceeds to the next middleware until it reaches the last argument, which is a callback function that typically renders a template on GET requests or redirects on POST requests. In this case, if you are authenticated, you will be redirected to the Account Management page; otherwise, you will be redirected to the Login page.

exports.getAccount = (req, res) => {
  res.render('account/profile', {
    title: 'Account Management'
  });
};

Express.js has app.get, app.post, app.put, app.delete, but for the most part, you will only use the first two HTTP verbs, unless you are building a RESTful API. If you just want to display a page, then use GET, if you are submitting a form, sending a file then use POST.

Here is a typical workflow for adding new routes to your application. Let's say we are building a page that lists all books from the database.

Step 1. Start by defining a route.

app.get('/books', bookController.getBooks);

Note: As of Express 4.x you can define your routes like so:

app.route('/books')
  .get(bookController.getBooks)
  .post(bookController.createBooks)
  .put(bookController.updateBooks)
  .delete(bookController.deleteBooks)

And here is how a route would look if it required an authentication and an authorization middleware:

app.route('/api/twitter')
  .all(passportConfig.isAuthenticated)
  .all(passportConfig.isAuthorized)
  .get(apiController.getTwitter)
  .post(apiController.postTwitter)

Use whichever style makes sense to you. Either one is acceptable. I think that chaining HTTP verbs on app.route is a very clean and elegant approach, but on the other hand, I can no longer see all my routes at a glance when you have one route per line.

Step 2. Create a new schema and a model Book.js inside the models directory.

const mongoose = require('mongoose');

const bookSchema = new mongoose.Schema({
  name: String
});

const Book = mongoose.model('Book', bookSchema);
module.exports = Book;

Step 3. Create a new controller file called book.js inside the controllers directory.

/**
 * GET /books
 * List all books.
 */
const Book = require('../models/Book.js');

exports.getBooks = (req, res) => {
  Book.find((err, docs) => {
    res.render('books', { books: docs });
  });
};

Step 4. Import that controller in app.js.

const bookController = require('./controllers/book');

Step 5. Create books.pug template.

extends layout

block content
  .page-header
    h3 All Books

  ul
    for book in books
      li= book.name

That's it! I will say that you could have combined Step 1, 2, 3 as following:

app.get('/books',(req, res) => {
  Book.find((err, docs) => {
    res.render('books', { books: docs });
  });
});

Sure, it's simpler, but as soon as you pass 1000 lines of code in app.js it becomes a little challenging to navigate the file. I mean, the whole point of this boilerplate project was to separate concerns, so you could work with your teammates without running into MERGE CONFLICTS. Imagine you have four developers working on a single app.js, I promise you it won't be fun resolving merge conflicts all the time. If you are the only developer, then it's okay. But as I said, once it gets up to a certain LoC size, it becomes difficult to maintain everything in a single file.

That's all there is to it. Express.js is super simple to use. Most of the time you will be dealing with other APIs to do the real work: Mongoose for querying database, socket.io for sending and receiving messages over WebSockets, sending emails via Nodemailer, form validation using express-validator library, parsing websites using Cheerio, etc.


How do I use Socket.io with Hackathon Starter?

Dan Stroot submitted an excellent pull request that adds a real-time dashboard with socket.io. And as much as I'd like to add it to the project, I think it violates one of the main principles of the Hackathon Starter:

When I started this project, my primary focus was on simplicity and ease of use. I also tried to make it as generic and reusable as possible to cover most use cases of hackathon web apps, without being too specific.

When I need to use socket.io, I really need it, but most of the time - I don't. But more importantly, WebSockets support is still experimental on most hosting providers. As of October 2013, Heroku supports WebSockets, but not until you opt-in by running this command:

Heroku labs:enable websockets -a myapp

And what if you are deploying to OpenShift? They do support WebSockets, but it is currently in a preview state. So, for OpenShift you would need to change the socket.io connect URI to the following:

const socket = io.connect('http://yoursite-namespace.rhcloud.com:8000');

Wait, why is it on port 8000? Who knows, and if I didn't run across this blog post I wouldn't even know I had to use port 8000.

I am really glad that Heroku and OpenShift at least have WebSockets support because many other PaaS providers still do not support it. Due to the aforementioned issues with WebSockets, I cannot include socket.io as part of the Hackathon Starter. For now... If you need to use socket.io in your app, please continue reading.

First, you need to install socket.io:

npm install socket.io

Replace const app = express(); with the following code:

const app = express();
const server = require('http').Server(app);
const io = require('socket.io')(server);

I like to have the following code organization in app.js (from top to bottom): module dependencies, import controllers, import configs, connect to database, express configuration, routes, start the server, socket.io stuff. That way I always know where to look for things.

Add the following code at the end of app.js:

io.on('connection', (socket) => {
  socket.emit('greet', { hello: 'Hey there browser!' });
  socket.on('respond', (data) => {
    console.log(data);
  });
  socket.on('disconnect', () => {
    console.log('Socket disconnected');
  });
});

One last thing left to change:

app.listen(app.get('port'), () => {

to

server.listen(app.get('port'), () => {

At this point, we are done with the back-end.

You now have a choice - to include your JavaScript code in Pug templates or have all your client-side JavaScript in a separate file - in app.js. I admit, when I first started with Node.js and JavaScript in general, I placed all JavaScript code inside templates because I have access to template variables passed in from Express right then and there. It's the easiest thing you can do, but also the least efficient and harder to maintain. Since then I almost never include inline JavaScript inside templates anymore.

But it's also understandable if you want to take the easier road. Most of the time you don't even care about performance during hackathons, you just want to "get shit done" before the time runs out. Well, either way, use whichever approach makes more sense to you. At the end of the day, it's what you build that matters, not how you build it.

If you want to stick all your JavaScript inside templates, then in layout.pug - your main template file, add this to head block.

script(src='/socket.io/socket.io.js')
script.
    let socket = io.connect(window.location.href);
    socket.on('greet', function (data) {
      console.log(data);
      socket.emit('respond', { message: 'Hey there, server!' });
    });

Note: Notice the path of the socket.io.js, you don't actually have to have socket.io.js file anywhere in your project; it will be generated automatically at runtime.

If you want to have JavaScript code separate from templates, move that inline script code into app.js, inside the $(document).ready() function:

$(document).ready(function() {

  // Place JavaScript code here...
  let socket = io.connect(window.location.href);
  socket.on('greet', function (data) {
    console.log(data);
    socket.emit('respond', { message: 'Hey there, server!' });
  });

});

And we are done!

Cheatsheets

ES6 Cheatsheet

Declarations

Declares a read-only named constant.

const name = 'yourName';

Declares a block scope local variable.

let index = 0;

Template Strings

Using the `${}` syntax, strings can embed expressions.

const name = 'Oggy';
const age = 3;

console.log(`My cat is named ${name} and is ${age} years old.`);

Modules

To import functions, objects, or primitives exported from an external module. These are the most common types of importing.

const name = require('module-name');
const { foo, bar } = require('module-name');

To export functions, objects, or primitives from a given file or module.

module.exports = { myFunction };
module.exports.name = 'yourName';
module.exports = myFunctionOrClass;

Spread Operator

The spread operator allows an expression to be expanded in places where multiple arguments (for function calls) or multiple elements (for array literals) are expected.

myFunction(...iterableObject);
<ChildComponent {...this.props} />

Promises

A Promise is used in asynchronous computations to represent an operation that hasn't completed yet but is expected in the future.

var p = new Promise(function(resolve, reject) { });

The catch() method returns a Promise and deals with rejected cases only.

p.catch(function(reason) { /* handle rejection */ });

The then() method returns a Promise. It takes two arguments: callback for the success & failure cases.

p.then(function(value) { /* handle fulfillment */ }, function(reason) { /* handle rejection */ });

The Promise.all(iterable) method returns a promise that resolves when all of the promises in the iterable argument have resolved or rejects with the reason of the first passed promise that rejects.

Promise.all([p1, p2, p3]).then(function(values) { console.log(values) });

Arrow Functions

Arrow function expression. Shorter syntax & lexically binds the this value. Arrow functions are anonymous.

singleParam => { statements }
() => { statements }
(param1, param2) => expression
const arr = [1, 2, 3, 4, 5];
const squares = arr.map(x => x * x);

Classes

The class declaration creates a new class using prototype-based inheritance.

class Person {
  constructor(name, age, gender) {
    this.name   = name;
    this.age    = age;
    this.gender = gender;
  }

  incrementAge() {
    this.age++;
  }
}

🎁 Credits: DuckDuckGo and @DrkSephy.

🔝 back to top

JavaScript Date Cheatsheet

Unix Timestamp (seconds)

Math.floor(Date.now() / 1000);
moment().unix();

Add 30 minutes to a Date object

var now = new Date();
now.setMinutes(now.getMinutes() + 30);
moment().add(30, 'minutes');

Date Formatting

// DD-MM-YYYY
var now = new Date();

var DD = now.getDate();
var MM = now.getMonth() + 1;
var YYYY = now.getFullYear();

if (DD < 10) {
  DD = '0' + DD;
}

if (MM < 10) {
  MM = '0' + MM;
}

console.log(MM + '-' + DD + '-' + YYYY); // 03-30-2016
console.log(moment(new Date(), 'MM-DD-YYYY'));
// hh:mm (12 hour time with am/pm)
var now = new Date();
var hours = now.getHours();
var minutes = now.getMinutes();
var amPm = hours >= 12 ? 'pm' : 'am';

hours = hours % 12;
hours = hours ? hours : 12;
minutes = minutes < 10 ? '0' + minutes : minutes;

console.log(hours + ':' + minutes + ' ' + amPm); // 1:43 am
console.log(moment(new Date(), 'hh:mm A'));

Next week Date object

var today = new Date();
var nextWeek = new Date(today.getTime() + 7 * 24 * 60 * 60 * 1000);
moment().add(7, 'days');

Yesterday Date object

var today = new Date();
var yesterday = date.setDate(date.getDate() - 1);
moment().add(-1, 'days');

🔝 back to top

Mongoose Cheatsheet

Find all users:

User.find((err, users) => {
  console.log(users);
});

Find a user by email:

let userEmail = 'example@gmail.com';
User.findOne({ email: userEmail }, (err, user) => {
  console.log(user);
});

Find 5 most recent user accounts:

User
  .find()
  .sort({ _id: -1 })
  .limit(5)
  .exec((err, users) => {
    console.log(users);
  });

Get the total count of a field from all documents:

Let's suppose that each user has a votes field and you would like to count the total number of votes in your database across all users. One very inefficient way would be to loop through each document and manually accumulate the count. Or you could use MongoDB Aggregation Framework instead:

User.aggregate({ $group: { _id: null, total: { $sum: '$votes' } } }, (err, votesCount)  => {
  console.log(votesCount.total);
});

🔝 back to top

Docker

You will need docker and docker-compose installed to build the application.

Docker installation

Common problems setting up docker

After installing docker, start the application with the following commands :

# To build the project for the first time or when you add dependencies
docker-compose build web

# To start the application (or to restart after making changes to the source code)
docker-compose up web

To view the app, find your docker IP address + port 8080 ( this will typically be http://localhost:8080/ ). To use a port other than 8080, you would need to modify the port in app.js, Dockerfile, and docker-compose.yml.

Deployment

Once you are ready to deploy your app, you will need to create an account with a cloud platform to host it. These are not the only choices, but they are my top picks. From my experience, the easiest way to get started is with Heroku. It will automatically restart your Node.js process when it crashes, has zero-downtime deployments, and supports custom domains on free accounts. Additionally, you can create an account with MongoDB Atlas and then pick one of the 4 providers below. Again, there are plenty of other choices, and you are not limited to just the ones listed below.

Deployment to Heroku

  • Download and install Heroku Toolbelt
  • In a terminal, run heroku login and enter your Heroku credentials
  • From your app directory run heroku create
  • Use the command heroku config:set KEY=val to set the different environment variables (KEY=val) for your application (i.e. heroku config:set BASE_URL=[heroku App Name].herokuapp.com or heroku config:set MONGODB_URI=mongodb://dbuser:<password>@cluster0-shard-00-00-sdf32.mongodb.net:27017,cluster0-shard-00-01-sdf32.mongodb.net:27017/<dbname>?ssl=true&retryWrites=true&w=majority (see Hosted MongoDB Atlas below), etc.) Make sure to set the environment variables for SENDGRID_USER, SENDGRID_PASSWORD, and any other API that you are using as well.
  • Lastly, do git push heroku master.

Please note that you may also use the Herko Dashboard to set or modify the configurations for your application.


Hosted MongoDB Atlas

  • Go to https://www.mongodb.com/cloud/atlas
  • Click the green Get started free button
  • Fill in your information then hit Get started free
  • You will be redirected to Create New Cluster page.
  • Select a Cloud Provider and Region (such as AWS and a free tier region)
  • Select cluster Tier to Free forever Shared Cluster
  • Give Cluster a name (default: Cluster0)
  • Click on green :zap:Create Cluster button
  • Now, to access your database you need to create a DB user. To create a new MongoDB user, from the Clusters view, select the Security tab
  • Under the MongoDB Users tab, click on +Add New User
  • Fill in a username and password and give it either Atlas Admin User Privilege
  • Next, you will need to create an IP address whitelist and obtain the connection URI. In the Clusters view, under the cluster details (i.e. SANDBOX - Cluster0), click on the CONNECT button.
  • Under section (1) Check the IP Whitelist, click on ALLOW ACCESS FROM ANYWHERE. The form will add a field with 0.0.0.0/0. Click SAVE to save the 0.0.0.0/0 whitelist.
  • Under section (2) Choose a connection method, click on Connect Your Application
  • In the new screen, select Node.js as Driver and version 3.6 or later.
  • Finally, copy the URI connection string and replace the URI in MONGODB_URI of .env.example with this URI string. Make sure to replace the with the db User password that you created under the Security tab.
  • Note that after some of the steps in the Atlas UI, you may see a banner stating We are deploying your changes. You will need to wait for the deployment to finish before using the DB in your application.

Note: As an alternative to MongoDB Atlas, there is also Compose.


OpenShift

**NOTE** *These instructions might be out of date due to changes in OpenShift. Heroku is currently a good free alternative. If you know the new process, please feel free to help us update this page*

  • First, install this Ruby gem: sudo gem install rhc :gem:
  • Run rhc login and enter your OpenShift credentials
  • From your app directory run rhc app create MyApp nodejs-0.10
  • Note: MyApp is the name of your app (no spaces)
  • Once that is done, you will be provided with URL, SSH and Git Remote links
  • Visit provided URL, and you should see the Welcome to your Node.js application on OpenShift page
  • Copy and paste Git Remote into git remote add openshift YOUR_GIT_REMOTE
  • Before you push your app, you need to do a few modifications to your code

Add these two lines to app.js, just place them anywhere before app.listen():

var IP_ADDRESS = process.env.OPENSHIFT_NODEJS_IP || '127.0.0.1';
var PORT = process.env.OPENSHIFT_NODEJS_PORT || 8080;

Then change app.listen() to:

app.listen(PORT, IP_ADDRESS,() => {
  console.log(`Express server listening on port ${PORT} in ${app.settings.env} mode`);
});

Add this to package.json, after name and version. This is necessary because, by default, OpenShift looks for server.js file. And by specifying supervisor app.js it will automatically restart the server when node.js process crashes.

"main": "app.js",
"scripts": {
  "start": "supervisor app.js"
},
  • Finally, you can now push your code to OpenShift by running git push -f openshift master
  • Note: The first time you run this command, you have to pass -f (force) flag because OpenShift creates a dummy server with the welcome page when you create a new Node.js app. Passing -f flag will override everything with your Hackathon Starter project repository. Do not run git pull as it will create unnecessary merge conflicts.
  • And you are done!

Azure

**NOTE** *Beyond the initial 12 month trial of Azure, the platform does not seem to offer a free tier for hosting NodeJS apps. If you are looking for a free tier service to host your app, Heroku might be a better choice at this point*

  • Login to Windows Azure Management Portal
  • Click the + NEW button on the bottom left of the portal
  • Click COMPUTE, then WEB APP, then QUICK CREATE
  • Enter a name for URL and select the datacenter REGION for your web site
  • Click on CREATE WEB APP button
  • Once the web site status changes to Running, click on the name of the web site to access the Dashboard
  • At the bottom right of the Quickstart page, select Set up a deployment from source control
  • Select Local Git repository from the list, and then click the arrow
  • To enable Git publishing, Azure will ask you to create a user name and password
  • Once the Git repository is ready, you will be presented with a GIT URL
  • Inside your Hackathon Starter directory, run git remote add azure [Azure Git URL]
  • To push your changes run git push azure master
  • Note: You will be prompted for the password you created earlier
  • On Deployments tab of your Windows Azure Web App, you will see the deployment history

IBM Bluemix Cloud Platform

NOTE At this point it appears that Bluemix's free tier to host NodeJS apps is limited to 30 days. If you are looking for a free tier service to host your app, Heroku might be a better choice at this point

Create a Bluemix Account

Sign up for Bluemix, or use an existing account.

Download and install the Cloud Foundry CLI to push your applications to Bluemix.

Create a manifest.yml file in the root of your application. ``` applications:

  • name: host: memory: 128M services:
    • myMongo-db-name ```

The host you use will determinate your application URL initially, e.g. <host>.mybluemix.net. The service name 'myMongo-db-name' is a declaration of your MongoDB service. If you are using other services like Watson for example, then you would declare them the same way.

Connect and login to Bluemix via the Cloud-foundry CLI

$ cf login -a https://api.ng.bluemix.net

Create a MongoDB service

$ cf create-service mongodb 100 [your-service-name]

Note: this is a free and experiment verion of MongoDB instance. Use the MongoDB by Compose instance for production applications:

$ cf create-service compose-for-mongodb Standard [your-service-name]'

Push the application

$ cf env <your-app-name >
(To view the *environment variables* created for your application)
$ cf push

Done, now go to the staging domain (<host>.mybluemix.net) and see your app running.

Cloud Foundry Commands More Bluemix samples Simple ToDo app in a programming language of your choice

IBM Watson

Be sure to check out the full list of Watson services to forwarder enhance your application functionality with a little effort. Watson services are easy to get going; it is simply a RESTful API call. Here is an example of a Watson Toner Analyzer to understand the emotional context of a piece of text that you send to Watson.

Watson catalog of services

Conversation - Quickly build and deploy chatbots and virtual agents across a variety of channels, including mobile devices, messaging platforms, and even robots.

Discovery - Unlock hidden value in data to find answers, monitor trends and surface patterns with the world’s most advanced cloud-native insight engine.

Language Translator - Translate text from one language to another.

Natural Language Classifier - Interpret and classify natural language with confidence.

Natural Language Understanding - Analyze text to extract meta-data from content such as concepts, entities, keywords and more.

Personality Insights - Predict personality characteristics, needs and values through written text.

Speech to Text - Convert audio and voice into written text for quick understanding of content.

Text to Speech - Convert written text into natural sounding audio in a variety of languages and voices.

Tone Analyzer - Understand emotions, social tendencies and perceived writing style.

Visual Recognition - Tag, classify and search visual content using machine learning.

Click here for live demos of each Watson service.


Google Cloud Platform

Download and install Node.js

Select or create a Google Cloud Platform Console project

Enable billing for your project (there's a $300 free trial)

Install and initialize the Google Cloud SDK

Create an app.yaml file at the root of your hackathon-starter folder with the following contents:

runtime: nodejs
env: flex
manual_scaling:
  instances: 1

Make sure you've set MONGODB_URI in .env.example

Run the following command to deploy the hackathon-starter app:

gcloud app deploy

Monitor your deployed app in the Cloud Console

View the logs for your app in the Cloud Console

Production

If you are starting with this boilerplate to build an application for prod deployment, or if after your hackathon you would like to get your project hardened for production use, see prod-checklist.md.

Changelog

You can find the changelog for the project in: CHANGELOG.md

Contributing

If something is unclear, confusing, or needs to be refactored, please let me know. Pull requests are always welcome, but due to the opinionated nature of this project, I cannot accept every pull request. Please open an issue before submitting a pull request. This project uses Airbnb JavaScript Style Guide with a few minor exceptions. If you are submitting a pull request that involves Pug templates, please make sure you are using spaces, not tabs.

Live Demo: https://hackathon-starter.walcony.com

Author: Sahat
Source Code: https://github.com/sahat/hackathon-starter 
License: MIT License

#node #boilerplate #oauth2 

Hackathon Starter: A Boilerplate for Node.js Web Applications
Rupert  Beatty

Rupert Beatty

1647676693

BlazorBoilerplate: Blazor Boilerplate/Starter Template with Mu

Blazor is a web framework designed to run in the browser on a WebAssembly-based .NET runtime. Blazor Boilerplate aka Blazor Starter Template is a SPA admin template that is able to run both WebAssembly (Core-Hosted) and Server-Side Blazor with a .NET Core 6.0 Server. Default mode for BB is Server Side. To switch to Webassembly log in as Admin and go to settings. Read more here

Repository Notes

  • Read the news below to stay up to date on the repo. We will try to keep the latest major changes on a different branch and have the more stable / tested version on the master branch.

Goals

  • This repository is community driven. It is not and never will be controlled by a corporation. It's success is dependent on people using it, reviewing it, offering suggestions and most importantly contributing. Please join the gitter discussion
  • To create a boilerplate with Blazor / Razor components that includes the most common functionality to start a real world application quickly.
  • Avoid many external components & libraries which can make it difficult to maintain, update, track down code, learn code and issues.
  • Minimal Javascript. Currently only using js for MudBlazor / Material Design. We may use components with JS in them but so far no Javascript has been written specifically for anything in the repository.

Live demo

Prerequisites

Don't know what Blazor is? Read here

Complete all Blazor dependencies.

  • The latest .Net 6.0 SDK
  • Install the Latest Visual Studio 2022 with the ASP.NET and web development workload selected. Ver. 3.1.0 is .net & Visual Studio 2019
  • Entity Framework Core on the command-line tools: dotnet tool install --global dotnet-ef

How to run

  1. Install the latest Visual Studio 2022 (v17.0.1 at least)
  2. Clone or download.
  3. Review / Update appsettings.json - DefaultConnection.
  4. Open the solution in Visual Studio and press F5.
  5. To view the API using Swagger UI, Run the solution and go to: http://localhost:53414/swagger/index.html. Live example: https://blazorboilerplate.com/swagger/index.html

Publish on IIS - What works for me on my Windows Server 2016 & SQL Server 2014 (Enkodellc)

Publish BlazorBoilerplate.Server project to your IIS website folder.

Install your SSL. Make sure your SSL is in the WebHosting Certificate Store, and in Linux My Certificate Store.

  • A free certificate from Let's Encrypt will work.
  • For steps 2 & 3 the utility win-acme installs the certificate on your server, performs renewal and configure your IIS Website Bindings to have https binding with the SSL certificate set and Port 443 for default.

Configure your IIS Website Bindings to have https binding with the SSL certificate set and Port 443 for default. Enable WebSockets for SignalR.

Configure / create appsettings.production.config. Set Connection String. If you are using Sql Server then make sure your connection string contains MultipleActiveResultSets=true, Set Thumbprint / SSL. Thumbprint example: 143fbd7bc36e78b1bcf9a53c13336eaebe33353a

Login with either the user [user | user123] or admin [admin | admin123] default accounts.

Thanks To

Contributing

Please star, watch and fork! We'd greatly appreciate any contribution you make. I am very open to updates and features, though most feature requests will be depending on how much community support exists.

Disclaimer / About the Author

I (Enkodellc) started this repository as I was frustrated with the examples out there that people were charging money for and were in my opinion incomplete or closed source. I paid for 4-5 of these solutions with an Angular front-end / .Net Core back-end and none of them were what I was looking for. This is my attempt to create something that developers can start a Blazor project with several great features to build from. I have a lot of experience with ASP.Net webforms an new to .NET Core and Blazor. This code is not meant to be perfect or follow every best practice. It though is my ambition to learn and get feedback on what best practices can be implemented. I will be migrating a Webforms app to Blazor so this is my opportunity to learn, share, grow, and get feedback on what hopefully will be a great Blazor Starter Kit.

I have taken small solutions from other repositories and will do my best to recognize those contributions. I am very open to ideas and suggestions. I am not a great developer, but I try. So please take this into consideration when using this repository. If you wish to hire me for consulting or as a contractor please reach out via email or https://gitter.im/enkodellc. I have taken well over 1,000 hours to create, maintain, and answer questions. Please donate to support my efforts.

Completed

  • Basic Login / User Creation
  • Admin Theme using Material Design / MudBlazor - 12/1/2021 Switched from MatBlazor
  • Swagger UI API visualizer - View the live API
  • Log Files using Serilog
  • Choose between SQL Lite File or MS SQL Database or Postgres
  • Email Confirmation of Registered Users
  • Forgot Password Functionality
  • ISoftDelete Interface for Models - Allows for "trash / restore" of data IsDeleted property
  • IAuditable Interface for Models - Allows for CreatedOn, CreatedBy, ModifiedOn, ModifiedBy properties
  • Api Audit Trail / Middleware to log Api Requests and Responses
  • Api Response Class to maintain consistent Api Requests and Responses
  • Todo List CRUD Example with N-Tier Layers Not just some fluff that most others do
  • Seed Database & Database Migrations
  • Forum chat and notification system - Thanks ajgoldenwings
  • Drag and Drop Examples - Chris Sainty Blazor Blog
  • Docker Container Support
  • Dual Mode (CSB / SSB) - Client Side / Webassembly & Sever Side. Thanks MarkStega
  • Error Log to Database with Serilog & SQL. Thanks np-at

Road map

Problem Solving Tips

  • If you are having issues wih authentication or any other strange behavior try using Incognito mode / different browser.
  • Make sure you have all pre-requisites installed.
  • Keep It Simple Stupid: If you are running into issues with SQL / connection string. First CHECK both appsettings.json (appsettings.production.json for production) and (appsettings.development.json for development).
  • Test out with SQLlite / file db. Then test out with a known good connection string.
  • Go back to the Origin: BlazorBoilerplate was built off of BlazorWithIdentity so first step is to run this and try and publish. The reasoning is that this is a very lean project to reduce the amount of code and resources requiring debugging.
  • If still failing get on Gitter BlazorBoilerplate for Blazor Boilerplate or Gitter aspnet/Blazor.
  • Debugging is very limited on WebAssembly / Client-side Blazor. Use Debug_SSB for debugging the UI. Just be aware of browser caching issues when switching modes. The server side of the project can easily be debugged, just not there yet on the client-side code.
  • If you are getting compiler errors try and close VS delete your .vs directory in the solution folder. If that doesn't work delete the solution and redownload the repo.

Postgres Support

*Note this might be out of date.. Delete Existing Migrations in the BlazorBoilerplate.Server/Migrations Folder and then create your own migrations:
-dotnet ef --startup-project ..\BlazorBoilerplate.Server migrations add InitialApplicationDbMigration --context ApplicationDbContext -o Migrations\ApplicationDb
-dotnet ef --startup-project ..\BlazorBoilerplate.Server\ migrations add InitialConfigurationDbMigration --context ConfigurationDbContext -o Migrations\ConfigurationDb
-dotnet ef --startup-project ..\BlazorBoilerplate.Server\ migrations add PersistedGrantDbContext --context PersistedGrantDbContext -o Migrations\PersistedGrantDb

Docker Support

  • Prerequisite: Install Docker Desktop
  • Include / Reload docker-compose project in solution.
  • Do Docker stuff - I don't have much experience with Docker.
  • In the command line go to the Utils folder and run "docker-compose build". Once complete run "docker-compose up"
  • The following will happen in the browser with ASPNETCORE_ENVIRONMENT=Development:
  • Connecting via localhost in chrome or firefox: You will get a console error: "Cannot assign requested address (localhost:port)" - because the js client is trying to connect to your local machine rather than the docker container. Login will not work.
  • Connecting over external ip address/dns: Login will work, but you will get a console error in the following scenarios:
  • In chrome over http: Cannot read property 'register' of undefined. Login works. After login: There is no additional error.
  • In chrome over https: 1) An SSL certificate error occurred when fetching the script; 2) DOMException: Failed to register a ServiceWorker for scope ('https://x.x.x.x:port/') with script ('https://x.x.x.x:port/service-worker.js'); Login works. After login: There is no additional error.
  • In firefox over http: 1) navigator.serviceWorker is undefined. Login works. After login: WebSocket is not in the OPEN state
  • In firefox over https: 1) No errors. Login works. After login: WebSocket is not in the OPEN state.
  • In ASPNETCORE_ENVIRONMENT=Production: http will redirect to https. If you are using a self signed/invalid ssl certificate the following will occur:
  • In chrome or firefox over https: Same as above except login will fail. After login attempt: There was an unhandled exception on the current circuit, so this circuit will be terminated.
  • Note: In Production, if the httpClientHandler server certificate validation returns false (caused by a self signed/invalid ssl certificate) then the login will fail. In Development, overriding the certificate validation via ServerCertificateCustomValidationCallback = () => { return true; } prevents the ssl cert validation from failing which causes the login to succeed.

Azure Support

  • Azure Hosting Wiki
  • *Note that Azure isn't as up to date with their SDK as Blazor Boilerplate so you might have to use an older version

News

4.0.0 Net Core 6

  • MudBlazor 6
  • EF 5 - Waiting on Breeze Updates
  • Nuget Package Updates

3.1.0 MudBlazor

  • Virtual Table
  • MudBlazor 5
  • .net Core 6, VS 2019, Linux Friendly

3.0.0 Net Core 5

2.0.0 Development is now Master (Major Project Refactor - Thanks GioviQ) (Documentation)

1.0.0 - Master branch

  • Nuget Package updates Blazor 3.2 - Production!

0.8.2 - Master branch

  • Nuget Package updates

0.8.1 Stable - Master branch

  • Blazor WebAssembly 3.2.0 Preview 5
  • Nuget Package updates

0.8.0 (Major Project Refactor - Thanks DanielBunting)

  • Refactor Project Architecture. Thanks DanielBunting
  • Add Initial Tests. Thanks DanielBunting
  • Project Code Review. Thanks GioviQ
  • Revised AuthorizationPolicyProvider. Thanks mobinseven
  • Server-side Multi-Tenant V.1 (Not working / No UI) - Thanks mobinseven
  • SQL Server Error Logging with Serilog Thanks np-at
  • Added Ultramapper for Dto restore / clone. Thanks GioviQ

0.7.0 (Breaking Changes)

  • .NET Core 3.2 Preview 1- Microsoft & Other Nuget package updates - Program.cs refactored for CSB
  • MatBlazor 2.1.2
  • Server-Side Blazor Auth Cookie Issue #138 - Thanks marcotana
  • Exit from Login dialog #139 - Thanks Oleg26Dev
  • Focus on Login Form Entry - Thanks responsive-edge
  • Azure Hosting Wiki and Project update - Thanks soomon
  • Known Issue with new project structure - Breaks CSB Debugging (shift + alt + d) - Expect fix in .Net Core 3.2 preview 2. Use SSB for debugging.

0.6.1 (No Major Breaking Changes)

  • .NET Core 3.1.1 - Microsoft Nuget package updates - security patches no code changes
  • Known Issue with new project structure - Breaks CSB Debugging (shift + alt + d) - Expect fix in .Net Core 3.2 preview 2. Use SSB for debugging.

0.6.0 (Major Breaking Changes)

  • Dual Mode CSB & SSB View Wiki. Thanks MarkStega
    • There are changes to solution structure for Dual Mode. Switching modes can be tricky with the browser cache so if you see something strange use incognito mode or a different browser. Best solution is to pick your version and stick with it, then expect to clear cache when switching. Read the Wiki!
    • Known Issue with new project structure - Breaks CSB (shift + alt + d) Debugging - Expect fix in .Net Core 3.2 preview 2 . Use SSB for debugging.

0.5.0

  • MatBlazor 2.0 Breaking Changes
  • .NET Core 3.1.0 / v3.1.0-preview4 Blazor Nuget package updates
  • Admin Roles / Permissions Management. Thanks vd3d
  • Fix Login EditForm / Double submit of Login. Thanks MarkStega
  • UserProfile Fixes. Thanks mobinseven
  • Chrome Cookie updates. Thanks oneparameter

0.4.0

  • Docker Support. Thanks npraskins & acid12
  • Fixed IAuditable / ShadowProperties for CreatedOn, CreatedBy, ModifiedOn, ModifiedBy. Thanks acid12
  • Known Issues:
    • Drag and Drop example does not work in FF. Known FF issue.

0.3.2

  • Identity Server 4 - Authentication with ASP.Net Identity Authorization with Policies
  • v3.1.0-preview3 / Nuget Package updates
  • Authorize / Policy Examples on Users Page
  • Known Issues:
    • IAuditable Shadow Properties not getting UserId
    • Drag and Drop example does not work in FF. Known FF issue.

0.3.0 - IS4 (Breaking Changes from 0.2.3)

  • Identity Server 4 First Release - Delete your DB! Thanks to ganmuru
  • User Profile Store Last Page Visited / Return on Login
  • .NET Core 3.0.100 / Blazor 3.0.0-preview9.19457.4 update
  • Known Issues:
    • IAuditable Shadow Properties not getting UserId

0.2.3 - .Net Core Authentication / Authorization (Stable Version)

  • .NET Core 3.0.100 / Blazor 3.0.0-preview9.19457.4 update
  • Known Issues:
    • IAuditable Shadow Properties not getting UserId

0.2.2

  • Drag and Drop Examples
  • .NET Core 3.0.0-rc1.19457.4 update
  • Known Issues:
    • IAuditable Shadow Properties not getting UserId

0.2.1

  • Update to .NET Core 3.0 Preview 9
  • User Management Screen (CRUD) & User Password Reset - Thanks npraskins
  • Confirmation Delete Dialog Stylize & Implementation
  • Known Issues:
    • IAuditable Shadow Properties not getting UserId

0.2.0

  • CRUD Todo List example
  • Restructure Project Refactor BlazorBoilerplate.Shared for N-Tier Design
  • Automapper for Client (dto) / Server Models
  • Removed old Migrations. Recommend to delete your database to start new.
  • Implement ShadowProperties for Auditable, SoftDelete Interfaces for Models (In Progress)
  • DB Seed Data
  • Forum chat and notification system - Thanks ajgoldenwings
  • Known Issues:
    • IAuditable Shadow Properties not getting UserId

0.1.9

  • Update to SDK 3.0.0-preview8-28405-07
  • Added IpAddress and UserId to Middleware ApiLogging
  • Review / Fix VS code Warnings and Information notice. Clean up code.
  • UserProfile - Beta
  • MatBlazor 1.6.0

0.1.8

  • Middleware to log Api Requests and Responses for auditing and debugging. Thanks salslab
  • Middleware for consistent API Responses and Exception Handling. Thanks proudmonkey
  • Email Pop3 / IMAP retrieval. Thanks npraskins
  • Responsive Navigation / Closed / Full / Minified / Minified & Hover effect
  • Added MatNavMenu PR for MatBlazor - Ver 1.5
  • Updated demo site for new MatNavMenu and rest of 0.1.8 code

0.1.7

  • User Profile Management
  • Refactor Email Settings and API
  • MatBlazor 1.3.0
  • Migrate to .NET Core 3.0

0.1.6

  • Email confirmation on Registration
    • Configure Email Configuration in server appsettings.json
    • Set "RequireConfirmedEmail" to true in appsettings.json
  • Forgot Password
    • Configure Email Configuration in server appsettings.json
  • Updated Email Templates for Forgot Password

0.1.5

  • Added Azure DevOps Pipeline for build status
  • Added Update Email Templates
  • Implemented New User Registration Email Template
  • Implement AuthorizeView for Theme
  • Breakout Theme Components

0.1.4

  • Add Mailkit for Email - Future work to add Email Templates
  • Started API Auth CascadingAuthenticationState / Polices / Claims
  • Added SQL Server as a DB option

0.1.3

  • Update to MatBlazor 1.2.1 - Not yet released so using local copy
  • Update Theme / Drawer minify & close
  • Fixed Known Issue - UserProfile not loading after login. Thanks nstohler
  • Secure Pages.
  • Anonymous Home Page.

0.1.2

  • Update to SDK 3.0.100-preview6-012264 - Breaking Changes
  • Update to MatBlazor 1.2
  • Update Theme
  • Known Issue - UserProfile not loading after login
  • Registration Form added Form Validation
  • Todo Table Fetch from API Example

0.1.1

  • Updated Theme / Responsive
  • Added Serilog Log Files

0.1.0

  • Initial release

Author: Enkodellc
Source Code: https://github.com/enkodellc/blazorboilerplate 
License: MIT License

#blazor #boilerplate #webassembly 

BlazorBoilerplate: Blazor Boilerplate/Starter Template with Mu