| library syncbase_client; |
| |
| import 'dart:async'; |
| import 'dart:typed_data' show Uint8List; |
| |
| import 'package:mojo/application.dart' show Application; |
| |
| import 'gen/dart-gen/mojom/lib/mojo/syncbase.mojom.dart' as mojom; |
| |
| // Export struct types from syncbase.mojom. |
| export 'gen/dart-gen/mojom/lib/mojo/syncbase.mojom.dart' |
| show BatchOptions, ExecStream, Perms, ScanStream, SyncGroupMemberInfo, SyncGroupSpec; |
| |
| bool isError(mojom.Error err) { |
| return err != null && err.id != ''; |
| } |
| |
| class SyncbaseClient { |
| final Application _app; |
| final mojom.SyncbaseProxy _proxy; |
| final String url; |
| |
| SyncbaseClient(this._app, this.url) : _proxy = new mojom.SyncbaseProxy.unbound() { |
| print('connecting to $url'); |
| _app.connectToService(url, _proxy); |
| print('connected'); |
| } |
| |
| Future close({bool immediate: false}) { |
| return _proxy.close(); |
| } |
| |
| // TODO(nlacasse): Break this SyncbaseClient class into multiple classes, one |
| // for each level. |
| |
| // TODO(nlacasse): Write some tests for this interface once syncbase runs as |
| // a mojo service. Currently we rely on dartanalyzer for correctness. |
| |
| //////////////////////////////////////// |
| // Service |
| |
| Future<mojom.Perms> serviceGetPermissions() async { |
| mojom.SyncbaseServiceGetPermissionsResponseParams v = await _proxy.ptr.serviceGetPermissions(); |
| if (isError(v.err)) throw v.err; |
| |
| // TODO(nlacasse): We need to return the version too. Create a struct type |
| // that combines perms and version? |
| return v.perms; |
| } |
| |
| Future serviceSetPermissions(mojom.Perms perms, String version) async { |
| mojom.SyncbaseServiceSetPermissionsResponseParams v = await _proxy.ptr.serviceSetPermissions(perms, version); |
| if (isError(v.err)) throw v.err; |
| return; |
| } |
| |
| //////////////////////////////////////// |
| // App |
| |
| Future appCreate(String name, mojom.Perms perms) async { |
| mojom.SyncbaseAppCreateResponseParams v = await _proxy.ptr.appCreate(name, perms); |
| if (isError(v.err)) throw v.err; |
| return; |
| } |
| |
| Future appDelete(String name) async { |
| mojom.SyncbaseAppDeleteResponseParams v = await _proxy.ptr.appDelete(name); |
| if (isError(v.err)) throw v.err; |
| return; |
| } |
| |
| Future<bool> appExists(String name) async { |
| mojom.SyncbaseAppExistsResponseParams v = await _proxy.ptr.appExists(name); |
| if (isError(v.err)) throw v.err; |
| return v.exists; |
| } |
| |
| Future<mojom.Perms> appGetPermissions(String name) async { |
| mojom.SyncbaseAppGetPermissionsResponseParams v = await _proxy.ptr.appGetPermissions(name); |
| if (isError(v.err)) throw v.err; |
| |
| // TODO(nlacasse): We need to return the version too. Create a struct type |
| // that combines perms and version? |
| return v.perms; |
| } |
| |
| Future appSetPermissions(String name, mojom.Perms perms, String version) async { |
| mojom.SyncbaseAppSetPermissionsResponseParams v = await _proxy.ptr.appSetPermissions(name, perms, version); |
| if (isError(v.err)) throw v.err; |
| return; |
| } |
| |
| //////////////////////////////////////// |
| // nosql.Database |
| |
| Future dbCreate(String name, mojom.Perms perms) async { |
| mojom.SyncbaseDbCreateResponseParams v = await _proxy.ptr.dbCreate(name, perms); |
| if (isError(v.err)) throw v.err; |
| return; |
| } |
| |
| Future dbDelete(String name) async { |
| mojom.SyncbaseDbDeleteResponseParams v = await _proxy.ptr.dbDelete(name); |
| if (isError(v.err)) throw v.err; |
| return; |
| } |
| |
| Future<bool> dbExists(String name) async { |
| mojom.SyncbaseDbExistsResponseParams v = await _proxy.ptr.dbExists(name); |
| if (isError(v.err)) throw v.err; |
| return v.exists; |
| } |
| |
| Future dbExec(String name, String query, mojom.ExecStream stream) async { |
| mojom.SyncbaseDbExecResponseParams v = await _proxy.ptr.dbExec(name, query, stream); |
| if (isError(v.err)) throw v.err; |
| return; |
| } |
| |
| Future<mojom.Perms> dbGetPermissions(String name) async { |
| mojom.SyncbaseDbGetPermissionsResponseParams v = await _proxy.ptr.dbGetPermissions(name); |
| if (isError(v.err)) throw v.err; |
| |
| // TODO(nlacasse): We need to return the version too. Create a struct type |
| // that combines perms and version? |
| return v.perms; |
| } |
| |
| Future<String> dbBeginBatch(String name, mojom.BatchOptions opts) async { |
| mojom.SyncbaseDbBeginBatchResponseParams v = await _proxy.ptr.dbBeginBatch(name, opts); |
| if (isError(v.err)) throw v.err; |
| return v.batchDn; |
| } |
| |
| Future dbCommit(String name) async { |
| mojom.SyncbaseDbCommitResponseParams v = await _proxy.ptr.dbCommit(name); |
| if (isError(v.err)) throw v.err; |
| return; |
| } |
| |
| Future dbAbort(String name) async { |
| mojom.SyncbaseDbAbortResponseParams v = await _proxy.ptr.dbAbort(name); |
| if (isError(v.err)) throw v.err; |
| return; |
| } |
| |
| Future dbSetPermissions(String name, mojom.Perms perms, String version) async { |
| mojom.SyncbaseDbSetPermissionsResponseParams v = await _proxy.ptr.dbSetPermissions(name, perms, version); |
| if (isError(v.err)) throw v.err; |
| return; |
| } |
| |
| //////////////////////////////////////// |
| // nosql.Database:SyncGroupManager |
| |
| Future<List<String>> dbGetSyncGroupNames(String name) async { |
| mojom.SyncbaseDbGetSyncGroupNamesResponseParams v = await _proxy.ptr.dbGetSyncGroupNames(name); |
| if (isError(v.err)) throw v.err; |
| return v.names; |
| } |
| |
| Future dbCreateSyncGroup( |
| String name, String sgName, mojom.SyncGroupSpec spec, mojom.SyncGroupMemberInfo myInfo) async { |
| mojom.SyncbaseDbCreateSyncGroupResponseParams v = await _proxy.ptr.dbCreateSyncGroup(name, sgName, spec, myInfo); |
| if (isError(v.err)) throw v.err; |
| return; |
| } |
| |
| Future dbJoinSyncGroup(String name, String sgName, mojom.SyncGroupMemberInfo myInfo) async { |
| mojom.SyncbaseDbJoinSyncGroupResponseParams v = await _proxy.ptr.dbJoinSyncGroup(name, sgName, myInfo); |
| if (isError(v.err)) throw v.err; |
| return; |
| } |
| |
| Future dbLeaveSyncGroup(String name, String sgName) async { |
| mojom.SyncbaseDbLeaveSyncGroupResponseParams v = await _proxy.ptr.dbLeaveSyncGroup(name, sgName); |
| if (isError(v.err)) throw v.err; |
| return; |
| } |
| |
| Future dbDestroySyncGroup(String name, String sgName) async { |
| mojom.SyncbaseDbDestroySyncGroupResponseParams v = await _proxy.ptr.dbDestroySyncGroup(name, sgName); |
| if (isError(v.err)) throw v.err; |
| return; |
| } |
| |
| Future dbEjectFromSyncGroup(String name, String sgName, String memberName) async { |
| mojom.SyncbaseDbEjectFromSyncGroupResponseParams v = |
| await _proxy.ptr.dbEjectFromSyncGroup(name, sgName, memberName); |
| if (isError(v.err)) throw v.err; |
| return; |
| } |
| |
| Future<mojom.SyncGroupSpec> dbGetSyncGroupSpec(String name, String sgName) async { |
| mojom.SyncbaseDbGetSyncGroupSpecResponseParams v = await _proxy.ptr.dbGetSyncGroupSpec(name, sgName); |
| if (isError(v.err)) throw v.err; |
| |
| // TODO(nlacasse): We need to return the version too. Create a struct type |
| // that combines spec and version? |
| return v.spec; |
| } |
| |
| Future dbSetSyncGroupSpec(String name, String sgName, mojom.SyncGroupSpec spec, String version) async { |
| mojom.SyncbaseDbSetSyncGroupSpecResponseParams v = await _proxy.ptr.dbSetSyncGroupSpec(name, sgName, spec, version); |
| if (isError(v.err)) throw v.err; |
| return; |
| } |
| |
| Future<Map<String, mojom.SyncGroupMemberInfo>> dbGetSyncGroupMembers(String name, String sgName) async { |
| mojom.SyncbaseDbGetSyncGroupMembersResponseParams v = await _proxy.ptr.dbGetSyncGroupMembers(name, sgName); |
| if (isError(v.err)) throw v.err; |
| return v.infos; |
| } |
| |
| //////////////////////////////////////// |
| // nosql.Table |
| |
| Future tableCreate(String name, mojom.Perms perms) async { |
| mojom.SyncbaseTableCreateResponseParams v = await _proxy.ptr.tableCreate(name, perms); |
| if (isError(v.err)) throw v.err; |
| return; |
| } |
| |
| Future tableDelete(String name) async { |
| mojom.SyncbaseTableDeleteResponseParams v = await _proxy.ptr.tableDelete(name); |
| if (isError(v.err)) throw v.err; |
| return; |
| } |
| |
| Future<bool> tableExists(String name) async { |
| mojom.SyncbaseTableExistsResponseParams v = await _proxy.ptr.tableExists(name); |
| if (isError(v.err)) throw v.err; |
| return v.exists; |
| } |
| |
| Future tableDeleteRowRange(String name, Uint8List start, Uint8List limit) async { |
| mojom.SyncbaseTableDeleteRowRangeResponseParams v = await _proxy.ptr.tableDeleteRowRange(name, start, limit); |
| if (isError(v.err)) throw v.err; |
| return; |
| } |
| |
| Future tableScan(String name, Uint8List start, Uint8List limit, mojom.ScanStream stream) async { |
| mojom.SyncbaseTableScanResponseParams v = await _proxy.ptr.tableScan(name, start, limit, stream); |
| if (isError(v.err)) throw v.err; |
| return; |
| } |
| |
| Future<List<mojom.PrefixPerms>> tableGetPermissions(String name, String key) async { |
| mojom.SyncbaseTableGetPermissionsResponseParams v = await _proxy.ptr.tableGetPermissions(name, key); |
| if (isError(v.err)) throw v.err; |
| return v.permsArr; |
| } |
| |
| Future tableSetPermissions(String name, String prefix, mojom.Perms perms) async { |
| mojom.SyncbaseTableSetPermissionsResponseParams v = await _proxy.ptr.tableSetPermissions(name, prefix, perms); |
| if (isError(v.err)) throw v.err; |
| return; |
| } |
| |
| Future tableDeletePermissions(String name, String prefix) async { |
| mojom.SyncbaseTableDeletePermissionsResponseParams v = await _proxy.ptr.tableDeletePermissions(name, prefix); |
| if (isError(v.err)) throw v.err; |
| return; |
| } |
| |
| //////////////////////////////////////// |
| // nosql.Row |
| |
| Future<bool> rowExists(String name) async { |
| mojom.SyncbaseRowExistsResponseParams v = await _proxy.ptr.rowExists(name); |
| if (isError(v.err)) throw v.err; |
| return v.exists; |
| } |
| |
| Future<Uint8List> rowGet(String name) async { |
| mojom.SyncbaseRowGetResponseParams v = await _proxy.ptr.rowGet(name); |
| if (isError(v.err)) throw v.err; |
| return v.value; |
| } |
| |
| Future rowPut(String name, Uint8List value) async { |
| mojom.SyncbaseRowPutResponseParams v = await _proxy.ptr.rowPut(name, value); |
| if (isError(v.err)) throw v.err; |
| return; |
| } |
| |
| Future rowDelete(String name) async { |
| mojom.SyncbaseRowDeleteResponseParams v = await _proxy.ptr.rowDelete(name); |
| if (isError(v.err)) throw v.err; |
| return; |
| } |
| } |