@aj-shadow/z-abs-funclayer-database-server 0.0.0-aj-beta.221

package/project/server/database-file/table-encoder.js

@@ -0,0 +1,82 @@
+
+'use strict';
+
+const DatabaseConst = require('../core/database-const');
+const Encoder = require('z-abs-corelayer-server/server/communication/core-protocol/encoder');
+
+
+class TableEncoder {
+  static encoder = new Encoder(null);
+  static size = 0;
+  
+  static calculateSize(row, types) {
+    TableEncoder.encoder.calculate(true);
+    TableEncoder._encodeRow(row, types);
+    const size = TableEncoder.encoder.offset;
+    TableEncoder.encoder.calculate(false);
+    TableEncoder.encoder.clear();
+    return size;
+  }
+
+  static encodeRow(row, types, size) {
+    TableEncoder.encoder.createBuffer(size);
+    TableEncoder._encodeRow(row, types);
+    const buffer = TableEncoder.encoder.buffer;
+    TableEncoder.encoder.clear();
+    return buffer;
+  }
+  
+  static _encodeRow(row, types) {
+    for(let i = 0; i < types.length; ++i) {
+      switch(types[i]) {
+        case DatabaseConst.COLUMN_TYPE_GUID:
+          TableEncoder.encoder.setGuid(row[i]);
+          break;
+        case DatabaseConst.COLUMN_TYPE_INT8:
+          TableEncoder.encoder.setInt8(row[i]);
+          break;
+        case DatabaseConst.COLUMN_TYPE_INT16:
+          TableEncoder.encoder.setInt16(row[i]);
+          break;
+        case DatabaseConst.COLUMN_TYPE_INT32:
+          TableEncoder.encoder.setInt32(row[i]);
+          break;
+        case DatabaseConst.COLUMN_TYPE_INT64:
+          TableEncoder.encoder.setBigInt64(row[i]);
+          break;
+        case DatabaseConst.COLUMN_TYPE_UINT8:
+          TableEncoder.encoder.setUint8(row[i]);
+          break;
+        case DatabaseConst.COLUMN_TYPE_UINT16:
+          TableEncoder.encoder.setUint16(row[i]);
+          break;
+        case DatabaseConst.COLUMN_TYPE_UINT32:
+          TableEncoder.encoder.setUint32(row[i]);
+          break;
+        case DatabaseConst.COLUMN_TYPE_UINT64:
+          TableEncoder.encoder.setBigUint64(row[i]);
+          break;
+        case DatabaseConst.COLUMN_TYPE_FLOAT32:
+          TableEncoder.encoder.setFloat32(row[i]);
+          break;
+        case DatabaseConst.COLUMN_TYPE_FLOAT64:
+          TableEncoder.encoder.setFloat64(row[i]);
+          break;
+        case DatabaseConst.COLUMN_TYPE_STRING:
+          TableEncoder.encoder.setString(row[i]);
+          break;
+        case DatabaseConst.COLUMN_TYPE_TIMESTAMP:
+          TableEncoder.encoder.setBigInt64(row[i]);
+          break;
+        default:
+  #BUILD_DEBUG_START
+            ddb.warning('DB type: ', types[i], ' is not supported.');
+  #BUILD_DEBUG_STOP
+          break;
+      };
+    }
+  }
+}
+
+
+module.exports = TableEncoder;

package/project/server/database-file/table-page.js

