functions/api/lib/team/team_service.dart

-import 'dart:async';
-
-import 'package:api/team/appwrite_user.dart';
-import 'package:api/team/membership.dart';
-import 'package:api/team/team.dart';
-import 'package:dart_appwrite/dart_appwrite.dart';
-import 'package:lib/lib.dart';
-
-class TeamService extends ClientFunction {
-  late final Teams _teams;
-  late final Users _users;
-
-  TeamService({required super.host, required super.projectId, required super.apiKey}) {
-    _teams = Teams(client);
-    _users = Users(client);
-  }
-
-  Stream<Team> getTeamsOfUser(String userId) async* {
-    var memberships = (await _users.listMemberships(userId: userId)).memberships;
-
-    for (var membership in memberships) {
-      yield await getTeam(membership.teamId);
-    }
-  }
-
-  Future<Team> getTeam(String teamId) async {
-    var team = await _teams.get(teamId: teamId);
-    var teamMemberships = (await _teams.listMemberships(teamId: team.$id)).memberships;
-
-    return Team(
-      teamId: team.$id,
-      teamName: team.name,
-      memberships: await Stream.fromFutures(teamMemberships.map((e) async => Membership(
-        joinedAt: DateTime.parse(e.joined),
-        user: await _getAppwriteUser(e.userId),
-      ))).toList(),
-    );
-  }
-
-  Future<AppwriteUser> _getAppwriteUser(String userId) async {
-    var user = await _users.get(userId: userId);
-    
-    return AppwriteUser(
-      id: user.$id,
-      email: user.email,
-      name: user.name,
-      isEnabled: user.status,
-    );
-  }
-}

lib/lib/lib.dart

@@ -18,3 +18,4 @@ export 'src/interface/api_endpoint.dart';
 export 'src/db_api_endpoint.dart';
 export 'src/exceptions/db_action_forbidden.dart';
 export 'src/converter/list_response/list_to_response_converter.dart';
+export 'src/checked_db_api_endpoint.dart';

lib/lib/src/checked_db_api_endpoint.dart

+import 'package:lib/src/db_api_endpoint.dart';
+import 'package:lib/src/exceptions/id_null.dart';
+import 'package:lib/src/exceptions/unauthorized.dart';
+import 'package:lib/src/interface/db_model.dart';
+
+class CheckedDbApiEndpoint<T extends DbModel, T1> extends DbApiEndpoint<T, T1> {
+  final Future<bool> Function(T)? createItemAllowed;
+  final Future<bool> Function(T1)? getItemAllowed;
+  final Future<bool> Function(T, T1)? updateItemAllowed;
+  final Future<bool> Function(T1)? deleteItemAllowed;
+  final bool allowActionsPerDefault;
+
+  CheckedDbApiEndpoint({
+    required super.database,
+    required super.itemFromRequest,
+    required super.itemToResponse,
+    this.createItemAllowed,
+    this.getItemAllowed,
+    this.updateItemAllowed,
+    this.deleteItemAllowed,
+    this.allowActionsPerDefault = false,
+  });
+
+  @override
+  Future<T1> create(T item) async {
+    await checkAndThrowIfNecessary(createItemAllowed, item);
+    return super.create(item);
+  }
+
+  @override
+  Future<T1> update(T item) async {
+    if(item.id == null) {
+      throw IdNullException(item);
+    }
+
+    var originalItem = await super.getFromId(item.id!);
+    await checkAndThrowIfNecessary(updateCheck(item, originalItem), item);
+
+    return super.update(item);
+  }
+
+  @override
+  Future<T1> delete(String id) async {
+    var item = await super.getFromId(id);
+    await checkAndThrowIfNecessary(deleteItemAllowed, item);
+
+    return super.delete(id);
+  }
+
+  @override
+  Future<T1> getFromId(String id) async {
+    var item = await super.getFromId(id);
+    await checkAndThrowIfNecessary(getItemAllowed, item);
+
+    return item;
+  }
+
+  @override
+  Stream<T1> getFromQueries(Iterable<String> queries) async* {
+    await for (var item in super.getFromQueries(queries)) {
+      if(await checkIfAllowed(getItemAllowed, item)) {
+        yield item;
+      }
+    }
+  }
+
+  @override
+  Stream<T1> getAll() async* {
+    await for (var item in super.getAll()) {
+      if(await checkIfAllowed(getItemAllowed, item)) {
+        yield item;
+      }
+    }
+  }
+
+  Future<void> checkAndThrowIfNecessary<T2>(Future<bool> Function(T2)? check, T2 item) async {
+    if(!await checkIfAllowed(check, item)) {
+      throw UnauthorizedException();
+    }
+  }
+
+  Future<bool> checkIfAllowed<T2>(Future<bool> Function(T2)? check, T2 item) {
+    if(check != null) {
+      return check(item);
+    }
+
+    return Future.value(allowActionsPerDefault);
+  }
+
+  Future<bool> Function(T)? updateCheck(T item, T1 originalItem) {
+    if(updateItemAllowed != null) {
+      return (item) => updateItemAllowed!(item, originalItem);
+    }
+    return null;
+  }
+}