create-nocobase-app 0.7.0-alpha.9 → 0.7.1-alpha.6

package/bin/index.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+const cli = require('../src/cli');
+
+cli.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-nocobase-app",
-  "version": "0.7.0-alpha.9",
+  "version": "0.7.1-alpha.6",
   "main": "src/index.js",
   "license": "Apache-2.0",
   "licenses": [
@@ -10,20 +10,19 @@
     }
   ],
   "dependencies": {
-    "@nocobase/utils": "^0.5.0-alpha.38",
+    "@umijs/utils": "^3.5.20",
     "axios": "^0.26.1",
     "chalk": "^4.1.1",
-    "commander": "^8.2.0",
-    "execa": "5",
-    "fs-extra": "^10.0.1",
-    "ora": "^5.4.1",
-    "tar": "^6.1.11"
+    "commander": "^9.2.0",
+    "tar": "6.1.11"
+  },
+  "bin": {
+    "create-nocobase-app": "./bin/index.js"
   },
-  "bin": "./bin/create-nocobase-app.js",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nocobase/nocobase.git",
     "directory": "packages/core/create-nocobase-app"
   },
-  "gitHead": "79d5b309fb92148162bfedfb7e304b4673faf568"
+  "gitHead": "b6f96c97020d278ae597bf05553442d7516b2216"
 }

package/src/cli.js

@@ -0,0 +1,34 @@
+const chalk = require('chalk');
+const { resolve } = require('path');
+const { Command } = require('commander');
+const { AppGenerator } = require('./generator');
+const { concat } = require('./util');
+const packageJson = require('../package.json');
+
+const cli = new Command('create-nocobase');
+
+cli
+  .arguments('<name>', 'directory of new NocoBase app')
+  .option('--quickstart', 'quickstart app creation')
+  .option('-a, --all-db-dialect', 'install all database dialect dependencies')
+  .option('-d, --db-dialect <dbDialect>', 'database dialect, current support sqlite/mysql/postgres', 'sqlite')
+  .option('-e, --env <env>', 'environment variables write into .env file', concat, [])
+  .description('create a new application')
+  .action(async (name, options) => {
+    if (options.quickstart) {
+      console.log(`⚠️  ${chalk.yellow('quickstart option is deprecated')}`);
+    }
+
+    const generator = new AppGenerator({
+      cwd: resolve(process.cwd(), name),
+      args: options,
+      context: {
+        name,
+        version: packageJson.version,
+      },
+    });
+
+    await generator.run();
+  });
+
+module.exports = cli;

package/src/generator.js