@@ -0,0 +1,182 @@
+
+'use strict';
+
+const TableDecoder = require('./table-decoder');
+const TableEncoder = require('./table-encoder');
+const DatabaseConst = require('../core/database-const');
+const Fs = require('fs');
+const Path = require('path');
+
+
+class TablePage {
+  static GROW_SIZE = 0;
+  static INDEX_SIZE = 5;
+  static indexBuffer = null;
+  static dataBuffer = null;
+  
+  constructor(id, tableName, rowIndex, pageSize, types, baseFileName) {
+    this.id = id;
+    this.tableName = tableName;
+    this.startRowIndex = rowIndex;
+    this.stopRowIndex = rowIndex;
+    this.indexes = [{start:-1, stop:-1, status:DatabaseConst.ROW_STATUS_NONE}];
+    this.types = types;
+    this.pageSize = pageSize;
+    this.freeSpace = pageSize;
+    this.dataFileName = `${baseFileName}-${id.toString().padStart(12, '0')}-data`;
+    this.fd = -1;
+  }
+  
+  active(isActive, cb) {
+    if(isActive) {
+      if(-1 === this.fd) {
+        Fs.open(this.dataFileName, 'r+', (err, fd) => {
+          if(err) {
+            ddb.error(`Could not open filehandler: '${this.dataFileName}'`);
+          }
+          else {
+            this.fd = fd;
+          }
+          cb(err);
+        });
+      }
+      else {
+        process.nextTick(cb);
+      }
+    }
+    else {
+      if(-1 === this.fd) {
+        process.nextTick(cb);
+      }
+      else {
+        Fs.close(this.fd, (err) => {
+          if(err) {
+            ddb.error(`Could not close filehandler: '${this.dataFileName}'`);
+          }
+          else {
+            this.fd = -1;
+          }
+          cb(err);
+        });
+      }
+    }
+  }
+  
+  insertRow(row, cb) {
+    const size = TableEncoder.calculateSize(row, this.types);
+    if(this.freeSpace - size - TablePage.INDEX_SIZE >= TablePage.GROW_SIZE) {
+      this.freeSpace -= (size + TablePage.INDEX_SIZE);
+      const buffer = TableEncoder.encodeRow(row, this.types, size);
+      const index = this.stopRowIndex - this.startRowIndex;
+      const indexData = this.indexes[index];
+      const start = indexData.stop + 1;
+      const stop = start + size;
+      const newIndexData = {start, stop, status:DatabaseConst.ROW_STATUS_EXISTS};
+      this._write(buffer, newIndexData, this.indexes.length, (err) => {
+        if(!err) {
+          this.indexes[index] = newIndexData;
+          this.indexes.push({start:-1, stop, status:DatabaseConst.ROW_STATUS_NONE});
+          ++this.stopRowIndex;
+        }
+        cb(err);
+      });
+      return true;
+    }
+    else {
+      return false;
+    }
+  }
+  
+  updateRow(row, rowIndex, cb) {
+    const index = this.indexes[rowIndex - this.startRowIndex];
+    console.log(index);
+    const size = TableEncoder.calculateSize(row, this.types);
+    if(size === index.stop -index.start) {
+      console.log('SAME SIZE');
+      const buffer = TableEncoder.encodeRow(row, this.types, size);
+      this._write(buffer, index, this.indexes.length, cb);
+    }
+    else {
+      console.log('!SAME SIZE!');
+      process.nextTick(cb, new Error('Update row not the same size'));
+    }
+  }
+  
+  _writeClosed(buffer, indexData, index, cb) {
+    Fs.open(this.dataFileName, 'r+', (errOpen, fd) => {
+      if(errOpen) {
+        cb(errOpen);
+        return;
+      }
+      this._writeOpen(fd, buffer, indexData, index, (errWrite) => {
+        Fs.close(fd, (errClose) => {
+          cb(errWrite ? errWrite : errClose);
+        });
+      });
+    });
+  }
+  
+  _writeOpen(fd, buffer, indexData, index, cb) {
+    Fs.write(fd, buffer, 0, indexData.stop - indexData.start, indexData.start, (err, bytes) => {
+      if(err) {
+        cb(err);
+        return;
+      }
+      TablePage.indexBuffer.writeUInt16BE(indexData.start, 0);
+      TablePage.indexBuffer.writeUInt16BE(indexData.stop, 2);
+      TablePage.indexBuffer.writeUInt8(indexData.status, 4);
+      Fs.write(fd, TablePage.indexBuffer, 0, TablePage.INDEX_SIZE, this.pageSize - index * TablePage.INDEX_SIZE, (err, bytes) => {
+        cb(err);
+      });
+    });
+  }
+  
+  _write(buffer, indexData, index, cb) {
+    if(-1 !== this.fd) {
+      this._writeOpen(this.fd, buffer, indexData, index, cb);
+    }
+    else {
+      this._writeClosed(buffer, indexData, index, cb);
+    }
+  }
+    
+  createFile(cb) {
+    Fs.writeFile(this.dataFileName, TablePage.dataBuffer, cb);
+  }
+  
+  static parseFile(data, types, defaults, pageSize) {
+    let freeSpace = pageSize;
+    let index = 0;
+    let pos = pageSize - TablePage.INDEX_SIZE;
+    const indexes = [{start:-1, stop:-1, status:DatabaseConst.ROW_STATUS_NONE}];
+    const rows = [];
+    TableDecoder.decoder.buffer = data;
+    while(freeSpace >= TablePage.GROW_SIZE) {
+      const start = data.readUInt16BE(pos);
+      const stop = data.readUInt16BE(pos + 2);
+      const status = data.readUInt8(pos + 4);
+      const indexData = indexes[index++];
+      if(0 === stop) {
+        break;
+      }
+      indexData.start = start;
+      indexData.stop = stop;
+      indexData.status = status;
+      indexes.push({start:-1, stop, status:DatabaseConst.ROW_STATUS_NONE});
+      const row = [];
+      TableDecoder.decodeRow(row, types, defaults, start, stop);
+      rows.push(row);
+      freeSpace -= (stop - start + TablePage.INDEX_SIZE);
+      pos -= TablePage.INDEX_SIZE;
+    }
+    TableDecoder.decoder.clear();
+    return {
+      indexes,
+      rows,
+      freeSpace
+    };
+  }
+}
+
+
+module.exports = TablePage;

