Headless Blog mit dem JavaScript Framework Sails.js

SailsJS – Ohne Patenthalse zur API

• Vorräte kontrol­lieren
• Leinen los
• Anker lichten
• Segel setzen
• Volle Fahrt voraus!

Vorbe­reitung unseres Turns

Vorräte kontrol­lieren

Instal­lation von Sails

Wir starten mit einem leeren Ordner, instal­lierten Node.js und einem Webbrowser der uns die Seite https://sailsjs.com/get-started anzeigt.

In (relativ) schneller Abfolge führen wir 

npm install sails -g
sails new FullSails

aus und beant­worten die Fragen des Installers. Wir wählen für unsere Zwecken das leere Sails Projekt aus und starten anschließend mit 

cd FullSails
sails lift

Instal­lation von PostgreSQL

Nun müssen wir noch unsere Datenbank verbinden. Die Entscheidung ist hierbei auf eine PostgreSQL Datenbank gefallen.

Es ist nicht nötig an dieser Stelle eine lokale Datenbank zu instal­lieren, da später sowieso auf Docker umgestellt wird. Wer auf Docker verzichten will, der sollte sich für sein Betriebs­system nun eine PostgreSQL Datenbank zulegen. Am besten richtet ihr dann gleich eine neue Datenbank mit Nutzer ein. Dieser Artikel beinhaltet alles was ihr dafür benötigt.

Ist das erledigt, öffnen wir einfach mal die Datei config/datastores.js.

default: {
 
/***************************************************************************
* *
* Want to use a different database during development? *
* *
* 1. Choose an adapter: *
* https://sailsjs.com/plugins/databases *
* *
* 2. Install it as a dependency of your Sails app. *
* (For example: npm install sails-mysql --save) *
* *
* 3. Then pass it in, along with a connection URL. *
* (See https://sailsjs.com/config/datastores for help.) *
* *
***************************************************************************/
// adapter: 'sails-mysql',
// url: 'mysql://user:password@host:port/database',
},

Im Prinzip sagt uns der Kommentar genau was getan werden muss, also fix auf https://sailsjs.com/plugins/databases und die Anwei­sungen befolgen:

npm install sails-postgresql --save

...
// adapter: 'sails-mysql',
// url: 'mysql://user:password@host:port/database',
adapter: 'sails-postgresql',
url: 'localhost://sails:fullsailsahead@host:port/fullsails',
...

An dieser Stelle benutze ich nun die Datenbank fullsails mit dem Nutzer sails und dem Password fullsailsahead.  ( Anm.: Die Datenbank ist hier für eine lokale Verbindung eingerichtet )

Leinen Los

Nun, da das Projekt lokal läuft, sollten wir uns um die Docker Container kümmern. Dieser wird für die CI Pipeline benötigt und erlaubt es uns später ein Rechner­un­ab­hän­giges deployment einfacher umzusetzen.

Um die Anwendung mit Docker zu versehen, benötigen wir 2 Dockerfile und 1 docker-compose.yml. Es bietet sich herbei die Docker Container als Ordner­struktur unter der docker-compose.yml anzulegen. Konkret sollten wir unsere Anwendung, die momentan so aussieht:

• Fullsails
  • api .…
  • assets .…
  • .…

umbauen, sodass die eigentlich Sails App gekapselt wird:

• FullSails
  • backend
    • api .…
    • assets .…
    • Dockerfile
    • .…
  • postgresql
    • Dockerfile 
    • .….
  • docker-compose.yml

Sails mit Docker

FROM node:latest
 
# add sources
COPY . /app
 
WORKDIR /app
 
RUN npm install
 
CMD ["npm","run", "start"]

Kurz umrissen wird hier einfach das neueste Node.js Image geladen, unser Quellcode wird in /app kopiert und anschließend wechseln wir dorthin und instal­lieren mit npm install unsere Abhängigkeiten.

Wichtig ist hier das wir die Anwendung mit npm run start hochfahren um sie in der Produktion Environment laufen zu lassen.

Kompo­sition der beiden Docker Container

