@trullock/firebase-common 1.1.1 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trullock/firebase-common",
-  "version": "1.1.1",
+  "version": "1.3.0",
   "description": "Collection of common firebase helpers",
   "homepage": "https://github.com/trullock/firebase#readme",
   "bugs": {
@@ -21,7 +21,7 @@
     "access": "public"
   },
   "scripts": {
-    "test": "node ./tests/getters.js"
+    "test": "node ./tests/test.js"
   },
   "dependencies": {
   }

package/src/automapper.js

@@ -4,7 +4,7 @@ let mappings = [];
 /**
  * 
  * @param {function} toFirestore A function of the form (key: string, value: object/primitive) => object/primitive. Return a mapped value or undefined to fallback to default mapping
- * @param {funciton} fromFirestore A function of the form (key: string, value: object/primitive) => object/primitive. Return a mapped value or undefined to fallback to default mapping
+ * @param {function} fromFirestore A function of the form (key: string, value: object/primitive, dest: object) => object/primitive. Return a mapped value or undefined to fallback to default mapping
  */
 export function registerMapping(toFirestore, fromFirestore)
 {
@@ -60,6 +60,23 @@ export function registerClassForPersistence(type, persistedGetters)
 	return doRegisterClassForPersistence(type, null, null, persistedGetters || [])
 }
 
+function getAllStaticProps(type) {
+    const props = [];
+    let current = type;
+    while (current && current !== Function.prototype)
+		{
+        Object.getOwnPropertyNames(current)
+            .filter(p => !['length', 'name', 'prototype'].includes(p))
+            .forEach(p => props.push({
+				name: p,
+				value: Object.getOwnPropertyDescriptor(current, p).value
+			}));
+			
+        current = Object.getPrototypeOf(current);
+    }
+    return props;
+}
+
 function doRegisterClassForPersistence(type, name, parent, persistedGetters)
 {
 	let key = name ? name : type.name;
@@ -72,10 +89,11 @@ function doRegisterClassForPersistence(type, name, parent, persistedGetters)
 	};
 
 	// static nested classes
-	for(let [k, value] of Object.entries(type))
+	let props = getAllStaticProps(type);
+	for(let prop of props)
 	{
-		if(value?.toString()?.substr(0, 5) == 'class')
-			doRegisterClassForPersistence(value, k, key, persistedGetters)
+		if(prop.value?.toString()?.substr(0, 5) == 'class')
+			doRegisterClassForPersistence(prop.value, prop.name, key, persistedGetters)
 	}
 }
 
@@ -219,7 +237,7 @@ export function autoMapFromFirestore(obj)
 			let handled = false;
 			for(let mapping of mappings)
 			{
-				let result = mapping.fromFirestore(key, value)
+				let result = mapping.fromFirestore(key, value, dest)
 				if(result !== undefined)
 				{
 					dest[key] = result;

package/src/utils.js

@@ -25,4 +25,75 @@ export function firestorePath(pathSegments)
 	});
 
 	return segemnts.join('/');
