add schema

Author: mabaasit

packages/compass-data-modeling/src/components/diagram-editor.tsx

@@ -21,6 +21,7 @@ import {
   palette,
 } from '@mongodb-js/compass-components';
 import { cancelAnalysis, retryAnalysis } from '../store/analysis-process';
+import { EditTypeSchema } from '../services/data-model-schema';
 
 const loadingContainerStyles = css({
   width: '100%',
@@ -95,7 +96,6 @@ const DiagramEditor: React.FunctionComponent<{
   model: unknown;
   onRetryClick: () => void;
   onCancelClick: () => void;
-  // TODO
   onApplyClick: (edit: unknown) => void;
 }> = ({
   step,
@@ -112,6 +112,7 @@ const DiagramEditor: React.FunctionComponent<{
   const isEditValid = useMemo(() => {
     try {
       JSON.parse(applyInput);
+      EditTypeSchema.parse(JSON.parse(applyInput));
       return true;
     } catch {
       return false;

packages/compass-data-modeling/src/components/saved-diagrams-list.spec.tsx

@@ -9,7 +9,7 @@ import SavedDiagramsList from './saved-diagrams-list';
 import { renderWithStore } from '../../test/setup-store';
 import type { DataModelingStore } from '../../test/setup-store';
 import { DataModelStorageServiceProvider } from '../provider';
-import type { MongoDBDataModelDescription } from '../services/data-model-storage';
+import type { MongoDBDataModelDescription } from '../services/data-model-schema';
 
 const storageItems: MongoDBDataModelDescription[] = [
   {

packages/compass-data-modeling/src/components/saved-diagrams-list.tsx

@@ -14,7 +14,7 @@ import {
 } from '@mongodb-js/compass-components';
 import { useDataModelSavedItems } from '../provider';
 import { deleteDiagram, openDiagram, renameDiagram } from '../store/diagram';
-import type { MongoDBDataModelDescription } from '../services/data-model-storage';
+import type { MongoDBDataModelDescription } from '../services/data-model-schema';
 import CollaborateIcon from './icons/collaborate';
 import SchemaVisualizationIcon from './icons/schema-visualization';
 import FlexibilityIcon from './icons/flexibility';

packages/compass-data-modeling/src/services/data-model-schema.ts

@@ -0,0 +1,131 @@
+import { z } from '@mongodb-js/compass-user-data';
+
+const FieldPathSchema = z.array(z.string());
+const NamespaceSchema = z.string().includes('.');
+
+const RelationshipSideSchema = z.object({
+  ns: NamespaceSchema,
+  cardinality: z.number(),
+  fields: z.array(FieldPathSchema),
+});
+const MongoDBJSONSchema = z.unknown();
+const RelationshipSchema = z.object({
+  id: z.string().uuid(),
+  relationship: z.tuple([RelationshipSideSchema, RelationshipSideSchema]),
+  isInferred: z.boolean(),
+});
+const StaticModelSchema = z.object({
+  collections: z.array(
+    z.object({
+      ns: NamespaceSchema,
+      jsonSchema: MongoDBJSONSchema,
+      indexes: z.array(z.unknown()),
+      shardKey: z.unknown().optional(),
+      displayPosition: z.tuple([z.number(), z.number()]),
+    })
+  ),
+  relationships: z.array(RelationshipSchema),
+});
+
+const SetModelSchema = z.object({
+  type: z.literal('SetModel'),
+  model: StaticModelSchema,
+});
+const RenameCollectionSchema = z.object({
+  type: z.literal('RenameCollection'),
+  from: NamespaceSchema,
+  to: NamespaceSchema,
+});
+const RenameFieldSchema = z.object({
+  type: z.literal('RenameField'),
+  ns: NamespaceSchema,
+  from: FieldPathSchema,
+  to: FieldPathSchema,
+});
+const AddFieldSchema = z.object({
+  type: z.literal('AddField'),
+  ns: NamespaceSchema,
+  field: FieldPathSchema,
+  jsonSchema: MongoDBJSONSchema,
+});
+const RemoveFieldSchema = z.object({
+  type: z.literal('RemoveField'),
+  ns: NamespaceSchema,
+  field: FieldPathSchema,
+});
+const AddCollectionSchema = z.object({
+  type: z.literal('AddCollection'),
+  ns: NamespaceSchema,
+});
+const RemoveCollectionSchema = z.object({
+  type: z.literal('RemoveCollection'),
+  ns: NamespaceSchema,
+});
+const ConvertFieldTypeSchema = z.object({
+  type: z.literal('ConvertFieldType'),
+  ns: NamespaceSchema,
+  field: FieldPathSchema,
+  from: MongoDBJSONSchema,
+  to: MongoDBJSONSchema,
+});
+const EmbedCollectionSchema = z.object({
+  type: z.literal('EmbedCollection'),
+  source: NamespaceSchema,
+  target: NamespaceSchema,
+  targetField: FieldPathSchema,
+  asNestedArray: z.boolean(),
+});
+const UnembedCollectionSchema = z.object({
+  type: z.literal('UnembedCollection'),
+  source: NamespaceSchema,
+  target: NamespaceSchema,
+  fromField: FieldPathSchema,
+});
+const AddRelationshipSchema = z.object({
+  type: z.literal('AddRelationship'),
+  relationship: RelationshipSchema,
+});
+const RemoveRelationshipSchema = z.object({
+  type: z.literal('RemoveRelationship'),
+  id: z.string().uuid(),
+});
+export const EditTypeSchema = z.discriminatedUnion('type', [
+  SetModelSchema,
+  RenameCollectionSchema,
+  RenameFieldSchema,
+  AddFieldSchema,
+  RemoveFieldSchema,
+  AddCollectionSchema,
+  RemoveCollectionSchema,
+  ConvertFieldTypeSchema,
+  EmbedCollectionSchema,
+  UnembedCollectionSchema,
+  AddRelationshipSchema,
+  RemoveRelationshipSchema,
+]);
+
+const EditBasePropsSchema = z.object({
+  id: z.string(),
+  timestamp: z.string().datetime(),
+  copiesEdit: z.string().optional(),
+});
+
+export const EditSchema = z.intersection(EditBasePropsSchema, EditTypeSchema);
+export type Edit = z.infer<typeof EditSchema>;
+
+export const MongoDBDataModelDescriptionSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  /**
+   * Connection id associated with the data model at the moment of configuring
+   * and analyzing. No connection id means diagram was imported and not attached
+   * to a connection. Practically speaking it just means that we can't do
+   * anything that would require re-fetching data associated with the diagram
+   */
+  connectionId: z.string().nullable(),
+  edits: z.array(EditSchema),
+});
+
+export type MongoDBDataModelDescription = z.output<
+  typeof MongoDBDataModelDescriptionSchema
+>;

packages/compass-data-modeling/src/services/data-model-storage-electron.tsx

@@ -1,10 +1,8 @@
 import React from 'react';
 import { UserData } from '@mongodb-js/compass-user-data';
-import type {
-  DataModelStorage,
-  MongoDBDataModelDescription,
-} from './data-model-storage';
-import { MongoDBDataModelDescriptionSchema } from './data-model-storage';
+import type { DataModelStorage } from './data-model-storage';
+import type { MongoDBDataModelDescription } from './data-model-schema';
+import { MongoDBDataModelDescriptionSchema } from './data-model-schema';
 import { DataModelStorageServiceProvider } from '../provider';
 
 class DataModelStorageElectron implements DataModelStorage {

packages/compass-data-modeling/src/services/data-model-storage.ts

@@ -1,24 +1,4 @@
-import { z } from '@mongodb-js/compass-user-data';
-
-export const MongoDBDataModelDescriptionSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  /**
-   * Connection id associated with the data model at the moment of configuring
-   * and analyzing. No connection id means diagram was imported and not attached
-   * to a connection. Practically speaking it just means that we can't do
-   * anything that would require re-fetching data associated with the diagram
-   */
-  connectionId: z.string().nullable(),
-
-  // TODO: define rest of the schema based on arch doc / tech design
-  edits: z.array(z.unknown()).default([]),
-});
-
-export type MongoDBDataModelDescription = z.output<
-  typeof MongoDBDataModelDescriptionSchema
->;
-
+import type { MongoDBDataModelDescription } from './data-model-schema';
 export interface DataModelStorage {
   save(description: MongoDBDataModelDescription): Promise<boolean>;
   delete(id: MongoDBDataModelDescription['id']): Promise<boolean>;

packages/compass-data-modeling/src/store/analysis-process.ts

@@ -3,8 +3,9 @@ import { isAction } from './util';
 import type { DataModelingThunkAction } from './reducer';
 import { analyzeDocuments } from 'mongodb-schema';
 import { getCurrentDiagramFromState } from './diagram';
-import type { Document } from 'bson';
+import { UUID, type Document } from 'bson';
 import type { AggregationCursor } from 'mongodb';
+import type { Edit } from '../services/data-model-schema';
 
 export type AnalysisProcessState = {
   currentAnalysisOptions:
@@ -61,9 +62,7 @@ export type AnalysisFinishedAction = {
   type: AnalysisProcessActionTypes.ANALYSIS_FINISHED;
   name: string;
   connectionId: string;
-  // TODO
-  schema: Record<string, unknown>;
-  relations: unknown[];
+  edit: Edit;
 };
 
 export type AnalysisFailedAction = {
@@ -188,7 +187,7 @@ export function startAnalysis(
             type: AnalysisProcessActionTypes.NAMESPACE_SCHEMA_ANALYZED,
             namespace: ns,
           });
-          return [ns, schema];
+          return [ns, schema] as const;
         })
       );
       if (options.automaticallyInferRelations) {
@@ -197,12 +196,27 @@ export function startAnalysis(
       if (cancelController.signal.aborted) {
         throw cancelController.signal.reason;
       }
+      // As the analysis finishes, we set the model on the diagram
+      const edit: Edit = {
+        id: new UUID().toString(),
+        timestamp: new Date().toISOString(),
+        type: 'SetModel',
+        model: {
+          relationships: [],
+          collections: schema.map(([ns, jsonSchema]) => ({
+            ns,
+            jsonSchema,
+            indexes: [],
+            shardKey: undefined,
+            displayPosition: [0, 0],
+          })),
+        },
+      };
       dispatch({
         type: AnalysisProcessActionTypes.ANALYSIS_FINISHED,
         name,
         connectionId,
-        schema: Object.fromEntries(schema),
-        relations: [],
+        edit,
       });
       void services.dataModelStorage.save(
         getCurrentDiagramFromState(getState())

packages/compass-data-modeling/src/store/diagram.ts

@@ -1,11 +1,20 @@
 import type { Reducer } from 'redux';
 import { UUID } from 'bson';
 import { isAction } from './util';
-import type { MongoDBDataModelDescription } from '../services/data-model-storage';
+import {
+  type MongoDBDataModelDescription,
+  type Edit,
+  EditSchema,
+  EditTypeSchema,
+} from '../services/data-model-schema';
 import { AnalysisProcessActionTypes } from './analysis-process';
 import { memoize } from 'lodash';
 import type { DataModelingState, DataModelingThunkAction } from './reducer';
-import { showConfirmation, showPrompt } from '@mongodb-js/compass-components';
+import {
+  openToast,
+  showConfirmation,
+  showPrompt,
+} from '@mongodb-js/compass-components';
 
 export type DiagramState =
   | (Omit<MongoDBDataModelDescription, 'edits'> & {
@@ -44,8 +53,7 @@ export type RenameDiagramAction = {
 
 export type ApplyEditAction = {
   type: DiagramActionTypes.APPLY_EDIT;
-  // TODO
-  edit: unknown;
+  edit: Edit;
 };
 
 export type UndoEditAction = {
@@ -90,16 +98,7 @@ export const diagramReducer: Reducer<DiagramState> = (
       connectionId: action.connectionId,
       edits: {
         prev: [],
-        current: [
-          {
-            // TODO
-            type: 'SetModel',
-            model: {
-              schema: action.schema,
-              relations: action.relations,
-            },
-          },
-        ],
+        current: [action.edit],
         next: [],
       },
     };
@@ -172,10 +171,16 @@ export function redoEdit(): DataModelingThunkAction<void, RedoEditAction> {
 }
 
 export function applyEdit(
-  edit: unknown
+  data: unknown
 ): DataModelingThunkAction<void, ApplyEditAction> {
   return (dispatch, getState, { dataModelStorage }) => {
-    dispatch({ type: DiagramActionTypes.APPLY_EDIT, edit });
+    const edit = EditTypeSchema.parse(data);
+    const extendedEdit = EditSchema.parse({
+      ...edit,
+      id: new UUID().toString(),
+      timestamp: new Date().toISOString(),
+    });
+    dispatch({ type: DiagramActionTypes.APPLY_EDIT, edit: extendedEdit });
     void dataModelStorage.save(getCurrentDiagramFromState(getState()));
   };
 }
@@ -205,7 +210,7 @@ export function deleteDiagram(
 export function renameDiagram(
   id: string // TODO maybe pass the whole thing here, we always have it when calling this, then we don't need to re-load storage
 ): DataModelingThunkAction<Promise<void>, RenameDiagramAction> {
-  return async (dispatch, getState, { dataModelStorage }) => {
+  return async (dispatch, getState, { dataModelStorage, logger }) => {
     try {
       const diagram = await dataModelStorage.load(id);
       if (!diagram) {
@@ -222,13 +227,23 @@ export function renameDiagram(
       dispatch({ type: DiagramActionTypes.RENAME_DIAGRAM, id, name: newName });
       void dataModelStorage.save({ ...diagram, name: newName });
     } catch (err) {
-      // TODO log
+      logger.log.error(
+        logger.mongoLogId(1_001_000_351),
+        'DataModeling',
+        'Failed to rename diagram',
+        { err }
+      );
+      openToast('data-modeling-rename-toast', {
+        variant: 'important',
+        title: 'Failed to rename diagram',
+        description: 'Please try again.',
+      });
     }
   };
 }
 
 // TODO
-function _applyEdit(model: any, edit: any) {
+function _applyEdit(model: any, edit: Edit) {
   if (edit && 'type' in edit) {
     if (edit.type === 'SetModel') {
       return edit.model;