Skip to content

Database diagrams editor that allows you to visualize and design your DB with a single query.

redo undo skeleton

Guy Ben-Aharonb8521d8b2aa3
diff --git a/package-lock.json b/package-lock.json
index cde7088d..f23efeab 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -24,6 +24,7 @@
"@radix-ui/react-toggle": "^1.1.0",
"@radix-ui/react-toggle-group": "^1.1.0",
"@radix-ui/react-tooltip": "^1.1.2",
+ "@uidotdev/usehooks": "^2.4.1",
"@xyflow/react": "^12.0.4",
"class-variance-authority": "^0.7.0",
"clsx": "^2.1.1",
@@ -2736,6 +2737,19 @@
"url": "https://opencollective.com/typescript-eslint"
}
},
+ "node_modules/@uidotdev/usehooks": {
+ "version": "2.4.1",
+ "resolved": "https://registry.npmjs.org/@uidotdev/usehooks/-/usehooks-2.4.1.tgz",
+ "integrity": "sha512-1I+RwWyS+kdv3Mv0Vmc+p0dPYH0DTRAo04HLyXReYBL9AeseDWUJyi4THuksBJcu9F0Pih69Ak150VDnqbVnXg==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=16"
+ },
+ "peerDependencies": {
+ "react": ">=18.0.0",
+ "react-dom": ">=18.0.0"
+ }
+ },
"node_modules/@ungap/structured-clone": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.2.0.tgz",
diff --git a/package.json b/package.json
index a7b5f7c1..59e83fd9 100644
--- a/package.json
+++ b/package.json
@@ -27,6 +27,7 @@
"@radix-ui/react-toggle": "^1.1.0",
"@radix-ui/react-toggle-group": "^1.1.0",
"@radix-ui/react-tooltip": "^1.1.2",
+ "@uidotdev/usehooks": "^2.4.1",
"@xyflow/react": "^12.0.4",
"class-variance-authority": "^0.7.0",
"clsx": "^2.1.1",
diff --git a/src/context/chartdb-context/chartdb-context.tsx b/src/context/chartdb-context/chartdb-context.tsx
index 2734a86c..3520c0a7 100644
--- a/src/context/chartdb-context/chartdb-context.tsx
+++ b/src/context/chartdb-context/chartdb-context.tsx
@@ -28,7 +28,7 @@ export interface ChartDBContext {
getTable: (id: string) => DBTable | null;
removeTable: (id: string) => Promise<void>;
updateTable: (id: string, table: Partial<DBTable>) => Promise<void>;
- updateTables: (tables: PartialExcept<DBTable, 'id'>[]) => Promise<void>;
+ // updateTables: (tables: PartialExcept<DBTable, 'id'>[]) => Promise<void>;
updateTablesState: (
updateFn: (tables: DBTable[]) => PartialExcept<DBTable, 'id'>[]
) => Promise<void>;
@@ -74,7 +74,7 @@ export interface ChartDBContext {
export const chartDBContext = createContext<ChartDBContext>({
databaseType: DatabaseType.GENERIC,
- diagramName: 'New Diagram',
+ diagramName: '',
diagramId: '',
tables: [],
relationships: [],
@@ -88,7 +88,7 @@ export const chartDBContext = createContext<ChartDBContext>({
updateDatabaseType: emptyFn,
// Table operations
- updateTables: emptyFn,
+ // updateTables: emptyFn,
createTable: emptyFn,
getTable: emptyFn,
addTable: emptyFn,
diff --git a/src/context/chartdb-context/chartdb-provider.tsx b/src/context/chartdb-context/chartdb-provider.tsx
index 91dd1632..74b36805 100644
--- a/src/context/chartdb-context/chartdb-provider.tsx
+++ b/src/context/chartdb-context/chartdb-provider.tsx
@@ -7,13 +7,22 @@ import { DBField } from '@/lib/domain/db-field';
import { DBIndex } from '@/lib/domain/db-index';
import { DBRelationship } from '@/lib/domain/db-relationship';
import { useStorage } from '@/hooks/use-storage';
+import { useRedoUndoStack } from '@/hooks/use-redo-undo-stack';
export const ChartDBProvider: React.FC<React.PropsWithChildren> = ({
children,
}) => {
- const [diagramId, setDiagramId] = React.useState('');
const db = useStorage();
- const [diagramName, setDiagramName] = React.useState('New Diagram');
+ const { setRedoStack, setUndoStack } = useRedoUndoStack();
+ console.log({ setRedoStack, setUndoStack });
+ // const [undoStack, setUndoStack] = React.useState<
+ // {
+ // action: string;
+ // data: any;
+ // }[]
+ // >([]);
+ const [diagramId, setDiagramId] = React.useState('');
+ const [diagramName, setDiagramName] = React.useState('');
const [databaseType, setDatabaseType] = React.useState<DatabaseType>(
DatabaseType.GENERIC
);
@@ -22,35 +31,45 @@ export const ChartDBProvider: React.FC<React.PropsWithChildren> = ({
[]
);
- const updateDatabaseType: ChartDBContext['updateDatabaseType'] = async (
- databaseType
- ) => {
- setDatabaseType(databaseType);
- await db.updateDiagram({
- id: diagramId,
- attributes: {
- databaseType,
+ const updateDatabaseType: ChartDBContext['updateDatabaseType'] =
+ useCallback(
+ async (databaseType) => {
+ setDatabaseType(databaseType);
+ await db.updateDiagram({
+ id: diagramId,
+ attributes: {
+ databaseType,
+ },
+ });
},
- });
- };
- const updateDiagramId: ChartDBContext['updateDiagramId'] = async (id) => {
- const prevId = diagramId;
- setDiagramId(id);
- await db.updateDiagram({ id: prevId, attributes: { id } });
- };
- const updateDiagramName: ChartDBContext['updateDiagramName'] = async (
- name
- ) => {
- setDiagramName(name);
- await db.updateDiagram({ id: diagramId, attributes: { name } });
- };
-
- const addTable: ChartDBContext['addTable'] = (table: DBTable) => {
- setTables((tables) => [...tables, table]);
- return db.addTable({ diagramId, table });
- };
-
- const createTable: ChartDBContext['createTable'] = async () => {
+ [db, diagramId, setDatabaseType]
+ );
+ const updateDiagramId: ChartDBContext['updateDiagramId'] = useCallback(
+ async (id) => {
+ const prevId = diagramId;
+ setDiagramId(id);
+ await db.updateDiagram({ id: prevId, attributes: { id } });
+ },
+ [db, diagramId, setDiagramId]
+ );
+
+ const updateDiagramName: ChartDBContext['updateDiagramName'] = useCallback(
+ async (name) => {
+ setDiagramName(name);
+ await db.updateDiagram({ id: diagramId, attributes: { name } });
+ },
+ [db, diagramId, setDiagramName]
+ );
+
+ const addTable: ChartDBContext['addTable'] = useCallback(
+ (table: DBTable) => {
+ setTables((tables) => [...tables, table]);
+ return db.addTable({ diagramId, table });
+ },
+ [db, diagramId, setTables]
+ );
+
+ const createTable: ChartDBContext['createTable'] = useCallback(async () => {
const table: DBTable = {
id: generateId(),
name: `table_${tables.length + 1}`,
@@ -74,394 +93,426 @@ export const ChartDBProvider: React.FC<React.PropsWithChildren> = ({
await addTable(table);
return table;
- };
-
- const getTable: ChartDBContext['getTable'] = (id: string) =>
- tables.find((table) => table.id === id) ?? null;
-
- const removeTable: ChartDBContext['removeTable'] = async (id: string) => {
- setTables((tables) => tables.filter((table) => table.id !== id));
- await db.deleteTable({ diagramId, id });
- };
-
- const updateTable: ChartDBContext['updateTable'] = async (
- id: string,
- table: Partial<DBTable>
- ) => {
- setTables((tables) =>
- tables.map((t) => (t.id === id ? { ...t, ...table } : t))
- );
- await db.updateTable({ id, attributes: table });
- };
-
- const updateTables: ChartDBContext['updateTables'] = async (
- tables: PartialExcept<DBTable, 'id'>[]
- ) => {
- setTables((currentTables) =>
- currentTables.map((table) => {
- const updatedTable = tables.find((t) => t.id === table.id);
- return updatedTable ? { ...table, ...updatedTable } : table;
- })
- );
+ }, [addTable, tables]);
+
+ const getTable: ChartDBContext['getTable'] = useCallback(
+ (id: string) => tables.find((table) => table.id === id) ?? null,
+ [tables]
+ );
- const promises = [];
- for (const table of tables) {
- promises.push(db.updateTable({ id: table.id, attributes: table }));
- }
-
- await Promise.all(promises);
- };
-
- const updateTablesState: ChartDBContext['updateTablesState'] = async (
- updateFn: (tables: DBTable[]) => PartialExcept<DBTable, 'id'>[]
- ) => {
- const updatedTables = updateFn(tables);
- setTables((prevTables) => {
- const updatedTables = updateFn(prevTables);
- return prevTables
- .map((prevTable) => {
- const updatedTable = updatedTables.find(
- (t) => t.id === prevTable.id
+ const removeTable: ChartDBContext['removeTable'] = useCallback(
+ async (id: string) => {
+ setTables((tables) => tables.filter((table) => table.id !== id));
+ await db.deleteTable({ diagramId, id });
+ },
+ [db, diagramId, setTables]
+ );
+
+ const updateTable: ChartDBContext['updateTable'] = useCallback(
+ async (id: string, table: Partial<DBTable>) => {
+ setTables((tables) =>
+ tables.map((t) => (t.id === id ? { ...t, ...table } : t))
+ );
+ await db.updateTable({ id, attributes: table });
+ },
+ [db, setTables]
+ );
+
+ // const updateTables: ChartDBContext['updateTables'] = useCallback(
+ // async (tables: PartialExcept<DBTable, 'id'>[]) => {
+ // setTables((currentTables) =>
+ // currentTables.map((table) => {
+ // const updatedTable = tables.find((t) => t.id === table.id);
+ // return updatedTable ? { ...table, ...updatedTable } : table;
+ // })
+ // );
+
+ // const promises = [];
+ // for (const table of tables) {
+ // promises.push(
+ // db.updateTable({ id: table.id, attributes: table })
+ // );
+ // }
+
+ // await Promise.all(promises);
+ // },
+ // [db, setTables]
+ // );
+
+ const updateTablesState: ChartDBContext['updateTablesState'] = useCallback(
+ async (
+ updateFn: (tables: DBTable[]) => PartialExcept<DBTable, 'id'>[]
+ ) => {
+ const updatedTables = updateFn(tables);
+ setTables((prevTables) => {
+ const updatedTables = updateFn(prevTables);
+ return prevTables
+ .map((prevTable) => {
+ const updatedTable = updatedTables.find(
+ (t) => t.id === prevTable.id
+ );
+ return updatedTable
+ ? { ...prevTable, ...updatedTable }
+ : prevTable;
+ })
+ .filter((prevTable) =>
+ updatedTables.some((t) => t.id === prevTable.id)
);
- return updatedTable
- ? { ...prevTable, ...updatedTable }
- : prevTable;
- })
- .filter((prevTable) =>
- updatedTables.some((t) => t.id === prevTable.id)
+ });
+
+ const promises = [];
+ for (const updatedTable of updatedTables) {
+ promises.push(
+ db.updateTable({
+ id: updatedTable.id,
+ attributes: updatedTable,
+ })
);
- });
-
- const promises = [];
- for (const updatedTable of updatedTables) {
- promises.push(
- db.updateTable({
- id: updatedTable.id,
- attributes: updatedTable,
- })
+ }
+
+ const tablesToDelete = tables.filter(
+ (table) => !updatedTables.some((t) => t.id === table.id)
);
- }
- const tablesToDelete = tables.filter(
- (table) => !updatedTables.some((t) => t.id === table.id)
- );
+ for (const table of tablesToDelete) {
+ promises.push(db.deleteTable({ diagramId, id: table.id }));
+ }
- for (const table of tablesToDelete) {
- promises.push(db.deleteTable({ diagramId, id: table.id }));
- }
-
- await Promise.all(promises);
- };
-
- const updateField: ChartDBContext['updateField'] = async (
- tableId: string,
- fieldId: string,
- field: Partial<DBField>
- ) => {
- setTables((tables) =>
- tables.map((table) =>
- table.id === tableId
- ? {
- ...table,
- fields: table.fields.map((f) =>
- f.id === fieldId ? { ...f, ...field } : f
- ),
- }
- : table
- )
- );
+ await Promise.all(promises);
+ },
+ [db, tables, setTables, diagramId]
+ );
- const table = await db.getTable({ diagramId, id: tableId });
- if (!table) {
- return;
- }
-
- await db.updateTable({
- id: tableId,
- attributes: {
- ...table,
- fields: table.fields.map((f) =>
- f.id === fieldId ? { ...f, ...field } : f
- ),
- },
- });
- };
-
- const removeField: ChartDBContext['removeField'] = async (
- tableId: string,
- fieldId: string
- ) => {
- setTables((tables) =>
- tables.map((table) =>
- table.id === tableId
- ? {
- ...table,
- fields: table.fields.filter((f) => f.id !== fieldId),
- }
- : table
- )
- );
+ const updateField: ChartDBContext['updateField'] = useCallback(
+ async (tableId: string, fieldId: string, field: Partial<DBField>) => {
+ setTables((tables) =>
+ tables.map((table) =>
+ table.id === tableId
+ ? {
+ ...table,
+ fields: table.fields.map((f) =>
+ f.id === fieldId ? { ...f, ...field } : f
+ ),
+ }
+ : table
+ )
+ );
- const table = await db.getTable({ diagramId, id: tableId });
- if (!table) {
- return;
- }
+ const table = await db.getTable({ diagramId, id: tableId });
+ if (!table) {
+ return;
+ }
- await db.updateTable({
- id: tableId,
- attributes: {
- ...table,
- fields: table.fields.filter((f) => f.id !== fieldId),
- },
- });
- };
-
- const addField: ChartDBContext['addField'] = async (
- tableId: string,
- field: DBField
- ) => {
- setTables((tables) =>
- tables.map((table) =>
- table.id === tableId
- ? { ...table, fields: [...table.fields, field] }
- : table
- )
- );
+ await db.updateTable({
+ id: tableId,
+ attributes: {
+ ...table,
+ fields: table.fields.map((f) =>
+ f.id === fieldId ? { ...f, ...field } : f
+ ),
+ },
+ });
+ },
+ [db, diagramId, setTables]
+ );
- const table = await db.getTable({ diagramId, id: tableId });
+ const removeField: ChartDBContext['removeField'] = useCallback(
+ async (tableId: string, fieldId: string) => {
+ setTables((tables) =>
+ tables.map((table) =>
+ table.id === tableId
+ ? {
+ ...table,
+ fields: table.fields.filter(
+ (f) => f.id !== fieldId
+ ),
+ }
+ : table
+ )
+ );
- if (!table) {
- return;
- }
+ const table = await db.getTable({ diagramId, id: tableId });
+ if (!table) {
+ return;
+ }
- await db.updateTable({
- id: tableId,
- attributes: {
- ...table,
- fields: [...table.fields, field],
- },
- });
- };
-
- const getField: ChartDBContext['getField'] = (
- tableId: string,
- fieldId: string
- ) => {
- const table = getTable(tableId);
- return table?.fields.find((f) => f.id === fieldId) ?? null;
- };
-
- const createField: ChartDBContext['createField'] = async (
- tableId: string
- ) => {
- const table = getTable(tableId);
- const field: DBField = {
- id: generateId(),
- name: `field_${(table?.fields?.length ?? 0) + 1}`,
- type: 'bigint',
- unique: false,
- nullable: true,
- primaryKey: false,
- createdAt: Date.now(),
- };
+ await db.updateTable({
+ id: tableId,
+ attributes: {
+ ...table,
+ fields: table.fields.filter((f) => f.id !== fieldId),
+ },
+ });
+ },
+ [db, diagramId, setTables]
+ );
- await addField(tableId, field);
-
- return field;
- };
-
- const addIndex: ChartDBContext['addIndex'] = async (
- tableId: string,
- index: DBIndex
- ) => {
- setTables((tables) =>
- tables.map((table) =>
- table.id === tableId
- ? { ...table, indexes: [...table.indexes, index] }
- : table
- )
- );
+ const addField: ChartDBContext['addField'] = useCallback(
+ async (tableId: string, field: DBField) => {
+ setTables((tables) =>
+ tables.map((table) =>
+ table.id === tableId
+ ? { ...table, fields: [...table.fields, field] }
+ : table
+ )
+ );
- const dbTable = await db.getTable({ diagramId, id: tableId });
- if (!dbTable) {
- return;
- }
+ const table = await db.getTable({ diagramId, id: tableId });
- await db.updateTable({
- id: tableId,
- attributes: {
- ...dbTable,
- indexes: [...dbTable.indexes, index],
- },
- });
- };
-
- const removeIndex: ChartDBContext['removeIndex'] = async (
- tableId: string,
- indexId: string
- ) => {
- setTables((tables) =>
- tables.map((table) =>
- table.id === tableId
- ? {
- ...table,
- indexes: table.indexes.filter(
- (i) => i.id !== indexId
- ),
- }
- : table
- )
- );
+ if (!table) {
+ return;
+ }
- const dbTable = await db.getTable({
- diagramId,
- id: tableId,
- });
+ await db.updateTable({
+ id: tableId,
+ attributes: {
+ ...table,
+ fields: [...table.fields, field],
+ },
+ });
+ },
+ [db, diagramId, setTables]
+ );
- if (!dbTable) {
- return;
- }
+ const getField: ChartDBContext['getField'] = useCallback(
+ (tableId: string, fieldId: string) => {
+ const table = getTable(tableId);
+ return table?.fields.find((f) => f.id === fieldId) ?? null;
+ },
+ [getTable]
+ );
- await db.updateTable({
- id: tableId,
- attributes: {
- ...dbTable,
- indexes: dbTable.indexes.filter((i) => i.id !== indexId),
- },
- });
- };
-
- const createIndex: ChartDBContext['createIndex'] = async (
- tableId: string
- ) => {
- const table = getTable(tableId);
- const index: DBIndex = {
- id: generateId(),
- name: `index_${(table?.indexes?.length ?? 0) + 1}`,
- fieldIds: [],
- unique: false,
- createdAt: Date.now(),
- };
+ const createField: ChartDBContext['createField'] = useCallback(
+ async (tableId: string) => {
+ const table = getTable(tableId);
+ const field: DBField = {
+ id: generateId(),
+ name: `field_${(table?.fields?.length ?? 0) + 1}`,
+ type: 'bigint',
+ unique: false,
+ nullable: true,
+ primaryKey: false,
+ createdAt: Date.now(),
+ };
+
+ await addField(tableId, field);
+
+ return field;
+ },
+ [addField, getTable]
+ );
- await addIndex(tableId, index);
-
- return index;
- };
-
- const getIndex: ChartDBContext['getIndex'] = (
- tableId: string,
- indexId: string
- ) => {
- const table = getTable(tableId);
- return table?.indexes.find((i) => i.id === indexId) ?? null;
- };
-
- const updateIndex: ChartDBContext['updateIndex'] = async (
- tableId: string,
- indexId: string,
- index: Partial<DBIndex>
- ) => {
- setTables((tables) =>
- tables.map((table) =>
- table.id === tableId
- ? {
- ...table,
- indexes: table.indexes.map((i) =>
- i.id === indexId ? { ...i, ...index } : i
- ),
- }
- : table
- )
- );
+ const addIndex: ChartDBContext['addIndex'] = useCallback(
+ async (tableId: string, index: DBIndex) => {
+ setTables((tables) =>
+ tables.map((table) =>
+ table.id === tableId
+ ? { ...table, indexes: [...table.indexes, index] }
+ : table
+ )
+ );
- const dbTable = await db.getTable({ diagramId, id: tableId });
+ const dbTable = await db.getTable({ diagramId, id: tableId });
+ if (!dbTable) {
+ return;
+ }
- if (!dbTable) {
- return;
- }
+ await db.updateTable({
+ id: tableId,
+ attributes: {
+ ...dbTable,
+ indexes: [...dbTable.indexes, index],
+ },
+ });
+ },
+ [db, diagramId, setTables]
+ );
- await db.updateTable({
- id: tableId,
- attributes: {
- ...dbTable,
- indexes: dbTable.indexes.map((i) =>
- i.id === indexId ? { ...i, ...index } : i
- ),
- },
- });
- };
-
- const addRelationship: ChartDBContext['addRelationship'] = async (
- relationship: DBRelationship
- ) => {
- setRelationships((relationships) => [...relationships, relationship]);
-
- await db.addRelationship({ diagramId, relationship });
- };
-
- const createRelationship: ChartDBContext['createRelationship'] = async ({
- sourceTableId,
- targetTableId,
- sourceFieldId,
- targetFieldId,
- }) => {
- const sourceTableName = getTable(sourceTableId)?.name ?? '';
- const targetTableName = getTable(targetTableId)?.name ?? '';
- const relationship: DBRelationship = {
- id: generateId(),
- name: `${sourceTableName}_${targetTableName}_fk`,
- sourceTableId,
- targetTableId,
- sourceFieldId,
- targetFieldId,
- type: 'one_to_one',
- createdAt: Date.now(),
- };
+ const removeIndex: ChartDBContext['removeIndex'] = useCallback(
+ async (tableId: string, indexId: string) => {
+ setTables((tables) =>
+ tables.map((table) =>
+ table.id === tableId
+ ? {
+ ...table,
+ indexes: table.indexes.filter(
+ (i) => i.id !== indexId
+ ),
+ }
+ : table
+ )
+ );
+
+ const dbTable = await db.getTable({
+ diagramId,
+ id: tableId,
+ });
+
+ if (!dbTable) {
+ return;
+ }
+
+ await db.updateTable({
+ id: tableId,
+ attributes: {
+ ...dbTable,
+ indexes: dbTable.indexes.filter((i) => i.id !== indexId),
+ },
+ });
+ },
+ [db, diagramId, setTables]
+ );
- await addRelationship(relationship);
+ const createIndex: ChartDBContext['createIndex'] = useCallback(
+ async (tableId: string) => {
+ const table = getTable(tableId);
+ const index: DBIndex = {
+ id: generateId(),
+ name: `index_${(table?.indexes?.length ?? 0) + 1}`,
+ fieldIds: [],
+ unique: false,
+ createdAt: Date.now(),
+ };
- return relationship;
- };
+ await addIndex(tableId, index);
- const getRelationship: ChartDBContext['getRelationship'] = (id: string) =>
- relationships.find((relationship) => relationship.id === id) ?? null;
+ return index;
+ },
+ [addIndex, getTable]
+ );
- const removeRelationship: ChartDBContext['removeRelationship'] = async (
- id: string
- ) => {
- setRelationships((relationships) =>
- relationships.filter((relationship) => relationship.id !== id)
- );
+ const getIndex: ChartDBContext['getIndex'] = useCallback(
+ (tableId: string, indexId: string) => {
+ const table = getTable(tableId);
+ return table?.indexes.find((i) => i.id === indexId) ?? null;
+ },
+ [getTable]
+ );
- await db.deleteRelationship({ diagramId, id });
- };
+ const updateIndex: ChartDBContext['updateIndex'] = useCallback(
+ async (tableId: string, indexId: string, index: Partial<DBIndex>) => {
+ setTables((tables) =>
+ tables.map((table) =>
+ table.id === tableId
+ ? {
+ ...table,
+ indexes: table.indexes.map((i) =>
+ i.id === indexId ? { ...i, ...index } : i
+ ),
+ }
+ : table
+ )
+ );
+
+ const dbTable = await db.getTable({ diagramId, id: tableId });
+
+ if (!dbTable) {
+ return;
+ }
+
+ await db.updateTable({
+ id: tableId,
+ attributes: {
+ ...dbTable,
+ indexes: dbTable.indexes.map((i) =>
+ i.id === indexId ? { ...i, ...index } : i
+ ),
+ },
+ });
+ },
+ [db, diagramId, setTables]
+ );
+
+ const addRelationship: ChartDBContext['addRelationship'] = useCallback(
+ async (relationship: DBRelationship) => {
+ setRelationships((relationships) => [
+ ...relationships,
+ relationship,
+ ]);
+
+ await db.addRelationship({ diagramId, relationship });
+ },
+ [db, diagramId, setRelationships]
+ );
+
+ const createRelationship: ChartDBContext['createRelationship'] =
+ useCallback(
+ async ({
+ sourceTableId,
+ targetTableId,
+ sourceFieldId,
+ targetFieldId,
+ }) => {
+ const sourceTableName = getTable(sourceTableId)?.name ?? '';
+ const targetTableName = getTable(targetTableId)?.name ?? '';
+ const relationship: DBRelationship = {
+ id: generateId(),
+ name: `${sourceTableName}_${targetTableName}_fk`,
+ sourceTableId,
+ targetTableId,
+ sourceFieldId,
+ targetFieldId,
+ type: 'one_to_one',
+ createdAt: Date.now(),
+ };
- const removeRelationships: ChartDBContext['removeRelationships'] = async (
- ...ids: string[]
- ) => {
- setRelationships((relationships) =>
- relationships.filter(
- (relationship) => !ids.includes(relationship.id)
- )
+ await addRelationship(relationship);
+
+ return relationship;
+ },
+ [addRelationship, getTable]
);
- await Promise.all(
- ids.map((id) => db.deleteRelationship({ diagramId, id }))
+ const getRelationship: ChartDBContext['getRelationship'] = useCallback(
+ (id: string) =>
+ relationships.find((relationship) => relationship.id === id) ??
+ null,
+ [relationships]
+ );
+
+ const removeRelationship: ChartDBContext['removeRelationship'] =
+ useCallback(
+ async (id: string) => {
+ setRelationships((relationships) =>
+ relationships.filter(
+ (relationship) => relationship.id !== id
+ )
+ );
+
+ await db.deleteRelationship({ diagramId, id });
+ },
+ [db, diagramId, setRelationships]
);
- };
-
- const updateRelationship: ChartDBContext['updateRelationship'] = async (
- id: string,
- relationship: Partial<DBRelationship>
- ) => {
- setRelationships((relationships) =>
- relationships.map((r) =>
- r.id === id ? { ...r, ...relationship } : r
- )
+
+ const removeRelationships: ChartDBContext['removeRelationships'] =
+ useCallback(
+ async (...ids: string[]) => {
+ setRelationships((relationships) =>
+ relationships.filter(
+ (relationship) => !ids.includes(relationship.id)
+ )
+ );
+
+ await Promise.all(
+ ids.map((id) => db.deleteRelationship({ diagramId, id }))
+ );
+ },
+ [db, diagramId, setRelationships]
);
- await db.updateRelationship({ id, attributes: relationship });
- };
+ const updateRelationship: ChartDBContext['updateRelationship'] =
+ useCallback(
+ async (id: string, relationship: Partial<DBRelationship>) => {
+ setRelationships((relationships) =>
+ relationships.map((r) =>
+ r.id === id ? { ...r, ...relationship } : r
+ )
+ );
+
+ await db.updateRelationship({ id, attributes: relationship });
+ },
+ [db, setRelationships]
+ );
const loadDiagram: ChartDBContext['loadDiagram'] = useCallback(
async (diagramId: string) => {
@@ -507,7 +558,7 @@ export const ChartDBProvider: React.FC<React.PropsWithChildren> = ({
getTable,
removeTable,
updateTable,
- updateTables,
+ // updateTables,
updateTablesState,
updateField,
removeField,
diff --git a/src/context/history-context/history-context.tsx b/src/context/history-context/history-context.tsx
new file mode 100644
index 00000000..7b93e925
--- /dev/null
+++ b/src/context/history-context/history-context.tsx
@@ -0,0 +1,12 @@
+import { emptyFn } from '@/lib/utils';
+import { createContext } from 'react';
+
+export interface HistoryContext {
+ undo: () => void;
+ redo: () => void;
+}
+
+export const historyContext = createContext<HistoryContext>({
+ undo: emptyFn,
+ redo: emptyFn,
+});
diff --git a/src/context/history-context/history-provider.tsx b/src/context/history-context/history-provider.tsx
new file mode 100644
index 00000000..655666bc
--- /dev/null
+++ b/src/context/history-context/history-provider.tsx
@@ -0,0 +1,74 @@
+import React, { useMemo } from 'react';
+import { historyContext } from './history-context';
+import { RedoUndoActionHandlers } from './redo-undo-action';
+import { useChartDB } from '@/hooks/use-chartdb';
+import { useRedoUndoStack } from '@/hooks/use-redo-undo-stack';
+
+export const HistoryProvider: React.FC<React.PropsWithChildren> = ({
+ children,
+}) => {
+ const { setRedoStack, setUndoStack, undoStack, redoStack } =
+ useRedoUndoStack();
+ console.log({ setRedoStack, setUndoStack, undoStack, redoStack });
+ const { addTable, removeTable, updateTable } = useChartDB();
+
+ const redoActionHandlers = useMemo(
+ (): Partial<RedoUndoActionHandlers> => ({
+ addTable: ({ table }) => {
+ return addTable(table!);
+ },
+ }),
+ [addTable]
+ );
+
+ const undoActionHandlers = useMemo(
+ (): Partial<RedoUndoActionHandlers> => ({
+ addTable: ({ tableId }) => {
+ return removeTable(tableId!);
+ },
+ removeTable: ({ table }) => {
+ return addTable(table!);
+ },
+ updateTable: ({ tableId, table }) => {
+ return updateTable(tableId!, table!);
+ },
+ }),
+ [addTable, removeTable, updateTable]
+ );
+
+ const undo = async () => {
+ if (undoStack.length === 0) {
+ return;
+ }
+
+ const action = undoStack[undoStack.length - 1];
+ if (action) {
+ const handler = undoActionHandlers[action.action];
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ await handler?.(action.data as any);
+ setRedoStack([...redoStack, action]);
+ setUndoStack(undoStack.slice(0, undoStack.length - 1));
+ }
+ };
+
+ const redo = async () => {
+ if (redoStack.length === 0) {
+ return;
+ }
+
+ const action = redoStack[redoStack.length - 1];
+ if (action) {
+ const handler = redoActionHandlers[action.action];
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ await handler?.(action.data as any);
+ setUndoStack([...undoStack, action]);
+ setRedoStack(redoStack.slice(0, redoStack.length - 1));
+ }
+ };
+
+ return (
+ <historyContext.Provider value={{ undo, redo }}>
+ {children}
+ </historyContext.Provider>
+ );
+};
diff --git a/src/context/history-context/redo-undo-action.ts b/src/context/history-context/redo-undo-action.ts
new file mode 100644
index 00000000..8fe81d85
--- /dev/null
+++ b/src/context/history-context/redo-undo-action.ts
@@ -0,0 +1,126 @@
+import { DBTable } from '@/lib/domain/db-table';
+import { DatabaseType } from '@/lib/domain/database-type';
+import { ChartDBContext } from '../chartdb-context/chartdb-context';
+import { DBField } from '@/lib/domain/db-field';
+import { DBIndex } from '@/lib/domain/db-index';
+import { DBRelationship } from '@/lib/domain/db-relationship';
+
+type Action = keyof ChartDBContext;
+
+type RedoUndoActionBase<T extends Action, D> = {
+ action: T;
+ data: D;
+};
+
+type RedoUndoActionUpdateDiagramId = RedoUndoActionBase<
+ 'updateDiagramId',
+ { id: string }
+>;
+
+type RedoUndoActionUpdateDiagramName = RedoUndoActionBase<
+ 'updateDiagramName',
+ { name: string }
+>;
+
+type RedoUndoActionUpdateDatabaseType = RedoUndoActionBase<
+ 'updateDatabaseType',
+ { databaseType: DatabaseType }
+>;
+
+type RedoUndoActionUpdateTable = RedoUndoActionBase<
+ 'updateTable',
+ { tableId: string; table: Partial<DBTable> }
+>;
+
+type RedoUndoActionAddTable = RedoUndoActionBase<
+ 'addTable',
+ { tableId?: string; table?: DBTable }
+>;
+
+type RedoUndoActionRemoveTable = RedoUndoActionBase<
+ 'removeTable',
+ { tableId?: string; table?: DBTable }
+>;
+
+type RedoUndoActionUpdateTablesState = RedoUndoActionBase<
+ 'updateTablesState',
+ { tables: DBTable[] }
+>;
+
+type RedoUndoActionAddField = RedoUndoActionBase<
+ 'addField',
+ { tableId: string; fieldId?: string; field?: DBField }
+>;
+
+type RedoUndoActionRemoveField = RedoUndoActionBase<
+ 'removeField',
+ { tableId: string; fieldId?: string; field?: DBField }
+>;
+
+type RedoUndoActionUpdateField = RedoUndoActionBase<
+ 'updateField',
+ { tableId: string; fieldId: string; field: Partial<DBField> }
+>;
+
+type RedoUndoActionAddIndex = RedoUndoActionBase<
+ 'addIndex',
+ { tableId: string; indexId?: string; index?: DBIndex }
+>;
+
+type RedoUndoActionRemoveIndex = RedoUndoActionBase<
+ 'removeIndex',
+ { tableId: string; indexId?: string; index?: DBIndex }
+>;
+
+type RedoUndoActionUpdateIndex = RedoUndoActionBase<
+ 'updateIndex',
+ { tableId: string; indexId: string; index: Partial<DBIndex> }
+>;
+
+type RedoUndoActionAddRelationship = RedoUndoActionBase<
+ 'addRelationship',
+ { relationshipId?: string; relationship?: DBRelationship }
+>;
+
+type RedoUndoActionRemoveRelationship = RedoUndoActionBase<
+ 'removeRelationship',
+ { relationshipId?: string; relationship?: DBRelationship }
+>;
+
+type RedoUndoActionUpdateRelationship = RedoUndoActionBase<
+ 'updateRelationship',
+ { relationshipId: string; relationship: Partial<DBRelationship> }
+>;
+
+type RedoUndoActionRemoveRelationships = RedoUndoActionBase<
+ 'removeRelationships',
+ { relationshipsIds?: string[]; relationships?: DBRelationship[] }
+>;
+
+export type RedoUndoAction =
+ | RedoUndoActionAddTable
+ | RedoUndoActionRemoveTable
+ | RedoUndoActionUpdateTable
+ | RedoUndoActionUpdateDatabaseType
+ | RedoUndoActionUpdateDiagramName
+ | RedoUndoActionUpdateDiagramId
+ | RedoUndoActionUpdateTablesState
+ | RedoUndoActionAddField
+ | RedoUndoActionRemoveField
+ | RedoUndoActionUpdateField
+ | RedoUndoActionAddIndex
+ | RedoUndoActionRemoveIndex
+ | RedoUndoActionUpdateIndex
+ | RedoUndoActionAddRelationship
+ | RedoUndoActionRemoveRelationship
+ | RedoUndoActionUpdateRelationship
+ | RedoUndoActionRemoveRelationships;
+
+export type RedoUndoActionData<T extends Action> = Extract<
+ RedoUndoAction,
+ { action: T }
+>['data'];
+
+export type RedoUndoActionHandlers = {
+ [K in Action]: (data: RedoUndoActionData<K>) => Promise<void>;
+};
diff --git a/src/context/history-context/redo-undo-stack-context.tsx b/src/context/history-context/redo-undo-stack-context.tsx
new file mode 100644
index 00000000..9359f773
--- /dev/null
+++ b/src/context/history-context/redo-undo-stack-context.tsx
@@ -0,0 +1,18 @@
+import React from 'react';
+import { createContext } from 'react';
+import { RedoUndoAction } from './redo-undo-action';
+import { emptyFn } from '@/lib/utils';
+
+export interface RedoUndoStackContext {
+ redoStack: RedoUndoAction[];
+ undoStack: RedoUndoAction[];
+ setRedoStack: React.Dispatch<React.SetStateAction<RedoUndoAction[]>>;
+ setUndoStack: React.Dispatch<React.SetStateAction<RedoUndoAction[]>>;
+}
+
+export const redoUndoStackContext = createContext<RedoUndoStackContext>({
+ redoStack: [],
+ undoStack: [],
+ setRedoStack: emptyFn,
+ setUndoStack: emptyFn,
+});
diff --git a/src/context/history-context/redo-undo-stack-provider.tsx b/src/context/history-context/redo-undo-stack-provider.tsx
new file mode 100644
index 00000000..e52c2180
--- /dev/null
+++ b/src/context/history-context/redo-undo-stack-provider.tsx
@@ -0,0 +1,23 @@
+import React from 'react';
+import { RedoUndoAction } from './redo-undo-action';
+import { redoUndoStackContext } from './redo-undo-stack-context';
+
+export const RedoUndoStackProvider: React.FC<React.PropsWithChildren> = ({
+ children,
+}) => {
+ const [undoStack, setUndoStack] = React.useState<RedoUndoAction[]>([]);
+ const [redoStack, setRedoStack] = React.useState<RedoUndoAction[]>([]);
+
+ return (
+ <redoUndoStackContext.Provider
+ value={{
+ redoStack,
+ undoStack,
+ setRedoStack,
+ setUndoStack,
+ }}
+ >
+ {children}
+ </redoUndoStackContext.Provider>
+ );
+};
diff --git a/src/hooks/use-history.ts b/src/hooks/use-history.ts
new file mode 100644
index 00000000..5033dc91
--- /dev/null
+++ b/src/hooks/use-history.ts
@@ -0,0 +1,4 @@
+import { useContext } from 'react';
+import { historyContext } from '@/context/history-context/history-context';
+
+export const useHistory = () => useContext(historyContext);
diff --git a/src/hooks/use-redo-undo-stack.ts b/src/hooks/use-redo-undo-stack.ts
new file mode 100644
index 00000000..0bb8c691
--- /dev/null
+++ b/src/hooks/use-redo-undo-stack.ts
@@ -0,0 +1,4 @@
+import { redoUndoStackContext } from '@/context/history-context/redo-undo-stack-context';
+import { useContext } from 'react';
+
+export const useRedoUndoStack = () => useContext(redoUndoStackContext);
diff --git a/src/router.tsx b/src/router.tsx
index 751c1b9e..173c42c6 100644
--- a/src/router.tsx
+++ b/src/router.tsx
@@ -7,6 +7,8 @@ import { ReactFlowProvider } from '@xyflow/react';
import { StorageProvider } from './context/storage-context/storage-provider';
import { CreateDiagramDialogProvider } from './dialogs/create-diagram-dialog/create-diagram-dialog-provider';
import { ConfigProvider } from './context/config-context/config-provider';
+import { HistoryProvider } from './context/history-context/history-provider';
+import { RedoUndoStackProvider } from './context/history-context/redo-undo-stack-provider';
const routes: RouteObject[] = [
...['', 'diagrams/:diagramId'].map((path) => ({
@@ -14,13 +16,17 @@ const routes: RouteObject[] = [
element: (
<StorageProvider>
<ConfigProvider>
- <ChartDBProvider>
- <CreateDiagramDialogProvider>
- <ReactFlowProvider>
- <EditorPage />
- </ReactFlowProvider>
- </CreateDiagramDialogProvider>
- </ChartDBProvider>
+ <RedoUndoStackProvider>
+ <ChartDBProvider>
+ <HistoryProvider>
+ <CreateDiagramDialogProvider>
+ <ReactFlowProvider>
+ <EditorPage />
+ </ReactFlowProvider>
+ </CreateDiagramDialogProvider>
+ </HistoryProvider>
+ </ChartDBProvider>
+ </RedoUndoStackProvider>
</ConfigProvider>
</StorageProvider>
),