+}
+
+
+
+
+
+
+
+
+
+
+
+function getAllProtoProps(obj) {
+	const props = [];
+	let proto = Object.getPrototypeOf(obj);
+	while (proto && proto !== Object.prototype)
+		{
+		Object.getOwnPropertyNames(proto)
+			.filter(p => p != 'constructor')
+			.forEach(p => props.push({
+				name: p,
+				descriptor: Object.getOwnPropertyDescriptor(proto, p)
+			}));
+		proto = Object.getPrototypeOf(proto);
+	}
+	return props
+}
+
+function getAllStaticProps(cls) {
+	const props = []
+	let current = cls;
+	while (current && current !== Function.prototype)
+	{
+		let properties = Object.getOwnPropertyNames(current)
+		properties = properties.filter(p => !['length', 'name', 'prototype'].includes(p))
+		properties.forEach(p => props.push({
+			name: p,
+			descriptor: Object.getOwnPropertyDescriptor(current, p)
+		}));
+		current = Object.getPrototypeOf(current);
+	}
+	return props;
+}
+
+function getAllNonStaticProps(cls) {
+	// TODO: can we extend cls with a class with a construction that doesnt call super() to get instance properties without actually "instantiating" the class?
+	const instance = new cls();
+			// tempted not to do this, as it requires instantiating the class, but it is the only way I can think of to get instance properties that are not declared in the constructor
+	return Object.getOwnPropertyNames(instance).map(p => ({ name: p, descriptor: Object.getOwnPropertyDescriptor(instance, p) }))
+		.concat(getAllProtoProps(instance))
+}
+
+
+export function Mixins(bases) {
+	class Bases {
+		constructor() {
+			bases.forEach(base => Object.assign(this, new base()));
+		}
+	}
+	bases.forEach(base => {
+		let properties = getAllNonStaticProps(base);
+		properties.forEach(prop => {
+			Object.defineProperty(Bases.prototype, prop.name, prop.descriptor)
+		})
+
+		properties = getAllStaticProps(base);
+		properties.forEach(prop => {
+			Object.defineProperty(Bases, prop.name, prop.descriptor)
+		})
+	})
+	return Bases;
 }

package/tests/automapper.test.js

@@ -0,0 +1,150 @@
+import test from "node:test";
+import assert from "node:assert";
+import { autoMapFromFirestore, autoMapToFirestore, registerClassForPersistence, registerMapping } from "../src/automapper.js";
+import { Mixins } from "../src/utils.js";
+
+class AggregateRoot
+{
+	_uncomittedEvents = []
+
+	get isDirty() {
+		return this._uncomittedEvents.length > 0;
+	}
+
+	
+	/**
+	 * Applys a new domain event to this object
+	 * @param {string} eventType The type of the event
+	 * @param {object} data The event data
+	 */
+	apply(eventType, data) 
+	{
+		data = data || {}
+		if(!data.aggregateRootId)
+			data.aggregateRootId = this.id;
+
+
+		this._uncomittedEvents.push({
+			type: eventType,
+			sequence: ++this._lastEventSequence,
+			data
+		});
+		
+		this._applyEvent(eventType, data);
+	}
+
+	_applyEvent(eventType, data)
+	{
+		let handlerName = 'on' + eventType.substr(0, 1).toUpperCase() + eventType.substr(1);
+		let fn = this[handlerName];
+		if(fn)
+			fn.call(this, data);
+	}
+}
+
+class Foo {
+    b = 2
+    bar = new Foo.Bar();
+	
+	static Bar = class {
+        a = 1
+		
+		barzy() {
+			return "barzy"
+		}
+    }
+
+	foozzy() {
+		return "foozzy"
+	}
+}
+
+class Baz extends Foo {
+    static c = 3
+	d = 4
+
+	bazzy() {
+		return "bazzy"
+	}
+}
+
+class Academy extends Mixins([Baz, AggregateRoot])
+{
+	static Test = class {}
+
+	uniqueList = new Set();
+
+	changeName(name)
+	{
+		this.apply('academyNameChanged', {
+			name
+		})
+	}
+
+	onAcademyNameChanged(event)
+	{
+		this.name = event.name;
+	}
+
+	constructor()
+	{
+		super();
+		this.bar = new Baz.Bar();
+		this.uniqueList.add('a')
+		this.uniqueList.add('b')
+		this.uniqueList.add('b')
+	}
+
+}
+
+test('test', t => {
+	let a = new Academy();
+
+	assert.equal(a.isDirty, false)
+
+	a.changeName('name');
+
+	assert.equal(a.isDirty, true)
+
+	assert.equal(a.name, 'name')
+})
+
+
+test('automapping', t => {
+	registerClassForPersistence(Academy);
+
+	registerMapping((key, value) => {
+		if(value instanceof Set)
+			return Array.from(value)
+		return undefined;
+	}, (key, value, dest) => {
+		if(dest[key] instanceof Set)
+			return new Set(value);
+		return undefined;
+	})
+
+
+	let a = new Academy();
+	let mapped = autoMapToFirestore(a);
+	let unmapped = autoMapFromFirestore(mapped);
+
+	assert.equal(a.d, 4)
+	assert.equal(mapped.d, 4)
+	assert.equal(unmapped.d, 4)
+
+	assert.equal(a.bar.a, 1)
+	assert.equal(mapped.bar.a, 1)
+	assert.equal(unmapped.bar.a, 1)
+
+	assert.equal(a.bar.barzy(), "barzy")
+	assert.equal(unmapped.bar.barzy(), "barzy");
+
+	assert.equal(a.foozzy(), "foozzy")
+	assert.equal(unmapped.foozzy(), "foozzy")
+
+	assert.equal(a.bazzy(), "bazzy")
+	assert.equal(unmapped.bazzy(), "bazzy")
+
+	assert(a.uniqueList instanceof Set)
+	assert.equal(unmapped.uniqueList.size, 2)
+})

