const filename = resolve(__dirname, 'index.html');
    const stream = fs.createReadStream(filename);
    ctx.status =200;
    ctx.type="html";
    stream.on('data',(chunk)=>{
        ctx.res.write(chunk);
    })
    const part1 = await task1();
    ctx.res.write(part1)
    const part2 = await task2();
    ctx.res.write(part2)
    ctx.res.end();

const shell = require('shelljs');
const path = require('path');
const chokidar = require('chokidar')

const form = "./profile1.html*";
const to = "root@106.52.73.93";
const password = "1234567890";
const expectPath = path.join(__dirname, './expect.exp');

//const test = shell.exec('npm run test')
//if(test !== 0){
//    process.exit(1);
//}

//const status = shell.exec('npm run build')
//if(status !== 0){
//    process.exit(1);
//}

const watch = chokidar.watch(process.cwd())

//shell.exec(`scp ${form} ${to}`); 


//加入expect.ecp
watcher.on('change', function(filePath){
   shell.exec(`expect ${expectPath} ${filePath} ${to} ${password}`); 
})

#!/usr/bin/expect
set from [lindex $argv 0]
set to [lindex $argv 1]
set password [lindex $argv 2]

set timeout 30
spawn bash -c "scp $from $to"

expect{
    "*password:" {send "$password\r"}
}

interact

const shell = require('shelljs');
const Rsync = require('rsync');
const path = require('path');
const colors = require('colors');
const argv = require('yargs').argv;
const { exit } = require('process');

//获取执行的进程参数
const [targetName] = argv._;

//设置多台测试机，给每台测试机起代号，对应不同的IP
const host_map = {
    staging001: 'onePiece:/root/build'
}

//判断如果不传参数 没有选择要部署的主机 给出提示
if (!host_map[targetName]) {
    shell.echo("目标主机不存在！");
    shell.exit(1);
}

//设置通知消息  以企业微信为例
function sendNotify(message) {
    shell.exec(`curl 'https//qyapi.weixin.qq.com - H 'Content-type:application' - d '{"message": ${message}}`)
}

//0代表成功
// sendNotify('安装依赖')
// console.log(colors.yellow('☕️ 安装依赖'))
// if(shell.exec("npm install").code !== 0){
//     shell.echo("error:npm install error.");
//     shell.exit(1)
// }

//测试
// sendNotify('进行测试')
// console.log(colors.yellow('☕️ 进行测试'))
// if(shell.exec("npm run test").code !== 0){
//     shell.echo("error:npm run test error.");
//     shell.exit(1)
// }
//构建
sendNotify('开始构建')
console.log(colors.yellow('☕️ 开始构建'))
if(shell.exec("npm run build").code !== 0){
    shell.echo("error:npm run build error.");
    shell.exit(1)
}

//部署
sendNotify("开始部署")
console.log(colors.yellow('☕️ 开始部署'));
const rsync = Rsync.build({
    source:path.join(__dirname,'../','/./build/*'),
    destination: host_map[targetName],
    flags:'avz',
    shell:'ssh'
})

rsync.execute(function(error, code, cmd) {
    console.log(error,code,cmd,)
    console.log(colors.yellow('☕️ 部署完成'))
    sendNotify('部署完成')
  });

import { extend } from "lodash";
import { join } from "path";

let config = {
  //配置后续资源路径和其他公共配置
  viewDir: join(__dirname, "..", "views"),
  staticDir: join(__dirname, "..", "assets"),
};

if (process.env.NODE_ENV === "development") {
  let localConfig = {
    port: 8081,
    memoryFlag: false,
  };

  config = extend(config, localConfig);
}

if (process.env.NODE_ENV === "production") {
  let localConfig = {
    port: 8082,
    memoryFlag: true,
  };

  config = extend(config, localConfig);
}

export default config;

import Koa from "koa";
import render from "koa-swig";
import { wrap } from "co";
import { port, viewDir, memoryFlag } from "./config";

const app = new Koa();

app.context.render = wrap(
  render({
    root: viewDir,
    autoescape: true,
    cache: memoryFlag,
    ext: "html",
    varControls: ["[[", "]]"],
    writeBody: false,
  })
);

app.listen(port, () => {
  console.log("🍺服务器启动成功", port);
});

class Controller {
  constructor() {}

  log() {
    console.log("父类Controller");
  }
}