@@ -0,0 +1,175 @@
+const chalk = require('chalk');
+const crypto = require('crypto');
+const { existsSync } = require('fs');
+const { join, resolve } = require('path');
+const { Generator } = require('@umijs/utils');
+const { downloadPackageFromNpm, updateJsonFile } = require('./util');
+
+class AppGenerator extends Generator {
+  constructor(options) {
+    const { context = {}, ...opts } = options;
+    super(opts);
+    this.context = context;
+    this.env = this.parseEnvs();
+  }
+
+  parseEnvs() {
+    const envs = this.args.env;
+    const items = {};
+    for (const env of envs) {
+      const keys = env.split('=');
+      if (keys.length !== 2) {
+        console.log(`${chalk.red(env)} is not a valid environment value`);
+        process.exit(1);
+      }
+      items[keys[0]] = keys[1];
+    }
+    return items;
+  }
+
+  checkDbEnv() {
+    const dialect = this.args.dbDialect;
+    const env = this.env;
+    if (dialect === 'sqlite') {
+      return;
+    }
+    if (!env.DB_DATABASE || !env.DB_USER || !env.DB_PASSWORD) {
+      console.log(
+        chalk.red(
+          `Please set DB_HOST, DB_PORT, DB_DATABASE, DB_USER, DB_PASSWORD in .env file to complete database settings`,
+        ),
+      );
+    }
+  }
+
+  checkProjectPath() {
+    if (existsSync(this.cwd)) {
+      console.log(chalk.red('Project directory already exists'));
+      process.exit(1);
+    }
+  }
+
+  checkDialect() {
+    const dialect = this.args.dbDialect;
+    const supportDialects = ['mysql', 'sqlite', 'postgres'];
+    if (!supportDialects.includes(dialect)) {
+      console.log(
+        `dialect ${chalk.red(dialect)} is not supported, currently supported dialects are ${chalk.green(
+          supportDialects.join(','),
+        )}.`,
+      );
+      process.exit(1);
+    }
+  }
+
+  getContext() {
+    const env = this.env;
+    const envs = [];
+    const dependencies = [];
+    const { dbDialect, allDbDialect } = this.args;
+
+    if (allDbDialect) {
+      dependencies.push(`"mysql2": "^2.3.3"`);
+      dependencies.push(`"pg": "^8.7.3"`);
+      dependencies.push(`"pg-hstore": "^2.3.4"`);
+      dependencies.push(`"sqlite3": "^5.0.8"`);
+    }
+
+    switch (dbDialect) {
+      case 'sqlite':
+        if (!allDbDialect) {
+          dependencies.push(`"sqlite3": "^5.0.8"`);
+        }
+        envs.push(`DB_STORAGE=${env.DB_STORAGE || 'storage/db/nocobase.sqlite'}`);
+        break;
+      case 'mysql':
+        if (!allDbDialect) {
+          dependencies.push(`"mysql2": "^2.3.3"`);
+        }
+        envs.push(`DB_HOST=${env.DB_HOST || 'localhost'}`);
+        envs.push(`DB_PORT=${env.DB_PORT || 3306}`);
+        envs.push(`DB_DATABASE=${env.DB_DATABASE || ''}`);
+        envs.push(`DB_USER=${env.DB_USER || ''}`);
+        envs.push(`DB_PASSWORD=${env.DB_PASSWORD || ''}`);
+        break;
+      case 'postgres':
+        if (!allDbDialect) {
+          dependencies.push(`"pg": "^8.7.3"`);
+          dependencies.push(`"pg-hstore": "^2.3.4"`);
+        }
+        envs.push(`DB_HOST=${env.DB_HOST || 'localhost'}`);
+        envs.push(`DB_PORT=${env.DB_PORT || 5432}`);
+        envs.push(`DB_DATABASE=${env.DB_DATABASE || ''}`);
+        envs.push(`DB_USER=${env.DB_USER || ''}`);
+        envs.push(`DB_PASSWORD=${env.DB_PASSWORD || ''}`);
+        break;
+    }
+
+    return {
+      ...this.context,
+      dependencies: dependencies.join(`,\n    `),
+      envs: envs.join(`\n`),
+      env: {
+        APP_PORT: 13000,
+        APP_ENV: 'development',
+        DB_DIALECT: dbDialect,
+        APP_KEY: crypto.randomBytes(256).toString('base64'),
+        ...env,
+      },
+    };
+  }
+
+  async downloadServerPackage() {
+    const { name } = this.context;
+    console.log('Download: @nocobase/app-server');
+    const serverPackageDir = resolve(this.cwd, 'packages/app/server');
+    await downloadPackageFromNpm('@nocobase/app-server', serverPackageDir);
+    await updateJsonFile(resolve(serverPackageDir, 'package.json'), (data) => {
+      data['name'] = `@${name}/app-server`;
+      data['version'] = '0.1.0';
+      return data;
+    });
+  }
+
+  async downloadClientPackage() {
+    const { name } = this.context;
+    console.log('Download: @nocobase/app-client');
+    const clientPackageDir = resolve(this.cwd, 'packages/app/client');
+    await downloadPackageFromNpm('@nocobase/app-client', clientPackageDir);
+    await updateJsonFile(resolve(clientPackageDir, 'package.json'), (data) => {
+      data['name'] = `@${name}/app-client`;
+      data['version'] = '0.1.0';
+      return data;
+    });
+  }
+
+  async writing() {
+    this.checkProjectPath();
+    this.checkDialect();
+
+    const { name } = this.context;
+
+    console.log(`Creating a new NocoBase application at ${chalk.green(name)}`);
+    console.log('Creating files');
+
+    this.copyDirectory({
+      context: this.getContext(),
+      path: join(__dirname, '../templates/app'),
+      target: this.cwd,
+    });
+
+    await this.downloadServerPackage();
+    await this.downloadClientPackage();
+
+    this.checkDbEnv();
+
+    console.log('');
+    console.log(chalk.green(`$ cd ${name}`));
+    console.log(chalk.green(`$ yarn install`));
+    console.log(chalk.green(`$ yarn nocobase install`));
+    console.log(chalk.green(`$ yarn dev`));
+    console.log('');
+  }
+}
+
+exports.AppGenerator = AppGenerator;

package/src/util.js

