标签: nestjs

import {Entity, PrimaryGeneratedColumn, Column} from "typeorm";

@Entity()
export class User {

@PrimaryGeneratedColumn()
id: number;

@Column()
name: string;

@Column()
password: string;
}

我在这里不需要密码，因为我想返回客户端：

const user = await User.find({where:{name:"test"}})

当我想修改密码时我需要密码：

const user = await User.findOne({where:{name:"test"}})
user.password="password";
await user.save()

有 Find、FindAndCount 甚至 FindOne 方法的解决方案吗？

我应该怎么做？

我目前正在从事课程服务工作。用户可以注册和取消注册课程。整个系统采用微服务架构构建，这意味着用户由另一个服务管理。因此，课程服务的数据模型如下所示：

model course {
  id                Int                @id @default(autoincrement())
  orderNumber       Int                @unique
  courseNumber      String             @unique @db.VarChar(255)
  courseName        String             @db.VarChar(255)
  courseOfficer     String             @db.VarChar(255)
  degree            String             @db.VarChar(255)
  ectCount          Int
  faculty           String             @db.VarChar(255)
  isWinter          Boolean            @default(false)
  isSummer          Boolean            @default(false)
  courseDescription String?            @db.VarChar(255)
  enrollmentCourse  enrollmentCourse[]
}

model enrollmentCourse {
  id       Int    @id @default(autoincrement())
  userId   String @db.VarChar(1024)
  course   course @relation(fields: [courseId], references: [id])
  courseId Int
}

我想查找某个用户注册的所有课程。我写了2个查询。我们浏览一下课程并尝试筛选注册课程。然而，这个不起作用，我拿回了所有课程。而第二个则检查注册课程，然后使用映射返回课程。这是可行的，但我不喜欢这个解决方案，如果它有效的话，我更喜欢第一个查询：（我已经使用本指南来编写第一个查询：here）

