diff --git a/lib/data/database.dart b/lib/data/database.dart
new file mode 100644
index 0000000..2c04942
--- /dev/null
+++ b/lib/data/database.dart
@@ -0,0 +1,46 @@
+import 'package:drift/drift.dart';
+import 'package:drift_flutter/drift_flutter.dart';
+import 'package:path_provider/path_provider.dart';
+
+part 'database.g.dart';
+
+class User extends Table {
+  TextColumn get id => text()();
+  TextColumn get name => text()();
+
+  @override
+  Set<Column<Object>> get primaryKey => {id};
+}
+
+class Group extends Table {
+  TextColumn get id => text()();
+  TextColumn get name => text()();
+
+  @override
+  Set<Column<Object>> get primaryKey => {id};
+}
+
+class UserGroup extends Table {
+  TextColumn get userId => text().references(User, #id)();
+  TextColumn get groupId => text().references(Group, #id)();
+
+  @override
+  Set<Column<Object>> get primaryKey => {userId, groupId};
+}
+
+@DriftDatabase(tables: [User, Group, UserGroup])
+class AppDatabase extends _$AppDatabase {
+  AppDatabase([QueryExecutor? executor]) : super(executor ?? _openConnection());
+
+  @override
+  int get schemaVersion => 1;
+
+  static QueryExecutor _openConnection() {
+    return driftDatabase(
+      name: 'gametracker_db',
+      native: const DriftNativeOptions(
+        databaseDirectory: getApplicationSupportDirectory,
+      ),
+    );
+  }
+}
\ No newline at end of file
diff --git a/lib/data/database.g.dart b/lib/data/database.g.dart
new file mode 100644
index 0000000..795f850
--- /dev/null
+++ b/lib/data/database.g.dart
@@ -0,0 +1,1455 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'database.dart';
+
+// ignore_for_file: type=lint
+class $UserTable extends User with TableInfo<$UserTable, UserData> {
+  @override
+  final GeneratedDatabase attachedDatabase;
+  final String? _alias;
+  $UserTable(this.attachedDatabase, [this._alias]);
+  static const VerificationMeta _idMeta = const VerificationMeta('id');
+  @override
+  late final GeneratedColumn<String> id = GeneratedColumn<String>(
+    'id',
+    aliasedName,
+    false,
+    type: DriftSqlType.string,
+    requiredDuringInsert: true,
+  );
+  static const VerificationMeta _nameMeta = const VerificationMeta('name');
+  @override
+  late final GeneratedColumn<String> name = GeneratedColumn<String>(
+    'name',
+    aliasedName,
+    false,
+    type: DriftSqlType.string,
+    requiredDuringInsert: true,
+  );
+  @override
+  List<GeneratedColumn> get $columns => [id, name];
+  @override
+  String get aliasedName => _alias ?? actualTableName;
+  @override
+  String get actualTableName => $name;
+  static const String $name = 'user';
+  @override
+  VerificationContext validateIntegrity(
+    Insertable<UserData> instance, {
+    bool isInserting = false,
+  }) {
+    final context = VerificationContext();
+    final data = instance.toColumns(true);
+    if (data.containsKey('id')) {
+      context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
+    } else if (isInserting) {
+      context.missing(_idMeta);
+    }
+    if (data.containsKey('name')) {
+      context.handle(
+        _nameMeta,
+        name.isAcceptableOrUnknown(data['name']!, _nameMeta),
+      );
+    } else if (isInserting) {
+      context.missing(_nameMeta);
+    }
+    return context;
+  }
+
+  @override
+  Set<GeneratedColumn> get $primaryKey => {id};
+  @override
+  UserData map(Map<String, dynamic> data, {String? tablePrefix}) {
+    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
+    return UserData(
+      id: attachedDatabase.typeMapping.read(
+        DriftSqlType.string,
+        data['${effectivePrefix}id'],
+      )!,
+      name: attachedDatabase.typeMapping.read(
+        DriftSqlType.string,
+        data['${effectivePrefix}name'],
+      )!,
+    );
+  }
+
+  @override
+  $UserTable createAlias(String alias) {
+    return $UserTable(attachedDatabase, alias);
+  }
+}
+
+class UserData extends DataClass implements Insertable<UserData> {
+  final String id;
+  final String name;
+  const UserData({required this.id, required this.name});
+  @override
+  Map<String, Expression> toColumns(bool nullToAbsent) {
+    final map = <String, Expression>{};
+    map['id'] = Variable<String>(id);
+    map['name'] = Variable<String>(name);
+    return map;
+  }
+
+  UserCompanion toCompanion(bool nullToAbsent) {
+    return UserCompanion(id: Value(id), name: Value(name));
+  }
+
+  factory UserData.fromJson(
+    Map<String, dynamic> json, {
+    ValueSerializer? serializer,
+  }) {
+    serializer ??= driftRuntimeOptions.defaultSerializer;
+    return UserData(
+      id: serializer.fromJson<String>(json['id']),
+      name: serializer.fromJson<String>(json['name']),
+    );
+  }
+  @override
+  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
+    serializer ??= driftRuntimeOptions.defaultSerializer;
+    return <String, dynamic>{
+      'id': serializer.toJson<String>(id),
+      'name': serializer.toJson<String>(name),
+    };
+  }
+
+  UserData copyWith({String? id, String? name}) =>
+      UserData(id: id ?? this.id, name: name ?? this.name);
+  UserData copyWithCompanion(UserCompanion data) {
+    return UserData(
+      id: data.id.present ? data.id.value : this.id,
+      name: data.name.present ? data.name.value : this.name,
+    );
+  }
+
+  @override
+  String toString() {
+    return (StringBuffer('UserData(')
+          ..write('id: $id, ')
+          ..write('name: $name')
+          ..write(')'))
+        .toString();
+  }
+
+  @override
+  int get hashCode => Object.hash(id, name);
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      (other is UserData && other.id == this.id && other.name == this.name);
+}
+
+class UserCompanion extends UpdateCompanion<UserData> {
+  final Value<String> id;
+  final Value<String> name;
+  final Value<int> rowid;
+  const UserCompanion({
+    this.id = const Value.absent(),
+    this.name = const Value.absent(),
+    this.rowid = const Value.absent(),
+  });
+  UserCompanion.insert({
+    required String id,
+    required String name,
+    this.rowid = const Value.absent(),
+  }) : id = Value(id),
+       name = Value(name);
+  static Insertable<UserData> custom({
+    Expression<String>? id,
+    Expression<String>? name,
+    Expression<int>? rowid,
+  }) {
+    return RawValuesInsertable({
+      if (id != null) 'id': id,
+      if (name != null) 'name': name,
+      if (rowid != null) 'rowid': rowid,
+    });
+  }
+
+  UserCompanion copyWith({
+    Value<String>? id,
+    Value<String>? name,
+    Value<int>? rowid,
+  }) {
+    return UserCompanion(
+      id: id ?? this.id,
+      name: name ?? this.name,
+      rowid: rowid ?? this.rowid,
+    );
+  }
+
+  @override
+  Map<String, Expression> toColumns(bool nullToAbsent) {
+    final map = <String, Expression>{};
+    if (id.present) {
+      map['id'] = Variable<String>(id.value);
+    }
+    if (name.present) {
+      map['name'] = Variable<String>(name.value);
+    }
+    if (rowid.present) {
+      map['rowid'] = Variable<int>(rowid.value);
+    }
+    return map;
+  }
+
+  @override
+  String toString() {
+    return (StringBuffer('UserCompanion(')
+          ..write('id: $id, ')
+          ..write('name: $name, ')
+          ..write('rowid: $rowid')
+          ..write(')'))
+        .toString();
+  }
+}
+
+class $GroupTable extends Group with TableInfo<$GroupTable, GroupData> {
+  @override
+  final GeneratedDatabase attachedDatabase;
+  final String? _alias;
+  $GroupTable(this.attachedDatabase, [this._alias]);
+  static const VerificationMeta _idMeta = const VerificationMeta('id');
+  @override
+  late final GeneratedColumn<String> id = GeneratedColumn<String>(
+    'id',
+    aliasedName,
+    false,
+    type: DriftSqlType.string,
+    requiredDuringInsert: true,
+  );
+  static const VerificationMeta _nameMeta = const VerificationMeta('name');
+  @override
+  late final GeneratedColumn<String> name = GeneratedColumn<String>(
+    'name',
+    aliasedName,
+    false,
+    type: DriftSqlType.string,
+    requiredDuringInsert: true,
+  );
+  @override
+  List<GeneratedColumn> get $columns => [id, name];
+  @override
+  String get aliasedName => _alias ?? actualTableName;
+  @override
+  String get actualTableName => $name;
+  static const String $name = 'group';
+  @override
+  VerificationContext validateIntegrity(
+    Insertable<GroupData> instance, {
+    bool isInserting = false,
+  }) {
+    final context = VerificationContext();
+    final data = instance.toColumns(true);
+    if (data.containsKey('id')) {
+      context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
+    } else if (isInserting) {
+      context.missing(_idMeta);
+    }
+    if (data.containsKey('name')) {
+      context.handle(
+        _nameMeta,
+        name.isAcceptableOrUnknown(data['name']!, _nameMeta),
+      );
+    } else if (isInserting) {
+      context.missing(_nameMeta);
+    }
+    return context;
+  }
+
+  @override
+  Set<GeneratedColumn> get $primaryKey => {id};
+  @override
+  GroupData map(Map<String, dynamic> data, {String? tablePrefix}) {
+    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
+    return GroupData(
+      id: attachedDatabase.typeMapping.read(
+        DriftSqlType.string,
+        data['${effectivePrefix}id'],
+      )!,
+      name: attachedDatabase.typeMapping.read(
+        DriftSqlType.string,
+        data['${effectivePrefix}name'],
+      )!,
+    );
+  }
+
+  @override
+  $GroupTable createAlias(String alias) {
+    return $GroupTable(attachedDatabase, alias);
+  }
+}
+
+class GroupData extends DataClass implements Insertable<GroupData> {
+  final String id;
+  final String name;
+  const GroupData({required this.id, required this.name});
+  @override
+  Map<String, Expression> toColumns(bool nullToAbsent) {
+    final map = <String, Expression>{};
+    map['id'] = Variable<String>(id);
+    map['name'] = Variable<String>(name);
+    return map;
+  }
+
+  GroupCompanion toCompanion(bool nullToAbsent) {
+    return GroupCompanion(id: Value(id), name: Value(name));
+  }
+
+  factory GroupData.fromJson(
+    Map<String, dynamic> json, {
+    ValueSerializer? serializer,
+  }) {
+    serializer ??= driftRuntimeOptions.defaultSerializer;
+    return GroupData(
+      id: serializer.fromJson<String>(json['id']),
+      name: serializer.fromJson<String>(json['name']),
+    );
+  }
+  @override
+  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
+    serializer ??= driftRuntimeOptions.defaultSerializer;
+    return <String, dynamic>{
+      'id': serializer.toJson<String>(id),
+      'name': serializer.toJson<String>(name),
+    };
+  }
+
+  GroupData copyWith({String? id, String? name}) =>
+      GroupData(id: id ?? this.id, name: name ?? this.name);
+  GroupData copyWithCompanion(GroupCompanion data) {
+    return GroupData(
+      id: data.id.present ? data.id.value : this.id,
+      name: data.name.present ? data.name.value : this.name,
+    );
+  }
+
+  @override
+  String toString() {
+    return (StringBuffer('GroupData(')
+          ..write('id: $id, ')
+          ..write('name: $name')
+          ..write(')'))
+        .toString();
+  }
+
+  @override
+  int get hashCode => Object.hash(id, name);
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      (other is GroupData && other.id == this.id && other.name == this.name);
+}
+
+class GroupCompanion extends UpdateCompanion<GroupData> {
+  final Value<String> id;
+  final Value<String> name;
+  final Value<int> rowid;
+  const GroupCompanion({
+    this.id = const Value.absent(),
+    this.name = const Value.absent(),
+    this.rowid = const Value.absent(),
+  });
+  GroupCompanion.insert({
+    required String id,
+    required String name,
+    this.rowid = const Value.absent(),
+  }) : id = Value(id),
+       name = Value(name);
+  static Insertable<GroupData> custom({
+    Expression<String>? id,
+    Expression<String>? name,
+    Expression<int>? rowid,
+  }) {
+    return RawValuesInsertable({
+      if (id != null) 'id': id,
+      if (name != null) 'name': name,
+      if (rowid != null) 'rowid': rowid,
+    });
+  }
+
+  GroupCompanion copyWith({
+    Value<String>? id,
+    Value<String>? name,
+    Value<int>? rowid,
+  }) {
+    return GroupCompanion(
+      id: id ?? this.id,
+      name: name ?? this.name,
+      rowid: rowid ?? this.rowid,
+    );
+  }
+
+  @override
+  Map<String, Expression> toColumns(bool nullToAbsent) {
+    final map = <String, Expression>{};
+    if (id.present) {
+      map['id'] = Variable<String>(id.value);
+    }
+    if (name.present) {
+      map['name'] = Variable<String>(name.value);
+    }
+    if (rowid.present) {
+      map['rowid'] = Variable<int>(rowid.value);
+    }
+    return map;
+  }
+
+  @override
+  String toString() {
+    return (StringBuffer('GroupCompanion(')
+          ..write('id: $id, ')
+          ..write('name: $name, ')
+          ..write('rowid: $rowid')
+          ..write(')'))
+        .toString();
+  }
+}
+
+class $UserGroupTable extends UserGroup
+    with TableInfo<$UserGroupTable, UserGroupData> {
+  @override
+  final GeneratedDatabase attachedDatabase;
+  final String? _alias;
+  $UserGroupTable(this.attachedDatabase, [this._alias]);
+  static const VerificationMeta _userIdMeta = const VerificationMeta('userId');
+  @override
+  late final GeneratedColumn<String> userId = GeneratedColumn<String>(
+    'user_id',
+    aliasedName,
+    false,
+    type: DriftSqlType.string,
+    requiredDuringInsert: true,
+    defaultConstraints: GeneratedColumn.constraintIsAlways(
+      'REFERENCES user (id)',
+    ),
+  );
+  static const VerificationMeta _groupIdMeta = const VerificationMeta(
+    'groupId',
+  );
+  @override
+  late final GeneratedColumn<String> groupId = GeneratedColumn<String>(
+    'group_id',
+    aliasedName,
+    false,
+    type: DriftSqlType.string,
+    requiredDuringInsert: true,
+    defaultConstraints: GeneratedColumn.constraintIsAlways(
+      'REFERENCES "group" (id)',
+    ),
+  );
+  @override
+  List<GeneratedColumn> get $columns => [userId, groupId];
+  @override
+  String get aliasedName => _alias ?? actualTableName;
+  @override
+  String get actualTableName => $name;
+  static const String $name = 'user_group';
+  @override
+  VerificationContext validateIntegrity(
+    Insertable<UserGroupData> instance, {
+    bool isInserting = false,
+  }) {
+    final context = VerificationContext();
+    final data = instance.toColumns(true);
+    if (data.containsKey('user_id')) {
+      context.handle(
+        _userIdMeta,
+        userId.isAcceptableOrUnknown(data['user_id']!, _userIdMeta),
+      );
+    } else if (isInserting) {
+      context.missing(_userIdMeta);
+    }
+    if (data.containsKey('group_id')) {
+      context.handle(
+        _groupIdMeta,
+        groupId.isAcceptableOrUnknown(data['group_id']!, _groupIdMeta),
+      );
+    } else if (isInserting) {
+      context.missing(_groupIdMeta);
+    }
+    return context;
+  }
+
+  @override
+  Set<GeneratedColumn> get $primaryKey => {userId, groupId};
+  @override
+  UserGroupData map(Map<String, dynamic> data, {String? tablePrefix}) {
+    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
+    return UserGroupData(
+      userId: attachedDatabase.typeMapping.read(
+        DriftSqlType.string,
+        data['${effectivePrefix}user_id'],
+      )!,
+      groupId: attachedDatabase.typeMapping.read(
+        DriftSqlType.string,
+        data['${effectivePrefix}group_id'],
+      )!,
+    );
+  }
+
+  @override
+  $UserGroupTable createAlias(String alias) {
+    return $UserGroupTable(attachedDatabase, alias);
+  }
+}
+
+class UserGroupData extends DataClass implements Insertable<UserGroupData> {
+  final String userId;
+  final String groupId;
+  const UserGroupData({required this.userId, required this.groupId});
+  @override
+  Map<String, Expression> toColumns(bool nullToAbsent) {
+    final map = <String, Expression>{};
+    map['user_id'] = Variable<String>(userId);
+    map['group_id'] = Variable<String>(groupId);
+    return map;
+  }
+
+  UserGroupCompanion toCompanion(bool nullToAbsent) {
+    return UserGroupCompanion(userId: Value(userId), groupId: Value(groupId));
+  }
+
+  factory UserGroupData.fromJson(
+    Map<String, dynamic> json, {
+    ValueSerializer? serializer,
+  }) {
+    serializer ??= driftRuntimeOptions.defaultSerializer;
+    return UserGroupData(
+      userId: serializer.fromJson<String>(json['userId']),
+      groupId: serializer.fromJson<String>(json['groupId']),
+    );
+  }
+  @override
+  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
+    serializer ??= driftRuntimeOptions.defaultSerializer;
+    return <String, dynamic>{
+      'userId': serializer.toJson<String>(userId),
+      'groupId': serializer.toJson<String>(groupId),
+    };
+  }
+
+  UserGroupData copyWith({String? userId, String? groupId}) => UserGroupData(
+    userId: userId ?? this.userId,
+    groupId: groupId ?? this.groupId,
+  );
+  UserGroupData copyWithCompanion(UserGroupCompanion data) {
+    return UserGroupData(
+      userId: data.userId.present ? data.userId.value : this.userId,
+      groupId: data.groupId.present ? data.groupId.value : this.groupId,
+    );
+  }
+
+  @override
+  String toString() {
+    return (StringBuffer('UserGroupData(')
+          ..write('userId: $userId, ')
+          ..write('groupId: $groupId')
+          ..write(')'))
+        .toString();
+  }
+
+  @override
+  int get hashCode => Object.hash(userId, groupId);
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      (other is UserGroupData &&
+          other.userId == this.userId &&
+          other.groupId == this.groupId);
+}
+
+class UserGroupCompanion extends UpdateCompanion<UserGroupData> {
+  final Value<String> userId;
+  final Value<String> groupId;
+  final Value<int> rowid;
+  const UserGroupCompanion({
+    this.userId = const Value.absent(),
+    this.groupId = const Value.absent(),
+    this.rowid = const Value.absent(),
+  });
+  UserGroupCompanion.insert({
+    required String userId,
+    required String groupId,
+    this.rowid = const Value.absent(),
+  }) : userId = Value(userId),
+       groupId = Value(groupId);
+  static Insertable<UserGroupData> custom({
+    Expression<String>? userId,
+    Expression<String>? groupId,
+    Expression<int>? rowid,
+  }) {
+    return RawValuesInsertable({
+      if (userId != null) 'user_id': userId,
+      if (groupId != null) 'group_id': groupId,
+      if (rowid != null) 'rowid': rowid,
+    });
+  }
+
+  UserGroupCompanion copyWith({
+    Value<String>? userId,
+    Value<String>? groupId,
+    Value<int>? rowid,
+  }) {
+    return UserGroupCompanion(
+      userId: userId ?? this.userId,
+      groupId: groupId ?? this.groupId,
+      rowid: rowid ?? this.rowid,
+    );
+  }
+
+  @override
+  Map<String, Expression> toColumns(bool nullToAbsent) {
+    final map = <String, Expression>{};
+    if (userId.present) {
+      map['user_id'] = Variable<String>(userId.value);
+    }
+    if (groupId.present) {
+      map['group_id'] = Variable<String>(groupId.value);
+    }
+    if (rowid.present) {
+      map['rowid'] = Variable<int>(rowid.value);
+    }
+    return map;
+  }
+
+  @override
+  String toString() {
+    return (StringBuffer('UserGroupCompanion(')
+          ..write('userId: $userId, ')
+          ..write('groupId: $groupId, ')
+          ..write('rowid: $rowid')
+          ..write(')'))
+        .toString();
+  }
+}
+
+abstract class _$AppDatabase extends GeneratedDatabase {
+  _$AppDatabase(QueryExecutor e) : super(e);
+  $AppDatabaseManager get managers => $AppDatabaseManager(this);
+  late final $UserTable user = $UserTable(this);
+  late final $GroupTable group = $GroupTable(this);
+  late final $UserGroupTable userGroup = $UserGroupTable(this);
+  @override
+  Iterable<TableInfo<Table, Object?>> get allTables =>
+      allSchemaEntities.whereType<TableInfo<Table, Object?>>();
+  @override
+  List<DatabaseSchemaEntity> get allSchemaEntities => [user, group, userGroup];
+}
+
+typedef $$UserTableCreateCompanionBuilder =
+    UserCompanion Function({
+      required String id,
+      required String name,
+      Value<int> rowid,
+    });
+typedef $$UserTableUpdateCompanionBuilder =
+    UserCompanion Function({
+      Value<String> id,
+      Value<String> name,
+      Value<int> rowid,
+    });
+
+final class $$UserTableReferences
+    extends BaseReferences<_$AppDatabase, $UserTable, UserData> {
+  $$UserTableReferences(super.$_db, super.$_table, super.$_typedResult);
+
+  static MultiTypedResultKey<$UserGroupTable, List<UserGroupData>>
+  _userGroupRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
+    db.userGroup,
+    aliasName: $_aliasNameGenerator(db.user.id, db.userGroup.userId),
+  );
+
+  $$UserGroupTableProcessedTableManager get userGroupRefs {
+    final manager = $$UserGroupTableTableManager(
+      $_db,
+      $_db.userGroup,
+    ).filter((f) => f.userId.id.sqlEquals($_itemColumn<String>('id')!));
+
+    final cache = $_typedResult.readTableOrNull(_userGroupRefsTable($_db));
+    return ProcessedTableManager(
+      manager.$state.copyWith(prefetchedData: cache),
+    );
+  }
+}
+
+class $$UserTableFilterComposer extends Composer<_$AppDatabase, $UserTable> {
+  $$UserTableFilterComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnFilters<String> get id => $composableBuilder(
+    column: $table.id,
+    builder: (column) => ColumnFilters(column),
+  );
+
+  ColumnFilters<String> get name => $composableBuilder(
+    column: $table.name,
+    builder: (column) => ColumnFilters(column),
+  );
+
+  Expression<bool> userGroupRefs(
+    Expression<bool> Function($$UserGroupTableFilterComposer f) f,
+  ) {
+    final $$UserGroupTableFilterComposer composer = $composerBuilder(
+      composer: this,
+      getCurrentColumn: (t) => t.id,
+      referencedTable: $db.userGroup,
+      getReferencedColumn: (t) => t.userId,
+      builder:
+          (
+            joinBuilder, {
+            $addJoinBuilderToRootComposer,
+            $removeJoinBuilderFromRootComposer,
+          }) => $$UserGroupTableFilterComposer(
+            $db: $db,
+            $table: $db.userGroup,
+            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
+            joinBuilder: joinBuilder,
+            $removeJoinBuilderFromRootComposer:
+                $removeJoinBuilderFromRootComposer,
+          ),
+    );
+    return f(composer);
+  }
+}
+
+class $$UserTableOrderingComposer extends Composer<_$AppDatabase, $UserTable> {
+  $$UserTableOrderingComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnOrderings<String> get id => $composableBuilder(
+    column: $table.id,
+    builder: (column) => ColumnOrderings(column),
+  );
+
+  ColumnOrderings<String> get name => $composableBuilder(
+    column: $table.name,
+    builder: (column) => ColumnOrderings(column),
+  );
+}
+
+class $$UserTableAnnotationComposer
+    extends Composer<_$AppDatabase, $UserTable> {
+  $$UserTableAnnotationComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  GeneratedColumn<String> get id =>
+      $composableBuilder(column: $table.id, builder: (column) => column);
+
+  GeneratedColumn<String> get name =>
+      $composableBuilder(column: $table.name, builder: (column) => column);
+
+  Expression<T> userGroupRefs<T extends Object>(
+    Expression<T> Function($$UserGroupTableAnnotationComposer a) f,
+  ) {
+    final $$UserGroupTableAnnotationComposer composer = $composerBuilder(
+      composer: this,
+      getCurrentColumn: (t) => t.id,
+      referencedTable: $db.userGroup,
+      getReferencedColumn: (t) => t.userId,
+      builder:
+          (
+            joinBuilder, {
+            $addJoinBuilderToRootComposer,
+            $removeJoinBuilderFromRootComposer,
+          }) => $$UserGroupTableAnnotationComposer(
+            $db: $db,
+            $table: $db.userGroup,
+            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
+            joinBuilder: joinBuilder,
+            $removeJoinBuilderFromRootComposer:
+                $removeJoinBuilderFromRootComposer,
+          ),
+    );
+    return f(composer);
+  }
+}
+
+class $$UserTableTableManager
+    extends
+        RootTableManager<
+          _$AppDatabase,
+          $UserTable,
+          UserData,
+          $$UserTableFilterComposer,
+          $$UserTableOrderingComposer,
+          $$UserTableAnnotationComposer,
+          $$UserTableCreateCompanionBuilder,
+          $$UserTableUpdateCompanionBuilder,
+          (UserData, $$UserTableReferences),
+          UserData,
+          PrefetchHooks Function({bool userGroupRefs})
+        > {
+  $$UserTableTableManager(_$AppDatabase db, $UserTable table)
+    : super(
+        TableManagerState(
+          db: db,
+          table: table,
+          createFilteringComposer: () =>
+              $$UserTableFilterComposer($db: db, $table: table),
+          createOrderingComposer: () =>
+              $$UserTableOrderingComposer($db: db, $table: table),
+          createComputedFieldComposer: () =>
+              $$UserTableAnnotationComposer($db: db, $table: table),
+          updateCompanionCallback:
+              ({
+                Value<String> id = const Value.absent(),
+                Value<String> name = const Value.absent(),
+                Value<int> rowid = const Value.absent(),
+              }) => UserCompanion(id: id, name: name, rowid: rowid),
+          createCompanionCallback:
+              ({
+                required String id,
+                required String name,
+                Value<int> rowid = const Value.absent(),
+              }) => UserCompanion.insert(id: id, name: name, rowid: rowid),
+          withReferenceMapper: (p0) => p0
+              .map(
+                (e) =>
+                    (e.readTable(table), $$UserTableReferences(db, table, e)),
+              )
+              .toList(),
+          prefetchHooksCallback: ({userGroupRefs = false}) {
+            return PrefetchHooks(
+              db: db,
+              explicitlyWatchedTables: [if (userGroupRefs) db.userGroup],
+              addJoins: null,
+              getPrefetchedDataCallback: (items) async {
+                return [
+                  if (userGroupRefs)
+                    await $_getPrefetchedData<
+                      UserData,
+                      $UserTable,
+                      UserGroupData
+                    >(
+                      currentTable: table,
+                      referencedTable: $$UserTableReferences
+                          ._userGroupRefsTable(db),
+                      managerFromTypedResult: (p0) =>
+                          $$UserTableReferences(db, table, p0).userGroupRefs,
+                      referencedItemsForCurrentItem: (item, referencedItems) =>
+                          referencedItems.where((e) => e.userId == item.id),
+                      typedResults: items,
+                    ),
+                ];
+              },
+            );
+          },
+        ),
+      );
+}
+
+typedef $$UserTableProcessedTableManager =
+    ProcessedTableManager<
+      _$AppDatabase,
+      $UserTable,
+      UserData,
+      $$UserTableFilterComposer,
+      $$UserTableOrderingComposer,
+      $$UserTableAnnotationComposer,
+      $$UserTableCreateCompanionBuilder,
+      $$UserTableUpdateCompanionBuilder,
+      (UserData, $$UserTableReferences),
+      UserData,
+      PrefetchHooks Function({bool userGroupRefs})
+    >;
+typedef $$GroupTableCreateCompanionBuilder =
+    GroupCompanion Function({
+      required String id,
+      required String name,
+      Value<int> rowid,
+    });
+typedef $$GroupTableUpdateCompanionBuilder =
+    GroupCompanion Function({
+      Value<String> id,
+      Value<String> name,
+      Value<int> rowid,
+    });
+
+final class $$GroupTableReferences
+    extends BaseReferences<_$AppDatabase, $GroupTable, GroupData> {
+  $$GroupTableReferences(super.$_db, super.$_table, super.$_typedResult);
+
+  static MultiTypedResultKey<$UserGroupTable, List<UserGroupData>>
+  _userGroupRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
+    db.userGroup,
+    aliasName: $_aliasNameGenerator(db.group.id, db.userGroup.groupId),
+  );
+
+  $$UserGroupTableProcessedTableManager get userGroupRefs {
+    final manager = $$UserGroupTableTableManager(
+      $_db,
+      $_db.userGroup,
+    ).filter((f) => f.groupId.id.sqlEquals($_itemColumn<String>('id')!));
+
+    final cache = $_typedResult.readTableOrNull(_userGroupRefsTable($_db));
+    return ProcessedTableManager(
+      manager.$state.copyWith(prefetchedData: cache),
+    );
+  }
+}
+
+class $$GroupTableFilterComposer extends Composer<_$AppDatabase, $GroupTable> {
+  $$GroupTableFilterComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnFilters<String> get id => $composableBuilder(
+    column: $table.id,
+    builder: (column) => ColumnFilters(column),
+  );
+
+  ColumnFilters<String> get name => $composableBuilder(
+    column: $table.name,
+    builder: (column) => ColumnFilters(column),
+  );
+
+  Expression<bool> userGroupRefs(
+    Expression<bool> Function($$UserGroupTableFilterComposer f) f,
+  ) {
+    final $$UserGroupTableFilterComposer composer = $composerBuilder(
+      composer: this,
+      getCurrentColumn: (t) => t.id,
+      referencedTable: $db.userGroup,
+      getReferencedColumn: (t) => t.groupId,
+      builder:
+          (
+            joinBuilder, {
+            $addJoinBuilderToRootComposer,
+            $removeJoinBuilderFromRootComposer,
+          }) => $$UserGroupTableFilterComposer(
+            $db: $db,
+            $table: $db.userGroup,
+            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
+            joinBuilder: joinBuilder,
+            $removeJoinBuilderFromRootComposer:
+                $removeJoinBuilderFromRootComposer,
+          ),
+    );
+    return f(composer);
+  }
+}
+
+class $$GroupTableOrderingComposer
+    extends Composer<_$AppDatabase, $GroupTable> {
+  $$GroupTableOrderingComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  ColumnOrderings<String> get id => $composableBuilder(
+    column: $table.id,
+    builder: (column) => ColumnOrderings(column),
+  );
+
+  ColumnOrderings<String> get name => $composableBuilder(
+    column: $table.name,
+    builder: (column) => ColumnOrderings(column),
+  );
+}
+
+class $$GroupTableAnnotationComposer
+    extends Composer<_$AppDatabase, $GroupTable> {
+  $$GroupTableAnnotationComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  GeneratedColumn<String> get id =>
+      $composableBuilder(column: $table.id, builder: (column) => column);
+
+  GeneratedColumn<String> get name =>
+      $composableBuilder(column: $table.name, builder: (column) => column);
+
+  Expression<T> userGroupRefs<T extends Object>(
+    Expression<T> Function($$UserGroupTableAnnotationComposer a) f,
+  ) {
+    final $$UserGroupTableAnnotationComposer composer = $composerBuilder(
+      composer: this,
+      getCurrentColumn: (t) => t.id,
+      referencedTable: $db.userGroup,
+      getReferencedColumn: (t) => t.groupId,
+      builder:
+          (
+            joinBuilder, {
+            $addJoinBuilderToRootComposer,
+            $removeJoinBuilderFromRootComposer,
+          }) => $$UserGroupTableAnnotationComposer(
+            $db: $db,
+            $table: $db.userGroup,
+            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
+            joinBuilder: joinBuilder,
+            $removeJoinBuilderFromRootComposer:
+                $removeJoinBuilderFromRootComposer,
+          ),
+    );
+    return f(composer);
+  }
+}
+
+class $$GroupTableTableManager
+    extends
+        RootTableManager<
+          _$AppDatabase,
+          $GroupTable,
+          GroupData,
+          $$GroupTableFilterComposer,
+          $$GroupTableOrderingComposer,
+          $$GroupTableAnnotationComposer,
+          $$GroupTableCreateCompanionBuilder,
+          $$GroupTableUpdateCompanionBuilder,
+          (GroupData, $$GroupTableReferences),
+          GroupData,
+          PrefetchHooks Function({bool userGroupRefs})
+        > {
+  $$GroupTableTableManager(_$AppDatabase db, $GroupTable table)
+    : super(
+        TableManagerState(
+          db: db,
+          table: table,
+          createFilteringComposer: () =>
+              $$GroupTableFilterComposer($db: db, $table: table),
+          createOrderingComposer: () =>
+              $$GroupTableOrderingComposer($db: db, $table: table),
+          createComputedFieldComposer: () =>
+              $$GroupTableAnnotationComposer($db: db, $table: table),
+          updateCompanionCallback:
+              ({
+                Value<String> id = const Value.absent(),
+                Value<String> name = const Value.absent(),
+                Value<int> rowid = const Value.absent(),
+              }) => GroupCompanion(id: id, name: name, rowid: rowid),
+          createCompanionCallback:
+              ({
+                required String id,
+                required String name,
+                Value<int> rowid = const Value.absent(),
+              }) => GroupCompanion.insert(id: id, name: name, rowid: rowid),
+          withReferenceMapper: (p0) => p0
+              .map(
+                (e) =>
+                    (e.readTable(table), $$GroupTableReferences(db, table, e)),
+              )
+              .toList(),
+          prefetchHooksCallback: ({userGroupRefs = false}) {
+            return PrefetchHooks(
+              db: db,
+              explicitlyWatchedTables: [if (userGroupRefs) db.userGroup],
+              addJoins: null,
+              getPrefetchedDataCallback: (items) async {
+                return [
+                  if (userGroupRefs)
+                    await $_getPrefetchedData<
+                      GroupData,
+                      $GroupTable,
+                      UserGroupData
+                    >(
+                      currentTable: table,
+                      referencedTable: $$GroupTableReferences
+                          ._userGroupRefsTable(db),
+                      managerFromTypedResult: (p0) =>
+                          $$GroupTableReferences(db, table, p0).userGroupRefs,
+                      referencedItemsForCurrentItem: (item, referencedItems) =>
+                          referencedItems.where((e) => e.groupId == item.id),
+                      typedResults: items,
+                    ),
+                ];
+              },
+            );
+          },
+        ),
+      );
+}
+
+typedef $$GroupTableProcessedTableManager =
+    ProcessedTableManager<
+      _$AppDatabase,
+      $GroupTable,
+      GroupData,
+      $$GroupTableFilterComposer,
+      $$GroupTableOrderingComposer,
+      $$GroupTableAnnotationComposer,
+      $$GroupTableCreateCompanionBuilder,
+      $$GroupTableUpdateCompanionBuilder,
+      (GroupData, $$GroupTableReferences),
+      GroupData,
+      PrefetchHooks Function({bool userGroupRefs})
+    >;
+typedef $$UserGroupTableCreateCompanionBuilder =
+    UserGroupCompanion Function({
+      required String userId,
+      required String groupId,
+      Value<int> rowid,
+    });
+typedef $$UserGroupTableUpdateCompanionBuilder =
+    UserGroupCompanion Function({
+      Value<String> userId,
+      Value<String> groupId,
+      Value<int> rowid,
+    });
+
+final class $$UserGroupTableReferences
+    extends BaseReferences<_$AppDatabase, $UserGroupTable, UserGroupData> {
+  $$UserGroupTableReferences(super.$_db, super.$_table, super.$_typedResult);
+
+  static $UserTable _userIdTable(_$AppDatabase db) => db.user.createAlias(
+    $_aliasNameGenerator(db.userGroup.userId, db.user.id),
+  );
+
+  $$UserTableProcessedTableManager get userId {
+    final $_column = $_itemColumn<String>('user_id')!;
+
+    final manager = $$UserTableTableManager(
+      $_db,
+      $_db.user,
+    ).filter((f) => f.id.sqlEquals($_column));
+    final item = $_typedResult.readTableOrNull(_userIdTable($_db));
+    if (item == null) return manager;
+    return ProcessedTableManager(
+      manager.$state.copyWith(prefetchedData: [item]),
+    );
+  }
+
+  static $GroupTable _groupIdTable(_$AppDatabase db) => db.group.createAlias(
+    $_aliasNameGenerator(db.userGroup.groupId, db.group.id),
+  );
+
+  $$GroupTableProcessedTableManager get groupId {
+    final $_column = $_itemColumn<String>('group_id')!;
+
+    final manager = $$GroupTableTableManager(
+      $_db,
+      $_db.group,
+    ).filter((f) => f.id.sqlEquals($_column));
+    final item = $_typedResult.readTableOrNull(_groupIdTable($_db));
+    if (item == null) return manager;
+    return ProcessedTableManager(
+      manager.$state.copyWith(prefetchedData: [item]),
+    );
+  }
+}
+
+class $$UserGroupTableFilterComposer
+    extends Composer<_$AppDatabase, $UserGroupTable> {
+  $$UserGroupTableFilterComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  $$UserTableFilterComposer get userId {
+    final $$UserTableFilterComposer composer = $composerBuilder(
+      composer: this,
+      getCurrentColumn: (t) => t.userId,
+      referencedTable: $db.user,
+      getReferencedColumn: (t) => t.id,
+      builder:
+          (
+            joinBuilder, {
+            $addJoinBuilderToRootComposer,
+            $removeJoinBuilderFromRootComposer,
+          }) => $$UserTableFilterComposer(
+            $db: $db,
+            $table: $db.user,
+            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
+            joinBuilder: joinBuilder,
+            $removeJoinBuilderFromRootComposer:
+                $removeJoinBuilderFromRootComposer,
+          ),
+    );
+    return composer;
+  }
+
+  $$GroupTableFilterComposer get groupId {
+    final $$GroupTableFilterComposer composer = $composerBuilder(
+      composer: this,
+      getCurrentColumn: (t) => t.groupId,
+      referencedTable: $db.group,
+      getReferencedColumn: (t) => t.id,
+      builder:
+          (
+            joinBuilder, {
+            $addJoinBuilderToRootComposer,
+            $removeJoinBuilderFromRootComposer,
+          }) => $$GroupTableFilterComposer(
+            $db: $db,
+            $table: $db.group,
+            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
+            joinBuilder: joinBuilder,
+            $removeJoinBuilderFromRootComposer:
+                $removeJoinBuilderFromRootComposer,
+          ),
+    );
+    return composer;
+  }
+}
+
+class $$UserGroupTableOrderingComposer
+    extends Composer<_$AppDatabase, $UserGroupTable> {
+  $$UserGroupTableOrderingComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  $$UserTableOrderingComposer get userId {
+    final $$UserTableOrderingComposer composer = $composerBuilder(
+      composer: this,
+      getCurrentColumn: (t) => t.userId,
+      referencedTable: $db.user,
+      getReferencedColumn: (t) => t.id,
+      builder:
+          (
+            joinBuilder, {
+            $addJoinBuilderToRootComposer,
+            $removeJoinBuilderFromRootComposer,
+          }) => $$UserTableOrderingComposer(
+            $db: $db,
+            $table: $db.user,
+            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
+            joinBuilder: joinBuilder,
+            $removeJoinBuilderFromRootComposer:
+                $removeJoinBuilderFromRootComposer,
+          ),
+    );
+    return composer;
+  }
+
+  $$GroupTableOrderingComposer get groupId {
+    final $$GroupTableOrderingComposer composer = $composerBuilder(
+      composer: this,
+      getCurrentColumn: (t) => t.groupId,
+      referencedTable: $db.group,
+      getReferencedColumn: (t) => t.id,
+      builder:
+          (
+            joinBuilder, {
+            $addJoinBuilderToRootComposer,
+            $removeJoinBuilderFromRootComposer,
+          }) => $$GroupTableOrderingComposer(
+            $db: $db,
+            $table: $db.group,
+            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
+            joinBuilder: joinBuilder,
+            $removeJoinBuilderFromRootComposer:
+                $removeJoinBuilderFromRootComposer,
+          ),
+    );
+    return composer;
+  }
+}
+
+class $$UserGroupTableAnnotationComposer
+    extends Composer<_$AppDatabase, $UserGroupTable> {
+  $$UserGroupTableAnnotationComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  $$UserTableAnnotationComposer get userId {
+    final $$UserTableAnnotationComposer composer = $composerBuilder(
+      composer: this,
+      getCurrentColumn: (t) => t.userId,
+      referencedTable: $db.user,
+      getReferencedColumn: (t) => t.id,
+      builder:
+          (
+            joinBuilder, {
+            $addJoinBuilderToRootComposer,
+            $removeJoinBuilderFromRootComposer,
+          }) => $$UserTableAnnotationComposer(
+            $db: $db,
+            $table: $db.user,
+            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
+            joinBuilder: joinBuilder,
+            $removeJoinBuilderFromRootComposer:
+                $removeJoinBuilderFromRootComposer,
+          ),
+    );
+    return composer;
+  }
+
+  $$GroupTableAnnotationComposer get groupId {
+    final $$GroupTableAnnotationComposer composer = $composerBuilder(
+      composer: this,
+      getCurrentColumn: (t) => t.groupId,
+      referencedTable: $db.group,
+      getReferencedColumn: (t) => t.id,
+      builder:
+          (
+            joinBuilder, {
+            $addJoinBuilderToRootComposer,
+            $removeJoinBuilderFromRootComposer,
+          }) => $$GroupTableAnnotationComposer(
+            $db: $db,
+            $table: $db.group,
+            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
+            joinBuilder: joinBuilder,
+            $removeJoinBuilderFromRootComposer:
+                $removeJoinBuilderFromRootComposer,
+          ),
+    );
+    return composer;
+  }
+}
+
+class $$UserGroupTableTableManager
+    extends
+        RootTableManager<
+          _$AppDatabase,
+          $UserGroupTable,
+          UserGroupData,
+          $$UserGroupTableFilterComposer,
+          $$UserGroupTableOrderingComposer,
+          $$UserGroupTableAnnotationComposer,
+          $$UserGroupTableCreateCompanionBuilder,
+          $$UserGroupTableUpdateCompanionBuilder,
+          (UserGroupData, $$UserGroupTableReferences),
+          UserGroupData,
+          PrefetchHooks Function({bool userId, bool groupId})
+        > {
+  $$UserGroupTableTableManager(_$AppDatabase db, $UserGroupTable table)
+    : super(
+        TableManagerState(
+          db: db,
+          table: table,
+          createFilteringComposer: () =>
+              $$UserGroupTableFilterComposer($db: db, $table: table),
+          createOrderingComposer: () =>
+              $$UserGroupTableOrderingComposer($db: db, $table: table),
+          createComputedFieldComposer: () =>
+              $$UserGroupTableAnnotationComposer($db: db, $table: table),
+          updateCompanionCallback:
+              ({
+                Value<String> userId = const Value.absent(),
+                Value<String> groupId = const Value.absent(),
+                Value<int> rowid = const Value.absent(),
+              }) => UserGroupCompanion(
+                userId: userId,
+                groupId: groupId,
+                rowid: rowid,
+              ),
+          createCompanionCallback:
+              ({
+                required String userId,
+                required String groupId,
+                Value<int> rowid = const Value.absent(),
+              }) => UserGroupCompanion.insert(
+                userId: userId,
+                groupId: groupId,
+                rowid: rowid,
+              ),
+          withReferenceMapper: (p0) => p0
+              .map(
+                (e) => (
+                  e.readTable(table),
+                  $$UserGroupTableReferences(db, table, e),
+                ),
+              )
+              .toList(),
+          prefetchHooksCallback: ({userId = false, groupId = false}) {
+            return PrefetchHooks(
+              db: db,
+              explicitlyWatchedTables: [],
+              addJoins:
+                  <
+                    T extends TableManagerState<
+                      dynamic,
+                      dynamic,
+                      dynamic,
+                      dynamic,
+                      dynamic,
+                      dynamic,
+                      dynamic,
+                      dynamic,
+                      dynamic,
+                      dynamic,
+                      dynamic
+                    >
+                  >(state) {
+                    if (userId) {
+                      state =
+                          state.withJoin(
+                                currentTable: table,
+                                currentColumn: table.userId,
+                                referencedTable: $$UserGroupTableReferences
+                                    ._userIdTable(db),
+                                referencedColumn: $$UserGroupTableReferences
+                                    ._userIdTable(db)
+                                    .id,
+                              )
+                              as T;
+                    }
+                    if (groupId) {
+                      state =
+                          state.withJoin(
+                                currentTable: table,
+                                currentColumn: table.groupId,
+                                referencedTable: $$UserGroupTableReferences
+                                    ._groupIdTable(db),
+                                referencedColumn: $$UserGroupTableReferences
+                                    ._groupIdTable(db)
+                                    .id,
+                              )
+                              as T;
+                    }
+
+                    return state;
+                  },
+              getPrefetchedDataCallback: (items) async {
+                return [];
+              },
+            );
+          },
+        ),
+      );
+}
+
+typedef $$UserGroupTableProcessedTableManager =
+    ProcessedTableManager<
+      _$AppDatabase,
+      $UserGroupTable,
+      UserGroupData,
+      $$UserGroupTableFilterComposer,
+      $$UserGroupTableOrderingComposer,
+      $$UserGroupTableAnnotationComposer,
+      $$UserGroupTableCreateCompanionBuilder,
+      $$UserGroupTableUpdateCompanionBuilder,
+      (UserGroupData, $$UserGroupTableReferences),
+      UserGroupData,
+      PrefetchHooks Function({bool userId, bool groupId})
+    >;
+
+class $AppDatabaseManager {
+  final _$AppDatabase _db;
+  $AppDatabaseManager(this._db);
+  $$UserTableTableManager get user => $$UserTableTableManager(_db, _db.user);
+  $$GroupTableTableManager get group =>
+      $$GroupTableTableManager(_db, _db.group);
+  $$UserGroupTableTableManager get userGroup =>
+      $$UserGroupTableTableManager(_db, _db.userGroup);
+}
diff --git a/lib/data/methods/group.dart b/lib/data/methods/group.dart
new file mode 100644
index 0000000..a5346ba
--- /dev/null
+++ b/lib/data/methods/group.dart
@@ -0,0 +1,28 @@
+import 'package:game_tracker/data/database.dart';
+import 'package:drift/drift.dart';
+
+extension GroupMethods on AppDatabase {
+  Future<List<GroupData>> getAllGroups() async {
+    return await select(group).get();
+  }
+
+  Future<GroupData> getGroupById(String id) async {
+    return await (select(group)..where((g) => g.id.equals(id))).getSingle();
+  }
+
+  Future<void> addGroup(String id, String name) async {
+    await into(group).insert(
+      GroupCompanion.insert(id: id, name: name),
+    );
+  }
+
+  Future<void> deleteGroup(String id) async {
+    await (delete(group)..where((g) => g.id.equals(id))).go();
+  }
+
+  Future<void> updateGroupname(String id, String newName) async {
+    await (update(group)..where((g) => g.id.equals(id))).write(
+      GroupCompanion(name: Value(newName)),
+    );
+  }
+}
\ No newline at end of file
diff --git a/lib/data/methods/user.dart b/lib/data/methods/user.dart
new file mode 100644
index 0000000..6f4c508
--- /dev/null
+++ b/lib/data/methods/user.dart
@@ -0,0 +1,28 @@
+import 'package:game_tracker/data/database.dart';
+import 'package:drift/drift.dart';
+
+extension UserMethods on AppDatabase {
+  Future<List<UserData>> getAllUsers() async {
+    return await select(user).get();
+  }
+
+  Future<UserData> getUserById(String id) async {
+    return await (select(user)..where((u) => u.id.equals(id))).getSingle();
+  }
+
+  Future<void> addUser(String id, String name) async {
+    await into(user).insert(
+      UserCompanion.insert(id: id, name: name),
+    );
+  }
+
+  Future<void> deleteUser(String id) async {
+    await (delete(user)..where((u) => u.id.equals(id))).go();
+  }
+
+  Future<void> updateUsername(String id, String newName) async {
+    await (update(user)..where((u) => u.id.equals(id))).write(
+      UserCompanion(name: Value(newName)),
+    );
+  }
+}
\ No newline at end of file
diff --git a/lib/data/methods/user_group.dart b/lib/data/methods/user_group.dart
new file mode 100644
index 0000000..206c1f0
--- /dev/null
+++ b/lib/data/methods/user_group.dart
@@ -0,0 +1,26 @@
+import 'package:game_tracker/data/database.dart';
+import 'package:drift/drift.dart';
+
+extension UserGroupMethods on AppDatabase {
+  Future<List<UserGroupData>> getAllUsersAndGroups() async {
+    return await select(userGroup).get();
+  }
+
+  Future<List<UserGroupData>> getUsersGroups(String userId) async {
+    return await (select(userGroup)..where((uG) => uG.userId.equals(userId))).get();
+  }
+
+  Future<List<UserGroupData>> getGroupsUsers(String groupId) async {
+    return await (select(userGroup)..where((uG) => uG.groupId.equals(groupId))).get();
+  }
+
+  Future<void> addUserToGroup(String userId, String groupId) async {
+    await into(userGroup).insert(
+      UserGroupCompanion.insert(userId: userId, groupId: groupId),
+    );
+  }
+
+  Future<void> removeUserFromGroup(String userId, String groupId) async {
+    await (delete(userGroup)..where((uG) => uG.userId.equals(userId) & uG.groupId.equals(groupId))).go();
+  }
+}
\ No newline at end of file
diff --git a/lib/main.dart b/lib/main.dart
index 1188332..e3f8a91 100644
--- a/lib/main.dart
+++ b/lib/main.dart
@@ -1,8 +1,16 @@
 import 'package:flutter/material.dart';
