@loopback/example-references-many 6.0.1

package/src/__tests__/helpers.ts

@@ -0,0 +1,119 @@
+// 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 {juggler} from '@loopback/repository';
+import {givenHttpServerConfig} from '@loopback/testlab';
+import {ReferencesManyApplication} from '../application';
+import {Account, Customer} from '../models';
+import {AccountRepository, CustomerRepository} from '../repositories';
+
+/*
+ ==============================================================================
+ HELPER FUNCTIONS
+ If you find yourself creating the same helper functions across different
+ test files, then extracting those functions into helper modules is an easy
+ way to reduce duplication.
+
+ Other tips:
+
+ - Using the super awesome Partial<T> type in conjunction with Object.assign
+   means you can:
+   * customize the object you get back based only on what's important
+   to you during a particular test
+   * avoid writing test logic that is brittle with respect to the properties
+   of your object
+ - Making the input itself optional means you don't need to do anything special
+   for tests where the particular details of the input don't matter.
+ ==============================================================================
+ */
+
+/**
+ * Generate a complete Customer object for use with tests.
+ * @param customer - A partial (or complete) Customer object.
+ */
+export function givenCustomer(customer?: Partial<Customer>) {
+  const data = Object.assign(
+    {
+      firstName: 'John',
+      lastName: 'Doe',
+    },
+    customer,
+  );
+  return new Customer(data);
+}
+
+/**
+ * Generate a complete Account object for use with tests.
+ * @param account - A partial (or complete) Account object.
+ */
+export function givenAccount(account?: Partial<Account>) {
+  const data = Object.assign({balance: 999}, account);
+  return new Account(data);
+}
+
+export async function givenRunningApplicationWithCustomConfiguration() {
+  const app = new ReferencesManyApplication({
+    rest: givenHttpServerConfig(),
+  });
+
+  await app.boot();
+
+  /**
+   * Override default config for DataSource for testing so we don't write
+   * test data to file when using the memory connector.
+   */
+  app.bind('datasources.config.db').to({
+    name: 'db',
+    connector: 'memory',
+  });
+
+  // Start Application
+  await app.start();
+  return app;
+}
+
+export async function givenCustomerRepositories(
+  app: ReferencesManyApplication,
+) {
+  const customerRepo = await app.getRepository(CustomerRepository);
+  const accountRepo = await app.getRepository(AccountRepository);
+  return {customerRepo, accountRepo};
+}
+
+export async function givenAccountRepositories(app: ReferencesManyApplication) {
+  const accountRepo = await app.getRepository(AccountRepository);
+  return {accountRepo};
+}
+
+export async function givenCustomerInstance(
+  customerRepo: CustomerRepository,
+  customer?: Partial<Customer>,
+) {
+  return customerRepo.create(givenCustomer(customer));
+}
+
+export async function givenAccountInstance(
+  accountRepo: AccountRepository,
+  account?: Partial<Account>,
+) {
+  return accountRepo.create(givenAccount(account));
+}
+
+export async function givenEmptyDatabase() {
+  const accountRepo: AccountRepository = new AccountRepository(testdb);
+  const customerRepo: CustomerRepository = new CustomerRepository(
+    testdb,
+    async () => accountRepo,
+    async () => customerRepo,
+  );
+
+  await accountRepo.deleteAll();
+  await customerRepo.deleteAll();
+}
+
+export const testdb: juggler.DataSource = new juggler.DataSource({
+  name: 'db',
+  connector: 'memory',
+});

package/src/__tests__/integration/customer.repository.integration.ts

