@common-stack/generate-plugin 5.0.5-alpha.9 → 6.0.1-alpha.0

package/src/generators/add-fullstack/files/tools/deploy-cli/updateYamlSettings.js

@@ -0,0 +1,53 @@
+/* eslint-disable jest/require-hook */
+const fs = require('fs');
+
+// Function to update the configuration file
+function updateConfiguration(filePath, newVersion) {
+    // Read the configuration file
+    fs.readFile(filePath, 'utf8', (err, data) => {
+        if (err) {
+            console.error(`Error reading the file: ${err.message}`);
+            return;
+        }
+
+        // Replace VERSION and CONNECTION_ID with newVersion
+        let updatedData = data
+            .replace(/VERSION: v\d+(\.\d+)?/g, `VERSION: ${newVersion}`)
+            .replace(/CONNECTION_ID: v\d+(\.\d+)?/g, `CONNECTION_ID: ${newVersion}`);
+
+        // Update CLIENT_URL
+        updatedData = updatedData.replace(
+            /CLIENT_URL: "https:\/\/[\w-]+-v\d+(\.\d+)?\.[\w-]+(\.\w+)?\/?"/g,
+            (match) => {
+                const domainParts = match.match(/https:\/\/[\w-]+-v\d+(\.\d+)?(\.[\w-]+)+/g);
+                if (domainParts && domainParts.length > 0) {
+                    const domain = domainParts[0];
+                    const newDomain = domain.replace(/-v\d+(\.\d+)?/, `-${newVersion}`);
+                    return match.replace(domain, newDomain);
+                }
+                return match;
+            },
+        );
+        // Write the updated configuration back to the file
+        fs.writeFile(filePath, updatedData, 'utf8', (err) => {
+            if (err) {
+                console.error(`Error writing to the file: ${err.message}`);
+                return;
+            }
+            console.log(`Configuration file updated successfully.`);
+            console.log(`Manually update CLIENT_URL in values-dev.yaml and values-prod.yaml`)
+        });
+    });
+}
+
+// Process command line arguments
+const filePath = process.argv[2];
+const versionArg = process.argv[3];
+
+if (!filePath || !versionArg || !versionArg.match(/^v\d+(\.\d+)?$/)) {
+    console.error('Usage: node updateConfiguration.js v[Major].[Minor]');
+    process.exit(1);
+}
+
+// Call the function with the provided version argument
+updateConfiguration(filePath, versionArg);

package/src/generators/add-fullstack/files/tools/deployVersionUpdate.js

@@ -0,0 +1,39 @@
+const { execSync } = require('child_process');
+const path = require('path');
+
+const LERNA_JSON_PATH = path.join(__dirname, '../lerna.json');
+const JENKINSFILE_PATH = path.join(__dirname, '../Jenkinsfile');
+const CONFIG_FILE_PATH = path.join(__dirname, '../values-dev.yaml'); // Updated path
+
+function runScript(scriptPath, args) {
+    console.log(`Running script: ${scriptPath} with args: ${args}`);
+    try {
+        const output = execSync(`node ${scriptPath} ${args}`, { stdio: 'pipe' });
+        console.log(output.toString());
+    } catch (error) {
+        console.error(`Error running script ${scriptPath}: ${error}`);
+        process.exit(1);
+    }
+}
+
+function main(versionArg) {
+    console.log(`Updating to version: ${versionArg}`);
+
+    // // Update lerna.json
+    runScript('./deploy-cli/updateLernaVersion.js', `${LERNA_JSON_PATH} ${versionArg}`);
+
+    // // Update Jenkinsfile
+    runScript('./deploy-cli/updateJenkinsfileVersion.js', `${JENKINSFILE_PATH} ${versionArg}`);
+
+    // Update configuration file
+    runScript('./deploy-cli/updateYamlSettings.js', `${CONFIG_FILE_PATH} ${versionArg}`);
+}
+
+const versionArg = process.argv[2];
+
+if (!versionArg || !versionArg.match(/^v\d+(\.\d+)?$/)) {
+    console.error('Usage: node deployVersionUpdate.js v[Major].[Minor]');
+    process.exit(1);
+}
+
+main(versionArg);

package/src/generators/add-fullstack/files/tools/esm-wrapper.js

