@contrail/cli 1.0.0 → 1.0.5

package/src/types/interfaces.ts

@@ -0,0 +1,54 @@
+export interface ReducedType {
+  slug: string;
+  label: string;
+  typePath: string;
+  isArchived: boolean;
+  typeProperties: ReducedType[];
+}
+
+export interface ReducedTypeProperties {
+  id: string;
+  isArchived: boolean;
+  propertyType: PropertyType;
+  slug: string;
+  label: string;
+  editable: boolean;
+  core: boolean;
+  typePropertyOptionSetId: string;
+  formula: string;
+  referencedTypeRootSlug: string;
+  defaultValue: string;
+  propertyLevel: string;
+  inherited: boolean;
+}
+
+export interface ReducedOptionSet {
+  id: string;
+  name: string;
+  isArchived: boolean;
+  optionSet: any[];
+}
+
+export declare enum PropertyType {
+  Text = 'text',
+  String = 'string',
+  Number = 'number',
+  Date = 'date',
+  Boolean = 'boolean',
+  MultiSelect = 'multi_select',
+  SingleSelect = 'choice',
+  Url = 'url',
+  Currency = 'currency',
+  Percent = 'percent',
+  Rating = 'rating',
+  Formula = 'formula',
+  ObjectReference = 'object_reference',
+  ObjectReferenceList = 'object_ref_list',
+  DataGrid = 'data_grid',
+  CascadingSelect = 'cascading_select',
+  Sequence = 'sequence',
+  Constant = 'constant',
+  Composite = 'composite',
+  UserList = 'userList',
+  Image = 'image',
+}

package/src/types/option-set-uploader.ts

@@ -0,0 +1,83 @@
+import { Entities } from '@contrail/sdk';
+import { ReducedOptionSet } from './interfaces';
+import fs from 'fs';
+import { getSeparatorByPlatform } from '../common';
+
+const yaml = require('js-yaml');
+
+function loadOptionSets(){
+  const TARGET_DIR = process.cwd();
+  try {
+    const separator = getSeparatorByPlatform();
+    const doc = yaml.load(fs.readFileSync(TARGET_DIR + separator + 'option_sets.yml', 'utf8'));
+    return doc.optionSets;
+  } catch (e) {
+    throw new Error(`ERROR PARSING YAML: ${e}`);
+  }
+}
+
+export async function uploadOptionSets() {
+  const optionSets: ReducedOptionSet[] = loadOptionSets();
+
+  const currentOptionSets = await new Entities().get({
+    entityName: 'type-property-option-set',
+  });
+
+  const currentOptionSetsByName = {};
+  for (const currentOptionSet of currentOptionSets) {
+    currentOptionSetsByName[currentOptionSet.name] = currentOptionSet;
+  }
+
+  const newOptionSetsByName = {};
+  for (const optionSet of optionSets) {
+    newOptionSetsByName[optionSet.name] = optionSet;
+  }
+
+  for (const optionSet of optionSets) {
+    try {
+      const found = currentOptionSetsByName[optionSet.name];
+      if (!found) {
+        console.log('Creating: ', optionSet.name);
+        await new Entities().create({
+          entityName: 'type-property-option-set',
+          object: {
+            name: optionSet.name,
+            optionSet: optionSet.optionSet,
+            isArchived: optionSet.isArchived,
+          },
+        });
+      }
+      else
+      {
+        console.log('Updating: ', optionSet.name);
+        await new Entities().update({
+          entityName: 'type-property-option-set',
+          id: found.id,
+          object: {
+            name: optionSet.name,
+            optionSet: optionSet.optionSet,
+            isArchived: optionSet.isArchived,
+          },
+        });
+      }
+    } catch (err) {
+      throw new Error(`Error Uploading OptionSets: ${err}`);
+    }
+  }
+
+  for (const currentOptionSet of currentOptionSets) {
+    try {
+      const found = newOptionSetsByName[currentOptionSet.name];
+      if (!found) {
+        console.log('Deleting: ', currentOptionSet.name);
+        await new Entities().delete({
+          entityName: 'type-property-option-set',
+          id: currentOptionSet.id,
+        });
+      }
+    } catch (err) {
+      throw new Error(`Error Deleting OptionSets: ${err}`);
+    }
+  }
+
+}

