zmodel_to_dart_runtime 1.0.3

Runtime contracts and helpers for Dart code generated from ZModel schema files

example/main.dart

// Example generated code for a schema with User, Post, and Role.
//
// This file is intentionally hand-written as a target shape for the builder.
// ignore_for_file: type=lint
// cspell: disable

import 'package:zmodel_to_dart_runtime/zmodel_to_dart_runtime.dart';

enum Role implements ZModelEnum {
  user('USER'),
  admin('ADMIN');

  const Role(this.value);

  @override
  final String value;
}

final class User extends ZModel {
  User();

  static final UserValidators validators = UserValidators();

  factory User.fromJson(Map<String, dynamic> json) {
    final user = User();
    user.fromJson(json);
    return user;
  }

  final ZModelIntField id = ZModelIntField('id');
  final ZModelDateTimeField createdAt = ZModelDateTimeField('createdAt');
  final ZModelStringField email = ZModelStringField('email');
  final ZModelStringField name = ZModelStringField('name');
  final ZModelEnumField<Role> role = ZModelEnumField<Role>('role', Role.values);
  final ZModelModelListField<Post> posts = ZModelModelListField<Post>(
    'posts',
    Post.fromJson,
  );

  @override
  String get modelName => 'User';

  late final Map<String, ZModelField> _fields = Map.unmodifiable({
    'id': id,
    'createdat': createdAt,
    'email': email,
    'name': name,
    'role': role,
    'posts': posts,
  });

  @override
  Map<String, ZModelField> get fields => _fields;
}

final class Post extends ZModel {
  Post();

  static final PostValidators validators = PostValidators();

  factory Post.fromJson(Map<String, dynamic> json) {
    final post = Post();
    post.fromJson(json);
    return post;
  }

  final ZModelIntField id = ZModelIntField('id');
  final ZModelDateTimeField createdAt = ZModelDateTimeField('createdAt');
  final ZModelDateTimeField updatedAt = ZModelDateTimeField('updatedAt');
  final ZModelBooleanField published = ZModelBooleanField('published');
  final ZModelStringField title = ZModelStringField('title');
  final ZModelModelField<User> author = ZModelModelField<User>(
    'author',
    User.fromJson,
  );
  final ZModelIntField authorId = ZModelIntField('authorId');

  @override
  String get modelName => 'Post';

  late final Map<String, ZModelField> _fields = Map.unmodifiable({
    'id': id,
    'createdat': createdAt,
    'updatedat': updatedAt,
    'published': published,
    'title': title,
    'author': author,
    'authorid': authorId,
  });

  @override
  Map<String, ZModelField> get fields => _fields;
}

final class UserValidators {
  UserValidators();

  late final ZFieldValidator<Object?> id = ZFieldValidator<Object?>(
    modelName: 'User',
    fieldName: 'id',
    isRequired: true,
    isUnique: true,
    rules: const [zRequiredRule, zIntRule],
  );

  late final ZFieldValidator<Object?> createdAt = ZFieldValidator<Object?>(
    modelName: 'User',
    fieldName: 'createdAt',
    isRequired: true,
    rules: const [zRequiredRule, zDateTimeRule],
  );

  late final ZFieldValidator<Object?> email = ZFieldValidator<Object?>(
    modelName: 'User',
    fieldName: 'email',
    isRequired: true,
    rules: const [zRequiredRule, zStringRule, zEmailRule],
  );

  late final ZFieldValidator<Object?> name = ZFieldValidator<Object?>(
    modelName: 'User',
    fieldName: 'name',
    rules: [zStringRule, zMinLengthRule(2), zMaxLengthRule(80)],
  );

  late final ZFieldValidator<Object?> role = ZFieldValidator<Object?>(
    modelName: 'User',
    fieldName: 'role',
    rules: [zEnumRule<Role>(Role.values)],
  );

  late final ZFieldValidator<Object?> posts = ZFieldValidator<Object?>(
    modelName: 'User',
    fieldName: 'posts',
    isRequired: true,
    rules: const [zRequiredRule, zListRule],
  );

