@live-change/framework 0.9.73 → 0.9.75

package/index.ts

@@ -0,0 +1,39 @@
+import App from './lib/App.js'
+
+export default App
+
+import ActionDefinition from './lib/definition/ActionDefinition.js'
+import EventDefinition from './lib/definition/EventDefinition.js'
+import ForeignIndexDefinition from './lib/definition/ForeignIndexDefinition.js'
+import ForeignModelDefinition from './lib/definition/ForeignModelDefinition.js'
+import IndexDefinition from './lib/definition/IndexDefinition.js'
+import ModelDefinition from './lib/definition/ModelDefinition.js'
+import PropertyDefinition from './lib/definition/PropertyDefinition.js'
+import ServiceDefinition from './lib/definition/ServiceDefinition.js'
+import TriggerDefinition from './lib/definition/TriggerDefinition.js'
+import ViewDefinition from './lib/definition/ViewDefinition.js'
+
+export {
+  ActionDefinition,
+  EventDefinition,
+  ForeignIndexDefinition,
+  ForeignModelDefinition,
+  IndexDefinition,
+  ModelDefinition,
+  PropertyDefinition,
+  ServiceDefinition,
+  TriggerDefinition,
+  ViewDefinition
+}
+
+// Export all types from definition files
+export type { ActionDefinitionSpecification, ActionParameters } from './lib/definition/ActionDefinition.js'
+export type { EventDefinitionSpecification, EventParameters } from './lib/definition/EventDefinition.js'
+export type { IndexDefinitionSpecification } from './lib/definition/IndexDefinition.js'
+export type { ModelDefinitionSpecification, ModelIndexDefinitionSpecification, ModelPropertyDefinitionSpecification } from './lib/definition/ModelDefinition.js'
+export type { PropertyDefinitionSpecification, ValidationSpecification, ValidationSpecificationObject } from './lib/definition/PropertyDefinition.js'
+export type { ViewDefinitionSpecification, ViewDefinitionSpecificationBase, ViewDefinitionSpecificationObservable, ViewDefinitionSpecificationDaoPath, ViewDefinitionSpecificationFetch } from './lib/definition/ViewDefinition.js'
+export type { TriggerDefinitionSpecification } from './lib/definition/TriggerDefinition.js'
+export type { ClientContext, ContextBase, ViewContext, ActionContext } from './lib/definition/types.js'
+export type { ServiceDefinitionSpecification } from './lib/definition/ServiceDefinition.js'
+export type { AccessSpecification, AccessFunction } from './lib/processors/accessMethod.js'

package/lib/App.js

@@ -36,6 +36,10 @@ import Debug from 'debug'
 
 const debug = Debug('framework')
 
