Skip to content

Bring projects, wikis, and teams together with AI. AppFlowy is the AI collaborative workspace where you achieve more without losing control of your data. The leading open source Notion alternative.

fix: high cpu usage

nathanc35db5c2a232
diff --git a/frontend/appflowy_tauri/src-tauri/src/init.rs b/frontend/appflowy_tauri/src-tauri/src/init.rs
index a9d22eefbf..98ab6d5376 100644
--- a/frontend/appflowy_tauri/src-tauri/src/init.rs
+++ b/frontend/appflowy_tauri/src-tauri/src/init.rs
@@ -10,7 +10,7 @@ pub fn init_flowy_core() -> AppFlowyCore {
}
data_path.push("data");
- std::env::set_var("RUST_LOG", "debug");
+ std::env::set_var("RUST_LOG", "trace");
let server_config = get_client_server_configuration().unwrap();
let config = AppFlowyCoreConfig::new(
data_path.to_str().unwrap(),
diff --git a/frontend/appflowy_tauri/src/appflowy_app/components/TestApiButton/DatabaseTestHelper.ts b/frontend/appflowy_tauri/src/appflowy_app/components/TestApiButton/DatabaseTestHelper.ts
index 4a79bc16e0..1eecc6f70a 100644
--- a/frontend/appflowy_tauri/src/appflowy_app/components/TestApiButton/DatabaseTestHelper.ts
+++ b/frontend/appflowy_tauri/src/appflowy_app/components/TestApiButton/DatabaseTestHelper.ts
@@ -11,7 +11,6 @@ import {
SelectOptionCellController,
TextCellController,
} from '../../stores/effects/database/cell/controller_builder';
-import assert from 'assert';
import { None, Option, Some } from 'ts-results';
import { TypeOptionBackendService } from '../../stores/effects/database/field/type_option/type_option_bd_svc';
import { DatabaseBackendService } from '../../stores/effects/database/database_bd_svc';
@@ -29,9 +28,16 @@ export async function openTestDatabase(viewId: string): Promise<DatabaseControll
return new DatabaseController(viewId);
}
-export async function assertTextCell(rowInfo: RowInfo, databaseController: DatabaseController, expectedContent: string) {
- const cellController = await makeTextCellController(rowInfo, databaseController).then((result) => result.unwrap());
- cellController.subscribeChanged({
+export async function assertTextCell(
+ fieldId: string,
+ rowInfo: RowInfo,
+ databaseController: DatabaseController,
+ expectedContent: string
+) {
+ const cellController = await makeTextCellController(fieldId, rowInfo, databaseController).then((result) =>
+ result.unwrap()
+ );
+ await cellController.subscribeChanged({
onCellChanged: (value) => {
const cellContent = value.unwrap();
if (cellContent !== expectedContent) {
@@ -39,55 +45,78 @@ export async function assertTextCell(rowInfo: RowInfo, databaseController: Datab
}
},
});
- cellController.getCellData();
+ await cellController.getCellData();
}
-export async function editTextCell(rowInfo: RowInfo, databaseController: DatabaseController, content: string) {
- const cellController = await makeTextCellController(rowInfo, databaseController).then((result) => result.unwrap());
+export async function editTextCell(
+ fieldId: string,
+ rowInfo: RowInfo,
+ databaseController: DatabaseController,
+ content: string
+) {
+ const cellController = await makeTextCellController(fieldId, rowInfo, databaseController).then((result) =>
+ result.unwrap()
+ );
await cellController.saveCellData(content);
}
export async function makeTextCellController(
+ fieldId: string,
rowInfo: RowInfo,
databaseController: DatabaseController
): Promise<Option<TextCellController>> {
- const builder = await makeCellControllerBuilder(rowInfo, FieldType.RichText, databaseController).then((result) =>
- result.unwrap()
+ const builder = await makeCellControllerBuilder(fieldId, rowInfo, FieldType.RichText, databaseController).then(
+ (result) => result.unwrap()
);
return Some(builder.build() as TextCellController);
}
export async function makeNumberCellController(
+ fieldId: string,
rowInfo: RowInfo,
databaseController: DatabaseController
): Promise<Option<NumberCellController>> {
- const builder = await makeCellControllerBuilder(rowInfo, FieldType.Number, databaseController).then((result) =>
- result.unwrap()
+ const builder = await makeCellControllerBuilder(fieldId, rowInfo, FieldType.Number, databaseController).then(
+ (result) => result.unwrap()
);
return Some(builder.build() as NumberCellController);
}
export async function makeSingleSelectCellController(
+ fieldId: string,
rowInfo: RowInfo,
databaseController: DatabaseController
): Promise<Option<SelectOptionCellController>> {
- const builder = await makeCellControllerBuilder(rowInfo, FieldType.SingleSelect, databaseController).then((result) =>
- result.unwrap()
+ const builder = await makeCellControllerBuilder(fieldId, rowInfo, FieldType.SingleSelect, databaseController).then(
+ (result) => result.unwrap()
+ );
+ return Some(builder.build() as SelectOptionCellController);
+}
+
+export async function makeMultiSelectCellController(
+ fieldId: string,
+ rowInfo: RowInfo,
+ databaseController: DatabaseController
+): Promise<Option<SelectOptionCellController>> {
+ const builder = await makeCellControllerBuilder(fieldId, rowInfo, FieldType.MultiSelect, databaseController).then(
+ (result) => result.unwrap()
);
return Some(builder.build() as SelectOptionCellController);
}
export async function makeDateCellController(
+ fieldId: string,
rowInfo: RowInfo,
databaseController: DatabaseController
): Promise<Option<DateCellController>> {
- const builder = await makeCellControllerBuilder(rowInfo, FieldType.DateTime, databaseController).then((result) =>
- result.unwrap()
+ const builder = await makeCellControllerBuilder(fieldId, rowInfo, FieldType.DateTime, databaseController).then(
+ (result) => result.unwrap()
);
return Some(builder.build() as DateCellController);
}
export async function makeCellControllerBuilder(
+ fieldId: string,
rowInfo: RowInfo,
fieldType: FieldType,
databaseController: DatabaseController
@@ -99,7 +128,7 @@ export async function makeCellControllerBuilder(
const cellByFieldId = await rowController.loadCells();
for (const cellIdentifier of cellByFieldId.values()) {
const builder = new CellControllerBuilder(cellIdentifier, cellCache, fieldController);
- if (cellIdentifier.fieldType === fieldType) {
+ if (cellIdentifier.fieldId === fieldId) {
return Some(builder);
}
}
@@ -107,6 +136,15 @@ export async function makeCellControllerBuilder(
return None;
}
+export function findFirstFieldInfoWithFieldType(rowInfo: RowInfo, fieldType: FieldType) {
+ const fieldInfo = rowInfo.fieldInfos.find((element) => element.field.field_type === fieldType);
+ if (fieldInfo === undefined) {
+ return None;
+ } else {
+ return Some(fieldInfo);
+ }
+}
+
export async function assertFieldName(viewId: string, fieldId: string, fieldType: FieldType, expected: string) {
const svc = new TypeOptionBackendService(viewId);
const typeOptionPB = await svc.getTypeOption(fieldId, fieldType).then((result) => result.unwrap());
diff --git a/frontend/appflowy_tauri/src/appflowy_app/components/TestApiButton/TestAPI.tsx b/frontend/appflowy_tauri/src/appflowy_app/components/TestApiButton/TestAPI.tsx
index 0f9a1fb9d1..b5354da161 100644
--- a/frontend/appflowy_tauri/src/appflowy_app/components/TestApiButton/TestAPI.tsx
+++ b/frontend/appflowy_tauri/src/appflowy_app/components/TestApiButton/TestAPI.tsx
@@ -10,6 +10,8 @@ import {
TestEditCell,
TestEditField,
TestGetSingleSelectFieldData,
+ TestSwitchFromMultiSelectToText,
+ TestSwitchFromSingleSelectToNumber,
} from './TestGrid';
export const TestAPI = () => {
@@ -26,6 +28,8 @@ export const TestAPI = () => {
<TestEditField></TestEditField>
<TestCreateNewField></TestCreateNewField>
<TestDeleteField></TestDeleteField>
+ <TestSwitchFromSingleSelectToNumber></TestSwitchFromSingleSelectToNumber>
+ <TestSwitchFromMultiSelectToText></TestSwitchFromMultiSelectToText>
</ul>
</React.Fragment>
);
diff --git a/frontend/appflowy_tauri/src/appflowy_app/components/TestApiButton/TestGrid.tsx b/frontend/appflowy_tauri/src/appflowy_app/components/TestApiButton/TestGrid.tsx
index d0ccbfab47..b4099252ce 100644
--- a/frontend/appflowy_tauri/src/appflowy_app/components/TestApiButton/TestGrid.tsx
+++ b/frontend/appflowy_tauri/src/appflowy_app/components/TestApiButton/TestGrid.tsx
@@ -1,6 +1,8 @@
import React from 'react';
import {
FieldType,
+ NumberFormat,
+ NumberTypeOptionPB,
SelectOptionCellDataPB,
SingleSelectTypeOptionPB,
ViewLayoutTypePB,
@@ -13,7 +15,10 @@ import {
assertTextCell,
createTestDatabaseView,
editTextCell,
+ findFirstFieldInfoWithFieldType,
+ makeMultiSelectCellController,
makeSingleSelectCellController,
+ makeTextCellController,
openTestDatabase,
} from './DatabaseTestHelper';
import {
@@ -23,7 +28,10 @@ import {
import { TypeOptionController } from '../../stores/effects/database/field/type_option/type_option_controller';
import { None, Some } from 'ts-results';
import { RowBackendService } from '../../stores/effects/database/row/row_bd_svc';
-import { makeSingleSelectTypeOptionContext } from '../../stores/effects/database/field/type_option/type_option_context';
+import {
+ makeNumberTypeOptionContext,
+ makeSingleSelectTypeOptionContext,
+} from '../../stores/effects/database/field/type_option/type_option_context';
export const TestCreateGrid = () => {
async function createBuildInGrid() {
@@ -33,11 +41,11 @@ export const TestCreateGrid = () => {
onViewChanged: (databasePB) => {
Log.debug('Did receive database:' + databasePB);
},
- onRowsChanged: async (rows) => {
- if (rows.length !== 3) {
- throw Error('Expected number of rows is 3, but receive ' + rows.length + view.id);
- }
- },
+ // onRowsChanged: async (rows) => {
+ // if (rows.length !== 3) {
+ // throw Error('Expected number of rows is 3, but receive ' + rows.length);
+ // }
+ // },
onFieldsChanged: (fields) => {
if (fields.length !== 3) {
throw Error('Expected number of fields is 3, but receive ' + fields.length);
@@ -59,8 +67,9 @@ export const TestEditCell = () => {
for (const [index, row] of databaseController.databaseViewCache.rowInfos.entries()) {
const cellContent = index.toString();
- await editTextCell(row, databaseController, cellContent);
- await assertTextCell(row, databaseController, cellContent);
+ const fieldInfo = findFirstFieldInfoWithFieldType(row, FieldType.RichText).unwrap();
+ await editTextCell(fieldInfo.field.id, row, databaseController, cellContent);
+ await assertTextCell(fieldInfo.field.id, row, databaseController, cellContent);
}
}
@@ -111,10 +120,11 @@ export const TestCreateSelectOptionInCell = () => {
await databaseController.open().then((result) => result.unwrap());
for (const [index, row] of databaseController.databaseViewCache.rowInfos.entries()) {
if (index === 0) {
- const cellController = await makeSingleSelectCellController(row, databaseController).then((result) =>
- result.unwrap()
+ const fieldInfo = findFirstFieldInfoWithFieldType(row, FieldType.SingleSelect).unwrap();
+ const cellController = await makeSingleSelectCellController(fieldInfo.field.id, row, databaseController).then(
+ (result) => result.unwrap()
);
- cellController.subscribeChanged({
+ await cellController.subscribeChanged({
onCellChanged: (value) => {
const option: SelectOptionCellDataPB = value.unwrap();
console.log(option);
@@ -167,6 +177,89 @@ export const TestGetSingleSelectFieldData = () => {
return TestButton('Test get single-select column data', testGetSingleSelectFieldData);
};
+export const TestSwitchFromSingleSelectToNumber = () => {
+ async function testSwitchFromSingleSelectToNumber() {
+ const view = await createTestDatabaseView(ViewLayoutTypePB.Grid);
+ const databaseController = await openTestDatabase(view.id);
+ await databaseController.open().then((result) => result.unwrap());
+
+ // Find the single select column
+ const singleSelect = databaseController.fieldController.fieldInfos.find(
+ (fieldInfo) => fieldInfo.field.field_type === FieldType.SingleSelect
+ )!;
+ const typeOptionController = new TypeOptionController(view.id, Some(singleSelect));
+ await typeOptionController.switchToField(FieldType.Number);
+
+ // Check the number type option
+ const numberTypeOptionContext = makeNumberTypeOptionContext(typeOptionController);
+ const numberTypeOption: NumberTypeOptionPB = await numberTypeOptionContext
+ .getTypeOption()
+ .then((result) => result.unwrap());
+ const format: NumberFormat = numberTypeOption.format;
+ if (format !== NumberFormat.Num) {
+ throw Error('The default format should be number');
+ }
+
+ await databaseController.dispose();
+ }
+
+ return TestButton('Test switch from single-select to number column', testSwitchFromSingleSelectToNumber);
+};
+
+export const TestSwitchFromMultiSelectToText = () => {
+ async function testSwitchFromMultiSelectToRichText() {
+ const view = await createTestDatabaseView(ViewLayoutTypePB.Grid);
+ const databaseController = await openTestDatabase(view.id);
+ await databaseController.open().then((result) => result.unwrap());
+
+ // Create multi-select field
+ const typeOptionController = new TypeOptionController(view.id, None, FieldType.MultiSelect);
+ await typeOptionController.initialize();
+
+ // Insert options to first row
+ const row = databaseController.databaseViewCache.rowInfos[0];
+ const multiSelectField = typeOptionController.getFieldInfo();
+ // const multiSelectField = findFirstFieldInfoWithFieldType(row, FieldType.MultiSelect).unwrap();
+ const selectOptionCellController = await makeMultiSelectCellController(
+ multiSelectField.field.id,
+ row,
+ databaseController
+ ).then((result) => result.unwrap());
+ const backendSvc = new SelectOptionCellBackendService(selectOptionCellController.cellIdentifier);
+ await backendSvc.createOption({ name: 'A' });
+ await backendSvc.createOption({ name: 'B' });
+ await backendSvc.createOption({ name: 'C' });
+
+ const selectOptionCellData = await selectOptionCellController.getCellData().then((result) => result.unwrap());
+ if (selectOptionCellData.options.length !== 3) {
+ throw Error('The options should equal to 3');
+ }
+
+ if (selectOptionCellData.select_options.length !== 3) {
+ throw Error('The selected options should equal to 3');
+ }
+ await selectOptionCellController.dispose();
+
+ // Switch to RichText field type
+ await typeOptionController.switchToField(FieldType.RichText).then((result) => result.unwrap());
+ if (typeOptionController.fieldType !== FieldType.RichText) {
+ throw Error('The field type should be text');
+ }
+
+ const textCellController = await makeTextCellController(multiSelectField.field.id, row, databaseController).then(
+ (result) => result.unwrap()
+ );
+ const cellContent = await textCellController.getCellData();
+ if (cellContent.unwrap() !== 'A,B,C') {
+ throw Error('The cell content should be A,B,C, but receive: ' + cellContent.unwrap());
+ }
+
+ await databaseController.dispose();
+ }
+
+ return TestButton('Test switch from multi-select to text column', testSwitchFromMultiSelectToRichText);
+};
+
export const TestEditField = () => {
async function testEditField() {
const view = await createTestDatabaseView(ViewLayoutTypePB.Grid);
diff --git a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/cell/cell_cache.ts b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/cell/cell_cache.ts
index 27099145c3..a19ad13d27 100644
--- a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/cell/cell_cache.ts
+++ b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/cell/cell_cache.ts
@@ -35,18 +35,19 @@ export class CellCache {
};
get<T>(key: CellCacheKey): Option<T> {
- const inner = this.cellDataByFieldId.get(key.fieldId);
- if (inner === undefined) {
+ const cellDataByRowId = this.cellDataByFieldId.get(key.fieldId);
+ if (cellDataByRowId === undefined) {
return None;
} else {
- const value = inner.get(key.rowId);
- if (typeof value === typeof undefined || typeof value === typeof null) {
+ const value = cellDataByRowId.get(key.rowId);
+ if (typeof value === typeof undefined) {
return None;
}
- if (value satisfies T) {
- return Some(value as T);
- }
- return None;
+
+ // if (value satisfies T) {
+ // return Some(value as T);
+ // }
+ return Some(value);
}
}
}
diff --git a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/cell/cell_controller.ts b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/cell/cell_controller.ts
index c438cd6cc8..6d3050d88a 100644
--- a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/cell/cell_controller.ts
+++ b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/cell/cell_controller.ts
@@ -8,28 +8,29 @@ import { ChangeNotifier } from '../../../../utils/change_notifier';
import { CellObserver } from './cell_observer';
import { Log } from '../../../../utils/log';
import { Err, None, Ok, Option, Some } from 'ts-results';
+import { DatabaseFieldObserver } from '../field/field_observer';
-export abstract class CellFieldNotifier {
- abstract subscribeOnFieldChanged(callback: () => void): void;
-}
+type Callbacks<T> = { onCellChanged: (value: Option<T>) => void; onFieldChanged?: () => void };
export class CellController<T, D> {
private fieldBackendService: FieldBackendService;
private cellDataNotifier: CellDataNotifier<Option<T>>;
private cellObserver: CellObserver;
private readonly cacheKey: CellCacheKey;
+ private readonly fieldNotifier: DatabaseFieldObserver;
+ private subscribeCallbacks?: Callbacks<T>;
constructor(
public readonly cellIdentifier: CellIdentifier,
private readonly cellCache: CellCache,
- private readonly fieldNotifier: CellFieldNotifier,
private readonly cellDataLoader: CellDataLoader<T>,
private readonly cellDataPersistence: CellDataPersistence<D>
) {
this.fieldBackendService = new FieldBackendService(cellIdentifier.viewId, cellIdentifier.fieldId);
- this.cacheKey = new CellCacheKey(cellIdentifier.rowId, cellIdentifier.fieldId);
+ this.cacheKey = new CellCacheKey(cellIdentifier.fieldId, cellIdentifier.rowId);
this.cellDataNotifier = new CellDataNotifier(cellCache.get<T>(this.cacheKey));
this.cellObserver = new CellObserver(cellIdentifier.rowId, cellIdentifier.fieldId);
+ this.fieldNotifier = new DatabaseFieldObserver(cellIdentifier.fieldId);
void this.cellObserver.subscribe({
/// 1.Listen on user edit event and load the new cell data if needed.
/// For example:
@@ -40,21 +41,23 @@ export class CellController<T, D> {
await this._loadCellData();
},
});
- }
- subscribeChanged = (callbacks: { onCellChanged: (value: Option<T>) => void; onFieldChanged?: () => void }) => {
/// 2.Listen on the field event and load the cell data if needed.
- this.fieldNotifier.subscribeOnFieldChanged(async () => {
- callbacks.onFieldChanged?.();
-
- /// reloadOnFieldChanged should be true if you need to load the data when the corresponding field is changed
- /// For example:
- /// ¥12 -> $12
- if (this.cellDataLoader.reloadOnFieldChanged) {
- await this._loadCellData();
- }
+ void this.fieldNotifier.subscribe({
+ onFieldChanged: () => {
+ this.subscribeCallbacks?.onFieldChanged?.();
+ /// reloadOnFieldChanged should be true if you need to load the data when the corresponding field is changed
+ /// For example:
+ /// ¥12 -> $12
+ if (this.cellDataLoader.reloadOnFieldChanged) {
+ void this._loadCellData();
+ }
+ },
});
+ }
+ subscribeChanged = async (callbacks: Callbacks<T>) => {
+ this.subscribeCallbacks = callbacks;
this.cellDataNotifier.observer.subscribe((cellData) => {
if (cellData !== null) {
callbacks.onCellChanged(cellData);
@@ -78,21 +81,21 @@ export class CellController<T, D> {
}
};
- /// Return the cell data if it exists in the cache
- /// If the cell data is not exist, it will load the cell
- /// data from the backend and then the [onCellChanged] will
- /// get called
- getCellData = (): Option<T> => {
+ /// Return the cell data immediately if it exists in the cache
+ /// Otherwise, it will load the cell data from the backend. The
+ /// subscribers of the [onCellChanged] will get noticed
+ getCellData = async (): Promise<Option<T>> => {
const cellData = this.cellCache.get<T>(this.cacheKey);
if (cellData.none) {
- void this._loadCellData();
+ await this._loadCellData();
+ return this.cellCache.get<T>(this.cacheKey);
}
return cellData;
};
private _loadCellData = () => {
return this.cellDataLoader.loadData().then((result) => {
- if (result.ok && result.val !== undefined) {
+ if (result.ok) {
this.cellCache.insert(this.cacheKey, result.val);
this.cellDataNotifier.cellData = Some(result.val);
} else {
@@ -104,19 +107,10 @@ export class CellController<T, D> {
dispose = async () => {
await this.cellObserver.unsubscribe();
+ await this.fieldNotifier.unsubscribe();
};
}
-export class CellFieldNotifierImpl extends CellFieldNotifier {
- constructor(private readonly fieldController: FieldController) {
- super();
- }
-
- subscribeOnFieldChanged(callback: () => void): void {
- this.fieldController.subscribeOnFieldsChanged(callback);
- }
-}
-
class CellDataNotifier<T> extends ChangeNotifier<T | null> {
_cellData: T | null;
diff --git a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/cell/cell_observer.ts b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/cell/cell_observer.ts
index 06409c7ae2..9aa9763a99 100644
--- a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/cell/cell_observer.ts
+++ b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/cell/cell_observer.ts
@@ -8,24 +8,27 @@ type UpdateCellNotifiedValue = Result<void, FlowyError>;
export type CellChangedCallback = (value: UpdateCellNotifiedValue) => void;
export class CellObserver {
- private _notifier?: ChangeNotifier<UpdateCellNotifiedValue>;
- private _listener?: DatabaseNotificationObserver;
+ private notifier?: ChangeNotifier<UpdateCellNotifiedValue>;
+ private listener?: DatabaseNotificationObserver;
constructor(public readonly rowId: string, public readonly fieldId: string) {}
subscribe = async (callbacks: { onCellChanged: CellChangedCallback }) => {
- this._notifier = new ChangeNotifier();
- this._notifier?.observer.subscribe(callbacks.onCellChanged);
+ this.notifier = new ChangeNotifier();
+ this.notifier?.observer.subscribe(callbacks.onCellChanged);
- this._listener = new DatabaseNotificationObserver({
- viewId: this.rowId + ':' + this.fieldId,
+ this.listener = new DatabaseNotificationObserver({
+ // The rowId combine with fieldId can identifier the cell.
+ // This format rowId:fieldId is also defined in the backend,
+ // so don't change this.
+ id: this.rowId + ':' + this.fieldId,
parserHandler: (notification, result) => {
switch (notification) {
case DatabaseNotification.DidUpdateCell:
if (result.ok) {
- this._notifier?.notify(Ok.EMPTY);
+ this.notifier?.notify(Ok.EMPTY);
} else {
- this._notifier?.notify(result);
+ this.notifier?.notify(result);
}
return;
default:
@@ -33,11 +36,11 @@ export class CellObserver {
}
},
});
- await this._listener.start();
+ await this.listener.start();
};
unsubscribe = async () => {
- this._notifier?.unsubscribe();
- await this._listener?.stop();
+ this.notifier?.unsubscribe();
+ await this.listener?.stop();
};
}
diff --git a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/cell/controller_builder.ts b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/cell/controller_builder.ts
index 584e77394f..9d66dd6ee5 100644
--- a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/cell/controller_builder.ts
+++ b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/cell/controller_builder.ts
@@ -1,11 +1,6 @@
-import {
- DateCellDataPB,
- FieldType,
- SelectOptionCellDataPB,
- URLCellDataPB,
-} from '../../../../../services/backend/models/flowy-database';
+import { DateCellDataPB, FieldType, SelectOptionCellDataPB, URLCellDataPB } from '../../../../../services/backend';
import { CellIdentifier } from './cell_bd_svc';
-import { CellController, CellFieldNotifierImpl } from './cell_controller';
+import { CellController } from './cell_controller';
import {
CellDataLoader,
DateCellDataParser,
@@ -34,15 +29,11 @@ export class CalendarData {
export type URLCellController = CellController<URLCellDataPB, string>;
export class CellControllerBuilder {
- _fieldNotifier: CellFieldNotifierImpl;
-
constructor(
public readonly cellIdentifier: CellIdentifier,
public readonly cellCache: CellCache,
public readonly fieldController: FieldController
- ) {
- this._fieldNotifier = new CellFieldNotifierImpl(this.fieldController);
- }
+ ) {}
///
build = () => {
@@ -68,77 +59,41 @@ export class CellControllerBuilder {
const loader = new CellDataLoader(this.cellIdentifier, new SelectOptionCellDataParser(), true);
const persistence = new TextCellDataPersistence(this.cellIdentifier);
- return new CellController<SelectOptionCellDataPB, string>(
- this.cellIdentifier,
- this.cellCache,
- this._fieldNotifier,
- loader,
- persistence
- );
+ return new CellController<SelectOptionCellDataPB, string>(this.cellIdentifier, this.cellCache, loader, persistence);
};
makeURLCellController = (): URLCellController => {
const loader = new CellDataLoader(this.cellIdentifier, new URLCellDataParser());
const persistence = new TextCellDataPersistence(this.cellIdentifier);
- return new CellController<URLCellDataPB, string>(
- this.cellIdentifier,
- this.cellCache,
- this._fieldNotifier,
- loader,
- persistence
- );
+ return new CellController<URLCellDataPB, string>(this.cellIdentifier, this.cellCache, loader, persistence);
};
makeDateCellController = (): DateCellController => {
const loader = new CellDataLoader(this.cellIdentifier, new DateCellDataParser(), true);
const persistence = new DateCellDataPersistence(this.cellIdentifier);
- return new CellController<DateCellDataPB, CalendarData>(
- this.cellIdentifier,
- this.cellCache,
- this._fieldNotifier,
- loader,
- persistence
- );
+ return new CellController<DateCellDataPB, CalendarData>(this.cellIdentifier, this.cellCache, loader, persistence);
};
makeNumberCellController = (): NumberCellController => {
const loader = new CellDataLoader(this.cellIdentifier, new StringCellDataParser(), true);
const persistence = new TextCellDataPersistence(this.cellIdentifier);
- return new CellController<string, string>(
- this.cellIdentifier,
- this.cellCache,
- this._fieldNotifier,
- loader,
- persistence
- );
+ return new CellController<string, string>(this.cellIdentifier, this.cellCache, loader, persistence);
};
makeTextCellController = (): TextCellController => {
const loader = new CellDataLoader(this.cellIdentifier, new StringCellDataParser());
const persistence = new TextCellDataPersistence(this.cellIdentifier);
- return new CellController<string, string>(
- this.cellIdentifier,
- this.cellCache,
- this._fieldNotifier,
- loader,
- persistence
- );
+ return new CellController<string, string>(this.cellIdentifier, this.cellCache, loader, persistence);
};
makeCheckboxCellController = (): CheckboxCellController => {
const loader = new CellDataLoader(this.cellIdentifier, new StringCellDataParser());
const persistence = new TextCellDataPersistence(this.cellIdentifier);
- return new CellController<string, string>(
- this.cellIdentifier,
- this.cellCache,
- this._fieldNotifier,
- loader,
- persistence
- );
+ return new CellController<string, string>(this.cellIdentifier, this.cellCache, loader, persistence);
};
}
diff --git a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/cell/data_parser.ts b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/cell/data_parser.ts
index 0fdb978d72..e44867c0df 100644
--- a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/cell/data_parser.ts
+++ b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/cell/data_parser.ts
@@ -7,11 +7,11 @@ import { Err, Ok } from 'ts-results';
import { Log } from '../../../../utils/log';
abstract class CellDataParser<T> {
- abstract parserData(data: Uint8Array): T | undefined;
+ abstract parserData(data: Uint8Array): T;
}
class CellDataLoader<T> {
- _service = new CellBackendService();
+ private service = new CellBackendService();
constructor(
readonly cellId: CellIdentifier,
@@ -20,7 +20,7 @@ class CellDataLoader<T> {
) {}
loadData = async () => {
- const result = await this._service.getCell(this.cellId);
+ const result = await this.service.getCell(this.cellId);
if (result.ok) {
return Ok(this.parser.parserData(result.val.data));
} else {
diff --git a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/cell/data_persistence.ts b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/cell/data_persistence.ts
index 12845aaa64..26e0a4afb9 100644
--- a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/cell/data_persistence.ts
+++ b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/cell/data_persistence.ts
@@ -27,10 +27,8 @@ export class DateCellDataPersistence extends CellDataPersistence<CalendarData> {
save(data: CalendarData): Promise<Result<void, FlowyError>> {
const payload = DateChangesetPB.fromObject({ cell_path: _makeCellPath(this.cellIdentifier) });
-
payload.date = data.date.getUTCMilliseconds.toString();
payload.is_utc = true;
-
if (data.time !== undefined) {
payload.time = data.time;
}
diff --git a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/cell/select_option_bd_svc.ts b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/cell/select_option_bd_svc.ts
index fb52dac1fd..1ab1a61148 100644
--- a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/cell/select_option_bd_svc.ts
+++ b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/cell/select_option_bd_svc.ts
@@ -30,6 +30,7 @@ export class SelectOptionBackendService {
export class SelectOptionCellBackendService {
constructor(public readonly cellIdentifier: CellIdentifier) {}
+ // Creates a new option and insert this option to the cell
createOption = async (params: { name: string; isSelect?: boolean }) => {
const payload = CreateSelectOptionPayloadPB.fromObject({
option_name: params.name,
@@ -39,7 +40,7 @@ export class SelectOptionCellBackendService {
const result = await DatabaseEventCreateSelectOption(payload);
if (result.ok) {
- return this._insertOption(result.val, params.isSelect || true);
+ return await this._insertOption(result.val, params.isSelect || true);
} else {
return result;
}
diff --git a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/database_controller.ts b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/database_controller.ts
index 25af4535ea..0ef8c27a1f 100644
--- a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/database_controller.ts
+++ b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/database_controller.ts
@@ -5,7 +5,7 @@ import { DatabasePB } from '../../../../services/backend/models/flowy-database/g
import { RowChangedReason, RowInfo } from './row/row_cache';
import { Err, Ok } from 'ts-results';
-export type SubscribeCallback = {
+export type SubscribeCallbacks = {
onViewChanged?: (data: DatabasePB) => void;
onRowsChanged?: (rowInfos: readonly RowInfo[], reason: RowChangedReason) => void;
onFieldsChanged?: (fieldInfos: readonly FieldInfo[]) => void;
@@ -15,7 +15,7 @@ export class DatabaseController {
private backendService: DatabaseBackendService;
fieldController: FieldController;
databaseViewCache: DatabaseViewCache;
- private _callback?: SubscribeCallback;
+ private _callback?: SubscribeCallbacks;
constructor(public readonly viewId: string) {
this.backendService = new DatabaseBackendService(viewId);
@@ -23,9 +23,9 @@ export class DatabaseController {
this.databaseViewCache = new DatabaseViewCache(viewId, this.fieldController);
}
- subscribe = (callbacks: SubscribeCallback) => {
+ subscribe = (callbacks: SubscribeCallbacks) => {
this._callback = callbacks;
- this.fieldController.subscribeOnFieldsChanged(callbacks.onFieldsChanged);
+ this.fieldController.subscribeOnNumOfFieldsChanged(callbacks.onFieldsChanged);
this.databaseViewCache.getRowCache().subscribeOnRowsChanged((reason) => {
this._callback?.onRowsChanged?.(this.databaseViewCache.rowInfos, reason);
});
diff --git a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/field/field_controller.ts b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/field/field_controller.ts
index 2d5a3959b2..05ab179325 100644
--- a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/field/field_controller.ts
+++ b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/field/field_controller.ts
@@ -1,49 +1,49 @@
import { Log } from '../../../../utils/log';
import { DatabaseBackendService } from '../database_bd_svc';
import { DatabaseFieldChangesetObserver } from './field_observer';
-import { FieldIdPB, FieldPB, IndexFieldPB } from '../../../../../services/backend/models/flowy-database/field_entities';
+import { FieldIdPB, FieldPB, IndexFieldPB } from '../../../../../services/backend';
import { ChangeNotifier } from '../../../../utils/change_notifier';
export class FieldController {
- private fieldListener: DatabaseFieldChangesetObserver;
private backendService: DatabaseBackendService;
- private fieldNotifier = new FieldNotifier([]);
+ private numOfFieldsObserver: DatabaseFieldChangesetObserver;
+ private numOfFieldsNotifier = new NumOfFieldsNotifier([]);
constructor(public readonly viewId: string) {
this.backendService = new DatabaseBackendService(viewId);
- this.fieldListener = new DatabaseFieldChangesetObserver(viewId);
+ this.numOfFieldsObserver = new DatabaseFieldChangesetObserver(viewId);
}
dispose = async () => {
- this.fieldNotifier.unsubscribe();
- await this.fieldListener.unsubscribe();
+ this.numOfFieldsNotifier.unsubscribe();
+ await this.numOfFieldsObserver.unsubscribe();
};
get fieldInfos(): readonly FieldInfo[] {
- return this.fieldNotifier.fieldInfos;
+ return this.numOfFieldsNotifier.fieldInfos;
}
getField = (fieldId: string): FieldInfo | undefined => {
- return this.fieldNotifier.fieldInfos.find((element) => element.field.id === fieldId);
+ return this.numOfFieldsNotifier.fieldInfos.find((element) => element.field.id === fieldId);
};
loadFields = async (fieldIds: FieldIdPB[]) => {
const result = await this.backendService.getFields(fieldIds);
if (result.ok) {
- this.fieldNotifier.fieldInfos = result.val.map((field) => new FieldInfo(field));
+ this.numOfFieldsNotifier.fieldInfos = result.val.map((field) => new FieldInfo(field));
} else {
Log.error(result.val);
}
};
- subscribeOnFieldsChanged = (callback?: (fieldInfos: readonly FieldInfo[]) => void) => {
- return this.fieldNotifier.observer.subscribe((fieldInfos) => {
+ subscribeOnNumOfFieldsChanged = (callback?: (fieldInfos: readonly FieldInfo[]) => void) => {
+ return this.numOfFieldsNotifier.observer.subscribe((fieldInfos) => {
callback?.(fieldInfos);
});
};
listenOnFieldChanges = async () => {
- await this.fieldListener.subscribe({
+ await this.numOfFieldsObserver.subscribe({
onFieldsChanged: (result) => {
if (result.ok) {
const changeset = result.val;
@@ -57,7 +57,7 @@ export class FieldController {
});
};
- _deleteFields = (deletedFields: FieldIdPB[]) => {
+ private _deleteFields = (deletedFields: FieldIdPB[]) => {
if (deletedFields.length === 0) {
return;
}
@@ -68,10 +68,10 @@ export class FieldController {
};
const newFieldInfos = [...this.fieldInfos];
newFieldInfos.filter(predicate);
- this.fieldNotifier.fieldInfos = newFieldInfos;
+ this.numOfFieldsNotifier.fieldInfos = newFieldInfos;
};
- _insertFields = (insertedFields: IndexFieldPB[]) => {
+ private _insertFields = (insertedFields: IndexFieldPB[]) => {
if (insertedFields.length === 0) {
return;
}
@@ -84,29 +84,28 @@ export class FieldController {
newFieldInfos.push(fieldInfo);
}
});
- this.fieldNotifier.fieldInfos = newFieldInfos;
+ this.numOfFieldsNotifier.fieldInfos = newFieldInfos;
};
- _updateFields = (updatedFields: FieldPB[]) => {
+ private _updateFields = (updatedFields: FieldPB[]) => {
if (updatedFields.length === 0) {
return;
}
const newFieldInfos = [...this.fieldInfos];
updatedFields.forEach((updatedField) => {
- newFieldInfos.map((element) => {
- if (element.field.id === updatedField.id) {
- return updatedField;
- } else {
- return element;
- }
+ const index = newFieldInfos.findIndex((fieldInfo) => {
+ return fieldInfo.field.id === updatedField.id;
});
+ if (index !== -1) {
+ newFieldInfos.splice(index, 1, new FieldInfo(updatedField));
+ }
});
- this.fieldNotifier.fieldInfos = newFieldInfos;
+ this.numOfFieldsNotifier.fieldInfos = newFieldInfos;
};
}
-class FieldNotifier extends ChangeNotifier<FieldInfo[]> {
+class NumOfFieldsNotifier extends ChangeNotifier<FieldInfo[]> {
constructor(private _fieldInfos: FieldInfo[]) {
super();
}
diff --git a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/field/field_observer.ts b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/field/field_observer.ts
index 423faac3db..9d7daec7df 100644
--- a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/field/field_observer.ts
+++ b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/field/field_observer.ts
@@ -17,7 +17,7 @@ export class DatabaseFieldChangesetObserver {
this.notifier?.observer.subscribe(callbacks.onFieldsChanged);
this.listener = new DatabaseNotificationObserver({
- viewId: this.viewId,
+ id: this.viewId,
parserHandler: (notification, result) => {
switch (notification) {
case DatabaseNotification.DidUpdateFields:
@@ -50,12 +50,12 @@ export class DatabaseFieldObserver {
constructor(public readonly fieldId: string) {}
- subscribe = async (callbacks: { onFieldsChanged: FieldNotificationCallback }) => {
+ subscribe = async (callbacks: { onFieldChanged: FieldNotificationCallback }) => {
this._notifier = new ChangeNotifier();
- this._notifier?.observer.subscribe(callbacks.onFieldsChanged);
+ this._notifier?.observer.subscribe(callbacks.onFieldChanged);
this._listener = new DatabaseNotificationObserver({
- viewId: this.fieldId,
+ id: this.fieldId,
parserHandler: (notification, result) => {
switch (notification) {
case DatabaseNotification.DidUpdateField:
diff --git a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/field/type_option/type_option_context.ts b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/field/type_option/type_option_context.ts
index 8c7da56219..3fc184cf20 100644
--- a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/field/type_option/type_option_context.ts
+++ b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/field/type_option/type_option_context.ts
@@ -172,7 +172,7 @@ export class TypeOptionContext<T> {
this.fieldObserver = new DatabaseFieldObserver(controller.fieldId);
void this.fieldObserver.subscribe({
- onFieldsChanged: () => {
+ onFieldChanged: () => {
void this.getTypeOption();
},
});
diff --git a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/field/type_option/type_option_controller.ts b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/field/type_option/type_option_controller.ts
index 7993e119b9..1961cae413 100644
--- a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/field/type_option/type_option_controller.ts
+++ b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/field/type_option/type_option_controller.ts
@@ -13,14 +13,20 @@ export class TypeOptionController {
private typeOptionBackendSvc: TypeOptionBackendService;
// Must call [initialize] if the passed-in fieldInfo is None
- constructor(public readonly viewId: string, private initialFieldInfo: Option<FieldInfo> = None) {
+ constructor(
+ public readonly viewId: string,
+ private readonly initialFieldInfo: Option<FieldInfo> = None,
+ private readonly defaultFieldType: FieldType = FieldType.RichText
+ ) {
this.typeOptionData = None;
this.typeOptionBackendSvc = new TypeOptionBackendService(viewId);
}
+ // It will create a new field for the defaultFieldType if the [initialFieldInfo] is None.
+ // Otherwise, it will get the type option of the [initialFieldInfo]
initialize = async () => {
if (this.initialFieldInfo.none) {
- await this.createTypeOption();
+ await this.createTypeOption(this.defaultFieldType);
} else {
await this.getTypeOption();
}
@@ -45,8 +51,16 @@ export class TypeOptionController {
return new FieldInfo(this.typeOptionData.val.field);
};
- switchToField = (fieldType: FieldType) => {
- return this.typeOptionBackendSvc.updateTypeOptionType(this.fieldId, fieldType);
+ switchToField = async (fieldType: FieldType) => {
+ const result = await this.typeOptionBackendSvc.updateTypeOptionType(this.fieldId, fieldType);
+ if (result.ok) {
+ const getResult = await this.typeOptionBackendSvc.getTypeOption(this.fieldId, fieldType);
+ if (getResult.ok) {
+ this.updateTypeOptionData(getResult.val);
+ }
+ return getResult;
+ }
+ return result;
};
setFieldName = async (name: string) => {
@@ -96,7 +110,7 @@ export class TypeOptionController {
});
};
- private createTypeOption = (fieldType: FieldType = FieldType.RichText) => {
+ private createTypeOption = (fieldType: FieldType) => {
return this.typeOptionBackendSvc.createTypeOption(fieldType).then((result) => {
if (result.ok) {
this.updateTypeOptionData(result.val);
diff --git a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/notifications/observer.ts b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/notifications/observer.ts
index 186e3276b0..aca10af257 100644
--- a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/notifications/observer.ts
+++ b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/notifications/observer.ts
@@ -6,10 +6,10 @@ import { Result } from 'ts-results';
export type ParserHandler = (notification: DatabaseNotification, result: Result<Uint8Array, FlowyError>) => void;
export class DatabaseNotificationObserver extends AFNotificationObserver<DatabaseNotification> {
- constructor(params: { viewId?: string; parserHandler: ParserHandler }) {
+ constructor(params: { id?: string; parserHandler: ParserHandler }) {
const parser = new DatabaseNotificationParser({
callback: params.parserHandler,
- id: params.viewId,
+ id: params.id,
});
super(parser);
}
diff --git a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/row/row_cache.ts b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/row/row_cache.ts
index a9d7499f19..2d68d161a4 100644
--- a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/row/row_cache.ts
+++ b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/row/row_cache.ts
@@ -19,26 +19,26 @@ import { Log } from '../../../../utils/log';
export type CellByFieldId = Map<string, CellIdentifier>;
export class RowCache {
- private readonly _rowList: RowList;
- private readonly _cellCache: CellCache;
- private readonly _notifier: RowChangeNotifier;
+ private readonly rowList: RowList;
+ private readonly cellCache: CellCache;
+ private readonly notifier: RowChangeNotifier;
constructor(public readonly viewId: string, private readonly getFieldInfos: () => readonly FieldInfo[]) {
- this._rowList = new RowList();
- this._cellCache = new CellCache(viewId);
- this._notifier = new RowChangeNotifier();
+ this.rowList = new RowList();
+ this.cellCache = new CellCache(viewId);
+ this.notifier = new RowChangeNotifier();
}
get rows(): readonly RowInfo[] {
- return this._rowList.rows;
+ return this.rowList.rows;
}
getCellCache = () => {
- return this._cellCache;
+ return this.cellCache;
};
loadCells = async (rowId: string): Promise<CellByFieldId> => {
- const opRow = this._rowList.getRow(rowId);
+ const opRow = this.rowList.getRow(rowId);
if (opRow.some) {
return this._toCellMap(opRow.val.row.id, this.getFieldInfos());
} else {
@@ -54,7 +54,7 @@ export class RowCache {
};
subscribeOnRowsChanged = (callback: (reason: RowChangedReason, cellMap?: Map<string, CellIdentifier>) => void) => {
- return this._notifier.observer.subscribe((change) => {
+ return this.notifier.observer.subscribe((change) => {
if (change.rowId !== undefined) {
callback(change.reason, this._toCellMap(change.rowId, this.getFieldInfos()));
} else {
@@ -65,18 +65,19 @@ export class RowCache {
onFieldUpdated = (fieldInfo: FieldInfo) => {
// Remove the cell data if the corresponding field was changed
- this._cellCache.removeWithFieldId(fieldInfo.field.id);
+ this.cellCache.removeWithFieldId(fieldInfo.field.id);
};
- onNumberOfFieldsUpdated = () => {
- this._notifier.withChange(RowChangedReason.FieldDidChanged);
+ onNumberOfFieldsUpdated = (fieldInfos: readonly FieldInfo[]) => {
+ this.rowList.setFieldInfos(fieldInfos);
+ this.notifier.withChange(RowChangedReason.FieldDidChanged);
};
initializeRows = (rows: RowPB[]) => {
rows.forEach((rowPB) => {
- this._rowList.push(this._toRowInfo(rowPB));
+ this.rowList.push(this._toRowInfo(rowPB));
});
- this._notifier.withChange(RowChangedReason.ReorderRows);
+ this.notifier.withChange(RowChangedReason.ReorderRows);
};
applyRowsChanged = (changeset: RowsChangesetPB) => {
@@ -91,15 +92,15 @@ export class RowCache {
};
applyReorderRows = (rowIds: string[]) => {
- this._rowList.reorderByRowIds(rowIds);
- this._notifier.withChange(RowChangedReason.ReorderRows);
+ this.rowList.reorderByRowIds(rowIds);
+ this.notifier.withChange(RowChangedReason.ReorderRows);
};
applyReorderSingleRow = (reorderRow: ReorderSingleRowPB) => {
- const rowInfo = this._rowList.getRow(reorderRow.row_id);
+ const rowInfo = this.rowList.getRow(reorderRow.row_id);
if (rowInfo !== undefined) {
- this._rowList.move({ rowId: reorderRow.row_id, fromIndex: reorderRow.old_index, toIndex: reorderRow.new_index });
- this._notifier.withChange(RowChangedReason.ReorderSingleRow, reorderRow.row_id);
+ this.rowList.move({ rowId: reorderRow.row_id, fromIndex: reorderRow.old_index, toIndex: reorderRow.new_index });
+ this.notifier.withChange(RowChangedReason.ReorderSingleRow, reorderRow.row_id);
}
};
@@ -108,14 +109,14 @@ export class RowCache {
return;
}
const updatedRow = opRow.row;
- const option = this._rowList.getRowWithIndex(updatedRow.id);
+ const option = this.rowList.getRowWithIndex(updatedRow.id);
if (option.some) {
const { rowInfo, index } = option.val;
- this._rowList.remove(rowInfo.row.id);
- this._rowList.insert(index, rowInfo.copyWith({ row: updatedRow }));
+ this.rowList.remove(rowInfo.row.id);
+ this.rowList.insert(index, rowInfo.copyWith({ row: updatedRow }));
} else {
const newRowInfo = new RowInfo(this.viewId, this.getFieldInfos(), updatedRow);
- this._rowList.push(newRowInfo);
+ this.rowList.push(newRowInfo);
}
};
@@ -126,9 +127,9 @@ export class RowCache {
private _deleteRows = (rowIds: string[]) => {
rowIds.forEach((rowId) => {
- const deletedRow = this._rowList.remove(rowId);
+ const deletedRow = this.rowList.remove(rowId);
if (deletedRow !== undefined) {
- this._notifier.withChange(RowChangedReason.Delete, deletedRow.rowInfo.row.id);
+ this.notifier.withChange(RowChangedReason.Delete, deletedRow.rowInfo.row.id);
}
});
};
@@ -136,9 +137,9 @@ export class RowCache {
private _insertRows = (rows: InsertedRowPB[]) => {
rows.forEach((insertedRow) => {
const rowInfo = this._toRowInfo(insertedRow.row);
- const insertedIndex = this._rowList.insert(insertedRow.index, rowInfo);
+ const insertedIndex = this.rowList.insert(insertedRow.index, rowInfo);
if (insertedIndex !== undefined) {
- this._notifier.withChange(RowChangedReason.Insert, insertedIndex.rowId);
+ this.notifier.withChange(RowChangedReason.Insert, insertedIndex.rowId);
}
});
};
@@ -152,39 +153,39 @@ export class RowCache {
updatedRows.forEach((updatedRow) => {
updatedRow.field_ids.forEach((fieldId) => {
const key = new CellCacheKey(fieldId, updatedRow.row.id);
- this._cellCache.remove(key);
+ this.cellCache.remove(key);
});
rowInfos.push(this._toRowInfo(updatedRow.row));
});
- const updatedIndexs = this._rowList.insertRows(rowInfos);
+ const updatedIndexs = this.rowList.insertRows(rowInfos);
updatedIndexs.forEach((row) => {
- this._notifier.withChange(RowChangedReason.Update, row.rowId);
+ this.notifier.withChange(RowChangedReason.Update, row.rowId);
});
};
private _hideRows = (rowIds: string[]) => {
rowIds.forEach((rowId) => {
- const deletedRow = this._rowList.remove(rowId);
+ const deletedRow = this.rowList.remove(rowId);
if (deletedRow !== undefined) {
- this._notifier.withChange(RowChangedReason.Delete, deletedRow.rowInfo.row.id);
+ this.notifier.withChange(RowChangedReason.Delete, deletedRow.rowInfo.row.id);
}
});
};
private _displayRows = (insertedRows: InsertedRowPB[]) => {
insertedRows.forEach((insertedRow) => {
- const insertedIndex = this._rowList.insert(insertedRow.index, this._toRowInfo(insertedRow.row));
+ const insertedIndex = this.rowList.insert(insertedRow.index, this._toRowInfo(insertedRow.row));
if (insertedIndex !== undefined) {
- this._notifier.withChange(RowChangedReason.Insert, insertedIndex.rowId);
+ this.notifier.withChange(RowChangedReason.Insert, insertedIndex.rowId);
}
});
};
dispose = async () => {
- this._notifier.dispose();
+ this.notifier.dispose();
};
private _toRowInfo = (rowPB: RowPB) => {
@@ -219,7 +220,6 @@ class RowList {
return Some(rowInfo);
}
};
-
getRowWithIndex = (rowId: string): Option<{ rowInfo: RowInfo; index: number }> => {
const rowInfo = this._rowInfoByRowId.get(rowId);
if (rowInfo !== undefined) {
@@ -322,6 +322,14 @@ class RowList {
includes = (rowId: string): boolean => {
return this._rowInfoByRowId.has(rowId);
};
+
+ setFieldInfos = (fieldInfos: readonly FieldInfo[]) => {
+ const newRowInfos: RowInfo[] = [];
+ this._rowInfos.forEach((rowInfo) => {
+ newRowInfos.push(rowInfo.copyWith({ fieldInfos: fieldInfos }));
+ });
+ this._rowInfos = newRowInfos;
+ };
}
export class RowInfo {
@@ -331,8 +339,8 @@ export class RowInfo {
public readonly row: RowPB
) {}
- copyWith = (params: { row?: RowPB }) => {
- return new RowInfo(this.viewId, this.fieldInfos, params.row || this.row);
+ copyWith = (params: { row?: RowPB; fieldInfos?: readonly FieldInfo[] }) => {
+ return new RowInfo(this.viewId, params.fieldInfos || this.fieldInfos, params.row || this.row);
};
}
diff --git a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/view/database_view_cache.ts b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/view/database_view_cache.ts
index 29b783864a..2a5d9303e6 100644
--- a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/view/database_view_cache.ts
+++ b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/view/database_view_cache.ts
@@ -12,10 +12,11 @@ export class DatabaseViewCache {
constructor(public readonly viewId: string, fieldController: FieldController) {
this.rowsObserver = new DatabaseViewRowsObserver(viewId);
this.rowCache = new RowCache(viewId, () => fieldController.fieldInfos);
- this.fieldSubscription = fieldController.subscribeOnFieldsChanged((fieldInfos) => {
+ this.fieldSubscription = fieldController.subscribeOnNumOfFieldsChanged((fieldInfos) => {
fieldInfos.forEach((fieldInfo) => {
this.rowCache.onFieldUpdated(fieldInfo);
});
+ this.rowCache.onNumberOfFieldsUpdated(fieldInfos);
});
}
diff --git a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/view/view_row_observer.ts b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/view/view_row_observer.ts
index 1bc3f4de6e..198c86e598 100644
--- a/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/view/view_row_observer.ts
+++ b/frontend/appflowy_tauri/src/appflowy_app/stores/effects/database/view/view_row_observer.ts
@@ -38,7 +38,7 @@ export class DatabaseViewRowsObserver {
this.reorderSingleRowNotifier.observer.subscribe(callbacks.onReorderSingleRow);
this._listener = new DatabaseNotificationObserver({
- viewId: this.viewId,
+ id: this.viewId,
parserHandler: (notification, result) => {
switch (notification) {
case DatabaseNotification.DidUpdateViewRowsVisibility:
diff --git a/frontend/rust-lib/flowy-codegen/src/ts_event/event_template.tera b/frontend/rust-lib/flowy-codegen/src/ts_event/event_template.tera
index 8444f304a8..2b23f78768 100644
--- a/frontend/rust-lib/flowy-codegen/src/ts_event/event_template.tera
+++ b/frontend/rust-lib/flowy-codegen/src/ts_event/event_template.tera
@@ -27,6 +27,7 @@ export async function {{ event_func_name }}(): Promise<Result<{{ output_deserial
console.log({{ event_func_name }}.name, object);
return Ok(object);
{%- else %}
+ console.log({{ event_func_name }}.name);
return Ok.EMPTY;
{%- endif %}
} else {
diff --git a/frontend/rust-lib/flowy-database/src/manager.rs b/frontend/rust-lib/flowy-database/src/manager.rs
index 2fb1ad316a..5195f567de 100644
--- a/frontend/rust-lib/flowy-database/src/manager.rs
+++ b/frontend/rust-lib/flowy-database/src/manager.rs
@@ -31,7 +31,7 @@ use flowy_task::TaskDispatcher;
use revision_model::Revision;
use std::sync::Arc;
-use tokio::sync::RwLock;
+use tokio::sync::{RwLock, RwLockWriteGuard, TryLockError};
pub trait DatabaseUser: Send + Sync {
fn user_id(&self) -> Result<String, FlowyError>;
@@ -118,7 +118,6 @@ impl DatabaseManager {
Ok(())
}
- #[tracing::instrument(level = "debug", skip_all, err)]
pub async fn create_database_block<T: AsRef<str>>(
&self,
block_id: T,
@@ -141,33 +140,32 @@ impl DatabaseManager {
.await
}
+ #[tracing::instrument(level = "debug", skip_all)]
pub async fn close_database_view<T: AsRef<str>>(&self, view_id: T) -> FlowyResult<()> {
let view_id = view_id.as_ref();
let database_info = self.database_ref_indexer.get_database_with_view(view_id)?;
tracing::Span::current().record("database_id", &database_info.database_id);
- let mut should_remove_editor = false;
- if let Some(database_editor) = self
- .editors_by_database_id
- .write()
- .await
- .get(&database_info.database_id)
- {
- database_editor.close_view_editor(view_id).await;
- should_remove_editor = database_editor.number_of_ref_views().await == 0;
- if should_remove_editor {
- database_editor.dispose().await;
- }
+ match self.editors_by_database_id.try_write() {
+ Ok(mut write_guard) => {
+ if let Some(database_editor) = write_guard.remove(&database_info.database_id) {
+ database_editor.close_view_editor(view_id).await;
+ if database_editor.number_of_ref_views().await == 0 {
+ database_editor.dispose().await;
+ } else {
+ self
+ .editors_by_database_id
+ .write()
+ .await
+ .insert(database_info.database_id, database_editor);
+ }
+ }
+ },
+ Err(_) => {
+ tracing::error!("Try to get the lock of editors_by_database_id failed");
+ },
}
- if should_remove_editor {
- tracing::debug!("Close database base editor: {}", database_info.database_id);
- self
- .editors_by_database_id
- .write()
- .await
- .remove(&database_info.database_id);
- }
Ok(())
}
@@ -235,12 +233,10 @@ impl DatabaseManager {
pool: Arc<ConnectionPool>,
) -> Result<Arc<DatabaseEditor>, FlowyError> {
let user = self.database_user.clone();
- tracing::debug!("Open database view: {}", view_id);
let (base_view_pad, base_view_rev_manager) =
make_database_view_revision_pad(view_id, user.clone()).await?;
let mut database_id = base_view_pad.database_id.clone();
-
- tracing::debug!("Open database: {}", database_id);
+ tracing::debug!("Open database: {} with view: {}", database_id, view_id);
if database_id.is_empty() {
// Before the database_id concept comes up, we used the view_id directly. So if
// the database_id is empty, which means we can used the view_id. After the version 0.1.1,
diff --git a/frontend/rust-lib/flowy-database/src/services/database/database_editor.rs b/frontend/rust-lib/flowy-database/src/services/database/database_editor.rs
index f497051afb..701ff72a98 100644
--- a/frontend/rust-lib/flowy-database/src/services/database/database_editor.rs
+++ b/frontend/rust-lib/flowy-database/src/services/database/database_editor.rs
@@ -116,13 +116,13 @@ impl DatabaseEditor {
self.database_views.open(view_editor).await
}
- #[tracing::instrument(name = "Close database editor view", level = "debug", skip_all)]
+ #[tracing::instrument(level = "debug", skip_all)]
pub async fn close_view_editor(&self, view_id: &str) {
- self.rev_manager.generate_snapshot().await;
self.database_views.close(view_id).await;
}
pub async fn dispose(&self) {
+ self.rev_manager.generate_snapshot().await;
self.database_blocks.close().await;
self.rev_manager.close().await;
}
diff --git a/frontend/rust-lib/flowy-database/src/services/database_view/editor.rs b/frontend/rust-lib/flowy-database/src/services/database_view/editor.rs
index 3454290ce4..e6918b9f50 100644
--- a/frontend/rust-lib/flowy-database/src/services/database_view/editor.rs
+++ b/frontend/rust-lib/flowy-database/src/services/database_view/editor.rs
@@ -178,12 +178,12 @@ impl DatabaseViewEditor {
.await
}
- #[tracing::instrument(name = "close grid view editor", level = "trace", skip_all)]
+ #[tracing::instrument(name = "close database view editor", level = "trace", skip_all)]
pub async fn close(&self) {
self.rev_manager.generate_snapshot().await;
self.rev_manager.close().await;
self.filter_controller.close().await;
- self.sort_controller.read().await.close().await;
+ self.sort_controller.write().await.close().await;
}
pub async fn handle_block_event(&self, event: Cow<'_, DatabaseBlockEvent>) {
@@ -509,8 +509,8 @@ impl DatabaseViewEditor {
.did_receive_changes(SortChangeset::from_insert(sort_type))
.await
};
- self.notify_did_update_sort(changeset).await;
drop(sort_controller);
+ self.notify_did_update_sort(changeset).await;
Ok(sort_rev)
}
@@ -539,7 +539,7 @@ impl DatabaseViewEditor {
pub async fn v_delete_all_sorts(&self) -> FlowyResult<()> {
let all_sorts = self.v_get_all_sorts().await;
- self.sort_controller.write().await.delete_all_sorts().await;
+ // self.sort_controller.write().await.delete_all_sorts().await;
self
.modify(|pad| {
let changeset = pad.delete_all_sorts()?;
diff --git a/frontend/rust-lib/flowy-database/src/services/database_view/editor_manager.rs b/frontend/rust-lib/flowy-database/src/services/database_view/editor_manager.rs
index 854d94f676..05975b1fb2 100644
--- a/frontend/rust-lib/flowy-database/src/services/database_view/editor_manager.rs
+++ b/frontend/rust-lib/flowy-database/src/services/database_view/editor_manager.rs
@@ -60,7 +60,11 @@ impl DatabaseViews {
}
pub async fn close(&self, view_id: &str) {
- self.view_editors.write().await.remove(view_id).await;
+ if let Ok(mut view_editors) = self.view_editors.try_write() {
+ view_editors.remove(view_id).await;
+ } else {
+ tracing::error!("Try to get the lock of view_editors failed");
+ }
}
pub async fn number_of_views(&self) -> usize {
diff --git a/frontend/rust-lib/flowy-database/src/services/field/type_options/type_option_cell.rs b/frontend/rust-lib/flowy-database/src/services/field/type_options/type_option_cell.rs
index 36e5f99466..b3f1e8e8cd 100644
--- a/frontend/rust-lib/flowy-database/src/services/field/type_options/type_option_cell.rs
+++ b/frontend/rust-lib/flowy-database/src/services/field/type_options/type_option_cell.rs
@@ -289,6 +289,7 @@ where
decoded_field_type: &FieldType,
field_rev: &FieldRevision,
) -> FlowyResult<BoxCellData> {
+ // tracing::debug!("get_cell_data: {:?}", std::any::type_name::<Self>());
let cell_data = if self.transformable() {
match self.transform_type_option_cell_str(&cell_str, decoded_field_type, field_rev) {
None => self.get_decoded_cell_data(cell_str, decoded_field_type, field_rev)?,
diff --git a/frontend/rust-lib/flowy-database/src/services/persistence/rev_sqlite/block_impl.rs b/frontend/rust-lib/flowy-database/src/services/persistence/rev_sqlite/block_impl.rs
index bfd640bba1..fadaec2ff9 100644
--- a/frontend/rust-lib/flowy-database/src/services/persistence/rev_sqlite/block_impl.rs
+++ b/frontend/rust-lib/flowy-database/src/services/persistence/rev_sqlite/block_impl.rs
@@ -22,7 +22,7 @@ impl RevisionDiskCache<Arc<ConnectionPool>> for SQLiteDatabaseBlockRevisionPersi
fn create_revision_records(&self, revision_records: Vec<SyncRecord>) -> Result<(), Self::Error> {
let conn = self.pool.get().map_err(internal_error)?;
- GridMetaRevisionSql::create(revision_records, &conn)?;
+ DatabaseBlockMetaRevisionSql::create(revision_records, &conn)?;
Ok(())
}
@@ -36,7 +36,7 @@ impl RevisionDiskCache<Arc<ConnectionPool>> for SQLiteDatabaseBlockRevisionPersi
rev_ids: Option<Vec<i64>>,
) -> Result<Vec<SyncRecord>, Self::Error> {
let conn = self.pool.get().map_err(internal_error)?;
- let records = GridMetaRevisionSql::read(&self.user_id, object_id, rev_ids, &conn)?;
+ let records = DatabaseBlockMetaRevisionSql::read(&self.user_id, object_id, rev_ids, &conn)?;
Ok(records)
}
@@ -47,7 +47,7 @@ impl RevisionDiskCache<Arc<ConnectionPool>> for SQLiteDatabaseBlockRevisionPersi
) -> Result<Vec<SyncRecord>, Self::Error> {
let conn = &*self.pool.get().map_err(internal_error)?;
let revisions =
- GridMetaRevisionSql::read_with_range(&self.user_id, object_id, range.clone(), conn)?;
+ DatabaseBlockMetaRevisionSql::read_with_range(&self.user_id, object_id, range.clone(), conn)?;
Ok(revisions)
}
@@ -55,7 +55,7 @@ impl RevisionDiskCache<Arc<ConnectionPool>> for SQLiteDatabaseBlockRevisionPersi
let conn = &*self.pool.get().map_err(internal_error)?;
conn.immediate_transaction::<_, FlowyError, _>(|| {
for changeset in changesets {
- GridMetaRevisionSql::update(changeset, conn)?;
+ DatabaseBlockMetaRevisionSql::update(changeset, conn)?;
}
Ok(())
})?;
@@ -68,7 +68,7 @@ impl RevisionDiskCache<Arc<ConnectionPool>> for SQLiteDatabaseBlockRevisionPersi
rev_ids: Option<Vec<i64>>,
) -> Result<(), Self::Error> {
let conn = &*self.pool.get().map_err(internal_error)?;
- GridMetaRevisionSql::delete(object_id, rev_ids, conn)?;
+ DatabaseBlockMetaRevisionSql::delete(object_id, rev_ids, conn)?;
Ok(())
}
@@ -80,8 +80,8 @@ impl RevisionDiskCache<Arc<ConnectionPool>> for SQLiteDatabaseBlockRevisionPersi
) -> Result<(), Self::Error> {
let conn = self.pool.get().map_err(internal_error)?;
conn.immediate_transaction::<_, FlowyError, _>(|| {
- GridMetaRevisionSql::delete(object_id, deleted_rev_ids, &conn)?;
- GridMetaRevisionSql::create(inserted_records, &conn)?;
+ DatabaseBlockMetaRevisionSql::delete(object_id, deleted_rev_ids, &conn)?;
+ DatabaseBlockMetaRevisionSql::create(inserted_records, &conn)?;
Ok(())
})
}
@@ -96,8 +96,8 @@ impl SQLiteDatabaseBlockRevisionPersistence {
}
}
-struct GridMetaRevisionSql();
-impl GridMetaRevisionSql {
+struct DatabaseBlockMetaRevisionSql();
+impl DatabaseBlockMetaRevisionSql {
fn create(revision_records: Vec<SyncRecord>, conn: &SqliteConnection) -> Result<(), FlowyError> {
// Batch insert: https://diesel.rs/guides/all-about-inserts.html
@@ -105,7 +105,8 @@ impl GridMetaRevisionSql {
.into_iter()
.map(|record| {
tracing::trace!(
- "[GridMetaRevisionSql] create revision: {}:{:?}",
+ "[{}] create revision: {}:{:?}",
+ std::any::type_name::<Self>(),
record.revision.object_id,
record.revision.rev_id
);
@@ -133,7 +134,8 @@ impl GridMetaRevisionSql {
.filter(dsl::object_id.eq(changeset.object_id));
let _ = update(filter).set(dsl::state.eq(state)).execute(conn)?;
tracing::debug!(
- "[GridMetaRevisionSql] update revision:{} state:to {:?}",
+ "[{}] update revision:{} state:to {:?}",
+ std::any::type_name::<Self>(),
changeset.rev_id,
changeset.state
);
@@ -193,7 +195,8 @@ impl GridMetaRevisionSql {
if let Some(rev_ids) = rev_ids {
tracing::trace!(
- "[GridMetaRevisionSql] Delete revision: {}:{:?}",
+ "[{}] Delete revision: {}:{:?}",
+ std::any::type_name::<Self>(),
object_id,
rev_ids
);
@@ -201,7 +204,11 @@ impl GridMetaRevisionSql {
}
let affected_row = sql.execute(conn)?;
- tracing::trace!("[GridMetaRevisionSql] Delete {} rows", affected_row);
+ tracing::trace!(
+ "[{}] Delete {} rows",
+ std::any::type_name::<Self>(),
+ affected_row
+ );
Ok(())
}
}
diff --git a/frontend/rust-lib/flowy-database/src/services/persistence/rev_sqlite/database_impl.rs b/frontend/rust-lib/flowy-database/src/services/persistence/rev_sqlite/database_impl.rs
index d146a01116..7a84e02f32 100644
--- a/frontend/rust-lib/flowy-database/src/services/persistence/rev_sqlite/database_impl.rs
+++ b/frontend/rust-lib/flowy-database/src/services/persistence/rev_sqlite/database_impl.rs
@@ -104,7 +104,8 @@ impl DatabaseRevisionSql {
.into_iter()
.map(|record| {
tracing::trace!(
- "[GridRevisionSql] create revision: {}:{:?}",
+ "[{}] create revision: {}:{:?}",
+ std::any::type_name::<Self>(),
record.revision.object_id,
record.revision.rev_id
);
@@ -132,7 +133,8 @@ impl DatabaseRevisionSql {
.filter(dsl::object_id.eq(changeset.object_id));
let _ = update(filter).set(dsl::state.eq(state)).execute(conn)?;
tracing::debug!(
- "[GridRevisionSql] update revision:{} state:to {:?}",
+ "[{}] update revision:{} state:to {:?}",
+ std::any::type_name::<Self>(),
changeset.rev_id,
changeset.state
);
@@ -192,7 +194,8 @@ impl DatabaseRevisionSql {
if let Some(rev_ids) = rev_ids {
tracing::trace!(
- "[GridRevisionSql] Delete revision: {}:{:?}",
+ "[{}] Delete revision: {}:{:?}",
+ std::any::type_name::<Self>(),
object_id,
rev_ids
);
@@ -200,7 +203,11 @@ impl DatabaseRevisionSql {
}
let affected_row = sql.execute(conn)?;
- tracing::trace!("[GridRevisionSql] Delete {} rows", affected_row);
+ tracing::trace!(
+ "[{}] Delete {} rows",
+ std::any::type_name::<Self>(),
+ affected_row
+ );
Ok(())
}
}
diff --git a/frontend/rust-lib/flowy-database/src/services/persistence/rev_sqlite/view_impl.rs b/frontend/rust-lib/flowy-database/src/services/persistence/rev_sqlite/view_impl.rs
index df076b62e7..d6f4340f7e 100644
--- a/frontend/rust-lib/flowy-database/src/services/persistence/rev_sqlite/view_impl.rs
+++ b/frontend/rust-lib/flowy-database/src/services/persistence/rev_sqlite/view_impl.rs
@@ -31,7 +31,7 @@ impl RevisionDiskCache<Arc<ConnectionPool>> for SQLiteDatabaseViewRevisionPersis
fn create_revision_records(&self, revision_records: Vec<SyncRecord>) -> Result<(), Self::Error> {
let conn = self.pool.get().map_err(internal_error)?;
- GridViewRevisionSql::create(revision_records, &conn)?;
+ DatabaseViewRevisionSql::create(revision_records, &conn)?;
Ok(())
}
@@ -45,7 +45,7 @@ impl RevisionDiskCache<Arc<ConnectionPool>> for SQLiteDatabaseViewRevisionPersis
rev_ids: Option<Vec<i64>>,
) -> Result<Vec<SyncRecord>, Self::Error> {
let conn = self.pool.get().map_err(internal_error)?;
- let records = GridViewRevisionSql::read(&self.user_id, object_id, rev_ids, &conn)?;
+ let records = DatabaseViewRevisionSql::read(&self.user_id, object_id, rev_ids, &conn)?;
Ok(records)
}
@@ -56,7 +56,7 @@ impl RevisionDiskCache<Arc<ConnectionPool>> for SQLiteDatabaseViewRevisionPersis
) -> Result<Vec<SyncRecord>, Self::Error> {
let conn = &*self.pool.get().map_err(internal_error)?;
let revisions =
- GridViewRevisionSql::read_with_range(&self.user_id, object_id, range.clone(), conn)?;
+ DatabaseViewRevisionSql::read_with_range(&self.user_id, object_id, range.clone(), conn)?;
Ok(revisions)
}
@@ -64,7 +64,7 @@ impl RevisionDiskCache<Arc<ConnectionPool>> for SQLiteDatabaseViewRevisionPersis
let conn = &*self.pool.get().map_err(internal_error)?;
conn.immediate_transaction::<_, FlowyError, _>(|| {
for changeset in changesets {
- GridViewRevisionSql::update(changeset, conn)?;
+ DatabaseViewRevisionSql::update(changeset, conn)?;
}
Ok(())
})?;
@@ -77,7 +77,7 @@ impl RevisionDiskCache<Arc<ConnectionPool>> for SQLiteDatabaseViewRevisionPersis
rev_ids: Option<Vec<i64>>,
) -> Result<(), Self::Error> {
let conn = &*self.pool.get().map_err(internal_error)?;
- GridViewRevisionSql::delete(object_id, rev_ids, conn)?;
+ DatabaseViewRevisionSql::delete(object_id, rev_ids, conn)?;
Ok(())
}
@@ -89,22 +89,23 @@ impl RevisionDiskCache<Arc<ConnectionPool>> for SQLiteDatabaseViewRevisionPersis
) -> Result<(), Self::Error> {
let conn = self.pool.get().map_err(internal_error)?;
conn.immediate_transaction::<_, FlowyError, _>(|| {
- GridViewRevisionSql::delete(object_id, deleted_rev_ids, &conn)?;
- GridViewRevisionSql::create(inserted_records, &conn)?;
+ DatabaseViewRevisionSql::delete(object_id, deleted_rev_ids, &conn)?;
+ DatabaseViewRevisionSql::create(inserted_records, &conn)?;
Ok(())
})
}
}
-struct GridViewRevisionSql();
-impl GridViewRevisionSql {
+struct DatabaseViewRevisionSql();
+impl DatabaseViewRevisionSql {
fn create(revision_records: Vec<SyncRecord>, conn: &SqliteConnection) -> Result<(), FlowyError> {
// Batch insert: https://diesel.rs/guides/all-about-inserts.html
let records = revision_records
.into_iter()
.map(|record| {
tracing::trace!(
- "[GridViewRevisionSql] create revision: {}:{:?}",
+ "[{}] create revision: {}:{:?}",
+ std::any::type_name::<Self>(),
record.revision.object_id,
record.revision.rev_id
);
@@ -132,7 +133,8 @@ impl GridViewRevisionSql {
.filter(dsl::object_id.eq(changeset.object_id));
let _ = update(filter).set(dsl::state.eq(state)).execute(conn)?;
tracing::debug!(
- "[GridViewRevisionSql] update revision:{} state:to {:?}",
+ "[{}] update revision:{} state:to {:?}",
+ std::any::type_name::<Self>(),
changeset.rev_id,
changeset.state
);
@@ -192,7 +194,8 @@ impl GridViewRevisionSql {
if let Some(rev_ids) = rev_ids {
tracing::trace!(
- "[GridViewRevisionSql] Delete revision: {}:{:?}",
+ "[{}] Delete revision: {}:{:?}",
+ std::any::type_name::<Self>(),
object_id,
rev_ids
);
@@ -200,7 +203,11 @@ impl GridViewRevisionSql {
}
let affected_row = sql.execute(conn)?;
- tracing::trace!("[GridViewRevisionSql] Delete {} rows", affected_row);
+ tracing::trace!(
+ "[{}] Delete {} rows",
+ std::any::type_name::<Self>(),
+ affected_row
+ );
Ok(())
}
}
diff --git a/frontend/rust-lib/flowy-database/src/services/sort/controller.rs b/frontend/rust-lib/flowy-database/src/services/sort/controller.rs
index 49e048754a..ab6ac9b721 100644
--- a/frontend/rust-lib/flowy-database/src/services/sort/controller.rs
+++ b/frontend/rust-lib/flowy-database/src/services/sort/controller.rs
@@ -63,12 +63,11 @@ impl SortController {
}
pub async fn close(&self) {
- self
- .task_scheduler
- .write()
- .await
- .unregister_handler(&self.handler_id)
- .await;
+ if let Ok(mut task_scheduler) = self.task_scheduler.try_write() {
+ // task_scheduler.unregister_handler(&self.handler_id).await;
+ } else {
+ tracing::error!("Try to get the lock of task_scheduler failed");
+ }
}
pub async fn did_receive_row_changed(&self, row_id: &str) {
diff --git a/frontend/rust-lib/flowy-folder/src/services/persistence/rev_sqlite/folder_rev_sqlite.rs b/frontend/rust-lib/flowy-folder/src/services/persistence/rev_sqlite/folder_rev_sqlite.rs
index 59df4f4c2a..de32507c4e 100644
--- a/frontend/rust-lib/flowy-folder/src/services/persistence/rev_sqlite/folder_rev_sqlite.rs
+++ b/frontend/rust-lib/flowy-folder/src/services/persistence/rev_sqlite/folder_rev_sqlite.rs
@@ -106,7 +106,8 @@ impl FolderRevisionSql {
.into_iter()
.map(|record| {
tracing::trace!(
- "[TextRevisionSql] create revision: {}:{:?}",
+ "[{}] create revision: {}:{:?}",
+ std::any::type_name::<Self>(),
record.revision.object_id,
record.revision.rev_id
);
@@ -135,7 +136,8 @@ impl FolderRevisionSql {
.filter(dsl::doc_id.eq(changeset.object_id));
let _ = update(filter).set(dsl::state.eq(state)).execute(conn)?;
tracing::debug!(
- "[TextRevisionSql] update revision:{} state:to {:?}",
+ "[{}] update revision:{} state:to {:?}",
+ std::any::type_name::<Self>(),
changeset.rev_id,
changeset.state
);
@@ -193,7 +195,8 @@ impl FolderRevisionSql {
if let Some(rev_ids) = rev_ids {
tracing::trace!(
- "[TextRevisionSql] Delete revision: {}:{:?}",
+ "[{}] Delete revision: {}:{:?}",
+ std::any::type_name::<Self>(),
object_id,
rev_ids
);
@@ -201,7 +204,11 @@ impl FolderRevisionSql {
}
let affected_row = sql.execute(conn)?;
- tracing::trace!("[TextRevisionSql] Delete {} rows", affected_row);
+ tracing::trace!(
+ "[{}] Delete {} rows",
+ std::any::type_name::<Self>(),
+ affected_row
+ );
Ok(())
}
}
diff --git a/frontend/rust-lib/flowy-task/src/scheduler.rs b/frontend/rust-lib/flowy-task/src/scheduler.rs
index ee9e4d979a..ae61bb08bb 100644
--- a/frontend/rust-lib/flowy-task/src/scheduler.rs
+++ b/frontend/rust-lib/flowy-task/src/scheduler.rs
@@ -5,6 +5,7 @@ use anyhow::Error;
use lib_infra::async_trait::async_trait;
use lib_infra::future::BoxResultFuture;
use lib_infra::ref_map::{RefCountHashMap, RefCountValue};
+use std::collections::HashMap;
use std::sync::Arc;
use std::time::Duration;
@@ -15,7 +16,7 @@ pub struct TaskDispatcher {
queue: TaskQueue,
store: TaskStore,
timeout: Duration,
- handlers: RefCountHashMap<RefCountTaskHandler>,
+ handlers: HashMap<String, Arc<dyn TaskHandler>>,
notifier: watch::Sender<bool>,
pub(crate) notifier_rx: Option<watch::Receiver<bool>>,
@@ -28,7 +29,7 @@ impl TaskDispatcher {
queue: TaskQueue::new(),
store: TaskStore::new(),
timeout,
- handlers: RefCountHashMap::new(),
+ handlers: HashMap::new(),
notifier,
notifier_rx: Some(notifier_rx),
}
@@ -39,13 +40,17 @@ impl TaskDispatcher {
T: TaskHandler,
{
let handler_id = handler.handler_id().to_owned();
- self
- .handlers
- .insert(handler_id, RefCountTaskHandler(Arc::new(handler)));
+ self.handlers.insert(handler_id, Arc::new(handler));
}
pub async fn unregister_handler<T: AsRef<str>>(&mut self, handler_id: T) {
- self.handlers.remove(handler_id.as_ref()).await;
+ if let Some(handler) = self.handlers.remove(handler_id.as_ref()) {
+ tracing::trace!(
+ "{}:{} is unregistered",
+ handler.handler_name(),
+ handler.handler_id()
+ );
+ }
}
pub fn stop(&mut self) {
@@ -54,6 +59,7 @@ impl TaskDispatcher {
self.store.clear();
}
+ #[tracing::instrument(level = "trace", skip_all)]
pub(crate) async fn process_next_task(&mut self) -> Option<()> {
let pending_task = self.queue.mut_head(|list| list.pop())?;
let mut task = self.store.remove_task(&pending_task.id)?;
@@ -69,25 +75,25 @@ impl TaskDispatcher {
let content = task.content.take()?;
if let Some(handler) = self.handlers.get(&task.handler_id) {
task.set_state(TaskState::Processing);
- tracing::trace!(
- "Run {} task with content: {:?}",
- handler.handler_name(),
- content
- );
+ tracing::trace!("{} task is running", handler.handler_name(),);
match tokio::time::timeout(self.timeout, handler.run(content)).await {
Ok(result) => match result {
- Ok(_) => task.set_state(TaskState::Done),
+ Ok(_) => {
+ tracing::trace!("{} task is done", handler.handler_name(),);
+ task.set_state(TaskState::Done)
+ },
Err(e) => {
- tracing::error!("Process {} task failed: {:?}", handler.handler_name(), e);
+ tracing::error!("{} task is failed: {:?}", handler.handler_name(), e);
task.set_state(TaskState::Failure);
},
},
Err(e) => {
- tracing::error!("Process {} task timeout: {:?}", handler.handler_name(), e);
+ tracing::error!("{} task is timeout: {:?}", handler.handler_name(), e);
task.set_state(TaskState::Timeout);
},
}
} else {
+ tracing::trace!("{} is cancel", task.handler_id);
task.set_state(TaskState::Cancel);
}
let _ = ret.send(task.into());
@@ -197,18 +203,3 @@ where
(**self).run(content)
}
}
-#[derive(Clone)]
-struct RefCountTaskHandler(Arc<dyn TaskHandler>);
-
-#[async_trait]
-impl RefCountValue for RefCountTaskHandler {
- async fn did_remove(&self) {}
-}
-
-impl std::ops::Deref for RefCountTaskHandler {
- type Target = Arc<dyn TaskHandler>;
-
- fn deref(&self) -> &Self::Target {
- &self.0
- }
-}