Breaking changes (#28)

* first pass at refactor

* LivePlugin refactor and tests

* Runtime initial changes

* spec updates round 1

* more fixups.

* fixed test warning

* fixed warning

* remove ds_store

* Updated tests

* fix syntax error

* cleanup

Author: bsneed

.gitignore

@@ -99,3 +99,4 @@ Examples/BasicExample/.DS_Store
 Sources/.DS_Store
 
 Sources/AnalyticsLive/.DS_Store
+.DS_Store

Package.resolved

@@ -1,4 +1,4 @@
-// swift-tools-version: 5.7
+// swift-tools-version: 5.9
 // The swift-tools-version declares the minimum version of Swift required to build this package.
 
 import PackageDescription
@@ -18,7 +18,7 @@ let package = Package(
             targets: ["AnalyticsLive"])
     ],
     dependencies: [
-        .package(url: "https://github.com/segmentio/analytics-swift.git", from: "1.7.2"),
+        .package(url: "https://github.com/segmentio/analytics-swift.git", from: "1.8.0"),
         .package(url: "https://github.com/segmentio/substrata-swift.git", from: "2.0.11"),
         //.package(path: "../substrata-swift")
     ],
@@ -37,9 +37,13 @@ let package = Package(
             ],
             resources: [
                 .copy("TestHelpers/filterSettings.json"),
+                .copy("TestHelpers/badSettings.json"),
                 .copy("TestHelpers/testbundle.js"),
                 .copy("TestHelpers/addliveplugin.js"),
                 .copy("TestHelpers/MyEdgeFunctions.js"),
+                .copy("TestHelpers/badtest.js"),
+                .copy("TestHelpers/runtimeBundle.js"),
+                .copy("TestHelpers/runtimeBundleNoProcess.js")
             ]),
     ]
 )

Package.swift

@@ -1,6 +1,6 @@
 //
 //  File.swift
-//  
+//
 //
 //  Created by Brandon Sneed on 5/5/22.
 //
