cloudcmd 17.1.5 → 17.2.0

package/server/{cloudcmd.js → cloudcmd.mjs}

@@ -1,40 +1,37 @@
-'use strict';
+import path, {dirname, join} from 'node:path';
+import {fileURLToPath} from 'node:url';
+import process from 'node:process';
+import fs from 'node:fs';
+import fullstore from 'fullstore';
+import currify from 'currify';
+import apart from 'apart';
+import ponse from 'ponse';
+import restafary from 'restafary';
+import restbox from 'restbox';
+import konsole from 'console-io';
+import edward from 'edward';
+import dword from 'dword';
+import deepword from 'deepword';
+import nomine from 'nomine';
+import fileop from '@cloudcmd/fileop';
+import cloudfunc from '../common/cloudfunc.js';
+import authentication from './auth.js';
+import {createConfig, configPath} from './config.js';
+import modulas from './modulas.js';
+import userMenu from './user-menu.mjs';
+import rest from './rest/index.js';
+import route from './route.js';
+import validate from './validate.js';
+import prefixer from './prefixer.js';
+import terminal from './terminal.js';
+import distribute from './distribute/index.js';
+import {createDepStore} from './depstore.js';
 
-const fullstore = require('fullstore');
-const process = require('node:process');
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const {assign} = Object;
 const DIR = `${__dirname}/`;
-const DIR_COMMON = `${DIR}../common/`;
-const path = require('node:path');
-
-const fs = require('node:fs');
-const cloudfunc = require(`${DIR_COMMON}cloudfunc`);
-
-const authentication = require(`${DIR}auth`);
-const {createConfig, configPath} = require(`${DIR}config`);
-
-const modulas = require(`${DIR}modulas`);
-
-const userMenu = require(`${DIR}user-menu`);
-const rest = require(`${DIR}rest`);
-const route = require(`${DIR}route`);
-const validate = require(`${DIR}validate`);
-const prefixer = require(`${DIR}prefixer`);
-const terminal = require(`${DIR}terminal`);
-const distribute = require(`${DIR}distribute`);
-const currify = require('currify');
-
-const apart = require('apart');
-const ponse = require('ponse');
-const restafary = require('restafary');
-const restbox = require('restbox');
-const konsole = require('console-io');
-const edward = require('edward');
-const dword = require('dword');
-const deepword = require('deepword');
-const nomine = require('nomine');
-const fileop = require('@cloudcmd/fileop');
-const DIR_ROOT = `${DIR}../`;
-
+const DIR_ROOT = join(DIR, '..');
 const getDist = (isDev) => isDev ? 'dist-dev' : 'dist';
 
 const isDev = fullstore(process.env.NODE_ENV === 'development');
@@ -49,7 +46,9 @@ const clean = (a) => a.filter(notEmpty);
 const isUndefined = (a) => typeof a === 'undefined';
 const isFn = (a) => typeof a === 'function';
 
