diff options
Diffstat (limited to 'graffiti.js')
| -rw-r--r-- | graffiti.js | 189 |
1 files changed, 96 insertions, 93 deletions
diff --git a/graffiti.js b/graffiti.js index 824fdf6..65c6ece 100644 --- a/graffiti.js +++ b/graffiti.js @@ -6,13 +6,13 @@ export default class { // There needs to be a new object map for each tag constructor( graffitiURL="https://graffiti.garden", - objectMapConstructor=()=>({})) { + objectConstructor=()=>({})) { this.graffitiURL = graffitiURL - this.objectMapConstructor = objectMapConstructor this.open = false this.eventTarget = new EventTarget() - this.tagMap = {} + this.tagMap = objectConstructor() // tag->{count, Set(uuid)} + this.objectMap = objectConstructor() // uuid->object this.GraffitiArray = GraffitiArray(this) this.#initialize() @@ -93,10 +93,10 @@ export default class { const data = await dataPromise delete data.messageID - if (data.type == 'error') { + if ('error' in data) { throw data } else { - return data['reply'] + return data.reply } } @@ -127,101 +127,120 @@ export default class { #updateCallback(object) { const uuid = this.#objectUUID(object) - let originalObject = null + // Add the UUID to the tag map + let subscribed = false for (const tag of object._tags) { if (!(tag in this.tagMap)) continue - const objectMap = this.tagMap[tag].objectMap - - if (uuid in objectMap) { - // Copy the original object if - // one exists, in case of failure - originalObject = Object.assign({},objectMap[uuid]) - - // Replace the object by copying - // so references to it don't break - this.#recursiveCopy(objectMap[uuid], object) - } else if (!('_id' in object)) { - - // Add properties to the object - // so it can be updated and removed - // without the collection - Object.defineProperty(object, '_id', { value: this.#objectUUID(object) }) - Object.defineProperty(object, '_update', { value: ()=>this.update(object) }) - Object.defineProperty(object, '_remove', { value: ()=>this.remove(object) }) - - objectMap[uuid] = object - } + this.tagMap[tag].uuids.add(uuid) + subscribed = true + } + + if (!subscribed) return + + // Define object specific properties + if (!('_id' in object)) { + // Assign the object UUID + Object.defineProperty(object, '_id', { value: uuid }) + + // Add proxy functions so object modifications + // sync with the server + object = new Proxy(object, this.#objectHandler(object, true)) } - // Return the original in case of failure - return originalObject + this.objectMap[uuid] = object } #removeCallback(object) { const uuid = this.#objectUUID(object) - let originalObject = null - for (const tag of object._tags) { - if (!(tag in this.tagMap)) continue - const objectMap = this.tagMap[tag].objectMap + // Remove the UUID from all relevant tag maps + let supported = false + for (const tag in this.tagMap) { + if (this.tagMap[tag].uuids.has(uuid)) { + if (object._tags.includes(tag)) { + this.tagMap[tag].uuids.delete(uuid) + } else { + supported = true + } + } + } - if (!(uuid in objectMap)) return - originalObject = Object.assign({},objectMap[uuid]) - delete objectMap[uuid] + // If all tags have been removed, delete entirely + if (!supported && uuid in this.objectMap) { + delete this.objectMap[uuid] } } async update(object) { - if (!this.myID) { - throw 'you can\'t update objects without logging in!' - } - - // Add by/to fields object._by = this.myID - if ('_to' in object && !Array.isArray(object._to)) { - throw new Error("_to must be an array") - } - - // Pre-generate the object's ID if it does not already exist if (!object._key) object._key = crypto.randomUUID() // Immediately replace the object - const originalObject = this.#updateCallback(object) + this.#updateCallback(object) // Send it to the server try { await this.#request({ update: object }) } catch(e) { - if (originalObject) { - // Restore the original object - this.#updateCallback(originalObject) - } else { - // Delete the temp object - this.#removeCallback(object) - } + // Delete the temp object + this.#removeCallback(object) throw e } } - async remove(object) { - if (!this.myID) { - throw 'you can\'t remove objects without logging in!' + #objectHandler(object, root) { + return { + get: (target, prop, receiver)=> + this.#getObjectProperty(object, target, prop, receiver), + set: (target, prop, val, receiver)=> + this.#setObjectProperty(object, root, target, prop, val, receiver), + deleteProperty: (target, prop)=> + this.#deleteObjectProperty(object, root, target, prop) } + } - if (this.myID != object._by) { - throw 'you can\'t remove an object that isn\'t yours!' + #getObjectProperty(object, target, prop, receiver) { + if (typeof target[prop] === 'object' && target[prop] !== null) { + return new Proxy(Reflect.get(target, prop, receiver), this.#objectHandler(object, false)) + } else { + return Reflect.get(target, prop, receiver) } + } - // Immediately remove the object - // but store it in case there is an error - const originalObject = this.#removeCallback(object) + #setObjectProperty(object, root, target, prop, val, receiver) { + // Store the original, perform the update, + // sync with server and restore original if error + const originalObject = Object.assign({}, object) + if (Reflect.set(target, prop, val, receiver)) { + this.#removeCallback(originalObject) + this.#updateCallback(object) + this.#request({ update: object }).catch(e=> { + this.#removeCallback(object) + this.#updateCallback(originalObject) + throw e + }) + return true + } else { return false } + } - try { - return await this.#request({ remove: object._key }) - } catch(e) { - // Delete failed, restore the object - if (originalObject) this.#updateCallback(originalObject) - throw e + #deleteObjectProperty(object, root, target, prop) { + const originalObject = Object.assign({}, object) + if (root && ['_key', '_by', '_tags'].includes(prop)) { + // This is a deletion of the whole object + this.#removeCallback(object) + this.#request({ remove: object._key }).catch(e=> { + this.#updateCallback(originalObject) + throw e + }) + return true + } else { + if (Reflect.deleteProperty(target, prop)) { + this.#request({ update: object }).catch(e=> { + this.#updateCallback(originalObject) + throw e + }) + return true + } else { return false } } } @@ -236,7 +255,7 @@ export default class { }}) } - objectsByTags(...tags) { + objects(...tags) { tags = tags.filter(tag=> tag!=null) for (const tag of tags) { if (!(tag in this.tagMap)) { @@ -244,12 +263,13 @@ export default class { } } - // Merge by UUID to combine all the maps - const combinedMaps = Object.assign({}, - ...tags.map(tag=> this.tagMap[tag].objectMap)) + // Merge by UUIDs from all tags and + // convert to relevant objects + const uuids = new Set(tags.map(tag=>[...this.tagMap[tag].uuids]).flat()) + const objects = [...uuids].map(uuid=> this.objectMap[uuid]) // Return an array wrapped with graffiti functions - return new this.GraffitiArray(...Object.values(combinedMaps)) + return new this.GraffitiArray(...objects) } async subscribe(...tags) { @@ -263,7 +283,7 @@ export default class { } else { // Create a new slot this.tagMap[tag] = { - objectMap: this.objectMapConstructor(), + uuids: new Set(), count: 1 } subscribingTags.push(tag) @@ -307,9 +327,9 @@ export default class { // Clear data for (let tag in this.tagMap) { - const objectMap = this.tagMap[tag].objectMap - for (let uuid in objectMap) delete objectMap[uuid] + this.tagMap[tag].uuids = new Set() } + for (let uuid in this.objectMap) delete this.objectMap[uuid] // Resubscribe const tags = Object.keys(this.tagMap) @@ -328,21 +348,4 @@ export default class { } return object._by + object._key } - - #recursiveCopy(target, source) { - for (const field in target) { - if (!(field in source)) { - delete target[field] - } - } - - for (const field in source) { - if (field in target && typeof target[field] == 'object' && typeof source[field] == 'object') { - this.#recursiveCopy(target[field], source[field]) - } else { - target[field] = source[field] - } - } - } } - |