package/project/server/database-file/table.js

@@ -0,0 +1,165 @@
+
+'use strict';
+
+const TableEncoder = require('./table-encoder');
+const TablePage = require('./table-page');
+const DatabaseConst = require('../core/database-const');
+
+
+class Table {
+  constructor(tableName, types, fileName) {
+    this.tableName = tableName;
+    this.types = types;
+    this.baseFileName = fileName;
+    this.nextRowIndex = 0;
+    this.nextPageIndex = 0;
+    this.meanSizeOfFullPages = 0;
+    this.tablePages = [];
+    this.pageSize = 8192;
+    this.pageLock = false;
+    this.pageLockQueue = [];
+    TablePage.indexBuffer = Buffer.allocUnsafeSlow(TablePage.INDEX_SIZE);
+    TablePage.dataBuffer = Buffer.allocUnsafeSlow(this.pageSize).fill(0);
+    TableEncoder.size = this.pageSize;
+  }
+  
+  createTable(cb) {
+    const tablePage = this._getTablePageNext();
+    tablePage.createFile((err) => {
+      if(err) {
+        cb(err);
+      }
+      else {
+        this.tablePages[this.nextPageIndex].active(true, cb);
+      }
+    });
+  }
+  
+  addTablePage(id) {
+    const tablePage = new TablePage(id, this.tableName, this.nextRowIndex, this.pageSize, this.types, this.baseFileName);
+    this.tablePages.push(tablePage);
+    return tablePage;
+  }
+  
+  parseTableFiles(fileDatas, table, cb) {
+    let fileData = fileDatas.shift();
+    let id = -1;
+    this.nextPageIndex = -1;
+    do { 
+      ++this.nextPageIndex;
+      const result = TablePage.parseFile(fileData.data, table.types, table.defaults, this.pageSize);
+      if(0 !== result.rows.length) {
+        Array.prototype.push.apply(table.rows, result.rows);
+        const tablePage = this.addTablePage(++id);
+        tablePage.stopRowIndex += result.rows.length;
+        tablePage.freeSpace = result.freeSpace;
+        tablePage.indexes = result.indexes;
+        this.nextRowIndex += result.rows.length;
+      }
+      fileData = fileDatas.shift();
+    } while(fileData);
+    const lastPos = this.tablePages.length - 1;
+    if(2 <= this.tablePages.length) {
+      const lastTablePage = this.tablePages[lastPos];
+      this.meanSizeOfFullPages = (this.nextRowIndex - (lastTablePage.stopRowIndex - lastTablePage.startRowIndex)) / (lastPos);
+    }
+    else {
+      this.meanSizeOfFullPages = 0;
+    }
+    if(lastPos >= 0) {
+      this.tablePages[lastPos].active(true, cb);
+    }
+    else {
+      cb(null);
+    }
+  }
+  
+  insertRow(row, cb) {
+    const tablePage = this._getTablePageNext();
+    if(!tablePage.insertRow(row, (err) => {
+      if(!err) {
+        ++this.nextRowIndex;
+      }
+      cb(err);
+    })) {
+      this._createTablePage((err) => {
+        if(err) {
+          cb(err);
+        }
+        else {
+          const currentTablePage = this.tablePages[this.nextPageIndex];
+          this.meanSizeOfFullPages = this.meanSizeOfFullPages + ((currentTablePage.stopRowIndex - currentTablePage.startRowIndex) - this.meanSizeOfFullPages) / (this.tablePages.length - 1);
+          this.tablePages[this.nextPageIndex].active(false, () => {
+            ++this.nextPageIndex;
+            this.tablePages[this.nextPageIndex].active(true, () => {
+              this.insertRow(row, cb);
+            });
+          });
+        }
+      });
+    }
+  }
+  
+  updateRow(row, rowIndex, cb) {
+    const possiblePageIndex = 0 === this.meanSizeOfFullPages ? 0 : Math.floor(rowIndex / this.meanSizeOfFullPages);
+    const tablePage = this._getPageFromRow(possiblePageIndex, rowIndex);
+    if(tablePage) {
+      tablePage.updateRow(row, rowIndex, cb);
+    }
+    else {
+      process.nextTick(cb, new Error('Update row not found:', rowIndex));
+    }
+  }
+  
+  _createTablePage(cb) {
+    if(this.pageLock) {
+      this.pageLockQueue.push(cb);
+    }
+    else {
+      this.pageLock = true;
+      const tablePage = new TablePage(this.tablePages.length, this.tableName, this.nextRowIndex, this.pageSize, this.types, this.baseFileName);
+      this.tablePages.push(tablePage);
+      tablePage.createFile((err) => {
+        let queuedCb = this.pageLockQueue.shift();
+        while(queuedCb) {
+          queuedCb(err);
+          queuedCb = this.pageLockQueue.shift();
+        }
+        this.pageLock = false;
+        cb(err);
+      });
+    }
+  }
+  
+  _getTablePageNext() {
+    return this.tablePages[this.nextPageIndex];
+  }
+  
+  _getPageFromRow(possiblePageIndex, rowIndex) {
+    const possiblePage = this.tablePages[possiblePageIndex];
+    if(rowIndex >= possiblePage.startRowIndex) {
+      if(rowIndex < possiblePage.stopRowIndex) {
+        return possiblePage;
+      }
+      else {
+        if(this.tablePages.length < ++possiblePageIndex) {
+          return this._getPageFromRow(possiblePageIndex);
+        }
+        else {
+          return null;
+        }
+      }
+    }
+    else {
+      if(0 >= --possiblePageIndex) {
+        return this._getPageFromRow(possiblePageIndex);
+      }
+      else {
+        return null;
+      }
+    }
+  }
+}
+
+
+module.exports = Table;

