FLW-2226: Snapshots loading optimisation

FearlessUtils/Classes/Runtime/TypeRegistry.swift

@@ -56,10 +56,25 @@ public class TypeRegistry: TypeRegistryProtocol {
     private var allOverrides: Set<ConstantPath> = []
 
     private var overrides: [ConstantPath: String] = [:]
-
-    public var registeredTypes: [Node] { graph.keys.compactMap { graph[$0] } }
-    public var registeredTypeNames: Set<String> { allKeys }
-    public var registeredOverrides: Set<ConstantPath> { allOverrides }
+
+    private let json: JSON
+    private let overridesJson: [JSON]?
+    private let additionalNodes: [Node]
+
+    public lazy var registeredTypes: [Node] = {
+        resolveJsons()
+        return graph.keys.compactMap { graph[$0] }
+    }()
+
+    public lazy var registeredTypeNames: Set<String> = {
+        resolveJsons()
+        return allKeys
+    }()
+
+    public lazy var registeredOverrides: Set<ConstantPath> = {
+        resolveJsons()
+        return allOverrides
+    }()
 
     init(
         json: JSON,
@@ -70,17 +85,14 @@ public class TypeRegistry: TypeRegistryProtocol {
     ) throws {
         self.nodeFactory = nodeFactory
         self.typeResolver = typeResolver
-
-        try parse(json: json)
-        parse(overrides: overrides)
-        override(nodes: additionalNodes)
-        resolveGenerics()
-
-        allKeys = Set(graph.keys)
-        allOverrides = Set(self.overrides.keys)
+        self.json = json
+        self.overridesJson = overrides
+        self.additionalNodes = additionalNodes
     }
 
     public func node(for key: String) -> Node? {
+        resolveJsons()
+
         if let node = graph[key] {
             return node
         }
@@ -102,10 +114,24 @@ public class TypeRegistry: TypeRegistryProtocol {
     }
 
     public func override(for moduleName: String, constantName: String) -> String? {
-        overrides[.init(moduleName: moduleName, constantName: constantName)]
+        resolveJsons()
+        return overrides[.init(moduleName: moduleName, constantName: constantName)]
     }
 
     // MARK: Private
+
+    private func resolveJsons() {
+        guard graph.keys.isEmpty else {
+            return
+        }
+        parse(json: json)
+        parse(overrides: overridesJson)
+        override(nodes: additionalNodes)
+        resolveGenerics()
+
+        allKeys = Set(graph.keys)
+        allOverrides = Set(self.overrides.keys)
+    }
 
     private func override(nodes: [Node]) {
         for node in nodes {
@@ -129,18 +155,16 @@ public class TypeRegistry: TypeRegistryProtocol {
         }
     }
 
-    private func parse(json: JSON) throws {
+    private func parse(json: JSON) {
         guard let dict = json.dictValue else {
-            throw TypeRegistryError.unexpectedJson
+            return
         }
 
         let keyParser = TermParser.generic()
 
-        let refinedDict = try dict.reduce(into: [String: JSON]()) { (result, item) in
+        let refinedDict = dict.reduce(into: [String: JSON]()) { (result, item) in
             if let type = keyParser.parse(json: .stringValue(item.key))?.first?.stringValue {
                 result[type] = item.value
-            } else {
-                throw TypeRegistryError.invalidKey(item.key)
             }
         }
 
@@ -149,7 +173,7 @@ public class TypeRegistry: TypeRegistryProtocol {
         }
 
         for item in refinedDict {
-            if let node = try nodeFactory.buildNode(from: item.value, typeName: item.key, mediator: self) {
+            if let node = try? nodeFactory.buildNode(from: item.value, typeName: item.key, mediator: self) {
                 graph[item.key] = node
             }
         }

FearlessUtils/Classes/Runtime/TypeRegistryCatalog.swift

@@ -22,28 +22,10 @@ public class TypeRegistryCatalog: TypeRegistryCatalogProtocol {
     public let runtimeMetadataRegistry: TypeRegistryProtocol
     public let baseRegistry: TypeRegistryProtocol
     public let versionedRegistries: [UInt64: TypeRegistryProtocol]
-    public let versionedTypes: [String: [UInt64]]
-    public let versionedOverrides: [ConstantPath: [UInt64]]
     public let typeResolver: TypeResolving
-
-    public let allTypes: Set<String>
-    public let mutex = NSLock()
-    public var registryCache: [String: TypeRegistryProtocol] = [:]
-
-    public init(
-        baseRegistry: TypeRegistryProtocol,
-        versionedRegistries: [UInt64: TypeRegistryProtocol],
-        runtimeMetadataRegistry: TypeRegistryProtocol,
-        typeResolver: TypeResolving
-    ) {
-        self.baseRegistry = baseRegistry
-        self.versionedRegistries = versionedRegistries
-        self.runtimeMetadataRegistry = runtimeMetadataRegistry
-        self.typeResolver = typeResolver
-
-        let allVersions = versionedRegistries.keys.sorted()
-
-        versionedTypes = allVersions.reduce(into: [String: [UInt64]]()) { (result, item) in
+
+    public lazy var versionedTypes: [String: [UInt64]] = {
+        let versionedTypes = allVersions.reduce(into: [String: [UInt64]]()) { (result, item) in
             guard let typeRegistry = versionedRegistries[item] else { return }
 
             let typeNames = typeRegistry.registeredTypeNames.filter { !(typeRegistry.node(for: $0) is GenericNode) }
@@ -57,7 +39,11 @@ public class TypeRegistryCatalog: TypeRegistryCatalogProtocol {
             }
         }
 
-        versionedOverrides = allVersions.reduce(into: [ConstantPath: [UInt64]]()) { result, item in
+        return versionedTypes
+    }()
+
+    public lazy var versionedOverrides: [ConstantPath: [UInt64]] = {
+        let versionedOverrides = allVersions.reduce(into: [ConstantPath: [UInt64]]()) { result, item in
             guard let typeRegistry = versionedRegistries[item] else { return }
             for constantPath in typeRegistry.registeredOverrides {
                 let versions: [UInt64] = result[constantPath] ?? []
@@ -67,8 +53,29 @@ public class TypeRegistryCatalog: TypeRegistryCatalogProtocol {
                 }
             }
         }
+
+        return versionedOverrides
+    }()
+
+    public lazy var allTypes: Set<String> = {
+        Set(versionedTypes.keys)
+    }()
+
+    public let mutex = NSLock()
+    public var registryCache: [String: TypeRegistryProtocol] = [:]
+    private let allVersions: [Dictionary<UInt64, TypeRegistryProtocol>.Keys.Element]
 
-        allTypes = Set(versionedTypes.keys)
+    public init(
+        baseRegistry: TypeRegistryProtocol,
+        versionedRegistries: [UInt64: TypeRegistryProtocol],
+        runtimeMetadataRegistry: TypeRegistryProtocol,
+        typeResolver: TypeResolving
+    ) {
+        self.baseRegistry = baseRegistry
+        self.versionedRegistries = versionedRegistries
+        self.runtimeMetadataRegistry = runtimeMetadataRegistry
+        self.typeResolver = typeResolver
+        self.allVersions = versionedRegistries.keys.sorted()
     }
 
     public func node(for typeName: String, version: UInt64) -> Node? {