@@ -0,0 +1,57 @@
+const fs = require('fs');
+const tar = require('tar');
+const axios = require('axios');
+const chalk = require('chalk');
+const crypto = require('crypto');
+const { join } = require('path');
+const { execa } = require('@umijs/utils');
+const { unlink, writeFile, readFile } = require('fs').promises;
+
+exports.downloadPackageFromNpm = async (packageName, target) => {
+  const { stdout } = await execa('npm', ['v', packageName, 'dist.tarball']);
+  const tarballFile = join(target, '..', `${crypto.createHash('md5').update(packageName).digest('hex')}-tarball.gz`);
+  const writer = fs.createWriteStream(tarballFile);
+  console.log(chalk.gray(`URL: ${stdout}`));
+  await axios.get(stdout, { responseType: 'stream' }).then((response) => {
+    return new Promise((resolve, reject) => {
+      response.data.pipe(writer);
+
+      let error = null;
+
+      writer.on('error', (err) => {
+        error = err;
+        writer.close();
+        reject(err);
+      });
+
+      writer.on('close', () => {
+        if (!error) {
+          resolve(true);
+        }
+      });
+    });
+  });
+
+  await tar.x({
+    file: tarballFile,
+    gzip: true,
+    cwd: target,
+    strip: 1,
+    k: true,
+    // filter(path, entry) {
+    //   return !(path.startsWith('package/lib') || path.startsWith('package/esm') || path.startsWith('package/dist'));
+    // },
+  });
+
+  await unlink(tarballFile);
+};
+
+exports.updateJsonFile = async (target, fn) => {
+  const content = await readFile(target, 'utf-8');
+  const json = JSON.parse(content);
+  await writeFile(target, JSON.stringify(fn(json), null, 2), 'utf-8');
+};
+
+exports.concat = (value, previous) => {
+  return previous.concat([value]);
+};

package/templates/app/.buildrc.ts

@@ -0,0 +1,5 @@
+export default {
+  target: 'node',
+  cjs: { type: 'babel', lazy: true },
+  excludePkgs: ['app/client'],
+};

package/templates/app/.editorconfig

@@ -0,0 +1,16 @@
+# http://editorconfig.org
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false
+
+[Makefile]
+indent_style = tab

package/templates/app/.env.tpl

@@ -0,0 +1,14 @@
+APP_ENV={{{env.APP_ENV}}}
+APP_KEY={{{env.APP_KEY}}}
+APP_PORT={{{env.APP_PORT}}}
+
+API_BASE_PATH=/api/
+API_BASE_URL=
+
+DB_LOGGING=off
+DB_DIALECT={{{env.DB_DIALECT}}}
+{{{envs}}}
+
+INIT_ROOT_EMAIL=admin@nocobase.com
+INIT_ROOT_PASSWORD=admin123
+INIT_ROOT_NICKNAME=Super Admin

package/templates/app/.gitignore.tpl

@@ -0,0 +1,19 @@
+node_modules/
+lib/
+esm/
+es/
+.env
+.DS_Store
+yarn-error.log
+lerna-debug.log
+/.vscode
+/.idea
+*.sqlite
+coverage
+.umi
+/uploads
+.env.test
+docs-dist/
+.npmrc
+dist/
+docker/**/storage

package/{src/resources/files → templates/app}/.prettierignore

@@ -8,4 +8,5 @@ package.json
 .umi-test
 packages/**/lib/**
 packages/**/esm/**
-packages/**/node_modules/**
+packages/**/node_modules/**
+packages/core/client/src/locale/*

package/{src/resources/files → templates/app}/jest.config.js

@@ -1,13 +1,15 @@
 const { pathsToModuleNameMapper } = require('ts-jest/utils');
-const { compilerOptions } = require('./tsconfig.jest.json');
+const { compilerOptions } = require('./tsconfig.json');
+const { resolve } = require('path');
 
 module.exports = {
+  rootDir: process.cwd(),
   collectCoverage: false,
   verbose: true,
   testEnvironment: 'jsdom',
   preset: 'ts-jest',
   testMatch: ['**/__tests__/**/*.test.[jt]s?(x)'],
-  setupFilesAfterEnv: [require.resolve('jest-dom/extend-expect'), './jest.setup.ts'],
+  setupFilesAfterEnv: [require.resolve('jest-dom/extend-expect'), resolve(__dirname, './jest.setup.ts')],
   moduleNameMapper: pathsToModuleNameMapper(compilerOptions.paths, {
     prefix: '<rootDir>/',
   }),
@@ -18,7 +20,7 @@ module.exports = {
       diagnostics: false,
     },
   },
