@live-change/framework 0.9.73 → 0.9.74

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

@@ -1,9 +1,26 @@
-import PropertyDefinition from "./PropertyDefinition.js"
+import PropertyDefinition, { PropertyDefinitionSpecification } from "./PropertyDefinition.js"
+import { ExecutionContext } from "./types.js"
 
-class ActionDefinition {
+type ActionParameters = Record<string, any>
 
-  constructor(definition) {
+export interface ActionContext extends ExecutionContext {
+  action: any
+  emit: (event: any) => void
+}
+
+export interface ActionDefinitionSpecification {  
+  name: string
+  properties: Record<string, PropertyDefinitionSpecification>
+  returns: PropertyDefinitionSpecification,
+  execute: (parameters: ActionParameters, context: ActionContext, emit: (event: any) => void) => 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 {
+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
+  properties: Record<string, PropertyDefinition>
+  function: (...args: any[]) => any
+  search: boolean
+  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,17 @@
 import PropertyDefinition from "./PropertyDefinition.js"
+import type { PropertyDefinitionSpecification } from "./PropertyDefinition.js"
+import type { IndexDefinitionSpecification } from "./IndexDefinition.js"
 import { crudChanges, definitionToJSON } from "../utils.js"
 
-class ModelDefinition {
+export interface ModelDefinitionSpecification {
+  name: string
+  properties: Record<string, PropertyDefinitionSpecification>
+  indexes: Record<string, IndexDefinitionSpecification>
+  onChange: (() => void)[]
+}
+
+class ModelDefinition<T extends ModelDefinitionSpecification> {
+  [key: string]: any
 
   constructor(definition, serviceName) {
     this.serviceName = serviceName
@@ -55,7 +65,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,17 @@
 import { typeName, definitionToJSON } from "../utils.js"
 
-class PropertyDefinition {
+export interface PropertyDefinitionSpecification {
+  type: string
+  of?: PropertyDefinitionSpecification
+  items?: PropertyDefinitionSpecification
+  properties?: Record<string, PropertyDefinitionSpecification>
+}
+
+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 +33,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 +56,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) {
+
+
+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,68 @@
+import PropertyDefinition, { PropertyDefinitionSpecification } from "./PropertyDefinition.js"
+
+import type { ExecutionContext } from "./types.js"
+
+export interface ViewDefinitionSpecificationBase {
+  name: string
+  properties: Record<string, PropertyDefinitionSpecification>
+  returns: PropertyDefinitionSpecification
+}
+
+export interface ViewContext extends ExecutionContext {  
+}
+
+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,12 @@
+
+export interface ClientContext {
+  session: string
+  user: string
+  ip: string
+  roles: string[]
+}
+
+export interface ExecutionContext {
+  client: ClientContext
+  service: any
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@live-change/framework",
-  "version": "0.9.73",
+  "version": "0.9.74",
   "description": "Live Change Framework - ultimate solution for real time mobile/web apps",
   "main": "index.js",
   "scripts": {
@@ -22,8 +22,8 @@
   },
   "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.74",
+    "@live-change/uid": "^0.9.74"
   },
-  "gitHead": "8968fc9d26b0256665e41b6064c71fb4ee728763"
+  "gitHead": "cdb37d2051a08b4425fcb282dfd51a2c8f3112ba"
 }

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