@loopback/example-references-many 6.0.1

package/dist/repositories/index.js

@@ -0,0 +1,10 @@
+"use strict";
+// Copyright IBM Corp. and LoopBack contributors 2022. All Rights Reserved.
+// Node module: @loopback/example-references-many
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./account.repository"), exports);
+tslib_1.__exportStar(require("./customer.repository"), exports);
+//# sourceMappingURL=index.js.map

package/dist/repositories/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/repositories/index.ts"],"names":[],"mappings":";AAAA,2EAA2E;AAC3E,iDAAiD;AACjD,+CAA+C;AAC/C,gEAAgE;;;AAEhE,+DAAqC;AACrC,gEAAsC"}

package/dist/sequence.d.ts

@@ -0,0 +1,3 @@
+import { MiddlewareSequence } from '@loopback/rest';
+export declare class MySequence extends MiddlewareSequence {
+}

package/dist/sequence.js

@@ -0,0 +1,12 @@
+"use strict";
+// Copyright IBM Corp. and LoopBack contributors 2022. All Rights Reserved.
+// Node module: @loopback/example-references-many
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySequence = void 0;
+const rest_1 = require("@loopback/rest");
+class MySequence extends rest_1.MiddlewareSequence {
+}
+exports.MySequence = MySequence;
+//# sourceMappingURL=sequence.js.map

package/dist/sequence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequence.js","sourceRoot":"","sources":["../src/sequence.ts"],"names":[],"mappings":";AAAA,2EAA2E;AAC3E,iDAAiD;AACjD,+CAA+C;AAC/C,gEAAgE;;;AAEhE,yCAAkD;AAElD,MAAa,UAAW,SAAQ,yBAAkB;CAAG;AAArD,gCAAqD"}

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@loopback/example-references-many",
+  "description": "Example of the references many relation in LoopBack 4.",
+  "version": "6.0.1",
+  "keywords": [
+    "loopback",
+    "LoopBack",
+    "example",
+    "tutorial",
+    "relations",
+    "CRUD",
+    "models",
+    "referenceMany",
+    "HasMany"
+  ],
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "author": "IBM Corp. and LoopBack contributors",
+  "copyright.owner": "IBM Corp. and LoopBack contributors",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/loopbackio/loopback-next.git",
+    "directory": "examples/references-many"
+  },
+  "engines": {
+    "node": "14 || 16 || 17 || 18"
+  },
+  "scripts": {
+    "build": "lb-tsc",
+    "build:watch": "lb-tsc --watch",
+    "clean": "lb-clean *example-references-many*.tgz dist *.tsbuildinfo package",
+    "lint": "npm run prettier:check && npm run eslint",
+    "lint:fix": "npm run eslint:fix && npm run prettier:fix",
+    "prettier:cli": "lb-prettier \"**/*.ts\"",
+    "prettier:check": "npm run prettier:cli -- -l",
+    "prettier:fix": "npm run prettier:cli -- --write",
+    "eslint": "lb-eslint --report-unused-disable-directives .",
+    "eslint:fix": "npm run eslint -- --fix",
+    "pretest": "npm run rebuild",
+    "test": "lb-mocha \"dist/__tests__/**/*.js\"",
+    "test:dev": "lb-mocha --allow-console-logs dist/__tests__/**/*.js && npm run posttest",
+    "verify": "npm pack && tar xf loopback-references-many*.tgz && tree package && npm run clean",
+    "premigrate": "npm run build ",
+    "migrate": "node ./dist/migrate",
+    "preopenapi-spec": "npm run build",
+    "openapi-spec": "node ./dist/openapi-spec",
+    "rebuild": "npm run clean && npm run build",
+    "prestart": "npm run rebuild",
+    "start": "node ."
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@loopback/boot": "^5.0.1",
+    "@loopback/core": "^4.0.1",
+    "@loopback/repository": "^5.0.1",
+    "@loopback/rest": "^12.0.1",
+    "@loopback/rest-explorer": "^5.0.1",
+    "@loopback/service-proxy": "^5.0.1",
+    "loopback-connector-rest": "^4.0.1",
+    "tslib": "^2.4.0"
+  },
+  "devDependencies": {
+    "@loopback/build": "^9.0.1",
+    "@loopback/eslint-config": "^13.0.1",
+    "@loopback/http-caching-proxy": "^4.0.1",
+    "@loopback/repository": "^5.0.1",
+    "@loopback/testlab": "^5.0.1",
+    "@types/lodash": "^4.14.182",
+    "@types/node": "^14.18.21",
+    "eslint": "^8.17.0",
+    "lodash": "^4.17.21",
+    "typescript": "~4.7.3"
+  },
+  "gitHead": "ccf7863d0639de966d6c6129b4aa94ba1dce2c33"
+}