-  modulePathIgnorePatterns: ['/esm/', '/lib/'],
+  modulePathIgnorePatterns: ['/esm/', '/es/', '/dist/', '/lib/'],
   coveragePathIgnorePatterns: [
     '/node_modules/',
     '/__tests__/',

package/{src/resources/files → templates/app}/jest.setup.ts

@@ -4,7 +4,6 @@ global['prettyFormat'] = prettyFormat;
 
 jest.setTimeout(300000);
 
-// 把 console.error 转换成 error，方便断言
 (() => {
   const spy = jest.spyOn(console, 'error');
   afterAll(() => {

package/{src/resources/files → templates/app}/lerna.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.6.0",
+  "version": "0.1.0",
   "npmClient": "yarn",
   "useWorkspaces": true,
   "npmClientArgs": [

package/templates/app/package.json.tpl

@@ -0,0 +1,28 @@
+{
+  "name": "{{{name}}}",
+  "private": true,
+  "workspaces": [
+    "packages/*/*"
+  ],
+  "scripts": {
+    "nocobase": "nocobase",
+    "dev": "nocobase dev",
+    "start": "nocobase start",
+    "clean": "nocobase clean",
+    "build": "nocobase build",
+    "test": "nocobase test",
+    "postinstall": "nocobase postinstall",
+    "lint": "eslint ."
+  },
+  "resolutions": {
+    "@types/react": "^17.0.0",
+    "@types/react-dom": "^17.0.0"
+  },
+  "dependencies": {
+    "@nocobase/cli": "{{{version}}}",
+    {{{dependencies}}}
+  },
+  "devDependencies": {
+    "@nocobase/devtools": "{{{version}}}"
+  }
+}

package/templates/app/packages/app/client/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "esnext",
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "importHelpers": true,
+    "jsx": "react-jsx",
+    "esModuleInterop": true,
+    "sourceMap": true,
+    "baseUrl": "./",
+    "strict": true,
+    "paths": {
+      "@/*": ["src/*"],
+      "@@/*": ["src/.umi/*"]
+    },
+    "allowSyntheticDefaultImports": true
+  },
+  "include": ["mock/**/*", "src/**/*", "config/**/*", ".umirc.ts", "typings.d.ts"],
+  "exclude": ["node_modules", "lib", "es", "dist", "typings", "**/__test__", "test", "docs", "tests"]
+}

package/templates/app/tsconfig.jest.json

@@ -0,0 +1,13 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "target": "ES6",
+    "module": "CommonJS"
+  },
+  "exclude": [
+    "./packages/*/esm",
+    "./packages/*/es",
+    "./packages/*/dist",
+    "./packages/*/lib"
+  ]
+}

package/{src/resources/files/tsconfig.json → templates/app/tsconfig.json.tpl}

@@ -3,9 +3,9 @@
     "esModuleInterop": true,
     "moduleResolution": "node",
     "jsx": "react",
-    "module": "commonjs",
-    "target": "es6",
-    "allowJs": false,
+    "target": "esnext",
+    "module": "esnext",
+    "allowJs": true,
     "noUnusedLocals": false,
     "preserveConstEnums": true,
     "skipLibCheck": true,
@@ -16,6 +16,13 @@
     "experimentalDecorators": true,
     "downlevelIteration": true,
     "baseUrl": ".",
-    "paths": {}
+    "paths": {
+      "@{{{name}}}/app-*": [
+        "packages/app/*/src"
+      ],
+      "@{{{name}}}/*": [
+        "packages/plugins/*/src"
+      ]
+    }
   }
 }

package/templates/app/tsconfig.server.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "target": "ES6",
+    "module": "CommonJS"
+  }
+}

package/bin/create-nocobase-app.js

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-
-require('../src/create-nocobase-app');

package/src/create-app.js

