@loopback/cli 4.0.0-alpha.9 → 4.1.1

package/generators/relation/references-many-relation.generator.js

@@ -0,0 +1,142 @@
+// Copyright IBM Corp. and LoopBack contributors 2019,2020. All Rights Reserved.
+// Node module: @loopback/cli
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+'use strict';
+
+const BaseRelationGenerator = require('./base-relation.generator');
+const utils = require('../../lib/utils');
+const relationUtils = require('./utils.generator');
+
+module.exports = class ReferencesManyRelationGenerator extends (
+  BaseRelationGenerator
+) {
+  constructor(args, opts) {
+    super(args, opts);
+  }
+
+  async generateControllers(options) {
+    // no controllers
+  }
+
+  async generateModels(options) {
+    // for repo to generate relation name
+    this.artifactInfo.relationName = options.relationName;
+    const modelDir = this.artifactInfo.modelDir;
+    const sourceModel = options.sourceModel;
+
+    const targetModel = options.destinationModel;
+    const relationType = options.relationType;
+    const relationName = options.relationName;
+    const defaultRelationName = options.defaultRelationName;
+    const foreignKeyName = options.foreignKeyName;
+    const fkType = options.destinationModelPrimaryKeyType;
+
+    const project = new relationUtils.AstLoopBackProject();
+    const sourceFile = relationUtils.addFileToProject(
+      project,
+      modelDir,
+      sourceModel,
+    );
+    const sourceClass = relationUtils.getClassObj(sourceFile, sourceModel);
+    // this checks if the foreign key already exists, so the 2nd param should be foreignKeyName
+    relationUtils.doesRelationExist(sourceClass, foreignKeyName);
+
+    const modelProperty = this.getReferencesMany(
+      targetModel,
+      relationName,
+      defaultRelationName,
+      foreignKeyName,
+      fkType,
+    );
+
+    relationUtils.addProperty(sourceClass, modelProperty);
+    const imports = relationUtils.getRequiredImports(targetModel, relationType);
+    relationUtils.addRequiredImports(sourceFile, imports);
+
+    sourceClass.formatText();
+    await sourceFile.save();
+  }
+
+  getReferencesMany(
+    className,
+    relationName,
+    defaultRelationName,
+    foreignKeyName,
+    fkType,
+  ) {
+    // checks if relation name is customized
+    let relationDecorator = [
+      {
+        name: 'referencesMany',
+        arguments: [`() =>  ${className}`],
+      },
+    ];
+    // already checked if the relation name is the same as the source key before
+    if (defaultRelationName !== relationName) {
+      relationDecorator = [
+        {
+          name: 'referencesMany',
+          arguments: [`() => ${className}, {name: '${relationName}'}`],
+        },
+      ];
+    }
+    return {
+      decorators: relationDecorator,
+      name: foreignKeyName,
+      type: fkType + '[]',
+    };
+  }
+
+  _getRepositoryRequiredImports(dstModelClassName, dstRepositoryClassName) {
+    const importsArray = super._getRepositoryRequiredImports(
+      dstModelClassName,
+      dstRepositoryClassName,
+    );
+    importsArray.push({
+      name: 'ReferencesManyAccessor',
+      module: '@loopback/repository',
+    });
+    return importsArray;
+  }
+
+  _getRepositoryRelationPropertyName() {
+    return this.artifactInfo.relationName;
+  }
+
+  _initializeProperties(options) {
+    super._initializeProperties(options);
+    this.artifactInfo.dstModelPrimaryKey = options.destinationModelPrimaryKey;
+  }
+
+  _getRepositoryRelationPropertyType() {
+    return (
+      `ReferencesManyAccessor<` +
+      `${utils.toClassName(this.artifactInfo.dstModelClass)}` +
+      `, typeof ${utils.toClassName(this.artifactInfo.srcModelClass)}` +
+      `.prototype.${this.artifactInfo.srcModelPrimaryKey}>`
+    );
+  }
+
+  _addCreatorToRepositoryConstructor(classConstructor) {
+    const relationName = this.artifactInfo.relationName;
+    const statement =
+      `this.${relationName} = ` +
+      `this.createReferencesManyAccessorFor('` +
+      `${relationName}',` +
+      ` ${utils.camelCase(this.artifactInfo.dstRepositoryClassName)}` +
+      `Getter,);`;
+    classConstructor.insertStatements(1, statement);
+  }
+
+  _registerInclusionResolverForRelation(classConstructor, options) {
+    const relationName = this.artifactInfo.relationName;
+    if (options.registerInclusionResolver) {
+      const statement =
+        `this.registerInclusionResolver(` +
+        `'${relationName}', this.${relationName}.inclusionResolver);`;
+      classConstructor.insertStatements(2, statement);
+    }
+  }
+};