package/project/server/database-git/database-git.js

@@ -0,0 +1,169 @@
+
+'use strict';
+
+const ActorPathGenerated = require('z-abs-corelayer-server/server/path/actor-path-generated');
+const GitSimple = require('simple-git');
+const Fs = require('fs');
+const Path = require('path');
+
+
+class DatabaseGit {
+  constructor(dbName, isReadOnly, releaseData) {
+    this.dbName = dbName;
+    this.isReadOnly = isReadOnly;
+    this.databasePath = `${ActorPathGenerated.getDatabasesGitFolder()}${Path.sep}${releaseData.releaseStep + (releaseData.organization ? Path.sep + releaseData.organization : '')}${Path.sep}${this.dbName}`;
+    this.databaseFileDefinition = `${this.databasePath}${Path.sep}project${Path.sep}server${Path.sep}definition.json`;
+    this.databaseFileData = `${this.databasePath}${Path.sep}project${Path.sep}server${Path.sep}data.json`;
+  }
+  
+  loadDatabase(cb) {
+    let pendings = 2;
+    let configList = [];
+    let configListError = null;
+    let statError = null;
+    GitSimple('.').listConfig((err, _configList) => {
+      configList = _configList
+      configListError = err;
+      if(0 === --pendings) {
+        this._loadDatabase(configListError, configList, statError, (err, definition, data) => {
+          cb(err, this.dbName, definition, data);
+        });
+      }
+    });                            
+    Fs.stat(this.databasePath, (err, stat) => {
+      statError = err;
+      if(0 === --pendings) {
+        this._loadDatabase(configListError, configList, statError, (err, definition, data) => {
+          cb(err, this.dbName, definition, data);
+        });
+      }
+    });
+  }
+  
+  _loadDatabase(configListError, configList, statError, cb) {
+    if(configListError) {
+      ddb.error('Could not get git config.');
+      cb(configListError);
+      return;
+    }
+    let isHttp = false; 
+    for(let i = configList.files.length - 1; i >= 0; --i) {
+      const remoteOriginUrl = configList.values[configList.files[i]]['remote.origin.url'];
+      if(remoteOriginUrl?.startsWith('https://')) {
+        isHttp = true; 
+        break;
+      }
+    }
+    if(statError) {
+      if('ENOENT' === statError.code) {
+        Fs.mkdir(this.databasePath, {recursive: true}, (err) => {
+          if(err) {
+            cb(err);
+            return;
+          }
+          else {
+            this._cloneDatabase(isHttp, (err) => {
+              if(err) {
+                cb(err);
+                return;
+              }
+              this._readDatabase(cb);
+            });
+          }
+        }); 
+      }
+      else {
+        cb(statError);
+      }
+    }
+    else {
+      this.fetchDatabase(cb);
+    }
+  }
+  
+  fetchDatabase(cb) {
+    GitSimple(this.databasePath).fetch(['--no-tags'], (err, result) => {
+      if(err) {
+        cb(err);
+        return;
+      }
+      if(0 !== result.updated.length || 0 !== result.deleted.length) {
+        GitSimple(this.databasePath).reset(this.databasePath, 'hard', 'HEAD', (err, result) => {
+          if(err) {
+            cb(err);
+            return;
+          }
+          GitSimple(this.databasePath).merge(this.databasePath, 'orig', '@{u}', ['--no-verify'], (err, result) => {
+            if(err) {
+              cb(err);
+              return;
+            }
+            this._readDatabase(cb);
+          });
+        });
+      }
+      else {
+        this._readDatabase(cb);
+      }
+    });
+  }
+  
+  _readDatabase(cb) {
+    let pendings = 2;
+    let definitionJson = '';
+    let dataJson = '';
+    let hasError = false;
+    Fs.readFile(this.databaseFileDefinition, (err, data) => {
+      if(!hasError) {
+        if(err) {
+          hasError = true;
+          cb(err, null, null);
+        }
+        else {
+          try {
+            definitionJson = JSON.parse(data);
+          }
+          catch(err) {
+            hasError = true;
+            cb(err, null, null);
+            return;
+          }
+          if(0 === --pendings) {
+            cb(null, definitionJson, dataJson);
+          }
+        }
+      }
+    });
+    Fs.readFile(this.databaseFileData, (err, data) => {
+      if(!hasError) {
+        if(err) {
+          hasError = true;
+          cb(err, null, null);
+        }
+        else {
+          try {
+            dataJson = JSON.parse(data);
+          }
+          catch(err) {
+            hasError = true;
+            cb(err, null, null);
+            return;
+          }
+          if(0 === --pendings) {
+            cb(null, definitionJson, dataJson);
+          }
+        }
+      }
+    });
+  }
+  
+  _cloneDatabase(isHttp, cb) {
+    const databaseRepo = isHttp ? `https://gitlab.com/actorjs-database/${this.dbName}.git` : `git@gitlab.com:actorjs-database/${this.dbName}.git`;
+    GitSimple(Path.resolve(`${this.databasePath}${Path.sep}..`), ['--no-tags', '--single-branch', '--depth=1']).clone(databaseRepo, (err, result) => {
+      cb(err);
+    });
+  }
+}
+
+
+module.exports = DatabaseGit;

