@live-change/db-server 0.5.3 → 0.5.6

package/Dockerfile

@@ -1,4 +1,4 @@
-FROM node:15
+FROM node:16
 USER root
 
 RUN npm -g config set user root

package/lib/Server.js

@@ -19,6 +19,12 @@ const Database = require('@live-change/db').Database
 
 const debug = require('debug')('db-server')
 
+const {
+  SsrServer,
+  createLoopbackDao
+} = require("@live-change/server")
+const packageInfo = require("@live-change/db-server/package.json");
+
 class DatabaseStore {
   constructor(path, backend, options) {
     this.path = path
@@ -93,71 +99,111 @@ class Server {
     }
   }
   createDao(session) {
-    const scriptContext = new ScriptContext({
-      /// TODO: script available routines
-      console
-    })
-    if(this.config.master) {
-      return new ReactiveDao(session, {
-        remoteUrl: this.config.master,
-        database: {
-          type: 'local',
+    const packageInfo = require('@live-change/db-server/package.json')
+
+    const store = { /// Low level data access
+      type: 'local',
           source: new ReactiveDao.SimpleDao({
-            methods: {
-              ...(profileLog.started
-                  ? profileLog.profileFunctions(dbDao.remoteRequests(this))
-                  : dbDao.remoteRequests(this))
-            },
-            values: {
-              ...dbDao.localReads(this, scriptContext)
-            }
-          })
+        methods: {
+          ...(profileLog.started
+              ? profileLog.profileFunctions(storeDao.localRequests(this))
+              : storeDao.localRequests(this))
         },
-        /*store: { /// Low level data access
-          type: 'remote',
-          generator: ReactiveDao.ObservableList
-        }*/
-        store: { /// Low level data access
-          type: 'local',
-          source: new ReactiveDao.SimpleDao({
-            methods: { // No write access to replica store
-            },
-            values: {
-              ...storeDao.localReads(this)
-            }
-          })
+        values: {
+          ...storeDao.localReads(this)
         }
       })
-    } else {
-      return new ReactiveDao(session, {
-        database: {
-          type: 'local',
-          source: new ReactiveDao.SimpleDao({
-            methods: {
-              ...(profileLog.started
-                  ? profileLog.profileFunctions(dbDao.localRequests(this, scriptContext))
-                  : dbDao.localRequests(this, scriptContext))
+    }
+
+    const version = {
+      type: 'local',
+      source: new ReactiveDao.SimpleDao({
+        methods: {},
+        values: {
+          version: {
+            observable() {
+              return new ReactiveDao.ObservableValue(packageInfo.version)
             },
-            values: {
-              ...dbDao.localReads(this, scriptContext)
+            async get() {
+              return packageInfo.version
             }
-          })
-        },
-        store: { /// Low level data access
-          type: 'local',
-          source: new ReactiveDao.SimpleDao({
-            methods: {
-              ...(profileLog.started
-                  ? profileLog.profileFunctions(storeDao.localRequests(this))
-                  : storeDao.localRequests(this))
+          }
+        }
+      })
+    }
+
+    const emptyServices = {
+      observable(parameters) {
+        return ReactiveDao.ObservableList([])
+      },
+      async get(parameters) {
+        return []
+      }
+    }
+    const sessionInfo = {
+      client: { session: 'dbRoot' },
+      services: []
+    }
+    const metadata = {
+      type: "local",
+      source: new ReactiveDao.SimpleDao({
+        methods: {},
+        values: {
+          serviceNames: emptyServices,
+          serviceDefinitions: emptyServices,
+          api: {
+            observable(parameters) {
+              ReactiveDao.ObservableValue(sessionInfo)
             },
-            values: {
-              ...storeDao.localReads(this)
+            async get(parameters) {
+              return sessionInfo
             }
-          })
+          }
         }
       })
     }
+
+    const scriptContext = new ScriptContext({
+      /// TODO: script available routines
+      console
+    })
+    let database
+    if(this.config.master) {
+      database = {
+        type: 'local',
+        source: new ReactiveDao.SimpleDao({
+          methods: {
+            ...(profileLog.started
+                ? profileLog.profileFunctions(dbDao.remoteRequests(this))
+                : dbDao.remoteRequests(this))
+          },
+          values: {
+            ...dbDao.localReads(this, scriptContext)
+          }
+        })
+      }
+
+    } else {
+      database = {
+        type: 'local',
+        source: new ReactiveDao.SimpleDao({
+          methods: {
+            ...(profileLog.started
+                ? profileLog.profileFunctions(dbDao.localRequests(this, scriptContext))
+                : dbDao.localRequests(this, scriptContext))
+          },
+          values: {
+            ...dbDao.localReads(this, scriptContext)
+          }
+        })
+      }
+    }
+    return new ReactiveDao(session, {
+      remoteUrl: this.config.master,
+      database,
+      serverDatabase: database,
+      store, version, metadata
+    })
   }
   async initialize(initOptions = {}) {
     if(!this.config.temporary) {
@@ -265,8 +311,10 @@ class Server {
     await this.metadataSavePromise
   }
 
-  getHttp() {
-    if(!this.http) {
+  async getHttp() {
+    if(this.http) return this.http
+    if(this.httpPromise) return this.httpPromise
+    this.httpPromise = (async () => {
       const app = express()
       const sockJsServer = sockjs.createServer({ prefix: '/api/sockjs' })
       sockJsServer.on('connection', (conn) => {
@@ -282,18 +330,36 @@ class Server {
         this.apiServer.handleConnection(serverConnection)
       })
       sockJsServer.attach(server)
+
+      const ssrRoot = path.dirname(require.resolve("@live-change/db-admin/front/vite.config.js"))
+      const dev = await fs.promises.access(path.resolve(ssrRoot, './dist'), fs.constants.R_OK)
+          .then(r => false).catch(r => true)
+      if(dev) console.log("STARTING ADMIN IN DEV MODE!")
+      const manifest = dev ? null : require(path.resolve(ssrRoot, 'dist/client/ssr-manifest.json'))
+      const admin = new SsrServer(app, manifest, {
+        dev,
+        fastAuth: true,
+        root: ssrRoot,
+        daoFactory: async (credentials, ip) => {
+          return await createLoopbackDao(credentials, () => this.apiServer.daoFactory(credentials, ip))
+        }
+      })
+      admin.start()
+
       this.http = {
         app,
         sockJsServer,
         wsServer,
-        server
+        server,
+        admin
       }
-    }
-    return this.http
+      return this.http
+    })()
+    return this.httpPromise
   }
 
-  listen(...args) {
-    this.getHttp().server.listen(...args)
+  async listen(...args) {
+    (await this.getHttp()).server.listen(...args)
   }
 
   async close() {

package/lib/backend.js

@@ -108,7 +108,6 @@ function createBackend(config) {
       closeStore(store) {
       },
       async deleteStore(store) {
-        await store.clear()
       }
     }
   } else if(config.backend == 'lmdb') {

package/lib/dbDao.js

@@ -372,6 +372,10 @@ function localReads(server, scriptContext) {
       observable: () => server.databasesListObservable,
       get: async () => server.databasesListObservable.list
     },
+    databases: {
+      observable: () => server.databasesListObservable.next(list => list.map(dbName => ({ id: dbName }))),
+      get: async () => server.databasesListObservable.list.map(dbName => ({ id: dbName }))
+    },
     databaseConfig: {
       observable: (dbName) => {
         const db = server.databases.get(dbName)
@@ -420,6 +424,78 @@ function localReads(server, scriptContext) {
         return db.logsListObservable.list
       }
     },
+    tablesCount: {
+      observable: (dbName, tableName, id) => {
+        const db = server.databases.get(dbName)
+        if(!db) return new ReactiveDao.ObservableError('databaseNotFound')
+        return db.tablesListObservable.next(tables => tables.length ?? 0)
+      },
+      get: async (dbName, tableName, id) =>{
+        const db = server.databases.get(dbName)
+        if(!db) throw new Error('databaseNotFound')
+        return db.tablesListObservable.list.length
+      }
+    },
+    indexesCount: {
+      observable: (dbName, tableName, id) => {
+        const db = server.databases.get(dbName)
+        if(!db) return new ReactiveDao.ObservableError('databaseNotFound')
+        return db.indexesListObservable.next(tables => tables.length ?? 0)
+      },
+      get: async (dbName, tableName, id) =>{
+        const db = server.databases.get(dbName)
+        if(!db) throw new Error('databaseNotFound')
+        return db.indexesListObservable.list.length
+      }
+    },
+    logsCount: {
+      observable: (dbName, tableName, id) => {
+        const db = server.databases.get(dbName)
+        if(!db) return new ReactiveDao.ObservableError('databaseNotFound')
+        return db.logsListObservable.next(tables => tables.length ?? 0)
+      },
+      get: async (dbName, tableName, id) =>{
+        const db = server.databases.get(dbName)
+        if(!db) throw new Error('databaseNotFound')
+        return db.logsListObservable.list.length
+      }
+    },
+    tables: {
+      observable: (dbName, tableName, id) => {
+        const db = server.databases.get(dbName)
+        if(!db) return new ReactiveDao.ObservableError('databaseNotFound')
+        return db.tablesListObservable.next(list => list.map(dbName => ({ id: dbName })))
+      },
+      get: async (dbName, tableName, id) =>{
+        const db = server.databases.get(dbName)
+        if(!db) throw new Error('databaseNotFound')
+        return db.tablesListObservable.list.map(dbName => ({ id: dbName }))
+      }
+    },
+    indexes: {
+      observable: (dbName, indexName, id) => {
+        const db = server.databases.get(dbName)
+        if(!db) return new ReactiveDao.ObservableError('databaseNotFound')
+        return db.indexesListObservable.next(list => list.map(dbName => ({ id: dbName })))
+      },
+      get: async (dbName, indexName, id) =>{
+        const db = server.databases.get(dbName)
+        if(!db) throw new Error('databaseNotFound')
+        return db.indexesListObservable.list.map(dbName => ({ id: dbName }))
+      }
+    },
+    logs: {
+      observable: (dbName, logName, id) => {
+        const db = server.databases.get(dbName)
+        if(!db) return new ReactiveDao.ObservableError('databaseNotFound')
+        return db.logsListObservable.next(list => list.map(dbName => ({ id: dbName })))
+      },
+      get: async (dbName, logName, id) => {
+        const db = server.databases.get(dbName)
+        if(!db) throw new Error('databaseNotFound')
+        return db.logsListObservable.list.map(dbName => ({ id: dbName }))
+      }
+    },
     tableConfig: {
       observable: (dbName, tableName, id) => {
         const db = server.databases.get(dbName)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@live-change/db-server",
-  "version": "0.5.3",
+  "version": "0.5.6",
   "description": "Database with observable data for live queries",
   "main": "index.js",
   "scripts": {
@@ -12,7 +12,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/live-change/db-server.git"
+    "url": "git+https://github.com/live-change/live-change-db.git"
   },
   "author": {
     "email": "m8@em8.pl",
@@ -21,22 +21,23 @@
   },
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/live-change/db-server/issues"
+    "url": "https://github.com/live-change/live-change-db/issues"
   },
-  "homepage": "https://github.com/live-change/db-server",
+  "homepage": "https://github.com/live-change/live-change-db",
   "devDependencies": {
-    "tape": "^5.2.2"
+    "tape": "^5.3.2"
   },
   "dependencies": {
-    "@live-change/dao": "^0.3.12",
-    "@live-change/dao-sockjs": "^0.2.1",
-    "@live-change/dao-websocket": "^0.3.2",
-    "@live-change/db": "^0.5.3",
-    "@live-change/db-client": "^0.5.3",
-    "@live-change/db-store-level": "^0.5.3",
-    "@live-change/db-store-lmdb": "^0.5.3",
-    "@live-change/db-store-observable-db": "^0.5.3",
-    "@live-change/db-store-rbtree": "^0.5.3",
+    "@live-change/dao": "0.4.6",
+    "@live-change/dao-sockjs": "0.4.5",
+    "@live-change/dao-websocket": "0.4.6",
+    "@live-change/db": "^0.5.6",
+    "@live-change/db-admin": "^0.5.6",
+    "@live-change/db-client": "^0.5.6",
+    "@live-change/db-store-level": "^0.5.6",
+    "@live-change/db-store-lmdb": "^0.5.6",
+    "@live-change/db-store-observable-db": "^0.5.6",
+    "@live-change/db-store-rbtree": "^0.5.6",
     "@live-change/sockjs": "^0.4.0-rc.1",
     "express": "^4.17.1",
     "line-reader": "^0.4.0",
@@ -46,7 +47,7 @@
     "rimraf-promise": "^2.0.0",
     "segfault-handler": "^1.3.0",
     "websocket": "^1.0.34",
-    "yargs": "^17.0.1"
+    "yargs": "^17.3.0"
   },
-  "gitHead": "d92fb65e55f55e246e7a4615cff609cafdc32eba"
+  "gitHead": "265e047dee05dbb0965a870d61d834242dad1af0"
 }