package/generators/relation/templates/controller-relation-template-belongs-to.ts.ejs

@@ -0,0 +1,38 @@
+import {
+  repository,
+} from '@loopback/repository';
+import {
+  param,
+  get,
+  getModelSchemaRef,
+} from '@loopback/rest';
+import {
+  <%= sourceModelClassName %>,
+  <%= targetModelClassName %>,
+} from '../models';
+import {<%= sourceRepositoryClassName %>} from '../repositories';
+
+export class <%= controllerClassName %> {
+  constructor(
+    @repository(<%= sourceRepositoryClassName %>)
+    public <%= paramSourceRepository %>: <%= sourceRepositoryClassName %>,
+  ) { }
+
+  @get('/<%= sourceModelPath %>/{id}/<%= targetModelName %>', {
+    responses: {
+      '200': {
+        description: '<%= targetModelClassName %> belonging to <%= sourceModelClassName %>',
+        content: {
+          'application/json': {
+            schema: {type: 'array', items: getModelSchemaRef(<%= targetModelClassName %>)},
+          },
+        },
+      },
+    },
+  })
+  async get<%= targetModelClassName %>(
+    @param.path.<%= sourceModelPrimaryKeyType %>('id') id: typeof <%= sourceModelClassName %>.prototype.<%= sourceModelPrimaryKey %>,
+  ): Promise<<%= targetModelClassName %>> {
+    return this.<%= paramSourceRepository %>.<%= relationPropertyName %>(id);
+  }
+}

package/generators/relation/templates/controller-relation-template-has-many-through.ts.ejs