@@ -0,0 +1,7 @@
+/* eslint-disable import/no-unresolved */
+/* eslint-disable no-global-assign */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-var-requires */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+require = require('esm')(module, { cjs: true });
+module.exports = require('./main.js');

package/src/generators/add-fullstack/files/tools/get-symlinked-modules.js

@@ -0,0 +1,44 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Returns a mapping from the names of symlinked packages to the physical paths of each package.
+ */
+module.exports = function getSymlinkedNodeModulesForDirectory(packagePath) {
+    const nodeModulesPath = path.join(packagePath, 'node_modules');
+    const directories = listDirectoryContents(nodeModulesPath);
+
+    const modules = {};
+    for (const directory of directories) {
+        // The directory is either a scope or a package
+        if (directory.startsWith('@')) {
+            const scopePath = path.join(nodeModulesPath, directory);
+            const scopedPackageDirectories = fs.readdirSync(scopePath);
+            for (const subdirectory of scopedPackageDirectories) {
+                const dependencyName = `${directory}/${subdirectory}`;
+                const dependencyPath = path.join(scopePath, subdirectory);
+                if (fs.lstatSync(dependencyPath).isSymbolicLink()) {
+                    modules[dependencyName] = fs.realpathSync(dependencyPath);
+                }
+            }
+        } else {
+            const dependencyName = directory;
+            const dependencyPath = path.join(nodeModulesPath, directory);
+            if (fs.lstatSync(dependencyPath).isSymbolicLink()) {
+                modules[dependencyName] = fs.realpathSync(dependencyPath);
+            }
+        }
+    }
+    return modules;
+};
+
+function listDirectoryContents(directory) {
+    try {
+        return fs.readdirSync(directory);
+    } catch (e) {
+        if (e.code === 'ENOENT') {
+            return [];
+        }
+        throw e;
+    }
+}

package/src/generators/add-fullstack/files/tools/sortPackageJson.mjs

@@ -0,0 +1,46 @@
+import { promises as fsPromises } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+// Function to define __dirname in ES Module scope
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Dynamic import for sort-package-json
+const sortPackageJson = await import('sort-package-json').then(module => module.default);
+
+// Directories to process
+const directories = [
+  path.join(__dirname, '../packages'),
+  path.join(__dirname, '../packages-modules'),
+  path.join(__dirname, '../servers'),
+  path.join(__dirname, '../portable-devices')
+];
+
+async function sortPackageJsonFile(filePath) {
+  const packageJson = JSON.parse(await fsPromises.readFile(filePath, 'utf8'));
+  const sortedPackageJson = sortPackageJson(packageJson);
+  await fsPromises.writeFile(filePath, JSON.stringify(sortedPackageJson, null, 2) + '\n');
+}
+
+async function sortAllPackageJsonFiles(dir) {
+  const files = await fsPromises.readdir(dir);
+  for (const file of files) {
+    const fullPath = path.join(dir, file);
+    const stat = await fsPromises.lstat(fullPath);
+    if (stat.isDirectory()) {
+      await sortAllPackageJsonFiles(fullPath);
+    } else if (file === 'package.json') {
+      await sortPackageJsonFile(fullPath);
+      console.log(`Sorted ${fullPath}`);
+    }
+  }
+}
+
+async function processDirectories(dirs) {
+  for (const dir of dirs) {
+    await sortAllPackageJsonFiles(dir);
+  }
+}
+
+await processDirectories(directories);

package/src/generators/add-fullstack/files/tools/update-dependency-link.js