@@ -1,170 +0,0 @@
-const chalk = require('chalk');
-const fse = require('fs-extra');
-const path = require('path');
-const { hasYarn, runInit, runInstall } = require('./utils');
-const ora = require('ora');
-const execa = require('execa');
-const { join, resolve } = require('path');
-
-const createEnvFile = require('./resources/templates/env');
-const createPackageJson = require('./resources/templates/package.json.js');
-const createServerPackageJson = require('./resources/templates/server.package.json.js');
-const createClientPackageJson = require('./resources/templates/client.package.json.js');
-const loadSrcFromNpm = require('./resources/templates/load-src-from-npm');
-
-let envs = undefined;
-
-const parseEnvs = (options) => {
-  if (envs) {
-    return envs;
-  }
-
-  for (const env of options.env) {
-    if (!env.match(/\w+=\w+/)) {
-      console.log(`${chalk.red(env)} is not a valid environment value`);
-      process.exit(1);
-    }
-  }
-
-  envs = options.env
-    .map((env) => env.split('='))
-    .reduce((carry, item) => {
-      carry[item[0]] = item[1];
-      return carry;
-    }, {});
-
-  return envs;
-};
-
-function checkDialect(dialect) {
-  const supportDialects = ['mysql', 'sqlite', 'postgres'];
-  if (!supportDialects.includes(dialect)) {
-    console.log(
-      `dialect ${chalk.red(dialect)} is not supported, currently supported dialects are ${chalk.green(
-        supportDialects.join(','),
-      )}.`,
-    );
-    process.exit(1);
-  }
-}
-
-const getDatabaseOptionsFromCommandOptions = (commandOptions) => {
-  const envs = parseEnvs(commandOptions);
-
-  if (!commandOptions.dbDialect || commandOptions.dbDialect === 'sqlite' || envs['DB_STORAGE']) {
-    return {
-      dialect: 'sqlite',
-      storage: envs['DB_STORAGE'] || 'db.sqlite',
-    };
-  }
-
-  const databaseOptions = {
-    dialect: commandOptions.dbDialect,
-    host: envs['DB_HOST'],
-    port: envs['DB_PORT'],
-    database: envs['DB_DATABASE'],
-    user: envs['DB_USER'],
-    password: envs['DB_PASSWORD'],
-  };
-
-  const emptyValues = Object.entries(databaseOptions).filter((items) => !items[1]);
-
-  if (emptyValues.length > 0) {
-    console.log(
-      chalk.red(
-        `Please set ${emptyValues
-          .map((i) => i[0])
-          .map((i) => `DB_${i.toUpperCase()}`)
-          .join(' ')} in .env file to complete database settings`,
-      ),
-    );
-  }
-
-  return databaseOptions;
-};
-
-async function createApp(directory, options) {
-  const dbDialect = options.dbDialect || 'sqlite';
-  checkDialect(dbDialect);
-
-  if (options.quickstart) {
-    console.log(`⚠️  ${chalk.yellow('quickstart option is deprecated')}`);
-  }
-
-  parseEnvs(options);
-
-  console.log(`Creating a new NocoBase application at ${chalk.green(directory)}.`);
-  console.log('Creating files.');
-
-  const projectPath = path.join(process.cwd(), directory);
-  const resourcePath = path.join(__dirname, 'resources');
-
-  const dbOptions = getDatabaseOptionsFromCommandOptions(options);
-
-  // copy files
-  await fse.copy(path.join(resourcePath, 'files'), projectPath);
-
-  console.log('download @nocobase/app-server');
-  await loadSrcFromNpm('@nocobase/app-server', path.join(projectPath, 'packages/app/server'));
-
-  console.log('download @nocobase/app-client');
-  await loadSrcFromNpm('@nocobase/app-client', path.join(projectPath, 'packages/app/client'));
-
-  // write .env file
-  await fse.writeFile(join(projectPath, '.env'), createEnvFile({ dbOptions, envs: parseEnvs(options) }));
-
-  // write root packages.json
-  await fse.writeJson(
-    join(projectPath, 'package.json'),
-    createPackageJson({
-      projectName: 'nocobase-app',
-    }),
-    {
-      spaces: 2,
-    },
-  );
-
-  // write server package.json
-  await fse.writeJson(
-    join(projectPath, 'packages/app/server/package.json'),
-    createServerPackageJson({
-      projectPath,
-      dbOptions,
-    }),
-    {
-      spaces: 2,
-    },
-  );
-
-  // write client package.json
-  await fse.writeJson(
-    join(projectPath, 'packages/app/client/package.json'),
-    createClientPackageJson({
-      projectPath,
-    }),
-    {
-      spaces: 2,
-    },
-  );
-
-  // run install command
-  console.log('finished');
-}
-
-function collect(value, previous) {
-  return previous.concat([value]);
-}
-
-function setCommandOptions(command) {
-  return command
-    .arguments('<directory>', 'directory of new NocoBase app')
-    .option('--quickstart', 'Quickstart app creation')
-    .option('-d, --db-dialect <dbdialect>', 'Database dialect, current support sqlite/mysql/postgres')
-    .option('-e, --env <envvalue>', 'environment variables write into .env file', collect, [])
-    .description('create a new application');
-}
-
-module.exports = {
-  setCommandOptions,
-  createApp,
-};

package/src/create-nocobase-app.js

@@ -1,11 +0,0 @@
-const { createApp, setCommandOptions } = require('./create-app');
-
-const { Command } = require('commander');
-const packageJson = require('../package.json');
-const program = new Command(packageJson.name);
-
-setCommandOptions(program);
-
-program.action((directory, options) => createApp(directory, options));
-
-program.parse(process.argv);

