class-validator#isObject TypeScript Examples

@IsObject()
    ifc_settings: {
        format: string;
        data_level: string;
        component_level: boolean;
        log_detail: number;
        arc_tolerance: string;
        tube: boolean;
        cl: boolean;
        insu_translucency: number;
        obst_translucency: number;
        root: number;
        pipe: number;
        nozzle: number;
        structure: number;
        cable: number;
    } = {
        format: 'IFC2x3',
        data_level: 'GA',
        component_level: true,
        log_detail: 2,
        arc_tolerance: '10mm',
        tube: true,
        cl: false,
        insu_translucency: 25,
        obst_translucency: 50,
        root: 6,
        pipe: 6,
        nozzle: 6,
        structure: 6,
        cable: 6,
    };

@IsObject()
    @IsOptional()
    validation?: {
        regex: string;
        min: number;
        max: number;
    };

/**
   * Node HTTPS.createServer options: https://nodejs.org/api/https.html#https_https_createserver_options_requestlistener
   */
  @IsOptional()
  @IsObject()
  serverOpts?: ServerOptions;

@IsOptional()
  @IsObject()
  payload?: any = null;

@IsObject()
    challengeMethods: {
        challenges: Challenge[];
    } = {
        challenges: [new Challenge()],
    };

@IsObject()
    properties: object = {};

@IsObject()
    @IsOptional()
    metadata: object = {};

@IsObject()
    properties: object = {};

@IsObject()
    @IsOptional()
    validation?: {
        regex: string;
        min?: number;
        max?: number;
    };

/**
   * Node Net.listen options: https://nodejs.org/api/net.html#net_server_listen_options_callback
   * @default { port: 3000 }
   * @env SERVER_PORT (for `{port: SERVER_PORT}` only)
   */
  @IsOptional()
  @IsObject()
  listenOpts?: ListenOptions;

@IsObject()
    action_config?: object = {};

@IsObject()
    properties: object = {};

@IsObject()
    properties: object = {};

@IsOptional()
    @IsObject()
    parameters?: {[key: string]: any};

@IsOptional()
    @IsObject()
    public metadata: Record<string, any> = {};

@IsObject()
    public entityMeta!: any;

@IsObject()
  payload!: AlertPayload;

static validatePrimitive(schema: string, value: any) {
    let message: string
    let isValid: boolean = true

    switch (schema) {
      case did:
        isValid = matches(value, DID)
        message = `Parameter "${value}" is not a valid. Valid format: (${DID}).`
        break

      case didMethod:
        isValid = matches(value, DID_METHOD)
        message = `Parameter "${value}" is not a valid. Valid format: (${DID_METHOD}).`
        break

      case jwt:
        isValid = matches(value, JWT)
        message = `Parameter "${value}" is not a valid JWT. Valid format: (${JWT}).`
        break

      case array:
        isValid = isArray(value)
        message = `Parameter "${value}" should be an array.`
        break

      case number:
        isValid = isNumber(value)
        message = `Parameter "${value}" should be a number.`
        break

      case object:
        isValid = isObject(value)
        message = `Parameter "${value}" should be an object.`
        break

      case string:
        isValid = isString(value)
        message = `Parameter "${value}" should be a string.`
        break

      case boolean:
        isValid = isBoolean(value)
        message = `Parameter "${value}" should be a boolean.`
        break

      case isoString:
        isValid = isISO8601(value)
        message = `Parameter "${value}" is not a valid ISO 8601 date string.`
        break

      case confirmationCode:
        isValid = matches(value, COGNITO_CONFIRMATION_CODE)
        message = `Parameter "${value}" is not a valid confirmation code. Valid format: (${COGNITO_CONFIRMATION_CODE}).`
        break

      case password:
        isValid = matches(value, PASSWORD)
        message = `Parameter "${value}" is not a password. Valid format: (${PASSWORD}).`
        break
    }

    return { isValid, message }
  }

@IsOptional()
  @IsObject()
  credentialSchema?: unknown

@Field()
  @Type(() => WhispFileUpload)
  @IsObject()
  file: WhispFileUpload;

@Field(() => GraphQLJSONObject, { nullable: true })
  @IsObject()
  @IsOptional()
  data?: any;

@Field(() => [WhispAttachmentInput], { nullable: true })
  @IsObject({ each: true })
  @IsOptional({ each: true })
  @ValidateNested({ each: true })
  @Type(() => WhispAttachmentInput)
  attachments?: WhispAttachmentInput[];

@Field(() => [TagInputType], { nullable: true })
  @IsObject()
  @IsOptional()
  tags?: TagInputType[];

@IsDefined()
  @IsObject()
  credentialSubject: unknown

// legacy attributes - to be deleted after support is dropped
  @IsOptional()
  @IsObject()
  claim?: unknown

@IsDefined()
  @IsObject()
  proof: Proof

@IsOptional()
  @IsObject()
  credentialStatus?: unknown

@Field(() => GraphQLJSONObject, { nullable: true })
  @IsOptional()
  @IsObject()
  filter: Record<string, unknown>;

@IsOptional()
  @IsObject()
  refreshService?: unknown