Merge pull request #1619 from Cratis:fix/namespace-id

Remove namespace id as a concept

Integration/Orleans.InProcess/for_Reactors/when_handling_event/an_it_fails_first_time/but_not_second_time.cs → Integration/Orleans.InProcess/for_Reactors/when_handling_event/and_it_fails/but_not_second_time.cs

@@ -5,9 +5,10 @@
 using Cratis.Chronicle.Contracts.Observation;
 using Cratis.Chronicle.Events;
 using Cratis.Chronicle.Integration.Base;
-using context = Cratis.Chronicle.Integration.Orleans.InProcess.for_Reactors.when_handling_event.and_it_fails_first_time.but_not_second_time.context;
+using Humanizer;
+using context = Cratis.Chronicle.Integration.Orleans.InProcess.for_Reactors.when_handling_event.and_it_fails.but_not_second_time.context;
 
-namespace Cratis.Chronicle.Integration.Orleans.InProcess.for_Reactors.when_handling_event.and_it_fails_first_time;
+namespace Cratis.Chronicle.Integration.Orleans.InProcess.for_Reactors.when_handling_event.and_it_fails;
 
 [Collection(GlobalCollection.Name)]
 public class but_not_second_time(context context) : Given<context>(context)
@@ -28,19 +29,20 @@ void Establish()
 
         async Task Because()
         {
+            var waitTime = 5.Seconds();
             await ReactorObserver.WaitTillActive();
             Observers[0].ShouldFail = true;
             Observers[1].ShouldFail = false;
             await EventStore.EventLog.Append(EventSourceId, Event);
 
             // Wait for the first event to have been handled
-            await Tcs[0].Task.WaitAsync(TimeSpan.FromSeconds(5));
+            await Tcs[0].Task.WaitAsync(waitTime);
 
             FailedPartitionsBeforeRetry = await EventStore.WaitForThereToBeFailedPartitions(ObserverId);
             Jobs = await EventStore.WaitForThereToBeJobs();
 
             // Wait for the second event to have been handled
-            await Tcs[1].Task.WaitAsync(TimeSpan.FromSeconds(5));
+            await Tcs[1].Task.WaitAsync(waitTime);
             await EventStore.WaitForThereToBeNoJobs();
 
             FailedPartitionsAfterRetry = await GetFailedPartitions();

Integration/Orleans.InProcess/for_Reactors/when_handling_event/an_it_fails_first_time/but_not_third_time.cs → Integration/Orleans.InProcess/for_Reactors/when_handling_event/and_it_fails/but_not_third_time.cs

@@ -5,9 +5,10 @@
 using Cratis.Chronicle.Contracts.Observation;
 using Cratis.Chronicle.Events;
 using Cratis.Chronicle.Integration.Base;
-using context = Cratis.Chronicle.Integration.Orleans.InProcess.for_Reactors.when_handling_event.and_it_fails_first_time.but_not_third_time.context;
+using Humanizer;
+using context = Cratis.Chronicle.Integration.Orleans.InProcess.for_Reactors.when_handling_event.and_it_fails.but_not_third_time.context;
 
-namespace Cratis.Chronicle.Integration.Orleans.InProcess.for_Reactors.when_handling_event.and_it_fails_first_time;
+namespace Cratis.Chronicle.Integration.Orleans.InProcess.for_Reactors.when_handling_event.and_it_fails;
 
 [Collection(GlobalCollection.Name)]
 public class but_not_third_time(context context) : Given<context>(context)
@@ -28,27 +29,29 @@ void Establish()
 
         async Task Because()
         {
+            var waitTime = 5.Seconds();
+
             await ReactorObserver.WaitTillActive();
             Observers[0].ShouldFail = true;
             Observers[1].ShouldFail = true;
             Observers[2].ShouldFail = false;
             await EventStore.EventLog.Append(EventSourceId, Event);
 
             // Wait for the first event to have been handled
-            await Tcs[0].Task.WaitAsync(TimeSpan.FromSeconds(60));
+            await Tcs[0].Task.WaitAsync(waitTime);
 
-            FailedPartitionsBeforeRetry = await EventStore.WaitForThereToBeFailedPartitions(ObserverId, TimeSpan.FromSeconds(60));
-            Jobs = await EventStore.WaitForThereToBeJobs(TimeSpan.FromSeconds(60));
+            FailedPartitionsBeforeRetry = await EventStore.WaitForThereToBeFailedPartitions(ObserverId, waitTime);
+            Jobs = await EventStore.WaitForThereToBeJobs(waitTime);
 
             // Wait for the second event to have been handled
-            await Tcs[1].Task.WaitAsync(TimeSpan.FromSeconds(60));
+            await Tcs[1].Task.WaitAsync(waitTime);
 
             FailedPartitionsBeforeRetry = await EventStore.WaitForThereToBeFailedPartitions(ObserverId, TimeSpan.FromSeconds(60));
-            Jobs = await EventStore.WaitForThereToBeJobs(TimeSpan.FromSeconds(60));
+            Jobs = await EventStore.WaitForThereToBeJobs(waitTime);
 
             // Wait for the third event to have been handled
-            await Tcs[2].Task.WaitAsync(TimeSpan.FromSeconds(60));
-            await EventStore.WaitForThereToBeNoJobs(TimeSpan.FromSeconds(60));
+            await Tcs[2].Task.WaitAsync(waitTime);
+            await EventStore.WaitForThereToBeNoJobs(waitTime);
 
             FailedPartitionsAfterRetry = await GetFailedPartitions();
         }

Source/Api/Namespaces/Namespace.cs

@@ -8,10 +8,6 @@ namespace Cratis.Api.Namespaces;
 /// <summary>
 /// Represents a namespace.
 /// </summary>
-/// <param name="Id">The <see cref="EventStoreNamespaceId"/> for the namespace.</param>
 /// <param name="Name">The name of the namespace.</param>
 /// <param name="Description">The description of the namespace.</param>
-public record Namespace(
-    EventStoreNamespaceId Id,
-    EventStoreNamespaceName Name,
-    string Description);
+public record Namespace(EventStoreNamespaceName Name, string Description);

Source/Api/Namespaces/NamespaceQueries.cs

@@ -27,6 +27,6 @@ public ISubject<IEnumerable<Namespace>> AllNamespaces([FromRoute] EventStoreName
         var store = storage.GetEventStore(eventStore);
         return new TransformingSubject<IEnumerable<NamespaceState>, IEnumerable<Namespace>>(
             store.Namespaces.ObserveAll(),
-            _ => _.Select(_ => new Namespace(_.Id, _.Name, string.Empty)));
+            _ => _.Select(_ => new Namespace(_.Name, string.Empty)));
     }
 }