@@ -0,0 +1,80 @@
+// 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 {expect, toJSON} from '@loopback/testlab';
+import {AccountRepository, CustomerRepository} from '../../repositories';
+import {
+  givenAccountInstance,
+  givenCustomerInstance,
+  givenEmptyDatabase,
+  testdb,
+} from '../helpers';
+
+describe('ReferencesManyRepository', () => {
+  let accountRepo: AccountRepository;
+  let customerRepo: CustomerRepository;
+
+  before(async () => {
+    accountRepo = new AccountRepository(testdb);
+    customerRepo = new CustomerRepository(
+      testdb,
+      async () => accountRepo,
+      async () => customerRepo,
+    );
+  });
+
+  beforeEach(givenEmptyDatabase);
+
+  it('includes Accounts in find method result', async () => {
+    const account = await givenAccountInstance(accountRepo);
+    const customer = await givenCustomerInstance(customerRepo, {
+      accountIds: [account.id],
+    });
+
+    const response = await customerRepo.find({
+      include: ['accounts'],
+    });
+
+    expect(toJSON(response)).to.deepEqual([
+      {
+        ...toJSON(customer),
+        accounts: [toJSON(account)],
+      },
+    ]);
+  });
+
+  it('includes Accounts in findById result', async () => {
+    const account = await givenAccountInstance(accountRepo);
+    const customer = await givenCustomerInstance(customerRepo, {
+      accountIds: [account.id],
+    });
+
+    const response = await customerRepo.findById(customer.id, {
+      include: ['accounts'],
+    });
+
+    expect(toJSON(response)).to.deepEqual({
+      ...toJSON(customer),
+      accounts: [toJSON(account)],
+    });
+  });
+
+  it('includes Accounts in findOne method result', async () => {
+    const account = await givenAccountInstance(accountRepo);
+    const customer = await givenCustomerInstance(customerRepo, {
+      accountIds: [account.id],
+    });
+
+    const response = await customerRepo.findOne({
+      where: {id: customer.id},
+      include: ['accounts'],
+    });
+
+    expect(toJSON(response)).to.deepEqual({
+      ...toJSON(customer),
+      accounts: [toJSON(account)],
+    });
+  });
+});

package/src/__tests__/unit/controllers/account.controller.unit.ts

@@ -0,0 +1,127 @@
+// Copyright IBM Corp. and LoopBack contributors 2019,2020. All Rights Reserved.
+// Node module: @loopback/example-account-list
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {
+  createStubInstance,
+  expect,
+  sinon,
+  StubbedInstanceWithSinonAccessor,
+} from '@loopback/testlab';
+import {AccountController} from '../../../controllers';
+import {Account} from '../../../models';
+import {AccountRepository} from '../../../repositories';
+import {givenAccount} from '../../helpers';
+
+describe('AccountController', () => {
+  let accountRepo: StubbedInstanceWithSinonAccessor<AccountRepository>;
+
+  /*
+  =============================================================================
+  TEST VARIABLES
+  Combining top-level objects with our resetRepositories method means we don't
+  need to duplicate several variable assignments (and generation statements)
+  in all of our test logic.
+
+  NOTE: If you wanted to parallelize your test runs, you should avoid this
+  pattern since each of these tests is sharing references.
+  =============================================================================
+  */
+  let controller: AccountController;
+  let aAccount: Account;
+  let aAccountWithId: Account;
+  let aChangedAccount: Account;
+  let aListOfAccounts: Account[];
+
+  beforeEach(resetRepositories);
+
+  describe('createAccount', () => {
+    it('creates a Account', async () => {
+      const create = accountRepo.stubs.create;
+      create.resolves(aAccountWithId);
+      const result = await controller.create(aAccount);
+      expect(result).to.eql(aAccountWithId);
+      sinon.assert.calledWith(create, aAccount);
+    });
+  });
+
+  describe('findAccountById', () => {
+    it('returns a account if it exists', async () => {
+      const findById = accountRepo.stubs.findById;
+      findById.resolves(aAccountWithId);
+      expect(await controller.findById(aAccountWithId.id as number)).to.eql(
+        aAccountWithId,
+      );
+      sinon.assert.calledWith(findById, aAccountWithId.id);
+    });
+  });
+
+  describe('findAccounts', () => {
+    it('returns multiple accounts if they exist', async () => {
+      const find = accountRepo.stubs.find;
+      find.resolves(aListOfAccounts);
+      expect(await controller.find()).to.eql(aListOfAccounts);
+      sinon.assert.called(find);
+    });
+
+    it('returns empty list if no accounts exist', async () => {
+      const find = accountRepo.stubs.find;
+      const expected: Account[] = [];
+      find.resolves(expected);
+      expect(await controller.find()).to.eql(expected);
+      sinon.assert.called(find);
+    });
+  });
+
+  describe('replaceAccount', () => {
+    it('successfully replaces existing items', async () => {
+      const replaceById = accountRepo.stubs.replaceById;
+      replaceById.resolves();
+      await controller.replaceById(
+        aAccountWithId.id as number,
+        aChangedAccount,
+      );
+      sinon.assert.calledWith(replaceById, aAccountWithId.id, aChangedAccount);
+    });
+  });
+
+  describe('updateAccount', () => {
+    it('successfully updates existing items', async () => {
+      const updateById = accountRepo.stubs.updateById;
+      updateById.resolves();
+      await controller.updateById(aAccountWithId.id as number, aChangedAccount);
+      sinon.assert.calledWith(updateById, aAccountWithId.id, aChangedAccount);
+    });
+  });
+
+  describe('deleteAccount', () => {
+    it('successfully deletes existing items', async () => {
+      const deleteById = accountRepo.stubs.deleteById;
+      deleteById.resolves();
+      await controller.deleteById(aAccountWithId.id as number);
+      sinon.assert.calledWith(deleteById, aAccountWithId.id);
+    });
+  });
+
+  function resetRepositories() {
+    accountRepo = createStubInstance(AccountRepository);
+    aAccount = givenAccount();
+    aAccountWithId = givenAccount({
+      id: 1,
+    });
+    aListOfAccounts = [
+      aAccountWithId,
+      givenAccount({
+        id: 2,
+        balance: 5,
+      }),
+    ] as Account[];
+    aChangedAccount = givenAccount({
+      id: aAccountWithId.id,
+      balance: 10,
+    });
+
+    controller = new AccountController(accountRepo);
+  }
+});