import Controller from "./Controller";
import Books from "../models/Books";
class BooksController extends Controller {
  constructor() {
    super();
  }

  //服务端渲染 直出
  async actionIndex(ctx, next) {
    const book = new Book();
    const data = await book.getData();
    ctx.body = await ctx.render("books/pages/list", data);
  }

  async actionCreate(ctx, next) {
    ctx.body = await ctx.render("books/pages/create");
  }
}

import Controller from "./Controller";
class IndexController extends Controller {
  constructor() {
    super();
  }
  async actionIndex(ctx, next) {
    ctx.body = "石晓波🏮";
  }
}
export default IndexController;

import router from "koa-simple-router";
import BooksController from "./BooksController";
import IndexController from "./IndexController";
const bookController = new BooksController();
const indexController = new IndexController();

export default (app) => {
  app.use(
    router((_) => {
      _.get("/", indexController.actionIndex);
      _.get("/books/list", bookController.actionIndex);
      _.get("/books/create", bookController.actionCreate);
    })
  );
};

import controllers from './controllers';
...
controllers(app)
...

import { get } from "axios";
class Books {
  getData() {
    return get("http://localhost/basic/web/index.php?r=books");
  }
}

import { configure, getLogger } from "log4js";
import errorHandler from "./middlewares/errorHandler.js";
configure({
  appenders: { cheese: { type: "file", filename: "logs/yd.log" } },
  categories: { default: { appenders: ["cheese"], level: "error" } },
});
const logger = getLogger("cheese");

errorHandler.error(app, logger);

class errorHandler{
    static error(app,logger){
        app.use(async (ctx, next)=>{
             try{
                  await  next();
             } catch(e){
                  logger.error(e);
                  ctx.body = "500请求啦~恢复中.'"
             }
        })

        app.use(async (ctx, next) => {
            await next();
            if(404 !== ctx.status){
                return;
            }
            ctx.body = '<script type="text/javascript" src="//qzonestyle.gtimg.cn/qzone/hybrid/app/404/search_children.js" charset="utf-8"></script>';
        })
    }
}

const banner = {
  init() {
    console.log('banner');
  },
};
export default banner;

import banner from '@/components/banner/banner.js';
banner.init();

import banner from '@/components/banner/banner.js';
banner.init();

const argv = require('yargs-parser')(process.argv.slice(2));
const _mode = argv.mode || 'development';
const _mergeConfig = require(`./config/webpack.${_mode}.js`);
const { merge } = require('webpack-merge');
const { sync } = require('glob');
const { resolve } = require('path');
const files = sync('./src/web/views/**/*.entry.js');
const HtmlWebpackPlugin = require('html-webpack-plugin');
const HtmlAfterPlugin = require('./config/HtmlAfterPlugin');

let _entry = {};
let _plugins = [];
for (let item of files) {
  // console.log(item)
  if (/.+\/([a-zA-Z]+-[a-zA-Z]+)(\.entry\.js)/g.test(item) == true) {
    const entryKey = RegExp.$1;
    _entry[entryKey] = item;
    const [dist, template] = entryKey.split('-');
    _plugins.push(
      new HtmlWebpackPlugin({
        filename: `../views/${dist}/pages/${template}.html`,
        template: `src/web/views/${dist}/pages/${template}.html`,
        chunks: ['runtime', entryKey],
        inject: false,
      })
    );
  } else {
    console.log('🐖', '项目配置匹配失败');
    process.exit(-1);
  }
}
const webpackConfig = {
  entry: _entry,
  optimization: {
    runtimeChunk: {
      name: 'runtime',
    },
  },
  plugins: [..._plugins, new HtmlAfterPlugin()],
  resolve: {
    alias: {
      '@': resolve('src/web'),
    },
  },
};
module.exports = merge(webpackConfig, _mergeConfig);

//开发环境
 output: {
    path: join(__dirname, '../dist/assets'),
    publicPath: '/',
    filename: 'scripts/[name].bundle.js',
  },
//生产环境
output: {
    path: join(__dirname, '../dist/assets'),
    publicPath: '/',
    filename: 'scripts/[name].[contenthash:5].bundle.js',
  },

  new CopyPlugin({
      patterns: [
        {
          from: join(__dirname, '../', 'src/web/views/layouts/layout.html'),
          to: '../views/layouts/layout.html',
        },
      ],
    }),
    new CopyPlugin({
      patterns: [
        {
          from: 'src/web/components/**/*.html',
          to: '../components',
          transformPath(targetPath, absolutePath) {
              //win环境
              return targetPath.replace('src\\web\\components\\', '');
              //mac环境
              // return targetPath.replace('src/web/components/', '');
          },
        },
      ],
    }),