package/src/types/types-extractor.ts

@@ -0,0 +1,116 @@
+import { Entities } from '@contrail/sdk';
+import { ReducedType, ReducedOptionSet, ReducedTypeProperties } from './interfaces';
+import chalk from 'chalk';
+import fs from 'fs';
+import { authUser } from '../auth/login';
+import { getSeparatorByPlatform } from '../common';
+
+const yaml = require('js-yaml');
+
+export async function getTypes(args) {
+  try {
+    const userConfig = await authUser();
+    console.log(`%s Getting all types for orgId: ${userConfig.orgId}`, chalk.blue.bold('START'));
+
+    console.log(`%s Retrieving`, chalk.yellow.bold('OPTION SETS'));
+    await getOptionSets();
+    console.log(`%s Retrieved`, chalk.yellow.bold('OPTION SETS'));
+
+    console.log(`%s Retrieving`, chalk.yellow.bold('TYPES'));
+    await getReducedTypes();
+    console.log(`%s Retrieved`, chalk.yellow.bold('TYPES'));
+
+  }
+  catch (e) {
+    console.log(`%s Types Retrieval Failed. ${e}`, chalk.red.bold('FAIL'));
+    return;
+  }
+
+  console.log('%s Types Retrieval Complete.', chalk.green.bold('COMPLETE'));
+}
+
+async function getOptionSets() {
+  const optionSets = await new Entities().get({
+    entityName: 'type-property-option-set',
+  });
+
+  const reducedOptionSets = [];
+  for (const optionSet of optionSets) {
+    const reducedOptionSet: ReducedOptionSet = {
+      id: optionSet.id,
+      name: optionSet.name,
+      isArchived: optionSet.isArchived,
+      optionSet: optionSet.optionSet,
+    };
+
+    reducedOptionSets.push(reducedOptionSet);
+  }
+
+  const optionSetsHolder = {
+    optionSets: reducedOptionSets,
+  };
+
+  const CURRENT_DIR = process.cwd();
+  const separator = getSeparatorByPlatform();
+
+  const yamlStr = yaml.dump(optionSetsHolder);
+  fs.writeFileSync(CURRENT_DIR + separator + 'option_sets.yml', yamlStr, 'utf8');
+}
+
+async function getReducedTypes() {
+  const types = await new Entities().get({
+    entityName: 'type',
+  });
+
+  console.log('Found types: ', types.length);
+
+  const reducedTypes = [];
+  for (const type of types) {
+    const typeWithProperties = await new Entities().get({
+      entityName: 'type',
+      id: type.id,
+      relations: ['typeProperties'],
+    });
+
+    const reducedTypeProperties = [];
+    for (const typeProperty of typeWithProperties.typeProperties) {
+      const reducedTypeProperty: ReducedTypeProperties = {
+        id: typeProperty.id,
+        isArchived: typeProperty.isArchived,
+        propertyType: typeProperty.propertyType,
+        slug: typeProperty.slug,
+        label: typeProperty.label,
+        editable: typeProperty.editable,
+        core: typeProperty.core,
+        typePropertyOptionSetId: typeProperty.typePropertyOptionSetId,
+        formula: typeProperty.formula,
+        referencedTypeRootSlug: typeProperty.referencedTypeRootSlug,
+        defaultValue: typeProperty.defaultValue,
+        propertyLevel: typeProperty.propertyLevel,
+        inherited: typeProperty.inherited,
+      };
+
+      reducedTypeProperties.push(reducedTypeProperty);
+    }
+
+    const reducedType: ReducedType = {
+      slug: typeWithProperties.slug,
+      label: typeWithProperties.label,
+      typePath: typeWithProperties.typePath,
+      isArchived: typeWithProperties.isArchived,
+      typeProperties: reducedTypeProperties,
+    };
+
+    reducedTypes.push(reducedType);
+  }
+
+  const typesHolder = {
+    types: reducedTypes,
+  };
+
+  const CURRENT_DIR = process.cwd();
+  const separator = getSeparatorByPlatform();
+
+  const yamlStr = yaml.dump(typesHolder);
+  fs.writeFileSync(CURRENT_DIR + separator + 'types.yml', yamlStr, 'utf8');
+}