package/src/__tests__/unit/controllers/customer.controller.unit.ts

@@ -0,0 +1,136 @@
+// Copyright IBM Corp. and LoopBack contributors 2019,2020. All Rights Reserved.
+// Node module: @loopback/example-customer-list
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {
+  createStubInstance,
+  expect,
+  sinon,
+  StubbedInstanceWithSinonAccessor,
+} from '@loopback/testlab';
+import {CustomerController} from '../../../controllers';
+import {Customer} from '../../../models';
+import {CustomerRepository} from '../../../repositories';
+import {givenCustomer} from '../../helpers';
+
+describe('CustomerController', () => {
+  let customerRepo: StubbedInstanceWithSinonAccessor<CustomerRepository>;
+
+  /*
+  =============================================================================
+  TEST VARIABLES
+  Combining top-level objects with our resetRepositories method means we don't
+  need to duplicate several variable assignments (and generation statements)
+  in all of our test logic.
+
+  NOTE: If you wanted to parallelize your test runs, you should avoid this
+  pattern since each of these tests is sharing references.
+  =============================================================================
+  */
+  let controller: CustomerController;
+  let aCustomer: Customer;
+  let aCustomerWithId: Customer;
+  let aChangedCustomer: Customer;
+  let aListOfCustomers: Customer[];
+
+  beforeEach(resetRepositories);
+
+  describe('createCustomer', () => {
+    it('creates a Customer', async () => {
+      const create = customerRepo.stubs.create;
+      create.resolves(aCustomerWithId);
+      const result = await controller.create(aCustomer);
+      expect(result).to.eql(aCustomerWithId);
+      sinon.assert.calledWith(create, aCustomer);
+    });
+  });
+
+  describe('findCustomerById', () => {
+    it('returns a customer if it exists', async () => {
+      const findById = customerRepo.stubs.findById;
+      findById.resolves(aCustomerWithId);
+      expect(await controller.findById(aCustomerWithId.id as number)).to.eql(
+        aCustomerWithId,
+      );
+      sinon.assert.calledWith(findById, aCustomerWithId.id);
+    });
+  });
+
+  describe('findCustomers', () => {
+    it('returns multiple customers if they exist', async () => {
+      const find = customerRepo.stubs.find;
+      find.resolves(aListOfCustomers);
+      expect(await controller.find()).to.eql(aListOfCustomers);
+      sinon.assert.called(find);
+    });
+
+    it('returns empty list if no customers exist', async () => {
+      const find = customerRepo.stubs.find;
+      const expected: Customer[] = [];
+      find.resolves(expected);
+      expect(await controller.find()).to.eql(expected);
+      sinon.assert.called(find);
+    });
+  });
+
+  describe('replaceCustomer', () => {
+    it('successfully replaces existing items', async () => {
+      const replaceById = customerRepo.stubs.replaceById;
+      replaceById.resolves();
+      await controller.replaceById(
+        aCustomerWithId.id as number,
+        aChangedCustomer,
+      );
+      sinon.assert.calledWith(
+        replaceById,
+        aCustomerWithId.id,
+        aChangedCustomer,
+      );
+    });
+  });
+
+  describe('updateCustomer', () => {
+    it('successfully updates existing items', async () => {
+      const updateById = customerRepo.stubs.updateById;
+      updateById.resolves();
+      await controller.updateById(
+        aCustomerWithId.id as number,
+        aChangedCustomer,
+      );
+      sinon.assert.calledWith(updateById, aCustomerWithId.id, aChangedCustomer);
+    });
+  });
+
+  describe('deleteCustomer', () => {
+    it('successfully deletes existing items', async () => {
+      const deleteById = customerRepo.stubs.deleteById;
+      deleteById.resolves();
+      await controller.deleteById(aCustomerWithId.id as number);
+      sinon.assert.calledWith(deleteById, aCustomerWithId.id);
+    });
+  });
+
+  function resetRepositories() {
+    customerRepo = createStubInstance(CustomerRepository);
+    aCustomer = givenCustomer();
+    aCustomerWithId = givenCustomer({
+      id: 1,
+    });
+    aListOfCustomers = [
+      aCustomerWithId,
+      givenCustomer({
+        id: 2,
+        firstName: 'Dave',
+        lastName: 'Brubeck',
+      }),
+    ] as Customer[];
+    aChangedCustomer = givenCustomer({
+      id: aCustomerWithId.id,
+      firstName: 'Tim',
+      lastName: 'Benton',
+    });
+
+    controller = new CustomerController(customerRepo);
+  }
+});

