oox 0.3.0-beta1 → 0.3.0-beta11

package/app.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.execute = exports.call = exports.on = exports.getMethods = exports.setMethods = exports.sourceKVMethods = exports.kvMethods = exports.eventHub = exports.asyncStore = exports.Context = void 0;
+exports.execute = exports.call = exports.emit = exports.off = exports.once = exports.on = exports.getMethods = exports.setMethods = exports.sourceKVMethods = exports.kvMethods = exports.eventHub = exports.asyncStore = exports.Context = exports.logger = void 0;
 const node_events_1 = require("node:events");
 const node_async_hooks_1 = require("node:async_hooks");
 const utils_1 = require("./utils");
+exports.logger = require("./logger");
 class Context {
     // 请求溯源ID
     traceId = '';
@@ -32,9 +33,21 @@ function getMethods() {
 }
 exports.getMethods = getMethods;
 function on(event, listener) {
-    return exports.eventHub.on(event, listener);
+    exports.eventHub.on(event, listener);
 }
 exports.on = on;
+function once(event, listener) {
+    exports.eventHub.once(event, listener);
+}
+exports.once = once;
+function off(event, listener) {
+    exports.eventHub.off(event, listener);
+}
+exports.off = off;
+function emit(event, ...args) {
+    return exports.eventHub.emit(event, ...args);
+}
+exports.emit = emit;
 /**
  * Call an Function on RPC server
  * @param action
@@ -124,18 +137,6 @@ async function execute(action, params, context) {
     // ============================= PROXY END =============================
     // make sure target action execute after all proxies
     if (target) {
-        /*
-        const sourceMethod = wrappedActions.get ( action )
-
-        const middlewareNames = actionMiddlewares.get ( sourceMethod )
-
-        if ( middlewareNames && middlewareNames.length ) for ( const name of middlewareNames ) {
-
-            const middleware = middlewares.get ( name )
-
-            await middleware ( action, params, context )
-        }
-        */
         return await target(...params);
     }
 }

package/bin/cli.js

@@ -1,43 +1,49 @@
 #! /usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.startup = exports.version = void 0;
 const chalk_1 = require("chalk");
 const starter_1 = require("./starter");
+Object.defineProperty(exports, "startup", { enumerable: true, get: function () { return starter_1.startup; } });
 const pkg = require("../package.json");
