@aj-shadow/actorjs-app 0.0.0-aj-beta.221

package/project/server/plugin-data/repos/repos.js

@@ -0,0 +1,94 @@
+
+'use strict';
+
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const Fs = require('fs');
+
+
+class Repos {
+  static writeNew(contentUrl, dataUrl, asynchWriteFile, done) {
+    Fs.access(ActorPathData.getLocalReposFolder(), Fs.constants.R_OK | Fs.constants.W_OK, (err) => {
+      if(err) {
+        this._createFolder((err) => {
+          if(err) {
+            done(err);
+          }
+          else {
+            this._createFile(contentUrl, dataUrl, asynchWriteFile, done);
+          }
+        });
+      }
+      else {
+        this._createFile(contentUrl, dataUrl, asynchWriteFile, done);
+      }
+    });
+  }
+  
+  static _update(repos, name, url) {
+    const found = repos.find((repo) => {
+      return name === repo.name;
+    });
+    if(found) {
+      found.url = url;
+    }
+    else {
+      repos.push({
+        name: name,
+        url: url
+      });
+    }
+  }
+  
+  static update(contentUrl, dataUrl, repos, asynchWriteFile, done) {
+    if(contentUrl) {
+      this._update(repos.actorjsContentRepos, 'actorjs-content-local', contentUrl);
+    }
+    if(dataUrl) {
+      this._update(repos.actorjsDataRepos, 'actorjs-data-local', dataUrl);
+    }
+    asynchWriteFile(ActorPathData.getLocalReposFile(), repos, done);
+  }
+  
+  static _createFolder(done) {
+    Fs.mkdir(ActorPathData.getLocalReposFolder(), done);
+  }
+  
+  static _createFile(contentUrl, dataUrl, asynchWriteFile, done) {
+    const repos = {
+      actorjsContentRepos: [],
+      actorjsDataRepos: []
+    };
+    if(contentUrl) {
+      repos.actorjsContentRepos.push({
+        name: 'actorjs-content-local',
+        url: contentUrl
+      });
+    }
+    if(dataUrl) {
+      repos.actorjsDataRepos.push({
+        name: 'actorjs-data-local',
+        url: dataUrl
+      });
+    }
+    asynchWriteFile(ActorPathData.getLocalReposFile(), repos, done);
+  }
+  
+  static getReposFile(asynchReadFile, done) {
+    Fs.access(ActorPathData.getLocalReposFile(), Fs.constants.R_OK | Fs.constants.W_OK, (err) => {
+      if(err) {
+        if('ENOENT' === err.code) {
+          done(null);
+        }
+        else {
+          done(err);
+        }
+      }
+      else {
+        asynchReadFile(ActorPathData.getLocalReposFile(), done);
+      }
+    });
+  }
+}
+
+
+module.exports = Repos;

package/project/server/plugin-data/stack-editor/helpers/template.js