package/tests/mixins.test.js

@@ -0,0 +1,114 @@
+import test, { beforeEach } from "node:test";
+import assert from "node:assert";
+import { Mixins } from "../src/utils.js";
+
+class Sequencer
+{
+	static sequence = [];
+
+	static reset()
+	{
+		this.sequence = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20];
+	}
+
+	static next()
+	{
+		return this.sequence.shift();
+	}
+}
+
+Sequencer.reset();
+
+class Foo {
+    a = 1
+
+	static staticA = 111
+
+	foo(){}
+
+	constructor() {
+		this.aa = Sequencer.next()
+	}
+}
+
+class Bar extends Foo {
+	b = 2
+	
+	static staticB = 222
+
+	bar(){}
+
+	constructor() {
+		super()
+		this.bb = Sequencer.next()
+	}
+}
+
+class Qux {
+	qux(){}
+
+	constructor() {
+		this.dd = Sequencer.next()
+	}
+}
+
+class Baz extends Mixins([Bar, Qux]) {
+	c = 3
+
+	static staticC = 333
+
+	baz(){}
+
+	constructor() {
+		super()
+		this.cc = Sequencer.next()
+		
+		// access own and inherited properties, plus own and inherited static properties
+		this.ee = this.c + this.b + this.a + Baz.staticC + Baz.staticB + Baz.staticA;
+	}
+}
+
+beforeEach(()=> {
+    Sequencer.reset();
+});
+
+test('instance properties', t => {
+	let baz = new Baz()
+
+	assert.equal(baz.a, 1)
+	assert.equal(baz.b, 2)
+	assert.equal(baz.c, 3)
+})
+
+test('prototype methods', t => {
+	let baz = new Baz()
+
+	assert.equal(typeof baz.foo, 'function')
+	assert.equal(typeof baz.bar, 'function')
+	assert.equal(typeof baz.baz, 'function')
+	assert.equal(typeof baz.qux, 'function')
+})
+
+test('constructors', t => {
+	let baz = new Baz()
+
+	assert.equal(baz.aa, 0)
+	assert.equal(baz.bb, 1)
+	assert.equal(baz.dd, 2)
+	assert.equal(baz.cc, 3)
+
+	let baz2 = new Baz()
+
+	assert.equal(baz2.aa, 4)
+	assert.equal(baz2.bb, 5)
+	assert.equal(baz2.dd, 6)
+	assert.equal(baz2.cc, 7)
+
+	assert.equal(baz.ee, 1 + 2 + 3 + 111 + 222 + 333)
+})
+
+test('static properties', t => {
+	assert.equal(Baz.staticA, 111)
+	assert.equal(Baz.staticB, 222)
+	assert.equal(Baz.staticC, 333)
+})