package/src/types/types-uploader.ts

@@ -0,0 +1,198 @@
+import { Entities, Request } from '@contrail/sdk';
+import { ReducedType, ReducedTypeProperties } from './interfaces';
+import { uploadOptionSets } from './option-set-uploader';
+import chalk from 'chalk';
+import fs from 'fs';
+import { authUser } from '../auth/login';
+import { getSeparatorByPlatform } from '../common';
+
+const yaml = require('js-yaml');
+
+export async function uploadTypes(args) {
+  try {
+    const userConfig = await authUser();
+    console.log(`%s Getting all types for orgId: ${userConfig.orgId}`, chalk.blue.bold('START'));
+
+    console.log(`%s Uploading`, chalk.yellow.bold('OPTION SETS'));
+    await uploadOptionSets();
+    console.log(`%s Uploaded`, chalk.yellow.bold('OPTION SETS'));
+
+    console.log(`%s Uploading`, chalk.yellow.bold('TYPES'));
+    await uploadReducedTypes();
+    console.log(`%s Uploaded`, chalk.yellow.bold('TYPES'));
+
+  }
+  catch (e) {
+    console.log(`%s Types Upload Failed. ${e}`, chalk.red.bold('FAIL'));
+    return;
+  }
+
+  console.log('%s Types Upload Complete.', chalk.green.bold('COMPLETE'));
+}
+
+function loadReducedTypes(){
+  const TARGET_DIR = process.cwd();
+  try {
+    const separator = getSeparatorByPlatform();
+    const doc = yaml.load(fs.readFileSync(TARGET_DIR + separator + 'types.yml', 'utf8'));
+    return doc.types;
+  } catch (e) {
+    throw new Error(`ERROR PARSING YAML: ${e}`);
+  }
+}
+
+async function uploadReducedTypes() {
+  const types: ReducedType[] = loadReducedTypes();
+
+  const currentTypesWithoutProperties = await new Entities().get({
+    entityName: 'type',
+  });
+
+  const currentTypes = [];
+  for (const currentTypeWithoutProperties of currentTypesWithoutProperties) {
+    const typeWithProperties = await new Entities().get({
+      entityName: 'type',
+      id: currentTypeWithoutProperties.id,
+      relations: ['typeProperties'],
+    });
+    currentTypes.push(typeWithProperties);
+  }
+
+  const currentTypesBySlug = {};
+  for (const currentType of currentTypes) {
+    currentTypesBySlug[currentType.slug] = currentType;
+  }
+
+  const newTypesBySlug = {};
+  for (const type of types) {
+    newTypesBySlug[type.slug] = type;
+  }
+
+  for (const type of types) {
+    try {
+      const found = currentTypesBySlug[type.slug];
+      if (!found) {
+        if (!type.typePath.includes(':')) {
+          console.log('Cannot create a base type. Skipping: ', type.slug);
+          continue;
+        }
+
+        console.log('Creating Type: ', type.slug);
+
+        const createdType = await new Entities().create({
+          entityName: 'type',
+          object: {
+            slug: type.slug,
+            label: type.label,
+            typePath: type.typePath,
+            isArchived: type.isArchived,
+          },
+        });
+
+        await uploadReducedTypeProperties(createdType, [], type.typeProperties);
+      }
+      else
+      {
+        console.log('Updating Type: ', type.slug);
+        const updatedType = await new Entities().update({
+          entityName: 'type',
+          id: found.id,
+          object: {
+            slug: type.slug,
+            label: type.label,
+            typePath: type.typePath,
+            isArchived: type.isArchived,
+          },
+        });
+
+        await uploadReducedTypeProperties(updatedType, found.typeProperties, type.typeProperties);
+      }
+
+    } catch (err) {
+      console.log('Error Uploading Types: ', err);
+    }
+  }
+
+  for (const currentType of currentTypes) {
+    try {
+      const found = newTypesBySlug[currentType.slug];
+      if (!found) {
+        console.log('Deleting Type: ', currentType.slug);
+        await new Entities().delete({
+          entityName: 'type',
+          id: currentType.id,
+        });
+      }
+    } catch (err) {
+      throw new Error(`Error Deleting Types: ${err}`);
+    }
+  }
+
+}
+
+async function uploadReducedTypeProperties(type, currentPropertyTypes, newPropertyTypes) {
+  const currentPropertyTypeBySlug = {};
+  for (const currentPropertyType of currentPropertyTypes) {
+    currentPropertyTypeBySlug[currentPropertyType.slug] = currentPropertyType;
+  }
+
+  const newPropertyTypesBySlug = {};
+  for (const newPropertyType of newPropertyTypes) {
+    newPropertyTypesBySlug[newPropertyType.slug] = newPropertyType;
+  }
+
+  for (const newPropertyType of newPropertyTypes) {
+    try {
+      const found = currentPropertyTypeBySlug[newPropertyType.slug];
+      if (!found && !newPropertyType.inherited) {
+        console.log('Creating Type-Property: ', newPropertyType.slug);
+
+        await Request.request(
+          `/types/${type.id}/type-properties`,
+          {
+          method: 'POST',
+          body: JSON.stringify({
+            isArchived: newPropertyType.isArchived,
+            propertyType: newPropertyType.propertyType,
+            slug: newPropertyType.slug,
+            label: newPropertyType.label,
+            editable: newPropertyType.editable,
+            core: newPropertyType.core,
+            typePropertyOptionSetId: newPropertyType.typePropertyOptionSetId,
+            formula: newPropertyType.formula,
+            referencedTypeRootSlug: newPropertyType.referencedTypeRootSlug,
+            defaultValue: newPropertyType.defaultValue,
+            propertyLevel: newPropertyType.propertyLevel,
+          }),
+          headers: {
+              'Accept': 'application/json',
+              'Content-Type': 'application/json',
+          },
+      });
+      }
+
+    } catch (err) {
+      console.log('Error Creating Properties: ', err);
+    }
+  }
+
+  for (const currentPropertyType of currentPropertyTypes) {
+    try {
+      const found = newPropertyTypesBySlug[currentPropertyType.slug];
+      if (!found && !currentPropertyType.inherited) {
+        console.log('Deleting Type-Property: ', currentPropertyType.slug);
+        await Request.request(
+          `/types/${type.id}/type-properties/${currentPropertyType.id}`,
+          {
+          method: 'DELETE',
+          headers: {
+              'Accept': 'application/json',
+              'Content-Type': 'application/json',
+          },
+      });
+      }
+    } catch (err) {
+      throw new Error(`Error Deleting Properties: ${err}`);
+    }
+  }
+}