Nun fehlt noch die Verknüpfung der beiden Container. Hierfür legen wir uns eine docker-compose.yml an.

version: '3.1'
services:
  api:
    build: ./backend
    ports:
      - "80:80"
      - "9229:9229"
    volumes:
      - ./backend:/app
    command: bash -c "npm install && npm start"
    environment:
      - NODE_ENV=development
    networks:
      - test
 
 
  postgresql:
      build: ./postgresql
      ports:
        - "5432:5432"
      networks:
        - test
 
networks:
  test:
    external:
      name: test

Von unten nach oben passiert nun folgendes:

• Anlegen eines Netzwerkes zum kapseln der Container Verbindung
• Definition des postgresql services. Hier wird die Dockerfile in ./postgresql gebaut, der Standartport nach außen geöffnet und der Container in das Netzwerk test gelegt.
• Definition des api services. Analog wird der Inhalt von ./backend  gebaut. Anschließend werden die ports 80 (Webserver) und 9229 (Node Debug, Optional) geöffnet.
  Anschließend wird noch das Volume einge­bunden um die lokalen Änderungen ohne Neubau des Containers zu übernehmen. Wir setzen nun noch die NODE_ENV variable und fügen den Service ebenfalls zum Netzwerk hinzu.
  Das command wird hier zum starten des Containers benutzt und überschreibt den Befehl in der backend/Dockerfile. Dies erlaubt es uns mittels docker-compose up die Abhän­gig­keiten zu aktualisieren.

Nun müssen wir noch die Verbindung zur Datenbank mittels Docker anpassen. Hierfür ersetzen wir in backend/config/datastore.js die hostadresse mit dem Namen des Postrg­reSQL Services

...
 
    adapter: 'sails-postgresql',
    url: 'postgresql://sails:fullsailahead@postgresql:5432/fullsails',
...

Also öffnen wir die beschriebene Datei in backend/config/env/production.js und ersetzen die werte für onlyAl­lo­wO­r­igins sowie port. Dadurch wird der production server auch auf port 80 gestartet werden, was unser gewünschter Port für die API ist.