package/src/resources/files/jest.cli.js

@@ -1,23 +0,0 @@
-const dotenv = require('dotenv');
-const { existsSync } = require('fs');
-const { resolve } = require('path')
-const yargs = require('yargs');
-
-const envFile = existsSync(resolve(__dirname, '.env.test')) ? '.env.test' : '.env';
-
-dotenv.config({
-  path: resolve(__dirname, envFile),
-});
-
-if (yargs.argv.dbDialect) {
-  process.env.DB_DIALECT = yargs.argv.dbDialect;
-}
-
-if (yargs.argv.dbPort) {
-  process.env.DB_PORT = yargs.argv.dbPort;
-}
-
-console.log('DB_DIALECT:', process.env.DB_DIALECT);
-console.log('DB_PORT:', process.env.DB_PORT);
-
-require('jest-cli/bin/jest');

package/src/resources/files/packages/app/client/.umirc.ts

@@ -1,35 +0,0 @@
-import { getUmiConfig } from '@nocobase/utils/umiConfig';
-import dotenv from 'dotenv';
-import { resolve } from 'path';
-import { defineConfig } from 'umi';
-
-dotenv.config({
-  path: resolve(__dirname, '../../../.env'),
-});
-
-process.env.MFSU_AD = 'none';
-
-const umiConfig = getUmiConfig();
-
-export default defineConfig({
-  hash: true,
-  define: {
-    'process.env.NOCOBASE_ENV': process.env.NOCOBASE_ENV,
-    ...umiConfig.define,
-  },
-  // only proxy when using `umi dev`
-  // if the assets are built, will not proxy
-  proxy: {
-    ...umiConfig.proxy,
-  },
-  nodeModulesTransform: {
-    type: 'none',
-  },
-  routes: [{ path: '/', exact: false, component: '@/pages/index' }],
-  // fastRefresh: {},
-  chainWebpack(config) {
-    const clientSrc = resolve(__dirname, '../../../node_modules/@nocobase/client/src');
-    config.module.rules.get('ts-in-node_modules').include.add(clientSrc);
-    config.resolve.alias.set('@nocobase/client', clientSrc);
-  },
-});

package/src/resources/files/packages/app/server/tsconfig.build.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../../tsconfig.build.json",
-  "compilerOptions": {
-    "outDir": "./lib",
-    "declaration": true
-  },
-  "include": ["./src/**/*.ts", "./src/**/*.tsx"],
-  "exclude": ["./src/__tests__/*", "./esm/*", "./lib/*"]
-}

package/src/resources/files/packages/app/server/tsconfig.json

@@ -1,5 +0,0 @@
-{
-  "extends": "../../../tsconfig.json",
-  "include": ["./src/**/*.ts", "./src/**/*.tsx"],
-  "exclude": ["./esm/*", "./lib/*"]
-}

package/src/resources/files/pnpm-workspace.yaml