@@ -0,0 +1,107 @@
+/* eslint-disable jest/require-hook */
+/* eslint-disable no-loop-func */
+/* eslint-disable no-undef */
+/* eslint-disable @typescript-eslint/no-var-requires */
+/* eslint-disable @typescript-eslint/no-floating-promises */
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-shadow */
+/* eslint-disable no-console */
+/* eslint-disable @typescript-eslint/restrict-template-expressions */
+/* eslint-disable consistent-return */
+const glob = require('glob');
+const path = require('path');
+const fs = require('fs');
+const simpleGit = require('simple-git');
+
+const git = simpleGit();
+
+const monorepoRoot = path.resolve(__dirname, '..');
+
+const findPackageJsonFiles = () => {
+  return new Promise((resolve, reject) => {
+    glob(
+      `${monorepoRoot}/+(servers|portable-devices|packages|packages-modules)/**/package.json`,
+      { onlyFiles: false, ignore: '**/node_modules/**' },
+      (err, files) => {
+        if (err) reject(`Unable to scan directory: ${err}`);
+        resolve(files);
+      }
+    );
+  });
+};
+
+const buildPackageMap = async () => {
+  const packageJsonFiles = await findPackageJsonFiles();
+  const packageMap = new Map();
+
+  packageJsonFiles.forEach(file => {
+    const packageJson = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (packageJson.name) {
+      packageMap.set(packageJson.name, path.dirname(file));
+    }
+  });
+
+  return packageMap;
+};
+
+const searchAndUpdate = (dependencies, filePath, obj, packageMap) => {
+  const packageDir = path.dirname(filePath);
+
+  for (const key in dependencies) {
+    if (packageMap.has(key)) {
+      const targetDir = packageMap.get(key);
+      const relativePath = path.relative(packageDir, targetDir);
+      dependencies[key] = `link:${relativePath}`;
+      const str = JSON.stringify(obj, null, 2);
+      fs.writeFileSync(filePath, str, 'utf8');
+    }
+  }
+};
+
+const updateDependencies = async () => {
+  const packageMap = await buildPackageMap();
+  const packageJsonFiles = await findPackageJsonFiles();
+
+  packageJsonFiles.forEach(file => {
+    if (!file.includes('node_modules')) {
+      fs.readFile(file, 'utf-8', (err, data) => {
+        if (err) return console.error(`Unable to scan directory: ${err}`);
+        try {
+          const obj = JSON.parse(data);
+          const { dependencies, peerDependencies, devDependencies } = obj;
+          searchAndUpdate(dependencies, file, obj, packageMap);
+          searchAndUpdate(peerDependencies, file, obj, packageMap);
+          searchAndUpdate(devDependencies, file, obj, packageMap);
+        } catch (err) {
+          console.error(`Errored at ${file}`);
+          console.error(err);
+        }
+      });
+    }
+  });
+};
+
+updateDependencies().then(() => {
+  git.add('.')
+    .then(() => {
+      git.status()
+        .then(status => {
+          console.log('POST GIT CHANGES', status);
+          if (status.modified.length) {
+            const fileArray = status.modified.filter(element => element.includes('package.json'));
+            const addArray = fileArray.map(element => `./${element}`);
+            git.add(addArray);
+            git.commit('Updated packages to use link for monorepo dependencies');
+          } else {
+            console.log('no change');
+          }
+        })
+        .catch(err => {
+          console.error(err);
+        });
+    })
+    .catch(err => console.error(err));
+}).catch(err => console.error(err));

package/src/generators/add-fullstack/files/tools/update-dependency-version.js