package/public/index.html

@@ -0,0 +1,72 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+  <title>myapp</title>
+
+  <meta charset="utf-8">
+  <meta http-equiv="X-UA-Compatible" content="IE=edge">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <link rel="shortcut icon" type="image/x-icon" href="https://loopback.io/favicon.ico">
+
+  <style>
+    h3 {
+      margin-left: 25px;
+      text-align: center;
+    }
+
+    a, a:visited {
+      color: #3f5dff;
+    }
+
+    h3 a {
+      margin-left: 10px;
+    }
+
+    a:hover, a:focus, a:active {
+      color: #001956;
+    }
+
+    .power {
+      position: absolute;
+      bottom: 25px;
+      left: 50%;
+      transform: translateX(-50%);
+    }
+
+    .info {
+      position: absolute;
+      top: 50%;
+      left: 50%;
+      transform: translate(-50%, -50%)
+    }
+
+    .info h1 {
+      text-align: center;
+      margin-bottom: 0;
+    }
+
+    .info p {
+      text-align: center;
+      margin-bottom: 3em;
+      margin-top: 1em;
+    }
+  </style>
+</head>
+
+<body>
+  <div class="info">
+    <h1>@loopback/example-references-many</h1>
+
+    <h3>OpenAPI spec: <a href="/openapi.json">/openapi.json</a></h3>
+    <h3>API Explorer: <a href="/explorer">/explorer</a></h3>
+  </div>
+
+  <footer class="power">
+    <a href="https://loopback.io" target="_blank">
+      <img src="https://loopback.io/images/branding/powered-by-loopback/blue/powered-by-loopback-sm.png" />
+    </a>
+  </footer>
+</body>
+
+</html>

package/src/__tests__/acceptance/account.acceptance.ts

