@mparticle/data-planning-node - npm Package Compare versions

Comparing version 0.1.1 to 1.0.0-alpha.0

package.json

 {
     "name": "@mparticle/data-planning-node",
-    "version": "0.1.1",
+    "version": "1.0.0-alpha.0",
     "description": "A Node Interface for Data Planning",
@@ -47,2 +47,3 @@ "main": "dist/mparticle-data-planning.common.js",
         "@types/jest": "^24.0.22",
+        "@types/jest-expect-message": "^1.0.1",
         "@types/mockdate": "^2.0.0",
@@ -54,2 +55,3 @@ "@types/node": "^12.12.6",
         "jest": "^24.9.0",
+        "jest-expect-message": "^1.0.2",
         "nock": "^11.7.2",
@@ -69,4 +71,4 @@ "pre-commit": "^1.2.2",
     "dependencies": {
-        "@mparticle/data-planning-models": "0.0.2-alpha.3",
-        "@mparticle/event-models": "^1.0.2",
+        "@mparticle/data-planning-models": "0.1.0-alpha.0",
+        "@mparticle/event-models": "^1.1.0-alpha.0",
         "ajv": "^6.10.2",
@@ -73,0 +75,0 @@ "axios": "^0.19.0"

src/data_planning/data_plan_event_validator.ts

 import {
     BaseEvent,
-    ScreenViewEvent,
-    CustomEvent,
-    ApplicationStateTransitionEvent,
-    CommerceEvent,
     Batch,
+    EventTypeEnum,
+    ApplicationStateTransitionEventData,
+    ScreenViewEventData,
+    CommerceEventData,
+    CustomEventData,
 } from '@mparticle/event-models';
@@ -21,5 +22,6 @@ import {
     DataPlanPointSchema,
-    ValidationErrorType,
     ValidationResultEvent,
     ValidationError,
+    ValidationResultEventData,
+    ValidationErrorTypeEnum,
 } from '@mparticle/data-planning-models';
@@ -269,3 +271,3 @@ import { JSONSchemaValidator } from '../validation/JSONSchemaValidator';
 
-        const result: ValidationResultEvent = {};
+        const result: ValidationResultEventData = {};
         const errors: ValidationError[] = [];
@@ -276,3 +278,3 @@
             const validationError: ValidationError = {
-                validation_error_type: 'unplanned',
+                validation_error_type: ValidationErrorTypeEnum.Unplanned,
                 key: 'unknown',
@@ -285,3 +287,3 @@ error_pointer: '#',
             return {
-                event_type: 'validation_results',
+                event_type: EventTypeEnum.validationResult,
                 data: result,
@@ -294,3 +296,3 @@ };
             const validationError: ValidationError = {
-                validation_error_type: 'unplanned',
+                validation_error_type: ValidationErrorTypeEnum.Unplanned,
                 key: this.getEventKey(event),
@@ -310,3 +312,3 @@ error_pointer: '#',
             return {
-                event_type: 'validation_result',
+                event_type: EventTypeEnum.validationResult,
                 data: result,
@@ -328,3 +330,3 @@ };
             return {
-                event_type: 'validation_result',
+                event_type: EventTypeEnum.validationResult,
                 data: result,
@@ -353,3 +355,3 @@ };
     validateUserAttributes(eventBatch: Batch): ValidationResultEvent {
-        const result: ValidationResultEvent = {};
+        const result: ValidationResultEventData = {};
         const point = this.dataPlanMatchLookups['user_attributes'];
@@ -363,3 +365,3 @@ const schema = point?.schema;
             const error: ValidationError = {
-                validation_error_type: ValidationErrorType.Unknown,
+                validation_error_type: ValidationErrorTypeEnum.Unknown,
                 error_pointer: '#',
@@ -371,3 +373,3 @@ actual: 'Invalid JSON Schema',
             return {
-                event_type: 'validation_result',
+                event_type: EventTypeEnum.validationResult,
                 data: {
@@ -393,3 +395,3 @@ match: result.match,
         return {
-            event_type: 'validation_result',
+            event_type: EventTypeEnum.validationResult,
             data: {
@@ -473,3 +475,3 @@ match: result.match,
     static getMatchKey(eventToMatch: BaseEvent): string | null {
-        switch (eventToMatch.event_type) {
+        switch (eventToMatch.event_type as string) {
             case MessageType.Breadcrumb:
@@ -494,22 +496,21 @@ return DataPlanMatchType.Breadcrumb;
                 // tslint:disable-next-line: max-line-length
-                const appStateTransitionEvent = eventToMatch as ApplicationStateTransitionEvent;
+                const appStateTransitionEventData = eventToMatch.data as ApplicationStateTransitionEventData;
                 return [
                     DataPlanMatchType.ApplicationStateTransition,
-                    appStateTransitionEvent.data?.application_transition_type,
+                    appStateTransitionEventData?.application_transition_type,
                 ].join(':');
             case MessageType.ScreenView:
-                const screenViewEvent = eventToMatch as ScreenViewEvent;
-                if (screenViewEvent.data) {
-                    return [
-                        DataPlanMatchType.ScreenView,
-                        '',
-                        screenViewEvent.data.screen_name,
-                    ].join(':');
-                }
-                return null;
+                // tslint:disable-next-line: max-line-length
+                const screenViewEventData = eventToMatch.data as ScreenViewEventData;
+                return [
+                    DataPlanMatchType.ScreenView,
+                    '',
+                    screenViewEventData?.screen_name,
+                ].join(':');
             case MessageType.Commerce:
-                const commerceEvent = eventToMatch as CommerceEvent;
+                // tslint:disable-next-line: max-line-length
+                const commerceEventData = eventToMatch.data as CommerceEventData;
                 const matchKey: string[] = [];
 
-                if (commerceEvent && commerceEvent.data) {
+                if (commerceEventData) {
                     const {
@@ -519,3 +520,3 @@ product_action,
                         promotion_action,
-                    } = commerceEvent.data;
+                    } = commerceEventData;
 
@@ -534,8 +535,8 @@ if (product_action) {
             case MessageType.CustomEvent:
-                const customEvent = eventToMatch as CustomEvent;
-                if (customEvent.data) {
+                const customEventData = eventToMatch.data as CustomEventData;
+                if (customEventData) {
                     return [
                         DataPlanMatchType.CustomEvent,
-                        customEvent.data.custom_event_type,
-                        customEvent.data.event_name,
+                        customEventData.custom_event_type,
+                        customEventData.event_name,
                     ].join(':');
@@ -556,11 +557,12 @@ }
         switch (eventToMatch.event_type) {
-            case MessageType.SessionStart:
+            case EventTypeEnum.sessionStart:
                 return { type: DataPlanMatchType.SessionStart };
-            case MessageType.SessionEnd:
+            case EventTypeEnum.sessionEnd:
                 return { type: DataPlanMatchType.SessionEnd };
-            case MessageType.ScreenView:
-                const screenViewEvent = eventToMatch as ScreenViewEvent;
+            case EventTypeEnum.screenView:
+                // tslint:disable-next-line: max-line-length
+                const screenViewEventData = eventToMatch.data as ScreenViewEventData;
                 let screenName = '';
-                if (screenViewEvent.data) {
-                    screenName = screenViewEvent.data.screen_name;
+                if (screenViewEventData) {
+                    screenName = screenViewEventData.screen_name;
                 }
@@ -574,9 +576,9 @@ const screenViewCriteria: ScreenViewEventCriteria = {
                 };
-            case MessageType.CustomEvent:
-                const customEvent: CustomEvent = eventToMatch as CustomEvent;
+            case EventTypeEnum.customEvent:
+                const customEventData = eventToMatch.data as CustomEventData;
                 const customEventCriteria: CustomEventCriteria = {
-                    event_name: customEvent?.data?.event_name || 'Custom Event',
+                    event_name: customEventData?.event_name || 'Custom Event',
                     // tslint:disable-next-line: max-line-length
                     custom_event_type:
-                        customEvent?.data?.custom_event_type || 'other',
+                        customEventData?.custom_event_type || 'other',
                 };
@@ -588,16 +590,17 @@
                 };
-            case MessageType.CrashReport:
+            case EventTypeEnum.crashReport:
                 return { type: DataPlanMatchType.CrashReport };
-            case MessageType.OptOut:
+            case EventTypeEnum.optOut:
                 return { type: DataPlanMatchType.OptOut };
-            case MessageType.FirstRun:
+            case EventTypeEnum.firstRun:
                 return { type: DataPlanMatchType.FirstRun };
-            case MessageType.ApplicationStateTransition:
+            case EventTypeEnum.applicationStateTransition:
                 // tslint:disable-next-line: max-line-length
-                const appStateTransitionEvent = eventToMatch as ApplicationStateTransitionEvent;
+                const appStateTransitionEventData = eventToMatch.data as ApplicationStateTransitionEventData;
                 // tslint:disable-next-line: max-line-length
                 const appStateTransitionCriteria: ApplicationStateTransitionEventCriteria = {
                     application_transition_type:
-                        appStateTransitionEvent?.data
-                            ?.application_transition_type || 'unknown',
+                        // tslint:disable-next-line: max-line-length
+                        appStateTransitionEventData?.application_transition_type ||
+                        'unknown',
                 };
@@ -608,14 +611,15 @@ return {
                 };
-            case MessageType.NetworkPerformance:
+            case EventTypeEnum.networkPerformance:
                 return { type: DataPlanMatchType.NetworkPerformance };
-            case MessageType.Breadcrumb:
+            case EventTypeEnum.breadcrumb:
                 return { type: DataPlanMatchType.Breadcrumb };
-            case MessageType.Uninstall:
+            case EventTypeEnum.uninstall:
                 return { type: DataPlanMatchType.Uninstall };
-            case MessageType.Commerce:
-                const commerceEvent = eventToMatch as CommerceEvent;
-                if (commerceEvent.data) {
-                    if (commerceEvent.data.product_action) {
+            case EventTypeEnum.commerceEvent:
+                // tslint:disable-next-line: max-line-length
+                const commerceEventData = eventToMatch.data as CommerceEventData;
+                if (commerceEventData) {
+                    if (commerceEventData.product_action) {
                         const criteria: ProductActionEventCriteria = {
-                            action: commerceEvent.data.product_action.action,
+                            action: commerceEventData.product_action.action,
                         };
@@ -626,5 +630,5 @@ return {
                         };
-                    } else if (commerceEvent.data.promotion_action) {
+                    } else if (commerceEventData.promotion_action) {
                         const criteria: PromotionActionEventCriteria = {
-                            action: commerceEvent.data.promotion_action.action,
+                            action: commerceEventData.promotion_action.action,
                         };
@@ -635,3 +639,3 @@ return {
                         };
-                    } else if (commerceEvent.data.product_impressions) {
+                    } else if (commerceEventData.product_impressions) {
                         return { type: DataPlanMatchType.ProductImpression };
@@ -651,8 +655,9 @@ }
             case 'custom_event':
-                const customEvent = eventToConvert as CustomEvent;
-                key = customEvent?.data?.event_name;
+                const customEventData = eventToConvert.data as CustomEventData;
+                key = customEventData?.event_name;
                 break;
             case 'screen_view':
-                const screenViewEvent = eventToConvert as ScreenViewEvent;
-                key = screenViewEvent?.data?.screen_name;
+                // tslint:disable-next-line: max-line-length
+                const screenViewEventData = eventToConvert.data as ScreenViewEventData;
+                key = screenViewEventData?.screen_name;
                 break;
@@ -659,0 +664,0 @@ default:

src/services/data_plan_service.ts

@@ -9,4 +9,9 @@ import path from 'path';
     DataPlanResults,
+    DataPlanVersion,
 } from '@mparticle/data-planning-models';
-import { Batch, BaseEvent } from '@mparticle/event-models';
+import {
+    Batch,
+    BaseEvent,
+    BatchEnvironmentEnum,
+} from '@mparticle/event-models';
 import { ApiClient } from '../utils/ApiClient';
@@ -18,4 +23,2 @@ import { AuthClient, Token } from '../utils/AuthClient';
 interface AccessCredentials {
-    orgId: number;
-    accountId: number;
     workspaceId: number;
@@ -26,27 +29,28 @@ clientId: string;
 
+interface ValidationOptions {
+    serverMode?: boolean;
+}
+
 export class DataPlanService {
-    private orgId?: number;
-    private accountId?: number;
     private workspaceId?: number;
     private clientId?: string;
     private clientSecret?: string;
-    private apiURL?: string;
+    private apiURL = '';
 
     constructor(credentials?: AccessCredentials) {
         if (credentials) {
-            const {
-                orgId,
-                accountId,
-                workspaceId,
-                clientId,
-                clientSecret,
-            } = credentials;
+            const { workspaceId, clientId, clientSecret } = credentials;
 
-            this.orgId = orgId;
-            this.accountId = accountId;
-            this.workspaceId = workspaceId;
-            this.clientId = clientId;
-            this.clientSecret = clientSecret;
+            if (workspaceId && clientId && clientSecret) {
+                this.workspaceId = workspaceId;
 
-            this.apiURL = this.getAPIURL();
+                this.clientId = clientId;
+                this.clientSecret = clientSecret;
+
+                this.apiURL = this.getAPIURL();
+            } else {
+                throw new Error(
+                    'Invalid Credentials for generating API Request'
+                );
+            }
         }
@@ -68,29 +72,60 @@ }
     private getAPIURL(): string {
-        const { orgId, accountId, workspaceId } = this;
-        if (orgId && accountId && workspaceId) {
-            const urlPath = path.join(
-                config.dataPlanningPath,
-                `${orgId}`,
-                `${accountId}`,
-                `${workspaceId}`,
-                `plans/`
-            );
-            return this.buildUrl(config.apiRoot, urlPath);
+        const { workspaceId } = this;
+        const urlPath = path.join(
+            config.dataPlanningPath,
+            `${workspaceId}`,
+            `plans`
+        );
+        return this.buildUrl(config.apiRoot, urlPath);
+    }
+
+    // TODO: Refactor this with getAPIUrl
+    private getValidationAPIURL(): string {
+        const { workspaceId } = this;
+        const urlPath = path.join(
+            config.dataPlanningPath,
+            `${workspaceId}`,
+            `test`
+        );
+        return this.buildUrl(config.apiRoot, urlPath);
+    }
+
+    async createDataPlan(dataPlanToCreate: DataPlan): Promise<DataPlan> {
+        const token = await this.getToken();
+        const api = new ApiClient<DataPlan>(this.apiURL, token);
+
+        try {
+            return api
+                .post(dataPlanToCreate)
+                .then((response: AxiosResponse) => response.data);
+        } catch (error) {
+            return error.response;
         }
-        throw new Error('Invalid Credentials for generating API Request');
     }
 
-    async getPlan(dataPlanId: string): Promise<DataPlan> {
-        if (!this.apiURL) {
-            throw new Error('Invalid API URL');
+    async createDataPlanVersion(
+        dataPlanId: string,
+        dataPlanVersion: DataPlanVersion
+    ): Promise<DataPlanVersion> {
+        const token = await this.getToken();
+        const url = this.apiURL + `/${dataPlanId}/versions`;
+        const api = new ApiClient<DataPlan>(url, token);
+
+        try {
+            return api
+                .post(dataPlanVersion)
+                .then((response: AxiosResponse) => response.data);
+        } catch (error) {
+            return error.response;
         }
+    }
 
+    async deleteDataPlan(dataPlanId: string): Promise<boolean> {
         const token = await this.getToken();
-        const api = new ApiClient<DataPlan>(
-            this.buildUrl(this.apiURL, dataPlanId),
-            token
-        );
+        const url = this.apiURL + `/${dataPlanId}`;
+        const api = new ApiClient<DataPlan>(url, token);
 
         try {
-            return api.fetch().then((response: AxiosResponse) => response.data);
+            // If this doesn't throw an arror, it should return true
+            return api.delete().then((response: AxiosResponse) => true);
         } catch (error) {
@@ -101,10 +136,22 @@ return error.response;
 
-    async getAllPlans(): Promise<DataPlan[]> {
+    async deleteDataPlanVersion(
+        dataPlanId: string,
+        versionNumber: number
+    ): Promise<boolean> {
         const token = await this.getToken();
+        const url = this.apiURL + `/${dataPlanId}/versions/${versionNumber}`;
+        const api = new ApiClient<DataPlan>(url, token);
 
-        if (!this.apiURL) {
-            throw new Error('Invalid API URL');
+        try {
+            // If this doesn't throw an arror, it should return true
+            return api.delete().then((response: AxiosResponse) => true);
+        } catch (error) {
+            return error.response;
         }
+    }
 
-        const api = new ApiClient<DataPlan[]>(this.apiURL, token);
+    async getDataPlan(dataPlanId: string): Promise<DataPlan> {
+        const token = await this.getToken();
+        const url = this.apiURL + `/${dataPlanId}`;
+        const api = new ApiClient<DataPlan>(url, token);
 
@@ -118,21 +165,41 @@ try {
 
-    async getVersionDocument(
+    async getDataPlans(): Promise<DataPlan[]> {
+        const token = await this.getToken();
+        const url = this.apiURL;
+        const api = new ApiClient<DataPlan[]>(url, token);
+
+        try {
+            return api.fetch().then((response: AxiosResponse) => response.data);
+        } catch (error) {
+            return error.response;
+        }
+    }
+
+    async getDataPlanVersion(
         dataPlanId: string,
         versionNumber: number
     ): Promise<DataPlanDocument> {
-        if (!this.apiURL) {
-            throw new Error('Invalid API URL');
+        const token = await this.getToken();
+        const url = this.apiURL + `/${dataPlanId}/versions/${versionNumber}`;
+        const api = new ApiClient<DataPlan>(url, token);
+
+        try {
+            return api.fetch().then((response: AxiosResponse) => response.data);
+        } catch (error) {
+            return error.response;
         }
+    }
 
+    async updateDataPlan(
+        dataPlanId: string,
+        dataPlan: DataPlan
+    ): Promise<DataPlan> {
         const token = await this.getToken();
-        const api = new ApiClient<DataPlan>(
-            this.buildUrl(
-                this.apiURL,
-                `${dataPlanId}/versions/${versionNumber}`
-            ),
-            token
-        );
+        const url = this.apiURL + `/${dataPlanId}`;
+        const api = new ApiClient<DataPlan>(url, token);
 
         try {
-            return api.fetch().then((response: AxiosResponse) => response.data);
+            return api
+                .patch(dataPlan)
+                .then((response: AxiosResponse) => response.data);
         } catch (error) {
@@ -143,37 +210,126 @@ return error.response;
 
+    async updateDataPlanVersion(
+        dataPlanId: string,
+        versionNumber: number,
+        dataPlanVersion: DataPlanVersion
+    ): Promise<DataPlanVersion> {
+        const token = await this.getToken();
+        const url = this.apiURL + `/${dataPlanId}/versions/${versionNumber}`;
+        const api = new ApiClient<DataPlanVersion>(url, token);
+
+        try {
+            return api
+                .patch(dataPlanVersion)
+                .then((response: AxiosResponse) => response.data);
+        } catch (error) {
+            return error.response;
+        }
+    }
+
     validateEvent(
         event: BaseEvent,
-        document: DataPlanDocument
-    ): DataPlanResults {
-        if (!event || !document) {
-            throw new Error(
-                'Data Plan Document and Event are missing and required'
+        dataPlanVersion: DataPlanVersion,
+        options?: ValidationOptions
+    ): Promise<DataPlanResults> {
+        if (!event || !dataPlanVersion) {
+            return Promise.reject(
+                'Data Plan Version or Event is missing and required'
             );
         }
 
-        const resultsDto: DataPlanResults = {};
-        const validator = new DataPlanEventValidator(document);
-        const result = validator.validateEvent(event);
+        const document = dataPlanVersion.version_document;
 
-        resultsDto.results = [result];
+        if (!document) {
+            return Promise.reject(
+                'Data Plan Version does not contain a valid Version Document'
+            );
+        }
 
-        return resultsDto;
+        const serverMode = options?.serverMode;
+
+        // Create a mock batch so we can pass an event to the server
+        const mpid = '';
+        const environment = BatchEnvironmentEnum.unknown;
+
+        if (serverMode) {
+            const batch: Batch = {
+                events: [event],
+                mpid,
+                environment,
+            };
+            return this.validateOnServer(batch, dataPlanVersion, options);
+        } else {
+            const resultsDto: DataPlanResults = {};
+            const validator = new DataPlanEventValidator(document);
+            const result = validator.validateEvent(event);
+
+            resultsDto.results = [result];
+
+            return Promise.resolve(resultsDto);
+        }
     }
 
-    validateBatch(batch: Batch, document: DataPlanDocument): DataPlanResults {
-        if (!batch || !document) {
-            throw new Error(
-                'Data Plan Document and Batch are missing and required'
+    validateBatch(
+        batch: Batch,
+        dataPlanVersion: DataPlanVersion,
+        options?: ValidationOptions
+    ): Promise<DataPlanResults> {
+        if (!batch || !dataPlanVersion) {
+            return Promise.reject(
+                'Data Plan Version or Batch is missing and required'
             );
         }
 
-        const resultsDto: DataPlanResults = {};
-        const validator = new DataPlanEventValidator(document, batch);
-        const results = validator.validateEventBatch(batch);
+        const document = dataPlanVersion.version_document;
 
-        resultsDto.batch = batch;
-        resultsDto.results = results;
+        if (!document) {
+            return Promise.reject(
+                'Data Plan Version does not contain a valid Version Document'
+            );
+        }
 
-        return resultsDto;
+        const serverMode = options?.serverMode;
+
+        if (serverMode) {
+            return this.validateOnServer(batch, dataPlanVersion, options);
+        } else {
+            const resultsDto: DataPlanResults = {};
+            const validator = new DataPlanEventValidator(document, batch);
+            const results = validator.validateEventBatch(batch);
+
+            resultsDto.batch = batch;
+            resultsDto.results = results;
+
+            return Promise.resolve(resultsDto);
+        }
     }
+
+    private async validateOnServer(
+        batch: Batch,
+        dataPlanVersion: DataPlanVersion,
+        options?: ValidationOptions
+    ): Promise<DataPlanResults> {
+        const document = dataPlanVersion.version_document;
+
+        if (!document) {
+            throw new Error(
+                'Data Plan Version does not contain a valid Version Document'
+            );
+        }
+
+        const token = await this.getToken();
+        const url = this.getValidationAPIURL();
+        const api = new ApiClient<DataPlan>(url, token);
+
+        try {
+            return api
+                .post({
+                    document,
+                    batch,
+                })
+                .then((response: AxiosResponse) => response.data);
+        } catch (error) {
+            return error.response;
+        }
+    }
 }

src/utils/ApiClient.ts

 import axios, { AxiosPromise } from 'axios';
-import { Token, TokenAPIResponse } from '../utils/AuthClient';
+import { Token } from '../utils/AuthClient';
 
+interface HTTPHeader {
+    Authorization?: string;
+}
+
 export class ApiClient<T> {
     constructor(public rootUrl: string, public token?: Token) {}
 
+    private addTokens(token: Token): HTTPHeader {
+        if (token.type.toUpperCase() === 'BEARER') {
+            return {
+                Authorization: `${token.type} ${token.value}`,
+            };
+        } else {
+            console.error(
+                'Received non-Bearer Token',
+                JSON.stringify(token, null, 4)
+            );
+            throw new Error('Invalid Auth token type');
+        }
+    }
+
     fetch(): AxiosPromise {
-        const headers: { [key: string]: string } = {};
+        let headers: HTTPHeader = {};
 
         if (this.token) {
-            if (this.token.type.toUpperCase() === 'BEARER') {
-                headers[
-                    'Authorization'
-                ] = `${this.token.type} ${this.token.value}`;
-            } else {
-                console.error('Received non-Bearer Token', this.token);
-                throw new Error('Invalid Auth token type');
-            }
+            headers = this.addTokens(this.token);
         }
 
-        return axios.get(`${this.rootUrl}`, {
-            headers,
-        });
+        return axios.get(`${this.rootUrl}`, { headers });
     }
@@ -28,4 +37,32 @@
     post(body: { [key: string]: any }): AxiosPromise {
-        return axios.post(`${this.rootUrl}`, body);
+        let headers: HTTPHeader = {};
+
+        if (this.token) {
+            headers = this.addTokens(this.token);
+        }
+
+        return axios.post(`${this.rootUrl}`, body, { headers });
     }
+
+    // tslint:disable-next-line: no-any
+    patch(body: { [key: string]: any }): AxiosPromise {
+        let headers: HTTPHeader = {};
+
+        if (this.token) {
+            headers = this.addTokens(this.token);
+        }
+
+        return axios.patch(`${this.rootUrl}`, body, { headers });
+    }
+
+    // tslint:disable-next-line: no-any
+    delete(): AxiosPromise {
+        let headers: HTTPHeader = {};
+
+        if (this.token) {
+            headers = this.addTokens(this.token);
+        }
+
+        return axios.delete(`${this.rootUrl}`, { headers });
+    }
 }

src/utils/config.ts

 export const config = {
     apiRoot: 'https://api.mparticle.com',
-    dataPlanningPath: 'planning/v1',
+    dataPlanningPath: 'platform/v2/workspaces',
 
@@ -5,0 +5,0 @@ auth: {

src/validation/JSONSchemaValidator.ts

 import {
-    ErrorType,
+    SchemaKeywordErrorType,
     ValidationErrorType,
     ValidationError,
+    ValidationErrorTypeEnum,
+    SchemaKeywordErrorTypeEnum,
 } from '@mparticle/data-planning-models';
@@ -112,22 +114,23 @@ import Ajv, {
         error.error_pointer = joinJsonPointer(nodes);
-        error.schema_keyword = args.keyword;
+        error.schema_keyword = args.keyword as SchemaKeywordErrorType;
         error.key = lastNode(nodes);
 
         switch (args.keyword) {
-            case ErrorType.MultipleOf:
-            case ErrorType.Maximum:
-            case ErrorType.ExclusiveMaximum:
-            case ErrorType.Minimum:
-            case ErrorType.ExclusiveMinimum:
-            case ErrorType.MaxLength:
-            case ErrorType.MinLength:
-            case ErrorType.Pattern:
-            case ErrorType.Format:
-                error.validation_error_type = ValidationErrorType.InvalidValue;
+            case SchemaKeywordErrorTypeEnum.MultipleOf:
+            case SchemaKeywordErrorTypeEnum.Maximum:
+            case SchemaKeywordErrorTypeEnum.ExclusiveMaximum:
+            case SchemaKeywordErrorTypeEnum.Minimum:
+            case SchemaKeywordErrorTypeEnum.ExclusiveMinimum:
+            case SchemaKeywordErrorTypeEnum.MaxLength:
+            case SchemaKeywordErrorTypeEnum.MinLength:
+            case SchemaKeywordErrorTypeEnum.Pattern:
+            case SchemaKeywordErrorTypeEnum.Format:
+                error.validation_error_type =
+                    ValidationErrorTypeEnum.InvalidValue;
                 error.expected = args.message;
                 break;
 
-            case ErrorType.AdditionalItems:
-            case ErrorType.AdditionalProperties:
-                error.validation_error_type = ValidationErrorType.Unplanned;
+            case SchemaKeywordErrorTypeEnum.AdditionalItems:
+            case SchemaKeywordErrorTypeEnum.AdditionalProperties:
+                error.validation_error_type = ValidationErrorTypeEnum.Unplanned;
                 const {
@@ -140,6 +143,6 @@ additionalProperty,
 
-            case ErrorType.Required:
+            case SchemaKeywordErrorTypeEnum.Required:
                 const { missingProperty } = args.params as RequiredParams;
                 error.validation_error_type =
-                    ValidationErrorType.MissingRequired;
+                    ValidationErrorTypeEnum.MissingRequired;
                 error.expected = missingProperty;
@@ -149,21 +152,23 @@ error.actual = undefined;
 
-            case ErrorType.Type:
-            case ErrorType.Const:
-            case ErrorType.Enum:
-                error.validation_error_type = ValidationErrorType.InvalidValue;
+            case SchemaKeywordErrorTypeEnum.Type:
+            case SchemaKeywordErrorTypeEnum.Const:
+            case SchemaKeywordErrorTypeEnum.Enum:
+                error.validation_error_type =
+                    ValidationErrorTypeEnum.InvalidValue;
                 error.expected = args.message;
                 break;
 
-            case ErrorType.Dependencies:
+            case SchemaKeywordErrorTypeEnum.Dependencies:
                 error.validation_error_type =
-                    ValidationErrorType.MissingRequired;
+                    ValidationErrorTypeEnum.MissingRequired;
                 error.expected = args.message;
                 break;
 
-            case ErrorType.PatternProperties:
-                error.validation_error_type = ValidationErrorType.InvalidValue;
+            case SchemaKeywordErrorTypeEnum.PatternProperties:
+                error.validation_error_type =
+                    ValidationErrorTypeEnum.InvalidValue;
                 break;
 
             default:
-                error.validation_error_type = ValidationErrorType.Unknown;
+                error.validation_error_type = ValidationErrorTypeEnum.Unknown;
                 error.expected = args.message;
@@ -170,0 +175,0 @@ break;

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Network access

Supply chain risk

This module accesses the network.

Found 2 instances in 1 package

Uses eval

Supply chain risk

Package uses dynamic code execution (e.g., eval()), which is a dangerous practice. This can prevent the code from running in certain environments and increases the risk that the code may contain exploits or malicious behavior.

Found 1 instance in 1 package

Environment variable access

Supply chain risk

Package accesses environment variables, which may be a sign of credential stuffing or data theft.

Found 6 instances in 1 package

Improved metrics

Number of low supply chain risk alerts

1

decreased by-95.65%

Number of medium supply chain risk alerts

1

decreased by-83.33%

Worsened metrics

Total package byte prevSize

63544

decreased by-95.06%

Dev dependency count

23

increased by9.52%

Number of package files

10

decreased by-52.38%

Lines of code

1220

decreased by-96.29%

Dependency changes

• + Added@mparticle/data-planning-models@0.1.0-alpha.0(transitive)

• - Removed@mparticle/data-planning-models@0.0.2-alpha.3(transitive)

• Updated@mparticle/data-planning-models@0.1.0-alpha.0

• Updated@mparticle/event-models@^1.1.0-alpha.0