-module.exports = (params) => {
+export default cloudcmd;
+
+function cloudcmd(params) {
     const p = params || {};
     const options = p.config || {};
     const config = p.configManager || createConfig({
@@ -57,7 +56,6 @@ module.exports = (params) => {
     });
     
     const {modules} = p;
-    
     const keys = Object.keys(options);
     
     for (const name of keys) {
@@ -87,16 +85,20 @@ module.exports = (params) => {
             socket: p.socket,
         });
     
-    return cloudcmd({
+    return cloudcmdMiddle({
         modules,
         config,
     });
-};
+}
+
+const depStore = createDepStore();
 
-module.exports.createConfigManager = createConfig;
-module.exports.configPath = configPath;
+export const createConfigManager = createConfig;
+export {
+    configPath,
+};
 
-module.exports._getIndexPath = getIndexPath;
+export const _getIndexPath = getIndexPath;
 
 function defaultValue(config, name, options) {
     const value = options[name];
@@ -108,7 +110,8 @@ function defaultValue(config, name, options) {
     return value;
 }
 
-module.exports._getPrefix = getPrefix;
+export const _getPrefix = getPrefix;
+
 function getPrefix(prefix) {
     if (isFn(prefix))
         return prefix() || '';
@@ -116,8 +119,7 @@ function getPrefix(prefix) {
     return prefix || '';
 }
 
-module.exports._initAuth = _initAuth;
-function _initAuth(config, accept, reject, username, password) {
+export function _initAuth(config, accept, reject, username, password) {
     if (!config('auth'))
         return accept();
     
@@ -176,7 +178,7 @@ function listen({prefixSocket, socket, config}) {
     distribute.export(config, socket);
 }
 
-function cloudcmd({modules, config}) {
+function cloudcmdMiddle({modules, config}) {
     const online = apart(config, 'online');
     const cache = false;
     const diff = apart(config, 'diff');
@@ -240,9 +242,14 @@ function cloudcmd({modules, config}) {
         userMenu({
             menuName: '.cloudcmd.menu.js',
         }),
-        rest(config),
+        rest({
+            config,
+            fs: depStore('fs'),
+            moveFiles: depStore('moveFiles'),
+        }),
         route(config, {
             html,
+            win32: depStore('win32'),
         }),
         ponseStatic,
     ]);
@@ -257,8 +264,9 @@ function logout(req, res, next) {
     res.sendStatus(401);
 }
 
-module.exports._isDev = isDev;
-module.exports._replaceDist = replaceDist;
+export const _isDev = isDev;
+export const _replaceDist = replaceDist;
+
 function replaceDist(url) {
     if (!isDev())
         return url;
@@ -284,3 +292,8 @@ function setSW(req, res, next) {
     
     next();
 }
+
+assign(cloudcmd, {
+    depStore,
+    createConfigManager,
+});

package/server/cloudcmd.spec.mjs

@@ -0,0 +1,180 @@
+import path, {dirname} from 'node:path';
+import {fileURLToPath} from 'node:url';
+import serveOnce from 'serve-once';
+import {test, stub} from 'supertape';
+import cloudcmd, {
+    _isDev,
+    _replaceDist,
+    createConfigManager,
+    _getPrefix,
+    _initAuth,
+    _getIndexPath,
+} from './cloudcmd.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const {request} = serveOnce(cloudcmd, {
+    config: {
+        auth: false,
+        dropbox: false,
+    },
+});
+
+test('cloudcmd: defaults: config', (t) => {
+    const configManager = createConfigManager();
+    
+    configManager('configDialog', false);
+    
+    cloudcmd({
+        configManager,
+    });
+    
+    t.notOk(configManager('configDialog'), 'should not override config with defaults');
+    t.end();
+});
+
+test('cloudcmd: defaults: console', (t) => {
+    const configManager = createConfigManager();
+    configManager('console', false);
+    
+    cloudcmd({
+        configManager,
+    });
+    
+    t.notOk(configManager('console'), 'should not override config with defaults');
+    t.end();
+});
+
+test('cloudcmd: getPrefix', (t) => {
+    const value = 'hello';
+    const result = _getPrefix(value);
+    
+    t.equal(result, value);
+    t.end();
+});
+
+test('cloudcmd: getPrefix: function', (t) => {
+    const value = 'hello';
+    const fn = () => value;
+    const result = _getPrefix(fn);
+    
+    t.equal(result, value);
+    t.end();
+});
+
+test('cloudcmd: getPrefix: function: empty', (t) => {
+    const value = null;
+    const fn = () => value;
+    const result = _getPrefix(fn);
+    
+    t.equal(result, '');
+    t.end();
+});
+
+test('cloudcmd: replaceDist', (t) => {
+    const currentIsDev = _isDev();
+    
+    _isDev(true);
+    const url = '/dist/hello';
+    const result = _replaceDist(url);
+    const expected = '/dist-dev/hello';
+    
+    _isDev(currentIsDev);
+    
+    t.equal(result, expected);
+    t.end();
+});
+
+test('cloudcmd: replaceDist: !isDev', (t) => {
+    const url = '/dist/hello';
+    
+    const currentIsDev = _isDev();
+    _isDev(false);
+    const result = _replaceDist(url);
+    
+    _isDev(currentIsDev);
+    
+    t.equal(result, url);
+    t.end();
+});
+
+test('cloudcmd: auth: reject', (t) => {
+    const accept = stub();
+    const reject = stub();
+    
+    const config = createConfigManager();
+    
+    const username = 'root';
+    const password = 'toor';
+    
+    config('auth', true);
+    config('username', username);
+    config('password', password);
+    
+    _initAuth(config, accept, reject, username, 'abc');
+    
+    t.ok(reject.called, 'should reject');
+    t.end();
+});
+
+test('cloudcmd: auth: accept', (t) => {
+    const accept = stub();
+    const reject = stub();
+    
+    const username = 'root';
+    const password = 'toor';
+    const auth = true;
+    
+    const config = createConfigManager();
+    config('username', username);
+    config('password', password);
+    config('auth', auth);
+    
+    _initAuth(config, accept, reject, username, password);
+    
+    t.ok(accept.called, 'should accept');
+    t.end();
+});
+
+test('cloudcmd: auth: accept: no auth', (t) => {
+    const accept = stub();
+    const reject = stub();
+    
+    const auth = false;
+    const username = 'root';
+    const password = 'toor';
+    
+    const config = createConfigManager();
+    config('username', username);
+    config('password', password);
+    config('auth', auth);
+    
+    _initAuth(config, accept, reject, username, password);
+    
+    t.ok(accept.called, 'should accept');
+    t.end();
+});
+
+test('cloudcmd: getIndexPath: production', (t) => {
+    const isDev = false;
+    const name = path.join(__dirname, '..', 'dist', 'index.html');
+    
+    t.equal(_getIndexPath(isDev), name);
+    t.end();
+});
+
+test('cloudcmd: getIndexPath: development', (t) => {
+    const isDev = true;
+    const name = path.join(__dirname, '..', 'dist-dev', 'index.html');
+    
+    t.equal(_getIndexPath(isDev), name);
+    t.end();
+});
+
+test('cloudcmd: sw', async (t) => {
+    const {status} = await request.get('/sw.js');
+    
+    t.equal(status, 200, 'should return sw');
+    t.end();
+});

package/server/config.js

@@ -153,7 +153,7 @@ function listen(manage, sock, auth) {
         .on('connection', (socket) => {
             if (!manage('auth'))
                 return connection(manage, socket);
-        
+            
             const reject = () => socket.emit('reject');
             socket.on('auth', auth(connectionWraped(manage, socket), reject));
         });

package/server/config.spec.mjs

@@ -0,0 +1,105 @@
+import {createRequire} from 'node:module';
+import {test, stub} from 'supertape';
+import {createConfig, _cryptoPass} from './config.js';
+import {apiURL} from '../common/cloudfunc.js';
+import {connect} from '../test/before.mjs';
+
+const require = createRequire(import.meta.url);
+const fixture = require('./config.fixture.json');
+
+const config = createConfig();
+
+test('config: manage', (t) => {
+    t.equal(undefined, config(), 'should return "undefined"');
+    t.end();
+});
+
+test('config: manage: get', async (t) => {
+    const editor = 'deepword';
+    const configManager = createConfig();
+    
+    const {done} = await connect({
+        config: {
+            editor,
+        },
+        configManager,
+    });
+    
+    done();
+    
+    t.equal(configManager('editor'), editor, 'should get config');
+    t.end();
+});
+
+test('config: manage: get: config', async (t) => {
+    const editor = 'deepword';
+    const conf = {
+        editor,
+    };
+    
+    const {done} = await connect({
+        config: conf,
+    });
+    
+    config('editor', 'dword');
+    done();
+    
+    t.equal('dword', config('editor'), 'should set config');
+    t.end();
+});
+
+test('config: manage: get: *', (t) => {
+    const data = config('*');
+    const keys = Object.keys(data);
+    
+    t.ok(keys.length > 1, 'should return config data');
+    t.end();
+});
+
+test('config: cryptoPass: no password', (t) => {
+    const json = {
+        hello: 'world',
+    };
+    
+    const config = createConfig();
+    const result = _cryptoPass(config, json);
+    
+    t.deepEqual(result, [config, json], 'should not change json');
+    t.end();
+});
+
+test('config: cryptoPass', (t) => {
+    const json = {
+        password: 'hello',
+    };
+    
+    const {password} = fixture;
+    
+    const expected = {
+        password,
+    };
+    
+    const config = createConfig();
+    const result = _cryptoPass(config, json);
+    
+    t.deepEqual(result, [config, expected], 'should crypt password');
+    t.end();
+});
+
+test('config: middle: no', (t) => {
+    const {middle} = config;
+    const next = stub();
+    const res = null;
+    const url = `${apiURL}/config`;
+    const method = 'POST';
+    
+    const req = {
+        url,
+        method,
+    };
+    
+    middle(req, res, next);
+    
+    t.calledWithNoArgs(next, 'should call next');
+    t.end();
+});

package/server/depstore.js

@@ -0,0 +1,15 @@
+'use strict';
+
+module.exports.createDepStore = () => {
+    let deps = {};
+    
+    return (name, value) => {
+        if (!name)
+            return deps = {};
+        
+        if (!value)
+            return deps[name];
+        
+        deps[name] = value;
+    };
+};

package/server/distribute/export.spec.mjs

@@ -0,0 +1,68 @@
+import Config from '../config.js';
+import {once} from 'node:events';
+import test from 'supertape';
+import io from 'socket.io-client';
+import {connect} from '../../test/before.mjs';
+
+const config = Config.createConfig();
+
+test('distribute: export', async (t) => {
+    const defaultConfig = {
+        export: true,
+        exportToken: 'a',
+        vim: true,
+        log: false,
+        prefix: '',
+    };
+    
+    const {port, done} = await connect({
+        config: defaultConfig,
+        configManager: config,
+    });
+    
+    const url = `http://localhost:${port}/distribute?port=1111`;
+    const socket = io.connect(url);
+    
+    await once(socket, 'connect');
+    socket.emit('auth', 'a');
+    
+    await once(socket, 'accept');
+    config('vim', false);
+    config('auth', true);
+    
+    await once(socket, 'change');
+    
+    socket.close();
+    await done();
+    
+    t.pass('should emit change');
+    t.end();
+});
+
+test('distribute: export: config', async (t) => {
+    const defaultConfig = {
+        export: true,
+        exportToken: 'a',
+        vim: true,
+        log: false,
+    };
+    
+    const {port, done} = await connect({
+        config: defaultConfig,
+    });
+    
+    const url = `http://localhost:${port}/distribute?port=1111`;
+    const socket = io.connect(url);
+    
+    socket.once('connect', () => {
+        socket.emit('auth', 'a');
+    });
+    
+    const data = await once(socket, 'config');
+    
+    socket.close();
+    await done();
+    
+    t.equal(typeof data, 'object', 'should emit object');
+    t.end();
+});