@@ -0,0 +1,351 @@
+
+'use strict';
+
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const Os = require('os');
+const Path = require('path');
+
+
+class Template {
+  constructor() {
+    
+  }
+  
+  createFile(path, name, type, templateName, transportName, cbWrite) {
+    const fileName = this._fileName(path, name, type, templateName);
+    const stackEndings = Template.stackEndings.get(templateName);
+    const text = Template.templates.get(templateName)({
+      stackEndings: stackEndings,
+      name: name,
+      nameUpperCase: this._formatName(name),
+      transportName: this._formatTransportName(transportName)
+    });
+    const file = Path.normalize(ActorPathData.getStackFile(`${path}${Path.sep}${fileName}`));
+    cbWrite(file, text, fileName);
+  }
+  
+  getPath(path, fileName = null) {
+    if(null !== fileName) {
+      return Path.normalize(ActorPathData.getStackFile(`${path}${Path.sep}${fileName}`));
+    }
+    else {
+      return Path.normalize(ActorPathData.getStackFile(path));
+    }
+  }
+  
+  _formatNamePart(namePart) {
+    if(0 === namePart.length) {
+      return '';
+    }
+    else if(1 === namePart.length) {
+      return `${namePart[0].toUpperCase()}`;
+    }
+    else {
+      return `${namePart[0].toUpperCase()}${namePart.slice(1)}`;
+    }
+  }
+  
+  _formatName(name) {
+    const nameParts = name.split('-');
+    const newNameParts = nameParts.map((namePart) => {
+      return this._formatNamePart(namePart);
+    });
+    return newNameParts.join('');
+  }
+  
+  _formatTransportName(transportName) {
+    return transportName.toUpperCase();
+  }
+  
+  _fileName(path, name, type, templateName) {
+    return `${name}${Template.stackEndings.get(templateName)}.${type}`;
+  }
+  
+  static _template(strings, ...keys) {
+    return ((...values) => {
+      const dict = values[values.length - 1] || {};
+      const result = [strings[0].replace(new RegExp('\n', 'g'), Os.EOL)];
+      keys.forEach((key, i) => {
+        const value = Number.isInteger(key) ? values[key] : dict[key];
+        result.push(value, strings[i + 1].replace(new RegExp('\n', 'g'), Os.EOL));
+      });
+      return result.join('');
+    });
+  }
+}
+
+
+Template.stackEndings = new Map([
+  ['Client Connection', '-connection-client'],
+  ['Server Connection', '-connection-server'],
+  ['Encoder', '-encoder'],
+  ['Decoder', '-decoder'],
+  ['Msg', '-msg'],
+  ['Const', '-const'],
+  ['Inner Log', '-inner-log'],
+  ['Style', '-style'],
+  ['Api', '-stack-api'],
+  ['Client Connection Options', '-connection-client-options'],
+  ['Server Connection Options', '-connection-server-options'],
+  ['Class [class js file]', ''],
+  ['None [empty js file]', '']
+]);
+
+Template.templates = new Map([
+  [
+    'Client Connection',
+    Template._template`
+'use strict';
+
+const StackApi = require('stack-api');
+const ${'nameUpperCase'}ConnectionClientOptions = require('./${'name'}-connection-client-options');
+const ${'nameUpperCase'}Encoder = require('./${'name'}-encoder');
+const ${'nameUpperCase'}Decoder = require('./${'name'}-decoder');
+
+
+class ${'nameUpperCase'}ConnectionClient extends StackApi.ConnectionClient {
+  constructor(id, cbActorCallbacks, connectionOptions, name = '${'name'}') {
+    super(id, cbActorCallbacks, name, StackApi.NetworkType.${'transportName'}, connectionOptions, ${'nameUpperCase'}ConnectionClientOptions);
+  }
+
+  send(msg) {
+    this.sendMessage(new ${'nameUpperCase'}Encoder(msg));
+  }
+  
+  receive(msg) {
+    this.receiveMessage(new ${'nameUpperCase'}Decoder(msg));
+  }
+}
+
+module.exports = ${'nameUpperCase'}ConnectionClient;
+`
+  ],
+  [
+    'Server Connection',
+    Template._template`
+'use strict';
+
+const StackApi = require('stack-api');
+const ${'nameUpperCase'}ConnectionServerOptions = require('./${'name'}-connection-server-options');
+const ${'nameUpperCase'}Encoder = require('./${'name'}-encoder');
+const ${'nameUpperCase'}Decoder = require('./${'name'}-decoder');
+
+
+class ${'nameUpperCase'}ConnectionServer extends StackApi.ConnectionServer {
+  constructor(id, cbActorCallbacks, connectionOptions, name = '${'name'}') {
+    super(id, cbActorCallbacks, name, StackApi.NetworkType.${'transportName'}, connectionOptions, ${'nameUpperCase'}ConnectionServerOptions);
+  }
+
+  receive(msg) {
+    this.receiveMessage(new ${'nameUpperCase'}Decoder(msg));
+  }
+
+  send(msg) {
+    this.sendMessage(new ${'nameUpperCase'}Encoder(msg));
+  }
+}
+
+module.exports = ${'nameUpperCase'}ConnectionServer;
+`
+  ],
+  [
+    'Encoder',
+    Template._template`
+'use strict';
+
+const StackApi = require('stack-api');
+const ${'nameUpperCase'}InnerLog = require('./${'name'}-inner-log');
+
+
+class ${'nameUpperCase'}Encoder extends StackApi.Encoder {
+  constructor(msg) {
+    super();
+    this.msg = msg;
+  }
+  
+  *encode() {
+
+  }
+}
+
+module.exports = ${'nameUpperCase'}Encoder;
+`
+  ],
+  [
+    'Decoder',
+    Template._template`
+'use strict';
+
+const StackApi = require('stack-api');
+const ${'nameUpperCase'}InnerLog = require('./${'name'}-inner-log');
+
+
+class ${'nameUpperCase'}Decoder extends StackApi.Decoder {
+  constructor(msg) {
+    super();
+    this.msg = msg;
+  }
+}
+
+module.exports = ${'nameUpperCase'}Decoder;
+`
+  ],
+  [
+    'Msg',
+    Template._template`
+'use strict';
+
+
+class ${'nameUpperCase'}Msg {
+  constructor() {
+  }
+}
+
+module.exports = ${'nameUpperCase'}Msg;
+`
+  ],
+  [
+    'Const',
+    Template._template`
+'use strict';
+
+
+class ${'nameUpperCase'}Const {
+  constructor() {
+    
+  }
+}
+
+${'nameUpperCase'}Const.MAX_CAPTION_SIZE = 30;
+${'nameUpperCase'}Const.BREAK_CAPTION_SIZE = ${'nameUpperCase'}Const.MAX_CAPTION_SIZE - 3;
+
+
+module.exports = ${'nameUpperCase'}Const;
+`
+  ],
+  [
+    'Inner Log',
+    Template._template`
+'use strict';
+
+const StackApi = require('stack-api');
+const ${'nameUpperCase'}Const = require('./${'name'}-const');
+
+
+class ${'nameUpperCase'}InnerLog {
+  static generateLog(msg, ipLogs) {
+    const readableMsg = \`\${StackApi.AsciiDictionary.getSymbolString(msg)}\`;
+    const innerLog = new StackApi.LogInner(\`\'\${readableMsg}\'\`);
+    ipLogs.push(innerLog);
+    return readableMsg.length <= ${'nameUpperCase'}Const.MAX_CAPTION_SIZE ? readableMsg : readableMsg.substring(0, ${'nameUpperCase'}Const.BREAK_CAPTION_SIZE) + '...';
+  }
+}
+
+module.exports = ${'nameUpperCase'}InnerLog;
+`
+  ],
+  [
+    'Style',
+    Template._template`
+'use strict';
+
+
+class ${'nameUpperCase'}Style {
+  constructor(index) {
+    this.index = index;
+    this.textColor= 'black';
+    this.textProtocolColor = 'black';
+    this.protocolColor = '#90EE90';
+    this.protocolBackgroundColor = 'rgba(144, 238, 144, 0.3)';
+  }
+}
+
+
+module.exports = ${'nameUpperCase'}Style;
+`
+  ],
+  [
+    'Api',
+    Template._template`
+'use strict';
+
+const ${'nameUpperCase'}ConnectionClientOptions = require('./${'name'}-connection-client-options');
+const ${'nameUpperCase'}ConnectionServerOptions = require('./${'name'}-connection-server-options');
+const ${'nameUpperCase'}Msg = require('./${'name'}-msg');
+const ${'nameUpperCase'}Const = require('./${'name'}-const');
+const ${'nameUpperCase'}Style = require('./${'name'}-style');
+
+
+const exportsObject = {
+  ${'nameUpperCase'}ConnectionClientOptions: ${'nameUpperCase'}ConnectionClientOptions,
+  ${'nameUpperCase'}ConnectionServerOptions: ${'nameUpperCase'}ConnectionServerOptions,
+  ${'nameUpperCase'}Msg: ${'nameUpperCase'}Msg,
+  ${'nameUpperCase'}Const: ${'nameUpperCase'}Const,
+  ${'nameUpperCase'}Style: ${'nameUpperCase'}Style
+}
+
+
+module.exports = exportsObject;
+`
+  ],
+  [
+    'Client Connection Options',
+    Template._template`
+'use strict';
+
+
+class ${'nameUpperCase'}ConnectionClientOptions {
+  constructor() {
+    
+  }
+  
+  clone() {
+    return new ${'nameUpperCase'}ConnectionClientOptions();
+  }
+}
+
+module.exports = new ${'nameUpperCase'}ConnectionClientOptions();
+`
+  ],
+  [
+    'Server Connection Options',
+    Template._template`
+'use strict';
+
+
+class ${'nameUpperCase'}ConnectionServerOptions {
+  constructor() {
+    
+  }
+  
+  clone() {
+    return new ${'nameUpperCase'}ConnectionServerOptions();
+  }
+}
+
+module.exports = new ${'nameUpperCase'}ConnectionServerOptions();
+`
+  ],
+  [
+    'Class [class js file]',
+    Template._template`
+'use strict';
+
+
+class ${'nameUpperCase'}${'stackEndings'} {
+  constructor() {
+    
+  }
+}
+
+module.exports = ${'nameUpperCase'}${'stackEndings'};
+`
+  ],
+  [
+    'None [empty js file]',
+    Template._template``
+  ]
+]);
+
+
+module.exports = Template;