const result1 = await this.prisma.course.findMany({
  where: { enrollmentCourse: { every: { userId: user.id } } },
  include: …

我试图遵循这个线程，但我不断收到错误。

变换响应.interceptor.ts：

import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
import { Observable } from 'rxjs';
import { map } from 'rxjs/operators';
import { ApiResponseInterface } from '@walletxp/shared-interfaces';

@Injectable()
export class TransformResponseInterceptor<T>
  implements NestInterceptor<T, ApiResponseInterface<Record<string, unknown>>>
{
  intercept(context: ExecutionContext, next: CallHandler): Observable<ApiResponseInterface<Record<string, unknown>>> {
    return next.handle().pipe(map((data) => ({ success: true, data })));
  }
}

对于它的测试，transform-response.interceptor.spec.ts：

import { TransformResponseInterceptor } from './transform-response.interceptor';
const interceptor = new TransformResponseInterceptor();

const executionContext: any = {
  switchToHttp: jest.fn().mockReturnThis(),
  getRequest: jest.fn().mockReturnThis(),
}; …

我正在构建一个 NestJs 应用程序，具有调度和配置功能。我希望能够使用环境变量配置我的 Cron，但它似乎不起作用。

应用程序模块.ts：

@Module({
  imports: [
    ConfigModule.forRoot(),
    ScheduleModule.forRoot(),
    SchedulingModule,
    ...
  ],
})
export class AppModule {}

Schedule.service.ts（来自我的SchedulingModule）：

@Cron(process.env.CRON_VALUE)
scheduledJob() {
  this.logger.log('Scheduled : Job');
  ...
}

.env：

...
CRON_VALUE=0 4 * * *
...

显然，目前检查该值时它是空的。我收到以下错误：

(node:55016) UnhandledPromiseRejectionWarning: TypeError: Cannot read property '_isAMomentObject' of undefined
    at new CronTime (/Users/antoinegrenard/Documents/Projet/b4finance/service-scheduling/node_modules/cron/lib/cron.js:42:50)
    at new CronJob (/Users/antoinegrenard/Documents/Projet/b4finance/service-scheduling/node_modules/cron/lib/cron.js:527:19)
    at /Users/antoinegrenard/Documents/Projet/b4finance/service-scheduling/node_modules/@nestjs/schedule/dist/scheduler.orchestrator.js:56:29 
    ...

我有一个DatabaseModule导入 TypeORM 并启动数据库连接（参见database.module.ts）。我在 CRUD 模块上使用该模块，并且在以经典方式注册模块时一切正常。

但是，当我延迟加载同一模块时，它会中断并出现“无法解析连接”错误。

“错误 [ExceptionsHandler] Nest 无法解析 ProductRepository 的依赖关系（？）。请确保索引 [0] 处的参数 Connection 在 TypeOrmModule 上下文中可用。”

（我正在编写无服务器函数，因此尝试延迟加载。）

// product.module.ts: the module I lazy-load
@Module({
imports: [
  DatabaseModule.register({
    entities: [Product],
  }),
],

// database.module.ts: the module that creates the db connections
export interface DatabaseOptions {
  entities: any[];
}

@Module({})
export class DatabaseModule {
  static register(options: DatabaseOptions): DynamicModule {
    return {
      module: DatabaseModule,
      imports: [
        TypeOrmModule.forRoot({
          type: 'mysql',
          host: '0.0.0.0',
          port: 3306,
          username: …

我设置了这条路线：

  @Get('/name/like')
  findByLikeName(@Query() query: { supplierID: string; name: string }) {
    return this.supplierProductService.findByLikeName(query);
  }

它利用底层服务中的查询参数：

  async findByLikeName({
    supplierID,
    name,
  }: {
    supplierID: string;
    name: string;
  }): Promise<SupplierProduct[]> {
    return await this.supplierProductRepository.findAll({
      where: {
        name: {
          [Op.like]: `%${name}%`,
        },
        supplierID: supplierID,
      },
    });
  }

但是，假设我想将 sellerID 移动到 /:supplierID 路由参数中，同时在查询对象中维护名称（以及潜在的其他查询参数），我将如何实现这一点？

我正在尝试将 Nestjs 应用程序部署到 google 应用引擎，但出现sh: 1: exec: nest: not found错误

我的包.json

    "main": "dist/main.js",
    "scripts": {
        "prebuild": "rimraf dist",
        "build": "nest build",
        "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
        "start": "nest start",
        "start:dev": "nest start --watch",
        "start:debug": "nest start --debug --watch",
        "start:prod": "node dist/main",
        "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
        "test": "jest",
        "test:watch": "jest --watch",
        "test:cov": "jest --coverage",
        "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
        "test:e2e": "jest --config ./test/jest-e2e.json",
        "gcp-build": "npm run build",
        "ae:deploy": "gcloud app deploy --quiet",
        "ae:browse": "gcloud app …

当我在 prop 装饰器中使用嵌套的对象数组时：

@Schema()
export class Child {
  @Prop()
  name: string;
}
    
@Schema()
export class Parent {
  @Prop({type: [Child], _id: false}) // don't need `_id` for nested objects
  children: Child[];
}

export const ParentSchema = SchemaFactory.createForClass(Parent);

我收到错误：

TypeError: Invalid schema configuration: `Child` is not a valid type within the array `children`.

如果我需要使用@Prop({_id: false})（以保持嵌套模式独立），我该如何解决这个问题？

如果我们更改 prop 装饰器，@Prop([Child])它就可以工作，但是我们需要禁用_id嵌套对象：

@Schema({_id: false})
export class Child {
  @Prop()
  name: string;
}

@Schema()
export class Parent {
  @Prop([Child])
  children: Child[]; …

我的控制器中有请求，这@Param是 MongoId 的字符串版本。如果我使用无效的字符串格式（不匹配 MongoId 格式）调用此请求，则该请求将继续执行，直到 MongoDB 调用抛出内部服务器错误。

我如何验证例如"aaa"“ANWPINREBAFSOFASD”未经过验证并在我的请求中尽早停止

当前控制器端点：

@Get(':id')
  @ApiOperation({ summary: 'Get nice information' })
  findOne(
    @Param('id') id: string) {
    return this.niceService.findOne(id);
  }

该服务称为：

async findOne(id: string): Promise<NiceDocument> {

    const niceResult: NiceDocument = await this.NiceSchema.findById(id)

    if (!niceResult) {
      throw new NotFoundException()
    }
    return table
  }

我将类验证器与 NestJS 结合使用，并尝试使用以下布局验证对象数组：

[
    {gameId: 1, numbers: [1, 2, 3, 5, 6]},
    {gameId: 2, numbers: [5, 6, 3, 5, 8]}
]

我的解析器

createBet(@Args('createBetInput') createBetInput: CreateBetInput) {
    return this.betsService.create(createBetInput);
  }

我的 createBetInput DTO

import { InputType, Field, Int } from '@nestjs/graphql';
import { IsArray, IsNumber } from 'class-validator';

@InputType()
export class CreateBetInput {
  @IsNumber()
  @Field(() => Int)
  gameId: number;

  @Field(() => [Int])
  @IsArray()
  numbers: number[];
}

我尝试了一些解决方案，但没有成功，老实说，我不知道该怎么做。

如何修改 DTO 以获得必要的验证？