...
  sockets: {
 
    /***************************************************************************
    *                                                                          *
    * Uncomment the `onlyAllowOrigins` whitelist below to configure which      *
    * "origins" are allowed to open socket connections to your Sails app.      *
    *                                                                          *
    * > Replace "https://example.com" etc. with the URL(s) of your app.        *
    * > Be sure to use the right protocol!  ("http://" vs. "https://")         *
    *                                                                          *
    ***************************************************************************/
    onlyAllowOrigins: [
        "http://0.0.0.0"
    ],
...
 
  /**************************************************************************
  *                                                                         *
  * Lift the server on port 80.                                             *
  * (if deploying behind a proxy, or to a PaaS like Heroku or Deis, you     *
  * probably don't need to set a port here, because it is oftentimes        *
  * handled for you automatically.  If you are not sure if you need to set  *
  * this, just try deploying without setting it and see if it works.)       *
  *                                                                         *
  ***************************************************************************/
  port: 80,
...

docker-compose up

Segel setzen

Um die API zu vervoll­stän­digen sind nun noch eine Handvoll Schritte von Nöten. Wir müssen unsere Models um nicht-primitive Typen und Bezie­hungen erweitern, unsere Business Logik in den Controller eintragen und unsere Daten initialisieren.

Model befüllen

Wir fügen nun zu unseren Models noch die benötigten Verknüp­fungen hinzu.

• User: Keine Beziehung zu anderen Models
• Post: 1 zu 1 Beziehung mit User für die Author Infor­mation
  Wir erweitern das Model um das Attribut author

  ...
      attributes: {
   
          //  ╔═╗╦═╗╦╔╦╗╦╔╦╗╦╦  ╦╔═╗╔═╗
          //  ╠═╝╠╦╝║║║║║ ║ ║╚╗╔╝║╣ ╚═╗
          //  ╩  ╩╚═╩╩ ╩╩ ╩ ╩ ╚╝ ╚═╝╚═╝
          message: {type: 'string'},
   
          //  ╔═╗╔╦╗╔╗ ╔═╗╔╦╗╔═╗
          //  ║╣ ║║║╠╩╗║╣  ║║╚═╗
          //  ╚═╝╩ ╩╚═╝╚═╝═╩╝╚═╝
           
          //  ╔═╗╔═╗╔═╗╔═╗╔═╗╦╔═╗╔╦╗╦╔═╗╔╗╔╔═╗
          //  ╠═╣╚═╗╚═╗║ ║║  ║╠═╣ ║ ║║ ║║║║╚═╗
          //  ╩ ╩╚═╝╚═╝╚═╝╚═╝╩╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝
          author: {
              model: 'User'
          }
  ...
  
  

• Comments: 1 zu 1 Beziehung mit Post
  Analog zu User erweitern wir um das Attribut postId

  ...
    attributes: {
   
      //  ╔═╗╦═╗╦╔╦╗╦╔╦╗╦╦  ╦╔═╗╔═╗
      //  ╠═╝╠╦╝║║║║║ ║ ║╚╗╔╝║╣ ╚═╗
      //  ╩  ╩╚═╩╩ ╩╩ ╩ ╩ ╚╝ ╚═╝╚═╝
   
      message: { type: 'string' },
   
      //  ╔═╗╔╦╗╔╗ ╔═╗╔╦╗╔═╗
      //  ║╣ ║║║╠╩╗║╣  ║║╚═╗
      //  ╚═╝╩ ╩╚═╝╚═╝═╩╝╚═╝
           
      //  ╔═╗╔═╗╔═╗╔═╗╔═╗╦╔═╗╔╦╗╦╔═╗╔╗╔╔═╗
      //  ╠═╣╚═╗╚═╗║ ║║  ║╠═╣ ║ ║║ ║║║║╚═╗
      //  ╩ ╩╚═╝╚═╝╚═╝╚═╝╩╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝
      postId: {
        model: 'Post'
      },
  ...
  
  

Controller befüllen

Durch die Vorge­gebene Struktur füllen wir nun noch schnell die benötigten Aktionen.

api/controllers/UserController.js:

...
module.exports = {
 
    /**
     * `UserController.index()`
     */
    list: async function (req, res) {
        const users = await User.find({
            where: {},
            select: ['name', 'email']
        })
 
        return res.json({
            users: users
        })
    },
 
    /**
     * `UserController.create()`
     */
    add: async function (req, res) {
 
        const token = uuid();
 
        const createdUser = await User.create({
            name: req.body.name,
            email: req.body.email,
            token: token
        }).fetch();
 
        return res.json({
            id: createdUser.id,
            token: createdUser.token,
            name: createdUser.name,
            email: createdUser.email
        });
    },
 
    /**
     * `UserController.show()`
     */
    get: async function (req, res) {
        const foundUser = await User.findOne({
              id: req.params.id
        });
 
        return res.json({
            id: foundUser.id,
            name: foundUser.name,
            email: foundUser.email
        });
    },
 
    /**
     * `UserController.edit()`
     */
    edit: async function (req, res) {
        const updateUser = await User
            .update({id: req.params.id})
            .set({
                name: req.body.name,
                email: req.body.email
            })
            .fetch()
            .then( (users) => users[0]);
 
        return res.json({
            id: updateUser.id,
            name: updateUser.name,
            email: updateUser.email
        });
    },
 
    /**
     * `UserController.delete()`
     */
    delete: async function (req, res) {
        await User.destroy({id: req.params.id});
 
        return res.ok();
    }
};

api/controllers/PostController.js:

...
module.exports = {
 
 
  /**
   * `PostController.add()`
   */
  add: async function (req, res) {
    const foundUser = await User.findOne({token: req.headers.token});
 
    if (!foundUser) return res.forbidden();
 
    const createdPost = await Post.create({
        message: req.body.message,
        author: foundUser.id,
    })
    .fetch()
    .then((post) => Post.findOne({id: post.id}).populate('author'));
 
    return res.json(Post.toResJson(createdPost));
  },
 
  /**
   * `PostController.get()`
   */
  get: async function (req, res) {
    const foundPost = await Post.findOne({id: req.params.id})
        .populate('author');
 
 
      return res.json(Post.toResJson(foundPost));
  },
 
  /**
   * `PostController.edit()`
   */
  edit: async function (req, res) {
    const updatedPost = await Post.update({id: req.params.id})
        .set({
            message: req.body.message
        })
        .fetch()
        .then((post) => Post.findOne({id: post[0].id}).populate('author'));
 
 
      return res.json(Post.toResJson(updatedPost));
  },
 
  /**
   * `PostController.delete()`
   */
  delete: async function (req, res) {
    await Post.destroy({id: req.params.id});
 
    return res.ok();
  },
 
  /**
   * `PostController.show()`
   */
  list: async function (req, res) {
    const listPosts = await Post.find()
        .populate('author')
        .then( (results) => results.map((post) => {return Post.toResJson(post)}));
 
    return res.json({
        posts: listPosts
    });
  }
 
};

api/controllers/CommentController.js

...
module.exports = {
 
 
    /**
     * `CommentController.add()`
     */
    add: async function (req, res) {
        const createdComment = await Comment.create({
            postId: req.params.postId,
            message: req.body.message,
        })
            .fetch()
 
        return res.json(Comment.toResJson(createdComment));
    },
 
    /**
     * `CommentController.get()`
     */
    get: async function (req, res) {
        const foundComment = await Comment.findOne({id: req.params.id});
 
        return res.json(Comment.toResJson(foundComment));
    },
 
    /**
     * `CommentController.edit()`
     */
    edit: async function (req, res) {
        const updatedComment = await Comment.update({id: req.params.id})
            .set({message: req.body.message})
            .fetch()
            .then( (results) => results[0]);
 
        return res.json(Comment.toResJson(updatedComment));
    },
 
    /**
     * `CommentController.delete()`
     */
    delete: async function (req, res) {
        await Comment.destroy({id: req.params.id})
 
        return res.ok();
    },
 
    /**
     * `CommentController.list()`
     */
    list: async function (req, res) {
        const listComment = await Comment.find({postId: req.params.postId})
            .then( (results) => results.map((comment) => {return Comment.toResJson(comment)}));
 
        return res.json({
            postId: req.params.postId,
            comments: listComment
        })
    }
 
};

...
    toResJson: function (comment) {
        return {
          id: comment.id,
          message: comment.message,
          postId: comment.postId.id ? comment.postId.id : comment.postId,
        }
    }
};

...
    toResJson: function (post) {
        return {
            id: post.id,
            message: post.message,
            author: {
                id: post.author.id,
                name: post.author.name
            }
        }
    }
};

Daten initia­li­sieren

Da wir unsere Anwendung noch nie mit Models gestartet haben, befinden sich auch noch keine Daten in der Datenbank. Sails bietet eine automa­ti­sierte Migration an, solange die Anwendung nicht mit NODE_ENV=production läuft.

Schalten wir diese migration für die dev Umgebung ein und setzen das migrate flag:

config/model.js

...
  /***************************************************************************
  *                                                                          *
  * How and whether Sails will attempt to automatically rebuild the          *
  * tables/collections/etc. in your schema.                                  *
  *                                                                          *
  * > Note that, when running in a production environment, this will be      *
  * > automatically set to `migrate: 'safe'`, no matter what you configure   *
  * > here.  This is a failsafe to prevent Sails from accidentally running   *
  * > auto-migrations on your production database.                           *
  * >                                                                        *
  * > For more info, see:                                                    *
  * > https://sailsjs.com/docs/concepts/orm/model-settings#?migrate         *
  *                                                                          *
  ***************************************************************************/
 
  migrate: 'alter',
...

Nun müssen wir unsere Anwendung stoppen

docker-compose down

und anschließend einmalig nicht mit NODE_ENV=production starten. Hierfür passen wir kurzerhand die package.json Datei an.

...
    "start": "NODE_ENV=dev node app.js",
...

docker-compose up

Nun müssen wir die Änderung in package.json wieder rückgängig machen

...
    "start": "NODE_ENV=production node app.js",
...

docker-compose restart