do not set the author automatically when modifying Causal* types, even if there is a single writer

Author: sbazerque

src/data/collections/causal/CausalArray.ts

@@ -15,7 +15,7 @@ import { ClassRegistry } from 'data/model/literals';
 import { MutableContentEvents } from 'data/model/mutable/MutableObject';
 import { MultiMap } from 'util/multimap';
 import { InvalidateAfterOp } from 'data/model/causal';
-import { AuthError, BaseCausalCollection, CausalCollection, CausalCollectionConfig, CausalCollectionOp } from './CausalCollection';
+import { AuthError, BaseCausalCollection, CausalCollection, CausalCollectionConfig } from './CausalCollection';
 import { Identity } from 'data/identity';
 
 // A mutable list with a 
@@ -29,11 +29,14 @@ class InsertOp<T> extends MutationOp {
     element?: T;
     ordinal?: Ordinal;
 
-    constructor(target?: CausalArray<T>, element?: T, ordinal?: Ordinal) {
+    constructor(target?: CausalArray<T>, element?: T, ordinal?: Ordinal, author?: Identity) {
         super(target);
 
         this.element = element;
         this.ordinal = ordinal;
+        if (author !== undefined) { 
+            this.setAuthor(author);
+        }
     }
 
     getClassName(): string {
@@ -65,8 +68,12 @@ class DeleteOp<T> extends InvalidateAfterOp {
 
     static className = 'hhs/v0/CausalArray/DeleteOp';
 
-    constructor(insertOp?: InsertOp<T>) {
+    constructor(insertOp?: InsertOp<T>, author?: Identity) {
         super(insertOp);
+
+        if (author !== undefined) {
+            this.setAuthor(author);
+        }
     }
 
     init() {
@@ -259,13 +266,7 @@ class CausalArray<T> extends BaseCausalCollection<T> implements CausalCollection
                 oldInsertionOps = this._currentInsertOps.get(elementHash);
             }
 
-            const insertOp = new InsertOp(this, element, ordinal);
-
-            if (author !== undefined) {
-                insertOp.setAuthor(author);
-            } else if (this.getClassName() === CausalArray.className) {
-                CausalCollectionOp.setSingleAuthorIfNecessary(insertOp);
-            }
+            const insertOp = new InsertOp(this, element, ordinal, author);
 
             const auth = Authorization.chain(this.createInsertAuthorizer(insertOp.getAuthor()), extraAuth);
 
@@ -416,13 +417,8 @@ class CausalArray<T> extends BaseCausalCollection<T> implements CausalCollection
     }
 
     private async deleteOpForInsertOp(insertOp: InsertOp<T>, author?: Identity, extraAuth?: Authorizer) {
-        const deleteOp = new DeleteOp(insertOp);
-
-        if (author !== undefined) {
-            deleteOp.setAuthor(author);
-        } else if (this.getClassName() === CausalArray.className) {
-            CausalCollectionOp.setSingleAuthorIfNecessary(deleteOp);
-        }
+        
+        const deleteOp = new DeleteOp(insertOp, author);
 
         const auth = Authorization.chain(this.createDeleteAuthorizer(deleteOp.getAuthor()), extraAuth);
 

src/data/collections/causal/CausalCollection.ts

@@ -81,20 +81,6 @@ abstract class BaseCausalCollection<T> extends BaseCollection<T> {
     }
 }
 
-abstract class CausalCollectionOp extends MutationOp {
 
-    static setSingleAuthorIfNecessary(op: MutationOp) {
-
-        const targetObject = op.getTargetObject();
-
-        if (targetObject instanceof BaseCausalCollection) {
-            if (targetObject.hasSingleWriter()) {
-                op.setAuthor(targetObject.getSingleWriter());
-            }
-        }
-
-    }
-}
-
-export { CausalCollection, BaseCausalCollection, CausalCollectionOp, AuthError };
+export { CausalCollection, BaseCausalCollection, AuthError };
 export type { CausalCollectionConfig };

src/data/collections/causal/CausalSet.ts

@@ -8,7 +8,7 @@ import { Authorization, Verification } from '../../model/causal/Authorization';
 import { HashedSet } from '../../model/immutable/HashedSet';
 import { MutableSetEvents } from '../../collections/mutable/MutableSet';
 import { MutableContentEvents } from '../../model/mutable/MutableObject';
-import { AuthError, BaseCausalCollection, CausalCollection, CausalCollectionConfig, CausalCollectionOp } from './CausalCollection';
+import { AuthError, BaseCausalCollection, CausalCollection, CausalCollectionConfig } from './CausalCollection';
 import { ClassRegistry } from 'data/model/literals';
 
 /*
@@ -25,10 +25,13 @@ class AddOp<T> extends MutationOp {
 
     element?: T;
 
-    constructor(targetObject?: CausalSet<T>, element?: T) {
+    constructor(targetObject?: CausalSet<T>, element?: T, author?: Identity) {
         super(targetObject);
 
         this.element = element;
+        if (author !== undefined) {
+            this.setAuthor(author);
+        }
     }
 
     getClassName(): string {
@@ -84,8 +87,12 @@ class AddOp<T> extends MutationOp {
 class DeleteOp<T> extends InvalidateAfterOp {
     static className = 'hss/v0/CausalSet/DeleteOp';
 
-    constructor(targetOp?: AddOp<T>) {
+    constructor(targetOp?: AddOp<T>, author?: Identity) {
         super(targetOp);
+
+        if (author !== undefined) {
+            this.setAuthor(author);
+        }
     }
 
     async validate(references: Map<Hash, HashedObject>): Promise<boolean> {
@@ -230,13 +237,7 @@ class CausalSet<T> extends BaseCausalCollection<T> implements CausalCollection<T
             throw new Error('CausalSet has type/element contraints that reject the element that is being added:' + elmt)
         }
 
-        const addOp = new AddOp(this, elmt);
-
-        if (author !== undefined) {
-            addOp.setAuthor(author);
-        } else {
-            CausalCollectionOp.setSingleAuthorIfNecessary(addOp);
-        }
+        const addOp = new AddOp(this, elmt, author);
 
         const auth = Authorization.chain(this.createAddAuthorizer(addOp.getAuthor()), extraAuth);
 
@@ -263,13 +264,7 @@ class CausalSet<T> extends BaseCausalCollection<T> implements CausalCollection<T
 
         for (const addOpHash of this._currentAddOpsPerElmt.get(hash)) {
             const addOp = this._currentAddOps.get(addOpHash) as AddOp<T>;
-            const deleteOp = new DeleteOp(addOp);
-
-            if (author !== undefined) {
-                deleteOp.setAuthor(author);
-            } else {
-                CausalCollectionOp.setSingleAuthorIfNecessary(deleteOp);
-            }
+            const deleteOp = new DeleteOp(addOp, author);
 
             const auth = Authorization.chain(this.createDeleteAuthorizer(deleteOp.getAuthor()), extraAuth);
 

src/data/collections/mutable/Collection.ts

@@ -5,6 +5,7 @@ import { Hash} from '../../model/hashing'
 
 
 type CollectionConfig = {
+    author?: Identity,
     writer?: Identity,
     writers?: IterableIterator<Identity>,
     acceptedTypes?: Array<string>,
@@ -29,6 +30,10 @@ abstract class BaseCollection<T> extends MutableObject {
     constructor(acceptedOpClasses : Array<string>, config?: MutableObjectConfig & CollectionConfig) {
         super(acceptedOpClasses, config);
 
+        if (config?.author !== undefined) {
+            this.setAuthor(config.author);
+        }
+
         if (config?.writers !== undefined) {
             this.writers = new HashedSet<Identity>(config.writers);
 
@@ -103,10 +108,6 @@ abstract class BaseCollection<T> extends MutableObject {
         return true;
     }
 
-    validateWriteAccess() {
-
-    }
-
     hasSingleWriter() {
         return this.writers !== undefined && this.writers.size() === 1;
     }

src/data/collections/mutable/GrowOnlySet.ts

@@ -16,10 +16,14 @@ class AddOp<T> extends CollectionOp<T> {
 
     element?: T;
 
-    constructor(targetObject?: GrowOnlySet<T>, element?: T) {
+    constructor(targetObject?: GrowOnlySet<T>, element?: T, author?: Identity) {
         super(targetObject);
 
         this.element = element;
+        
+        if (author !== undefined) {
+            this.setAuthor(author);
+        }
     }
 
     getClassName(): string {
@@ -84,14 +88,12 @@ class GrowOnlySet<T> extends BaseCollection<T> {
         }
 
         if (!this.has(element)) {
-            let op = new AddOp<T>(this, element);
+            let op = new AddOp<T>(this, element, author);
             if (author !== undefined) {
 
                 if (this.writers !== undefined && !this.writers.has(author)) {
                     throw new Error('Identity ' + author.hash() + ' tried to add an element to GrowOnlySet ' + this.hash() + ', but it is not in the writers set.');
                 }
-
-                op.setAuthor(author);
             } else {
                 if (this.writers !== undefined) {
                     throw new Error('Tried to add an element to GrowOnlySet ' + this.hash + ', but did not probide an author that can write to it.');

src/data/collections/mutable/MutableArray.ts

@@ -12,6 +12,7 @@ import { ClassRegistry } from 'data/model/literals';
 import { MutableContentEvents } from 'data/model/mutable/MutableObject';
 import { MultiMap } from 'util/multimap';
 import { BaseCollection, Collection, CollectionConfig, CollectionOp } from './Collection';
+import { Identity } from 'data/identity';
 
 // a simple mutable list with a single writer
 
@@ -24,11 +25,14 @@ class InsertOp<T> extends CollectionOp<T> {
     element?: T;
     ordinal?: Ordinal;
 
-    constructor(target?: MutableArray<T>, element?: T, ordinal?: Ordinal) {
+    constructor(target?: MutableArray<T>, element?: T, ordinal?: Ordinal, author?: Identity) {
         super(target);
 
         this.element = element;
         this.ordinal = ordinal;
+        if (author !== undefined) {
+            this.setAuthor(author);
+        }
     }
 
     getClassName(): string {
@@ -69,7 +73,7 @@ class DeleteOp<T> extends CollectionOp<T> {
     elementHash?: Hash;
     deletedOps?: HashedSet<HashReference<InsertOp<T>>>;
 
-    constructor(target?: MutableArray<T>, elementHash?: Hash, insertOps?: IterableIterator<HashReference<InsertOp<T>>>) {
+    constructor(target?: MutableArray<T>, elementHash?: Hash, insertOps?: IterableIterator<HashReference<InsertOp<T>>>, author?: Identity) {
         super(target);
 
         this.elementHash = elementHash;
@@ -85,6 +89,10 @@ class DeleteOp<T> extends CollectionOp<T> {
                 this.deletedOps.add(insertOp);
             }
         }
+
+        if (author !== undefined) {
+            this.setAuthor(author);
+        }
     }
 
     init() {
@@ -208,11 +216,11 @@ class MutableArray<T> extends BaseCollection<T> implements Collection<T> {
         this._ordinals = [];
     }
 
-    async insertAt(element: T, idx: number) {
-        await this.insertManyAt([element], idx);
+    async insertAt(element: T, idx: number, author?: Identity) {
+        await this.insertManyAt([element], idx, author);
     }
 
-    async insertManyAt(elements: T[], idx: number) {
+    async insertManyAt(elements: T[], idx: number, author?: Identity) {
         this.rebuild();
 
         // In the "no duplicates" case, any items we insert will disappear from their old positions. So
@@ -262,7 +270,7 @@ class MutableArray<T> extends BaseCollection<T> implements Collection<T> {
                 oldInsertionOps = this._currentInsertOpRefs.get(elementHash);
             }
 
-            const insertOp = new InsertOp(this, element, ordinal);
+            const insertOp = new InsertOp(this, element, ordinal, author);
             await this.applyNewOp(insertOp);
 
             // Note: in the "no duplicates" case, the delete -if necessary- has to come after the 
@@ -280,52 +288,52 @@ class MutableArray<T> extends BaseCollection<T> implements Collection<T> {
         }
     }
 
-    async deleteAt(idx: number) {
-        await this.deleteManyAt(idx, 1);
+    async deleteAt(idx: number, author?: Identity) {
+        await this.deleteManyAt(idx, 1, author);
     }
 
-    async deleteManyAt(idx: number, count: number) {
+    async deleteManyAt(idx: number, count: number, author?: Identity) {
         this.rebuild();
 
         while (idx < this._contents.length && count > 0) {
             let hash = this._hashes[idx];
 
             if (this.duplicates) {
-                await this.delete(hash, this._ordinals[idx]);
+                await this.delete(hash, this._ordinals[idx], author);
             } else {
-                await this.delete(hash);
+                await this.delete(hash, undefined, author);
             }
 
             idx = idx + 1;
             count = count - 1;
         }
     }
 
-    async deleteElement(element: T) {
-        this.deleteElementByHash(HashedObject.hashElement(element));
+    async deleteElement(element: T, author?: Identity) {
+        this.deleteElementByHash(HashedObject.hashElement(element), author);
     }
 
-    async deleteElementByHash(hash: Hash) {
+    async deleteElementByHash(hash: Hash, author?: Identity) {
         this.rebuild();
-        this.delete(hash);
+        this.delete(hash, undefined, author);
     }
 
-    async push(element: T) {
-        await this.insertAt(element, this._contents.length);
+    async push(element: T, author?: Identity) {
+        await this.insertAt(element, this._contents.length, author);
     }
 
-    async pop(): Promise<T> {
+    async pop(author?: Identity): Promise<T> {
         this.rebuild();
         const lastIdx = this._contents.length - 1;
         const last = this._contents[lastIdx];
-        await this.deleteAt(lastIdx);
+        await this.deleteAt(lastIdx, author);
 
         return last;
     }
 
-    async concat(elements: T[]) {
+    async concat(elements: T[], author?: Identity) {
         this.rebuild();
-        await this.insertManyAt(elements, this._contents.length);
+        await this.insertManyAt(elements, this._contents.length, author);
     }
 
     contents() {
@@ -369,15 +377,15 @@ class MutableArray<T> extends BaseCollection<T> implements Collection<T> {
         return this._contents[idx];
     }
 
-    private async delete(hash: Hash, ordinal?: Ordinal) {
+    private async delete(hash: Hash, ordinal?: Ordinal, author?: Identity) {
 
         let deleteOp: DeleteOp<T>|undefined = undefined;
         const insertOpRefs = this._currentInsertOpRefs.get(hash);
 
         if (ordinal !== undefined) {
             for (const insertOpRef of insertOpRefs.values()) {
                 if (this._currentInsertOpOrds.get(insertOpRef.hash) === ordinal) {
-                    deleteOp = new DeleteOp(this, hash, [insertOpRef].values());
+                    deleteOp = new DeleteOp(this, hash, [insertOpRef].values(), author);
                     break;
                 }
             }