  late final ZModelValidator<User> model = ZModelValidator<User>(
    modelName: 'User',
    fields: {
      'id': id,
      'createdAt': createdAt,
      'email': email,
      'name': name,
      'role': role,
      'posts': posts,
    },
  );

  ZValidationResult validateMap(Map<String, Object?> data) {
    return model.validateMap(data);
  }

  ZValidationResult validateModel(User value) {
    return model.validateModel(value);
  }
}

final class PostValidators {
  PostValidators();

  late final ZFieldValidator<Object?> id = ZFieldValidator<Object?>(
    modelName: 'Post',
    fieldName: 'id',
    isRequired: true,
    isUnique: true,
    rules: const [zRequiredRule, zIntRule],
  );

  late final ZFieldValidator<Object?> createdAt = ZFieldValidator<Object?>(
    modelName: 'Post',
    fieldName: 'createdAt',
    isRequired: true,
    rules: const [zRequiredRule, zDateTimeRule],
  );

  late final ZFieldValidator<Object?> updatedAt = ZFieldValidator<Object?>(
    modelName: 'Post',
    fieldName: 'updatedAt',
    isRequired: true,
    rules: const [zRequiredRule, zDateTimeRule],
  );

  late final ZFieldValidator<Object?> published = ZFieldValidator<Object?>(
    modelName: 'Post',
    fieldName: 'published',
    isRequired: true,
    rules: const [zRequiredRule, zBooleanRule],
  );

  late final ZFieldValidator<Object?> title = ZFieldValidator<Object?>(
    modelName: 'Post',
    fieldName: 'title',
    isRequired: true,
    rules: const [zRequiredRule, zStringRule],
  );

  late final ZFieldValidator<Object?> author = ZFieldValidator<Object?>(
    modelName: 'Post',
    fieldName: 'author',
    isRequired: true,
    rules: const [zRequiredRule, zModelRule],
  );

  late final ZFieldValidator<Object?> authorId = ZFieldValidator<Object?>(
    modelName: 'Post',
    fieldName: 'authorId',
    isRequired: true,
    rules: const [zRequiredRule, zIntRule],
  );

  late final ZModelValidator<Post> model = ZModelValidator<Post>(
    modelName: 'Post',
    fields: {
      'id': id,
      'createdAt': createdAt,
      'updatedAt': updatedAt,
      'published': published,
      'title': title,
      'author': author,
      'authorId': authorId,
    },
  );

  ZValidationResult validateMap(Map<String, Object?> data) {
    return model.validateMap(data);
  }

  ZValidationResult validateModel(Post value) {
    return model.validateModel(value);
  }
}

final class UserCreate extends ZModelCreate<User> {
  UserCreate([super.data]);

  @override
  UserCreate copyWithData(Map<String, Object?> data) {
    return UserCreate(data);
  }

  UserCreate email(String value) {
    return set('email', value);
  }

  UserCreate name(String? value) {
    return set('name', value);
  }

  UserCreate role(Role? value) {
    return set('role', value);
  }

  late final ZModelCreateNestedBuilder<
    User,
    UserCreate,
    Post,
    PostCreate,
    PostWhereUnique
  >
  posts =
      ZModelCreateNestedBuilder<
        User,
        UserCreate,
        Post,
        PostCreate,
        PostWhereUnique
      >(this, 'posts');
}

final class UserCreateMany extends ZModelCreateMany<User, UserCreate> {
  UserCreateMany([super.data]);

  @override
  UserCreateMany copyWithData(Iterable<UserCreate> data) {
    return UserCreateMany(data);
  }
}

final class UserUpdate extends ZModelUpdate<User> {
  UserUpdate([super.data]);

  @override
  UserUpdate copyWithData(Map<String, Object?> data) {
    return UserUpdate(data);
  }

  UserUpdate email(String? value) {
    return set('email', value);
  }

  UserUpdate name(String? value) {
    return set('name', value);
  }

  UserUpdate role(Role? value) {
    return set('role', value);
  }
}

