diff --git a/.idea/appflowy_client.iml b/.idea/appflowy_client.iml index d20a79f9a5..68470141ae 100644 --- a/.idea/appflowy_client.iml +++ b/.idea/appflowy_client.iml @@ -60,6 +60,9 @@ + + + diff --git a/.idea/libraries/Dart_Packages.xml b/.idea/libraries/Dart_Packages.xml index de18681fa8..6cdeb161e3 100644 --- a/.idea/libraries/Dart_Packages.xml +++ b/.idea/libraries/Dart_Packages.xml @@ -280,6 +280,7 @@ @@ -738,6 +739,7 @@ @@ -759,6 +761,7 @@ @@ -766,6 +769,7 @@ @@ -902,6 +906,7 @@ + @@ -970,10 +975,13 @@ + + + diff --git a/app_flowy/packages/flowy_sdk/lib/protobuf.dart b/app_flowy/packages/flowy_sdk/lib/protobuf.dart index 3e2e25e5fb..020e7a672f 100644 --- a/app_flowy/packages/flowy_sdk/lib/protobuf.dart +++ b/app_flowy/packages/flowy_sdk/lib/protobuf.dart @@ -1,7 +1,9 @@ // Auto-generated, do not edit +export 'protobuf/kv.pb.dart'; export 'protobuf/ffi_response.pb.dart'; export 'protobuf/ffi_request.pb.dart'; export 'protobuf/sign_up.pb.dart'; export 'protobuf/sign_in.pb.dart'; +export 'protobuf/user_table.pb.dart'; export 'protobuf/event.pb.dart'; export 'protobuf/user.pb.dart'; diff --git a/app_flowy/packages/flowy_sdk/lib/protobuf/kv.pb.dart b/app_flowy/packages/flowy_sdk/lib/protobuf/kv.pb.dart new file mode 100644 index 0000000000..799b02d7d4 --- /dev/null +++ b/app_flowy/packages/flowy_sdk/lib/protobuf/kv.pb.dart @@ -0,0 +1,214 @@ +/// +// Generated code. Do not modify. +// source: kv.proto +// +// @dart = 2.12 +// ignore_for_file: annotate_overrides,camel_case_types,unnecessary_const,non_constant_identifier_names,library_prefixes,unused_import,unused_shown_name,return_of_invalid_type,unnecessary_this,prefer_final_fields + +import 'dart:core' as $core; + +import 'package:fixnum/fixnum.dart' as $fixnum; +import 'package:protobuf/protobuf.dart' as $pb; + +enum KeyValue_OneOfStrValue { + strValue, + notSet +} + +enum KeyValue_OneOfIntValue { + intValue, + notSet +} + +enum KeyValue_OneOfFloatValue { + floatValue, + notSet +} + +enum KeyValue_OneOfBoolValue { + boolValue, + notSet +} + +class KeyValue extends $pb.GeneratedMessage { + static const $core.Map<$core.int, KeyValue_OneOfStrValue> _KeyValue_OneOfStrValueByTag = { + 2 : KeyValue_OneOfStrValue.strValue, + 0 : KeyValue_OneOfStrValue.notSet + }; + static const $core.Map<$core.int, KeyValue_OneOfIntValue> _KeyValue_OneOfIntValueByTag = { + 3 : KeyValue_OneOfIntValue.intValue, + 0 : KeyValue_OneOfIntValue.notSet + }; + static const $core.Map<$core.int, KeyValue_OneOfFloatValue> _KeyValue_OneOfFloatValueByTag = { + 4 : KeyValue_OneOfFloatValue.floatValue, + 0 : KeyValue_OneOfFloatValue.notSet + }; + static const $core.Map<$core.int, KeyValue_OneOfBoolValue> _KeyValue_OneOfBoolValueByTag = { + 5 : KeyValue_OneOfBoolValue.boolValue, + 0 : KeyValue_OneOfBoolValue.notSet + }; + static final $pb.BuilderInfo _i = $pb.BuilderInfo(const $core.bool.fromEnvironment('protobuf.omit_message_names') ? '' : 'KeyValue', createEmptyInstance: create) + ..oo(0, [2]) + ..oo(1, [3]) + ..oo(2, [4]) + ..oo(3, [5]) + ..aOS(1, const $core.bool.fromEnvironment('protobuf.omit_field_names') ? '' : 'key') + ..aOS(2, const $core.bool.fromEnvironment('protobuf.omit_field_names') ? '' : 'strValue') + ..aInt64(3, const $core.bool.fromEnvironment('protobuf.omit_field_names') ? '' : 'intValue') + ..a<$core.double>(4, const $core.bool.fromEnvironment('protobuf.omit_field_names') ? '' : 'floatValue', $pb.PbFieldType.OD) + ..aOB(5, const $core.bool.fromEnvironment('protobuf.omit_field_names') ? '' : 'boolValue') + ..hasRequiredFields = false + ; + + KeyValue._() : super(); + factory KeyValue({ + $core.String? key, + $core.String? strValue, + $fixnum.Int64? intValue, + $core.double? floatValue, + $core.bool? boolValue, + }) { + final _result = create(); + if (key != null) { + _result.key = key; + } + if (strValue != null) { + _result.strValue = strValue; + } + if (intValue != null) { + _result.intValue = intValue; + } + if (floatValue != null) { + _result.floatValue = floatValue; + } + if (boolValue != null) { + _result.boolValue = boolValue; + } + return _result; + } + factory KeyValue.fromBuffer($core.List<$core.int> i, [$pb.ExtensionRegistry r = $pb.ExtensionRegistry.EMPTY]) => create()..mergeFromBuffer(i, r); + factory KeyValue.fromJson($core.String i, [$pb.ExtensionRegistry r = $pb.ExtensionRegistry.EMPTY]) => create()..mergeFromJson(i, r); + @$core.Deprecated( + 'Using this can add significant overhead to your binary. ' + 'Use [GeneratedMessageGenericExtensions.deepCopy] instead. ' + 'Will be removed in next major version') + KeyValue clone() => KeyValue()..mergeFromMessage(this); + @$core.Deprecated( + 'Using this can add significant overhead to your binary. ' + 'Use [GeneratedMessageGenericExtensions.rebuild] instead. ' + 'Will be removed in next major version') + KeyValue copyWith(void Function(KeyValue) updates) => super.copyWith((message) => updates(message as KeyValue)) as KeyValue; // ignore: deprecated_member_use + $pb.BuilderInfo get info_ => _i; + @$core.pragma('dart2js:noInline') + static KeyValue create() => KeyValue._(); + KeyValue createEmptyInstance() => create(); + static $pb.PbList createRepeated() => $pb.PbList(); + @$core.pragma('dart2js:noInline') + static KeyValue getDefault() => _defaultInstance ??= $pb.GeneratedMessage.$_defaultFor(create); + static KeyValue? _defaultInstance; + + KeyValue_OneOfStrValue whichOneOfStrValue() => _KeyValue_OneOfStrValueByTag[$_whichOneof(0)]!; + void clearOneOfStrValue() => clearField($_whichOneof(0)); + + KeyValue_OneOfIntValue whichOneOfIntValue() => _KeyValue_OneOfIntValueByTag[$_whichOneof(1)]!; + void clearOneOfIntValue() => clearField($_whichOneof(1)); + + KeyValue_OneOfFloatValue whichOneOfFloatValue() => _KeyValue_OneOfFloatValueByTag[$_whichOneof(2)]!; + void clearOneOfFloatValue() => clearField($_whichOneof(2)); + + KeyValue_OneOfBoolValue whichOneOfBoolValue() => _KeyValue_OneOfBoolValueByTag[$_whichOneof(3)]!; + void clearOneOfBoolValue() => clearField($_whichOneof(3)); + + @$pb.TagNumber(1) + $core.String get key => $_getSZ(0); + @$pb.TagNumber(1) + set key($core.String v) { $_setString(0, v); } + @$pb.TagNumber(1) + $core.bool hasKey() => $_has(0); + @$pb.TagNumber(1) + void clearKey() => clearField(1); + + @$pb.TagNumber(2) + $core.String get strValue => $_getSZ(1); + @$pb.TagNumber(2) + set strValue($core.String v) { $_setString(1, v); } + @$pb.TagNumber(2) + $core.bool hasStrValue() => $_has(1); + @$pb.TagNumber(2) + void clearStrValue() => clearField(2); + + @$pb.TagNumber(3) + $fixnum.Int64 get intValue => $_getI64(2); + @$pb.TagNumber(3) + set intValue($fixnum.Int64 v) { $_setInt64(2, v); } + @$pb.TagNumber(3) + $core.bool hasIntValue() => $_has(2); + @$pb.TagNumber(3) + void clearIntValue() => clearField(3); + + @$pb.TagNumber(4) + $core.double get floatValue => $_getN(3); + @$pb.TagNumber(4) + set floatValue($core.double v) { $_setDouble(3, v); } + @$pb.TagNumber(4) + $core.bool hasFloatValue() => $_has(3); + @$pb.TagNumber(4) + void clearFloatValue() => clearField(4); + + @$pb.TagNumber(5) + $core.bool get boolValue => $_getBF(4); + @$pb.TagNumber(5) + set boolValue($core.bool v) { $_setBool(4, v); } + @$pb.TagNumber(5) + $core.bool hasBoolValue() => $_has(4); + @$pb.TagNumber(5) + void clearBoolValue() => clearField(5); +} + +class KeyValueQuery extends $pb.GeneratedMessage { + static final $pb.BuilderInfo _i = $pb.BuilderInfo(const $core.bool.fromEnvironment('protobuf.omit_message_names') ? '' : 'KeyValueQuery', createEmptyInstance: create) + ..aOS(1, const $core.bool.fromEnvironment('protobuf.omit_field_names') ? '' : 'key') + ..hasRequiredFields = false + ; + + KeyValueQuery._() : super(); + factory KeyValueQuery({ + $core.String? key, + }) { + final _result = create(); + if (key != null) { + _result.key = key; + } + return _result; + } + factory KeyValueQuery.fromBuffer($core.List<$core.int> i, [$pb.ExtensionRegistry r = $pb.ExtensionRegistry.EMPTY]) => create()..mergeFromBuffer(i, r); + factory KeyValueQuery.fromJson($core.String i, [$pb.ExtensionRegistry r = $pb.ExtensionRegistry.EMPTY]) => create()..mergeFromJson(i, r); + @$core.Deprecated( + 'Using this can add significant overhead to your binary. ' + 'Use [GeneratedMessageGenericExtensions.deepCopy] instead. ' + 'Will be removed in next major version') + KeyValueQuery clone() => KeyValueQuery()..mergeFromMessage(this); + @$core.Deprecated( + 'Using this can add significant overhead to your binary. ' + 'Use [GeneratedMessageGenericExtensions.rebuild] instead. ' + 'Will be removed in next major version') + KeyValueQuery copyWith(void Function(KeyValueQuery) updates) => super.copyWith((message) => updates(message as KeyValueQuery)) as KeyValueQuery; // ignore: deprecated_member_use + $pb.BuilderInfo get info_ => _i; + @$core.pragma('dart2js:noInline') + static KeyValueQuery create() => KeyValueQuery._(); + KeyValueQuery createEmptyInstance() => create(); + static $pb.PbList createRepeated() => $pb.PbList(); + @$core.pragma('dart2js:noInline') + static KeyValueQuery getDefault() => _defaultInstance ??= $pb.GeneratedMessage.$_defaultFor(create); + static KeyValueQuery? _defaultInstance; + + @$pb.TagNumber(1) + $core.String get key => $_getSZ(0); + @$pb.TagNumber(1) + set key($core.String v) { $_setString(0, v); } + @$pb.TagNumber(1) + $core.bool hasKey() => $_has(0); + @$pb.TagNumber(1) + void clearKey() => clearField(1); +} + diff --git a/app_flowy/packages/flowy_sdk/lib/protobuf/kv.pbenum.dart b/app_flowy/packages/flowy_sdk/lib/protobuf/kv.pbenum.dart new file mode 100644 index 0000000000..79c2244e07 --- /dev/null +++ b/app_flowy/packages/flowy_sdk/lib/protobuf/kv.pbenum.dart @@ -0,0 +1,7 @@ +/// +// Generated code. Do not modify. +// source: kv.proto +// +// @dart = 2.12 +// ignore_for_file: annotate_overrides,camel_case_types,unnecessary_const,non_constant_identifier_names,library_prefixes,unused_import,unused_shown_name,return_of_invalid_type,unnecessary_this,prefer_final_fields + diff --git a/app_flowy/packages/flowy_sdk/lib/protobuf/kv.pbjson.dart b/app_flowy/packages/flowy_sdk/lib/protobuf/kv.pbjson.dart new file mode 100644 index 0000000000..18b6a90598 --- /dev/null +++ b/app_flowy/packages/flowy_sdk/lib/protobuf/kv.pbjson.dart @@ -0,0 +1,32 @@ +/// +// Generated code. Do not modify. +// source: kv.proto +// +// @dart = 2.12 +// ignore_for_file: annotate_overrides,camel_case_types,unnecessary_const,non_constant_identifier_names,library_prefixes,unused_import,unused_shown_name,return_of_invalid_type,unnecessary_this,prefer_final_fields + +import 'dart:core' as $core; +const KeyValue$json = const { + '1': 'KeyValue', + '2': const [ + const {'1': 'key', '3': 1, '4': 1, '5': 9, '10': 'key'}, + const {'1': 'str_value', '3': 2, '4': 1, '5': 9, '9': 0, '10': 'strValue'}, + const {'1': 'int_value', '3': 3, '4': 1, '5': 3, '9': 1, '10': 'intValue'}, + const {'1': 'float_value', '3': 4, '4': 1, '5': 1, '9': 2, '10': 'floatValue'}, + const {'1': 'bool_value', '3': 5, '4': 1, '5': 8, '9': 3, '10': 'boolValue'}, + ], + '8': const [ + const {'1': 'one_of_str_value'}, + const {'1': 'one_of_int_value'}, + const {'1': 'one_of_float_value'}, + const {'1': 'one_of_bool_value'}, + ], +}; + +const KeyValueQuery$json = const { + '1': 'KeyValueQuery', + '2': const [ + const {'1': 'key', '3': 1, '4': 1, '5': 9, '10': 'key'}, + ], +}; + diff --git a/app_flowy/packages/flowy_sdk/lib/protobuf/kv.pbserver.dart b/app_flowy/packages/flowy_sdk/lib/protobuf/kv.pbserver.dart new file mode 100644 index 0000000000..5698403d05 --- /dev/null +++ b/app_flowy/packages/flowy_sdk/lib/protobuf/kv.pbserver.dart @@ -0,0 +1,9 @@ +/// +// Generated code. Do not modify. +// source: kv.proto +// +// @dart = 2.12 +// ignore_for_file: annotate_overrides,camel_case_types,unnecessary_const,non_constant_identifier_names,library_prefixes,unused_import,unused_shown_name,return_of_invalid_type,unnecessary_this,prefer_final_fields + +export 'kv.pb.dart'; + diff --git a/app_flowy/packages/flowy_sdk/lib/protobuf/user_table.pb.dart b/app_flowy/packages/flowy_sdk/lib/protobuf/user_table.pb.dart new file mode 100644 index 0000000000..97f85fa415 --- /dev/null +++ b/app_flowy/packages/flowy_sdk/lib/protobuf/user_table.pb.dart @@ -0,0 +1,100 @@ +/// +// Generated code. Do not modify. +// source: user_table.proto +// +// @dart = 2.12 +// ignore_for_file: annotate_overrides,camel_case_types,unnecessary_const,non_constant_identifier_names,library_prefixes,unused_import,unused_shown_name,return_of_invalid_type,unnecessary_this,prefer_final_fields + +import 'dart:core' as $core; + +import 'package:protobuf/protobuf.dart' as $pb; + +class User extends $pb.GeneratedMessage { + static final $pb.BuilderInfo _i = $pb.BuilderInfo(const $core.bool.fromEnvironment('protobuf.omit_message_names') ? '' : 'User', createEmptyInstance: create) + ..aOS(1, const $core.bool.fromEnvironment('protobuf.omit_field_names') ? '' : 'id') + ..aOS(2, const $core.bool.fromEnvironment('protobuf.omit_field_names') ? '' : 'name') + ..aOS(3, const $core.bool.fromEnvironment('protobuf.omit_field_names') ? '' : 'email') + ..aOS(4, const $core.bool.fromEnvironment('protobuf.omit_field_names') ? '' : 'password') + ..hasRequiredFields = false + ; + + User._() : super(); + factory User({ + $core.String? id, + $core.String? name, + $core.String? email, + $core.String? password, + }) { + final _result = create(); + if (id != null) { + _result.id = id; + } + if (name != null) { + _result.name = name; + } + if (email != null) { + _result.email = email; + } + if (password != null) { + _result.password = password; + } + return _result; + } + factory User.fromBuffer($core.List<$core.int> i, [$pb.ExtensionRegistry r = $pb.ExtensionRegistry.EMPTY]) => create()..mergeFromBuffer(i, r); + factory User.fromJson($core.String i, [$pb.ExtensionRegistry r = $pb.ExtensionRegistry.EMPTY]) => create()..mergeFromJson(i, r); + @$core.Deprecated( + 'Using this can add significant overhead to your binary. ' + 'Use [GeneratedMessageGenericExtensions.deepCopy] instead. ' + 'Will be removed in next major version') + User clone() => User()..mergeFromMessage(this); + @$core.Deprecated( + 'Using this can add significant overhead to your binary. ' + 'Use [GeneratedMessageGenericExtensions.rebuild] instead. ' + 'Will be removed in next major version') + User copyWith(void Function(User) updates) => super.copyWith((message) => updates(message as User)) as User; // ignore: deprecated_member_use + $pb.BuilderInfo get info_ => _i; + @$core.pragma('dart2js:noInline') + static User create() => User._(); + User createEmptyInstance() => create(); + static $pb.PbList createRepeated() => $pb.PbList(); + @$core.pragma('dart2js:noInline') + static User getDefault() => _defaultInstance ??= $pb.GeneratedMessage.$_defaultFor(create); + static User? _defaultInstance; + + @$pb.TagNumber(1) + $core.String get id => $_getSZ(0); + @$pb.TagNumber(1) + set id($core.String v) { $_setString(0, v); } + @$pb.TagNumber(1) + $core.bool hasId() => $_has(0); + @$pb.TagNumber(1) + void clearId() => clearField(1); + + @$pb.TagNumber(2) + $core.String get name => $_getSZ(1); + @$pb.TagNumber(2) + set name($core.String v) { $_setString(1, v); } + @$pb.TagNumber(2) + $core.bool hasName() => $_has(1); + @$pb.TagNumber(2) + void clearName() => clearField(2); + + @$pb.TagNumber(3) + $core.String get email => $_getSZ(2); + @$pb.TagNumber(3) + set email($core.String v) { $_setString(2, v); } + @$pb.TagNumber(3) + $core.bool hasEmail() => $_has(2); + @$pb.TagNumber(3) + void clearEmail() => clearField(3); + + @$pb.TagNumber(4) + $core.String get password => $_getSZ(3); + @$pb.TagNumber(4) + set password($core.String v) { $_setString(3, v); } + @$pb.TagNumber(4) + $core.bool hasPassword() => $_has(3); + @$pb.TagNumber(4) + void clearPassword() => clearField(4); +} + diff --git a/app_flowy/packages/flowy_sdk/lib/protobuf/user_table.pbenum.dart b/app_flowy/packages/flowy_sdk/lib/protobuf/user_table.pbenum.dart new file mode 100644 index 0000000000..9000c27feb --- /dev/null +++ b/app_flowy/packages/flowy_sdk/lib/protobuf/user_table.pbenum.dart @@ -0,0 +1,7 @@ +/// +// Generated code. Do not modify. +// source: user_table.proto +// +// @dart = 2.12 +// ignore_for_file: annotate_overrides,camel_case_types,unnecessary_const,non_constant_identifier_names,library_prefixes,unused_import,unused_shown_name,return_of_invalid_type,unnecessary_this,prefer_final_fields + diff --git a/app_flowy/packages/flowy_sdk/lib/protobuf/user_table.pbjson.dart b/app_flowy/packages/flowy_sdk/lib/protobuf/user_table.pbjson.dart new file mode 100644 index 0000000000..485790bd85 --- /dev/null +++ b/app_flowy/packages/flowy_sdk/lib/protobuf/user_table.pbjson.dart @@ -0,0 +1,18 @@ +/// +// Generated code. Do not modify. +// source: user_table.proto +// +// @dart = 2.12 +// ignore_for_file: annotate_overrides,camel_case_types,unnecessary_const,non_constant_identifier_names,library_prefixes,unused_import,unused_shown_name,return_of_invalid_type,unnecessary_this,prefer_final_fields + +import 'dart:core' as $core; +const User$json = const { + '1': 'User', + '2': const [ + const {'1': 'id', '3': 1, '4': 1, '5': 9, '10': 'id'}, + const {'1': 'name', '3': 2, '4': 1, '5': 9, '10': 'name'}, + const {'1': 'email', '3': 3, '4': 1, '5': 9, '10': 'email'}, + const {'1': 'password', '3': 4, '4': 1, '5': 9, '10': 'password'}, + ], +}; + diff --git a/app_flowy/packages/flowy_sdk/lib/protobuf/user_table.pbserver.dart b/app_flowy/packages/flowy_sdk/lib/protobuf/user_table.pbserver.dart new file mode 100644 index 0000000000..5e568e0c0a --- /dev/null +++ b/app_flowy/packages/flowy_sdk/lib/protobuf/user_table.pbserver.dart @@ -0,0 +1,9 @@ +/// +// Generated code. Do not modify. +// source: user_table.proto +// +// @dart = 2.12 +// ignore_for_file: annotate_overrides,camel_case_types,unnecessary_const,non_constant_identifier_names,library_prefixes,unused_import,unused_shown_name,return_of_invalid_type,unnecessary_this,prefer_final_fields + +export 'user_table.pb.dart'; + diff --git a/rust-lib/flowy-ast/src/ty_ext.rs b/rust-lib/flowy-ast/src/ty_ext.rs index f78ef1addd..a20d1e9006 100644 --- a/rust-lib/flowy-ast/src/ty_ext.rs +++ b/rust-lib/flowy-ast/src/ty_ext.rs @@ -58,7 +58,7 @@ pub fn parse_ty<'a>(ctxt: &Ctxt, ty: &'a syn::Type) -> Option> { match seg.ident.to_string().as_ref() { "HashMap" => generate_hashmap_ty_info(ctxt, ty, seg, bracketed), "Vec" => generate_vec_ty_info(ctxt, seg, bracketed), - "Option" => generate_option_ty_info(ty, seg), + "Option" => generate_option_ty_info(ctxt, ty, seg, bracketed), _ => { panic!("Unsupported ty") }, @@ -113,15 +113,19 @@ pub fn generate_hashmap_ty_info<'a>( } fn generate_option_ty_info<'a>( + ctxt: &Ctxt, ty: &'a syn::Type, path_segment: &'a PathSegment, + bracketed: &'a AngleBracketedGenericArguments, ) -> Option> { assert_eq!(path_segment.ident.to_string(), "Option".to_string()); + let types = parse_bracketed(bracketed); + let bracket_ty_info = Box::new(parse_ty(ctxt, &types[0])); return Some(TyInfo { ident: &path_segment.ident, ty, primitive_ty: PrimitiveTy::Opt, - bracket_ty_info: Box::new(None), + bracket_ty_info, }); } diff --git a/rust-lib/flowy-derive/src/derive_cache/derive_cache.rs b/rust-lib/flowy-derive/src/derive_cache/derive_cache.rs index d4adf32546..625f7002e2 100644 --- a/rust-lib/flowy-derive/src/derive_cache/derive_cache.rs +++ b/rust-lib/flowy-derive/src/derive_cache/derive_cache.rs @@ -15,7 +15,9 @@ pub fn category_from_str(type_str: &str) -> TypeCategory { "HashMap" => TypeCategory::Map, "u8" => TypeCategory::Bytes, "String" => TypeCategory::Str, - "FFIRequest" + "KeyValue" + | "KeyValueQuery" + | "FFIRequest" | "FFIResponse" | "User" | "SignUpRequest" diff --git a/rust-lib/flowy-derive/src/proto_buf/deserialize.rs b/rust-lib/flowy-derive/src/proto_buf/deserialize.rs index 429bab7364..47353ecadf 100644 --- a/rust-lib/flowy-derive/src/proto_buf/deserialize.rs +++ b/rust-lib/flowy-derive/src/proto_buf/deserialize.rs @@ -47,14 +47,19 @@ pub fn make_de_token_steam(ctxt: &Ctxt, ast: &ASTContainer) -> Option Option { let member = &field.member; let ident = get_member_ident(ctxt, member)?; let ty_info = parse_ty(ctxt, &field.ty)?; + let bracketed_ty_info = ty_info.bracket_ty_info.as_ref().as_ref(); + let has_func = format_ident!("has_{}", ident.to_string()); - match ident_category(ty_info.ident) { + // eprintln!("😁{:#?}", ty_info.primitive_ty); + // eprintln!("{:#?}", ty_info.bracket_ty_info); + match ident_category(bracketed_ty_info.unwrap().ident) { TypeCategory::Enum => { let get_func = format_ident!("get_{}", ident.to_string()); let ty = ty_info.ty; @@ -65,7 +70,6 @@ fn token_stream_for_one_of(ctxt: &Ctxt, field: &ASTField) -> Option } }) }, - TypeCategory::Primitive => { let get_func = format_ident!("get_{}", ident.to_string()); Some(quote! { @@ -74,14 +78,21 @@ fn token_stream_for_one_of(ctxt: &Ctxt, field: &ASTField) -> Option } }) }, + TypeCategory::Str => { + let take_func = format_ident!("take_{}", ident.to_string()); + Some(quote! { + if pb.#has_func() { + o.#member=Some(pb.#take_func()); + } + }) + }, _ => { let take_func = format_ident!("take_{}", ident.to_string()); let ty = ty_info.ty; - Some(quote! { if pb.#has_func() { - let struct_de_from_pb = #ty::try_from(&mut pb.#take_func()).unwrap(); - o.#member=Some(struct_de_from_pb); + let val = #ty::try_from(&mut pb.#take_func()).unwrap(); + o.#member=Some(val); } }) }, diff --git a/rust-lib/flowy-derive/src/proto_buf/mod.rs b/rust-lib/flowy-derive/src/proto_buf/mod.rs index a559df294f..dbfc134b9f 100644 --- a/rust-lib/flowy-derive/src/proto_buf/mod.rs +++ b/rust-lib/flowy-derive/src/proto_buf/mod.rs @@ -51,3 +51,29 @@ pub fn expand_enum_derive(input: &syn::DeriveInput) -> Result { +// impl std::convert::TryFrom<&$target> for $target { +// type Error = String; +// fn try_from(val: &$target) -> Result { +// Ok(val.clone()) } } +// +// impl std::convert::TryInto<$target> for $target { +// type Error = String; +// +// fn try_into(self) -> Result { Ok(self) } +// } +// }; +// } +// +// impl_try_for_primitive_type!(String); +// impl_try_for_primitive_type!(i64); +// impl_try_for_primitive_type!(i32); +// impl_try_for_primitive_type!(i16); +// impl_try_for_primitive_type!(u64); +// impl_try_for_primitive_type!(u32); +// impl_try_for_primitive_type!(u16); +// impl_try_for_primitive_type!(bool); +// impl_try_for_primitive_type!(f64); +// impl_try_for_primitive_type!(f32); diff --git a/rust-lib/flowy-derive/src/proto_buf/serialize.rs b/rust-lib/flowy-derive/src/proto_buf/serialize.rs index cd733c5c67..d0ea585695 100644 --- a/rust-lib/flowy-derive/src/proto_buf/serialize.rs +++ b/rust-lib/flowy-derive/src/proto_buf/serialize.rs @@ -12,11 +12,11 @@ pub fn make_se_token_stream(ctxt: &Ctxt, ast: &ASTContainer) -> Option Opti let set_func = format_ident!("set_{}", ident.to_string()); Some(quote! { match self.#member { - Some(ref s) => { pb.#set_func(s.try_into().unwrap()) } + Some(ref s) => { pb.#set_func(s.clone()) } None => {} } }) diff --git a/rust-lib/flowy-infra/Cargo.toml b/rust-lib/flowy-infra/Cargo.toml index 5588b36d0b..1b8535f13c 100644 --- a/rust-lib/flowy-infra/Cargo.toml +++ b/rust-lib/flowy-infra/Cargo.toml @@ -6,4 +6,12 @@ edition = "2018" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] -uuid = { version = "0.8", features = ["serde", "v4"] } \ No newline at end of file +uuid = { version = "0.8", features = ["serde", "v4"] } +diesel = {version = "1.4.7", features = ["sqlite"]} +diesel_derives = {version = "1.4.1", features = ["sqlite"]} +diesel_migrations = {version = "1.4.0", features = ["sqlite"]} +flowy-derive = { path = "../flowy-derive"} +flowy-sqlite = { path = "../flowy-sqlite"} +lazy_static = "1.4.0" +protobuf = {version = "2.18.0"} +log = "0.4.14" \ No newline at end of file diff --git a/rust-lib/flowy-infra/Flowy.toml b/rust-lib/flowy-infra/Flowy.toml new file mode 100644 index 0000000000..32812aa4d5 --- /dev/null +++ b/rust-lib/flowy-infra/Flowy.toml @@ -0,0 +1,2 @@ +proto_crates = ["src/kv"] +event_files = [""] \ No newline at end of file diff --git a/rust-lib/flowy-infra/src/kv/kv.rs b/rust-lib/flowy-infra/src/kv/kv.rs new file mode 100644 index 0000000000..43246cf0bf --- /dev/null +++ b/rust-lib/flowy-infra/src/kv/kv.rs @@ -0,0 +1,188 @@ +use crate::kv::schema::{kv_table, kv_table::dsl, KV_SQL}; +use ::diesel::{query_dsl::*, ExpressionMethods}; +use diesel::{Connection, SqliteConnection}; +use flowy_derive::ProtoBuf; +use flowy_sqlite::{DBConnection, Database, PoolConfig}; +use lazy_static::lazy_static; +use std::{path::Path, sync::RwLock}; +const DB_NAME: &str = "kv.db"; +lazy_static! { + pub static ref KV_HOLDER: RwLock = RwLock::new(KVStore::new()); +} + +pub struct KVStore { + database: Option, +} + +impl KVStore { + fn new() -> Self { KVStore { database: None } } + + pub fn init(&mut self, root: &str) -> Result<(), String> { + if !Path::new(root).exists() { + return Err(format!("{} not exists", root)); + } + + let pool_config = PoolConfig::default(); + let database = Database::new(root, DB_NAME, pool_config).unwrap(); + let conn = database.get_connection().unwrap(); + SqliteConnection::execute(&*conn, KV_SQL).unwrap(); + self.database = Some(database); + + Ok(()) + } + + pub fn set(item: KeyValue) -> Result<(), String> { + match get_connection() { + Ok(conn) => { + let _ = diesel::insert_into(kv_table::table) + .values(&item) + .execute(&*conn) + .map_err(|e| format!("{:?}", e))?; + + Ok(()) + }, + Err(e) => Err(e), + } + } + + #[allow(dead_code)] + pub fn remove(key: &str) -> Result<(), String> { + match get_connection() { + Ok(conn) => { + let _ = diesel::delete(dsl::kv_table.filter(kv_table::key.eq(key))) + .execute(&*conn) + .map_err(|e| format!("{:?}", e))?; + Ok(()) + }, + Err(e) => Err(e), + } + } + + pub fn get(key: &str) -> Result { + match get_connection() { + Ok(conn) => { + let item = dsl::kv_table + .filter(kv_table::key.eq(key)) + .first::(&*conn) + .map_err(|e| format!("{:?}", e))?; + Ok(item) + }, + Err(e) => Err(e), + } + } +} + +macro_rules! impl_get_func { + ( + $func_name:ident, + $get_method:ident=>$target:ident + ) => { + impl KVStore { + #[allow(dead_code)] + pub fn $func_name(k: &str) -> Option<$target> { + match KVStore::get(k) { + Ok(item) => item.$get_method, + Err(_) => None, + } + } + } + }; +} + +macro_rules! impl_set_func { + ($func_name:ident,$set_method:ident,$key_type:ident) => { + impl KVStore { + #[allow(dead_code)] + pub fn $func_name(key: &str, value: $key_type) { + let mut item = KeyValue::new(key); + item.$set_method = Some(value); + match KVStore::set(item) { + Ok(_) => {}, + Err(e) => { + log::error!("{:?}", e) + }, + }; + } + } + }; +} + +impl_set_func!(set_str, str_value, String); + +impl_set_func!(set_bool, bool_value, bool); + +impl_set_func!(set_int, int_value, i64); + +impl_set_func!(set_float, float_value, f64); + +impl_get_func!(get_str,str_value=>String); + +impl_get_func!(get_int,int_value=>i64); + +impl_get_func!(get_float,float_value=>f64); + +impl_get_func!(get_bool,bool_value=>bool); + +fn get_connection() -> Result { + match KV_HOLDER.read() { + Ok(store) => { + let conn = store + .database + .as_ref() + .expect("KVStore is not init") + .get_connection() + .map_err(|e| format!("{:?}", e))?; + Ok(conn) + }, + Err(e) => { + let msg = format!("KVStore get connection failed: {:?}", e); + log::error!("{:?}", msg); + Err(msg) + }, + } +} + +#[derive( + PartialEq, Clone, Debug, ProtoBuf, Default, Queryable, Identifiable, Insertable, AsChangeset, +)] +#[table_name = "kv_table"] +#[primary_key(key)] +pub struct KeyValue { + #[pb(index = 1)] + pub key: String, + + #[pb(index = 2, one_of)] + pub str_value: Option, + + #[pb(index = 3, one_of)] + pub int_value: Option, + + #[pb(index = 4, one_of)] + pub float_value: Option, + + #[pb(index = 5, one_of)] + pub bool_value: Option, +} + +impl KeyValue { + pub fn new(key: &str) -> Self { + KeyValue { + key: key.to_string(), + ..Default::default() + } + } +} + +#[derive(ProtoBuf, Default, Debug)] +pub struct KeyValueQuery { + #[pb(index = 1)] + key: String, +} + +impl KeyValueQuery { + pub fn new(key: &str) -> Self { + let mut query = KeyValueQuery::default(); + query.key = key.to_string(); + query + } +} diff --git a/rust-lib/flowy-infra/src/kv/mod.rs b/rust-lib/flowy-infra/src/kv/mod.rs new file mode 100644 index 0000000000..fc18a73c2e --- /dev/null +++ b/rust-lib/flowy-infra/src/kv/mod.rs @@ -0,0 +1,4 @@ +mod kv; +mod schema; + +pub use kv::*; diff --git a/rust-lib/flowy-infra/src/kv/schema.rs b/rust-lib/flowy-infra/src/kv/schema.rs new file mode 100644 index 0000000000..4925374595 --- /dev/null +++ b/rust-lib/flowy-infra/src/kv/schema.rs @@ -0,0 +1,20 @@ +#[allow(dead_code)] +pub const KV_SQL: &str = r#" +CREATE TABLE IF NOT EXISTS kv_table ( + key TEXT NOT NULL PRIMARY KEY, + str_value TEXT, + int_value BIGINT, + float_value DOUBLE, + bool_value BOOLEAN +); +"#; + +table! { + kv_table (key) { + key -> Text, + str_value -> Nullable, + int_value -> Nullable, + float_value -> Nullable, + bool_value -> Nullable, + } +} diff --git a/rust-lib/flowy-infra/src/lib.rs b/rust-lib/flowy-infra/src/lib.rs index 802948d07d..221e526e73 100644 --- a/rust-lib/flowy-infra/src/lib.rs +++ b/rust-lib/flowy-infra/src/lib.rs @@ -1 +1,13 @@ +#[macro_use] +extern crate diesel; + +#[macro_use] +extern crate diesel_derives; + +#[macro_use] +extern crate diesel_migrations; + +mod kv; +mod protobuf; + pub fn uuid() -> String { uuid::Uuid::new_v4().to_string() } diff --git a/rust-lib/flowy-infra/src/protobuf/mod.rs b/rust-lib/flowy-infra/src/protobuf/mod.rs new file mode 100644 index 0000000000..2480f62fbe --- /dev/null +++ b/rust-lib/flowy-infra/src/protobuf/mod.rs @@ -0,0 +1,4 @@ + +mod model; +pub use model::*; + \ No newline at end of file diff --git a/rust-lib/flowy-infra/src/protobuf/model/kv.rs b/rust-lib/flowy-infra/src/protobuf/model/kv.rs new file mode 100644 index 0000000000..d8312eefc3 --- /dev/null +++ b/rust-lib/flowy-infra/src/protobuf/model/kv.rs @@ -0,0 +1,641 @@ +// This file is generated by rust-protobuf 2.22.1. Do not edit +// @generated + +// https://github.com/rust-lang/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![allow(unused_attributes)] +#![cfg_attr(rustfmt, rustfmt::skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `kv.proto` + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_22_1; + +#[derive(PartialEq,Clone,Default)] +pub struct KeyValue { + // message fields + pub key: ::std::string::String, + // message oneof groups + pub one_of_str_value: ::std::option::Option, + pub one_of_int_value: ::std::option::Option, + pub one_of_float_value: ::std::option::Option, + pub one_of_bool_value: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a KeyValue { + fn default() -> &'a KeyValue { + ::default_instance() + } +} + +#[derive(Clone,PartialEq,Debug)] +pub enum KeyValue_oneof_one_of_str_value { + str_value(::std::string::String), +} + +#[derive(Clone,PartialEq,Debug)] +pub enum KeyValue_oneof_one_of_int_value { + int_value(i64), +} + +#[derive(Clone,PartialEq,Debug)] +pub enum KeyValue_oneof_one_of_float_value { + float_value(f64), +} + +#[derive(Clone,PartialEq,Debug)] +pub enum KeyValue_oneof_one_of_bool_value { + bool_value(bool), +} + +impl KeyValue { + pub fn new() -> KeyValue { + ::std::default::Default::default() + } + + // string key = 1; + + + pub fn get_key(&self) -> &str { + &self.key + } + pub fn clear_key(&mut self) { + self.key.clear(); + } + + // Param is passed by value, moved + pub fn set_key(&mut self, v: ::std::string::String) { + self.key = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_key(&mut self) -> &mut ::std::string::String { + &mut self.key + } + + // Take field + pub fn take_key(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.key, ::std::string::String::new()) + } + + // string str_value = 2; + + + pub fn get_str_value(&self) -> &str { + match self.one_of_str_value { + ::std::option::Option::Some(KeyValue_oneof_one_of_str_value::str_value(ref v)) => v, + _ => "", + } + } + pub fn clear_str_value(&mut self) { + self.one_of_str_value = ::std::option::Option::None; + } + + pub fn has_str_value(&self) -> bool { + match self.one_of_str_value { + ::std::option::Option::Some(KeyValue_oneof_one_of_str_value::str_value(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_str_value(&mut self, v: ::std::string::String) { + self.one_of_str_value = ::std::option::Option::Some(KeyValue_oneof_one_of_str_value::str_value(v)) + } + + // Mutable pointer to the field. + pub fn mut_str_value(&mut self) -> &mut ::std::string::String { + if let ::std::option::Option::Some(KeyValue_oneof_one_of_str_value::str_value(_)) = self.one_of_str_value { + } else { + self.one_of_str_value = ::std::option::Option::Some(KeyValue_oneof_one_of_str_value::str_value(::std::string::String::new())); + } + match self.one_of_str_value { + ::std::option::Option::Some(KeyValue_oneof_one_of_str_value::str_value(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_str_value(&mut self) -> ::std::string::String { + if self.has_str_value() { + match self.one_of_str_value.take() { + ::std::option::Option::Some(KeyValue_oneof_one_of_str_value::str_value(v)) => v, + _ => panic!(), + } + } else { + ::std::string::String::new() + } + } + + // int64 int_value = 3; + + + pub fn get_int_value(&self) -> i64 { + match self.one_of_int_value { + ::std::option::Option::Some(KeyValue_oneof_one_of_int_value::int_value(v)) => v, + _ => 0, + } + } + pub fn clear_int_value(&mut self) { + self.one_of_int_value = ::std::option::Option::None; + } + + pub fn has_int_value(&self) -> bool { + match self.one_of_int_value { + ::std::option::Option::Some(KeyValue_oneof_one_of_int_value::int_value(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_int_value(&mut self, v: i64) { + self.one_of_int_value = ::std::option::Option::Some(KeyValue_oneof_one_of_int_value::int_value(v)) + } + + // double float_value = 4; + + + pub fn get_float_value(&self) -> f64 { + match self.one_of_float_value { + ::std::option::Option::Some(KeyValue_oneof_one_of_float_value::float_value(v)) => v, + _ => 0., + } + } + pub fn clear_float_value(&mut self) { + self.one_of_float_value = ::std::option::Option::None; + } + + pub fn has_float_value(&self) -> bool { + match self.one_of_float_value { + ::std::option::Option::Some(KeyValue_oneof_one_of_float_value::float_value(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_float_value(&mut self, v: f64) { + self.one_of_float_value = ::std::option::Option::Some(KeyValue_oneof_one_of_float_value::float_value(v)) + } + + // bool bool_value = 5; + + + pub fn get_bool_value(&self) -> bool { + match self.one_of_bool_value { + ::std::option::Option::Some(KeyValue_oneof_one_of_bool_value::bool_value(v)) => v, + _ => false, + } + } + pub fn clear_bool_value(&mut self) { + self.one_of_bool_value = ::std::option::Option::None; + } + + pub fn has_bool_value(&self) -> bool { + match self.one_of_bool_value { + ::std::option::Option::Some(KeyValue_oneof_one_of_bool_value::bool_value(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_bool_value(&mut self, v: bool) { + self.one_of_bool_value = ::std::option::Option::Some(KeyValue_oneof_one_of_bool_value::bool_value(v)) + } +} + +impl ::protobuf::Message for KeyValue { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.key)?; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.one_of_str_value = ::std::option::Option::Some(KeyValue_oneof_one_of_str_value::str_value(is.read_string()?)); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.one_of_int_value = ::std::option::Option::Some(KeyValue_oneof_one_of_int_value::int_value(is.read_int64()?)); + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeFixed64 { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.one_of_float_value = ::std::option::Option::Some(KeyValue_oneof_one_of_float_value::float_value(is.read_double()?)); + }, + 5 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.one_of_bool_value = ::std::option::Option::Some(KeyValue_oneof_one_of_bool_value::bool_value(is.read_bool()?)); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.key.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.key); + } + if let ::std::option::Option::Some(ref v) = self.one_of_str_value { + match v { + &KeyValue_oneof_one_of_str_value::str_value(ref v) => { + my_size += ::protobuf::rt::string_size(2, &v); + }, + }; + } + if let ::std::option::Option::Some(ref v) = self.one_of_int_value { + match v { + &KeyValue_oneof_one_of_int_value::int_value(v) => { + my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint); + }, + }; + } + if let ::std::option::Option::Some(ref v) = self.one_of_float_value { + match v { + &KeyValue_oneof_one_of_float_value::float_value(v) => { + my_size += 9; + }, + }; + } + if let ::std::option::Option::Some(ref v) = self.one_of_bool_value { + match v { + &KeyValue_oneof_one_of_bool_value::bool_value(v) => { + my_size += 2; + }, + }; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if !self.key.is_empty() { + os.write_string(1, &self.key)?; + } + if let ::std::option::Option::Some(ref v) = self.one_of_str_value { + match v { + &KeyValue_oneof_one_of_str_value::str_value(ref v) => { + os.write_string(2, v)?; + }, + }; + } + if let ::std::option::Option::Some(ref v) = self.one_of_int_value { + match v { + &KeyValue_oneof_one_of_int_value::int_value(v) => { + os.write_int64(3, v)?; + }, + }; + } + if let ::std::option::Option::Some(ref v) = self.one_of_float_value { + match v { + &KeyValue_oneof_one_of_float_value::float_value(v) => { + os.write_double(4, v)?; + }, + }; + } + if let ::std::option::Option::Some(ref v) = self.one_of_bool_value { + match v { + &KeyValue_oneof_one_of_bool_value::bool_value(v) => { + os.write_bool(5, v)?; + }, + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: ::std::boxed::Box) -> ::std::boxed::Box { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> KeyValue { + KeyValue::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT; + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "key", + |m: &KeyValue| { &m.key }, + |m: &mut KeyValue| { &mut m.key }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor::<_>( + "str_value", + KeyValue::has_str_value, + KeyValue::get_str_value, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i64_accessor::<_>( + "int_value", + KeyValue::has_int_value, + KeyValue::get_int_value, + )); + fields.push(::protobuf::reflect::accessor::make_singular_f64_accessor::<_>( + "float_value", + KeyValue::has_float_value, + KeyValue::get_float_value, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor::<_>( + "bool_value", + KeyValue::has_bool_value, + KeyValue::get_bool_value, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::( + "KeyValue", + fields, + file_descriptor_proto() + ) + }) + } + + fn default_instance() -> &'static KeyValue { + static instance: ::protobuf::rt::LazyV2 = ::protobuf::rt::LazyV2::INIT; + instance.get(KeyValue::new) + } +} + +impl ::protobuf::Clear for KeyValue { + fn clear(&mut self) { + self.key.clear(); + self.one_of_str_value = ::std::option::Option::None; + self.one_of_int_value = ::std::option::Option::None; + self.one_of_float_value = ::std::option::Option::None; + self.one_of_bool_value = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for KeyValue { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for KeyValue { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct KeyValueQuery { + // message fields + pub key: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a KeyValueQuery { + fn default() -> &'a KeyValueQuery { + ::default_instance() + } +} + +impl KeyValueQuery { + pub fn new() -> KeyValueQuery { + ::std::default::Default::default() + } + + // string key = 1; + + + pub fn get_key(&self) -> &str { + &self.key + } + pub fn clear_key(&mut self) { + self.key.clear(); + } + + // Param is passed by value, moved + pub fn set_key(&mut self, v: ::std::string::String) { + self.key = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_key(&mut self) -> &mut ::std::string::String { + &mut self.key + } + + // Take field + pub fn take_key(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.key, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for KeyValueQuery { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.key)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.key.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.key); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if !self.key.is_empty() { + os.write_string(1, &self.key)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: ::std::boxed::Box) -> ::std::boxed::Box { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> KeyValueQuery { + KeyValueQuery::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT; + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "key", + |m: &KeyValueQuery| { &m.key }, + |m: &mut KeyValueQuery| { &mut m.key }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::( + "KeyValueQuery", + fields, + file_descriptor_proto() + ) + }) + } + + fn default_instance() -> &'static KeyValueQuery { + static instance: ::protobuf::rt::LazyV2 = ::protobuf::rt::LazyV2::INIT; + instance.get(KeyValueQuery::new) + } +} + +impl ::protobuf::Clear for KeyValueQuery { + fn clear(&mut self) { + self.key.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for KeyValueQuery { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for KeyValueQuery { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\x08kv.proto\"\xf1\x01\n\x08KeyValue\x12\x10\n\x03key\x18\x01\x20\x01(\ + \tR\x03key\x12\x1d\n\tstr_value\x18\x02\x20\x01(\tH\0R\x08strValue\x12\ + \x1d\n\tint_value\x18\x03\x20\x01(\x03H\x01R\x08intValue\x12!\n\x0bfloat\ + _value\x18\x04\x20\x01(\x01H\x02R\nfloatValue\x12\x1f\n\nbool_value\x18\ + \x05\x20\x01(\x08H\x03R\tboolValueB\x12\n\x10one_of_str_valueB\x12\n\x10\ + one_of_int_valueB\x14\n\x12one_of_float_valueB\x13\n\x11one_of_bool_valu\ + e\"!\n\rKeyValueQuery\x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03keyJ\xf8\ + \x03\n\x06\x12\x04\0\0\x0b\x01\n\x08\n\x01\x0c\x12\x03\0\0\x12\n\n\n\x02\ + \x04\0\x12\x04\x02\0\x08\x01\n\n\n\x03\x04\0\x01\x12\x03\x02\x08\x10\n\ + \x0b\n\x04\x04\0\x02\0\x12\x03\x03\x04\x13\n\x0c\n\x05\x04\0\x02\0\x05\ + \x12\x03\x03\x04\n\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03\x03\x0b\x0e\n\x0c\ + \n\x05\x04\0\x02\0\x03\x12\x03\x03\x11\x12\n\x0b\n\x04\x04\0\x08\0\x12\ + \x03\x04\x044\n\x0c\n\x05\x04\0\x08\0\x01\x12\x03\x04\n\x1a\n\x0b\n\x04\ + \x04\0\x02\x01\x12\x03\x04\x1d2\n\x0c\n\x05\x04\0\x02\x01\x05\x12\x03\ + \x04\x1d#\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03\x04$-\n\x0c\n\x05\x04\0\ + \x02\x01\x03\x12\x03\x0401\n\x0b\n\x04\x04\0\x08\x01\x12\x03\x05\x043\n\ + \x0c\n\x05\x04\0\x08\x01\x01\x12\x03\x05\n\x1a\n\x0b\n\x04\x04\0\x02\x02\ + \x12\x03\x05\x1d1\n\x0c\n\x05\x04\0\x02\x02\x05\x12\x03\x05\x1d\"\n\x0c\ + \n\x05\x04\0\x02\x02\x01\x12\x03\x05#,\n\x0c\n\x05\x04\0\x02\x02\x03\x12\ + \x03\x05/0\n\x0b\n\x04\x04\0\x08\x02\x12\x03\x06\x048\n\x0c\n\x05\x04\0\ + \x08\x02\x01\x12\x03\x06\n\x1c\n\x0b\n\x04\x04\0\x02\x03\x12\x03\x06\x1f\ + 6\n\x0c\n\x05\x04\0\x02\x03\x05\x12\x03\x06\x1f%\n\x0c\n\x05\x04\0\x02\ + \x03\x01\x12\x03\x06&1\n\x0c\n\x05\x04\0\x02\x03\x03\x12\x03\x0645\n\x0b\ + \n\x04\x04\0\x08\x03\x12\x03\x07\x044\n\x0c\n\x05\x04\0\x08\x03\x01\x12\ + \x03\x07\n\x1b\n\x0b\n\x04\x04\0\x02\x04\x12\x03\x07\x1e2\n\x0c\n\x05\ + \x04\0\x02\x04\x05\x12\x03\x07\x1e\"\n\x0c\n\x05\x04\0\x02\x04\x01\x12\ + \x03\x07#-\n\x0c\n\x05\x04\0\x02\x04\x03\x12\x03\x0701\n\n\n\x02\x04\x01\ + \x12\x04\t\0\x0b\x01\n\n\n\x03\x04\x01\x01\x12\x03\t\x08\x15\n\x0b\n\x04\ + \x04\x01\x02\0\x12\x03\n\x04\x13\n\x0c\n\x05\x04\x01\x02\0\x05\x12\x03\n\ + \x04\n\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03\n\x0b\x0e\n\x0c\n\x05\x04\ + \x01\x02\0\x03\x12\x03\n\x11\x12b\x06proto3\ +"; + +static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) +} diff --git a/rust-lib/flowy-infra/src/protobuf/model/mod.rs b/rust-lib/flowy-infra/src/protobuf/model/mod.rs new file mode 100644 index 0000000000..b481acecd1 --- /dev/null +++ b/rust-lib/flowy-infra/src/protobuf/model/mod.rs @@ -0,0 +1,4 @@ +// Auto-generated, do not edit + +mod kv; +pub use kv::*; diff --git a/rust-lib/flowy-infra/src/protobuf/proto/kv.proto b/rust-lib/flowy-infra/src/protobuf/proto/kv.proto new file mode 100644 index 0000000000..f182c418cd --- /dev/null +++ b/rust-lib/flowy-infra/src/protobuf/proto/kv.proto @@ -0,0 +1,12 @@ +syntax = "proto3"; + +message KeyValue { + string key = 1; + oneof one_of_str_value { string str_value = 2; }; + oneof one_of_int_value { int64 int_value = 3; }; + oneof one_of_float_value { double float_value = 4; }; + oneof one_of_bool_value { bool bool_value = 5; }; +} +message KeyValueQuery { + string key = 1; +} diff --git a/rust-lib/flowy-sdk/src/module.rs b/rust-lib/flowy-sdk/src/module.rs index f209360a48..63dfbf9a68 100644 --- a/rust-lib/flowy-sdk/src/module.rs +++ b/rust-lib/flowy-sdk/src/module.rs @@ -1,5 +1,5 @@ use flowy_dispatch::prelude::Module; -use flowy_user::prelude::{UserSession, UserSessionBuilder, UserSessionConfig}; +use flowy_user::prelude::UserSessionBuilder; use std::sync::Arc; pub struct ModuleConfig { diff --git a/rust-lib/flowy-user/src/domain/tables/user_table.rs b/rust-lib/flowy-user/src/domain/tables/user_table.rs index 85a2b75b7a..016b21459b 100644 --- a/rust-lib/flowy-user/src/domain/tables/user_table.rs +++ b/rust-lib/flowy-user/src/domain/tables/user_table.rs @@ -1,4 +1,3 @@ -use crate::domain::{UserEmail, UserName, UserPassword}; use flowy_database::schema::user_table; use flowy_derive::ProtoBuf; diff --git a/rust-lib/flowy-user/src/errors.rs b/rust-lib/flowy-user/src/errors.rs index 55f498fc50..63891a6c7b 100644 --- a/rust-lib/flowy-user/src/errors.rs +++ b/rust-lib/flowy-user/src/errors.rs @@ -1,6 +1,5 @@ use derive_more::Display; -use flowy_dispatch::prelude::{DispatchError, EventResponse, ResponseBuilder, StatusCode}; -use std::{io, sync::PoisonError}; +use flowy_dispatch::prelude::DispatchError; #[derive(Debug, Clone, Display)] pub enum UserError { diff --git a/rust-lib/flowy-user/src/protobuf/model/mod.rs b/rust-lib/flowy-user/src/protobuf/model/mod.rs index b49606c4c8..70b1efc830 100644 --- a/rust-lib/flowy-user/src/protobuf/model/mod.rs +++ b/rust-lib/flowy-user/src/protobuf/model/mod.rs @@ -6,6 +6,9 @@ pub use sign_up::*; mod sign_in; pub use sign_in::*; +mod user_table; +pub use user_table::*; + mod event; pub use event::*; diff --git a/rust-lib/flowy-user/src/protobuf/model/user_table.rs b/rust-lib/flowy-user/src/protobuf/model/user_table.rs new file mode 100644 index 0000000000..ba994bd203 --- /dev/null +++ b/rust-lib/flowy-user/src/protobuf/model/user_table.rs @@ -0,0 +1,341 @@ +// This file is generated by rust-protobuf 2.22.1. Do not edit +// @generated + +// https://github.com/rust-lang/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![allow(unused_attributes)] +#![cfg_attr(rustfmt, rustfmt::skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `user_table.proto` + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_22_1; + +#[derive(PartialEq,Clone,Default)] +pub struct User { + // message fields + pub id: ::std::string::String, + pub name: ::std::string::String, + pub email: ::std::string::String, + pub password: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a User { + fn default() -> &'a User { + ::default_instance() + } +} + +impl User { + pub fn new() -> User { + ::std::default::Default::default() + } + + // string id = 1; + + + pub fn get_id(&self) -> &str { + &self.id + } + pub fn clear_id(&mut self) { + self.id.clear(); + } + + // Param is passed by value, moved + pub fn set_id(&mut self, v: ::std::string::String) { + self.id = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_id(&mut self) -> &mut ::std::string::String { + &mut self.id + } + + // Take field + pub fn take_id(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.id, ::std::string::String::new()) + } + + // string name = 2; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // string email = 3; + + + pub fn get_email(&self) -> &str { + &self.email + } + pub fn clear_email(&mut self) { + self.email.clear(); + } + + // Param is passed by value, moved + pub fn set_email(&mut self, v: ::std::string::String) { + self.email = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_email(&mut self) -> &mut ::std::string::String { + &mut self.email + } + + // Take field + pub fn take_email(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.email, ::std::string::String::new()) + } + + // string password = 4; + + + pub fn get_password(&self) -> &str { + &self.password + } + pub fn clear_password(&mut self) { + self.password.clear(); + } + + // Param is passed by value, moved + pub fn set_password(&mut self, v: ::std::string::String) { + self.password = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_password(&mut self) -> &mut ::std::string::String { + &mut self.password + } + + // Take field + pub fn take_password(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.password, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for User { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.id)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.email)?; + }, + 4 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.password)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.id.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.id); + } + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.name); + } + if !self.email.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.email); + } + if !self.password.is_empty() { + my_size += ::protobuf::rt::string_size(4, &self.password); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if !self.id.is_empty() { + os.write_string(1, &self.id)?; + } + if !self.name.is_empty() { + os.write_string(2, &self.name)?; + } + if !self.email.is_empty() { + os.write_string(3, &self.email)?; + } + if !self.password.is_empty() { + os.write_string(4, &self.password)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: ::std::boxed::Box) -> ::std::boxed::Box { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> User { + User::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT; + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "id", + |m: &User| { &m.id }, + |m: &mut User| { &mut m.id }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &User| { &m.name }, + |m: &mut User| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "email", + |m: &User| { &m.email }, + |m: &mut User| { &mut m.email }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "password", + |m: &User| { &m.password }, + |m: &mut User| { &mut m.password }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::( + "User", + fields, + file_descriptor_proto() + ) + }) + } + + fn default_instance() -> &'static User { + static instance: ::protobuf::rt::LazyV2 = ::protobuf::rt::LazyV2::INIT; + instance.get(User::new) + } +} + +impl ::protobuf::Clear for User { + fn clear(&mut self) { + self.id.clear(); + self.name.clear(); + self.email.clear(); + self.password.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for User { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for User { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\x10user_table.proto\"\\\n\x04User\x12\x0e\n\x02id\x18\x01\x20\x01(\tR\ + \x02id\x12\x12\n\x04name\x18\x02\x20\x01(\tR\x04name\x12\x14\n\x05email\ + \x18\x03\x20\x01(\tR\x05email\x12\x1a\n\x08password\x18\x04\x20\x01(\tR\ + \x08passwordJ\x86\x02\n\x06\x12\x04\0\0\x07\x01\n\x08\n\x01\x0c\x12\x03\ + \0\0\x12\n\n\n\x02\x04\0\x12\x04\x02\0\x07\x01\n\n\n\x03\x04\0\x01\x12\ + \x03\x02\x08\x0c\n\x0b\n\x04\x04\0\x02\0\x12\x03\x03\x04\x12\n\x0c\n\x05\ + \x04\0\x02\0\x05\x12\x03\x03\x04\n\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03\ + \x03\x0b\r\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03\x03\x10\x11\n\x0b\n\x04\ + \x04\0\x02\x01\x12\x03\x04\x04\x14\n\x0c\n\x05\x04\0\x02\x01\x05\x12\x03\ + \x04\x04\n\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03\x04\x0b\x0f\n\x0c\n\x05\ + \x04\0\x02\x01\x03\x12\x03\x04\x12\x13\n\x0b\n\x04\x04\0\x02\x02\x12\x03\ + \x05\x04\x15\n\x0c\n\x05\x04\0\x02\x02\x05\x12\x03\x05\x04\n\n\x0c\n\x05\ + \x04\0\x02\x02\x01\x12\x03\x05\x0b\x10\n\x0c\n\x05\x04\0\x02\x02\x03\x12\ + \x03\x05\x13\x14\n\x0b\n\x04\x04\0\x02\x03\x12\x03\x06\x04\x18\n\x0c\n\ + \x05\x04\0\x02\x03\x05\x12\x03\x06\x04\n\n\x0c\n\x05\x04\0\x02\x03\x01\ + \x12\x03\x06\x0b\x13\n\x0c\n\x05\x04\0\x02\x03\x03\x12\x03\x06\x16\x17b\ + \x06proto3\ +"; + +static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) +} diff --git a/rust-lib/flowy-user/src/protobuf/proto/user_table.proto b/rust-lib/flowy-user/src/protobuf/proto/user_table.proto new file mode 100644 index 0000000000..6ae8d964d1 --- /dev/null +++ b/rust-lib/flowy-user/src/protobuf/proto/user_table.proto @@ -0,0 +1,8 @@ +syntax = "proto3"; + +message User { + string id = 1; + string name = 2; + string email = 3; + string password = 4; +} diff --git a/rust-lib/flowy-user/src/services/database.rs b/rust-lib/flowy-user/src/services/database.rs index 1979747f76..1236e29774 100644 --- a/rust-lib/flowy-user/src/services/database.rs +++ b/rust-lib/flowy-user/src/services/database.rs @@ -89,7 +89,7 @@ impl UserDB { #[cfg(test)] mod tests { - use super::*; + #[test] fn init_db_test() { // init_user_db(".").unwrap(); diff --git a/rust-lib/flowy-user/tests/auth_test.rs b/rust-lib/flowy-user/tests/auth_test.rs index b428ccb15f..e9217d820b 100644 --- a/rust-lib/flowy-user/tests/auth_test.rs +++ b/rust-lib/flowy-user/tests/auth_test.rs @@ -9,7 +9,7 @@ fn sign_up_success() { password: valid_password(), }; - let response = EventTester::new(SignUp).request(request).sync_send(); + let _response = EventTester::new(SignUp).request(request).sync_send(); // .parse::(); // dbg!(&response); }