feat: repository integration (#23)

Add a User model, an in-memory datasource,
and a repository which ties them together.
Also add unit tests for HelloWorldController,
and an acceptance test for persistence.
Lastly, refactor repo to make use of rest
package.

Author: b-admike

package.json

@@ -21,18 +21,20 @@
   "author": "IBM",
   "license": "MIT",
   "devDependencies": {
-    "@loopback/openapi-spec": "^4.0.0-alpha.8",
-    "@loopback/testlab": "^4.0.0-alpha.6",
+    "@loopback/testlab": "^4.0.0-alpha.7",
     "@types/mocha": "^2.2.41",
     "dredd": "^4.3.0",
     "mocha": "^3.5.0",
     "ts-node": "^3.3.0",
     "typescript": "^2.4.2"
   },
   "dependencies": {
-    "@loopback/authentication": "^4.0.0-alpha.5",
-    "@loopback/context": "^4.0.0-alpha.11",
-    "@loopback/core": "^4.0.0-alpha.11",
+    "@loopback/authentication": "^4.0.0-alpha.10",
+    "@loopback/context": "^4.0.0-alpha.14",
+    "@loopback/core": "^4.0.0-alpha.16",
+    "@loopback/openapi-spec": "^4.0.0-alpha.10",
+    "@loopback/repository": "^4.0.0-alpha.8",
+    "@loopback/rest": "^4.0.0-alpha.3",
     "@types/passport": "^0.3.3",
     "@types/passport-http": "^0.3.2",
     "passport": "^0.3.2",

src/apidefs/hello-world.api.ts

@@ -0,0 +1,92 @@
+// Copyright IBM Corp. 2017. All Rights Reserved.
+// Node module: loopback-next-hello-world
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+'use strict';
+
+export const helloWorldApi = {
+  paths: {
+    '/helloworld': {
+      get: {
+        'x-operation-name': 'helloWorld',
+        'x-controller-name': 'HelloWorldController',
+        parameters: [
+          {
+            name: 'name',
+            in: 'query',
+            description: 'Your name.',
+            required: false,
+            type: 'string',
+            'x-example': 'Ted',
+          },
+        ],
+        responses: {
+          '200': {
+            description: 'Returns a hello world with your (optional) name.',
+            examples: {
+              'text/plain': 'Hello world Ted {"username":"a","password":"a"}',
+            },
+          },
+        },
+      },
+    },
+    '/users': {
+      get: {
+        'x-operation-name': 'getUsers',
+        'x-controller-name': 'HelloWorldController',
+        parameters: [
+          {
+            name: 'name',
+            in: 'query',
+            description: 'The name for the user instance.',
+            required: false,
+            type: 'string',
+            'x-example': 'Ted',
+          },
+        ],
+        responses: {
+          '200': {
+            description: 'An array of persisted user instances.',
+            schema: {
+              type: 'array',
+              items: {
+                $ref: '#/definitions/user',
+              },
+            },
+            examples: {
+              'application/json': '[{username:"Ted", id: 1}]',
+            },
+          },
+        },
+      },
+      post: {
+        'x-operation-name': 'createUser',
+        'x-controller-name': 'HelloWorldController',
+        consumes: ['application/json'],
+        produces: ['application/json'],
+        parameters: [
+          {
+            name: 'userInfo',
+            in: 'body',
+            description: 'The user model instance to create.',
+            required: false,
+            schema: {
+              $ref: '#/definitions/user',
+            },
+          },
+        ],
+        responses: {
+          '200': {
+            description: 'The created user instance.',
+            schema: {
+              $ref: '#/definitions/user',
+            },
+            examples: {
+              'application/json': '{"id": 1,"username": "Ted"}',
+            },
+          },
+        },
+      },
+    },
+  },
+};

src/apidefs/swagger.ts

@@ -0,0 +1,32 @@
+import * as lbOpenApiSpec from '@loopback/openapi-spec';
+import {OpenApiSpec} from '@loopback/openapi-spec';
+import {helloWorldApi} from './hello-world.api';
+
+export let spec = lbOpenApiSpec.createEmptyApiSpec();
+spec.info = {
+  title: 'Hello World API',
+  version: '1.0',
+};
+spec.swagger = '2.0';
+spec.basePath = '/';
+spec.definitions = {
+  user: {
+    type: 'object',
+    properties: {
+      id: {
+        type: 'number',
+        description: 'The ID for a user instance.',
+      },
+      username: {
+        type: 'string',
+        description: 'The username for a user instance.',
+      },
+    },
+    required: ['username'],
+    example: {
+      username: 'Ted',
+    },
+  },
+};
+
+spec = Object.assign({}, spec, helloWorldApi);

src/application.ts

@@ -3,20 +3,40 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 import {Application} from '@loopback/core';
-import {AuthenticationComponent, AuthenticationBindings} from '@loopback/authentication';
-import {validateApiSpec} from '@loopback/testlab'
+import {
+  AuthenticationComponent,
+  AuthenticationBindings,
+} from '@loopback/authentication';
+import {validateApiSpec} from '@loopback/testlab';
 import {MyAuthStrategyProvider} from './providers/auth-strategy';
 import {HelloWorldController} from './controllers/hello-world';
 import {MySequence} from './sequence';
+import {UserRepository} from './repositories/user.repository';
+import {Class, Repository, RepositoryMixin} from '@loopback/repository';
+import {RestComponent, RestServer, RestBindings} from '@loopback/rest';
+import {spec} from './apidefs/swagger';
 
-export class HelloWorldApp extends Application {
+export class HelloWorldApp extends RepositoryMixin(Application) {
   constructor() {
     super({
-      components: [AuthenticationComponent],
-      sequence: MySequence,
+      components: [AuthenticationComponent, RestComponent],
+      repositories: [UserRepository],
     });
-    this.bind(AuthenticationBindings.STRATEGY)
-      .toProvider(MyAuthStrategyProvider);
     this.controller(HelloWorldController);
   }
+
+  async start() {
+    const server = await this.getServer(RestServer);
+    server.sequence(MySequence);
+    server.api(spec);
+    server
+      .bind(AuthenticationBindings.STRATEGY)
+      .toProvider(MyAuthStrategyProvider);
+    await super.start();
+    let port = await server.get(RestBindings.PORT);
+    console.log(`HTTP server listening on port ${port}`);
+    console.log(
+      `Run \'curl localhost:${port}/helloworld?name=YOUR_NAME\' to try it out`,
+    );
+  }
 }

src/controllers/hello-world.api.ts

@@ -4,16 +4,38 @@
 // License text available at https://opensource.org/licenses/MIT
 'use strict';
 
-import {api, inject} from '@loopback/core';
-import {controllerSpec} from './hello-world.api';
-import {authenticate, AuthenticationBindings, UserProfile} from '@loopback/authentication';
+import {inject} from '@loopback/core';
+import {api} from '@loopback/rest';
+import {helloWorldApi} from '../apidefs/hello-world.api';
+import {
+  authenticate,
+  AuthenticationMetadata,
+  AuthenticationBindings,
+  UserProfile,
+} from '@loopback/authentication';
+import {UserRepository} from '../repositories/user.repository';
+import {User} from '../models/user.model';
 
-@api(controllerSpec)
+@api(helloWorldApi)
 export class HelloWorldController {
-  constructor(@inject(AuthenticationBindings.CURRENT_USER) private user: UserProfile) {}
+  constructor(
+    @inject(AuthenticationBindings.CURRENT_USER) private user: UserProfile,
+    @inject('repositories.UserRepository') private repository: UserRepository,
+  ) {}
 
   @authenticate('BasicStrategy')
-  helloWorld(name: string) {
-      return `Hello world ${name} ` + JSON.stringify(this.user);
+  async helloWorld(name?: string) {
+    return `Hello world ${name} ` + JSON.stringify(this.user);
+  }
+
+  @authenticate('BasicStrategy')
+  async getUsers(name?: string): Promise<User[]> {
+    let filter = name ? {where: {username: name}} : {};
+    return await this.repository.find(filter);
+  }
+
+  @authenticate('BasicStrategy')
+  async createUser(userInfo: Partial<User>) {
+    return await this.repository.create(new User(userInfo));
   }
 }

src/controllers/hello-world.ts

@@ -0,0 +1,6 @@
+import {juggler, DataSourceConstructor} from '@loopback/repository';
+
+export const db = new DataSourceConstructor({
+  name: 'db',
+  connector: 'memory',
+});

src/datasources/db.datasource.ts

@@ -5,19 +5,12 @@
 import {CoreBindings} from '@loopback/core';
 import {HelloWorldApp} from './application';
 export {HelloWorldApp};
+import {RestServer, RestBindings} from '@loopback/rest';
 
 if (require.main === module.parent) {
   // executed from the console
   const app = new HelloWorldApp();
-
-  app.start().then(
-    () => {
-      let port = app.getSync(CoreBindings.HTTP_PORT);
-      console.log(`HTTP server listening on port ${port}`);
-      console.log(`Run \'curl localhost:${port}/helloworld?name=YOUR_NAME\' to try it out`);
-    },
-    err => {
-      console.error('Cannot start the application', err);
-      process.exit(1);
-    });
-} 
+  (async function main() {
+    await app.start();
+  })();
+}

src/index.ts

@@ -0,0 +1,20 @@
+import {Entity, model, property} from '@loopback/repository';
+
+@model()
+export class User extends Entity {
+  @property({
+    description: 'The ID for a user.',
+    id: true,
+    generated: true,
+    type: 'number',
+  })
+  id: number;
+
+  @property({
+    description: 'The username for a user.',
+    required: true,
+    default: 'Anonymous User',
+    type: 'string',
+  })
+  username: string;
+}

src/models/user.model.ts

@@ -2,16 +2,11 @@
 // Node module: loopback-next-hello-world
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
-import {
-  inject,
-  Provider,
-  ValueOrPromise,
-} from '@loopback/context';
+import {inject, Provider, ValueOrPromise} from '@loopback/context';
 import {
   AuthenticationBindings,
   AuthenticationMetadata,
 } from '@loopback/authentication';
-
 import {Strategy} from 'passport';
 import {BasicStrategy} from 'passport-http';
 
@@ -21,8 +16,7 @@ export class MyAuthStrategyProvider implements Provider<Strategy> {
     private metadata: AuthenticationMetadata,
   ) {}
 
-
-  value() : ValueOrPromise<Strategy> {
+  value(): ValueOrPromise<Strategy> {
     const name = this.metadata.strategy;
     if (name === 'BasicStrategy') {
       return new BasicStrategy(this.verify);