class-validator#isUUID TypeScript Examples

get = wrapHandler(async (event) => {
  await connectToDatabase();
  const id = event.pathParameters?.vulnerabilityId;
  if (!isUUID(id)) {
    return NotFound;
  }

  // Need to use QueryBuilder because typeorm doesn't support nested
  // relations filtering -- see https://github.com/typeorm/typeorm/issues/3890
  const search = new VulnerabilitySearch();
  search.filters = new VulnerabilityFilters();
  search.filters.id = id;
  const [result] = await search.getResults(event);

  return {
    statusCode: result.length ? 200 : 404,
    body: result.length ? JSON.stringify(result[0]) : ''
  };
})

@Expose()
  @IsUUID()
  public executorId: string;

@IsUUID()
  @IsOptional()
  organization?: string;

@Expose()
  @IsUUID()
  public postId: string;

@IsUUID()
    public entityId!: string;

@Expose()
  @IsOptional()
  @IsUUID()
  public imageId?: string;

@Column({
    nullable: true,
  })
  @IsOptional()
  @IsUUID()
  uuid: string;

update = wrapHandler(async (event) => {
  const id = event.pathParameters?.organizationId;

  if (!id || !isUUID(id)) {
    return NotFound;
  }

  if (!isOrgAdmin(event, id)) return Unauthorized;
  const body = await validateBody<
    NewOrganization | NewOrganizationNonGlobalAdmins
  >(
    isGlobalWriteAdmin(event)
      ? NewOrganization
      : NewOrganizationNonGlobalAdmins,
    event.body
  );

  await connectToDatabase();
  const org = await Organization.findOne(
    {
      id
    },
    {
      relations: ['userRoles', 'granularScans']
    }
  );
  if (org) {
    if ('tags' in body) {
      body.tags = await findOrCreateTags(body.tags);
    }

    Organization.merge(org, { ...body, parent: undefined });
    await Organization.save(org);
    return {
      statusCode: 200,
      body: JSON.stringify(org)
    };
  }
  return NotFound;
})

@IsUUID()
  id!: Uuid;

@IsUUID()
  @IsOptional()
  tag?: string;

@IsUUID()
    relationship_pair_id?: string;

@IsUUID()
    public id!: string;

@IsUUID()
    container_id?: string;

@IsUUID()
    public id!: string;

@IsOptional()
    @IsUUID()
    id?: string;

@IsUUID(undefined, { each: true })
  roles!: Set<Uuid>;

static listAll = async (req: Request, res: Response) => {
    console.log(util.inspect(req.query.knowledgeVector, false, null, true /* enable colors */));

    if (isEmpty(req.query.knowledgeVector)) {
      res
        .status(400)
        .send(
          'Must send an array of knowledge vectors as query param. An empty knowledge vector would be { processes: [{ id : "validUUIDv4" , clock : 0 } ]}'
        );
      return;
    }

    // Thorough JSON validation using JSON Schema, TypedJSON and class-validator
    const ajv = new Ajv();
    const valid = ajv.validate(kvSchema, req.query.knowledgeVector);
    if (!valid) {
      console.log(ajv.errors);
      res.status(400).send(ajv.errors);
      return;
    }

    let incomingKV: KnowledgeVector;
    try {
      incomingKV = new TypedJSON(KnowledgeVector).parse(req.query.knowledgeVector);
    } catch (error) {
      res.status(400).send("JSON schema error");
      return;
    }

    console.log(util.inspect(incomingKV, false, null, true /* enable colors */));

    const errors = await validate(incomingKV);
    if (errors.length > 0) {
      res.status(400).send(errors);
      return;
    }

    //console.log(util.inspect(incomingKV, false, null, true /* enable colors */));

    let returnRevRecord = new OCKRevisionRecord();
    returnRevRecord.entities = [];

    // Case 1 : iOS device is syncing for the first time, it has no knowledge of the servers clock
    if (isEmpty(incomingKV.processes.find((process) => process.id === uuid))) {
      // store incoming clock locally
      let clockRepo = getMongoRepository(Process);

      for (const process of incomingKV.processes) {
        assert(isUUID(process.id));
        const processExists = await clockRepo.findOne({ id: process.id });
        if (isEmpty(processExists)) {
          assert(isNotEmpty(process.id));
          await clockRepo.save(process);
        }
      }

      // send all outcomes and tasks
      const taskRepository = getMongoRepository(OCKTask);
      const tasks = await taskRepository.find({});

      const outcomeRepository = getMongoRepository(OCKOutcome);
      const outcomes = await outcomeRepository.find({});

      tasks.map((entity) => {
        delete entity.kv;
        returnRevRecord.entities.push({ type: "task", object: entity });
      });
      outcomes.map((entity) => {
        delete entity.kv;
        returnRevRecord.entities.push({ type: "outcome", object: entity });
      });

      // set kv for revisionRecord
      returnRevRecord.knowledgeVector = await getLatestKnowledgeVector();

      //console.log(util.inspect(returnRevRecord, false, null, true /* enable colors */));
      res.status(201).send(returnRevRecord);
      return;
    }

    // Case 2 : It has synced before but its clock might be older than local, send entities newer than clock
    const clock = incomingKV.processes.find((process) => process.id === uuid).clock;
    assert(!isEmpty(clock), "clock cannot be undefined at this point");

    const taskRepository = getMongoRepository(OCKTask);
    const tasks = await taskRepository.find({
      $and: [{ "kv.processes.clock": { $gt: clock } }, { "kv.processes.id": { $eq: uuid } }],
    });

    const outcomeRepository = getMongoRepository(OCKOutcome);
    const outcomes = await outcomeRepository.find({
      $and: [{ "kv.processes.clock": { $gt: clock } }, { "kv.processes.id": { $eq: uuid } }],
    });

    tasks.map((entity) => {
      delete entity.kv;
      returnRevRecord.entities.push({ type: "task", object: entity });
    });
    outcomes.map((entity) => {
      delete entity.kv;
      returnRevRecord.entities.push({ type: "outcome", object: entity });
    });

    // set kv for revisionRecord
    returnRevRecord.knowledgeVector = await getLatestKnowledgeVector();

    //console.log(util.inspect(returnRevRecord, false, null, true /* enable colors */));
    res.status(201).send(returnRevRecord);
  };