package/templates/javascript/actions/example/action.js

@@ -1,38 +1,38 @@
-async function execute(config, event, Functions) {        
-  const getBodyFromEvent = (config, event) => {            
-    let body = Functions.StringUtil.parseVariables(config.message, event);            
-    console.log('body: ', body);            
-    if (config.sendDetails) {                
-      const data = event;                
-      const properties = {};                
-      let addedProperty = false;                
-      for (const property of config.fieldsToForward) {                    
-        const variableLevels = property.split('.');                    
-        let replacementValue = data;                    
-        for (let i = 0; i < variableLevels.length; i++) {                        
-          replacementValue = replacementValue[variableLevels[i]];                    
-        }                    
-        properties[property] = replacementValue;                    
-        addedProperty = true;                
-      }                
-      if (addedProperty) {                    
-        body = body + ' Properties: ' + JSON.stringify(properties) + '.';                
-      }            
-    }            
-    return JSON.stringify({ text: body });        
-  };        
-  const body = getBodyFromEvent(config, event);        
-  console.log('Sending message: ', body);        
-  const response = await Functions.fetch(config.url, {            
-    method: 'POST',            
-    body: body,            
-    headers: { 'Content-Type': 'application/json' }        
-  });        
-  if (!response.ok) {            
-    console.log('Webhook event failed to publish');            
-    console.log('Response: ', JSON.stringify(response));        
-  }        
-  else {            
-    console.log('Published!');        
-  }    
+async function execute(config, event, Functions) {        
+  const getBodyFromEvent = (config, event) => {            
+    let body = Functions.stringUtil.parseVariables(config.message, event);            
+    console.log('body: ', body);            
+    if (config.sendDetails) {                
+      const data = event;                
+      const properties = {};                
+      let addedProperty = false;                
+      for (const property of config.fieldsToForward) {                    
+        const variableLevels = property.split('.');                    
+        let replacementValue = data;                    
+        for (let i = 0; i < variableLevels.length; i++) {                        
+          replacementValue = replacementValue[variableLevels[i]];                    
+        }                    
+        properties[property] = replacementValue;                    
+        addedProperty = true;                
+      }                
+      if (addedProperty) {                    
+        body = body + ' Properties: ' + JSON.stringify(properties) + '.';                
+      }            
+    }            
+    return JSON.stringify({ text: body });        
+  };        
+  const body = getBodyFromEvent(config, event);        
+  console.log('Sending message: ', body);        
+  const response = await Functions.fetch(config.url, {            
+    method: 'POST',            
+    body: body,            
+    headers: { 'Content-Type': 'application/json' }        
+  });        
+  if (!response.ok) {            
+    console.log('Webhook event failed to publish');            
+    console.log('Response: ', JSON.stringify(response));        
+  }        
+  else {            
+    console.log('Published!');        
+  }    
 }

package/templates/javascript/app.yml

@@ -1,42 +1,54 @@
-appIdentifier: "@your-co/app-name"
-appName: "Your App Name"
-appDescription: "Your app description."
-visibility: public
-publisher: "Your company name"
-version: 1.0
-
-appConfiguration: 
-  apiHost: 
-    label: "API Host"
-    propertyType: "string"
-  userName: 
-    label: "User Name"
-    propertyType: "string"
-  password: 
-    label: "Password"
-    propertyType: "string"
-
-actions: 
-  updateProduct: 
-    handler: actions/example/action.js
-    name: "Update Product"
-    description: "Updates a product in the destination system."
-
-triggers: 
-  trigger1: 
-    key: product|create
-    name: "Produt Created"
-
-workflows: 
-  workflow1: 
-    name: "Update item on product creation"
-    triggerKey: product|create
-    paths:
-      path1: 
-        conditional: "{retailPrice} > 10"
-        actions: 
-          updateItem: 
-            actionId: updateItem
-            configuration:
-
-
+appIdentifier: "@your-co/app-name"
+appName: "Your App Name"
+appDescription: "Your app description."
+visibility: public
+publisher: "Your company name"
+version: 1.0
+
+# eventWorkflowTriggerKeyMapping will be used to parse an incoming event into a key that can trigger workflows
+# {} indicates a field on the event. You can use nested fields by separating the levels with a '.'
+# i.e. an event {details: {eventType: 'apparel'}, actionType: 'create'} can be parsed to apparel|create with the following
+eventWorkflowTriggerKeyMapping: "{details.eventType}|{actionType}" 
+
+appConfiguration: 
+  apiHost: 
+    label: "API Host"
+    propertyType: "string"
+  userName: 
+    label: "User Name"
+    propertyType: "string"
+  password: 
+    label: "Password"
+    propertyType: "string"
+
+actions: 
+  updateProduct: 
+    handler: actions/example/action.js
+    name: "Update Product"
+    description: "Updates a product in the destination system."
+    actionConfiguration: 
+      email: 
+        label: "Email Address"
+        propertyType: "string"
+
+triggers: 
+  trigger1: 
+    key: product|create
+    name: "External Product Created"
+    external: true
+    description: "Triggers on externally created products"
+
+# TODO - This is not read
+workflows: 
+  workflow1: 
+    name: "Update item on product creation"
+    triggerKey: product|create
+    paths:
+      path1: 
+        conditional: "{retailPrice} > 10"
+        actions: 
+          updateItem: 
+            actionId: updateItem
+            configuration:
+
+

package/templates/javascript/package.json

@@ -1,23 +1,23 @@
-{
-  "name": "test-app",
-  "version": "1.0.0",
-  "description": "",
-  "main": "index.js",
-  "bin": {
-    "@contrail/contrail-cli": "bin/init",
-    "contrail": "bin/init"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": [
-  ],
-  "author": "",
-  "license": "ISC",
-  "dependencies": {
-    "chalk": "^4.0.0"
-  }
-}
+{
+  "name": "test-app",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "bin": {
+    "@contrail/contrail-cli": "bin/init",
+    "contrail": "bin/init"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+  ],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "chalk": "^4.0.0"
+  }
+}