package/project/server/plugin-data/stack-editor/plugin_data_StackEditorBuild.js

@@ -0,0 +1,185 @@
+
+'use strict';
+
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const ActorPath = require('z-abs-corelayer-server/server/path/actor-path');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+const GuidGenerator = require('z-abs-corelayer-cs/clientServer/guid-generator');
+//const Browserify = require('browserify');
+//const { JSHINT } = require('jshint');
+const Vm = require('vm');
+const Fs = require('fs');
+const Path = require('path');
+
+
+class StackEditorBuild extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest(content, path, file) {
+    const indexVmScript = this.expectAsynchResponse();
+    const indexBundle = this.expectAsynchResponse();
+    const indexJsHint = this.expectAsynchResponse();
+    try {
+      const script = new Vm.Script(content, {filename:file});
+      this.asynchResponseSuccess(indexVmScript, {check:'success'});
+    }
+    catch(err) {
+      this.asynchResponseSuccess(indexVmScript, {check: 'failure', err: this._parseVmError(err)});
+    }
+    this.asynchResponseSuccess(indexBundle, {check:'success'});
+    this.asynchResponseSuccess(indexJsHint, {check:'success'});
+    /*let bundleResponseSent = false;
+    const newContent = this._updateRequire(content, path, file);
+    this._createTempBundleFile(newContent, file, (err, tempFileName) => {
+      if(err) {
+        this.asynchResponseError(err.message, indexBundle);
+      }
+      else {
+        const browserify = Browserify(tempFileName);
+        const x = browserify.bundle((errB, buf) => {
+          if(errB) {
+            if(!bundleResponseSent) {
+              const bundleError = this._parseBundle(errB.message, newContent, file);
+              if(null !== bundleError) {
+                this.asynchResponseSuccess(indexBundle, {check:'failure', err: bundleError});
+              }
+              else {
+                this.asynchResponseSuccess(indexBundle, {check:'success'});
+              }
+              bundleResponseSent = true;
+            }
+          }
+          else {
+            if(!bundleResponseSent) {
+              this.asynchResponseSuccess(indexBundle, {check:'success'});
+              bundleResponseSent = true;
+            }
+          }
+        });
+      }
+    }); 
+    JSHINT(content, {node: true, esversion: 11, noyield: true});
+    if(0 === JSHINT.errors.length) {
+      this.asynchResponseSuccess(indexJsHint, {check:'success'});
+    }
+    else {
+      const jsHintErrors = this._parseJsHint(JSHINT.errors, file);
+      this.asynchResponseSuccess(indexJsHint, {check:'failure', errors: jsHintErrors});
+    }*/
+  }
+  
+  _createTempBundleFile(content, file, cb) {
+    const id = GuidGenerator.create();
+    const tempFileName = `${ActorPath.getActorTmpPath()}${Path.sep}${id}_${file}`;
+    Fs.writeFile(tempFileName, content, (err) => {
+      if(err) {
+        cb(err);
+      }
+      else {
+        cb(undefined, tempFileName);
+      }
+    });
+  }
+  
+  _updateRequire(content, path, file) {
+    let startIndex = content.indexOf("require('");
+    let stopIndex = content.indexOf("');", startIndex);
+    const foundStackNames = [];
+    const reqLen = "require('".length;
+    while(-1 !== startIndex && -1 !== stopIndex) {
+      const stackName = content.substring(startIndex + reqLen, stopIndex);
+      foundStackNames.push({name: stackName, start: startIndex + reqLen, stop: stopIndex});
+      startIndex = content.indexOf("require('", stopIndex);
+      stopIndex = content.indexOf("');", startIndex);
+    }
+    startIndex = 0;
+    let newContent = '';
+    for(let i = 0; i < foundStackNames.length; ++i) {
+      const stackObject = foundStackNames[i];
+      newContent += content.substring(startIndex, stackObject.start);
+      if(stackObject.name.endsWith('-stack-api')) {
+        newContent += stackObject.name;
+      }
+      else if(stackObject.name.endsWith('actor-api') || stackObject.name.endsWith('stack-api')) {
+        newContent += stackObject.name;
+      }
+      else if(stackObject.name.startsWith('.')) {
+        const newPath = Path.normalize(`${ActorPathData.getStackFile(path)}/${stackObject.name}`).replace(new RegExp('[/\\\\]', 'g'), '/');
+        newContent += newPath;
+      }
+      else {
+        newContent += stackObject.name;
+      }
+      startIndex = stackObject.stop;
+    }
+    newContent += content.substring(startIndex, content.length - 1);
+    return newContent;
+  }
+  
+  _parseVmError(err) {
+    const msg = err.stack;
+    const lineBrIndex = msg.indexOf('\n');
+    if(-1 !== lineBrIndex) {
+      const firstLine = msg.substring(0, lineBrIndex);
+      const parts = firstLine.split(':');
+      return {
+        file: parts[0].trim(),
+        msg: err.message,
+        line: Number.parseInt(parts[1].trim())
+      };
+    }
+    return {
+      file: 'unknown',
+      msg: err.message,
+      line: -1
+    };
+  }
+  
+  _parseBundle(err, content, file) {
+    if(err.startsWith('Cannot find module')) {
+      const first = err.indexOf("'");
+      if(-1 !== first) {
+        const second = err.indexOf("'", first + 1);
+        if(-1 !== second) {
+          let current = 0;
+          let lineNbr = 1;
+          const searchIndex = content.indexOf(err.substring(first + 1, second));
+          if(-1 !== searchIndex) {
+            while(true) {
+              const lineBr = content.indexOf('\n', current);
+              if(searchIndex <= lineBr) {
+                break;
+              }
+              else {
+                current = lineBr + 1;
+                ++lineNbr;
+              }
+            }
+            return {
+              file: file,
+              msg: err.substring(0, second + 1),
+              line: lineNbr
+            };
+          }
+        }
+      }
+    }
+    return null;
+  }
+  
+  _parseJsHint(errors, file) {
+    const responseErrors = [];
+    errors.forEach((error) => {
+      responseErrors.push({
+        file: file,
+        msg: error.reason,
+        line: error.line
+      });
+    });
+    return responseErrors;
+  }
+}
+
+module.exports = StackEditorBuild;

