@mikemajesty/microservice-crud 0.0.5 → 0.0.6

package/mongo.README.md

@@ -0,0 +1,24 @@
+#### Mongo CRUD
+
+### Add Module to microservice.
+
+ - Access the app.module.ts file
+  ```
+    src/app.module.ts
+  ```
+ - Add your Mongo Module in the Imports array. 
+  ```
+    imports: [NewModule]
+  ```
+
+---
+
+The following is a list of all the people that have contributed Nestjs monorepo CLI. Thanks for your contributions!
+
+[<img alt="mikemajesty" src="https://avatars1.githubusercontent.com/u/11630212?s=460&v=4&s=117" width="117">](https://github.com/mikemajesty)
+
+## License
+
+It is available under the MIT license.
+[License](https://opensource.org/licenses/mit-license.php)
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikemajesty/microservice-crud",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "Monorepo CLI",
   "main": "src/cli.js",
   "scripts": {

package/potgres.README.md

@@ -0,0 +1,35 @@
+#### Postgres CRUD
+
+### Add Schema to Sequelize.
+
+ - Access the config.ts file
+  ```
+    src/infra/database/postgres/config.ts
+  ```
+ - Add your Postgres schema in the addModels function. 
+  ```
+    sequelizeConfig.addModels([NewSchema]);
+  ```
+
+### Add Module to microservice.
+
+ - Access the app.module.ts file
+  ```
+    src/app.module.ts
+  ```
+ - Add your Postgres Module in the Imports array. 
+  ```
+    imports: [NewModule]
+  ```
+
+---
+
+The following is a list of all the people that have contributed Nestjs monorepo CLI. Thanks for your contributions!
+
+[<img alt="mikemajesty" src="https://avatars1.githubusercontent.com/u/11630212?s=460&v=4&s=117" width="117">](https://github.com/mikemajesty)
+
+## License
+
+It is available under the MIT license.
+[License](https://opensource.org/licenses/mit-license.php)
+

package/src/cli.js

@@ -22,7 +22,7 @@ const { getModuleAdapter } = require('./templates/postgres/modules/adapter');
 const { getModuleController } = require('./templates/postgres/modules/controller');
 const { getModule } = require('./templates/postgres/modules/module');
 const { getModuleRepository } = require('./templates/postgres/modules/repository');
-const { getModuleSchema } = require('./templates/postgres/modules/schema');
+const { getModuleSchema } = require('./templates/postgres/schemas/schema');
 const { getModuleSwagger } = require('./templates/postgres/modules/swagger');
 const { getModuleType } = require('./templates/postgres/modules/types');
 
@@ -43,7 +43,7 @@ const { getModuleAdapter: getModuleAdapterMongo } = require('./templates/mongo/m
 const { getModuleController: getModuleControllerMongo } = require('./templates/mongo/modules/controller');
 const { getModule: getModuleMongo } = require('./templates/mongo/modules/module');
 const { getModuleRepository: getModuleRepositoryMongo } = require('./templates/mongo/modules/repository');
-const { getModuleSchema: getModuleSchemaMongo } = require('./templates/mongo/modules/schema');
+const { getModuleSchema: getModuleSchemaMongo } = require('./templates/mongo/schemas/schema');
 const { getModuleSwagger: getModuleSwaggerMongo } = require('./templates/mongo/modules/swagger');
 const { getModuleType: getModuleTypeMongo } = require('./templates/mongo/modules/types');
 
@@ -88,24 +88,29 @@ const createPostgresCrud = async (name) => {
 
     const useCasesPathTest = `${useCasesPath}/__tests__`
     fs.mkdirSync(useCasesPathTest)
-
     fs.writeFileSync(`${useCasesPathTest}/${name}-create.spec.ts`, getCoreUsecaseCreateTest(name))
     fs.writeFileSync(`${useCasesPathTest}/${name}-update.spec.ts`, getCoreUsecaseUpdateTest(name))
     fs.writeFileSync(`${useCasesPathTest}/${name}-delete.spec.ts`, getCoreUsecaseDeleteTest(name))
     fs.writeFileSync(`${useCasesPathTest}/${name}-list.spec.ts`, getCoreUsecaseListTest(name))
     fs.writeFileSync(`${useCasesPathTest}/${name}-getByID.spec.ts`, getCoreUsecaseGetByIDTest(name))
 
+    const schemasPath = `${__dirname}/scafold/postgres/schemas`;
+    if (fs.existsSync(schemasPath)) {
+      fs.rmSync(schemasPath, { recursive: true });
+    }
+    fs.mkdirSync(schemasPath)
+    fs.writeFileSync(`${schemasPath}/${name}.ts`, getModuleSchema(name))
+
     const modulesPath = `${dirRoot}/modules/${name}`;
     fs.mkdirSync(modulesPath)
-
     fs.writeFileSync(`${modulesPath}/adapter.ts`, getModuleAdapter(name))
     fs.writeFileSync(`${modulesPath}/controller.ts`, getModuleController(name))
     fs.writeFileSync(`${modulesPath}/module.ts`, getModule(name))
     fs.writeFileSync(`${modulesPath}/repository.ts`, getModuleRepository(name))
-    fs.writeFileSync(`${modulesPath}/schema.ts`, getModuleSchema(name))
     fs.writeFileSync(`${modulesPath}/swagger.ts`, getModuleSwagger(name))
     fs.writeFileSync(`${modulesPath}/types.ts`, getModuleType(name))
 
+
     return `${name}`
   } catch (error) {
     console.log('error', error)
@@ -164,6 +169,15 @@ const createMongoCrud = async (name) => {
     fs.writeFileSync(`${useCasesPathTest}/${name}-list.spec.ts`, getCoreUsecaseListMongoTest(name))
     fs.writeFileSync(`${useCasesPathTest}/${name}-getByID.spec.ts`, getCoreUsecaseGetByIDMongoTest(name))
 
+    const schemasPath = `${__dirname}/scafold/mongo/schemas`;
+    
+    if (fs.existsSync(schemasPath)) {
+      fs.rmSync(schemasPath, { recursive: true });
+    }
+
+    fs.mkdirSync(schemasPath)
+    fs.writeFileSync(`${schemasPath}/${name}.ts`, getModuleSchemaMongo(name))
+
     const modulesPath = `${dirRoot}/modules/${name}`;
     fs.mkdirSync(modulesPath)
 
@@ -280,11 +294,30 @@ export async function cli(args) {
         const destination = `${dest}/src/${folder}`.replace('\n', '');
 
         fse.copySync(source, destination, { overwrite: true });
+        
+        const destPathSchema = `${dest}/src/infra/database/${userInput.type === 'postgres:crud' ? 'postgres' : 'mongo'}/schemas`;
+        
+        console.log('destPathSchema', destPathSchema)
+        
+        const pathSchema = path.resolve(src, '../schemas');
+
+        console.log('pathSchema', pathSchema)
+        fse.copySync(pathSchema, destPathSchema, { overwrite: true });
 
         if (fs.existsSync(source)) {
           fs.rmSync(source, { recursive: true });
         }
       }
+
+      console.log(bold(green('===done===')))
+
+      if (userInput.type === 'postgres:crud') {
+        console.log(red('!!!!!!!!!!REAMDE!!!!!!!'), green(bold('https://github.com/mikemajesty/nestjs-microservice-api-cli/blob/main/potgres.README.md')))
+      }
+
+      if (userInput.type === 'mongo:crud') {
+        console.log(red('!!!!!!!!!!REAMDE!!!!!!!'), green(bold('https://github.com/mikemajesty/nestjs-microservice-api-cli/blob/main/mongo.README.md')))
+      }
     });
 
   } catch (error) {

package/src/scafold/mongo/schemas/bird.ts

@@ -0,0 +1,35 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { Document } from 'mongoose';
+import * as paginate from 'mongoose-paginate-v2';
+
+import { BirdEntity } from '@/core/bird/entity/bird';
+
+export type BirdDocument = Document & BirdEntity;
+
+@Schema({
+  collection: 'birds',
+  autoIndex: true,
+  timestamps: true
+})
+export class Bird {
+  @Prop({ type: String })
+  _id: string;
+
+  @Prop({ index: true, min: 1, max: 200, required: true, type: String })
+  name: string;
+
+  @Prop({ type: Date, default: null })
+  deletedAt: Date;
+}
+
+const BirdSchema = SchemaFactory.createForClass(Bird);
+
+BirdSchema.index({ name: 1 });
+
+BirdSchema.plugin(paginate);
+
+BirdSchema.virtual('id').get(function () {
+  return this._id;
+});
+
+export { BirdSchema };

package/src/scafold/postgres/schemas/dog.ts

@@ -0,0 +1,13 @@
+import { Column, DataType, Model, Table } from 'sequelize-typescript';
+
+@Table({ timestamps: true, tableName: 'dogs' })
+export class DogSchema extends Model {
+  @Column({ primaryKey: true, type: DataType.UUID })
+  id: string;
+
+  @Column(DataType.STRING)
+  name: string;
+
+  @Column({ allowNull: true, type: DataType.DATE })
+  deletedAt?: Date;
+}

package/src/templates/mongo/modules/repository.js

@@ -9,8 +9,9 @@ import { PaginateModel } from 'mongoose';
 
 import { I${capitalizeFirstLetter(name)}Repository } from '@/core/${name}/repository/${name}';
 import { MongoRepository } from '@/infra/repository';
-import { ValidateDatabaseSort } from '@/utils/decorators/validate-allowed-sort-order.decorator';
-import { SearchTypeEnum, ValidateMongoFilter } from '@/utils/decorators/validate-mongo-filter.decorator';
+import { ValidateMongooseFilter } from '@/utils/decorators/database/mongo/validate-mongoose-filter.decorator';
+import { ValidateDatabaseSortAllowed } from '@/utils/decorators/database/validate-database-sort-allowed.decorator';
+import { SearchTypeEnum } from '@/utils/decorators/types';
 
 import { ${capitalizeFirstLetter(name)}, ${capitalizeFirstLetter(name)}Document } from './schema';
 import { ${capitalizeFirstLetter(name)}ListInput, ${capitalizeFirstLetter(name)}ListOutput } from './types';
@@ -21,8 +22,8 @@ export class ${capitalizeFirstLetter(name)}Repository extends MongoRepository<${
     super(entity);
   }
 
-  @ValidateMongoFilter([{ name: 'name', type: SearchTypeEnum.like }])
-  @ValidateDatabaseSort(['name', 'createdAt'])
+  @ValidateMongooseFilter([{ name: 'name', type: SearchTypeEnum.like }])
+  @ValidateDatabaseSortAllowed(['name', 'createdAt'])
   async paginate({ limit, page, sort, search }: ${capitalizeFirstLetter(name)}ListInput): Promise<${capitalizeFirstLetter(name)}ListOutput> {
     const ${name}s = await this.entity.paginate(search, { page, limit, sort });
 

package/src/templates/mongo/{modules → schemas}/schema.js

@@ -1,4 +1,6 @@
 
+const pluralize = require('pluralize')
+
 function capitalizeFirstLetter(string) {
   return string.charAt(0).toUpperCase() + string.slice(1);
 }
@@ -12,7 +14,7 @@ import { ${capitalizeFirstLetter(name)}Entity } from '@/core/${name}/entity/${na
 export type ${capitalizeFirstLetter(name)}Document = Document & ${capitalizeFirstLetter(name)}Entity;
 
 @Schema({
-  collection: '${name}-collection',
+  collection: '${pluralize(name)}',
   autoIndex: true,
   timestamps: true
 })

package/src/templates/postgres/core/repository/repository.js

@@ -5,11 +5,12 @@ function capitalizeFirstLetter(string) {
 
 const getCoreRepository = (name) => `import { IRepository } from '@/infra/repository';
 import { ${capitalizeFirstLetter(name)}ListInput, ${capitalizeFirstLetter(name)}ListOutput } from '@/modules/${name}/types';
+import { DatabaseOptionsType } from '@/utils/database/sequelize';
 
 import { ${capitalizeFirstLetter(name)}Entity } from '../entity/${name}';
 
 export abstract class I${capitalizeFirstLetter(name)}Repository extends IRepository<${capitalizeFirstLetter(name)}Entity> {
-  abstract paginate(input: ${capitalizeFirstLetter(name)}ListInput): Promise<${capitalizeFirstLetter(name)}ListOutput>;
+  abstract paginate<TOptions = DatabaseOptionsType>(input: ${capitalizeFirstLetter(name)}ListInput, options?: TOptions): Promise<${capitalizeFirstLetter(name)}ListOutput>;
 }
 `
 

package/src/templates/postgres/modules/module.js

@@ -4,8 +4,7 @@ function capitalizeFirstLetter(string) {
 }
 
 const getModule = (name) => `import { MiddlewareConsumer, Module, NestModule } from '@nestjs/common';
-import { getRepositoryToken, TypeOrmModule } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
+import { ModelCtor, Sequelize } from 'sequelize-typescript';
 
 import { ${capitalizeFirstLetter(name)}Entity } from '@/core/${name}/entity/${name}';
 import { I${capitalizeFirstLetter(name)}Repository } from '@/core/${name}/repository/${name}';
@@ -15,7 +14,10 @@ import { ${capitalizeFirstLetter(name)}GetByIdUsecase } from '@/core/${name}/use
 import { ${capitalizeFirstLetter(name)}ListUsecase } from '@/core/${name}/use-cases/${name}-list';
 import { ${capitalizeFirstLetter(name)}UpdateUsecase } from '@/core/${name}/use-cases/${name}-update';
 import { RedisCacheModule } from '@/infra/cache/redis';
-import { LoggerModule } from '@/infra/logger';
+import { IDataBaseAdapter } from '@/infra/database';
+import { PostgresDatabaseModule } from '@/infra/database/postgres/module';
+import { ${capitalizeFirstLetter(name)}Schema } from '@/infra/database/postgres/schemas/${name}';
+import { ILoggerAdapter, LoggerModule } from '@/infra/logger';
 import { TokenModule } from '@/libs/auth';
 import { IsLoggedMiddleware } from '@/utils/middlewares/is-logged.middleware';
 
@@ -28,18 +30,18 @@ import {
 } from './adapter';
 import { ${capitalizeFirstLetter(name)}Controller } from './controller';
 import { ${capitalizeFirstLetter(name)}Repository } from './repository';
-import { ${capitalizeFirstLetter(name)}Schema } from './schema';
 
 @Module({
-  imports: [TokenModule, LoggerModule, TypeOrmModule.forFeature([${capitalizeFirstLetter(name)}Schema]), RedisCacheModule],
+  imports: [TokenModule, LoggerModule, RedisCacheModule, PostgresDatabaseModule],
   controllers: [${capitalizeFirstLetter(name)}Controller],
   providers: [
     {
       provide: I${capitalizeFirstLetter(name)}Repository,
-      useFactory: (repository: Repository<${capitalizeFirstLetter(name)}Schema & ${capitalizeFirstLetter(name)}Entity>) => {
-        return new ${capitalizeFirstLetter(name)}Repository(repository);
+      useFactory: (database: IDataBaseAdapter) => {
+        const repository = database.getDatabase<Sequelize>().model(${capitalizeFirstLetter(name)}Schema);
+        return new ${capitalizeFirstLetter(name)}Repository(repository as ModelCtor<${capitalizeFirstLetter(name)}Schema> & ${capitalizeFirstLetter(name)}Entity);
       },
-      inject: [getRepositoryToken(${capitalizeFirstLetter(name)}Schema)]
+      inject: [IDataBaseAdapter]
     },
     {
       provide: I${capitalizeFirstLetter(name)}CreateAdapter,
@@ -49,7 +51,7 @@ import { ${capitalizeFirstLetter(name)}Schema } from './schema';
     {
       provide: I${capitalizeFirstLetter(name)}UpdateAdapter,
       useFactory: (repository: I${capitalizeFirstLetter(name)}Repository) => new ${capitalizeFirstLetter(name)}UpdateUsecase(repository),
-      inject: [I${capitalizeFirstLetter(name)}Repository]
+      inject: [ILoggerAdapter, I${capitalizeFirstLetter(name)}Repository]
     },
     {
       provide: I${capitalizeFirstLetter(name)}GetByIDAdapter,

package/src/templates/postgres/modules/repository.js

@@ -4,40 +4,38 @@ function capitalizeFirstLetter(string) {
 }
 
 const getModuleRepository = (name) => `import { Injectable } from '@nestjs/common';
-import { Repository } from 'typeorm';
+import { ModelCtor } from 'sequelize-typescript';
 
 import { ${capitalizeFirstLetter(name)}Entity } from '@/core/${name}/entity/${name}';
 import { I${capitalizeFirstLetter(name)}Repository } from '@/core/${name}/repository/${name}';
-import { PostgresRepository } from '@/infra/repository/postgres/repository';
-import { ValidateDatabaseSort } from '@/utils/decorators/validate-allowed-sort-order.decorator';
-import { SearchTypeEnum, ValidatePostgresFilter } from '@/utils/decorators/validate-postgres-filter.decorator';
-import { calucaleSkip } from '@/utils/pagination';
+import { ${capitalizeFirstLetter(name)}Schema } from '@/infra/database/postgres/schemas/${name}';
+import { SequelizeRepository } from '@/infra/repository/postgres/repository';
+import { ${capitalizeFirstLetter(name)}ListInput, ${capitalizeFirstLetter(name)}ListOutput } from '@/modules/${name}/types';
+import { DatabaseOptionsSchema, DatabaseOptionsType } from '@/utils/database/sequelize';
+import { ConvertPaginateInputToSequelizeFilter } from '@/utils/decorators/database/postgres/convert-paginate-input-to-sequelize-filter.decorator';
+import { ValidateDatabaseSortAllowed } from '@/utils/decorators/database/validate-database-sort-allowed.decorator';
+import { SearchTypeEnum } from '@/utils/decorators/types';
 
-import { ${capitalizeFirstLetter(name)}Schema } from './schema';
-import { ${capitalizeFirstLetter(name)}ListInput, ${capitalizeFirstLetter(name)}ListOutput } from './types';
+type Model = ModelCtor<${capitalizeFirstLetter(name)}Schema> & ${capitalizeFirstLetter(name)}Entity;
 
 @Injectable()
-export class ${capitalizeFirstLetter(name)}Repository
-  extends PostgresRepository<${capitalizeFirstLetter(name)}Schema & ${capitalizeFirstLetter(name)}Entity>
-  implements Omit<I${capitalizeFirstLetter(name)}Repository, 'updateMany' | 'seed'>
-{
-  constructor(readonly repository: Repository<${capitalizeFirstLetter(name)}Schema & ${capitalizeFirstLetter(name)}Entity>) {
+export class ${capitalizeFirstLetter(name)}Repository extends SequelizeRepository<Model> implements I${capitalizeFirstLetter(name)}Repository {
+  constructor(readonly repository: Model) {
     super(repository);
   }
 
-  @ValidatePostgresFilter([{ name: 'name', type: SearchTypeEnum.like }])
-  @ValidateDatabaseSort(['createdAt', 'name'])
-  async paginate(input: ${capitalizeFirstLetter(name)}ListInput): Promise<${capitalizeFirstLetter(name)}ListOutput> {
-    const skip = calucaleSkip(input);
+  @ValidateDatabaseSortAllowed(['createdAt', 'name', 'breed', 'age'])
+  @ConvertPaginateInputToSequelizeFilter([
+    { name: 'name', type: SearchTypeEnum.like },
+    { name: 'breed', type: SearchTypeEnum.like },
+    { name: 'age', type: SearchTypeEnum.equal }
+  ])
+  async paginate(input: ${capitalizeFirstLetter(name)}ListInput, options: DatabaseOptionsType): Promise<${capitalizeFirstLetter(name)}ListOutput> {
+    const { schema } = DatabaseOptionsSchema.parse(options);
 
-    const [docs, total] = await this.repository.findAndCount({
-      take: input.limit,
-      skip,
-      order: input.sort,
-      where: input.search
-    });
+    const list = await this.repository.schema(schema).findAndCountAll(input);
 
-    return { docs, total, page: input.page, limit: input.limit };
+    return { docs: list.rows, limit: input.limit, page: input.page, total: list.count };
   }
 }
 `

package/src/templates/postgres/schemas/schema.js

@@ -0,0 +1,25 @@
+
+const pluralize = require('pluralize')
+
+function capitalizeFirstLetter(string) {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}
+
+const getModuleSchema = (name) => `import { Column, DataType, Model, Table } from 'sequelize-typescript';
+
+@Table({ timestamps: true, tableName: '${pluralize(name)}' })
+export class ${capitalizeFirstLetter(name)}Schema extends Model {
+  @Column({ primaryKey: true, type: DataType.UUID })
+  id: string;
+
+  @Column(DataType.STRING)
+  name: string;
+
+  @Column({ allowNull: true, type: DataType.DATE })
+  deletedAt?: Date;
+}
+`
+
+module.exports = {
+  getModuleSchema
+}

package/README.md

@@ -1,92 +0,0 @@
-# Nestjs CLI monorepo
-
-### [Monorepo](https://github.com/mikemajesty/nestjs-monorepo) CLI
-
-### install
-  - 
-    ```
-    $ npm i -g @mikemajesty/microservice-crud
-    ```
-  ---
-### Usage
-  - 1 - type cli command
-    ```bash
-    $ microservice-crud
-    ```
-  - 2 select template type [API, MODULE, TEST]
-  <br>[<img alt="mikemajesty" src="https://raw.githubusercontent.com/mikemajesty/microservice-crud/master/img/select-template.png">](https://github.com/mikemajesty)
-
-  
-  
-  
-  - 3 - type template name
-        <br>[<img alt="mikemajesty" src="https://raw.githubusercontent.com/mikemajesty/microservice-crud/master/img/template-name.png">](https://github.com/mikemajesty)
- 
- 
- 
- - 4 - Select path template
-    ```bash
-    # API must be inside [apps] folder - nestjs-monorepo/apps/
-    # MODULE must be inside [api] folder - nestjs-monorepo/apps/auth-api/src/modules/
-    # TEST must be inside [*] folder - nestjs-monorepo/*
-    ```
-  
----
-### API skeleton
-```
-.
-└── main-api
-    ├── Dockerfile
-    ├── jest.config.js
-    ├── package.json
-    ├── src
-    │   ├── main.ts
-    │   └── modules
-    │       ├── health
-    │       │   ├── adapter.ts
-    │       │   ├── controller.ts
-    │       │   ├── module.ts
-    │       │   ├── service.ts
-    │       │   ├── swagger.ts
-    │       │   └── __tests__
-    │       │       ├── controller.e2e.spec.ts
-    │       │       ├── module.spec.ts
-    │       │       └── service.spec.ts
-    │       └── module.ts
-    ├── tests
-    │   └── initialization.js
-    ├── tsconfig.build.json
-    └── tsconfig.json
-```
-
-### MODULE skeleton
-```
-.
-└── module
-    ├── adapter.ts
-    ├── controller.ts
-    ├── module.ts
-    ├── service.ts
-    ├── swagger.ts
-    └── __tests__
-        ├── controller.e2e.spec.ts
-        ├── module.spec.ts
-        └── service.spec.ts
-```
-### TEST skeleton
-```
-.
-└── __tests__
-    ├── controller.e2e.spec.ts
-    ├── module.spec.ts
-    └── service.spec.ts
-```
----
-The following is a list of all the people that have contributed Nestjs monorepo CLI. Thanks for your contributions!
-
-[<img alt="mikemajesty" src="https://avatars1.githubusercontent.com/u/11630212?s=460&v=4&s=117" width="117">](https://github.com/mikemajesty)
-
-## License
-
-It is available under the MIT license.
-[License](https://opensource.org/licenses/mit-license.php)

package/src/templates/postgres/modules/schema.js

@@ -1,32 +0,0 @@
-
-function capitalizeFirstLetter(string) {
-  return string.charAt(0).toUpperCase() + string.slice(1);
-}
-
-const getModuleSchema = (name) => `import { Max, Min } from 'class-validator';
-import { BaseEntity, Column, CreateDateColumn, DeleteDateColumn, Entity, UpdateDateColumn } from 'typeorm';
-
-@Entity({ name: '${name}_collection' })
-export class ${capitalizeFirstLetter(name)}Schema extends BaseEntity {
-  @Column({ type: 'uuid', primary: true })
-  id: string;
-
-  @Column('text')
-  @Min(1)
-  @Max(200)
-  name: string;
-
-  @CreateDateColumn()
-  createdAt: Date;
-
-  @UpdateDateColumn()
-  updatedAt: Date;
-
-  @DeleteDateColumn({ nullable: true })
-  deletedAt: Date;
-}
-`
-
-module.exports = {
-  getModuleSchema
-}