Online Webpack Service
global.BrowserFS= require('browserfs');
var fs_server = require('fs')
var fs = fs_server
var path = require('path');
var find = require('findit');
var fx = require('mkdir-recursive');
const debug=require('debug');
debug('app');
console.log(process.env);
var o={
db: {
location : './mydb'
},
defaultConfigUrl : 'https://api.frdl.de/app/webfantize/package/config/preset/frdl.webfantize.fixtures.patch.webfanpack-js',
alias:{
// 'frdlweb':'@frdl/monkeyism/shims/common.browser.js',
// 'browserfs' : 'codesandbox-browserfs',
// 'fs': 'browserfs/dist/shims/fs.js',
// 'process':'codesandbox-browserfs/dist/shims/process.js',
//'fs': 'browserfs/dist/shims/fs.js',
'buffer': 'browserfs/dist/shims/buffer.js',
'path': 'browserfs/dist/shims/path.js',
// 'processGlobal': 'browserfs/dist/shims/process.js',
// 'bufferGlobal': 'browserfs/dist/shims/bufferGlobal.js',
// 'bfsGlobal': 'browserfs',
// 'BrowserFS':'browserfs'
// 'vm': 'vm2'
},
optionsTimeout:{
// Optional. This will be the default timeout for all endpoints.
// If omitted there is no default timeout on endpoints
timeout: 900000,
// Optional. This function will be called on a timeout and it MUST
// terminate the request.
// If omitted the module will end the request with a default 503 error.
onTimeout: function(req, res) {
res.status(503)
.send(`<h1>Timeout requesting '${req.host}${req.url}' or not found!</h1>`
+ `<a href="${req.host}${req.url}">retry...</a><br />`
+ `<a href="/">CDN Home</a><br />`
+ `<br /><br />`
// + `${JSON.stringify(req.EXTRA)}<br />`
);
},
// Optional. Define a function to be called if an attempt to send a response
// happens after the timeout where:
// - method: is the method that was called on the response object
// - args: are the arguments passed to the method
// - requestTime: is the duration of the request
// timeout happened
onDelayedResponse: function(req, method, args, requestTime) {
console.log(`Attempted to call ${method} after timeout`);
},
// Optional. Provide a list of which methods should be disabled on the
// response object when a timeout happens and an error has been sent. If
// omitted, a default list of all methods that tries to send a response
// will be disable on the response object
disable: ['write', 'setHeaders', 'send', 'json', 'end']
},//optionsTimeout
handle404 : function(req, res) {
res.status(404)
.send(`<h1>404 - '${req.host}${req.url}' NOT FOUND!</h1>`
+ `<a href="${req.host}${req.url}">retry...</a><br />`
+ `<a href="/">CDN Home</a><br />`
+ `<br /><br />`
// + `${JSON.stringify(req.EXTRA)}<br />`
);
},
corsWhitelist: ['*',
'https://frdl.io',
'https://cdn.frdl.io',
'https://cdn.webfan.de',
'https://*.webfan.de',
'https://*.webfan.website',
'https://*.domainundhomepagespeicher.de',
'https://webfan.io',
'https://frdl.ws',
'https://*.frdl.ws',
'https://frdl.de',
'https://*.frdl.de'
]
};
var chmodr = require('chmodr');
if(!forceWritableDirectory(o.db.location)){
throw new Error('LevelDB dir "'+o.db.location+'" is not available!');
}else{
console.log('LevelDB dir "'+o.db.location+'" is available...');
}
var levelup = require('levelup');
var leveldown = require('leveldown');
const DB_ERRORS = levelup.errors;
// 1) Create our store
var db = levelup(leveldown(o.db.location));
const canonicalize = require('canonicalize');
var whitelist = o.corsWhitelist;
var corsOptionsDelegate = function (req, callback) {
var corsOptions;
if (whitelist.indexOf('*') !== -1 || whitelist.indexOf(req.header('Origin')) !== -1) {
corsOptions = { origin: true } // reflect (enable) the requested origin in the CORS response
} else {
corsOptions = { origin: false } // disable CORS for this request
}
callback(null, corsOptions) // callback expects two parameters: error and options
}
var corsOptions = {
origin: '*',
optionsSuccessStatus: 200 // some legacy browsers (IE11, various SmartTVs) choke on 204
}
///var AllOfThem = require('all-of-them');
var optionsTimeout = o.optionsTimeout;
var Application = exports = (module && module.exports) ? module.exports : {};
var jsCode = `
exports=module.exports=new Error('Code not set in webfantized-webpack');
`;
//var SourceReader = require("source");
global.intercept = require('express-mung');
console.log(intercept);
// app.use(intercept.send((chunk, req, res) => this.cacheSet(req.cacheKey, chunk)))
// Any requests after this will be stored in cache.
// TODO: figure out if I should homogenize requests by invoking hydrate here
// app.use(intercept.json((json, req, res) => this.cacheSet(req.cacheKey, json)))
// json is not needed since it invokes send on its own.
//app.use(intercept.write((buffer, encoding, req, res) => this.cacheSet(req.cacheKey, buffer)))
function __PATCH_CACHE_INTERCEPTOR(app){
if('undefined'===typeof global.intercept.send ){
global.intercept.send = function send(fn){
return function cacheInterceptor(chunk, req,res,next){
fn.apply(this, [chunk, req, res]);
next();
}.bind(app);
};
}else{
app.use(global.intercept.send.bind(app)(global.intercept.send.bind(app)));
}
return app;
}
const __TEMP_DIR__ = require('temp-dir');
console.log(__TEMP_DIR__);
var sha1 = require('sha1');
const cors = require('cors');
const cookieParser = require('cookie-parser');
const timeout = require('express-timeout-handler');
var etag = require('etag');
const ExpressCache = require('express-cache-middleware');
const cacheManager = require('cache-manager');
const fsHashStore = require('cache-manager-fs-hash');
const fileType = require('file-type');
var fx = require('mkdir-recursive');
var chmodr = require('chmodr');
var Base64 = require('js-base64');
var b64 = require('url-safe-base64');
var {
encode, decode, trim,
isBase64, isUrlSafeBase64
} = b64;
const Module = require('module')
const os = require('os')
const express = require('express')
//require('node-libs-browser'); // explicit import for runkit.com
var webpack = require('webpack');
var { Plugin } =webpack;
//var webpackSandboxed =require('webpack-sandboxed');
//var webpackSandboxed =require('webpack-sandboxed');//.default;
var webpackSandboxed =require('webpack-sandboxed');//.default;
const UglifyJsPlugin = require('uglifyjs-webpack-plugin');
const { CachedInputFileSystem, ResolverFactory } = require("enhanced-resolve");
var VirtualModulesPlugin = require('webpack-virtual-modules');
const { WebpackManifestPlugin } =require('webpack-manifest-plugin');
var DirectoryNamedWebpackPlugin = require("directory-named-webpack-plugin");
var ExtractTextPlugin = require('extract-text-webpack-plugin');
const MiniCssExtractPlugin = require('mini-css-extract-plugin');
const SmartBannerPlugin = require('smart-banner-webpack-plugin');
const babel=require('@babel/core');
//const fs_browser=require('codesandbox-browserfs');
const babelLoader= require('babel-loader');
const readdirCluster = require('readdir-cluster')
var bodyParser = require('body-parser');
//dependenciesBrowser()
var dl = require('@frdl/simple-downloader');
var RequireHelper = require('@frdl/custom-require');
var webfan = require("@frdl/webfan");
var NpmInstallPlugin = require("npm-install-webpack-plugin");
var memfs = require('memfs');
var { vol, Volume } = memfs
var { patchFs, patchRequire } = require('fs-monkey')
var { VM, NodeVM, VMScript } = require('vm2')
var unionfs = require('unionfs')
global.BrowserFS= require('browserfs');
const fs_browser=require('codesandbox-browserfs/dist/shims/fs.js');
var expressCacheDir = path.resolve(__TEMP_DIR__,//__dirname,
'express-server-cache-'
//+ etag(JSON.stringify(require('./config/cdn-list.json'))).replace(/"/, '')
+ 'asfaf'
);
var url=require("url");
console.log('Start booting endpoint application...' );
db.on('ready', function () {
console.log('db,isOpen', db.isOpen() );
});
var app = Application.app = makeApp(Application);
console.log('Application.app : ',app);
console.log('App started.' );
console.log('Start Testings...' );
(async ()=>{
process.nextTick(async ()=>{
//DEBIAN_FRONTEND: "noninteractive"
if("noninteractive"===process.env.DEBIAN_FRONTEND){
var baseUrlEndpointRunkit = process.env.RUNKIT_ENDPOINT_URL;
console.log(baseUrlEndpointRunkit);
// console.log( process.env.RUNKIT_ENDPOINT_URL);
///webpack/bW9kdWxlLmV4cG9ydHM9NDI/path,url/code/
var testUrl = baseUrlEndpointRunkit + '/webpack/bW9kdWxlLmV4cG9ydHM9NDI/url/code/';
dl(testUrl).then(testresult=>{
console.log(testUrl, testresult.data.toString());
});
}
});
})();
function readFilesFromPackage(name) {
var pkgdir = path.dirname(require.resolve(name + '/package.json'));
var pkg = JSON.parse(fs.readFileSync(pkgdir + '/package.json', 'utf8'));
var main = require.resolve(name);
var modules = {};
modules[name] = fs.readFileSync(main);
modules[name + '/package.json'] = pkg;
if (pkg.directories && pkg.directories.lib) {
var libdir = path.resolve(pkgdir, pkg.directories.lib);
find.sync(libdir)
.filter(function (lib) {
return lib.match(/\.js$/)
&& path.resolve(libdir, lib) !== main
&& !path.basename(lib).match(/^\./)
;
})
.forEach(function (lib) {
var src = fs.readFileSync(lib);
var p = lib.slice(libdir.length)
.replace(/\.js$/,'');
modules[name + '/lib' + p] = src;
})
;
}
else if (fs.existsSync(pkgdir + '/lib')) {
find.sync(pkgdir + '/lib')
.filter(function (lib) {
return lib.match(/\.js$/)
&& path.resolve(pkgdir + '/lib', lib) !== main
&& !path.basename(lib).match(/^\./)
;
})
.forEach(function (lib) {
var src = fs.readFileSync(lib);
var p = lib.slice((pkgdir + '/lib').length)
.replace(/\.js$/,'');
modules[name + '/lib' + p] = src;
})
;
}
var bins = [ pkg.bin, pkg.directories && pkg.directories.bin ]
.map(function (bin) {
return bin && (pkgdir + '/' + bin)
})
.filter(function (bin) {
return fs.existsSync(bin)
})
;
fs.readdirSync(pkgdir)
.filter(function (file) {
return file.match(/\.js$/)
&& !path.basename(file).match(/^\./)
&& bins.indexOf(pkgdir + '/' + file) < 0
&& pkgdir + '/' + file !== main
;
})
.forEach(function (file) {
var p = name + '/' + file.replace(/\.js$/, '');
modules[p] = fs.readFileSync(pkgdir + '/' + file);
})
;
return modules;
}
async function getVolume(dir){
var ServerClusterFs = await fetchAllServerFilesForVirtualFs(
dir,
// __dirname,
fs_server
)
//.then(console.log)
.catch(console.error)
var filesStructure = {};
for(var p in ServerClusterFs){
if('string'!==typeof ServerClusterFs[p].contents)continue;
filesStructure[p] = ServerClusterFs[p].contents;
}
var vol = Volume.fromJSON(filesStructure);
return vol;
}
function main(_code, __packages, req, res, next) {
//__packages.push('babel-loader');
//__packages.push('process');
//patchFs(VirtualFilesystem);
//patchRequire(VirtualFilesystem);
//Application.config['config.$plug'][0].modules.sandbox;
//console.log('require.cache',require.cache);
//console.log('webpack.Module',webpack.Module);
return new Promise(async function(resolve,reject){
var VirtualFilesystem = new unionfs.Union();
var serverVolume = memfs.createFsFromVolume(fs_server);
var ServerClusterFs = await fetchAllServerFilesForVirtualFs(
path.resolve(process.cwd(), '.'),
// __dirname,
fs_server
)
//.then(console.log)
.catch(console.error)
//console.log('Object.keys(require.cache)',Object.keys(require.cache));
//console.log('require.cache',require.cache);
var filesStructure = {};
for(var p in ServerClusterFs){
if('string'!==typeof ServerClusterFs[p].contents)continue;
filesStructure[p] = ServerClusterFs[p].contents;
}
for(var c in require.cache){
if('string'!==typeof require.cache[c].filename)continue;
filesStructure[require.cache[c].filename] = (fs_server.readFileSync(require.cache[c].filename)).toString();
}
var workspaceVolume = Volume.fromJSON(filesStructure);
VirtualFilesystem.use(serverVolume);
VirtualFilesystem.use(fs_server);
VirtualFilesystem.use(workspaceVolume);
VirtualFilesystem.use(fs_browser);
/// Application.VirtualFilesystem=VirtualFilesystem;
const inc1_filename = '/app/main.inc1.js' ;
const inc1 = `
// global.BrowserFS= require('browserfs');
`;
VirtualFilesystem.use(Volume.fromJSON({
'/app/main.inc1.js' : inc1
}));
var configResponse = await dl(o.defaultConfigUrl);
var config=Application.config=configResponse.data;
__packages = __packages.map(p=>{
return (-1!==Application.config['config.$plug'][0].modules.whitelist.indexOf(p)) ? p : false;
});
while(0<__packages.length){
var p = __packages.shift();
if(-1!==Application.config['config.$plug'][0].modules.whitelist.indexOf(p)
&& -1===Application.config['config.$plug'][0].modules.sandbox.indexOf(p)
) {
Application.config['config.$plug'][0].modules.sandbox.push(p);
}else{
if('undefined'===typeof res.headers){
res.headers=[];
}
if(!res.headers.warning){
res.headers.warning=[];
}
res.headers.warning.push(`Module ${p} is not whitelistet and cannot be installed!`);
}
}
Application.config['config.$plug'][0].modules.sandbox.push('webpack');
var InstallPlugin = new NpmInstallPlugin({
// Use --save or --save-dev
dev: true,
// Install missing peerDependencies
peerDependencies: false,
// Reduce amount of console logging
quiet: false,
// npm command used inside company, yarn is not supported yet
npm: 'npm'
});
// console.log(InstallPlugin);
Application.config['config.$plug'][0].modules.sandbox.forEach(m=>{
// NpmInstallPlugin,prototype.install(m);
});
var modulesFolders = [
path.resolve(process.cwd(),'/app'),
// '/',
'/app/available_modules'
//'node_modules',
// path.resolve(process.cwd(),__dirname),
// process.cwd(),
// path.resolve(process.cwd(),'/app/available_modules'),
// path.resolve(process.cwd(),'/app/system'),
// path.resolve(process.cwd(),process.env.HOME)
].reverse();
Module.globalPaths.forEach(p=>{
modulesFolders.push(p);
});
process.env.PATH.split(/\:/).forEach(d=>{
modulesFolders.push(d);
});
for(var k in modulesFolders){
// VirtualFilesystem.use(getVolume(modulesFolders[k]), path.dirname(modulesFolders[k]));
}
// for(var k in [
// process.cwd()
//]){
// VirtualFilesystem.use(getVolume(modulesFolders[k]));
// }
var virtualModules = new VirtualModulesPlugin(filesStructure);
const productionPlugins= [
//new ExtractTextPlugin('[id].[name].[contenthash].bundle.css'),
// new MiniCssExtractPlugin({
// filename: '[id].[name].[contenthash].bundle.css'
// }),
// MiniCssExtractPlugin.getCssModule(webpack),
// InstallPlugin,
new SmartBannerPlugin(
{
banner: `[filename] \n`
+ `\nFetched from : cdn.frdl.io`
+ `\nPowered by Runkit : https://runkit.com/frdl/webfan-pack`
+ `\nDate: ${new Date().toLocaleString()}\n`,
raw: false,
entryOnly: false
}),
virtualModules,
new webpack.ProvidePlugin({
// 'BrowserFS':'BrowserFS',
// 'process': ['codesandbox-browserfs/dist/shims/process.js']//,
// 'frdlweb': ['@frdl/monkeyism/shims/common.browser.js']
}),
new webpack.DefinePlugin({
'process.env.NODE_ENV': JSON.stringify('production')
})//,
// new WebpackManifestPlugin({ writeToFileEmit: true })
// ,new UglifyJsPlugin()
];
const plugins= [
...productionPlugins
];
const CustomModulesResolverPlugin = ResolverFactory.createResolver({
alias: o.alias,
// Typical usage will consume the `fs` + `CachedInputFileSystem`, which wraps Node.js `fs` to add caching.
fileSystem: VirtualFilesystem,
extensions: [".js", ".ts", '.ts', '.css', ".json"]
/* any other resolver options here. Options/defaults can be seen below */
});
// patchFs(VirtualFilesystem);
//patchRequire(VirtualFilesystem);
unionfs.ufs
.use(VirtualFilesystem);
/**
const sandbox = await webpackSandboxed.default(options);
console.log(sandbox);
//var runner = new webpackSandboxed.WebpackRunner(MemoryFS, options);
console.log( sandbox.memfs );
console.log( sandbox.config );
var runner = new webpackSandboxed.WebpackRunner(
sandbox.memfs ,
sandbox.config
);
console.log('runner', runner )
console.log('runner', runner.run )
const [bundle, stats] = runner.run("module.exports = {foo: 'bar'};");
**/
// const code = `module.exports = () => 42;`;
const sandbox = await webpackSandboxed.default( /*unionfs.ufs,*/{
// const sandbox = await webpackSandboxed( fs_server,{
//const sandbox = await webpack( {
config: {
/// context :process.cwd(),
/// context:'/',
target: 'web',
/* */
entry:{
webfan: Application.config['config.$plug'][0]["@"]
},
output: {
chunkFilename: '[id].[name].[hash].js',
path: '/app/dist',
filename: '[id].[name].[contenthash].bundle.js',
library: 'webfan',
libraryTarget: 'umd'
},
plugins : plugins,
cache: {
type: 'memory'
},
/* cache:false, */
resolve: {
modules: modulesFolders,
extensions: [".js", ".ts", '.ts', '.css', ".json"],
// modules: modulesFolders,
// root : modulesFolders,
// Use our versions of Node modules
alias: o.alias,
plugins:[
CustomModulesResolverPlugin,
InstallPlugin
]
},
module: {
noParse: /browserfs\.js/,
rules: [
{
test: /\.css$/i,
use: [MiniCssExtractPlugin.loader, 'css-loader'],
},
{
test: /\.json/i,
loader: 'json',
},
{
test: /\.js$/,
exclude: /node_modules/,
// loader: 'babel-loader',
use: {
loader: 'babel-loader',
options: {
plugins: [
"@babel/plugin-syntax-dynamic-import",
[
"@babel/plugin-transform-runtime",
{
"absoluteRuntime": false,
"corejs": false,
"helpers": true,
"regenerator": true,
"useESModules": true
}
]
],
presets: [
'es2015',
[
'@babel/preset-env',
{
targets: {
esmodules: true
},
}
]
],
babelrc: true
}
}/*,
options: {
modules: true,
plugins: [
"@babel/plugin-syntax-dynamic-import",
[
"@babel/plugin-transform-runtime",
{
"absoluteRuntime": false,
"corejs": false,
"helpers": true,
"regenerator": true,
"useESModules": true
}
]
],
presets: [
'es2015',
'react',
[
'@babel/preset-env',
{
targets: {
esmodules: true
},
}
]
],
babelrc: true
}*/
}/*,
{
test: /\.css$/,
//use: ExtractTextPlugin.extract({
use: plugins[0].extract({
fallback: 'style-loader',
use: {
loader: 'css-loader',
options: {
modules: true
}
}
})
} */
]
},
externals: {
// 'process':'process/browser.js'//,
// 'frdlweb':'@frdl/monkeyism/shims/common.browser'
},
plugins:plugins
},
// ,
packages: Application.config['config.$plug'][0].modules.sandbox,
// Packages to load into the virtual filesystem.
// Local files to load into the virtual filesystem.
includes: [inc1_filename
// , 'webpack/buildin/global.js'
// , 'webpack/buildin/module.js'
],
// For module resolution to work, the base directory needs to be equal to
// the parent directory of node_modules where all necessary packages are installed.
// basedir:process.cwd()
// basedir:'/'
basedir:'/'
}).catch(reject)
;
// const projectFileSystem = memfs.createFsFromVolume(VirtualFilesystem);
// Todo remove when we drop webpack@4 support
// outputFileSystem.join = path.join.bind(path);
//sandbox.inputFileSystem = VirtualFilesystem;
sandbox.inputFileSystem = unionfs.ufs;
// sandbox.outputFileSystem =VirtualFilesystem;
sandbox.outputFileSystem =fs_browser;
console.log( sandbox );
var runner = new webpackSandboxed.WebpackRunner(
sandbox.memfs ,
sandbox.config
);
console.log( runner );
// patchFs(VirtualFilesystem);
// patchRequire(VirtualFilesystem);
// sandbox.outputFileSystem =memfs.createFsFromVolume(VirtualFilesystem);
// console.log( sandbox.compile(code), resolve );
// return sandbox;
//resolve(sandbox);
// try{
// var code =(isBase64(_code) || isUrlSafeBase64(_code)|| !/[\s|\{|\}|\;|\,|\.]/.test(_code) )
// ? decode(_code) : _code;
// }catch(fehler){
// var code =Buffer.from(_code, 'base64').toString('ascii') ;
// }
var code =(isBase64(_code) || isUrlSafeBase64(_code) || !(/([\s|\{|\}|\;|\,|\.])/.test(_code)))
? decode(_code) : _code;
// const [bundle, stats] =
// sandbox.run(code || jsCode).then(packed=>{
//sandbox.run(code || jsCode).then(packed=>{
const packed = runner.run(code || jsCode);
const [bundle, stats] = packed;
console.log('[bundle, stats]',[bundle, stats]);
//resolve([bundle,stats]);
const key = Object.keys(bundle)[0];
const compiled = bundle[key];
// resolve(compiled);
// return compiled;
// const vm = new VM({
// timeout: 30 * 60* 1000,
// sandbox: {
// fs : fs_browser
// }
// });
// const exported = eval(compiled);
// const exported = vm.run(compiled);
resolve({
key:key,
bundle:bundle,
stats:stats,
compiled:compiled//,
// exported:exported
});
// });
}).catch(next);
}
function fetchAllServerFilesForVirtualFs(dir,fs=require('fs')){
return new Promise(async(resolve,reject)=>{
const paths = {};
function DirectoryIterator(fullPath, relativePath, statObject) {
if (statObject.directory && relativePath[0] === '.') {
return false // do not delve deeper into hidden paths
}
if(paths.length===0)console.log('statObject',statObject);
// paths.push(fullPath)
if (false===statObject.directory ){
paths[fullPath]={root:dir, path: relativePath, stat: statObject};
paths[fullPath].contents = (fs.readFileSync(fullPath)).toString()
return true;
}else{
return true;
}
}
readdirCluster(dir, DirectoryIterator, function (err) {
if (err) {
//throw err
reject(err);
}else{
console.log('completed successfully paths:', paths)
resolve(paths);
}
});
});
}
function requireFromString(code, filename, opts, Module) {
// var path = require('path');
if (typeof filename === 'object') {
opts = filename;
filename = undefined;
}
if (typeof Module === 'undefined') {
var Module = require('module');
}
opts = opts || {};
filename = filename || '';
opts.appendPaths = opts.appendPaths || [];
opts.prependPaths = opts.prependPaths || [];
if (typeof code !== 'string') {
throw new Error('code must be a string, not ' + typeof code);
}
var paths = Module._nodeModulePaths(path.dirname(filename));
var parent = module.parent;
var m = new Module(filename, parent);
m.filename = filename;
m.paths = [].concat(opts.prependPaths).concat(paths).concat(opts.appendPaths);
m._compile(code, filename);
var exports = m.exports;
parent && parent.children && parent.children.splice(parent.children.indexOf(m), 1);
return exports;
}
function handlePathsLogger(err, paths) {
if(err){
return ((e)=>{throw e;})(err)
}
var relPaths = paths.map(curPath => {
return path.relative('~/', curPath);
});
relPaths = relPaths.sort();
console.log('paths', paths);
console.log('relPaths', relPaths);
}
function dependencies(){
/*
require('@frdl/eventemitter');
require('ready');
require('@babel/preset-env');
require('co');
require('@types/memory-fs');
require('memory-fs');
require('resolve');
require('express');
require('@types/debug');
require('@types/extract-text-webpack-plugin');
require('@types/jest');
require('@types/resolve');
require('@types/webpack');
require('@babel/core');
require('@types/debug');
require('@types/extract-text-webpack-plugin');
require('@types/jest');
require('@types/resolve');
require('@types/webpack');*/
// require('@babel/core');
// require('babel-preset-es2015');
// require('babel-preset-react');
}
function dependenciesBrowser(){
require('@babel/core');
require('node-libs-browser');
require('babel-core');
require('process');
require('babel-loader');
require('babel-preset-es2015');
require('babel-preset-react');
require('css-loader');
require('json-loader');
}
function dependenciesBrowserWeb(){
require('insertion-query');
require('on-idle');
require('process')
}
function runkitExpress(anExport, baseMount, baseApp)
{
var mount =baseMount || express();
var app = baseApp || express();
// app.use(timeout.handler(optionsTimeout));
// "mount" is our root app, and it mounts "app" at your notebook path
// which is available in the RUNKIT_MOUNT_PATH environment variable
mount.use(process.env.RUNKIT_MOUNT_PATH || "", app);
if (anExport) {
anExport.endpoint = mount;
}
// overwrite .listen since it is not needed
app.listen = function(){}
// return the express instance for use by the caller
return app;
}
function addFirstApplicationMidlewareHandlers(baseApp){
var app = baseApp;
// var MOD = 0755;
// var DMOD = 0777;
const cacheMiddleware = new ExpressCache(
cacheManager.caching({
store: 'memory',//fsHashStore,//
options: {
//dir: expressCacheDir,
ttl: 3600, //time to life in seconds
// subdirs: true, //create subdirectories to reduce the
max: 2 * 60 * 60 * 1000
//files in a single dir (default: false)
// zip: true //zip files to save diskspace (default: false)
}
}), {
hydrate: (req, res, data, cb) => {
var guess = false;
// Use file-type library to guess MIME type from Buffer.
//const guess = fileType.fromBuffer(data.slice(0, 4101))
try{
var guess = fileType.fromBuffer(data.slice(0, 4101))
}catch(e){
try{
var guess = fileType.fromFile(req.url)
}catch(e2){
var guess={
mime : res.headers['content-type']
};
}
}
//const guess = fileType.fromBuffer(res.body)
//res.json(guess);
if( guess && guess.mime) {
res.contentType(guess.mime)
}
cb(null, data)
}
}
);
//requireTools.extensions();
cacheMiddleware.attach(__PATCH_CACHE_INTERCEPTOR(app));
/*
(()=>{
var MOD = 0777;
var DMOD = 0777;
if (!fs.existsSync(expressCacheDir)) {
fx.mkdirSync(expressCacheDir);
}
if (!fs.existsSync(expressCacheDir)) {
throw new Error('Directory ' + expressCacheDir +'does not exist');
}
try{
chmodr.sync(expressCacheDir, MOD);
}catch(e){
console.warn(e);
}
try{
fs.chmodSync(expressCacheDir,DMOD);
}catch(e){
console.warn(e);
}
})();
*/
app.disable('x-powered-by');
app.options('*', cors(corsOptionsDelegate)) ;//app.use(cors(corsOptions));
app.use(cors(corsOptions));
app.use(timeout.handler(optionsTimeout));
app.use(cookieParser());
app.use(bodyParser.json()); // support json encoded bodies
app.use(bodyParser.urlencoded({ extended: true })); // support encoded bodies
//cacheMiddleware.attach(app);
return app;
}
function __cacheKey(name, method, params){
return 'ck_' + sha1(
canonicalize({
method : name,
httpmethod : method,
params :canonicalize(params)
})
);
}
function wrapMainWebfanpack(req, res, next, mode, code, __packages){
return new Promise(async (RootResolve,RootReject)=>{
console.log( 'db.isOpen', db.isOpen() );
// db.on('ready', async function(){
if(! db.isOpen()){
console.log( 'db', db );
}
var KEY = __cacheKey('handler_webfanpack_'+req.method.toLowerCase(), req.method, {
mode:mode,
packages:__packages,
code:code
});
var result = await new Promise((resolve,reject)=>{
db.get(KEY)
.catch(function (err) {
resolve(err);
}).then(function (r) {
resolve(r);
});
}).catch(function (err) {
throw new Error(err);
}) .then(function (r) {
return r;
});
/*
t.ok(err instanceof Error)
t.ok(err instanceof DB_ERRORS.LevelUPError)
t.ok(err instanceof DB_ERRORS.NotFoundError)
t.is(err.notFound, true, 'err.notFound is `true`')
t.is(err.status, 404, 'err.status is 404')
t.ok(/\[undefkey\]/.test(err))
done()
*/
if(result instanceof Error
&& result instanceof DB_ERRORS.LevelUPError
&& result instanceof DB_ERRORS.NotFoundError
&& true === result.notFound
&& 404 === result.status){
result = await main(code, __packages, req, res, next)
.catch(RootReject)
.then(function (r) {
db.put(KEY, r)
.then(function () {
return db.get(KEY, { asBuffer: false })
})
.then(function (value) {
console.log('some value stored in the database', {
key : KEY,
value:value
})
}).catch(console.error);
return r;
})
;
}
RootResolve(result);
// });
});
}
async function handler_webfanpack_get(req, res, next)
{
var mode =req.params.mode || 'code';
var payload =req.params.payload || jsCode;
// try{
var code =(isBase64(payload) || isUrlSafeBase64(payload) || !/[\s|\{|\}|\;|\,|\.]/.test(payload))
? Base64.decode(payload) : payload;
/* var code = Buffer.from(payload, 'base64').toString('ascii');*/
/* var code= decode(payload);*/
// }catch(fehler){
//return next(payload);
// }
/* var code=payload;*/
var __packages =(req.params.dependencies || '').split(/[\,\;\s]/);
if(code){
var result = await wrapMainWebfanpack(req, res, next, mode, code, __packages)
.catch(next);
if(result && (result.compiled || result.bundle)){
// main(code, __packages, req, res, next).then(result=>{
if('code'===mode){
res.header['content-type']='text/javascript';
res.end(result.compiled);
}else if('meta'===mode){
res.header['content-type']='application/json';
res.json({bundle:result.bundle,
assets:webfan.toData(result.stats.compilation.assets)});
}else{
next('Invalid mode parameter');
}
// }).catch(next);
}else{
res.header['content-type']='application/json';
res.json({ERROR_RESPONSE:result});
}
}else{
next('Invalid code parameter');
}
}
async function handler_webfanpack_post(req, res, next)
{
var mode =req.body.mode || 'code';
var payload =req.body.code || jsCode;
var code =(isBase64(payload) || isUrlSafeBase64(payload) || !/[\s|\{|\}|\;|\,|\.]/.test(payload))
? Base64.decode(payload) : payload;
var __packages =(req.body.dependencies || '').split(/[\,\;\s]/);
if(code){
var result = await wrapMainWebfanpack(req, res, next, mode, code, __packages)
.catch(next);
if(result && (result.compiled || result.bundle)){
// main(code, __packages, req, res, next).then(result=>{
if('code'===mode){
res.header['content-type']='text/javascript';
res.end(result.compiled);
}else if('meta'===mode){
res.header['content-type']='application/json';
res.json({bundle:result.bundle,
assets:webfan.toData(result.stats.compilation.assets)});
}else{
next('Invalid mode parameter');
}
// }).catch(next);
}else{
res.header['content-type']='application/json';
res.json({ERROR_RESPONSE:result});
}
}else{
next('Invalid code parameter');
}
}
/*
var php = require('uniter').createEngine('PHP');
php.getStdout().on('data', function (text) { console.log(text); });
php.execute('<?php print "Hello from PHP!";');
*/
async function handler_php_post(req, res, next)
{
if('string'!==typeof req.body.code){
next('POST parameter "code" is required in request body');
}else{
var payload =req.body.code || jsCode;
var code =(isBase64(payload) || isUrlSafeBase64(payload) || !/[\s|\{|\}|\;|\,|\.]/.test(payload))
? Base64.decode(payload) : payload;
var contentType= req.params.mimetype1 + '/' + req.params.mimetype2;
res.header['content-type']='text/javascript';
var text = await wrapTranspileToPhp(req, res, code);
res.end(text);
}
}
async function handler_php_get(req, res, next)
{
if('string'!==typeof req.params.code){
next('POST parameter "code" is required in request body');
}else{
var payload =req.params.code || "<?php\necho 'Hello, world!';";
var code =(isBase64(payload) || isUrlSafeBase64(payload) || !/[\s|\{|\}|\;|\,|\.]/.test(payload))
? Base64.decode(payload) : payload;
var contentType= req.params.mimetype1 + '/' + req.params.mimetype2;
res.header['content-type']='text/javascript';
var text = await wrapTranspileToPhp(req, res, code);
res.end(text);
}
}
function wrapTranspileToPhp(req, res, code){
return new Promise(async (RootResolve,RootReject)=>{
console.log( 'db.isOpen', db.isOpen() );
if(! db.isOpen()){
console.log( 'db', db );
}
var KEY = __cacheKey('handler_TranspileToPh_'+req.method.toLowerCase(), req.method, {
code:code,
strlen:code.length
});
var result = await new Promise((resolve,reject)=>{
db.get(KEY)
.catch(function (err) {
resolve(err);
}).then(function (r) {
resolve(r);
});
}).catch(function (err) {
throw new Error(err);
}) .then(function (r) {
return r;
});
if(result instanceof Error
&& result instanceof DB_ERRORS.LevelUPError
&& result instanceof DB_ERRORS.NotFoundError
&& true === result.notFound
&& 404 === result.status){
result = await new Promise((resolve,reject)=>{
var php = require('uniter').createEngine('PHP');
php.getStdout().on('data', function (text) {
db.put(KEY,text)
.then(function () {
return db.get(KEY, { asBuffer: false })
})
.then(function (value) {
console.log('some value stored in the database', {
key : KEY,
value:value
})
}).catch(console.error);
resolve(text);
});
php.execute(code);
});
}
RootResolve(result);
});
}
function addApplicationRoutes(App){
var app = App || express();
app=addApplicationRoutesWebfanpack(app);
app=addApplicationRoutesPhp(app);
return app;
}
function addApplicationRoutesPhp(App){
var app = App || express();
app.post( '/php/:mimetype1/:mimetype2/', handler_php_post);
app.get( '/php/:mimetype1/:mimetype2/:code', handler_php_get);
return app;
}
function addApplicationRoutesWebfanpack(App){
var app = App || express();
app.post( '/webpack/', handler_webfanpack_post);
app.get('/webpack/:payload?/:dependencies?/:mode?',handler_webfanpack_get);
return app;
}
function makeApp(exportObject){
var Application = exportObject;
var baseMount = express();
var AppsApp = express();
var app=runkitExpress(exportObject, baseMount,AppsApp) ;
app= addFirstApplicationMidlewareHandlers( app );
app = addApplicationRoutes(app);
return app;
}
function forceWritableDirectory(Dir, mod, dmod){
var MOD = mod || 0777;
var DMOD = dmod || 0777;
if (!fs.existsSync(Dir)) {
fx.mkdirSync(Dir);
}
if (!fs.existsSync(Dir)) {
throw new Error('Directory ' + Dir +'does not exist');
}
try{
chmodr.sync(Dir, MOD);
}catch(e){
console.warn(e);
}
try{
fs.chmodSync(Dir,DMOD);
}catch(e){
console.warn(e);
}
return fs.existsSync(Dir);
}
no comments
sign in to comment