package/project/server/plugin-data/stack-editor/plugin_data_StackEditorFileDelete.js

@@ -0,0 +1,21 @@
+
+'use strict';
+
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const ActorPathDist = require('z-abs-corelayer-server/server/path/actor-path-dist');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class StackEditorFileDelete extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.DELETE);
+  }
+  
+  onRequest(file) {
+    this.asynchRmFileResponse(ActorPathData.getStackFile(file));
+    this.asynchRmFileResponse(ActorPathDist.getStackFile(file));
+  }
+}
+
+
+module.exports = StackEditorFileDelete;

package/project/server/plugin-data/stack-editor/plugin_data_StackEditorFileGet.js

@@ -0,0 +1,18 @@
+
+'use strict';
+
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class StackEditorFileGet extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest(file) {
+    this.asynchReadTextFileResponse(ActorPathData.getStackFile(file));
+  }
+}
+
+module.exports = StackEditorFileGet;

package/project/server/plugin-data/stack-editor/plugin_data_StackEditorFileNew.js

@@ -0,0 +1,24 @@
+
+'use strict';
+
+const Template = require('./helpers/template');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class StackEditorFileNew extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.ADD);
+    this.template = new Template();
+  }
+  
+  onRequest(path, name, type, templateName) {
+    this.expectAsynchResponseTemp();
+    this.template.createFile(path, name, type, templateName, 'tcp', (file, text, fileName) => {
+      this.asynchWriteTextFileResponse(file, text, fileName);
+    });
+    this.unExpectAsynchResponseTemp();
+  }
+}
+
+
+module.exports = StackEditorFileNew;