@@ -14,8 +14,6 @@ public class AnalyticsJS: JSExport {
 
     internal weak var analytics: Analytics?
 
-    internal var addedPlugins = [(String?, LivePlugin)]()
-    
     internal lazy var currentLivePluginVersion: String? = {
         return LivePlugins.currentLivePluginVersion()
     }()
@@ -36,60 +34,95 @@ public class AnalyticsJS: JSExport {
         Self.existingInstances.removeAll(where: { $0 === self.analytics })
     }
 
+    
     static func insertOrigin(event: RawEvent?, data: [String: Any]) -> RawEvent? {
         guard var working = event else { return event }
-        if let newContext = try? working.context?.add(value: data, forKey: "__eventOrigin") {
+        if let newContext = try? working.context?.add(
+            value: data,
+            forKey: "__eventOrigin"
+        ) {
             working.context = newContext
         }
         return working
     }
 
     internal func originMarkerEnrichment(event: RawEvent?) -> RawEvent? {
         return Self.insertOrigin(event: event, data: [
-            "type": "signals",
+            "type": "js",
             "version": currentLivePluginVersion ?? ""
         ])
     }
 
+    private func contextEnrichment(with context: [String: Any]?) -> EnrichmentClosure {
+        return { event in
+            guard var working = event, let context = context else {
+                return event
+            }
+            
+            // Get existing context as dictionary and merge with new context
+            var mergedContext = working.context?.dictionaryValue ?? [:]
+            mergedContext.merge(context) { _, new in new }
+            
+            do {
+                working.context = try JSON(mergedContext)
+            } catch {
+                // If JSON creation fails, return original event
+                return event
+            }
+            return working
+        }
+    }
+    
+    private func enrichments(with context: [String: Any]?) -> [EnrichmentClosure] {
+        var enrichments = [originMarkerEnrichment]
+        if let context = context {
+            enrichments.append(contextEnrichment(with: context))
+        }
+        return enrichments
+    }
+    
     internal func setupExports() {
         exportProperty(named: "traits") { [weak self] in
-            guard let self else { return nil }
-            let traits: [String: Any]? = analytics?.traits()
+            guard let self, let analytics = self.analytics else { return nil }
+            let traits: [String: Any]? = analytics.traits()
             return traits as? JSConvertible
         }
 
         exportProperty(named: "userId") { [weak self] in
-            guard let self else { return nil }
-            return analytics?.userId
+            return self?.analytics?.userId
         }
 
         exportProperty(named: "anonymousId") { [weak self] in
-            guard let self else { return nil }
-            return analytics?.anonymousId
+            return self?.analytics?.anonymousId
         }
 
         exportMethod(named: "track") { [weak self] in self?.track(args: $0) }
-        exportMethod(named: "identify") { [weak self] in self?.identify(args: $0) }
+        exportMethod(named: "identify") {
+            [weak self] in self?.identify(args: $0)
+        }
         exportMethod(named: "screen") { [weak self] in self?.screen(args: $0) }
         exportMethod(named: "group") { [weak self] in self?.group(args: $0) }
-        exportMethod(named: "alias") { [weak self] in self?.alias(args: $0) }
         exportMethod(named: "add") { [weak self] in self?.add(args: $0) }
         exportMethod(named: "flush") { [weak self] in self?.flush(args: $0) }
         exportMethod(named: "reset") { [weak self] in self?.reset(args: $0) }
-        exportMethod(named: "removeLivePlugins") { [weak self] in self?.removeLivePlugins(args: $0) }
     }
 
     public override func construct(args: [JSConvertible?]) {
         if let writeKey = args.typed(as: String.self, index: 0) {
-            let existing = Self.existingInstances.first(where: { $0.writeKey == writeKey })
+            let existing = Self.existingInstances.first(
+                where: { $0.writeKey == writeKey
+                })
             if let existing {
                 self.analytics = existing
                 return
             } else {
                 // we do some work on user-created instances to avoid multiple instances of the same write key
                 // by just attaching whatever existing instance that might exist with that write key.
-                let createdAnalytics = Analytics(configuration: Configuration(writeKey: writeKey)
-                    .trackApplicationLifecycleEvents(false)
+                let createdAnalytics = Analytics(
+                    configuration: Configuration(
+                        writeKey: writeKey
+                    )
+                    .setTrackedApplicationLifecycleEvents(.none)
                 )
                 Self.existingInstances.append(createdAnalytics)
                 self.analytics = createdAnalytics
@@ -99,113 +132,109 @@ public class AnalyticsJS: JSExport {
 
     public func track(args: [JSConvertible?]) -> JSConvertible? {
         guard let analytics else { return nil }
-        guard let name = args.typed(as: String.self, index: 0) else { return nil }
-        let properties = args.typed(as: Dictionary.self, index: 1)
-        
-        let addEventOrigin: EnrichmentClosure = { [weak self] event in
-            return Self.insertOrigin(event: event, data: [
-                "type": "signals",
-                "version": self?.currentLivePluginVersion ?? ""
-            ])
+        guard let name = args.typed(as: String.self, index: 0) else {
+            return nil
         }
+        let properties = args.typed(as: Dictionary.self, index: 1)
+        let context = args.typed(as: Dictionary.self, index: 2)
 
-        analytics.track(name: name, properties: properties, enrichments: [addEventOrigin])
+        analytics
+            .track(
+                name: name,
+                properties: properties,
+                enrichments: enrichments(with: context)
+            )
         return nil
     }
 
     public func identify(args: [JSConvertible?]) -> JSConvertible? {
         guard let analytics else { return nil }
-        guard let userId = args.typed(as: String.self, index: 0) else { return nil }
+        guard let userId = args.typed(as: String.self, index: 0) else {
+            return nil
+        }
         let traits = args.typed(as: Dictionary.self, index: 1)
-        analytics.identify(userId: userId, traits: traits, enrichments: [originMarkerEnrichment])
+        let context = args.typed(as: Dictionary.self, index: 2)
+        analytics
+            .identify(
+                userId: userId,
+                traits: traits,
+                enrichments: enrichments(with: context)
+            )
         return nil
     }
 
     public func screen(args: [JSConvertible?]) -> JSConvertible? {
         guard let analytics else { return nil }
-        guard let title = args.typed(as: String.self, index: 0) else { return nil }
+        guard let title = args.typed(as: String.self, index: 0) else {
+            return nil
+        }
         let category = args.typed(as: String.self, index: 1)
         let properties = args.typed(as: Dictionary.self, index: 2)
-        analytics.screen(title: title, category: category, properties: properties, enrichments: [originMarkerEnrichment])
+        let context = args.typed(as: Dictionary.self, index: 3)
+        analytics
+            .screen(
+                title: title,
+                category: category,
+                properties: properties,
+                enrichments: enrichments(with: context)
+            )
         return nil
+        
     }
 
     public func group(args: [JSConvertible?]) -> JSConvertible? {
         guard let analytics else { return nil }
-        guard let groupId = args.typed(as: String.self, index: 0) else { return nil }
+        guard let groupId = args.typed(as: String.self, index: 0) else {
+            return nil
+        }
         let traits = args.typed(as: Dictionary.self, index: 1)
-        analytics.group(groupId: groupId, traits: traits, enrichments: [originMarkerEnrichment])
-        return nil
-    }
-    
-    public func alias(args: [JSConvertible?]) -> JSConvertible? {
-        guard let analytics else { return nil }
-        guard let newId = args.typed(as: String.self, index: 0) else { return nil }
-        analytics.alias(newId: newId, enrichments: [originMarkerEnrichment])
+        let context = args.typed(as: Dictionary.self, index: 2)
+        analytics
+            .group(
+                groupId: groupId,
+                traits: traits,
+                enrichments: enrichments(with: context)
+            )
         return nil
+        
     }
 
     public func flush(args: [JSConvertible?]) -> JSConvertible? {
         guard let analytics else { return nil }
         analytics.flush()
         return nil
+    
     }
 
     public func reset(args: [JSConvertible?]) -> JSConvertible? {
         guard let analytics else { return nil }
         analytics.reset()
         return nil
+        
     }
 
     public func add(args: [JSConvertible?]) -> JSConvertible? {
-        var result = false
-        
-        guard let analytics else { return result }
-        guard let plugin = args.typed(as: JSClass.self, index: 0) else { return result }
+        guard let analytics else { return nil }
+        guard let plugin = args.typed(as: JSClass.self, index: 0) else {
+            return false
+        }
 
         let type = plugin["type"]?.typed(as: Int.self)
         let destination = plugin["destination"]?.typed(as: String.self)
 
-        guard let type = type else { return result }
+        guard let type = type else { return false }
+        guard let pluginType = PluginType(rawValue: type) else { return false }
 
-        guard let pluginType = PluginType(rawValue: type) else { return result }
         let edgeFn = LivePlugin(jsPlugin: plugin, type: pluginType)
 
         if let dest = destination {
             // we have a destination specified, so add it there
-            if let d = analytics.find(key: dest) {
-                //DispatchQueue.main.async {
-                    _ = d.add(plugin: edgeFn)
-                //}
-                result = true
-                self.addedPlugins.append((dest, edgeFn))
-            }
+            guard let d = analytics.find(key: dest) else { return false }
+            _ = d.add(plugin: edgeFn)
+            return true
         } else {
-            //DispatchQueue.main.async {
-                _ = analytics.add(plugin: edgeFn)
-            //}
-            result = true
-            self.addedPlugins.append((nil, edgeFn))
+            _ = analytics.add(plugin: edgeFn)
+            return true
         }
-        return result
-    }
-    
-    public func removeLivePlugins(args: [JSConvertible?]) -> JSConvertible? {
-        guard let analytics else { return nil }
-        
-        for tuple in self.addedPlugins {
-            let (dest, p) = tuple
-            if let dst = dest {
-                // Remove from destination
-                if let d = analytics.find(key: dst) {
-                    d.remove(plugin: p)
-                }
-            } else {
-                // Remove from main timeline
-                analytics.remove(plugin: p)
-            }
-        }
-        self.addedPlugins.removeAll()
-        return nil
     }
 }

Sources/AnalyticsLive/LivePlugins/AnalyticsJS.swift

@@ -11,7 +11,7 @@ internal class Bundler {
     static var sessionConfig = URLSessionConfiguration.default
 
     class func getLocalBundleFolderURL() -> URL {
-        let paths = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)
+        let paths = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask)
         var result = paths[0]
         result.appendPathComponent("segmentJSBundles")
         if let identifier = Bundle.main.bundleIdentifier {

Sources/AnalyticsLive/LivePlugins/Bundler.swift

@@ -23,7 +23,7 @@ public struct EmbeddedJS {
     public static let edgeFnBaseSetupScript = """
     class LivePlugin {
         constructor(type, destination) {
-            console.log("js: LivePlugin.constructor() called");
+            //console.log("js: LivePlugin.constructor() called");
             this._type = type;
             this._destination = destination;
         }
@@ -39,7 +39,7 @@ public struct EmbeddedJS {
         update(settings, type) { }
 
         execute(event) {
-            console.log("js: LivePlugin.execute() called");
+            //console.log("js: LivePlugin.execute() called");
             var result = event;
             switch(event.type) {
                 case "identify":
@@ -66,7 +66,7 @@ public struct EmbeddedJS {
         }
     
         track(event) {
-            console.log("js: Super.track() called");
+            //console.log("js: Super.track() called");
             return event;
         }
     
@@ -79,7 +79,7 @@ public struct EmbeddedJS {
         }
         
         screen(event) {
-            console.log("js: Super.screen() called");
+            //console.log("js: Super.screen() called");
             return event;
         }