@@ -1,2 +0,0 @@
-packages:
-  - packages/**

package/src/resources/files/tsconfig.build.json

@@ -1,19 +0,0 @@
-{
-  "compilerOptions": {
-    "esModuleInterop": true,
-    "resolveJsonModule": true,
-    "moduleResolution": "node",
-    "jsx": "react",
-    "module": "commonjs",
-    "target": "es6",
-    "allowJs": false,
-    "noUnusedLocals": false,
-    "preserveConstEnums": true,
-    "skipLibCheck": true,
-    "sourceMap": true,
-    "inlineSources": true,
-    "declaration": true,
-    "experimentalDecorators": true,
-    "downlevelIteration": true,
-  }
-}

package/src/resources/files/tsconfig.jest.json

@@ -1,14 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "jsx": "react",
-    "esModuleInterop": true,
-    "resolveJsonModule": true,
-    "moduleResolution": "node",
-    "allowJs": true,
-    "module": "commonjs",
-    "target": "es6",
-    "paths": {}
-  },
-  "exclude": ["./packages/*/esm", "./packages/*/lib"]
-}

package/src/resources/templates/client.package.json.js

@@ -1,16 +0,0 @@
-const path = require('path');
-
-module.exports = (opts) => {
-  const { projectPath } = opts;
-  const templateJsonPath = path.join(projectPath, 'packages/app/client/package.json');
-  const templateJson = require(templateJsonPath);
-
-  return {
-    ...templateJson,
-    name: 'app-client',
-    version: '0.1.0',
-    dependencies: {
-      ...templateJson.dependencies,
-    },
-  };
-};

package/src/resources/templates/env.js

@@ -1,34 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const crypto = require('crypto');
-const _ = require('lodash');
-
-const generateASecret = () => crypto.randomBytes(256).toString('base64');
-
-module.exports = (options) => {
-  const { dbOptions, envs } = options;
-  const tmpl = fs.readFileSync(path.join(__dirname, 'env.template'));
-  const compile = _.template(tmpl);
-
-  const dbEnvs = Object.keys(dbOptions)
-    .map((keyName) => [`DB_${keyName.toUpperCase()}`, dbOptions[keyName]])
-    .map((item) => `${item[0]}=${item[1] || ''}`)
-    .join('\n');
-
-  let envContent = compile({
-    jwtSecret: generateASecret(),
-    dbEnvs,
-  });
-
-  for (const env of Object.entries(envs)) {
-    const [key, value] = env;
-    const re = new RegExp(`${key}=\\w+`);
-    if (envContent.match(re)) {
-      envContent = envContent.replace(re, `${key}=${value}`);
-    } else {
-      envContent = `${envContent}${key}=${value}\n`;
-    }
-  }
-
-  return envContent;
-};

package/src/resources/templates/env.template

@@ -1,37 +0,0 @@
-NOCOBASE_ENV=development
-
-SERVER_HOST=0.0.0.0
-SERVER_PORT=3000
-
-JWT_SECRET=<%= jwtSecret %>
-
-# api base path endpoint for app(web)
-SERVER_BASE_PATH=/api/
-
-# api server access point for app(web when build)
-SERVER_BASE_URL=
-
-DB_LOG_SQL=off
-<%= dbEnvs %>
-
-# local or ali-oss
-DEFAULT_STORAGE_TYPE=local
-STORAGE_TYPE=local
-
-# LOCAL STORAGE
-LOCAL_STORAGE_USE_STATIC_SERVER=true
-LOCAL_STORAGE_BASE_URL=
-
-# ALI OSS STORAGE
-ALI_OSS_STORAGE_BASE_URL=
-ALI_OSS_REGION=oss-cn-beijing
-ALI_OSS_ACCESS_KEY_ID=
-ALI_OSS_ACCESS_KEY_SECRET=
-ALI_OSS_BUCKET=
-
-# AWS
-AWS_ACCESS_KEY_ID=
-AWS_SECRET_ACCESS_KEY=
-AWS_S3_REGION=
-AWS_S3_BUCKET=
-AWS_S3_STORAGE_BASE_URL=

package/src/resources/templates/load-src-from-npm.js

@@ -1,49 +0,0 @@
-const execa = require('execa');
-const axios = require('axios');
-const fs = require('fs');
-const fsP = require('fs/promises');
-const tar = require('tar');
-const { join } = require('path');
-const crypto = require('crypto');
-
-module.exports = async (packageName, target) => {
-  const viewResult = await execa('npm', ['v', packageName, 'dist.tarball']);
-  const url = viewResult['stdout'];
-
-  const tarballFile = join(target, '..', `${crypto.createHash('md5').update(packageName).digest('hex')}-tarball.gz`);
-
-  const writer = fs.createWriteStream(tarballFile);
-
-  await axios.get(url, { responseType: 'stream' }).then((response) => {
-    return new Promise((resolve, reject) => {
-      response.data.pipe(writer);
-
-      let error = null;
-
-      writer.on('error', (err) => {
-        error = err;
-        writer.close();
-        reject(err);
-      });
-
-      writer.on('close', () => {
-        if (!error) {
-          resolve(true);
-        }
-      });
-    });
-  });
-
-  const result = await tar.x({
-    file: tarballFile,
-    gzip: true,
-    cwd: target,
-    strip: 1,
-    k: true,
-    filter(path, entry) {
-      return !(path.startsWith('package/lib') || path.startsWith('package/esm') || path.startsWith('package/dist'));
-    },
-  });
-
-  await fsP.unlink(tarballFile);
-};

package/src/resources/templates/package.json.js

@@ -1,67 +0,0 @@
-module.exports = (opts) => {
-  const { projectName } = opts;
-  return {
-    name: projectName,
-    version: '0.1.0',
-    private: true,
-    workspaces: ['packages/app/*', 'packages/plugins/*'],
-    license: 'MIT',
-    scripts: {
-      start: 'concurrently --kill-others "npm run start-server" "npm run start-client"',
-      bootstrap: 'lerna bootstrap',
-      clean: 'rimraf -rf packages/{app,plugins}/*/{lib,esm,dist} && lerna clean',
-      nocobase:
-        'cross-env DOTENV_CONFIG_PATH=.env ts-node-dev -r dotenv/config -r tsconfig-paths/register ./packages/app/server/src/index.ts',
-      'nocobase-prod': 'cross-env DOTENV_CONFIG_PATH=.env node -r dotenv/config packages/app/server/lib/index.js',
-      'start-client': 'cd packages/app/client && npm run start',
-      'start-server': 'npm run nocobase start',
-      build: 'lerna run build',
-      'build-docs': 'dumi build',
-      test: 'node ./jest.cli.js -i',
-      lint: 'eslint .',
-    },
-    resolutions: {
-      '@types/react': '^17.0.0',
-      '@types/react-dom': '^17.0.0',
-    },
-    devDependencies: {
-      '@testing-library/react': '^12.1.2',
-      '@types/jest': '^26.0.0',
-      '@types/node': '^12.6.8',
-      '@types/react': '^17.0.0',
-      '@types/react-dom': '^17.0.0',
-      '@typescript-eslint/eslint-plugin': '^4.9.1',
-      '@typescript-eslint/parser': '^4.8.2',
-      concurrently: '^7.0.0',
-      'cross-env': '^7.0.3',
-      dotenv: '^10.0.0',
-      eslint: '^7.14.0',
-      'eslint-config-prettier': '^7.0.0',
-      'eslint-plugin-import': '^2.13.0',
-      'eslint-plugin-markdown': '^2.0.1',
-      'eslint-plugin-node': '^11.1.0',
-      'eslint-plugin-prettier': '^3.1.0',
-      'eslint-plugin-promise': '^4.0.0',
-      'eslint-plugin-react': '^7.14.2',
-      'eslint-plugin-react-hooks': '^4.2.0',
-      'eslint-plugin-vue': '^7.0.1',
-      jest: '^26.0.0',
-      'jest-codemods': '^0.19.1',
-      'jest-dom': '^3.1.2',
-      'jest-localstorage-mock': '^2.3.0',
-      'jest-styled-components': '6.3.3',
-      'jest-watch-lerna-packages': '^1.1.0',
-      lerna: '^4.0.0',
-      prettier: '^2.2.1',
-      'pretty-format': '^24.0.0',
-      'pretty-quick': '^3.1.0',
-      rimraf: '^3.0.0',
-      'ts-jest': '^26.0.0',
-      'ts-loader': '^7.0.4',
-      'ts-node': '^9.1.1',
-      'ts-node-dev': '^1.1.8',
-      'tsconfig-paths': '^3.12.0',
-      typescript: '^4.1.5',
-    },
-  };
-};