const HtmlWebpackPlugin = require('html-webpack-plugin');
const pluginName = 'HtmlAfterPlugin';

const assetsHelp = (data) => {
  let js = [];
  const getAssetsName = {
    js: (item) => `<script src="${item}"></script>`,
  };
  for (let jsitem of data.js) {
    js.push(getAssetsName.js(jsitem));
  }
  return {
    js,
  };
};

class HtmlAfterPlugin {
  constructor() {
    this.jsarr = [];
  }
  apply(compiler) {
    compiler.hooks.compilation.tap(pluginName, (compilation) => {
      HtmlWebpackPlugin.getHooks(compilation).beforeAssetTagGeneration.tapAsync(
        pluginName,
        (htmlPligunData, cb) => {
          const { js } = assetsHelp(htmlPligunData.assets);
          this.jsarr = js;
          cb(null, htmlPligunData);
        }
      );
      HtmlWebpackPlugin.getHooks(compilation).beforeEmit.tapAsync(
        pluginName,
        (data, cb) => {
          let _html = data.html;
          _html = _html.replace('<!--injectjs-->', this.jsarr.join(''));
          _html = _html.replace(/@components/g, '../../../components');
          _html = _html.replace(/@layouts/g, '../../layouts');
          data.html = _html;
          cb(null, data);
        }
      );
    });
  }
}

module.exports = HtmlAfterPlugin;

const gulp = require('gulp');
const watch = require('gulp-watch');
const entry = './src/server/**/*.js';
const plumber = require('gulp-plumber');
const cleanEntry = './src/server/config/index.js';
const rollup = require('gulp-rollup');
const babel = require('gulp-babel');
const replace = require('@rollup/plugin-replace');
const prepack = require('gulp-prepack');
function builddev() {
  return watch(entry, { ignoreInitial: false }, () => {
    gulp
      .src(entry)
      .pipe(plumber())
      .pipe(
        babel({
          babelrc: false,
          plugins: ['@babel/plugin-transform-modules-commonjs'],
        })
      )
      .pipe(gulp.dest('dist'));
  });
}

function buildprod() {
  return gulp
    .src(entry)
    .pipe(
      babel({
        babelrc: false,
        ignore: [cleanEntry],
        plugins: ['@babel/plugin-transform-modules-commonjs'],
      })
    )
    .pipe(gulp.dest('dist'));
}

//清理环境变量
function buildconfig() {
  return (
    gulp
      .src(entry)
      .pipe(
        rollup({
          input: cleanEntry,
          output: {
            format: 'cjs',
          },
          plugins: [
            replace({
              'process.env.NODE_ENV': JSON.stringify('production'),
            }),
          ],
        })
      )
      // .pipe(prepack({}))
      .pipe(gulp.dest('./dist'))
  );
}

let build = gulp.series(builddev);
if (process.env.NODE_ENV == 'production') {
  build = gulp.series(buildprod, buildconfig);
}

gulp.task('default', build);

async actionIndex(ctx, next) {
    // const book = new Book();
    // const { data } = await book.getData();
    const data = '123';
    // console.log('🐻', data);
    // ctx.body = {
    //   data,
    // };
    const html = await ctx.render('books/pages/list', {
      data,
    });
    if (ctx.request.header['x-pjax']) {
      console.log('站内切');
      const $ = cheerio.load(html);
      ctx.status = 200;
      ctx.type = 'html';
      //每个组件都需要加 否则切页动态替换的时候不能加载所有的组件
      $('.pjaxcontent').each(function () {
        ctx.res.write($(this).html());
      });
      //因为有缓存的原因原地切虽然没有重新加载js但是已经在栈中，当两个页面来回切就会发现js没有运行所以要加如下代码
      $('.lazyload-js').each(function () {
        ctx.res.write(
          `<script class="lazyload-js" src="${$(this).attr('src')}"></script>`
        );
      });
      ctx.res.end();
    } else {
      function createSSRStreamPromise() {
        console.log('落地页');
        return new Promise((resolve, reject) => {
          const htmlStream = new Readable()
          htmlStream.push(html);
          htmlStream.push(null);
          ctx.type = 'html';
          ctx.status = 200;
          htmlStream.on('error', (err) => {
            reject(err)
          })
            .pipe(ctx.res)
        })
      }

      await createSSRStreamPromise();
    }
    ctx.body = await ctx.render('books/pages/list');
  }

            {
            test: /\.js$/, 
                exclude: /(node_modules|bower_components)/,
                use: [
                    {
                        loader: 'babel-loader',
                    }
                ]
            }

