Fix tags

indexedDb/channels/handlers.go

@@ -38,16 +38,16 @@ type manager struct {
 // RegisterHandlers registers all the reception handlers to manage messages from
 // the main thread for the channels.EventModel.
 func (m *manager) RegisterHandlers() {
-	m.mh.RegisterHandler(worker.NewWASMEventModelTag, m.newWASMEventModelHandler)
-	m.mh.RegisterHandler(worker.JoinChannelTag, m.joinChannelHandler)
-	m.mh.RegisterHandler(worker.LeaveChannelTag, m.leaveChannelHandler)
-	m.mh.RegisterHandler(worker.ReceiveMessageTag, m.receiveMessageHandler)
-	m.mh.RegisterHandler(worker.ReceiveReplyTag, m.receiveReplyHandler)
-	m.mh.RegisterHandler(worker.ReceiveReactionTag, m.receiveReactionHandler)
-	m.mh.RegisterHandler(worker.UpdateFromUUIDTag, m.updateFromUUIDHandler)
-	m.mh.RegisterHandler(worker.UpdateFromMessageIDTag, m.updateFromMessageIDHandler)
-	m.mh.RegisterHandler(worker.GetMessageTag, m.getMessageHandler)
-	m.mh.RegisterHandler(worker.DeleteMessageTag, m.deleteMessageHandler)
+	m.mh.RegisterCallback(mChannels.NewWASMEventModelTag, m.newWASMEventModelHandler)
+	m.mh.RegisterCallback(mChannels.JoinChannelTag, m.joinChannelHandler)
+	m.mh.RegisterCallback(mChannels.LeaveChannelTag, m.leaveChannelHandler)
+	m.mh.RegisterCallback(mChannels.ReceiveMessageTag, m.receiveMessageHandler)
+	m.mh.RegisterCallback(mChannels.ReceiveReplyTag, m.receiveReplyHandler)
+	m.mh.RegisterCallback(mChannels.ReceiveReactionTag, m.receiveReactionHandler)
+	m.mh.RegisterCallback(mChannels.UpdateFromUUIDTag, m.updateFromUUIDHandler)
+	m.mh.RegisterCallback(mChannels.UpdateFromMessageIDTag, m.updateFromMessageIDHandler)
+	m.mh.RegisterCallback(mChannels.GetMessageTag, m.getMessageHandler)
+	m.mh.RegisterCallback(mChannels.DeleteMessageTag, m.deleteMessageHandler)
 }
 
 // newWASMEventModelHandler is the handler for NewWASMEventModel. Returns an
@@ -97,7 +97,7 @@ func (m *manager) messageReceivedCallback(
 	}
 
 	// Send it to the main thread
-	m.mh.SendMessage(worker.MessageReceivedCallbackTag, data)
+	m.mh.SendMessage(mChannels.MessageReceivedCallbackTag, data)
 }
 
 // storeDatabaseName sends the database name to the main thread and waits for