+import 'package:game_tracker/data/database.dart';
 import 'package:game_tracker/presentation/views/home_view.dart';
+import 'package:provider/provider.dart';
 
 void main() {
-  runApp(const MyApp());
+  runApp(
+    Provider<AppDatabase>(
+      create: (context) => AppDatabase(),
+      child: const MyApp(),
+      dispose: (context, db) => db.close(),
+   ),
+  );
 }
 
 class MyApp extends StatelessWidget {
diff --git a/pubspec.yaml b/pubspec.yaml
index aa5fa8a..b539585 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -34,6 +34,10 @@ dependencies:
   # The following adds the Cupertino Icons font to your application.
   # Use with the CupertinoIcons class for iOS style icons.
   cupertino_icons: ^1.0.8
+  drift: ^2.27.0
+  drift_flutter: ^0.2.4
+  path_provider: ^2.1.5
+  provider: ^6.1.5
 
 dev_dependencies:
   flutter_test:
@@ -45,6 +49,8 @@ dev_dependencies:
   # package. See that file for information about deactivating specific lint
   # rules and activating additional ones.
   flutter_lints: ^5.0.0
+  drift_dev: ^2.27.0
+  build_runner: ^2.5.4
 
 # For information on the generic Dart part of this file, see the
 # following page: https://dart.dev/tools/pub/pubspec