final class UserWhere extends ZModelWhere<User> {
  UserWhere([super.data]);

  @override
  UserWhere copyWithData(Map<String, Object?> data) {
    return UserWhere(data);
  }

  late final ZIntWhereClauseBuilder<User, UserWhere> id =
      ZIntWhereClauseBuilder(this, 'id');
  late final ZStringWhereClauseBuilder<User, UserWhere> email =
      ZStringWhereClauseBuilder(this, 'email');
  late final ZEnumWhereClauseBuilder<Role, User, UserWhere> role =
      ZEnumWhereClauseBuilder<Role, User, UserWhere>(this, 'role');

  late final ZModelFKWhereClauseBuilder<User, UserWhere, Post, PostWhere>
  posts = ZModelFKWhereClauseBuilder<User, UserWhere, Post, PostWhere>(
    this,
    'posts',
  );

  late final ZModelListWhereBuilder<User, UserWhere> and =
      ZModelListWhereBuilder<User, UserWhere>(this, 'AND');
  late final ZModelListWhereBuilder<User, UserWhere> or =
      ZModelListWhereBuilder<User, UserWhere>(this, 'OR');
  late final ZModelListWhereBuilder<User, UserWhere> not =
      ZModelListWhereBuilder<User, UserWhere>(this, 'NOT');
}

final class UserWhereUnique extends ZModelWhereUnique<User> {
  UserWhereUnique([super.data]);

  @override
  UserWhereUnique copyWithData(Map<String, Object?> data) {
    return UserWhereUnique(data);
  }

  UserWhereUnique id(int value) {
    return set('id', value);
  }

  UserWhereUnique email(String value) {
    return set('email', value);
  }

  @override
  Map<String, Object?> toJson() {
    final data = super.toJson();
    if (data.isEmpty) throw StateError('Empty where clause');
    return data;
  }
}

final class UserSelect extends ZModelSelect<User> {
  UserSelect([super.data]);

  @override
  UserSelect copyWithData(Map<String, Object?> data) {
    return UserSelect(data);
  }

  UserSelect id([bool value = true]) {
    return set('id', value);
  }

  UserSelect createdAt([bool value = true]) {
    return set('createdAt', value);
  }

  UserSelect email([bool value = true]) {
    return set('email', value);
  }

  UserSelect name([bool value = true]) {
    return set('name', value);
  }

  UserSelect role([bool value = true]) {
    return set('role', value);
  }

  UserSelect posts([bool value = true]) {
    return set('posts', value);
  }

  UserSelect postsWith({
    PostSelect? select,
    PostOmit? omit,
    PostInclude? include,
    PostWhere? where,
  }) {
    return set('posts', {
      'select': ?select?.toJson(),
      'omit': ?omit?.toJson(),
      'include': ?include?.toJson(),
      'where': ?where?.toJson(),
    });
  }
}

final class UserOmit extends ZModelOmit<User> {
  UserOmit([super.data]);

  @override
  UserOmit copyWithData(Map<String, Object?> data) {
    return UserOmit(data);
  }

  UserOmit id([bool value = true]) {
    return set('id', value);
  }

  UserOmit createdAt([bool value = true]) {
    return set('createdAt', value);
  }

  UserOmit email([bool value = true]) {
    return set('email', value);
  }

  UserOmit name([bool value = true]) {
    return set('name', value);
  }

  UserOmit role([bool value = true]) {
    return set('role', value);
  }
}

final class UserInclude extends ZModelInclude<User> {
  UserInclude([super.data]);

  @override
  UserInclude copyWithData(Map<String, Object?> data) {
    return UserInclude(data);
  }

  UserInclude posts([bool value = true]) {
    return set('posts', value);
  }

  UserInclude postsWith({
    PostSelect? select,
    PostOmit? omit,
    PostInclude? include,
    PostWhere? where,
  }) {
    return set('posts', {
      'select': ?select?.toJson(),
      'omit': ?omit?.toJson(),
      'include': ?include?.toJson(),
      'where': ?where?.toJson(),
    });
  }
}