@@ -107,14 +107,14 @@ func (m *manager) messageReceivedCallback(
 func (m *manager) storeDatabaseName(databaseName string) error {
 	// Register response handler with channel that will wait for the response
 	responseChan := make(chan []byte)
-	m.mh.RegisterCallback(worker.StoreDatabaseNameTag,
+	m.mh.RegisterCallback(mChannels.StoreDatabaseNameTag,
 		func(data []byte) ([]byte, error) {
 			responseChan <- data
 			return nil, nil
 		})
 
 	// Send encryption status to main thread
-	m.mh.SendMessage(worker.StoreDatabaseNameTag, []byte(databaseName))
+	m.mh.SendMessage(mChannels.StoreDatabaseNameTag, []byte(databaseName))
 
 	// Wait for response
 	select {
@@ -151,14 +151,14 @@ func (m *manager) storeEncryptionStatus(
 
 	// Register response handler with channel that will wait for the response
 	responseChan := make(chan []byte)
-	m.mh.RegisterCallback(worker.EncryptionStatusTag,
+	m.mh.RegisterCallback(mChannels.EncryptionStatusTag,
 		func(data []byte) ([]byte, error) {
 			responseChan <- data
 			return nil, nil
 		})
 
 	// Send encryption status to main thread
-	m.mh.SendMessage(worker.EncryptionStatusTag, data)
+	m.mh.SendMessage(mChannels.EncryptionStatusTag, data)
 
 	// Wait for response
 	var response mChannels.EncryptionStatusReply

indexedDb/dm/handlers.go

@@ -36,12 +36,12 @@ type manager struct {
 // RegisterHandlers registers all the reception handlers to manage messages from
 // the main thread for the channels.EventModel.
 func (m *manager) RegisterHandlers() {
-	m.mh.RegisterHandler(worker.NewWASMEventModelTag, m.newWASMEventModelHandler)
-	m.mh.RegisterHandler(worker.ReceiveTag, m.receiveHandler)
-	m.mh.RegisterHandler(worker.ReceiveTextTag, m.receiveTextHandler)
-	m.mh.RegisterHandler(worker.ReceiveReplyTag, m.receiveReplyHandler)
-	m.mh.RegisterHandler(worker.ReceiveReactionTag, m.receiveReactionHandler)
-	m.mh.RegisterHandler(worker.UpdateSentStatusTag, m.updateSentStatusHandler)
+	m.mh.RegisterCallback(mDm.NewWASMEventModelTag, m.newWASMEventModelHandler)
+	m.mh.RegisterCallback(mDm.ReceiveTag, m.receiveHandler)
+	m.mh.RegisterCallback(mDm.ReceiveTextTag, m.receiveTextHandler)
+	m.mh.RegisterCallback(mDm.ReceiveReplyTag, m.receiveReplyHandler)
+	m.mh.RegisterCallback(mDm.ReceiveReactionTag, m.receiveReactionHandler)
+	m.mh.RegisterCallback(mDm.UpdateSentStatusTag, m.updateSentStatusHandler)
 }
 
 // newWASMEventModelHandler is the handler for NewWASMEventModel. Returns an
@@ -91,7 +91,7 @@ func (m *manager) messageReceivedCallback(
 	}
 
 	// Send it to the main thread
-	m.mh.SendMessage(worker.MessageReceivedCallbackTag, data)
+	m.mh.SendMessage(mDm.MessageReceivedCallbackTag, data)
 }
 
 // storeDatabaseName sends the database name to the main thread and waits for
@@ -101,14 +101,14 @@ func (m *manager) messageReceivedCallback(
 func (m *manager) storeDatabaseName(databaseName string) error {
 	// Register response handler with channel that will wait for the response
 	responseChan := make(chan []byte)
-	m.mh.RegisterCallback(worker.StoreDatabaseNameTag,
+	m.mh.RegisterCallback(mDm.StoreDatabaseNameTag,
 		func(data []byte) ([]byte, error) {
 			responseChan <- data
 			return nil, nil
 		})
 
 	// Send encryption status to main thread
-	m.mh.SendMessage(worker.StoreDatabaseNameTag, []byte(databaseName))
+	m.mh.SendMessage(mDm.StoreDatabaseNameTag, []byte(databaseName))
 
 	// Wait for response
 	select {
@@ -145,14 +145,14 @@ func (m *manager) storeEncryptionStatus(
 
 	// Register response handler with channel that will wait for the response
 	responseChan := make(chan []byte)
-	m.mh.RegisterCallback(worker.EncryptionStatusTag,
+	m.mh.RegisterCallback(mDm.EncryptionStatusTag,
 		func(data []byte) ([]byte, error) {
 			responseChan <- data
 			return nil, nil
 		})
 
 	// Send encryption status to main thread
-	m.mh.SendMessage(worker.EncryptionStatusTag, data)
+	m.mh.SendMessage(mDm.EncryptionStatusTag, data)
 
 	// Wait for response
 	var response mChannels.EncryptionStatusReply

indexedDbWorker/channels/implementation.go

@@ -40,12 +40,12 @@ func (w *wasmModel) JoinChannel(channel *cryptoBroadcast.Channel) {
 		return
 	}
 
-	w.wm.SendMessage(worker.JoinChannelTag, data, nil)
+	w.wm.SendMessage(JoinChannelTag, data, nil)
 }
 
 // LeaveChannel is called whenever a channel is left locally.
 func (w *wasmModel) LeaveChannel(channelID *id.ID) {
-	w.wm.SendMessage(worker.LeaveChannelTag, channelID.Marshal(), nil)
+	w.wm.SendMessage(LeaveChannelTag, channelID.Marshal(), nil)
 }
 
 // ReceiveMessage is called whenever a message is received on a given channel.
@@ -81,7 +81,7 @@ func (w *wasmModel) ReceiveMessage(channelID *id.ID, messageID message.ID,
 	}
 
 	uuidChan := make(chan uint64)
-	w.wm.SendMessage(worker.ReceiveMessageTag, data, func(data []byte) {
+	w.wm.SendMessage(ReceiveMessageTag, data, func(data []byte) {
 		var uuid uint64
 		err = json.Unmarshal(data, &uuid)
 		if err != nil {
@@ -149,7 +149,7 @@ func (w *wasmModel) ReceiveReply(channelID *id.ID, messageID,
 	}
 
 	uuidChan := make(chan uint64)
-	w.wm.SendMessage(worker.ReceiveReplyTag, data, func(data []byte) {
+	w.wm.SendMessage(ReceiveReplyTag, data, func(data []byte) {
 		var uuid uint64
 		err = json.Unmarshal(data, &uuid)
 		if err != nil {
@@ -211,7 +211,7 @@ func (w *wasmModel) ReceiveReaction(channelID *id.ID, messageID,
 	}
 
 	uuidChan := make(chan uint64)
-	w.wm.SendMessage(worker.ReceiveReactionTag, data, func(data []byte) {
+	w.wm.SendMessage(ReceiveReactionTag, data, func(data []byte) {
 		var uuid uint64
 		err = json.Unmarshal(data, &uuid)
 		if err != nil {
@@ -298,7 +298,7 @@ func (w *wasmModel) UpdateFromUUID(uuid uint64, messageID *message.ID,
 		return
 	}
 
-	w.wm.SendMessage(worker.UpdateFromUUIDTag, data, nil)
+	w.wm.SendMessage(UpdateFromUUIDTag, data, nil)
 }
 
 // UpdateFromMessageID is called whenever a message with the message ID is
@@ -344,7 +344,7 @@ func (w *wasmModel) UpdateFromMessageID(messageID message.ID,
 	}
 
 	uuidChan := make(chan uint64)
-	w.wm.SendMessage(worker.UpdateFromMessageIDTag, data,
+	w.wm.SendMessage(UpdateFromMessageIDTag, data,
 		func(data []byte) {
 			var uuid uint64
 			err = json.Unmarshal(data, &uuid)
@@ -378,7 +378,7 @@ type GetMessageMessage struct {
 func (w *wasmModel) GetMessage(
 	messageID message.ID) (channels.ModelMessage, error) {
 	msgChan := make(chan GetMessageMessage)
-	w.wm.SendMessage(worker.GetMessageTag, messageID.Marshal(),
+	w.wm.SendMessage(GetMessageTag, messageID.Marshal(),
 		func(data []byte) {
 			var msg GetMessageMessage
 			err := json.Unmarshal(data, &msg)
@@ -405,7 +405,7 @@ func (w *wasmModel) GetMessage(
 // DeleteMessage removes a message with the given messageID from storage.
 func (w *wasmModel) DeleteMessage(messageID message.ID) error {
 	errChan := make(chan error)
-	w.wm.SendMessage(worker.DeleteMessageTag, messageID.Marshal(),
+	w.wm.SendMessage(DeleteMessageTag, messageID.Marshal(),
 		func(data []byte) {
 			if data != nil {
 				errChan <- errors.New(string(data))

indexedDbWorker/channels/init.go

@@ -56,23 +56,20 @@ func NewWASMEventModel(path string, encryption cryptoChannel.Cipher,
 	cb MessageReceivedCallback) (channels.EventModel, error) {
 
 	// TODO: bring in URL and name from caller
-	wm, err := worker.NewManager(
-		WorkerJavascriptFileURL, "channelsIndexedDb")
+	wm, err := worker.NewManager(WorkerJavascriptFileURL, "channelsIndexedDb")
 	if err != nil {
 		return nil, err
 	}
 
 	// Register handler to manage messages for the MessageReceivedCallback
 	wm.RegisterCallback(
-		worker.MessageReceivedCallbackTag, messageReceivedCallbackHandler(cb))
+		MessageReceivedCallbackTag, messageReceivedCallbackHandler(cb))
 
 	// Register handler to manage checking encryption status from local storage
-	wm.RegisterCallback(
-		worker.EncryptionStatusTag, checkDbEncryptionStatusHandler(wm))
+	wm.RegisterCallback(EncryptionStatusTag, checkDbEncryptionStatusHandler(wm))
 
 	// Register handler to manage the storage of the database name
-	wm.RegisterCallback(
-		worker.StoreDatabaseNameTag, storeDatabaseNameHandler(wm))
+	wm.RegisterCallback(StoreDatabaseNameTag, storeDatabaseNameHandler(wm))
 
 	encryptionJSON, err := json.Marshal(encryption)
 	if err != nil {
@@ -90,7 +87,7 @@ func NewWASMEventModel(path string, encryption cryptoChannel.Cipher,
 	}
 
 	errChan := make(chan string)
-	wm.SendMessage(worker.NewWASMEventModelTag, payload,
+	wm.SendMessage(NewWASMEventModelTag, payload,
 		func(data []byte) { errChan <- string(data) })
 
 	select {
@@ -175,7 +172,7 @@ func checkDbEncryptionStatusHandler(
 			return
 		}
 
-		wh.SendMessage(worker.EncryptionStatusTag, statusData, nil)
+		wh.SendMessage(EncryptionStatusTag, statusData, nil)
 	}
 }
 
@@ -191,6 +188,6 @@ func storeDatabaseNameHandler(
 			returnData = []byte(err.Error())
 		}
 
-		wh.SendMessage(worker.StoreDatabaseNameTag, returnData, nil)
+		wh.SendMessage(StoreDatabaseNameTag, returnData, nil)
 	}
 }

indexedDbWorker/channels/tags.go

+////////////////////////////////////////////////////////////////////////////////
+// Copyright © 2022 xx foundation                                             //
+//                                                                            //
+// Use of this source code is governed by a license that can be found in the  //
+// LICENSE file.                                                              //
+////////////////////////////////////////////////////////////////////////////////
+
+package channels
+
+import "gitlab.com/elixxir/xxdk-wasm/worker"
+
+// List of tags that can be used when sending a message or registering a handler
+// to receive a message.
+const (
+
+	NewWASMEventModelTag       worker.Tag = "NewWASMEventModel"
+	MessageReceivedCallbackTag worker.Tag = "MessageReceivedCallback"
+	EncryptionStatusTag        worker.Tag = "EncryptionStatus"
+	StoreDatabaseNameTag       worker.Tag = "StoreDatabaseName"
+
+	JoinChannelTag         worker.Tag = "JoinChannel"
+	LeaveChannelTag        worker.Tag = "LeaveChannel"
+	ReceiveMessageTag      worker.Tag = "ReceiveMessage"
+	ReceiveReplyTag        worker.Tag = "ReceiveReply"
+	ReceiveReactionTag     worker.Tag = "ReceiveReaction"
+	UpdateFromUUIDTag      worker.Tag = "UpdateFromUUID"
+	UpdateFromMessageIDTag worker.Tag = "UpdateFromMessageID"
+	GetMessageTag          worker.Tag = "GetMessage"
+	DeleteMessageTag       worker.Tag = "DeleteMessage"
+)
\ No newline at end of file

indexedDbWorker/dm/implementation.go

@@ -67,7 +67,7 @@ func (w *wasmModel) Receive(messageID message.ID, nickname string, text []byte,
 	}
 
 	uuidChan := make(chan uint64)
-	w.wh.SendMessage(worker.ReceiveTag, data, func(data []byte) {
+	w.wh.SendMessage(ReceiveTag, data, func(data []byte) {
 		var uuid uint64
 		err = json.Unmarshal(data, &uuid)
 		if err != nil {
@@ -112,7 +112,7 @@ func (w *wasmModel) ReceiveText(messageID message.ID, nickname, text string,
 	}
 
 	uuidChan := make(chan uint64)
-	w.wh.SendMessage(worker.ReceiveTextTag, data, func(data []byte) {
+	w.wh.SendMessage(ReceiveTextTag, data, func(data []byte) {
 		var uuid uint64
 		err = json.Unmarshal(data, &uuid)
 		if err != nil {
@@ -158,7 +158,7 @@ func (w *wasmModel) ReceiveReply(messageID, reactionTo message.ID, nickname,
 	}
 
 	uuidChan := make(chan uint64)
-	w.wh.SendMessage(worker.ReceiveReplyTag, data, func(data []byte) {
+	w.wh.SendMessage(ReceiveReplyTag, data, func(data []byte) {
 		var uuid uint64
 		err = json.Unmarshal(data, &uuid)
 		if err != nil {
@@ -204,7 +204,7 @@ func (w *wasmModel) ReceiveReaction(messageID, reactionTo message.ID, nickname,
 	}
 
 	uuidChan := make(chan uint64)
-	w.wh.SendMessage(worker.ReceiveReactionTag, data, func(data []byte) {
+	w.wh.SendMessage(ReceiveReactionTag, data, func(data []byte) {
 		var uuid uint64
 		err = json.Unmarshal(data, &uuid)
 		if err != nil {
@@ -242,5 +242,5 @@ func (w *wasmModel) UpdateSentStatus(uuid uint64, messageID message.ID,
 			"Could not JSON marshal payload for TransferMessage: %+v", err)
 	}
 
-	w.wh.SendMessage(worker.UpdateSentStatusTag, data, nil)
+	w.wh.SendMessage(UpdateSentStatusTag, data, nil)
 }

indexedDbWorker/dm/init.go

@@ -46,23 +46,20 @@ func NewWASMEventModel(path string, encryption cryptoChannel.Cipher,
 	cb MessageReceivedCallback) (dm.EventModel, error) {
 
 	// TODO: bring in URL and name from caller
-	wh, err := worker.NewManager(
-		WorkerJavascriptFileURL, "dmIndexedDb")
+	wh, err := worker.NewManager(WorkerJavascriptFileURL, "dmIndexedDb")
 	if err != nil {
 		return nil, err
 	}
 
 	// Register handler to manage messages for the MessageReceivedCallback
 	wh.RegisterCallback(
-		worker.MessageReceivedCallbackTag, messageReceivedCallbackHandler(cb))
+		MessageReceivedCallbackTag, messageReceivedCallbackHandler(cb))
 
 	// Register handler to manage checking encryption status from local storage
-	wh.RegisterCallback(
-		worker.EncryptionStatusTag, checkDbEncryptionStatusHandler(wh))
+	wh.RegisterCallback(EncryptionStatusTag, checkDbEncryptionStatusHandler(wh))
 
 	// Register handler to manage the storage of the database name
-	wh.RegisterCallback(
-		worker.StoreDatabaseNameTag, storeDatabaseNameHandler(wh))
+	wh.RegisterCallback(StoreDatabaseNameTag, storeDatabaseNameHandler(wh))
 
 	encryptionJSON, err := json.Marshal(encryption)
 	if err != nil {
@@ -80,7 +77,7 @@ func NewWASMEventModel(path string, encryption cryptoChannel.Cipher,
 	}
 
 	errChan := make(chan string)
-	wh.SendMessage(worker.NewWASMEventModelTag, payload,
+	wh.SendMessage(NewWASMEventModelTag, payload,
 		func(data []byte) { errChan <- string(data) })
 
 	select {
@@ -164,7 +161,7 @@ func checkDbEncryptionStatusHandler(wh *worker.Manager) func(data []byte) {
 			return
 		}
 
-		wh.SendMessage(worker.EncryptionStatusTag, statusData, nil)
+		wh.SendMessage(EncryptionStatusTag, statusData, nil)
 	}
 }
 
@@ -179,6 +176,6 @@ func storeDatabaseNameHandler(wh *worker.Manager) func(data []byte) {
 			returnData = []byte(err.Error())
 		}
 
-		wh.SendMessage(worker.StoreDatabaseNameTag, returnData, nil)
+		wh.SendMessage(StoreDatabaseNameTag, returnData, nil)
 	}
 }

indexedDbWorker/dm/tags.go

+////////////////////////////////////////////////////////////////////////////////
+// Copyright © 2022 xx foundation                                             //
+//                                                                            //
+// Use of this source code is governed by a license that can be found in the  //
+// LICENSE file.                                                              //
+////////////////////////////////////////////////////////////////////////////////
+
+package channelEventModel
+
+import "gitlab.com/elixxir/xxdk-wasm/worker"
+
+// List of tags that can be used when sending a message or registering a handler
+// to receive a message.
+const (
+	NewWASMEventModelTag       worker.Tag = "NewWASMEventModel"
+	MessageReceivedCallbackTag worker.Tag = "MessageReceivedCallback"
+	EncryptionStatusTag        worker.Tag = "EncryptionStatus"
+	StoreDatabaseNameTag       worker.Tag = "StoreDatabaseName"
+
+	ReceiveReplyTag     worker.Tag = "ReceiveReply"
+	ReceiveReactionTag  worker.Tag = "ReceiveReaction"
+	ReceiveTag          worker.Tag = "Receive"
+	ReceiveTextTag      worker.Tag = "ReceiveText"
+	UpdateSentStatusTag worker.Tag = "UpdateSentStatusTag"
+)

worker/README.md

 # Web Worker API
 
-This package allows you to create a [Javascript Web Worker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API)
+This package allows you to create
+a [Javascript Web Worker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API)
 from WASM and facilitates communication between the web worker and the main
 thread using a messaging system.
 
@@ -27,7 +28,6 @@ func main() {
 }
 ```
 
-
 Example WASM start file:
 
 ```javascript

worker/manager.go

@@ -20,15 +20,14 @@ import (
 )
 
 // TODO:
-//  1. fix tag system
-//  2. restructure packages
-//  3. Get path to JS file from bindings
-//  4. Add tests for manager.go and thread.go
+//  1. restructure packages
+//  2. Get path to JS file from bindings
+//  3. Add tests for manager.go and thread.go
 
-// InitID is the ID for the first item in the callback list. If the list only
+// initID is the ID for the first item in the callback list. If the list only
 // contains one callback, then this is the ID of that callback. If the list has
 // autogenerated unique IDs, this is the initial ID to start at.
-const InitID = uint64(0)
+const initID = uint64(0)
 
 // Response timeouts.
 const (
@@ -54,7 +53,7 @@ type Manager struct {
 	// received from the worker. Each callback is keyed on a tag specifying how
 	// the received message should be handled. If the message is a reply to a
 	// message sent to the worker, then the callback is also keyed on a unique
-	// ID. If the message is not a reply, then it appears on InitID.
+	// ID. If the message is not a reply, then it appears on initID.
 	callbacks map[Tag]map[uint64]ReceptionCallback
 
 	// responseIDs is a list of the newest ID to assign to each callback when
@@ -88,7 +87,7 @@ func NewManager(aURL, name string) (*Manager, error) {
 	// Register a callback that will receive initial message from worker
 	// indicating that it is ready
 	ready := make(chan struct{})
-	m.RegisterCallback(ReadyTag, func([]byte) { ready <- struct{}{} })
+	m.RegisterCallback(readyTag, func([]byte) { ready <- struct{}{} })
 
 	// Wait for the ready signal from the worker
 	select {
@@ -115,7 +114,7 @@ func (m *Manager) SendMessage(
 	jww.DEBUG.Printf("[WW] [%s] Main sending message for %q and ID %d with "+
 		"data: %s", m.name, tag, id, data)
 
-	msg := Message{
+	msg := message{
 		Tag:  tag,
 		ID:   id,
 		Data: data,
@@ -132,7 +131,7 @@ func (m *Manager) SendMessage(
 // receiveMessage is registered with the Javascript event listener and is called
 // every time a new message from the worker is received.
 func (m *Manager) receiveMessage(data []byte) error {
-	var msg Message
+	var msg message
 	err := json.Unmarshal(data, &msg)
 	if err != nil {
 		return err
@@ -184,7 +183,7 @@ func (m *Manager) RegisterCallback(tag Tag, receptionCB ReceptionCallback) {
 	m.mux.Lock()
 	defer m.mux.Unlock()
 
-	id := InitID
+	id := initID
 
 	jww.DEBUG.Printf("[WW] [%s] Main registering callback for tag %q and ID "+
 		"%d (autoID: %t)", m.name, tag, id)
@@ -217,7 +216,7 @@ func (m *Manager) registerReplyCallback(
 // thread-safe.
 func (m *Manager) getNextID(tag Tag) uint64 {
 	if _, exists := m.responseIDs[tag]; !exists {
-		m.responseIDs[tag] = InitID
+		m.responseIDs[tag] = initID
 	}
 
 	id := m.responseIDs[tag]

worker/manager_test.go

@@ -35,17 +35,11 @@ func TestManager_getNextID(t *testing.T) {
 		responseIDs: make(map[Tag]uint64),
 	}
 
-	for _, tag := range []Tag{
-		ReadyTag, NewWASMEventModelTag, EncryptionStatusTag,
-		StoreDatabaseNameTag, JoinChannelTag, LeaveChannelTag,
-		ReceiveMessageTag, ReceiveReplyTag, ReceiveReactionTag,
-		UpdateFromUUIDTag, UpdateFromMessageIDTag, GetMessageTag,
-		DeleteMessageTag, ReceiveTag, ReceiveTextTag, UpdateSentStatusTag,
-	} {
+	for _, tag := range []Tag{readyTag, "test", "A", "B", "C"} {
 		id := m.getNextID(tag)
-		if id != InitID {
-			t.Errorf("ID for new tag %q is not InitID."+
-				"\nexpected: %d\nreceived: %d", tag, InitID, id)
+		if id != initID {
+			t.Errorf("ID for new tag %q is not initID."+
+				"\nexpected: %d\nreceived: %d", tag, initID, id)
 		}
 
 		for j := uint64(1); j < 100; j++ {

worker/message.go

@@ -7,9 +7,9 @@
 
 package worker
 
-// Message is the outer message that contains the contents of each message sent
+// message is the outer message that contains the contents of each message sent
 // to the worker. It is transmitted as JSON.
-type Message struct {
+type message struct {
 	Tag      Tag    `json:"tag"`
 	ID       uint64 `json:"id"`
 	DeleteCB bool   `json:"deleteCB"`

worker/tag.go

@@ -12,30 +12,7 @@ package worker
 // Tag describes how a message sent to or from the worker should be handled.
 type Tag string
 
-// FIXME: This system of tagging does not work so well when using the
-//  Manager for more than one database. This should bed fixed.
-
-// List of tags that can be used when sending a message or registering a handler
-// to receive a message.
+// Generic tags used by all workers.
 const (
-	ReadyTag Tag = "Ready"
-
-	NewWASMEventModelTag       Tag = "NewWASMEventModel"
-	MessageReceivedCallbackTag Tag = "MessageReceivedCallback"
-	EncryptionStatusTag        Tag = "EncryptionStatus"
-	StoreDatabaseNameTag       Tag = "StoreDatabaseName"
-
-	JoinChannelTag         Tag = "JoinChannel"
-	LeaveChannelTag        Tag = "LeaveChannel"
-	ReceiveMessageTag      Tag = "ReceiveMessage"
-	ReceiveReplyTag        Tag = "ReceiveReply"
-	ReceiveReactionTag     Tag = "ReceiveReaction"
-	UpdateFromUUIDTag      Tag = "UpdateFromUUID"
-	UpdateFromMessageIDTag Tag = "UpdateFromMessageID"
-	GetMessageTag          Tag = "GetMessage"
-	DeleteMessageTag       Tag = "DeleteMessage"
-
-	ReceiveTag          Tag = "Receive"
-	ReceiveTextTag      Tag = "ReceiveText"
-	UpdateSentStatusTag Tag = "UpdateSentStatusTag"
+	readyTag Tag = "Ready"
 )

worker/thread.go

@@ -55,14 +55,14 @@ func NewThreadManager(name string) *ThreadManager {
 // ready. Once the main thread receives this, it will initiate communication.
 // Therefore, this should only be run once all listeners are ready.
 func (tm *ThreadManager) SignalReady() {
-	tm.SendMessage(ReadyTag, nil)
+	tm.SendMessage(readyTag, nil)
 }
 
 // SendMessage sends a message to the main thread for the given tag.
 func (tm *ThreadManager) SendMessage(tag Tag, data []byte) {
-	msg := Message{
+	msg := message{
 		Tag:      tag,
-		ID:       InitID,
+		ID:       initID,
 		DeleteCB: false,
 		Data:     data,
 	}
@@ -81,7 +81,7 @@ func (tm *ThreadManager) SendMessage(tag Tag, data []byte) {
 // sendResponse sends a reply to the main thread with the given tag and ID.
 func (tm *ThreadManager) sendResponse(
 	tag Tag, id uint64, data []byte) {
-	msg := Message{
+	msg := message{
 		Tag:      tag,
 		ID:       id,
 		DeleteCB: true,
@@ -103,7 +103,7 @@ func (tm *ThreadManager) sendResponse(
 // everytime a message from the main thread is received. If the registered
 // callback returns a response, it is sent to the main thread.
 func (tm *ThreadManager) receiveMessage(data []byte) error {
-	var msg Message
+	var msg message
 	err := json.Unmarshal(data, &msg)
 	if err != nil {
 		return err