-const args = process.argv.slice(2);
-const command = args[0];
-var isStartup = true;
-if (!command || ['help', '-h', '-help', '--help', 'version', '-v', '-version', '--version'].includes(command)) {
-    isStartup = false;
-    console.log();
-    console.log('OOX Service');
-    console.log((0, chalk_1.bold) `version`, chalk_1.bold.green `${pkg.version}`);
-    console.log((0, chalk_1.underline) `${pkg.homepage}`);
-    console.log();
+exports.version = pkg.version;
+const jsExecutionFilename = process.argv[1];
+if (/(oox.*cli\.js)$/.test(jsExecutionFilename)) {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    var isStartup = true;
+    if (!command || ['help', '-h', '-help', '--help', 'version', '-v', '-version', '--version'].includes(command)) {
+        isStartup = false;
+        console.log();
+        console.log('OOX Service');
+        console.log((0, chalk_1.bold) `version`, chalk_1.bold.green `${pkg.version}`);
+        console.log((0, chalk_1.underline) `${pkg.homepage}`);
+        console.log();
+    }
+    if (['help', '-h', '-help', '--help'].includes(command)) {
+        console.log((0, chalk_1.bold) `Usage:`);
+        console.log('  oox entry.js');
+        console.log();
+        console.log('  oox entry.js port=8080');
+        console.log();
+        console.log('  oox app/entry/index.js group=app/ env=envs/entry.js ignore=core');
+        console.log();
+        console.log((0, chalk_1.bold) `Params:`);
+        const params = [
+            ['  default-env  [ file ]  ', '.js or .json file, merge to oox.config'],
+            ['  env          [ file ]  ', '.js or .json file, merge to oox.config', (0, chalk_1.bold) `(after default-env)`],
+            ['  port         [ int  ]  ', 'set', (0, chalk_1.bold) `0`, 'for random port, or any integer > 0'],
+            ['  group        [ dir  ]  ', 'service group directory, all LocalCall transform to RPC'],
+            ['  ignore       [ name ]  ', 'set a name for LocalCall do not transform to RPC, support string | array<string>'],
+            ['  http         [ json ]  ', 'HTTP server options, support flat name, ex: http.path=/api'],
+            ['  socketio     [ json ]  ', 'SocketIO server options, support flat name'],
+            ['  registry     [ urls ]  ', 'registry service url, support string | array<string>'],
+            ['  origin       [ urls ]  ', 'set', (0, chalk_1.bold) `*`, 'allow any connections <Access-Control-Allow-Origin>'],
+            ['  ...                    ', 'set params as', (0, chalk_1.bold) `foo=bar` + ',', 'usage as', (0, chalk_1.bold) `oox.config.foo`]
+        ];
+        params.forEach(row => console.log(...row, '\n'));
+        console.log();
+    }
+    if (isStartup)
+        (0, starter_1.startup)();
 }
-if (['help', '-h', '-help', '--help'].includes(command)) {
-    console.log((0, chalk_1.bold) `Usage:`);
-    console.log('  oox entry.js');
-    console.log();
-    console.log('  oox entry.js port=8080');
-    console.log();
-    console.log('  oox app/entry/index.js group=app/ env=envs/entry.js ignore=core');
-    console.log();
-    console.log((0, chalk_1.bold) `Params:`);
-    const params = [
-        ['  default-env  [ file ]  ', '.js or .json file, merge to oox.config'],
-        ['  env          [ file ]  ', '.js or .json file, merge to oox.config', (0, chalk_1.bold) `(after default-env)`],
-        ['  port         [ int  ]  ', 'set', (0, chalk_1.bold) `0`, 'for random port, or any integer > 0'],
-        ['  group        [ dir  ]  ', 'service group directory, all LocalCall transform to RPC'],
-        ['  ignore       [ name ]  ', 'set a name for LocalCall do not transform to RPC, support string | array<string>'],
-        ['  http         [ json ]  ', 'HTTP server options, support flat name, ex: http.path=/api'],
-        ['  socketio     [ json ]  ', 'SocketIO server options, support flat name'],
-        ['  registry     [ urls ]  ', 'registry service url, support string | array<string>'],
-        ['  origin       [ urls ]  ', 'set', (0, chalk_1.bold) `*`, 'allow any connections <Access-Control-Allow-Origin>'],
-        ['  ...                    ', 'set params as', (0, chalk_1.bold) `foo=bar` + ',', 'usage as', (0, chalk_1.bold) `oox.config.foo`]
-    ];
-    params.forEach(row => console.log(...row, '\n'));
-    console.log();
-}
-if (isStartup)
-    (0, starter_1.startup)();

package/bin/configurer.js

@@ -25,17 +25,30 @@ function mergeFlatEnv(env) {
         }
     }
 }
