Add model serializer and coreid login provider

src/orm/connection/event/QueryExecutedEventSerializer.ts

@@ -1,9 +1,8 @@
-import {BaseSerializer} from '../../../support/bus'
+import {BaseSerializer, ObjectSerializer} from '../../../support/bus'
 import {QueryExecutedEvent} from './QueryExecutedEvent'
 import {Awaitable, JSONState} from '../../../util'
 import {Container, Inject, Injectable} from '../../../di'
 import {DatabaseService} from '../../DatabaseService'
-import {ObjectSerializer} from '../../../support/bus/serial/decorators'
 
 export interface QueryExecutedEventSerialPayload extends JSONState {
     connectionName: string

src/orm/index.ts

@@ -7,6 +7,8 @@ export * from './builder/Builder'
 
 export * from './connection/Connection'
 export * from './connection/PostgresConnection'
+export * from './connection/event/QueryExecutedEvent'
+export * from './connection/event/QueryExecutedEventSerializer'
 
 export * from './dialect/SQLDialect'
 export * from './dialect/PostgreSQLDialect'
@@ -17,6 +19,7 @@ export * from './model/ModelBuilder'
 export * from './model/ModelResultIterable'
 export * from './model/events'
 export * from './model/Model'
+export * from './model/ModelSerializer'
 
 export * from './model/relation/RelationBuilder'
 export * from './model/relation/Relation'

src/orm/model/ModelSerializer.ts

@@ -0,0 +1,68 @@
+import {BaseSerializer, ObjectSerializer} from '../../support/bus'
+import {Model} from './Model'
+import {Awaitable, ErrorWithContext, JSONState, Maybe} from '../../util'
+import {QueryRow} from '../types'
+import {Inject, Injectable, isInstantiable} from '../../di'
+import {Canon} from '../../service/Canon'
+
+export interface ModelSerialPayload extends JSONState {
+    canonicalResolver: string,
+    primaryKey: any,
+    objectValues: QueryRow,
+}
+
+@ObjectSerializer()
+@Injectable()
+export class ModelSerializer extends BaseSerializer<Model<any>, ModelSerialPayload> {
+    @Inject()
+    protected readonly canon!: Canon
+
+    protected async decodeSerial(serial: ModelSerialPayload): Promise<Model<any>> {
+        const ModelClass = this.canon.getFromFullyQualified(serial.canonicalResolver) as typeof Model
+        if ( !ModelClass || !(ModelClass.prototype instanceof Model) || !isInstantiable<Model<any>>(ModelClass) ) {
+            throw new ErrorWithContext('Cannot decode serialized model as canonical resolver is invalid', {
+                serial,
+            })
+        }
+
+        let inst: Maybe<Model<any>> = this.make<Model<any>>(ModelClass)
+        if ( serial.primaryKey ) {
+            inst = await ModelClass.query()
+                .whereKey(serial.primaryKey)
+                .first()
+        }
+
+        if ( !inst ) {
+            throw new ErrorWithContext('Could not look up serialized model', {
+                serial,
+            })
+        }
+
+        await inst.assume(serial.objectValues)
+        return inst
+    }
+
+    protected encodeActual(actual: Model<any>): Awaitable<ModelSerialPayload> {
+        const ctor = actual.constructor as typeof Model
+        const canonicalResolver = ctor.getFullyQualifiedCanonicalResolver()
+        if ( !canonicalResolver ) {
+            throw new ErrorWithContext('Unable to serialize model: no Canonical resolver', {
+                actual,
+            })
+        }
+
+        return {
+            canonicalResolver,
+            primaryKey: actual.key(),
+            objectValues: actual.toObject(),
+        }
+    }
+
+    protected getName(): string {
+        return '@extollo/lib.ModelSerializer'
+    }
+
+    matchActual(some: Model<any>): boolean {
+        return some instanceof Model
+    }
+}