@@ -0,0 +1,139 @@
+// Copyright IBM Corp. and LoopBack contributors 2019,2020. All Rights Reserved.
+// Node module: @loopback/example-references-many
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {EntityNotFoundError} from '@loopback/repository';
+import {Client, createRestAppClient, expect, toJSON} from '@loopback/testlab';
+import {ReferencesManyApplication} from '../../application';
+import {Account} from '../../models/';
+import {AccountRepository} from '../../repositories/';
+import {
+  givenAccount,
+  givenAccountInstance,
+  givenAccountRepositories,
+  givenRunningApplicationWithCustomConfiguration,
+} from '../helpers';
+
+describe('ReferencesManyApplication', () => {
+  let app: ReferencesManyApplication;
+  let client: Client;
+  let accountRepo: AccountRepository;
+
+  before(async () => {
+    app = await givenRunningApplicationWithCustomConfiguration();
+  });
+  after(() => app.stop());
+
+  before(async () => {
+    ({accountRepo} = await givenAccountRepositories(app));
+  });
+  before(() => {
+    client = createRestAppClient(app);
+  });
+
+  beforeEach(async () => {
+    await accountRepo.deleteAll();
+  });
+
+  it('creates an account', async function () {
+    const account = givenAccount();
+    const response = await client.post('/accounts').send(account).expect(200);
+    expect(response.body).to.containDeep(account);
+    const result = await accountRepo.findById(response.body.id);
+    expect(result).to.containDeep(account);
+  });
+
+  it('gets a count of accounts', async function () {
+    await givenAccountInstance(accountRepo, {balance: 22});
+    await givenAccountInstance(accountRepo, {balance: 33});
+    await client.get('/accounts/count').expect(200, {count: 2});
+  });
+
+  context('when dealing with a single persisted account', () => {
+    let persistedAccount: Account;
+
+    beforeEach(async () => {
+      persistedAccount = await givenAccountInstance(accountRepo);
+    });
+
+    it('gets an account by ID', () => {
+      return client
+        .get(`/accounts/${persistedAccount.id}`)
+        .send()
+        .expect(200, toJSON(persistedAccount));
+    });
+
+    it('returns 404 when getting an account that does not exist', () => {
+      return client.get('/accounts/99999').expect(404);
+    });
+
+    it('replaces the account by ID', async () => {
+      const updatedAccount = givenAccount({
+        balance: 44,
+      });
+      await client
+        .put(`/accounts/${persistedAccount.id}`)
+        .send(updatedAccount)
+        .expect(204);
+      const result = await accountRepo.findById(persistedAccount.id);
+      expect(result).to.containEql(updatedAccount);
+    });
+
+    it('returns 404 when replacing an account that does not exist', () => {
+      return client.put('/accounts/99999').send(givenAccount()).expect(404);
+    });
+
+    it('updates the account by ID ', async () => {
+      const updatedAccount = givenAccount({
+        balance: 55,
+      });
+      await client
+        .patch(`/accounts/${persistedAccount.id}`)
+        .send(updatedAccount)
+        .expect(204);
+      const result = await accountRepo.findById(persistedAccount.id);
+      expect(result).to.containEql(updatedAccount);
+    });
+
+    it('returns 404 when updating an account that does not exist', () => {
+      return client.patch('/account/99999').send(givenAccount()).expect(404);
+    });
+
+    it('deletes the account', async () => {
+      await client.del(`/accounts/${persistedAccount.id}`).send().expect(204);
+      await expect(
+        accountRepo.findById(persistedAccount.id),
+      ).to.be.rejectedWith(EntityNotFoundError);
+    });
+
+    it('returns 404 when deleting an account that does not exist', async () => {
+      await client.del(`/accounts/99999`).expect(404);
+    });
+  });
+
+  it('queries accounts with a filter', async () => {
+    await givenAccountInstance(accountRepo, {balance: 77});
+
+    const emptyAccount = await givenAccountInstance(accountRepo, {balance: 0});
+
+    await client
+      .get('/accounts')
+      .query({filter: {where: {balance: 0}}})
+      .expect(200, [toJSON(emptyAccount)]);
+  });
+
+  it('updates accounts using a filter', async () => {
+    await givenAccountInstance(accountRepo, {
+      balance: 1,
+    });
+    await givenAccountInstance(accountRepo, {
+      balance: 2,
+    });
+    await client
+      .patch('/accounts')
+      .query({where: {balance: 2}})
+      .send({balance: 3})
+      .expect(200, {count: 1});
+  });
+});

package/src/__tests__/acceptance/customer.acceptance.ts