-function configure() {
-    let env = Object.create(null);
-    const defaultEnvPath = argv.getEnvArg('default-env');
-    if (defaultEnvPath && fs.existsSync(defaultEnvPath)) {
-        Object.assign(env, require(path.resolve(defaultEnvPath)));
+async function readEnvFile(filePath) {
+    let env = {};
+    if (filePath && fs.existsSync(filePath)) {
+        if (filePath.endsWith('.json')) {
+            const raw = fs.readFileSync(filePath, 'utf-8');
+            env = JSON.parse(raw);
+        }
+        else {
+            const finalPath = path.resolve(filePath).replace(/\\/g, '/');
+            env = await eval(`import('file://${finalPath}')`);
+        }
     }
-    const envPath = argv.getEnvArg('env');
-    if (envPath && fs.existsSync(envPath)) {
-        Object.assign(env, require(path.resolve(envPath)));
+    else {
+        throw new Error('Env file not found: ' + filePath);
     }
-    Object.assign(env, argv.getAllEnvArgs());
+    return env.default || env;
+}
+async function configure(mergeEnv) {
+    const env = Object.create(null);
+    const defaultEnvPath = argv.getEnvArg('default-env');
+    const targetEnvPath = argv.getEnvArg('env');
+    const defaultEnv = defaultEnvPath ? await readEnvFile(defaultEnvPath) : {};
+    const targetEnv = targetEnvPath ? await readEnvFile(targetEnvPath) : {};
+    Object.assign(env, defaultEnv, targetEnv, argv.getAllEnvArgs());
     mergeFlatEnv(env);
     if ('string' === typeof env.ignore)
         env.ignore = env.ignore.split(',');
@@ -44,6 +57,8 @@ function configure() {
     if ('string' === typeof env.origin && env.origin.includes(',')) {
         env.origin = env.origin.split(',');
     }
+    if (mergeEnv)
+        Object.assign(env, mergeEnv);
     return env;
 }
 exports.configure = configure;

package/bin/loader.mjs

@@ -0,0 +1,459 @@
+
+import path from 'node:path'
+
+import os from 'node:os'
+
+import fs from 'node:fs'
+
+import { get as httpGet } from 'node:http'
+
+import { get as httpsGet } from 'node:https'
+
+import oox from '../index.mjs'
+
+
+/**
+ * NodeJS versions < 16 dose not support loader chain
+ */
+const NodeJSBigVersion = +process.versions.node.split('.').shift()
+const useCompatLoader = NodeJSBigVersion < 16
+const compatLoaders = []
+if ( useCompatLoader ) {
+    const args = process.execArgv
+    let index = -1, size = args.length
+    let isLoaderTag = false
+    while ( ++index < size ) {
+
+        const symbol = args [ index ]
+
+        if ( isLoaderTag ) {
+
+            isLoaderTag = false
+
+            if ( 'oox/loader' === symbol ) break
+            
+            compatLoaders.push ( await import ( symbol ) )
+        }
+
+        if ( [ '--loader', '--experimental-loader' ].includes ( symbol ) ) {
+
+            isLoaderTag = true
+        }
+    }
+
+    compatLoaders.reverse ( )
+}
+
+
+
+function generateRPCProxyScript ( name, attributes = [ ] ) {
+
+    let attrExports = ''
+
+    for ( const attr of attributes ) {
+    
+        attrExports += `\nexport const ${attr} = proxyer.${attr}\n`
+    }
+    
+    const script = `
+import oox from 'oox'
+function RPC_${name} ( ) { }
+function dotCall ( name, action ) {
+	
+	return new Proxy ( RPC_${name}, {
+
+        get ( target, key ) {
+
+			return dotCall ( name, action ? action + '.' + key : key )
+		},
+		
+		has ( target, key ) { return true },
+		
+		apply ( target, thisArg, args ) {
+
+            return oox.rpc ( name, action, args )
+		}
+	} )
+}
+const proxyer = dotCall ( '${name}', '' )
+export default proxyer
+${attrExports}
+`
+
+    return script
+}
+
+
+
+function generateRPCProxyURL ( name, attributes ) {
+    
+    let searchText = ''
+
+    if ( attributes.length ) {
+
+        const search = new URLSearchParams ( )
+
+        for ( const attr of attributes ) {
+    
+            search.append ( 'attr', attr )
+        }
+
+        searchText = '?' + search.toString ( )
+    }
+
+    return `oox://rpc/${name}.mjs${searchText}`
+}
+
+
+
+function isWebURL ( url ) {
+
+    return url && ( url.startsWith ( 'https://' ) || url.startsWith ( 'http://' ) )
+}
+
+
+
+function isFileURL ( url ) {
+
+    return url && url.startsWith ( 'file://' )
+}
+
+
+
+function isOOXURL ( url ) {
+
+    return url && url.startsWith ( 'oox://' )
+}
+
+
+
+function pathCorrect ( path ) {
+
+    return os.platform ( ) === 'win32' && path.startsWith ( '/' ) ? path.replace ( '/', '' ) : path
+}
+
+
+
+/**
+ * make ESModule support dynamic <export *> attributes import
+ * @param {string} importerSpecifier the import url
+ * @param {string} specifier parentURL
+ * @returns {string[]}
+ */
+function getImportAttributes ( importerSpecifier, specifier ) {
+
+    const attributes = [ ]
+
+    const contents = fs.readFileSync ( importerSpecifier, 'utf-8' )
+
+    // import * as xxx from "xxx"
+    const mergeImport = contents.match ( new RegExp ( `import.+\\*\\s*as\\s+(\\w+)\\s+from\\s*["']${specifier}["']` ) )
+
+    if ( mergeImport ) {
+
+        const mergeName = mergeImport [ 1 ]
+
+        const attributesIterator = contents.matchAll ( new RegExp ( `${mergeName}\\s*\\.\\s*(\\w+)`, 'g' ) )
+
+        for ( const caseItem of attributesIterator ) {
+
+            attributes.push ( caseItem [ 1 ] )
+        }
+    }
+
+    // import { a, b, c } from 'xxx'
+    const attributeImport = contents.match ( new RegExp ( `import.+{(.+)}\\s*from\\s*["']${specifier}["']` ) )
+
+    if ( attributeImport ) {
+
+        const definedAttributes = attributeImport [ 1 ].split ( ',' ).map ( v => v.trim ( ) ).filter ( v => !v.startsWith ( 'default' ) )
+        
+        attributes.push ( ...definedAttributes )
+    }
+
+    return Array.from ( new Set ( attributes ) )
+}
+
+
+
+/**
+ * transform local call => RPC
+ * @param {string} originalSpecifier 
+ * @param {string} specifier 
+ * @param {string} parentURL 
+ * @returns 
+ */
+function ooxRPCImportTransform ( originalSpecifier, specifier, parentURL ) {
+
+    const { entryFile } = oox.config
+
+    const url = new URL ( specifier )
+
+    const groupURL = entryFile.group ? new URL ( '/' + entryFile.group, 'file://' ) : null
+
+    // OOX RPC Proxy URL generation
+    if ( !specifier.endsWith ( entryFile.path ) && groupURL && url.href.startsWith ( groupURL.href ) ) {
+
+        const subSpecifier = url.href.slice ( groupURL.href.length )
+
+        const matchResult = subSpecifier.match ( /^\/?([\w-]+)(\/index)?(\.((\w?js)|(ts\w?)))?$/ )
+
+        if ( matchResult ) {
+
+            const importerSpecifier = parentURL.replace ( os.platform ( ) === 'win32' ? /file:\/+/ : 'file://', '' )
+
+            const attributes = getImportAttributes ( importerSpecifier, originalSpecifier )
+
+            return { shortCircuit: true, url: generateRPCProxyURL ( matchResult [ 1 ], attributes ) }
+        }
+    }
+
+    return null
+}
+
+
+
+/**
+ * Directory import supported
+ * Ignored '.ts|.js' suffix import supported
+ * @param {string} specifier 
+ * @returns {string}
+ */
+function directoryImportTransform ( specifier ) {
+
+    let filename = new URL ( specifier ).pathname
+
+    if ( os.platform ( ) === 'win32' && filename.startsWith ( '/' ) ) {
+
+        filename = filename.replace ( '/', '' )
+    }
+
+    const stat0 = fs.statSync ( filename, {
+        throwIfNoEntry: false
+    } )
+
+    if ( !stat0 || stat0.isDirectory ( ) ) {
+
+        const justNeedEntry = stat0 && stat0.isDirectory ( )
+
+        const dirname = justNeedEntry ? filename : path.dirname ( filename )
+
+        const stat1 = justNeedEntry ? stat0 : fs.statSync ( dirname, {
+            throwIfNoEntry: false
+        } )
+
+        // find entry file
+        if ( stat1 && stat1.isDirectory ( ) ) {
+
+            const paths = filename.split ( '/' )
+
+            const filenameWithoutExtension = justNeedEntry ? 'index' : paths.pop ( )
+
+            const matchEntryRegExp = new RegExp ( `^${filenameWithoutExtension}\\.((\\w?js)|(ts\\w?))$` )
+
+            const entries = fs.readdirSync ( dirname )
+
+            for ( const entry of entries ) {
+
+                if ( !matchEntryRegExp.test ( entry ) ) continue
+
+                paths.push ( entry )
+
+                specifier = 'file://' + paths.join ( '/' )
+
+                break
+            }
+        }
+    }
+
+    return specifier
+}
+
+
+
+/**
+ * @param {string} specifier
+ * @param {{
+ *   conditions: string[],
+ *   parentURL: string | undefined,
+ * }} context
+ * @param {Function} defaultResolve
+ * @returns {Promise<{ url: string }>}
+ */
+export async function resolve ( specifier, context, defaultResolve ) {
+
+    const originalSpecifier = specifier
+
+    const { parentURL } = context
+
+    // HTTP & HTTPS
+    if ( isWebURL ( specifier ) ) {
+
+        return { shortCircuit: true, url: specifier }
+    } else if ( isWebURL ( parentURL ) && ( specifier.startsWith ( '.' ) || specifier.startsWith ( '/' ) ) ) {
+
+        return { shortCircuit: true, url: new URL ( specifier, parentURL ).href }
+    }
+
+    // OOX special alias for web package
+    if ( specifier === 'oox' && !isFileURL ( parentURL ) ) {
+
+        return {
+            shortCircuit: true,
+            url: await import.meta.resolve ( specifier )
+        }
+    }
+
+    if ( !isFileURL ( specifier ) ) {
+
+        try {
+
+            specifier = defaultResolve ( specifier, context, defaultResolve ).url
+        } catch ( error ) {
+
+            if ( !isFileURL ( parentURL ) ) throw error
+
+            const _specifier = directoryImportTransform ( new URL ( specifier, parentURL ).href )
+
+            if ( _specifier === specifier ) throw error
+
+            specifier = _specifier
+        }
+    }
+
+    const ooxRPCTransform = ooxRPCImportTransform ( originalSpecifier, specifier, parentURL )
+
+    if ( ooxRPCTransform ) return ooxRPCTransform
+
+    if ( useCompatLoader ) {
+
+        const iterator = compatLoaders.values ( )
+
+        const { value } = iterator.next ( )
+
+        if ( value ) {
+
+            return value.resolve ( specifier, context, ( specifier, context, nextResolve ) => {
+
+                const { value } = iterator.next ( )
+
+                if ( value ) return value.resolve ( specifier, context, nextResolve )
+
+                return defaultResolve ( specifier, context, defaultResolve )
+            } )
+        }
+    }
+
+    return defaultResolve ( specifier, context, defaultResolve )
+}
+
+
+
+/**
+ * @param {string} url
+ * @param {{
+ *   format: string,
+ * }} context If resolve settled with a `format`, that value is included here.
+ * @param {Function} defaultLoad
+ * @returns {Promise<{
+ *   format: string,
+ *   source: string | ArrayBuffer | SharedArrayBuffer | Uint8Array,
+ * }>}
+ */
+export async function load ( url, context, defaultLoad ) {
+
+    if ( isWebURL ( url ) || isOOXURL ( url ) ) {
+
+        return getSource ( url, context, defaultLoad )
+    }
+
+    if ( useCompatLoader ) {
+
+        const iterator = compatLoaders.values ( )
+
+        const { value } = iterator.next ( )
+
+        if ( value ) {
+
+            return value.load ( url, context, ( url, context, nextLoad ) => {
+
+                const { value } = iterator.next ( )
+
+                if ( value ) return value.load ( url, context, nextLoad )
+
+                return defaultLoad ( url, context, defaultLoad )
+            } )
+        }
+    }
+
+    return defaultLoad ( url, context, defaultLoad )
+}
+
+
+
+export function getFormat ( url, context, defaultGetFormat ) {
+
+    if ( isWebURL ( url ) || isOOXURL ( url ) ) {
+
+        return {
+            format: 'module'
+        }
+    }
+
+    if ( useCompatLoader ) {
+
+        const iterator = compatLoaders.values ( )
+
+        const { value } = iterator.next ( )
+
+        if ( value ) {
+
+            return value.getFormat ( url, context, ( url, context, nextGetFormat ) => {
+
+                const { value } = iterator.next ( )
+
+                if ( value ) return value.getFormat ( url, context, nextGetFormat )
+
+                return defaultGetFormat ( url, context, defaultGetFormat )
+            } )
+        }
+    }
+
+    return defaultGetFormat ( url, context, defaultGetFormat )
+}
+
+
+
+export function getSource ( url, context, defaultGetSource ) {
+
+    if ( isWebURL ( url ) ) {
+
+        const getMethod = url.startsWith ( 'https://' ) ? httpsGet : httpGet
+
+        return new Promise ( ( resolve, reject ) => getMethod ( url, res => {
+            let source = ''
+            res
+            .on ( 'data', chunk => source += chunk )
+            .on ( 'end', () => resolve ( { shortCircuit: true, format: 'module', source } ) )
+        } ).on ( 'error', reject ) )
+    } else if ( isOOXURL ( url ) ) {
+
+        const mURL = new URL ( url )
+
+        if ( mURL.host === 'rpc' ) {
+
+            const regexp = /\/([\w-]+)\.mjs$/
+
+            const matchResult = mURL.pathname.match ( regexp )
+
+            // read all import attributes
+            const attributes = mURL.searchParams.getAll ( 'attr' )
+        
+            const source = generateRPCProxyScript ( matchResult [ 1 ], attributes )
+
+            return { shortCircuit: true, format: 'module', source }
+        }
+    }
+  
+    return defaultGetSource ( url, context, defaultGetSource )
+}

package/bin/proxyer.js

@@ -21,14 +21,14 @@ function rewriteModuleCache(id, exports) {
     m.paths = paths;
     require.cache[id] = m;
 }
-function dotCall(name, paths = []) {
+function dotCall(name, action) {
     return new Proxy(function () { }, {
         get(target, key) {
-            return dotCall(name, paths.concat(key));
+            return dotCall(name, action ? action + '.' + key : key);
         },
         has(target, key) { return true; },
         apply(target, thisArg, args) {
-            return oox.rpc(name, paths.join('.'), args);
+            return oox.rpc(name, action, args);
         }
     });
 }
@@ -44,18 +44,23 @@ function proxyGroup(groupDirectory, excludes = []) {
         const fullPath = path.resolve(directory + path.sep + filename);
         const stat = fs.statSync(fullPath);
         let id = '', name = '';
-        if (stat.isDirectory() && fs.existsSync(fullPath + '/index.js')) {
-            id = fullPath + '/index.js';
+        if (stat.isDirectory()) {
+            const entries = fs.readdirSync(fullPath);
+            for (const entry of entries) {
+                if (/^index\.((\w?js)|(ts\w?))$/.test(entry))
+                    id = path.resolve(fullPath, entry);
+            }
             name = filename;
         }
-        else if (filename.endsWith('.js')) {
+        else {
+            const scriptMatch = filename.match(/(\w+)\.((\w?js)|(ts\w?))$/);
+            if (!scriptMatch)
+                continue;
             id = fullPath;
-            name = filename.split('.js')[0];
+            name = scriptMatch[1];
         }
-        else
-            continue;
         if (!excludes.includes(name))
-            rewriteModuleCache(id, dotCall(name));
+            rewriteModuleCache(id, dotCall(name, ''));
     }
 }
 exports.proxyGroup = proxyGroup;