@@ -0,0 +1,106 @@
+/* eslint-disable jest/require-hook */
+/* eslint-disable no-loop-func */
+/* eslint-disable no-undef */
+/* eslint-disable @typescript-eslint/no-var-requires */
+/* eslint-disable @typescript-eslint/no-floating-promises */
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-shadow */
+/* eslint-disable no-console */
+/* eslint-disable @typescript-eslint/restrict-template-expressions */
+/* eslint-disable consistent-return */
+const glob = require('glob');
+const path = require('path');
+const fs = require('fs');
+
+const SERVER_FOLDER = './servers';
+const simpleGit = require('simple-git');
+
+const git = simpleGit();
+
+const searchAndUpdate = (dependencies, filePath, obj) => {
+    const fileWrie = filePath;
+    const packageDir = path.dirname(filePath);
+    console.log('---PACKAGE DIR', packageDir);
+    for (const key in dependencies) {
+        if (dependencies[key].includes('link:')) {
+            const relativeDepFolder = dependencies[key].split('link:')[1];
+            console.log('--FOLDER ROAD', relativeDepFolder);
+            const dependencyFolder = path.join(packageDir, relativeDepFolder);
+            try {
+                fs.readdirSync(dependencyFolder);
+            } catch (err) {
+
+                console.log(`--- err ${err.message}`);
+                console.log(
+                    `err Search for dependency of ${filePath} with package path ${relativeDepFolder} not found`,
+                );
+                throw err;
+            }
+            glob(`${dependencyFolder}/package.json`, { ignore: '**/node_modules/**' }, (err, files) => {
+                if (err) return console.error(`Unable to scan directory: ${err}`);
+                console.log(files);
+                files.forEach((file) => {
+                    fs.readFile(file, 'utf-8', (err, data) => {
+                        if (err) return console.error(`Unable to scan directory: ${err}`);
+                        try {
+                            const objVersion = JSON.parse(data);
+                            const { version } = objVersion;
+                            dependencies[key] = `${version}`;
+                            const str = JSON.stringify(obj, null, 2);
+                            fs.writeFileSync(fileWrie, str, 'ascii');
+                        } catch (err) {
+                            console.error(`Failed at file: ${file}`)
+                            throw (err);
+                        }
+
+                    });
+                });
+            });
+        }
+    }
+};
+
+glob(
+    './+(servers|portable-devices|packages|packages-modules)/**/package.json',
+    { onlyFiles: false, ignore: '**/node_modules/**' },
+    (err, files) => {
+        if (err) return console.error(`Unable to scan directory: ${err}`);
+        files.forEach((file) => {
+            if (!file.includes('node_modules')) {
+                fs.readFile(file, 'utf-8', (err, data) => {
+                    if (err) return console.error(`Unable to scan directory: ${err}`);
+                    try {
+                        const obj = JSON.parse(data);
+                        const { dependencies, peerDependencies, devDependencies } = obj;
+                        searchAndUpdate(dependencies, file, obj);
+                        searchAndUpdate(peerDependencies, file, obj);
+                        searchAndUpdate(devDependencies, file, obj);
+                    } catch (err) {
+                        console.error(`Errored at ${file}`);
+                        console.error(err);
+                    }
+                });
+            }
+        });
+        git.add('.')
+            .then(() => {
+                git.status()
+                    .then((status) => {
+                        console.log('POST GIT CHANGES', status);
+                        if (status.modified.length) {
+                            const fileArray = status.modified.filter((element) => element.includes('package.json'));
+                            const addArray = fileArray.map((element) => `./${element}`);
+                            git.add(addArray);
+                            git.commit('corrected packages version!');
+                        } else console.log('no change');
+                    })
+                    .catch((err) => {
+                        console.error(err);
+                    });
+            })
+            .catch((err) => console.error(err));
+    },
+);

package/src/generators/add-fullstack/files/tools/webpack/server.config.js

