exaby73 / luthor Goto Github PK

void main() {
  final v = l.list(validators: [l.number().required()]);
  print(v.validateValue([1, 2, 3, null]));
}

final nestedSchema = nestedSchema = l.schema({
  'address': l.schema({
    'city': l.string().required(),
    'state': l.string().required(),
  }).required(),
});

nestedSchema.validateSchema({}); // throws

class AuthDto {
  final String email;
  final String password;

  const AuthDto({required this.email, required this.password});

  factory AuthDto.fromJson(Map<String, dynamic> json) {
    return AuthDto(email: json['email'] as String, password: json['password'] as String);
  }
}

final v = l.schema({'email': l.string().email().required(), 'password': l.string().min(8).required()});
final rawJson = {'email': '[email protected]', 'password': 'password'};
final result = v.validateSchema(rawJson);

switch (result) {
  case SchemaValidationSuccess(data: final validatedJson):
    final dto = AuthDto.fromJson(validatedJson);
    // Do something with the dto
  case SchemaValidationError(data: _, errors: final errors):
    // Do something with the errors
}

final v = l.schema({'email': l.string().email().required(), 'password': l.string().min(8).required()});
final rawJson = {'email': '[email protected]', 'password': 'password'};
final result = v.validateSchema(rawJson, fromJson: AuthDto.fromJson);

switch (result) {
  case SchemaValidationSuccess(data: final dto):
    // Do something with the dto. dto is of type `AuthDto`
  case SchemaValidationError(data: _, errors: final errors):
    // Do something with the errors
}

@luthor
@freezed
class TestEntity with _$TestEntity {
  @JsonSerializable(fieldRename: FieldRename.snake)
  const factory TestEntity({
    required String firstTestField,
    @JsonKey(name: "second") required String secondTestField,
  }) = _TestEntity;

  static SchemaValidationResult<TestEntity> validate(Map<String, dynamic> json) => _$validate(json);

  factory TestEntity.fromJson(Map<String, dynamic> json) => _$TestEntityFromJson(json);
}

Validator $TestEntitySchema = l.schema({
  'firstTestField': l.string().required(),
  'secondTestField': l.string().required(),
});

Validator $TestEntitySchema = l.schema({
  'first_test_field': l.string().required(),
  'second': l.string().required(),
});

final result = l.string().validate('hello');

result.when(
  success: (String value) => print(value),
  error: (String message) => throw Exception(message),
)

final v = l.string().email().required();
final r = v.validate(1);
print(r.whenOrNull(error: (e) => e)); // "value is not a string"

final s = l.schema({
  email: l.string.email().required(),
  password: l.string.min(8).required(),
});
final r = v.validate({'email': 1});
print(r.whenOrNull(error: (e) => e)); // "email is not a string"

final v = l.string().email().required();
final r = v.validate(1);
print(r.whenOrNull(error: (e) => e)); // ["value is not a string", "value is not a valid email"]

final s = l.schema({
  email: l.string.email().required(),
  password: l.string.min(8).required(),
});
final r = v.validate({'email': 1});
print(r.whenOrNull(error: (e) => e)); 
/* 
{
  "email": ["email is not a string", "email is not a valid email"],
  "password: ["password is not a string", "password must be at least 8 characters long", "password is required"]
}
*/