@@ -0,0 +1,110 @@
+import {
+  Count,
+  CountSchema,
+  Filter,
+  repository,
+  Where,
+} from '@loopback/repository';
+  import {
+  del,
+  get,
+  getModelSchemaRef,
+  getWhereSchemaFor,
+  param,
+  patch,
+  post,
+  requestBody,
+} from '@loopback/rest';
+import {
+<%= sourceModelClassName %>,
+<%= throughModelClassName %>,
+<%= targetModelClassName %>,
+} from '../models';
+import {<%= sourceRepositoryClassName %>} from '../repositories';
+
+export class <%= controllerClassName %> {
+  constructor(
+    @repository(<%= sourceRepositoryClassName %>) protected <%= paramSourceRepository %>: <%= sourceRepositoryClassName %>,
+  ) { }
+
+  @get('/<%= sourceModelPath %>/{id}/<%= targetModelPath %>', {
+    responses: {
+      '200': {
+        description: 'Array of <%= sourceModelClassName %> has many <%= targetModelClassName %> through <%= throughModelClassName %>',
+        content: {
+          'application/json': {
+            schema: {type: 'array', items: getModelSchemaRef(<%= targetModelClassName %>)},
+          },
+        },
+      },
+    },
+  })
+  async find(
+    @param.path.<%= sourceModelPrimaryKeyType %>('id') id: <%= sourceModelPrimaryKeyType %>,
+    @param.query.object('filter') filter?: Filter<<%= targetModelClassName %>>,
+  ): Promise<<%= targetModelClassName %>[]> {
+    return this.<%= paramSourceRepository %>.<%= relationPropertyName %>(id).find(filter);
+  }
+
+  @post('/<%= sourceModelPath %>/{id}/<%= targetModelPath %>', {
+    responses: {
+      '200': {
+        description: 'create a <%= targetModelClassName %> model instance',
+        content: {'application/json': {schema: getModelSchemaRef(<%= targetModelClassName %>)}},
+      },
+    },
+  })
+  async create(
+    @param.path.<%= sourceModelPrimaryKeyType %>('id') id: typeof <%= sourceModelClassName %>.prototype.<%= sourceModelPrimaryKey %>,
+    @requestBody({
+      content: {
+        'application/json': {
+          schema: getModelSchemaRef(<%= targetModelClassName %>, {
+            title: 'New<%= targetModelClassName %>In<%= sourceModelClassName %>',
+            exclude: ['<%= targetModelPrimaryKey %>'],
+          }),
+        },
+      },
+    }) <%= targetModelRequestBody %>: Omit<<%= targetModelClassName %>, '<%= targetModelPrimaryKey %>'>,
+  ): Promise<<%= targetModelClassName %>> {
+    return this.<%= paramSourceRepository %>.<%= relationPropertyName %>(id).create(<%= targetModelRequestBody %>);
+  }
+
+  @patch('/<%= sourceModelPath %>/{id}/<%= targetModelPath %>', {
+    responses: {
+      '200': {
+        description: '<%= sourceModelClassName %>.<%= targetModelClassName %> PATCH success count',
+        content: {'application/json': {schema: CountSchema}},
+      },
+    },
+  })
+  async patch(
+    @param.path.<%= sourceModelPrimaryKeyType %>('id') id: <%= sourceModelPrimaryKeyType %>,
+    @requestBody({
+      content: {
+        'application/json': {
+          schema: getModelSchemaRef(<%= targetModelClassName %>, {partial: true}),
+        },
+      },
+    })
+    <%= targetModelRequestBody %>: Partial<<%= targetModelClassName %>>,
+    @param.query.object('where', getWhereSchemaFor(<%= targetModelClassName %>)) where?: Where<<%= targetModelClassName %>>,
+  ): Promise<Count> {
+    return this.<%= paramSourceRepository %>.<%= relationPropertyName %>(id).patch(<%= targetModelRequestBody %>, where);
+  }
+
+  @del('/<%= sourceModelPath %>/{id}/<%= targetModelPath %>', {
+    responses: {
+      '200': {
+        description: '<%= sourceModelClassName %>.<%= targetModelClassName %> DELETE success count',
+        content: {'application/json': {schema: CountSchema}},
+      },
+    },
+  })
+  async delete(
+    @param.path.<%= sourceModelPrimaryKeyType %>('id') id: <%= sourceModelPrimaryKeyType %>,
+    @param.query.object('where', getWhereSchemaFor(<%= targetModelClassName %>)) where?: Where<<%= targetModelClassName %>>,
+  ): Promise<Count> {
+    return this.<%= paramSourceRepository %>.<%= relationPropertyName %>(id).delete(where);
+  }
+}

package/generators/relation/templates/controller-relation-template-has-many.ts.ejs