package/src/application.ts

@@ -0,0 +1,49 @@
+// 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
+
+import {BootMixin} from '@loopback/boot';
+import {ApplicationConfig} from '@loopback/core';
+import {RepositoryMixin} from '@loopback/repository';
+import {RestApplication} from '@loopback/rest';
+import {
+  RestExplorerBindings,
+  RestExplorerComponent,
+} from '@loopback/rest-explorer';
+import {ServiceMixin} from '@loopback/service-proxy';
+import path from 'path';
+import {MySequence} from './sequence';
+
+export {ApplicationConfig};
+
+export class ReferencesManyApplication extends BootMixin(
+  ServiceMixin(RepositoryMixin(RestApplication)),
+) {
+  constructor(options: ApplicationConfig = {}) {
+    super(options);
+
+    // Set up the custom sequence
+    this.sequence(MySequence);
+
+    // Set up default home page
+    this.static('/', path.join(__dirname, '../public'));
+
+    // Customize @loopback/rest-explorer configuration here
+    this.configure(RestExplorerBindings.COMPONENT).to({
+      path: '/explorer',
+    });
+    this.component(RestExplorerComponent);
+
+    this.projectRoot = __dirname;
+    // Customize @loopback/boot Booter Conventions here
+    this.bootOptions = {
+      controllers: {
+        // Customize ControllerBooter Conventions here
+        dirs: ['controllers'],
+        extensions: ['.controller.js'],
+        nested: true,
+      },
+    };
+  }
+}

package/src/controllers/account.controller.ts