package/src/resources/templates/server.package.json.js

@@ -1,38 +0,0 @@
-const path = require('path');
-const dialectLib = (dialect) => {
-  if (dialect === 'sqlite') {
-    return {
-      sqlite3: '^5.0.2',
-    };
-  }
-
-  if (dialect === 'mysql') {
-    return {
-      mysql2: '^2.3.3',
-    };
-  }
-
-  if (dialect === 'postgres') {
-    return {
-      pg: '^8.7.3',
-      'pg-hstore': '^2.3.4',
-    };
-  }
-};
-
-module.exports = (opts) => {
-  const { dbOptions, projectPath } = opts;
-  const templateJsonPath = path.join(projectPath, 'packages/app/server/package.json');
-  const templateJson = require(templateJsonPath);
-
-  return {
-    ...templateJson,
-    name: 'app-server',
-    version: '0.1.0',
-    main: 'index.js',
-    dependencies: {
-      ...templateJson.dependencies,
-      ...dialectLib(dbOptions.dialect),
-    },
-  };
-};

package/src/utils.js

@@ -1,39 +0,0 @@
-const execa = require('execa');
-
-function hasYarn() {
-  return (process.env.npm_config_user_agent || '').indexOf('yarn') === 0;
-}
-
-function runYarn(path, args) {
-  if (hasYarn()) {
-    return execa('yarn', args, {
-      cwd: path,
-      stdin: 'ignore',
-    });
-  }
-
-  return execa('npm', args, { cwd: path, stdin: 'ignore' });
-}
-
-function runInstall(path) {
-  return runYarn(path, ['install']);
-}
-
-function runStart(path) {
-  return runYarn(path, ['run', 'start']);
-}
-
-function runInit(path, args = []) {
-  if (!hasYarn()) {
-    args.unshift('--');
-  }
-  console.log('run init', args);
-  return runYarn(path, ['run', 'nocobase', 'init', ...args]);
-}
-
-module.exports = {
-  runInit,
-  runStart,
-  runInstall,
-  hasYarn,
-};