const a = 1;
let b = 2;


class myClass{

}

const mine = new myClass();
console.log('mine',mine);

export const aFunc = () => {
    return a + b;
}

export const arrInclude = () => {
    const arr = [1, 2, 3, 4];
    return arr.includes(a)
}

export const promiseFunc = () => {
    return new Promise((resolve) => {
        setTimeout(() => {
            document.body.style.backgroundColor = 'green';
        }, 3000)
    })
}

const asyncFunc = async () => {
    await promiseFunc();
    console.log('success!!!!!!!!!!')
}



console.log('aFunc', aFunc())

console.log('arrInclude', arrInclude())

document.body.style.backgroundColor = 'red';

asyncFunc();

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "aFunc": function() { return /* binding */ aFunc; },
/* harmony export */   "arrInclude": function() { return /* binding */ arrInclude; },
/* harmony export */   "promiseFunc": function() { return /* binding */ promiseFunc; }
/* harmony export */ });
/* harmony import */ var _babel_runtime_corejs2_helpers_asyncToGenerator__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime-corejs2/helpers/asyncToGenerator */ "./node_modules/@babel/runtime-corejs2/helpers/esm/asyncToGenerator.js");
/* harmony import */ var _babel_runtime_corejs2_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime-corejs2/helpers/classCallCheck */ "./node_modules/@babel/runtime-corejs2/helpers/esm/classCallCheck.js");
/* harmony import */ var _babel_runtime_corejs2_regenerator__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime-corejs2/regenerator */ "./node_modules/@babel/runtime-corejs2/regenerator/index.js");
/* harmony import */ var _babel_runtime_corejs2_regenerator__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_corejs2_regenerator__WEBPACK_IMPORTED_MODULE_2__);
/* harmony import */ var _babel_runtime_corejs2_core_js_promise__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @babel/runtime-corejs2/core-js/promise */ "./node_modules/@babel/runtime-corejs2/core-js/promise.js");
/* harmony import */ var _babel_runtime_corejs2_core_js_promise__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_corejs2_core_js_promise__WEBPACK_IMPORTED_MODULE_3__);




// import "core-js/stable";
// import "regenerator-runtime/runtime";
var a = 1;
var b = 2;

var myClass = function myClass() {
  (0,_babel_runtime_corejs2_helpers_classCallCheck__WEBPACK_IMPORTED_MODULE_1__["default"])(this, myClass);
};

var mine = new myClass();
console.log('mine', mine);
var aFunc = function aFunc() {
  return a + b;
};
var arrInclude = function arrInclude() {
  var arr = [1, 2, 3, 4];
  return arr.includes(a);
};
var promiseFunc = function promiseFunc() {
  return new (_babel_runtime_corejs2_core_js_promise__WEBPACK_IMPORTED_MODULE_3___default())(function (resolve) {
    setTimeout(function () {
      document.body.style.backgroundColor = 'green';
    }, 3000);
  });
};

var asyncFunc = /*#__PURE__*/function () {
  var _ref = (0,_babel_runtime_corejs2_helpers_asyncToGenerator__WEBPACK_IMPORTED_MODULE_0__["default"])( /*#__PURE__*/_babel_runtime_corejs2_regenerator__WEBPACK_IMPORTED_MODULE_2___default().mark(function _callee() {
    return _babel_runtime_corejs2_regenerator__WEBPACK_IMPORTED_MODULE_2___default().wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            _context.next = 2;
            return promiseFunc();

          case 2:
            console.log('success!!!!!!!!!!');

          case 3:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));

  return function asyncFunc() {
    return _ref.apply(this, arguments);
  };
}();

console.log('aFunc', aFunc());
console.log('arrInclude', arrInclude());
document.body.style.backgroundColor = 'red';
asyncFunc();