@live-change/framework 0.9.137 → 0.9.139

package/lib/definition/QueryDefinition.ts

@@ -0,0 +1,59 @@
+import { AccessSpecification } from "../processors/accessMethod.js"
+import PropertyDefinition, { PropertyDefinitionSpecification } from "./PropertyDefinition.js"
+import type { ContextBase, QueryParameters } from "./types.js"
+
+type QueryCode = string | ((input: any, output: any, parameters: QueryParameters) => Promise<any>)
+
+export interface QueryDefinitionSpecification {  
+  name: string
+  properties: Record<string, PropertyDefinitionSpecification>
+  returns?: PropertyDefinitionSpecification,
+  code: QueryCode,
+  sourceName: string,
+  update: boolean,
+
+  validation?: (parameters: QueryParameters, context: ContextBase) => Promise<any>
+  waitForEvents?: boolean,
+  timeout?: number,
+  requestTimeout?: number
+}
+
+class QueryDefinition<T extends QueryDefinitionSpecification> {
+  [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 QueryDefinition

package/lib/definition/ServiceDefinition.ts

@@ -8,6 +8,7 @@ import ViewDefinition, { ViewDefinitionSpecification } from "./ViewDefinition.js
 import EventDefinition from "./EventDefinition.js"
 import defaultValidators from '../utils/validators.js'
 import { crudChanges, definitionToJSON } from "../utils.js"
+import QueryDefinition, { QueryDefinitionSpecification } from "./QueryDefinition.js"
 
 function createModelProxy(definition, model) {
   return new Proxy(model, {
@@ -72,6 +73,21 @@ function createForeignIndexProxy(definition, model) {
   })
 }
 
+function createQueryProxy(definition, query) {
+  return new Proxy(query, {
+    get(target, prop, receiver) {
+      const runtime  = definition._runtime
+      if(runtime) {
+        const queryRuntime = runtime.queries[query.name]
+        if(queryRuntime[prop]) {
+          return Reflect.get(queryRuntime, prop, receiver)
+        }
+      }
+      return Reflect.get(target, prop, receiver)
+    }
+  })
+}
+
 
 
 export interface ServiceDefinitionSpecification {
@@ -99,6 +115,7 @@ class ServiceDefinition<T extends ServiceDefinitionSpecification> {
     this.endpoints = []
     this.validators = { ...defaultValidators }
     this.clientSideFilters = []
+    this.queries = {}
     // @ts-ignore
     for(let key in definition) this[key] = definition[key]
   }
@@ -193,6 +210,13 @@ class ServiceDefinition<T extends ServiceDefinitionSpecification> {
     this.clientSideFilters.push(filter)
   }
 
+  query<T extends QueryDefinitionSpecification>(definition: T) {
+    if(this.queries[definition.name]) throw new Error('query ' + definition.name + ' already exists')
+    const query = new QueryDefinition<T>(definition)
+    this.queries[query.name] = query
+    return createQueryProxy(this, query)
+  }
+
   toJSON() {
     let models = {}
     for(let key in this.models) models[key] = this.models[key].toJSON()
@@ -235,9 +259,11 @@ class ServiceDefinition<T extends ServiceDefinitionSpecification> {
     let oldModule = JSON.parse(JSON.stringify(oldModuleParam))
     let changes: Record<string, any>[] = []
     changes.push(...crudChanges(oldModule.models || {}, this.models || {},
-        "Model", "model", { }))
+      "Model", "model", { }))
     changes.push(...crudChanges(oldModule.indexes || {}, this.indexes || {},
       "Index", "index", { }))
+    changes.push(...crudChanges(oldModule.queries || {}, this.queries || {},
+      "Query", "query", { }))
     return changes
   }
 }

package/lib/definition/types.ts

@@ -19,6 +19,7 @@ export interface ViewContext extends ContextBase {
 export type ActionParameters = Record<string, any>
 export type TriggerParameters = Record<string, any>
 export type EventParameters = Record<string, any>
+export type QueryParameters = Record<string, any>
 
 export interface TriggerSettings {
   service?: string,

package/lib/runtime/LiveDao.js

@@ -1,5 +1,6 @@
 import LcDao from "@live-change/dao"
 import Dao from "./Dao.js"
+import { originalCredentialsSymbol } from "@live-change/dao"
 
 import { waitForSignal } from './utils.js'
 
@@ -31,12 +32,14 @@ class LiveDao extends LcDao.DaoProxy {
 
   computeCredentials() {
     let credentials = JSON.parse(JSON.stringify(this.initialCredentials))
+    const originalCredentials = JSON.parse(JSON.stringify(this.initialCredentials))
     const keys = Object.keys(credentials).filter(key => key.endsWith("Key"))
     for(const credentialsObserver of this.credentialsObservations) {
       credentials = {
         ...credentials,
         ...credentialsObserver.credentials,
-        roles: [...credentials.roles, ...(credentialsObserver.credentials.roles || [])]
+        roles: [...credentials.roles, ...(credentialsObserver.credentials.roles || [])],
+        [originalCredentialsSymbol]: originalCredentials
       }
     }    
     for(const key of keys) {

package/lib/runtime/Query.js

@@ -0,0 +1,101 @@
+import { prepareParameters, processReturn, preFilterParameters } from "./params.js"
+
+class Query {
+
+  constructor(definition, service) {
+    this.definition = definition
+    this.service = service
+    this.queryKey = `${service.name}.${definition.name}`
+    this.isObjectQuery = definition.returns?.type !== Array && definition.returns?.type !== 'Array' 
+                 && definition.returns?.type !== 'array'
+    this.codeString = typeof definition.code === 'function' ? `(${definition.code.toString()})` : definition.code
+  }
+
+  async run(parameters, context) {
+    if(!this.definition.update) throw new Error("Only update queries can be run")
+    
+    if(!parameters) parameters = {}
+    if(!context) context = {
+      client: {
+        session: null,
+        user: null,
+        ip: null,
+        roles: []
+      },
+      service: this.service,
+    }
+    
+    let preparedParams = await prepareParameters(parameters, this.definition.properties, this.service)        
+
+    const resultPromise = this.service.app.dao.requestWithSettings({
+      timeout: this.definition.timeout,
+    }, ['database', 'runQuery'], this.service.app.databaseName, 'queries', this.queryKey, preparedParams)
+    
+    resultPromise.catch(error => {
+      console.error(`Query ${this.definition.name} error `, error.stack || error)
+    })
+    return resultPromise
+  }
+
+  get(parameters, context) {
+    if(this.definition.update) throw new Error("Only non-update queries can be get")
+    
+    if(!parameters) parameters = {}
+    if(!context) context = {
+      client: {
+        session: null,
+        user: null,
+        ip: null,
+        roles: []
+      },
+      service: this.service,
+    }
+
+    const resultPromise = this.service.app.dao.get([
+      'database', this.definition.isObjectQuery ? 'runQueryObject' : 'runQuery', 
+      this.service.app.databaseName, 'queries', this.queryKey, parameters
+    ])
+    resultPromise.catch(error => {
+      console.error(`Query ${this.definition.name} error `, error.stack || error)
+    })
+    return resultPromise
+  }
+
+  observable(parameters, context) {
+    if(this.definition.update) throw new Error("Only non-update queries can be observable")
+    if(!parameters) parameters = {}
+    if(!context) context = {
+      client: {
+        session: null,
+        user: null,
+        ip: null,
+        roles: []
+      },
+      service: this.service,
+    }
+
+    const resultPromise = this.service.app.dao.observable([
+      'database', this.definition.isObjectQuery ? 'runQueryObject' : 'runQuery', 
+      this.service.app.databaseName, 'queries', this.queryKey, parameters
+    ])
+    resultPromise.catch(error => {
+      console.error(`Query ${this.definition.name} error `, error.stack || error)
+    })
+    return resultPromise
+  }
+
+  toJSON() {
+    return {
+      name: this.definition.name,
+      properties: this.definition.properties,
+      returns: this.definition.returns,
+      code: this.codeString,
+      sourceName: this.definition.sourceName,
+      update: this.definition.update,
+      timeout: this.definition.timeout,
+      requestTimeout: this.definition.requestTimeout,
+    }
+  }
+}
+
+export default Query

package/lib/runtime/Service.js

@@ -70,6 +70,11 @@ class Service {
     }
 
     this.authenticators = this.definition.authenticators
+
+    this.queries = {}
+    for(let queryName in this.definition.queries) {
+      this.queries[queryName] = new Query( this.definition.queries[queryName], this )
+    }
   }
 
   async start(config) {

package/lib/updaters/database.js

@@ -10,6 +10,8 @@ async function update(changes, service, app, force) {
   const dao = app.dao
   const database = app.databaseName
 
+  dao.request(['database', 'createTable'], database, 'queries').catch(e => 'ok')
+
   if(!app.noCache) {
     dao.request(['database', 'createTable'], database, 'cache').catch(e => 'ok')
     dao.request(['database', 'createIndex'], database, 'cache_byTimestamp', `${
@@ -110,10 +112,6 @@ async function update(changes, service, app, force) {
 
     debug("CREATE INDEX", indexName, index)
 
-    const options = {
-      multi: index.multi || false
-    }
-
     if(index.function) {
       const functionCode = `(${index.function})`
       ;(globalThis.compiledFunctionsCandidates = globalThis.compiledFunctionsCandidates || {})[functionCode] = index.function
@@ -322,6 +320,42 @@ async function update(changes, service, app, force) {
             }
         })`, { table, property: change.name })*/
       } break;
+      case "createQuery": {
+        const query = change.query
+        const queryKey = service.name + '.' + query.name
+        await dao.request(['database', 'put'], database, 'queries', {
+          id: queryKey,
+          code: typeof query.code === 'function' ? `(${query.code.toString()})` : query.code,
+          sourceName: query.sourceName,
+          update: query.update,
+          timeout: query.timeout,          
+          properties: query.properties,
+          returns: query.returns                    
+        })
+        debug("QUERY CREATED!", query.name)
+      } break;
+      case "renameQuery": {        
+        const query = change.to        
+        const queryKey = service.name + '.' + query.name
+        const oldQueryKey = service.name + '.' + change.from.name
+        const oldQuery = await dao.get(['database', 'get', database, 'queries', oldQueryKey])
+        await dao.request(['database', 'put'], database, 'queries', {
+          id: queryKey,
+          code: typeof oldQuery.code === 'function' ? `(${oldQuery.code.toString()})` : oldQuery.code,
+          sourceName: oldQuery.sourceName,
+          update: oldQuery.update, 
+          timeout: oldQuery.timeout,          
+          properties: oldQuery.properties,
+          returns: oldQuery.returns                    
+        })        
+        await dao.request(['database', 'delete'], database, 'queries', oldQueryKey)
+        debug("QUERY RENAMED!", query.name)
+      } break;
+      case "deleteQuery": {
+        const queryKey = service.name + '.' + change.name
+        await dao.request(['database', 'delete'], database, 'queries', queryKey)
+        debug("QUERY DELETED!", change.name)
+      } break;
       default:
     }
   }

package/package.json

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