@@ -0,0 +1,110 @@
+import {
+  Count,
+  CountSchema,
+  Filter,
+  repository,
+  Where,
+} from '@loopback/repository';
+import {
+  del,
+  get,
+  getModelSchemaRef,
+  getWhereSchemaFor,
+  param,
+  patch,
+  post,
+  requestBody,
+} from '@loopback/rest';
+import {
+  <%= sourceModelClassName %>,
+  <%= targetModelClassName %>,
+} from '../models';
+import {<%= sourceRepositoryClassName %>} from '../repositories';
+
+export class <%= controllerClassName %> {
+  constructor(
+    @repository(<%= sourceRepositoryClassName %>) protected <%= paramSourceRepository %>: <%= sourceRepositoryClassName %>,
+  ) { }
+
+  @get('/<%= sourceModelPath %>/{id}/<%= targetModelPath %>', {
+    responses: {
+      '200': {
+        description: 'Array of <%= sourceModelClassName %> has many <%= targetModelClassName %>',
+        content: {
+          'application/json': {
+            schema: {type: 'array', items: getModelSchemaRef(<%= targetModelClassName %>)},
+          },
+        },
+      },
+    },
+  })
+  async find(
+    @param.path.<%= sourceModelPrimaryKeyType %>('id') id: <%= sourceModelPrimaryKeyType %>,
+    @param.query.object('filter') filter?: Filter<<%= targetModelClassName %>>,
+  ): Promise<<%= targetModelClassName %>[]> {
+    return this.<%= paramSourceRepository %>.<%= relationPropertyName %>(id).find(filter);
+  }
+
+  @post('/<%= sourceModelPath %>/{id}/<%= targetModelPath %>', {
+    responses: {
+      '200': {
+        description: '<%= sourceModelClassName %> model instance',
+        content: {'application/json': {schema: getModelSchemaRef(<%= targetModelClassName %>)}},
+      },
+    },
+  })
+  async create(
+    @param.path.<%= sourceModelPrimaryKeyType %>('id') id: typeof <%= sourceModelClassName %>.prototype.<%= sourceModelPrimaryKey %>,
+    @requestBody({
+      content: {
+        'application/json': {
+          schema: getModelSchemaRef(<%= targetModelClassName %>, {
+            title: 'New<%= targetModelClassName %>In<%= sourceModelClassName %>',
+            exclude: ['<%= targetModelPrimaryKey %>'],
+            optional: ['<%= foreignKeyName %>']
+          }),
+        },
+      },
+    }) <%= targetModelRequestBody %>: Omit<<%= targetModelClassName %>, '<%= targetModelPrimaryKey %>'>,
+  ): Promise<<%= targetModelClassName %>> {
+    return this.<%= paramSourceRepository %>.<%= relationPropertyName %>(id).create(<%= targetModelRequestBody %>);
+  }
+
+  @patch('/<%= sourceModelPath %>/{id}/<%= targetModelPath %>', {
+    responses: {
+      '200': {
+        description: '<%= sourceModelClassName %>.<%= targetModelClassName %> PATCH success count',
+        content: {'application/json': {schema: CountSchema}},
+      },
+    },
+  })
+  async patch(
+    @param.path.<%= sourceModelPrimaryKeyType %>('id') id: <%= sourceModelPrimaryKeyType %>,
+    @requestBody({
+      content: {
+        'application/json': {
+          schema: getModelSchemaRef(<%= targetModelClassName %>, {partial: true}),
+        },
+      },
+    })
+    <%= targetModelRequestBody %>: Partial<<%= targetModelClassName %>>,
+    @param.query.object('where', getWhereSchemaFor(<%= targetModelClassName %>)) where?: Where<<%= targetModelClassName %>>,
+  ): Promise<Count> {
+    return this.<%= paramSourceRepository %>.<%= relationPropertyName %>(id).patch(<%= targetModelRequestBody %>, where);
+  }
+
+  @del('/<%= sourceModelPath %>/{id}/<%= targetModelPath %>', {
+    responses: {
+      '200': {
+        description: '<%= sourceModelClassName %>.<%= targetModelClassName %> DELETE success count',
+        content: {'application/json': {schema: CountSchema}},
+      },
+    },
+  })
+  async delete(
+    @param.path.<%= sourceModelPrimaryKeyType %>('id') id: <%= sourceModelPrimaryKeyType %>,
+    @param.query.object('where', getWhereSchemaFor(<%= targetModelClassName %>)) where?: Where<<%= targetModelClassName %>>,
+  ): Promise<Count> {
+    return this.<%= paramSourceRepository %>.<%= relationPropertyName %>(id).delete(where);
+  }
+}

package/generators/relation/templates/controller-relation-template-has-one.ts.ejs