package/project/server/database-npm/database-npm.js

@@ -0,0 +1,89 @@
+
+'use strict';
+
+const DatabaseCache = require('../core/database-cache');
+const ActorPathGenerated = require('z-abs-corelayer-server/server/path/actor-path-generated');
+const ChildProcess = require('child_process');
+const Fs = require('fs');
+const Path = require('path');
+
+
+class DatabaseNpm {
+  constructor(dbName, isReadOnly, releaseData) {
+    this.dbName = dbName;
+    this.isReadOnly = isReadOnly;
+    this.releaseData = releaseData;
+    this.databasePath = ActorPathGenerated.getDatabasesNpmFolder();
+    this.databaseFile = `${this.databasePath}${Path.sep}node_modules${Path.sep}${this.releaseData.organization}${Path.sep}${this.dbName}${Path.sep}project${Path.sep}server`;
+    this.npmInstall = `npm install --prefix ${this.databasePath} ${this.releaseData.organization}/${this.dbName}@latest --no-save --ignore-scripts --package-lock false`;
+  }
+  
+  loadDatabase(cb) {
+    ChildProcess.exec(this.npmInstall, (err, stdout, stderr) => {
+      if(!err) {
+        this._readDatabase((err, definition, data) => {
+          cb(err, this.dbName, definition, data);
+        });
+      }
+      else {
+        cb(err, this.dbName);
+      }
+    });
+  }
+  
+  fetchDatabase(cb) {
+    this.loadDatabase(cb);
+  }
+  
+  _readDatabase(cb) {
+    let pendings = 2;
+    let definitionJson = '';
+    let dataJson = '';
+    let hasError = false;
+    Fs.readFile(`${this.databaseFile}${Path.sep}definition.json`, (err, data) => {
+      if(!hasError) {
+        if(err) {
+          hasError = true;
+          cb(err, null, null);
+        }
+        else {
+          try {
+            definitionJson = JSON.parse(data);
+          }
+          catch(err) {
+            hasError = true;
+            cb(err, null, null);
+            return;
+          }
+          if(0 === --pendings) {
+            cb(null, definitionJson, dataJson);
+          }
+        }
+      }
+    });
+    Fs.readFile(`${this.databaseFile}${Path.sep}data.json`, (err, data) => {
+      if(!hasError) {
+        if(err) {
+          hasError = true;
+          cb(err, null, null);
+        }
+        else {
+          try {
+            dataJson = JSON.parse(data);
+          }
+          catch(err) {
+            hasError = true;
+            cb(err, null, null);
+            return;
+          }
+          if(0 === --pendings) {
+            cb(null, definitionJson, dataJson);
+          }
+        }
+      }
+    });
+  }
+}
+
+
+module.exports = DatabaseNpm;