@@ -0,0 +1,198 @@
+// Copyright IBM Corp. and LoopBack contributors 2019,2020. All Rights Reserved.
+// Node module: @loopback/example-references-many
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {EntityNotFoundError} from '@loopback/repository';
+import {Client, createRestAppClient, expect, toJSON} from '@loopback/testlab';
+import {ReferencesManyApplication} from '../../application';
+import {Customer} from '../../models/';
+import {AccountRepository, CustomerRepository} from '../../repositories/';
+import {
+  givenAccountInstance,
+  givenCustomer,
+  givenCustomerInstance,
+  givenCustomerRepositories,
+  givenRunningApplicationWithCustomConfiguration,
+} from '../helpers';
+
+describe('ReferencesManyApplication', () => {
+  let app: ReferencesManyApplication;
+  let client: Client;
+  let customerRepo: CustomerRepository;
+  let accountRepo: AccountRepository;
+
+  before(async () => {
+    app = await givenRunningApplicationWithCustomConfiguration();
+  });
+  after(() => app.stop());
+
+  before(async () => {
+    ({customerRepo, accountRepo} = await givenCustomerRepositories(app));
+  });
+  before(() => {
+    client = createRestAppClient(app);
+  });
+
+  beforeEach(async () => {
+    await customerRepo.deleteAll();
+    await accountRepo.deleteAll();
+  });
+
+  it('creates a customer', async function () {
+    const customer = givenCustomer();
+    const response = await client.post('/customers').send(customer).expect(200);
+    expect(response.body).to.containDeep(customer);
+    const result = await customerRepo.findById(response.body.id);
+    expect(result).to.containDeep(customer);
+  });
+
+  it('gets a count of customers', async function () {
+    await givenCustomerInstance(customerRepo, {
+      firstName: 'Andrew',
+      lastName: 'Jackson',
+    });
+    await givenCustomerInstance(customerRepo, {
+      firstName: 'James',
+      lastName: 'Gunn',
+    });
+    await client.get('/customers/count').expect(200, {count: 2});
+  });
+
+  context('when dealing with a single persisted customer', () => {
+    let persistedCustomer: Customer;
+
+    beforeEach(async () => {
+      persistedCustomer = await givenCustomerInstance(customerRepo);
+    });
+
+    it('gets a customer by ID', () => {
+      return client
+        .get(`/customers/${persistedCustomer.id}`)
+        .send()
+        .expect(200, toJSON(persistedCustomer));
+    });
+
+    it('returns 404 when getting a customer that does not exist', () => {
+      return client.get('/customers/99999').expect(404);
+    });
+
+    it('replaces the customer by ID', async () => {
+      const updatedCustomer = givenCustomer({
+        firstName: 'Andrew',
+        lastName: 'Jackson',
+      });
+      await client
+        .put(`/customers/${persistedCustomer.id}`)
+        .send(updatedCustomer)
+        .expect(204);
+      const result = await customerRepo.findById(persistedCustomer.id);
+      expect(result).to.containEql(updatedCustomer);
+    });
+
+    it('returns 404 when replacing a customer that does not exist', () => {
+      return client.put('/customers/99999').send(givenCustomer()).expect(404);
+    });
+
+    it('updates the customer by ID ', async () => {
+      const updatedCustomer = givenCustomer({
+        firstName: 'Tommy',
+        lastName: 'Jeans',
+      });
+      await client
+        .patch(`/customers/${persistedCustomer.id}`)
+        .send(updatedCustomer)
+        .expect(204);
+      const result = await customerRepo.findById(persistedCustomer.id);
+      expect(result).to.containEql(updatedCustomer);
+    });
+
+    it('returns 404 when updating a customer that does not exist', () => {
+      return client.patch('/customer/99999').send(givenCustomer()).expect(404);
+    });
+
+    it('deletes the customer', async () => {
+      await client.del(`/customers/${persistedCustomer.id}`).send().expect(204);
+      await expect(
+        customerRepo.findById(persistedCustomer.id),
+      ).to.be.rejectedWith(EntityNotFoundError);
+    });
+
+    it('returns 404 when deleting a customer that does not exist', async () => {
+      await client.del(`/customers/99999`).expect(404);
+    });
+  });
+
+  it('queries customers with a filter', async () => {
+    await givenCustomerInstance(customerRepo, {
+      firstName: 'Andrew',
+      lastName: 'Jackson',
+    });
+
+    const unnamedCustomer = await givenCustomerInstance(customerRepo, {
+      firstName: '',
+      lastName: '',
+    });
+
+    await client
+      .get('/customers')
+      .query({filter: {where: {firstName: ''}}})
+      .expect(200, [toJSON(unnamedCustomer)]);
+  });
+
+  it('updates customers using a filter', async () => {
+    await givenCustomerInstance(customerRepo, {
+      firstName: 'Andrew',
+      lastName: 'Jackson',
+    });
+    await givenCustomerInstance(customerRepo, {
+      firstName: 'James',
+      lastName: 'Gunn',
+    });
+    await client
+      .patch('/customers')
+      .query({where: {firstName: 'Andrew'}})
+      .send({firstName: 'Tommy'})
+      .expect(200, {count: 1});
+  });
+
+  it('includes Accounts in query result', async () => {
+    const firstAccount = await givenAccountInstance(accountRepo, {balance: 10});
+    const secondAccount = await givenAccountInstance(accountRepo, {
+      balance: 20,
+    });
+    const customer = await givenCustomerInstance(customerRepo);
+    const customerWithAccounts = await givenCustomerInstance(customerRepo, {
+      accountIds: [firstAccount.id, secondAccount.id],
+    });
+    const filter = JSON.stringify({include: ['accounts']});
+
+    const response = await client.get('/customers').query({filter: filter});
+
+    expect(response.body).to.have.length(2);
+    expect(response.body[0]).to.deepEqual({
+      ...toJSON(customer),
+      accounts: [],
+    });
+    expect(response.body[1]).to.deepEqual({
+      ...toJSON(customerWithAccounts),
+      accounts: [toJSON(firstAccount), toJSON(secondAccount)],
+    });
+  });
+
+  it('not includes a not existed Account in query result', async () => {
+    const notExistedId = 1;
+    const customer = await givenCustomerInstance(customerRepo, {
+      accountIds: [notExistedId],
+    });
+    const filter = JSON.stringify({include: ['accounts']});
+
+    const response = await client.get('/customers').query({filter: filter});
+
+    expect(response.body).to.have.length(1);
+    expect(response.body[0]).to.deepEqual({
+      ...toJSON(customer),
+      accounts: [],
+    });
+  });
+});