@@ -0,0 +1,110 @@
+import {
+  Count,
+  CountSchema,
+  Filter,
+  repository,
+  Where,
+} from '@loopback/repository';
+import {
+  del,
+  get,
+  getModelSchemaRef,
+  getWhereSchemaFor,
+  param,
+  patch,
+  post,
+  requestBody,
+} from '@loopback/rest';
+import {
+  <%= sourceModelClassName %>,
+  <%= targetModelClassName %>,
+} from '../models';
+import {<%= sourceRepositoryClassName %>} from '../repositories';
+
+export class <%= controllerClassName %> {
+  constructor(
+    @repository(<%= sourceRepositoryClassName %>) protected <%= paramSourceRepository %>: <%= sourceRepositoryClassName %>,
+  ) { }
+
+  @get('/<%= sourceModelPath %>/{id}/<%= targetModelPath %>', {
+    responses: {
+      '200': {
+        description: '<%= sourceModelClassName %> has one <%= targetModelClassName %>',
+        content: {
+          'application/json': {
+            schema: getModelSchemaRef(<%= targetModelClassName %>),
+          },
+        },
+      },
+    },
+  })
+  async get(
+    @param.path.<%= sourceModelPrimaryKeyType %>('id') id: <%= sourceModelPrimaryKeyType %>,
+    @param.query.object('filter') filter?: Filter<<%= targetModelClassName %>>,
+  ): Promise<<%= targetModelClassName %>> {
+    return this.<%= paramSourceRepository %>.<%= relationPropertyName %>(id).get(filter);
+  }
+
+  @post('/<%= sourceModelPath %>/{id}/<%= targetModelPath %>', {
+    responses: {
+      '200': {
+        description: '<%= sourceModelClassName %> model instance',
+        content: {'application/json': {schema: getModelSchemaRef(<%= targetModelClassName %>)}},
+      },
+    },
+  })
+  async create(
+    @param.path.<%= sourceModelPrimaryKeyType %>('id') id: typeof <%= sourceModelClassName %>.prototype.<%= sourceModelPrimaryKey %>,
+    @requestBody({
+      content: {
+        'application/json': {
+          schema: getModelSchemaRef(<%= targetModelClassName %>, {
+            title: 'New<%= targetModelClassName %>In<%= sourceModelClassName %>',
+            exclude: ['<%= targetModelPrimaryKey %>'],
+            optional: ['<%= foreignKeyName %>']
+          }),
+        },
+      },
+    }) <%= targetModelRequestBody %>: Omit<<%= targetModelClassName %>, '<%= targetModelPrimaryKey %>'>,
+  ): Promise<<%= targetModelClassName %>> {
+    return this.<%= paramSourceRepository %>.<%= relationPropertyName %>(id).create(<%= targetModelRequestBody %>);
+  }
+
+  @patch('/<%= sourceModelPath %>/{id}/<%= targetModelPath %>', {
+    responses: {
+      '200': {
+        description: '<%= sourceModelClassName %>.<%= targetModelClassName %> PATCH success count',
+        content: {'application/json': {schema: CountSchema}},
+      },
+    },
+  })
+  async patch(
+    @param.path.<%= sourceModelPrimaryKeyType %>('id') id: <%= sourceModelPrimaryKeyType %>,
+    @requestBody({
+      content: {
+        'application/json': {
+          schema: getModelSchemaRef(<%= targetModelClassName %>, {partial: true}),
+        },
+      },
+    })
+    <%= targetModelRequestBody %>: Partial<<%= targetModelClassName %>>,
+    @param.query.object('where', getWhereSchemaFor(<%= targetModelClassName %>)) where?: Where<<%= targetModelClassName %>>,
+  ): Promise<Count> {
+    return this.<%= paramSourceRepository %>.<%= relationPropertyName %>(id).patch(<%= targetModelRequestBody %>, where);
+  }
+
+  @del('/<%= sourceModelPath %>/{id}/<%= targetModelPath %>', {
+    responses: {
+      '200': {
+        description: '<%= sourceModelClassName %>.<%= targetModelClassName %> DELETE success count',
+        content: {'application/json': {schema: CountSchema}},
+      },
+    },
+  })
+  async delete(
+    @param.path.<%= sourceModelPrimaryKeyType %>('id') id: <%= sourceModelPrimaryKeyType %>,
+    @param.query.object('where', getWhereSchemaFor(<%= targetModelClassName %>)) where?: Where<<%= targetModelClassName %>>,
+  ): Promise<Count> {
+    return this.<%= paramSourceRepository %>.<%= relationPropertyName %>(id).delete(where);
+  }
+}