@@ -0,0 +1,165 @@
+process.env.ENV_FILE !== null && require('dotenv').config({ path: process.env.ENV_FILE });
+const webpack = require('webpack');
+const path = require('path');
+const MiniCSSExtractPlugin = require('mini-css-extract-plugin');
+const { CleanWebpackPlugin } = require('clean-webpack-plugin');
+const nodeExternals = require('webpack-node-externals');
+const NodemonPlugin = require('nodemon-webpack-plugin'); // Ding
+const LoadablePlugin = require('@loadable/webpack-plugin');
+const { WebpackManifestPlugin } = require('webpack-manifest-plugin');
+
+const modulenameExtra = process.env.BUILD_MODULE_TO_INCLUDE ? `${process.env.BUILD_MODULE_TO_INCLUDE}|` : '';
+let modulenameRegex;
+
+try {
+    modulenameRegex = new RegExp(
+        `(${modulenameExtra}@test-stack*|ts-invariant|webpack/hot/poll)|(\\.(css|less|scss|png|ico|jpg|gif|xml|woff|woff2|otf|ttf|eot|svg)(\\?[0-9a-z]+)?$)`
+    );
+    console.log('Module Name Regex: ', modulenameRegex);
+} catch (error) {
+    console.error('Error creating regex for module name: ', error);
+}
+
+if (process.env.BUILD_MODULE_TO_INCLUDE) {
+    console.log('Build Module to include (BUILD_MODULE_TO_INCLUDE): ', process.env.BUILD_MODULE_TO_INCLUDE);
+} else {
+    console.log('BUILD_MODULE_TO_INCLUDE is not set.');
+}
+
+const config = ({ buildConfig, indexFilePath, currentDir }) => ({
+    entry: {
+        index: (process.env.NODE_ENV !== 'production' ? ['webpack/hot/poll?200'] : []).concat([
+            'raf/polyfill',
+            indexFilePath,
+        ]),
+    },
+    name: 'server',
+    module: {
+        rules: [
+            { test: /\.mjs$/, include: /node_modules/, type: 'javascript/auto' },
+            {
+                test: /\.(png|ico|jpg|gif|xml)$/,
+                use: { loader: 'url-loader', options: { name: '[fullhash].[ext]', limit: 100000 } },
+            },
+            {
+                test: /\.woff(2)?(\?v=[0-9]\.[0-9]\.[0-9])?$/,
+                use: { loader: 'url-loader', options: { name: '[fullhash].[ext]', limit: 100000 } },
+            },
+            {
+                test: /\.(otf|ttf|eot|svg)(\?v=[0-9]\.[0-9]\.[0-9])?$/,
+                use: { loader: 'file-loader', options: { name: '[fullhash].[ext]' } },
+            },
+            {
+                test: /\.css$/,
+                use: [
+                    process.env.NODE_ENV === 'production'
+                        ? { loader: MiniCSSExtractPlugin.loader }
+                        : { loader: 'style-loader' },
+                    { loader: 'css-loader', options: { sourceMap: true, importLoaders: 1 } },
+                    { loader: 'postcss-loader', options: { sourceMap: true } },
+                ],
+            },
+            {
+                test: /\.scss$/,
+                use: [
+                    process.env.NODE_ENV === 'production'
+                        ? { loader: MiniCSSExtractPlugin.loader }
+                        : { loader: 'style-loader' },
+                    { loader: 'css-loader', options: { sourceMap: true, importLoaders: 1 } },
+                    { loader: 'postcss-loader', options: { sourceMap: true } },
+                    { loader: 'sass-loader', options: { sourceMap: true } },
+                ],
+            },
+            {
+                test: /\.less$/,
+                use: [
+                    process.env.NODE_ENV === 'production'
+                        ? { loader: MiniCSSExtractPlugin.loader }
+                        : { loader: 'style-loader' },
+                    { loader: 'css-loader', options: { sourceMap: true, importLoaders: 1 } },
+                    { loader: 'postcss-loader', options: { sourceMap: true } },
+                    { loader: 'less-loader', options: { lessOptions: { javascriptEnabled: true }, sourceMap: true } },
+                ],
+            },
+            { test: /\.graphqls/, use: { loader: 'raw-loader' } },
+            { test: /\.(graphql|gql)$/, use: [{ loader: 'graphql-tag/loader' }] },
+            {
+                test: /\.(mjs|mts|[tj]sx?)$/,
+                use: {
+                    loader: 'babel-loader',
+                    options: { babelrc: true, rootMode: 'upward-optional' },
+                },
+            },
+            { test: /locales/, use: { loader: '@alienfast/i18next-loader' } },
+        ],
+        unsafeCache: false,
+    },
+    resolve: {
+        symlinks: true,
+        cacheWithContext: false,
+        unsafeCache: false,
+        extensions: [
+            '.web.mjs',
+            '.web.js',
+            '.web.jsx',
+            '.web.ts',
+            '.web.tsx',
+            '.mjs',
+            '.js',
+            '.jsx',
+            '.ts',
+            '.tsx',
+            '.json',
+        ],
+    },
+    watchOptions: { ignored: /dist/ },
+    output: {
+        pathinfo: false,
+        filename: '[name].js',
+        path: path.join(currentDir, 'dist'),
+        publicPath: '/',
+        sourceMapFilename: '[name].[chunkhash][ext].map',
+    },
+    devtool: process.env.NODE_ENV === 'production' ? 'nosources-source-map' : 'cheap-module-source-map',
+    mode: process.env.NODE_ENV || 'development',
+    performance: { hints: false },
+    plugins: (process.env.NODE_ENV !== 'production'
+        ? [
+              //  new Dotenv(),
+              new webpack.HotModuleReplacementPlugin(),
+              new NodemonPlugin({ script: './dist/index.js' }),
+          ]
+        : []
+    ).concat([
+        new MiniCSSExtractPlugin({
+            chunkFilename: '[name].[id].[chunkhash].css',
+            filename: `[name].[chunkhash].css`,
+        }),
+        new CleanWebpackPlugin({ cleanOnceBeforeBuildPatterns: ['dist'] }),
+        new webpack.BannerPlugin({ banner: 'require("source-map-support").install();', raw: true, entryOnly: true }),
+        new webpack.DefinePlugin(
+            Object.assign(
+                ...Object.entries(buildConfig).map(([k, v]) => ({
+                    [k]: typeof v !== 'string' ? v : `"${v.replace(/\\/g, '\\\\')}"`,
+                })),
+            ),
+        ),
+        new WebpackManifestPlugin({ fileName: 'assets.json' }),
+        new LoadablePlugin(),
+    ]),
+    target: 'node',
+    externals: [
+        nodeExternals(),
+        nodeExternals({
+            modulesDir: path.resolve(currentDir, '../../node_modules'),
+            allowlist: [modulenameRegex],
+        }),
+    ],
+    optimization: {
+        concatenateModules: false,
+        minimize: false,
+    },
+    node: { __dirname: true, __filename: true },
+});
+
+module.exports = config;