final class UserOrderBy extends ZModelOrderBy<User> {
  UserOrderBy([super.data]);

  @override
  UserOrderBy copyWithData(Iterable<ZModelOrderByEntry> data) {
    return UserOrderBy(data);
  }

  late final ZModelOrderByBuilder<User, UserOrderBy> id =
      ZModelOrderByBuilder<User, UserOrderBy>(this, 'id');

  late final ZModelOrderByBuilder<User, UserOrderBy> email =
      ZModelOrderByBuilder<User, UserOrderBy>(this, 'email');

  late final ZModelOrderByBuilder<User, UserOrderBy> createdAt =
      ZModelOrderByBuilder<User, UserOrderBy>(this, 'createdAt');
}

final class UserDistinct extends ZModelDistinct<User> {
  UserDistinct([super.data]);

  @override
  UserDistinct copyWithData(Iterable<String> data) {
    return UserDistinct(data);
  }

  UserDistinct field(String name) {
    return add<UserDistinct>(name);
  }
}

final class PostCreate extends ZModelCreate<Post> {
  PostCreate([super.data]);

  @override
  PostCreate copyWithData(Map<String, Object?> data) {
    return PostCreate(data);
  }

  PostCreate published(bool? value) {
    return set('published', value);
  }

  PostCreate title(String value) {
    return set('title', value);
  }

  PostCreate author(Object? value) {
    return set('author', value);
  }

  PostCreate authorId(int? value) {
    return set('authorId', value);
  }
}

final class PostCreateMany extends ZModelCreateMany<Post, PostCreate> {
  PostCreateMany([super.data]);

  @override
  PostCreateMany copyWithData(Iterable<PostCreate> data) {
    return PostCreateMany(data);
  }
}

final class PostUpdate extends ZModelUpdate<Post> {
  PostUpdate([super.data]);

  @override
  PostUpdate copyWithData(Map<String, Object?> data) {
    return PostUpdate(data);
  }

  PostUpdate published(bool? value) {
    return set('published', value);
  }

  PostUpdate title(String? value) {
    return set('title', value);
  }

  PostUpdate author(Object? value) {
    return set('author', value);
  }

  PostUpdate authorId(int? value) {
    return set('authorId', value);
  }
}

final class PostWhere extends ZModelWhere<Post> {
  PostWhere([super.data]);

  @override
  PostWhere copyWithData(Map<String, Object?> data) {
    return PostWhere(data);
  }

  PostWhere id(Object? value) {
    return set('id', value);
  }

  PostWhere published(Object? value) {
    return set('published', value);
  }

  PostWhere authorId(Object? value) {
    return set('authorId', value);
  }

  late final ZModelListWhereBuilder<Post, PostWhere> and =
      ZModelListWhereBuilder<Post, PostWhere>(this, 'AND');
  late final ZModelListWhereBuilder<Post, PostWhere> or =
      ZModelListWhereBuilder<Post, PostWhere>(this, 'OR');
  late final ZModelListWhereBuilder<Post, PostWhere> not =
      ZModelListWhereBuilder<Post, PostWhere>(this, 'NOT');
}

final class PostWhereUnique extends ZModelWhereUnique<Post> {
  PostWhereUnique([super.data]);

  @override
  PostWhereUnique copyWithData(Map<String, Object?> data) {
    return PostWhereUnique(data);
  }

  PostWhereUnique id(int value) {
    return set('id', value);
  }
}

final class PostSelect extends ZModelSelect<Post> {
  PostSelect([super.data]);

  @override
  PostSelect copyWithData(Map<String, Object?> data) {
    return PostSelect(data);
  }

  PostSelect id([bool value = true]) {
    return set('id', value);
  }

  PostSelect title([bool value = true]) {
    return set('title', value);
  }

  PostSelect author([bool value = true]) {
    return set('author', value);
  }

  PostSelect authorWith({
    UserSelect? select,
    UserOmit? omit,
    UserInclude? include,
    UserWhere? where,
  }) {
    return set('author', {
      'select': ?select?.toJson(),
      'omit': ?omit?.toJson(),
      'include': ?include?.toJson(),
      'where': ?where?.toJson(),
    });
  }
}