@@ -0,0 +1,177 @@
+// 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
+
+import {
+  Count,
+  CountSchema,
+  Filter,
+  FilterExcludingWhere,
+  repository,
+  Where,
+} from '@loopback/repository';
+import {
+  del,
+  get,
+  getModelSchemaRef,
+  param,
+  patch,
+  post,
+  put,
+  requestBody,
+} from '@loopback/rest';
+import {Account} from '../models';
+import {AccountRepository} from '../repositories';
+
+export class AccountController {
+  constructor(
+    @repository(AccountRepository)
+    public accountRepository: AccountRepository,
+  ) {}
+
+  @post('/accounts', {
+    responses: {
+      '200': {
+        description: 'Account model instance',
+        content: {'application/json': {schema: getModelSchemaRef(Account)}},
+      },
+    },
+  })
+  async create(
+    @requestBody({
+      content: {
+        'application/json': {
+          schema: getModelSchemaRef(Account, {
+            title: 'NewAccount',
+            exclude: ['id'],
+          }),
+        },
+      },
+    })
+    account: Omit<Account, 'id'>,
+  ): Promise<Account> {
+    return this.accountRepository.create(account);
+  }
+
+  @get('/accounts/count', {
+    responses: {
+      '200': {
+        description: 'Account model count',
+        content: {'application/json': {schema: CountSchema}},
+      },
+    },
+  })
+  async count(@param.where(Account) where?: Where<Account>): Promise<Count> {
+    return this.accountRepository.count(where);
+  }
+
+  @get('/accounts', {
+    responses: {
+      '200': {
+        description: 'Array of Account model instances',
+        content: {
+          'application/json': {
+            schema: {
+              type: 'array',
+              items: getModelSchemaRef(Account, {includeRelations: true}),
+            },
+          },
+        },
+      },
+    },
+  })
+  async find(
+    @param.filter(Account) filter?: Filter<Account>,
+  ): Promise<Account[]> {
+    return this.accountRepository.find(filter);
+  }
+
+  @patch('/accounts', {
+    responses: {
+      '200': {
+        description: 'Account PATCH success count',
+        content: {'application/json': {schema: CountSchema}},
+      },
+    },
+  })
+  async updateAll(
+    @requestBody({
+      content: {
+        'application/json': {
+          schema: getModelSchemaRef(Account, {partial: true}),
+        },
+      },
+    })
+    account: Account,
+    @param.where(Account) where?: Where<Account>,
+  ): Promise<Count> {
+    return this.accountRepository.updateAll(account, where);
+  }
+
+  @get('/accounts/{id}', {
+    responses: {
+      '200': {
+        description: 'Account model instance',
+        content: {
+          'application/json': {
+            schema: getModelSchemaRef(Account, {includeRelations: true}),
+          },
+        },
+      },
+    },
+  })
+  async findById(
+    @param.path.number('id') id: number,
+    @param.filter(Account, {exclude: 'where'})
+    filter?: FilterExcludingWhere<Account>,
+  ): Promise<Account> {
+    return this.accountRepository.findById(id, filter);
+  }
+
+  @patch('/accounts/{id}', {
+    responses: {
+      '204': {
+        description: 'Account PATCH success',
+      },
+    },
+  })
+  async updateById(
+    @param.path.number('id') id: number,
+    @requestBody({
+      content: {
+        'application/json': {
+          schema: getModelSchemaRef(Account, {partial: true}),
+        },
+      },
+    })
+    account: Account,
+  ): Promise<void> {
+    await this.accountRepository.updateById(id, account);
+  }
+
+  @del('/accounts/{id}', {
+    responses: {
+      '204': {
+        description: 'Account DELETE success',
+      },
+    },
+  })
+  async deleteById(@param.path.number('id') id: number): Promise<void> {
+    await this.accountRepository.deleteById(id);
+  }
+
+  @put('/accounts/{id}', {
+    responses: {
+      '204': {
+        description: 'Account PUT success',
+      },
+    },
+  })
+  async replaceById(
+    @param.path.number('id') id: number,
+    @requestBody() account: Account,
+  ): Promise<void> {
+    await this.accountRepository.replaceById(id, account);
+  }
+}