package/project/z-abs-funclayer-database-server.tree

@@ -0,0 +1,21 @@
+59471cfa-20c5-4d54-95e3-bfc6c5690aa5;;z-abs-funclayer-database-server;project_folder;.;[actorjs,js]
+5ddf2916-8ed9-4f99-8547-b8a7c3c476fa;59471cfa-20c5-4d54-95e3-bfc6c5690aa5;server;static_folder;./z-abs-funclayer-database-server;[js]
+1659decf-22ce-4d8a-81ce-841f816c1a62;5ddf2916-8ed9-4f99-8547-b8a7c3c476fa;_build;static_folder;./z-abs-funclayer-database-server/server;[bld]
+a00a05dc-1023-4a9a-a640-217cc533b818;1659decf-22ce-4d8a-81ce-841f816c1a62;server-funclayer-database-server.bld;file;./z-abs-funclayer-database-server/server/_build;bld
+aac685aa-4052-430f-b7ca-d9230292a51e;1659decf-22ce-4d8a-81ce-841f816c1a62;z-abs-funclayer-database-server.prj;file;./z-abs-funclayer-database-server/server/_build;prj
+82a6ada3-f19a-4375-be1f-dcb5578b831b;5ddf2916-8ed9-4f99-8547-b8a7c3c476fa;core;folder;./z-abs-funclayer-database-server/server;[js,jsx,html]
+d52efe09-818e-4336-b62c-fd0668b885eb;82a6ada3-f19a-4375-be1f-dcb5578b831b;database-cache.js;file;./z-abs-funclayer-database-server/server/core;js
+29365329-92fb-48df-9bd1-8076a4e48016;82a6ada3-f19a-4375-be1f-dcb5578b831b;database-const.js;file;./z-abs-funclayer-database-server/server/core;js
+eb8be420-8de6-448b-93e9-48b9aa3a4c7c;82a6ada3-f19a-4375-be1f-dcb5578b831b;database-database.js;file;./z-abs-funclayer-database-server/server/core;js
+f818737d-7bf2-4e94-a5ce-9cff6156caea;82a6ada3-f19a-4375-be1f-dcb5578b831b;database-lock.js;file;./z-abs-funclayer-database-server/server/core;js
+ab22af0c-1e0d-412f-b39b-c724fecc0e65;82a6ada3-f19a-4375-be1f-dcb5578b831b;database-table.js;file;./z-abs-funclayer-database-server/server/core;js
+886a61fa-1f47-44c2-a690-9caccf49b67d;5ddf2916-8ed9-4f99-8547-b8a7c3c476fa;database-file;folder;./z-abs-funclayer-database-server/server;[js]
+b2933700-cf12-4aed-9f53-226653ee0c45;886a61fa-1f47-44c2-a690-9caccf49b67d;database-file.js;file;./z-abs-funclayer-database-server/server/database-file;js
+06fde3ae-24f4-4d19-9ab5-2da7dc2ef9c0;886a61fa-1f47-44c2-a690-9caccf49b67d;table-decoder.js;file;./z-abs-funclayer-database-server/server/database-file;js
+93b0cfb4-ff16-4933-885f-f42611e5ac5c;886a61fa-1f47-44c2-a690-9caccf49b67d;table-encoder.js;file;./z-abs-funclayer-database-server/server/database-file;js
+5616f079-ffc9-4a6b-b422-292942229c86;886a61fa-1f47-44c2-a690-9caccf49b67d;table.js;file;./z-abs-funclayer-database-server/server/database-file;js
+b7ac1df6-2267-4f75-b9c3-d15d7a53c12a;886a61fa-1f47-44c2-a690-9caccf49b67d;table-page.js;file;./z-abs-funclayer-database-server/server/database-file;js
+d06ff963-a60d-4e72-bb8c-0a6920f17fa7;5ddf2916-8ed9-4f99-8547-b8a7c3c476fa;database-git;folder;./z-abs-funclayer-database-server/server;[json]
+d2ae58a2-5eaf-4a02-bfdb-0cf45e55c244;d06ff963-a60d-4e72-bb8c-0a6920f17fa7;database-git.js;file;./z-abs-funclayer-database-server/server/database-git;js
+d6f61d9a-1e5d-433d-97aa-5e1b8a04364a;5ddf2916-8ed9-4f99-8547-b8a7c3c476fa;database-npm;folder;./z-abs-funclayer-database-server/server;[json]
+e24e686d-f161-46bf-82b3-79104fef61fc;d6f61d9a-1e5d-433d-97aa-5e1b8a04364a;database-npm.js;file;./z-abs-funclayer-database-server/server/database-npm;js