final class PostOmit extends ZModelOmit<Post> {
  PostOmit([super.data]);

  @override
  PostOmit copyWithData(Map<String, Object?> data) {
    return PostOmit(data);
  }

  PostOmit id([bool value = true]) {
    return set('id', value);
  }

  PostOmit createdAt([bool value = true]) {
    return set('createdAt', value);
  }

  PostOmit updatedAt([bool value = true]) {
    return set('updatedAt', value);
  }

  PostOmit published([bool value = true]) {
    return set('published', value);
  }

  PostOmit title([bool value = true]) {
    return set('title', value);
  }

  PostOmit authorId([bool value = true]) {
    return set('authorId', value);
  }
}

final class PostInclude extends ZModelInclude<Post> {
  PostInclude([super.data]);

  @override
  PostInclude copyWithData(Map<String, Object?> data) {
    return PostInclude(data);
  }

  PostInclude author([bool value = true]) {
    return set('author', value);
  }

  PostInclude authorWith({
    UserSelect? select,
    UserOmit? omit,
    UserInclude? include,
    UserWhere? where,
  }) {
    return set('author', {
      'select': ?select?.toJson(),
      'omit': ?omit?.toJson(),
      'include': ?include?.toJson(),
      'where': ?where?.toJson(),
    });
  }
}

final class PostOrderBy extends ZModelOrderBy<Post> {
  PostOrderBy([super.data]);

  @override
  PostOrderBy copyWithData(Iterable<ZModelOrderByEntry> data) {
    return PostOrderBy(data);
  }

  late final ZModelOrderByBuilder<Post, PostOrderBy> id =
      ZModelOrderByBuilder<Post, PostOrderBy>(this, 'id');

  late final ZModelOrderByBuilder<Post, PostOrderBy> createdAt =
      ZModelOrderByBuilder<Post, PostOrderBy>(this, 'createdAt');

  late final ZModelOrderByBuilder<Post, PostOrderBy> updatedAt =
      ZModelOrderByBuilder<Post, PostOrderBy>(this, 'updatedAt');
}

final class PostDistinct extends ZModelDistinct<Post> {
  PostDistinct([super.data]);

  @override
  PostDistinct copyWithData(Iterable<String> data) {
    return PostDistinct(data);
  }

  PostDistinct field(String name) {
    return add<PostDistinct>(name);
  }
}

final class BlogSchemaRpcTransport implements ZRpcTransport {
  @override
  Future<ZHttpResponse> send(
    ZHttpMethod method,
    String path, {
    Map<String, String>? queryParameters,
    Object? body,
  }) async {
    print('Sending $method $path');
    return ZHttpResponse(statusCode: 200, data: {});
  }
}

final class BlogSchemaRpcClient extends ZRpcClient {
  BlogSchemaRpcClient(super.transport);

  ZModelRpcApi<User> get user {
    return ZModelRpcApi<User>(transport, 'User', fromJson: User.fromJson);
  }

  ZModelRpcApi<Post> get post {
    return ZModelRpcApi<Post>(transport, 'Post', fromJson: Post.fromJson);
  }

  //
  @override
  Map<String, ZModelRpcApi> get models => {'user': user, 'post': post};
}

void main() {
  final client = BlogSchemaRpcClient(BlogSchemaRpcTransport());

  final response = client.user.findFirst(
    select: UserSelect().id().email().createdAt().role(),
    include: UserInclude().posts(),
    omit: UserOmit().createdAt(),
    where: UserWhere().email.equals('[e-mail]'),
  );
  response.then((value) {
    print(value.data);
  });

  final response2 = client.user.findMany(
    orderBy: UserOrderBy().createdAt.order(false),
  );
  response2.then((value) {
    print(value.data);
  });

  final response3 = client.user.create(
    data: UserCreate().email('[e-mail]').posts.createMany([
      PostCreate().title('First post'),
    ]),
  );
  response3.then((value) {
    print(value.data);
  });
}