Skip to content

Commit

Permalink
refactor(dbx-analytics): added prefixes to all analytics related classes
Browse files Browse the repository at this point in the history 
BREAKING CHANGE: Added dbx prefix to all analytics items to keep consistency
  • Loading branch information
@dereekb
dereekb committed Mar 4, 2022
1 parent b6fa656 commit 5db960f
Show file tree
Hide file tree
Showing 12 changed files with 145 additions and 144 deletions.
12 changes: 6 additions & 6 deletions packages/dbx-analytics/src/lib/action/analytics.action.directive.ts
View file
Original file line number Diff line number Diff line change
Expand Up @@ -3,7 +3,7 @@ import { switchMap, tap, shareReplay } from 'rxjs/operators';
import { Host, Directive, Input, OnInit, OnDestroy } from '@angular/core';
import { BehaviorSubject, merge, Observable, of } from 'rxjs';
import { ActionContextStoreSourceInstance, AbstractSubscriptionDirective } from '@dereekb/dbx-core';
import { AnalyticsService } from '../analytics/analytics.service';
import { DbxAnalyticsService } from '../analytics/analytics.service';
import { Maybe, ReadableError } from '@dereekb/util';

export enum DbxActionAnalyticsTriggerType {
Expand All @@ -14,10 +14,10 @@ export enum DbxActionAnalyticsTriggerType {
}

export interface DbxActionAnalyticsConfig<T = any, O = any> {
onTriggered: (service: AnalyticsService) => void;
onReady: (service: AnalyticsService, value: T) => void;
onSuccess: (service: AnalyticsService, value: Maybe<O>) => void;
onError: (service: AnalyticsService, error: Maybe<ReadableError>) => void;
onTriggered: (service: DbxAnalyticsService) => void;
onReady: (service: DbxAnalyticsService, value: T) => void;
onSuccess: (service: DbxAnalyticsService, value: Maybe<O>) => void;
onError: (service: DbxAnalyticsService, error: Maybe<ReadableError>) => void;
}

/**
Expand All @@ -42,7 +42,7 @@ export class DbxActionAnalyticsDirective<T> extends AbstractSubscriptionDirectiv

constructor(
@Host() readonly source: ActionContextStoreSourceInstance,
readonly analyticsService: AnalyticsService
readonly analyticsService: DbxAnalyticsService
) {
super();
}
Expand Down
2 changes: 1 addition & 1 deletion packages/dbx-analytics/src/lib/action/analytics.action.module.ts
View file
Original file line number Diff line number Diff line change
Expand Up @@ -9,4 +9,4 @@ import { DbxActionAnalyticsDirective } from './analytics.action.directive';
DbxActionAnalyticsDirective
]
})
export class AnalyticsActionModule { }
export class DbxAnalyticsActionModule { }
4 changes: 2 additions & 2 deletions packages/dbx-analytics/src/lib/analytics/analytics.module.ts
View file
Original file line number Diff line number Diff line change
@@ -1,5 +1,5 @@
import { NgModule, ModuleWithProviders, Provider } from '@angular/core';
import { AnalyticsService } from './analytics.service';
import { DbxAnalyticsService } from './analytics.service';


export interface DbxAnalyticsModuleOptions {
Expand All @@ -21,7 +21,7 @@ export class DbxAnalyticsModule {
// Configuration
options.analyticsConfigurationProvider,
// Service
AnalyticsService
DbxAnalyticsService
]
};
}
Expand Down
26 changes: 13 additions & 13 deletions packages/dbx-analytics/src/lib/analytics/analytics.service.spec.ts
View file
Original file line number Diff line number Diff line change
@@ -1,47 +1,47 @@
import {
AnalyticsService, AnalyticsServiceConfiguration,
AnalyticsUserSource, AbstractAnalyticsServiceListener
DbxAnalyticsService, DbxAnalyticsServiceConfiguration,
DbxAnalyticsUserSource, AbstractDbxAnalyticsServiceListener
} from './analytics.service';
import { BehaviorSubject, Subject, Subscription } from 'rxjs';
import { AnalyticsUser } from './analytics';
import { AnalyticsStreamEvent, AnalyticsStreamEventType } from './analytics.stream';
import { DbxAnalyticsUser } from './analytics';
import { DbxAnalyticsStreamEvent, DbxAnalyticsStreamEventType } from './analytics.stream';

class TestAnalyticsServiceListener extends AbstractAnalyticsServiceListener {
class TestAnalyticsServiceListener extends AbstractDbxAnalyticsServiceListener {

readonly events = new Subject<AnalyticsStreamEvent>();
readonly events = new Subject<DbxAnalyticsStreamEvent>();

protected _initializeServiceSubscription(): false | Subscription {
return this.analyticsEvents$.subscribe((event) => this.events.next(event));
}

}

describe('Analytics Service', () => {
describe('DbxAnalyticsService', () => {

const userStream = new BehaviorSubject<AnalyticsUser>({ user: '0' });
const userStream = new BehaviorSubject<DbxAnalyticsUser>({ user: '0' });

const testListener: TestAnalyticsServiceListener = new TestAnalyticsServiceListener();

const testUserSource: AnalyticsUserSource = {
const testUserSource: DbxAnalyticsUserSource = {
analyticsUser$: userStream
};

let analyticsService: AnalyticsService;
let analyticsService: DbxAnalyticsService;

beforeEach(() => {
const configuration: AnalyticsServiceConfiguration = {
const configuration: DbxAnalyticsServiceConfiguration = {
listeners: [testListener],
isProduction: true,
userSource: testUserSource
};

analyticsService = new AnalyticsService(configuration);
analyticsService = new DbxAnalyticsService(configuration);
});

it('#sendPageView() should send a page view event', (done) => {

testListener.events.subscribe((event) => {
expect(event.type).toBe(AnalyticsStreamEventType.PageView);
expect(event.type).toBe(DbxAnalyticsStreamEventType.PageView);
done();
});

Expand Down
114 changes: 57 additions & 57 deletions packages/dbx-analytics/src/lib/analytics/analytics.service.ts
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,45 +2,45 @@ import { Observable, Subject, BehaviorSubject, of, Subscription } from 'rxjs';
import { filter, first, shareReplay, switchMap } from 'rxjs/operators';
import { Inject, Injectable, Optional } from '@angular/core';
import { SubscriptionObject, filterMaybe } from '@dereekb/rxjs';
import { AnalyticsEvent, AnalyticsEventData, AnalyticsEventName, AnalyticsUser, NewUserAnalyticsEventData, UserAnalyticsEvent } from './analytics';
import { AnalyticsStreamEvent, AnalyticsStreamEventType } from './analytics.stream';
import { DbxAnalyticsEvent, DbxAnalyticsEventData, DbxAnalyticsEventName, DbxAnalyticsUser, NewUserAnalyticsEventData, DbxUserAnalyticsEvent } from './analytics';
import { DbxAnalyticsStreamEvent, DbxAnalyticsStreamEventType } from './analytics.stream';
import { Maybe, Destroyable } from '@dereekb/util';

export abstract class AnalyticsEventEmitterService {
abstract sendNewUserEvent(user: AnalyticsUser, data: NewUserAnalyticsEventData): void;
abstract sendUserLoginEvent(user: AnalyticsUser, data?: AnalyticsEventData): void;
abstract sendUserLogoutEvent(data?: AnalyticsEventData): void;
abstract sendUserPropertiesEvent(user: AnalyticsUser, data?: AnalyticsEventData): void;
abstract sendEventData(name: AnalyticsEventName, data?: AnalyticsEventData): void;
abstract sendEvent(event: AnalyticsEvent): void;
export abstract class DbxAnalyticsEventEmitterService {
abstract sendNewUserEvent(user: DbxAnalyticsUser, data: NewUserAnalyticsEventData): void;
abstract sendUserLoginEvent(user: DbxAnalyticsUser, data?: DbxAnalyticsEventData): void;
abstract sendUserLogoutEvent(data?: DbxAnalyticsEventData): void;
abstract sendUserPropertiesEvent(user: DbxAnalyticsUser, data?: DbxAnalyticsEventData): void;
abstract sendEventData(name: DbxAnalyticsEventName, data?: DbxAnalyticsEventData): void;
abstract sendEvent(event: DbxAnalyticsEvent): void;
abstract sendPageView(page?: string): void;
}

export abstract class AnalyticsEventStreamService {
abstract readonly events$: Observable<AnalyticsStreamEvent>;
export abstract class DbxAnalyticsEventStreamService {
abstract readonly events$: Observable<DbxAnalyticsStreamEvent>;
}

export abstract class AnalyticsUserSource {
abstract readonly analyticsUser$: Observable<Maybe<AnalyticsUser>>;
export abstract class DbxAnalyticsUserSource {
abstract readonly analyticsUser$: Observable<Maybe<DbxAnalyticsUser>>;
}

export abstract class AnalyticsServiceListener {
public abstract listenToService(service: AnalyticsService): void;
export abstract class DbxAnalyticsServiceListener {
public abstract listenToService(service: DbxAnalyticsService): void;
}

/**
* Abstract AnalyticsServiceListener implementation.
*/
export abstract class AbstractAnalyticsServiceListener implements AnalyticsServiceListener, Destroyable {
export abstract class AbstractDbxAnalyticsServiceListener implements DbxAnalyticsServiceListener, Destroyable {

private _sub = new SubscriptionObject();
protected _analytics = new BehaviorSubject<Maybe<AnalyticsService>>(undefined);
protected _analytics = new BehaviorSubject<Maybe<DbxAnalyticsService>>(undefined);

readonly analytics$ = this._analytics.pipe(filterMaybe(), shareReplay(1));
readonly analyticsEvents$ = this.analytics$.pipe(switchMap(x => x.events$), shareReplay(1));

// MARK: AnalyticsServiceListener
listenToService(service: AnalyticsService): void {
listenToService(service: DbxAnalyticsService): void {
this._analytics.next(service);
const sub = this._initializeServiceSubscription();

Expand All @@ -59,18 +59,18 @@ export abstract class AbstractAnalyticsServiceListener implements AnalyticsServi

}

export abstract class AnalyticsServiceConfiguration {
listeners: AnalyticsServiceListener[] = [];
export abstract class DbxAnalyticsServiceConfiguration {
listeners: DbxAnalyticsServiceListener[] = [];
isProduction?: boolean;
logEvents?: boolean;
userSource?: AnalyticsUserSource;
userSource?: DbxAnalyticsUserSource;
}

export class AnalyticsStreamEventAnalyticsEventWrapper implements AnalyticsStreamEvent {
export class DbxAnalyticsStreamEventAnalyticsEventWrapper implements DbxAnalyticsStreamEvent {

constructor(public readonly event: UserAnalyticsEvent, public readonly type: AnalyticsStreamEventType = AnalyticsStreamEventType.Event) { }
constructor(public readonly event: DbxUserAnalyticsEvent, public readonly type: DbxAnalyticsStreamEventType = DbxAnalyticsStreamEventType.Event) { }

public get user(): Maybe<AnalyticsUser> {
public get user(): Maybe<DbxAnalyticsUser> {
return this.event.user;
}

Expand All @@ -84,7 +84,7 @@ export class AnalyticsStreamEventAnalyticsEventWrapper implements AnalyticsStrea
* Primary analytics service that emits analytics events that components can listen to.
*/
@Injectable()
export class AnalyticsService implements AnalyticsEventStreamService, AnalyticsEventEmitterService, Destroyable {
export class DbxAnalyticsService implements DbxAnalyticsEventStreamService, DbxAnalyticsEventEmitterService, Destroyable {

// TODO: Make these configurable.

Expand All @@ -93,18 +93,18 @@ export class AnalyticsService implements AnalyticsEventStreamService, AnalyticsE
static readonly USER_LOGOUT_EVENT_NAME = 'User Logout';
static readonly USER_PROPERTIES_EVENT_NAME = 'User Properties';

private _subject = new Subject<AnalyticsStreamEvent>();
private _subject = new Subject<DbxAnalyticsStreamEvent>();
readonly events$ = this._subject.asObservable();

private _userSource = new BehaviorSubject<Maybe<AnalyticsUserSource>>(undefined);
private _userSource = new BehaviorSubject<Maybe<DbxAnalyticsUserSource>>(undefined);
readonly user$ = this._userSource.pipe(switchMap(x => (x) ? x.analyticsUser$ : of(undefined)), shareReplay(1));

private _userSourceSub = new SubscriptionObject();
private _loggerSub = new SubscriptionObject();

constructor(
private _config: AnalyticsServiceConfiguration,
@Optional() @Inject(AnalyticsUserSource) userSource: Maybe<AnalyticsUserSource> = _config.userSource
private _config: DbxAnalyticsServiceConfiguration,
@Optional() @Inject(DbxAnalyticsUserSource) userSource: Maybe<DbxAnalyticsUserSource> = _config.userSource
) {
this._init();

Expand All @@ -117,8 +117,8 @@ export class AnalyticsService implements AnalyticsEventStreamService, AnalyticsE
/**
* Sets the user directly.
*/
public setUser(user: Maybe<AnalyticsUser>): void {
let source: Maybe<AnalyticsUserSource>;
public setUser(user: Maybe<DbxAnalyticsUser>): void {
let source: Maybe<DbxAnalyticsUserSource>;

if (user) {
source = { analyticsUser$: of(user) };
Expand All @@ -127,79 +127,79 @@ export class AnalyticsService implements AnalyticsEventStreamService, AnalyticsE
this._userSource.next(source);
}

public setUserSource(source: AnalyticsUserSource): void {
public setUserSource(source: DbxAnalyticsUserSource): void {
this._userSource.next(source);
}

// MARK: AnalyticsEventEmitterService
/**
* Sends an event.
*/
public sendNewUserEvent(user: AnalyticsUser, data: NewUserAnalyticsEventData): void {
public sendNewUserEvent(user: DbxAnalyticsUser, data: NewUserAnalyticsEventData): void {
this.sendNextEvent({
name: AnalyticsService.USER_REGISTRATION_EVENT_NAME,
name: DbxAnalyticsService.USER_REGISTRATION_EVENT_NAME,
data
}, AnalyticsStreamEventType.NewUserEvent, user);
}, DbxAnalyticsStreamEventType.NewUserEvent, user);
}

public sendUserLoginEvent(user: AnalyticsUser, data?: AnalyticsEventData): void {
public sendUserLoginEvent(user: DbxAnalyticsUser, data?: DbxAnalyticsEventData): void {
this.sendNextEvent({
name: AnalyticsService.USER_LOGIN_EVENT_NAME,
name: DbxAnalyticsService.USER_LOGIN_EVENT_NAME,
data
}, AnalyticsStreamEventType.UserLoginEvent, user);
}, DbxAnalyticsStreamEventType.UserLoginEvent, user);
}

public sendUserLogoutEvent(data?: AnalyticsEventData, clearUser = true): void {
public sendUserLogoutEvent(data?: DbxAnalyticsEventData, clearUser = true): void {
this.sendNextEvent({
name: AnalyticsService.USER_LOGOUT_EVENT_NAME,
name: DbxAnalyticsService.USER_LOGOUT_EVENT_NAME,
data
}, AnalyticsStreamEventType.UserLogoutEvent);
}, DbxAnalyticsStreamEventType.UserLogoutEvent);

if (clearUser) {
this.setUser(undefined);
}
}

public sendUserPropertiesEvent(user: AnalyticsUser, data?: AnalyticsEventData): void {
public sendUserPropertiesEvent(user: DbxAnalyticsUser, data?: DbxAnalyticsEventData): void {
this.sendNextEvent({
name: AnalyticsService.USER_PROPERTIES_EVENT_NAME,
name: DbxAnalyticsService.USER_PROPERTIES_EVENT_NAME,
data
}, AnalyticsStreamEventType.UserPropertiesEvent, user);
}, DbxAnalyticsStreamEventType.UserPropertiesEvent, user);
}

public sendEventData(name: AnalyticsEventName, data?: AnalyticsEventData): void {
public sendEventData(name: DbxAnalyticsEventName, data?: DbxAnalyticsEventData): void {
return this.sendEvent({
name,
data
});
}

public sendEventType(eventType: AnalyticsEventName): void {
public sendEventType(eventType: DbxAnalyticsEventName): void {
this.sendNextEvent({
name: eventType
}, AnalyticsStreamEventType.Event);
}, DbxAnalyticsStreamEventType.Event);
}

public sendEvent(event: AnalyticsEvent): void {
this.sendNextEvent(event, AnalyticsStreamEventType.Event);
public sendEvent(event: DbxAnalyticsEvent): void {
this.sendNextEvent(event, DbxAnalyticsStreamEventType.Event);
}

public sendPageView(page?: string): void {
this.sendNextEvent({
name: page
}, AnalyticsStreamEventType.PageView);
}, DbxAnalyticsStreamEventType.PageView);
}

protected sendNextEvent(event: AnalyticsEvent = {}, type: AnalyticsStreamEventType, userOverride?: AnalyticsUser): void {
protected sendNextEvent(event: DbxAnalyticsEvent = {}, type: DbxAnalyticsStreamEventType, userOverride?: DbxAnalyticsUser): void {
this.user$.pipe(first()).subscribe((analyticsUser) => {
const user: Maybe<AnalyticsUser> = (userOverride != null) ? userOverride : analyticsUser;
const analyticsEvent: UserAnalyticsEvent = { ...event, user };
const user: Maybe<DbxAnalyticsUser> = (userOverride != null) ? userOverride : analyticsUser;
const analyticsEvent: DbxUserAnalyticsEvent = { ...event, user };
this.nextEvent(analyticsEvent, type);
});
}

protected nextEvent(event: UserAnalyticsEvent, type: AnalyticsStreamEventType): void {
const wrapper = new AnalyticsStreamEventAnalyticsEventWrapper(event, type);
protected nextEvent(event: DbxUserAnalyticsEvent, type: DbxAnalyticsStreamEventType): void {
const wrapper = new DbxAnalyticsStreamEventAnalyticsEventWrapper(event, type);
this._subject.next(wrapper);
}

Expand All @@ -220,12 +220,12 @@ export class AnalyticsService implements AnalyticsEventStreamService, AnalyticsE

// Create a new subscription
this._loggerSub.subscription = this._subject.subscribe((x) => {
console.log(`AnalyticsService: Analytics Event - ${AnalyticsStreamEventType[x.type]} User: ${x.userId} Data: ${JSON.stringify(x.event)}.`);
console.log(`AnalyticsService: Analytics Event - ${DbxAnalyticsStreamEventType[x.type]} User: ${x.userId} Data: ${JSON.stringify(x.event)}.`);
});
}

this._userSourceSub.subscription = this.user$.subscribe(() => {
this.sendNextEvent({}, AnalyticsStreamEventType.UserChange);
this.sendNextEvent({}, DbxAnalyticsStreamEventType.UserChange);
});
}

Expand Down
14 changes: 7 additions & 7 deletions packages/dbx-analytics/src/lib/analytics/analytics.stream.ts
View file
Original file line number Diff line number Diff line change
@@ -1,7 +1,7 @@
import { Maybe } from "@dereekb/util";
import { AnalyticsUser, UserAnalyticsEvent, AnalyticsUserId } from "./analytics";
import { DbxAnalyticsUser, DbxUserAnalyticsEvent, DbxAnalyticsUserId } from "./analytics";

export enum AnalyticsStreamEventType {
export enum DbxAnalyticsStreamEventType {

PageView,
UserChange,
Expand All @@ -17,9 +17,9 @@ export enum AnalyticsStreamEventType {

}

export interface AnalyticsStreamEvent {
readonly type: AnalyticsStreamEventType;
readonly user?: Maybe<AnalyticsUser>;
readonly event?: UserAnalyticsEvent;
readonly userId?: AnalyticsUserId;
export interface DbxAnalyticsStreamEvent {
readonly type: DbxAnalyticsStreamEventType;
readonly user?: Maybe<DbxAnalyticsUser>;
readonly event?: DbxUserAnalyticsEvent;
readonly userId?: DbxAnalyticsUserId;
}
Loading

0 comments on commit 5db960f

Please sign in to comment.