package/src/generators/add-fullstack/files/tools/webpack-util.js

@@ -0,0 +1,14 @@
+/* eslint-disable no-multi-assign */
+/* eslint-disable @typescript-eslint/no-var-requires */
+/* eslint-disable func-names */
+/* eslint-disable no-undef */
+
+const path = require('path');
+/* helper function to get into build directory */
+module.exports = libPath = function (name) {
+    if (undefined === name) {
+        return path.join('dist');
+    }
+
+    return path.join('lib', name);
+};

package/src/generators/add-fullstack/files/tools/webpackAppConfig.js

@@ -0,0 +1,44 @@
+const dependencyPlatforms = {
+    '@cdm-logger/server': 'server',
+    bunyan: 'server',
+    'export-dir': 'server',
+    express: 'server',
+    'body-parser': 'server',
+    envalid: 'server',
+    'apollo-server-express': 'server',
+    'graphql-subscriptions': 'server',
+    'graphql-tools': 'server',
+    'graphql-tag': ['server', 'web'],
+    'immutability-helper': ['ios', 'android', 'web'],
+    'isomorphic-fetch': 'server',
+    knex: 'server',
+    mysql2: 'server',
+    persistgraphql: ['server', 'web'],
+    'graphql-nats-subscriptions': 'server',
+    'graphql-server-core': 'server',
+    helmet: 'server',
+    'hemera-joi': 'server',
+    'hemera-plugin': 'server',
+    'hemera-safe-promises': 'server',
+    'hemera-sql-store': 'server',
+    'hemera-zipkin': 'server',
+    inversify: 'server',
+    morgan: 'server',
+    nats: 'server',
+    'nats-hemera': 'server',
+    nconf: 'server',
+    'node-pre-gyp': 'server',
+    'prop-types': 'web',
+    ramda: ['web', 'server'],
+    'reflect-metadata': 'server',
+    sequelize: 'server',
+    'react-native': ['ios', 'android'],
+    'react-navigation': ['ios', 'android'],
+    'serialize-javascript': 'server',
+    'source-map-support': 'server',
+    sqlite3: 'server',
+    'styled-components': ['server', 'web'],
+    ws: ['server'],
+};
+
+module.exports = { dependencyPlatforms };

package/src/generators/add-fullstack/files/transform.js

@@ -0,0 +1,14 @@
+const config = {
+    babelrc: false,
+    presets: ["@babel/preset-env", "@babel/preset-react",
+    // ["@babel/preset-typescript", { isTSX: true, allExtensions: true }]
+  ],
+    plugins: [
+      ["@babel/plugin-proposal-class-properties", { loose: true }],
+      "@babel/plugin-transform-runtime",
+      "@babel/plugin-syntax-dynamic-import",
+      "@babel/plugin-proposal-object-rest-spread",
+    ],
+  };
+  module.exports = require("babel-jest").createTransformer(config);
+  

package/src/generators/add-fullstack/files/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ES2022",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "jsx": "react",
+    "skipLibCheck": true,
+    "declaration": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "preserveConstEnums": true,
+    "sourceMap": true,
+    "noImplicitAny": false,
+    "allowSyntheticDefaultImports": true,
+    "pretty": true,
+    "removeComments": false,
+    "lib": [
+      "ES2020",
+      "dom",
+      "esnext.asynciterable"
+    ]
+  },
+  "include": ["src", "typings/*.d.ts"],
+  "exclude": ["node_modules"]
+}