Source/Kernel/Grains/EventSequences/EventSequence.cs

@@ -249,7 +249,7 @@ public async Task<AppendManyResult> AppendMany(
                 causedBy));
         }
 
-        return new AppendManyResult
+        return new()
         {
             CorrelationId = correlationId,
             SequenceNumbers = results.Select(r => r.SequenceNumber).ToImmutableList(),

Source/Kernel/Grains/Namespaces/Namespaces.cs

@@ -33,7 +33,7 @@ public async Task Ensure(EventStoreNamespaceName @namespace)
         if (State.Namespaces.Any(_ => _.Name == @namespace)) return;
 
         logger.AddingNamespace(@namespace);
-        State.NewNamespaces.Add(new NamespaceState(EventStoreNamespaceId.Default, @namespace, DateTimeOffset.UtcNow));
+        State.NewNamespaces.Add(new NamespaceState(@namespace, DateTimeOffset.UtcNow));
 
         var eventStoreName = (EventStoreName)this.GetPrimaryKeyString();
         var channelId = ChannelId.Create(WellKnownBroadcastChannelNames.NamespaceAdded, eventStoreName);

Source/Kernel/Grains/Namespaces/NamespacesStateStorageProvider.cs

@@ -24,10 +24,10 @@ public async Task ReadStateAsync<T>(string stateName, GrainId grainId, IGrainSta
         var eventStoreName = grainId.Key.ToString()!;
         var eventStore = storage.GetEventStore(eventStoreName);
 
-        var namespaces = (await eventStore.Namespaces.GetAll()).Select(_ => new NamespaceState(_.Id, _.Name, _.Created)).ToList();
+        var namespaces = (await eventStore.Namespaces.GetAll()).Select(_ => new NamespaceState(_.Name, _.Created)).ToList();
         if (namespaces.Find(_ => _.Name == EventStoreNamespaceName.Default) == default)
         {
-            var @namespace = new NamespaceState(EventStoreNamespaceId.Default, EventStoreNamespaceName.Default, DateTimeOffset.UtcNow);
+            var @namespace = new NamespaceState(EventStoreNamespaceName.Default, DateTimeOffset.UtcNow);
             namespaces.Add(@namespace);
             await eventStore.Namespaces.Create(@namespace.Name, @namespace.Created);
         }

Source/Kernel/Storage.MongoDB/Namespaces/MongoDBNamespace.cs

@@ -10,15 +10,10 @@ namespace Cratis.Chronicle.Storage.MongoDB.Namespaces;
 /// </summary>
 public class MongoDBNamespace
 {
-    /// <summary>
-    /// Gets or sets the unique identifier.
-    /// </summary>
-    [BsonId]
-    public Guid Id { get; set; }
-
     /// <summary>
     /// Gets or sets the name of the namespace.
     /// </summary>
+    [BsonId]
     public string Name { get; set; } = string.Empty;
 
     /// <summary>

Source/Kernel/Storage.MongoDB/Namespaces/NamespaceStorage.cs

@@ -36,7 +36,6 @@ public Task Create(EventStoreNamespaceName name, DateTimeOffset created)
 
         var @namespace = new MongoDBNamespace
         {
-            Id = Guid.NewGuid(),
             Name = name,
             Created = created
         };
@@ -60,14 +59,14 @@ public async Task<IEnumerable<NamespaceState>> GetAll()
     {
         var result = await GetCollection().FindAsync(_ => true);
         var namespaces = await result.ToListAsync();
-        return namespaces.Select(_ => new NamespaceState(_.Id, _.Name, _.Created));
+        return namespaces.Select(_ => new NamespaceState(_.Name, _.Created));
     }
 
     /// <inheritdoc/>
     public ISubject<IEnumerable<NamespaceState>> ObserveAll() =>
          new TransformingSubject<IEnumerable<MongoDBNamespace>, IEnumerable<NamespaceState>>(
             GetCollection().Observe(),
-            _ => _.Select(_ => new NamespaceState(_.Id, _.Name, _.Created)));
+            _ => _.Select(_ => new NamespaceState(_.Name, _.Created)));
 
     IMongoCollection<MongoDBNamespace> GetCollection() => database.GetCollection<MongoDBNamespace>(WellKnownCollectionNames.Namespaces);
 }

Source/Kernel/Storage/Namespaces/NamespaceState.cs

@@ -8,10 +8,6 @@ namespace Cratis.Chronicle.Storage.Namespaces;
 /// <summary>
 /// Represents the state of a namespace.
 /// </summary>
-/// <param name="Id"><see cref="EventStoreNamespaceId"/> for the namespace.</param>
 /// <param name="Name"><see cref="EventStoreNamespaceName"/> for the namespace. </param>
 /// <param name="Created">WHen it was created.</param>
-public record NamespaceState(
-    EventStoreNamespaceId Id,
-    EventStoreNamespaceName Name,
-    DateTimeOffset Created);
+public record NamespaceState(EventStoreNamespaceName Name, DateTimeOffset Created);

Source/Workbench/Web/Api/Namespaces/AllNamespaces.ts

@@ -12,19 +12,14 @@ import Handlebars from 'handlebars';
 const routeTemplate = Handlebars.compile('/api/event-store/{{eventStore}}/namespaces');
 
 class AllNamespacesSortBy {
-    private _id: SortingActionsForObservableQuery<Namespace[]>;
     private _name: SortingActionsForObservableQuery<Namespace[]>;
     private _description: SortingActionsForObservableQuery<Namespace[]>;
 
     constructor(readonly query: AllNamespaces) {
-        this._id = new SortingActionsForObservableQuery<Namespace[]>('id', query);
         this._name = new SortingActionsForObservableQuery<Namespace[]>('name', query);
         this._description = new SortingActionsForObservableQuery<Namespace[]>('description', query);
     }
 
-    get id(): SortingActionsForObservableQuery<Namespace[]> {
-        return this._id;
-    }
     get name(): SortingActionsForObservableQuery<Namespace[]> {
         return this._name;
     }
@@ -34,13 +29,9 @@ class AllNamespacesSortBy {
 }
 
 class AllNamespacesSortByWithoutQuery {
-    private _id: SortingActions  = new SortingActions('id');
     private _name: SortingActions  = new SortingActions('name');
     private _description: SortingActions  = new SortingActions('description');
 
-    get id(): SortingActions {
-        return this._id;
-    }
     get name(): SortingActions {
         return this._name;
     }

Source/Workbench/Web/Api/Namespaces/Namespace.ts

@@ -5,13 +5,9 @@
 /* eslint-disable sort-imports */
 // eslint-disable-next-line header/header
 import { field } from '@cratis/fundamentals';
-import { Guid } from '@cratis/fundamentals';
 
 export class Namespace {
 
-    @field(Guid)
-    id!: Guid;
-
     @field(String)
     name!: string;
 

Source/Workbench/Web/Features/EventStore/General/Namespaces/Namespaces.tsx

@@ -3,7 +3,7 @@
 
 import { withViewModel } from '@cratis/applications.react.mvvm';
 import { NamespacesViewModel } from './NamespacesViewModel';
-import { AllNamespaces, AllNamespacesArguments, Namespace } from 'Api/Namespaces';
+import { AllNamespaces, AllNamespacesArguments } from 'Api/Namespaces';
 import { type EventStoreAndNamespaceParams } from 'Shared';
 import strings from 'Strings';
 import { DataPage, MenuItem } from 'Components';
@@ -13,8 +13,6 @@ import { useParams } from 'react-router-dom';
 import { useDialogRequest } from '@cratis/applications.react.mvvm/dialogs';
 import { AddNamespace, AddNamespaceRequest, AddNamespaceResponse } from './AddNamespace';
 
-const renderId = (namespace: Namespace) => namespace.id.toString();
-
 export const Namespaces = withViewModel(NamespacesViewModel, ({ viewModel }) => {
     const params = useParams<EventStoreAndNamespaceParams>();
     const [AddNamespaceDialogWrapper] = useDialogRequest<AddNamespaceRequest, AddNamespaceResponse>(AddNamespaceRequest);
@@ -28,7 +26,7 @@ export const Namespaces = withViewModel(NamespacesViewModel, ({ viewModel }) =>
                 title={strings.eventStore.general.types.title}
                 query={AllNamespaces}
                 queryArguments={queryArgs}
-                dataKey='id'
+                dataKey='name'
                 emptyMessage={strings.eventStore.general.namespaces.empty}>
 
                 <DataPage.MenuItems>
@@ -39,12 +37,6 @@ export const Namespaces = withViewModel(NamespacesViewModel, ({ viewModel }) =>
                 </DataPage.MenuItems>
 
                 <DataPage.Columns>
-                    <Column
-                        field='id'
-                        style={{ width: '400px' }}
-                        header={strings.eventStore.general.namespaces.columns.id}
-                        sortable
-                        body={renderId}/>
                     <Column field='name' header={strings.eventStore.general.namespaces.columns.name} sortable />
                 </DataPage.Columns>
             </DataPage>

Source/Workbench/Web/Features/EventStore/Namespaces/Observers/ObserversViewModel.ts

@@ -9,7 +9,6 @@ import { INamespaces } from 'State/Namespaces';
 import { DialogButtons, IDialogs } from '@cratis/applications.react.mvvm/dialogs';
 import { DialogResult } from '@cratis/applications.react/dialogs';
 import { type EventStoreAndNamespaceParams } from 'Shared';
-import { Guid } from '@cratis/fundamentals';
 
 @injectable()
 export class ObserversViewModel {
@@ -19,7 +18,7 @@ export class ObserversViewModel {
         private readonly _replay: Replay,
         private readonly _dialogs: IDialogs,
         @inject('params') private readonly _params: EventStoreAndNamespaceParams) {
-        this.currentNamespace = { id: Guid.empty, name: '', description: '' };
+        this.currentNamespace = { name: '', description: '' };
 
         namespaces.currentNamespace.subscribe(namespace => {
             this.currentNamespace = namespace;

Source/Workbench/Web/Features/EventStore/Namespaces/Observers/for_ObserversViewModel/when_replaying/given/a_view_model.ts

@@ -9,12 +9,11 @@ import { Namespace } from 'Api/Namespaces';
 import { Replay } from 'Api/Observation';
 import { Dialogs } from '@cratis/applications.react.mvvm/dialogs';
 import { type EventStoreAndNamespaceParams } from 'Shared';
-import { Guid } from '@cratis/fundamentals';
 
 export class a_view_model {
     constructor() {
         this.namespaces = {
-            currentNamespace: new BehaviorSubject<Namespace>({ id: Guid.empty, name: '', description: '' }),
+            currentNamespace: new BehaviorSubject<Namespace>({ name: '', description: '' }),
             setCurrentNamespace: sinon.stub(),
             namespaces: new BehaviorSubject<Namespace[]>([])
 

Source/Workbench/Web/Layout/Default/NamespaceSelector/NamespaceSelectorViewModel.ts

@@ -4,7 +4,6 @@
 import { inject, injectable } from 'tsyringe';
 import { Namespace } from 'Api/Namespaces';
 import { INamespaces } from 'State/Namespaces';
-import { Guid } from '@cratis/fundamentals';
 
 export interface INamespaceSelectorProps {
     onNamespaceSelected: (namespace: Namespace) => void;
@@ -26,7 +25,7 @@ export class NamespaceSelectorViewModel {
         });
     }
 
-    currentNamespace: Namespace = { id: Guid.empty, name: '', description: '' };
+    currentNamespace: Namespace = { name: '', description: '' };
     namespaces: Namespace[] = [];
 
     onNamespaceSelected(namespace: Namespace) {

Source/Workbench/Web/State/Namespaces/Namespaces.ts

@@ -9,14 +9,13 @@ import { BehaviorSubject } from 'rxjs';
 import { CurrentNamespaceChanged } from './CurrentNamespaceChanged';
 import { INamespaces } from './INamespaces';
 import { type EventStoreAndNamespaceParams } from 'Shared';
-import { Guid } from '@cratis/fundamentals';
 
 /**
  * Represents an implementation of {@link INamespaces}
  */
 @injectable()
 export class Namespaces implements INamespaces {
-    private _currentNamespace: BehaviorSubject<Namespace> = new BehaviorSubject({ id: Guid.empty, name: '', description: '' });
+    private _currentNamespace: BehaviorSubject<Namespace> = new BehaviorSubject({ name: '', description: '' });
     private _namespaces: BehaviorSubject<Namespace[]> = new BehaviorSubject<Namespace[]>([]);
 
     constructor(