+
+import * as utils from './utils.js'
+import * as validation from './utils/validation.js'
+
 class App {
 
   constructor(config = {}) {
@@ -82,8 +86,25 @@ class App {
     this.startedServices = {}
     this.triggerRoutes = {}
     this.globalViews = {}
+
   }
 
+  static app() {
+    if(!globalThis.liveChangeFrameworkApp) {
+      globalThis.liveChangeFrameworkApp = new App()
+    }
+    return globalThis.liveChangeFrameworkApp
+  }
+
+  static utils = utils
+  static validation = validation
+  static rangeProperties = utils.rangeProperties
+  static encodeIdentifier = utils.encodeIdentifier
+  static extractRange = utils.extractRange
+  static isomorphic = utils.isomorphic
+  static computeDefaults = utils.computeDefaults
+  static computeUpdates = utils.computeUpdates
+
   createServiceDefinition( definition ) {
     const sourceConfig = this.config && this.config.services && this.config.services.find
       && this.config.services.find(c => c.name === definition.name)

package/lib/definition/{ActionDefinition.js → ActionDefinition.ts}

@@ -1,9 +1,25 @@
-import PropertyDefinition from "./PropertyDefinition.js"
+import { AccessSpecification } from "../processors/accessMethod.js"
+import PropertyDefinition, { PropertyDefinitionSpecification } from "./PropertyDefinition.js"
+import type { ActionContext } from "./types.js"
 
-class ActionDefinition {
+export type ActionParameters = Record<string, any>
 
-  constructor(definition) {
+export interface ActionDefinitionSpecification {  
+  name: string
+  properties: Record<string, PropertyDefinitionSpecification>
+  returns: PropertyDefinitionSpecification,
+  execute: (parameters: ActionParameters, context: ActionContext, emit: (event: any) => void) => any,
+  access: AccessSpecification,
+  skipValidation: boolean,
+  validation: (parameters: ActionParameters, context: ActionContext) => Promise<any>
+}
+
+class ActionDefinition<T extends ActionDefinitionSpecification> {
+  [key: string]: any
+  
+  constructor(definition: T) {
     this.properties = {}
+    // @ts-ignore
     for(let key in definition) this[key] = definition[key]
     if(definition.properties) {
       for (let propName in definition.properties) {

package/lib/definition/{EventDefinition.js → EventDefinition.ts}

@@ -1,9 +1,20 @@
-import PropertyDefinition from "./PropertyDefinition.js"
+import PropertyDefinition, { PropertyDefinitionSpecification } from "./PropertyDefinition.js"
 
-class EventDefinition {
+export type EventParameters = Record<string, any>
 
-  constructor(definition) {
+export interface EventDefinitionSpecification {
+  name: string
+  properties: Record<string, PropertyDefinitionSpecification>
+  returns: PropertyDefinitionSpecification,
+  execute: (parameters: EventParameters) => any
+}
+
+class EventDefinition<T extends EventDefinitionSpecification> {
+  [key: string]: any
+
+  constructor(definition: T) {
     this.properties = {}
+    // @ts-ignore
     for(let key in definition) this[key] = definition[key]
     if(definition.properties) {
       for (let propName in definition.properties) {

package/lib/definition/{ForeignIndexDefinition.js → ForeignIndexDefinition.ts}

@@ -1,7 +1,8 @@
-
 class ForeignIndexDefinition {
+  serviceName: string
+  indexName: string
 
-  constructor(serviceName, indexName) {
+  constructor(serviceName: string, indexName: string) {
     this.serviceName = serviceName
     this.indexName = indexName
   }

package/lib/definition/{ForeignModelDefinition.js → ForeignModelDefinition.ts}

@@ -1,6 +1,8 @@
 class ForeignModelDefinition {
+  serviceName: string
+  name: string
 
-  constructor(serviceName, modelName) {
+  constructor(serviceName: string, modelName: string) {
     this.serviceName = serviceName
     this.name = modelName
   }

package/lib/definition/{IndexDefinition.js → IndexDefinition.ts}

@@ -1,8 +1,19 @@
 
-class IndexDefinition {
+export interface IndexDefinitionSpecification {
+  name: string
+  property: string | string[]
+  function: (...args: any[]) => any
+  parameters: Record<string, any>
+  storage: any
+  multi: boolean,
+}
+
+class IndexDefinition<T extends IndexDefinitionSpecification> {
+  [key: string]: any
 
-  constructor(definition) {
+  constructor(definition: T) {
     this.properties = {}
+    // @ts-ignore
     for(let key in definition) this[key] = definition[key]
   }
 
@@ -16,7 +27,7 @@ class IndexDefinition {
   computeChanges( oldIndexParam ) {
     let oldIndex = JSON.parse(JSON.stringify(oldIndexParam))
     oldIndex.indexes = oldIndex.indexes || {}
-    let changes = []
+    let changes: Record<string, any>[] = []
     if(oldIndex.function !== `${this.function}`) {
       changes.push({ operation: "deleteIndex", name: this.name })
       changes.push({ operation: "createIndex", name: this.name, index: this.toJSON() })

package/lib/definition/{ModelDefinition.js → ModelDefinition.ts}

@@ -1,7 +1,29 @@
 import PropertyDefinition from "./PropertyDefinition.js"
+import type { PropertyDefinitionSpecification } from "./PropertyDefinition.js"
 import { crudChanges, definitionToJSON } from "../utils.js"
 
-class ModelDefinition {
+export interface ModelIndexDefinitionSpecification {  
+  property?: string | string[]
+  function?: (...args: any[]) => any
+  parameters?: Record<string, any>  
+  storage?: any
+  multi?: boolean,
+}
+
+export interface ModelPropertyDefinitionSpecification {
+  type: string,
+  index: ModelIndexDefinitionSpecification
+}
+
+export interface ModelDefinitionSpecification {
+  name: string
+  properties: Record<string, ModelPropertyDefinitionSpecification>
+  indexes: Record<string, ModelIndexDefinitionSpecification>
+  onChange: (() => void)[]
+}
+
+class ModelDefinition<T extends ModelDefinitionSpecification> {
+  [key: string]: any
 
   constructor(definition, serviceName) {
     this.serviceName = serviceName
@@ -55,7 +77,7 @@ class ModelDefinition {
   computeChanges( oldModelParam ) {
     let oldModel = JSON.parse(JSON.stringify(oldModelParam))
     oldModel.indexes = oldModel.indexes || {}
-    let changes = []
+    let changes: Record<string, any>[] = []
     const json = this.toJSON()
     changes.push(...crudChanges(oldModel.properties || {}, json.properties || {},
         "Property", "property", { model: this.name }))

package/lib/definition/{PropertyDefinition.js → PropertyDefinition.ts}

@@ -1,8 +1,25 @@
 import { typeName, definitionToJSON } from "../utils.js"
 
-class PropertyDefinition {
+export interface ValidationSpecificationObject {
+  name: string
+  [key: string]: any
+}
+
+export type ValidationSpecification = ValidationSpecificationObject | string
+
+export interface PropertyDefinitionSpecification {
+  type: string
+  of?: PropertyDefinitionSpecification
+  items?: PropertyDefinitionSpecification
+  properties?: Record<string, PropertyDefinitionSpecification>,
+  validation: ValidationSpecification[]
+}
+
+class PropertyDefinition<T extends PropertyDefinitionSpecification> {
+  [key: string]: any
 
-  constructor(definition) {
+  constructor(definition: T) {
+    // @ts-ignore
     for(let key in definition) this[key] = definition[key]
     if(definition.properties) {
       for (let propName in definition.properties) {
@@ -24,7 +41,7 @@ class PropertyDefinition {
   }
 
   toJSON() {
-    let properties = undefined
+    let properties: Record<string, any> | undefined = undefined
     if(this.properties) {
       properties = {}
       for (let propName in this.properties) {
@@ -47,7 +64,7 @@ class PropertyDefinition {
   }
 
   computeChanges( oldProperty, params, name) {
-    let changes = []
+    let changes: Record<string, any>[] = []
     let typeChanged = false
     if(typeName(this.type) !== typeName(oldProperty.type)) typeChanged = true
     if((this.of && typeName(this.of.type)) !== (oldProperty.of && typeName(oldProperty.of.type)))

package/lib/definition/{ServiceDefinition.js → ServiceDefinition.ts}

@@ -1,10 +1,10 @@
-import ModelDefinition from "./ModelDefinition.js"
+import ModelDefinition, { ModelDefinitionSpecification } from "./ModelDefinition.js"
 import ForeignModelDefinition from "./ForeignModelDefinition.js"
-import IndexDefinition from "./IndexDefinition.js"
+import IndexDefinition, { IndexDefinitionSpecification } from "./IndexDefinition.js"
 import ForeignIndexDefinition from "./ForeignIndexDefinition.js"
 import ActionDefinition from "./ActionDefinition.js"
-import TriggerDefinition from "./TriggerDefinition.js"
-import ViewDefinition from "./ViewDefinition.js"
+import TriggerDefinition, { TriggerDefinitionSpecification } from "./TriggerDefinition.js"
+import ViewDefinition, { ViewDefinitionSpecification } from "./ViewDefinition.js"
 import EventDefinition from "./EventDefinition.js"
 import defaultValidators from '../utils/validators.js'
 import { crudChanges } from "../utils.js"
@@ -70,8 +70,16 @@ function createForeignIndexProxy(definition, model) {
   })
 }
 
-class ServiceDefinition {
-  constructor(definition) {
+
+
+export interface ServiceDefinitionSpecification {
+
+}
+
+class ServiceDefinition<T extends ServiceDefinitionSpecification> {
+  [key: string]: any
+
+  constructor(definition: T) {
     this.models = {}
     this.foreignModels = {}
     this.indexes = {}
@@ -89,10 +97,11 @@ class ServiceDefinition {
     this.endpoints = []
     this.validators = { ...defaultValidators }
     this.clientSideFilters = []
+    // @ts-ignore
     for(let key in definition) this[key] = definition[key]
   }
 
-  model(definition) {
+  model<T extends ModelDefinitionSpecification>(definition: T) {
     if(this.models[definition.name]) throw new Error('model ' + definition.name + ' already exists')
     const model = new ModelDefinition(definition, this.name)
     this.models[model.name] = model
@@ -132,14 +141,14 @@ class ServiceDefinition {
     return event
   }
 
-  view(definition) {
+  view<T extends ViewDefinitionSpecification>(definition: T) {
     if(this.views[definition.name]) throw new Error('view ' + definition.name + ' already exists')
     const view = new ViewDefinition(definition)
     this.views[view.name] = view
     return view
   }
 
-  trigger(definition) {
+  trigger<T extends TriggerDefinitionSpecification>(definition: T) {
     const trigger = new TriggerDefinition(definition)
     //if(this.triggers[trigger.name]) throw new Error('trigger ' + trigger.name + ' already exists')
     this.triggers[trigger.name] = [ ...(this.triggers[trigger.name] || []) , trigger ]
@@ -220,7 +229,7 @@ class ServiceDefinition {
 
   computeChanges( oldModuleParam ) {
     let oldModule = JSON.parse(JSON.stringify(oldModuleParam))
-    let changes = []
+    let changes: Record<string, any>[] = []
     changes.push(...crudChanges(oldModule.models || {}, this.models || {},
         "Model", "model", { }))
     changes.push(...crudChanges(oldModule.indexes || {}, this.indexes || {},

package/lib/definition/{TriggerDefinition.js → TriggerDefinition.ts}

@@ -1,9 +1,17 @@
-import PropertyDefinition from "./PropertyDefinition.js"
+import PropertyDefinition, { PropertyDefinitionSpecification } from "./PropertyDefinition.js"
 
-class TriggerDefinition {
+export interface TriggerDefinitionSpecification {
+  name: string
+  properties: Record<string, PropertyDefinitionSpecification>
+  returns: PropertyDefinitionSpecification
+}
+
+class TriggerDefinition<T extends TriggerDefinitionSpecification> {
+  [key: string]: any
 
-  constructor(definition) {
+  constructor(definition: T) {
     this.properties = {}
+    // @ts-ignore
     for(let key in definition) this[key] = definition[key]
     if(definition.properties) {
       for (let propName in definition.properties) {

package/lib/definition/ViewDefinition.ts

@@ -0,0 +1,71 @@
+import PropertyDefinition, { PropertyDefinitionSpecification } from "./PropertyDefinition.js"
+
+import type { ViewContext } from "./types.js"
+
+import type { AccessSpecification } from "../processors/accessMethod.js"
+
+export interface ViewDefinitionSpecificationBase {
+  name: string
+  properties: Record<string, PropertyDefinitionSpecification>
+  returns: PropertyDefinitionSpecification
+  internal: boolean,
+  access: AccessSpecification,
+  skipValidation: boolean,
+  validation: (parameters: Record<string, any>, context: ViewContext) => Promise<any>
+}
+
+export interface ViewDefinitionSpecificationObservable extends ViewDefinitionSpecificationBase {
+  observable: (parameters: Record<string, any>, context: ViewContext) => any
+  get: (parameters: Record<string, any>, context: ViewContext) => Promise<any>
+}
+
+export interface ViewDefinitionSpecificationDaoPath extends ViewDefinitionSpecificationBase {
+  daoPath: (parameters: Record<string, any>, context: ViewContext) => any[]
+}
+
+export interface ViewDefinitionSpecificationFetch extends ViewDefinitionSpecificationBase {
+  fetch: (parameters: Record<string, any>, context: ViewContext) => Promise<any>
+}
+
+export type ViewDefinitionSpecification = 
+  ViewDefinitionSpecificationObservable | ViewDefinitionSpecificationDaoPath | ViewDefinitionSpecificationFetch
+
+class ViewDefinition<T extends ViewDefinitionSpecification> {
+  [key: string]: any
+
+  constructor(definition: T) {
+    this.properties = {}
+    // @ts-ignore
+    for(let key in definition) this[key] = definition[key]
+    if(definition.properties) {
+      for (let propName in definition.properties) {
+        const propDefn = definition.properties[propName]
+        this.createAndAddProperty(propName, propDefn)
+      }
+    }
+    if(definition.returns) {
+      this.returns = new PropertyDefinition(definition.returns)
+    }
+  }
+
+  createAndAddProperty(name, definition) {
+    const property = new PropertyDefinition(definition)
+    this.properties[name] = property
+  }
+
+  toJSON() {
+    let properties = {}
+    for(let propName in this.properties) {
+      properties[propName] = this.properties[propName].toJSON()
+    }
+    let returns = this.returns ? this.returns.toJSON() : null
+    return {
+      ... this,
+      properties,
+      returns
+    }
+  }
+
+}
+
+export default ViewDefinition

package/lib/definition/types.ts

@@ -0,0 +1,21 @@
+
+export interface ClientContext {
+  session: string
+  user: string
+  ip: string
+  roles: string[]
+}
+
+export interface ContextBase {
+  client: ClientContext
+  service: any,
+  visibilityTest: boolean
+}
+
+export interface ViewContext extends ContextBase {
+  view: any,
+}
+
+export interface ActionContext extends ContextBase {
+  action: any
+}

package/lib/processors/{accessMethod.js → accessMethod.ts}

@@ -1,4 +1,10 @@
-export default function getAccessMethod(access) {
+import { ActionContext, ViewContext } from "../definition/types.js"
+
+export type AccessFunction = (params: Record<string, any>, context: ViewContext | ActionContext) => boolean
+
+export type AccessSpecification = AccessFunction | string[] | 'internal'
+
+export default function getAccessMethod(access: AccessSpecification) {
   if(typeof access == 'function') {
     return access
   } else if(Array.isArray(access)) {

package/lib/processors/autoValidation.js

@@ -24,6 +24,10 @@ export default function(service, app) {
           if(!action.skipValidation) {
             await validate(args[0], validators, { source: action, action, service, app, ...context })
           }
+          if(typeof action.validation === 'function') {
+            const result = await action.validation(args[0], { source: action, action, service, app, ...context })
+            if(result) throw result            
+          }
           return oldExec.apply(action, args)
         }
       }
@@ -31,25 +35,35 @@ export default function(service, app) {
   }
   for(let viewName in service.views) {
     const view = service.views[viewName]
-    if(view.skipValidation) continue
+    if(view.skipValidation && !view.validation) continue
     const validators = getValidators(view, service, view)
     if(Object.keys(validators).length > 0) {
       if (view.observable) {
         const oldObservable = view.observable
         view.observable = async (...args) => {
           const context = args[1]
-          return validate(args[0], validators, { source: view, view, service, app, ...context }).then(() =>
-              oldObservable.apply(view, args)
-          )
+          if(!view.skipValidation) {
+            await validate(args[0], validators, { source: view, view, service, app, ...context })
+          }
+          if(typeof view.validation === 'function') {
+            const result = await view.validation(args[0], { source: view, view, service, app, ...context })
+            if(result) throw result            
+          }
+          return oldObservable.apply(view, args)
         }
       }
       if(view.get) {
         const oldGet = view.get
         view.get = async (...args) => {
           const context = args[1]
-          return validate(args[0], validators, { source: view, view, service, app, ...context }).then(() =>
-              oldGet.apply(view, args)
-          )
+          if(!view.skipValidation) {
+            await validate(args[0], validators, { source: view, view, service, app, ...context })
+          }
+          if(typeof view.validation === 'function') {
+            const result = await view.validation(args[0], { source: view, view, service, app, ...context })
+            if(result) throw result            
+          }
+          return oldGet.apply(view, args)          
         }
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@live-change/framework",
-  "version": "0.9.73",
+  "version": "0.9.75",
   "description": "Live Change Framework - ultimate solution for real time mobile/web apps",
   "main": "index.js",
   "scripts": {
@@ -22,8 +22,11 @@
   },
   "homepage": "https://github.com/live-change/live-change-stack",
   "devDependencies": {
-    "@live-change/dao": "^0.9.73",
-    "@live-change/uid": "^0.9.73"
+    "@live-change/dao": "^0.9.75",
+    "@live-change/uid": "^0.9.75",
+    "typedoc": "0.28.3",
+    "typedoc-plugin-markdown": "^4.6.3",
+    "typedoc-plugin-rename-defaults": "^0.7.3"
   },
-  "gitHead": "8968fc9d26b0256665e41b6064c71fb4ee728763"
+  "gitHead": "07528a11201aa968ce48bf48bd2eea5e030842f6"
 }

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "allowSyntheticDefaultImports": true,
+
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "lib": ["ES2020", "DOM"],
+
+    /* Linting */
+    "strict": false,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noFallthroughCasesInSwitch": true,
+    "outDir": "dist",
+    "checkJs": false,
+    "esModuleInterop": true,    // Enable interop for ES modules
+    "resolveJsonModule": true,  // Allow importing JSON files
+    "skipLibCheck": true,
+    "noImplicitAny": false
+  },
+  "files": ["index.ts"],
+  "include": [
+    "lib/**/*.ts", "lib/**/*.js", "index.ts"],
+  "exclude": ["node_modules/@types", "node_modules/**/*.d.ts", "**/*.test.js", "**/CMakeFiles/**"]
+}
+

package/typedoc.json

@@ -0,0 +1,14 @@
+{
+  "entryPoints": ["index.ts"],
+  "out": "docs",
+  "includeVersion": true,
+  "excludePrivate": true,
+  "excludeInternal": true,
+  "excludeProtected": true,
+  "tsconfig": "./tsconfig.json",
+  "plugin": [
+    "typedoc-plugin-markdown",
+    "typedoc-plugin-rename-defaults"
+  ],
+  "sourceLinkTemplate": "https://github.com/live-change/live-change-stack/blob/master/framework/framework/{path}#L{line}"
+}

package/index.js

@@ -1,46 +0,0 @@
-import App from './lib/App.js'
-
-App.app = () => {
-  if(!globalThis.liveChangeFrameworkApp) {
-    globalThis.liveChangeFrameworkApp = new App()
-  }
-  return globalThis.liveChangeFrameworkApp
-}
-
-import * as utils from './lib/utils.js'
-import * as validation from './lib/utils/validation.js'
-
-App.utils = utils
-App.validation = validation
-App.rangeProperties = utils.rangeProperties
-App.encodeIdentifier = utils.encodeIdentifier
-App.extractRange = utils.extractRange
-App.isomorphic = utils.isomorphic
-App.computeDefaults = utils.computeDefaults
-App.computeUpdates = utils.computeUpdates
-
-export default App
-
-import ActionDefinition from './lib/definition/ActionDefinition.js'
-import EventDefinition from './lib/definition/EventDefinition.js'
-import ForeignIndexDefinition from './lib/definition/ForeignIndexDefinition.js'
-import ForeignModelDefinition from './lib/definition/ForeignModelDefinition.js'
-import IndexDefinition from './lib/definition/IndexDefinition.js'
-import ModelDefinition from './lib/definition/ModelDefinition.js'
-import PropertyDefinition from './lib/definition/PropertyDefinition.js'
-import ServiceDefinition from './lib/definition/ServiceDefinition.js'
-import TriggerDefinition from './lib/definition/TriggerDefinition.js'
-import ViewDefinition from './lib/definition/ViewDefinition.js'
-
-export {
-  ActionDefinition,
-  EventDefinition,
-  ForeignIndexDefinition,
-  ForeignModelDefinition,
-  IndexDefinition,
-  ModelDefinition,
-  PropertyDefinition,
-  ServiceDefinition,
-  TriggerDefinition,
-  ViewDefinition
-}

package/lib/definition/ViewDefinition.js

@@ -1,39 +0,0 @@
-import PropertyDefinition from "./PropertyDefinition.js"
-
-class ViewDefinition {
-
-  constructor(definition) {
-    this.properties = {}
-    for(let key in definition) this[key] = definition[key]
-    if(definition.properties) {
-      for (let propName in definition.properties) {
-        const propDefn = definition.properties[propName]
-        this.createAndAddProperty(propName, propDefn)
-      }
-    }
-    if(definition.returns) {
-      this.returns = new PropertyDefinition(definition.returns)
-    }
-  }
-
-  createAndAddProperty(name, definition) {
-    const property = new PropertyDefinition(definition)
-    this.properties[name] = property
-  }
-
-  toJSON() {
-    let properties = {}
-    for(let propName in this.properties) {
-      properties[propName] = this.properties[propName].toJSON()
-    }
-    let returns = this.returns ? this.returns.toJSON() : null
-    return {
-      ... this,
-      properties,
-      returns
-    }
-  }
-
-}
-
-export default ViewDefinition