package/src/__tests__/acceptance/home-page.acceptance.ts

@@ -0,0 +1,36 @@
+// Copyright IBM Corp. and LoopBack contributors 2019,2020. All Rights Reserved.
+// Node module: @loopback/example-references-many
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {Client} from '@loopback/testlab';
+import {ReferencesManyApplication} from '../..';
+import {setupApplication} from './test-helper';
+
+describe('HomePage', () => {
+  let app: ReferencesManyApplication;
+  let client: Client;
+
+  before('setupApplication', async () => {
+    ({app, client} = await setupApplication());
+  });
+
+  after(async () => {
+    await app.stop();
+  });
+
+  it('exposes a default home page', async () => {
+    await client
+      .get('/')
+      .expect(200)
+      .expect('Content-Type', /text\/html/);
+  });
+
+  it('exposes self-hosted explorer', async () => {
+    await client
+      .get('/explorer/')
+      .expect(200)
+      .expect('Content-Type', /text\/html/)
+      .expect(/<title>LoopBack API Explorer/);
+  });
+});

package/src/__tests__/acceptance/test-helper.ts

@@ -0,0 +1,29 @@
+// Copyright IBM Corp. and LoopBack contributors 2019,2020. All Rights Reserved.
+// Node module: @loopback/example-references-many
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {
+  Client,
+  createRestAppClient,
+  givenHttpServerConfig,
+} from '@loopback/testlab';
+import {ReferencesManyApplication} from '../..';
+
+export async function setupApplication(): Promise<AppWithClient> {
+  const app = new ReferencesManyApplication({
+    rest: givenHttpServerConfig(),
+  });
+
+  await app.boot();
+  await app.start();
+
+  const client = createRestAppClient(app);
+
+  return {app, client};
+}
+
+export interface AppWithClient {
+  app: ReferencesManyApplication;
+  client: Client;
+}