@common-stack/generate-plugin 6.0.1-alpha.9 → 6.0.2-alpha.2

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

@@ -1,106 +1,121 @@
-/* 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 glob = require('glob');
 
 const git = simpleGit();
+const monorepoRoot = path.resolve(__dirname, '..');
+
+// matching prettier format
+const JSON_SPACING = 4;
+const ADD_END_NEWLINE = true; // Set to true to add a newline at the end of the file
+
+const findPackageJsonFiles = () => {
+    return new Promise((resolve, reject) => {
+        glob(
+            `${monorepoRoot}/+(servers|portable-devices|packages|packages-modules)/**/package.json`,
+            { onlyFiles: true, 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: path.dirname(file),
+                version: packageJson.version,
+            });
+        }
+    });
+
+    return packageMap;
+};
+
+const searchAndUpdate = (dependencies, filePath, obj, packageMap) => {
+    let modified = false;
 
-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:')) {
+        if (dependencies[key].startsWith('link:')) {
             const relativeDepFolder = dependencies[key].split('link:')[1];
-            console.log('--FOLDER ROAD', relativeDepFolder);
-            const dependencyFolder = path.join(packageDir, relativeDepFolder);
+            const dependencyFolder = path.join(path.dirname(filePath), relativeDepFolder);
+
             try {
-                fs.readdirSync(dependencyFolder);
+                const packageJsonPath = path.join(dependencyFolder, 'package.json');
+                const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+                if (dependencies[key] !== packageJson.version) {
+                    dependencies[key] = packageJson.version;
+                    modified = true;
+                }
             } catch (err) {
-
-                console.log(`--- err ${err.message}`);
-                console.log(
-                    `err Search for dependency of ${filePath} with package path ${relativeDepFolder} not found`,
-                );
+                console.error(`Error updating ${key} in ${filePath}: ${err.message}`);
                 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);
-                        }
-
-                    });
-                });
-            });
+        } else if (packageMap.has(key)) {
+            const version = packageMap.get(key).version;
+            if (dependencies[key] !== version) {
+                dependencies[key] = version;
+                modified = true;
+            }
+        }
+    }
+
+    if (modified) {
+        // Write the updated package.json back to disk with or without a newline at the end
+        let formattedJson = JSON.stringify(obj, null, JSON_SPACING);
+        if (ADD_END_NEWLINE) {
+            formattedJson += '\n';
         }
+        fs.writeFileSync(filePath, formattedJson, 'utf8');
     }
+
+    return modified;
 };
 
-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);
-                    }
-                });
+const updateDependencies = async () => {
+    const packageMap = await buildPackageMap();
+    const packageJsonFiles = await findPackageJsonFiles();
+    const modifiedFiles = [];
+
+    packageJsonFiles.forEach((file) => {
+        if (!file.includes('node_modules')) {
+            try {
+                const data = fs.readFileSync(file, 'utf8');
+                const obj = JSON.parse(data);
+                const { dependencies, peerDependencies, devDependencies } = obj;
+
+                let modified = false;
+                modified = searchAndUpdate(dependencies, file, obj, packageMap) || modified;
+                modified = searchAndUpdate(peerDependencies, file, obj, packageMap) || modified;
+                modified = searchAndUpdate(devDependencies, file, obj, packageMap) || modified;
+
+                if (modified) {
+                    modifiedFiles.push(file);
+                }
+            } catch (err) {
+                console.error(`Unable to read file ${file}: ${err.message}`);
             }
-        });
-        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));
-    },
-);
+        }
+    });
+
+    if (modifiedFiles.length > 0) {
+        await git.add(modifiedFiles);
+        await git.commit('Updated packages to use correct versions and linked dependencies');
+    } else {
+        console.log('No changes detected');
+    }
+};
+
+updateDependencies()
+    .then(() => {
+        console.log('Dependencies updated successfully.');
+    })
+    .catch((err) => console.error(`Error in updateDependencies: ${err.message}`));

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

@@ -0,0 +1,77 @@
+import { resolve, dirname, join } from 'path';
+import { readFileSync, writeFileSync } from 'fs';
+import glob from 'glob';
+
+export const JSON_SPACING = 4;
+export const ADD_END_NEWLINE = true; // Set to true to add a newline at the end of the file
+
+export const monorepoRoot = resolve(dirname(import.meta.url), '..');
+
+export const findPackageJsonFiles = () => {
+    return new Promise((resolve, reject) => {
+        glob(
+            `${monorepoRoot}/+(servers|portable-devices|packages|packages-modules)/**/package.json`,
+            { onlyFiles: true, ignore: '**/node_modules/**' },
+            (err, files) => {
+                if (err) reject(`Unable to scan directory: ${err}`);
+                resolve(files);
+            },
+        );
+    });
+};
+
+export const buildPackageMap = async () => {
+    const packageJsonFiles = await findPackageJsonFiles();
+    const packageMap = new Map();
+
+    packageJsonFiles.forEach((file) => {
+        const packageJson = JSON.parse(readFileSync(file, 'utf8'));
+        if (packageJson.name) {
+            packageMap.set(packageJson.name, {
+                path: dirname(file),
+                version: packageJson.version,
+            });
+        }
+    });
+
+    return packageMap;
+};
+
+export const searchAndUpdate = (dependencies, filePath, obj, packageMap) => {
+    let modified = false;
+
+    for (const key in dependencies) {
+        if (dependencies[key].startsWith('link:')) {
+            const relativeDepFolder = dependencies[key].split('link:')[1];
+            const dependencyFolder = join(dirname(filePath), relativeDepFolder);
+
+            try {
+                const packageJsonPath = join(dependencyFolder, 'package.json');
+                const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+                if (dependencies[key] !== packageJson.version) {
+                    dependencies[key] = packageJson.version;
+                    modified = true;
+                }
+            } catch (err) {
+                console.error(`Error updating ${key} in ${filePath}: ${err.message}`);
+                throw err;
+            }
+        } else if (packageMap.has(key)) {
+            const version = packageMap.get(key).version;
+            if (dependencies[key] !== version) {
+                dependencies[key] = version;
+                modified = true;
+            }
+        }
+    }
+
+    if (modified) {
+        let formattedJson = JSON.stringify(obj, null, JSON_SPACING);
+        if (ADD_END_NEWLINE) {
+            formattedJson += '\n';
+        }
+        writeFileSync(filePath, formattedJson, 'utf8');
+    }
+
+    return modified;
+};

package/src/generators/add-fullstack/generator.ts

@@ -1,7 +1,17 @@
 import { addProjectConfiguration, formatFiles, generateFiles, Tree, updateJson } from '@nx/devkit';
 import * as path from 'path';
+import fs from 'fs';
 import { AddFullstackGeneratorSchema } from './schema';
-import { getValid } from '../../utils';
+import { getValid, isValid } from '../../utils';
+import { 
+    generateBackend, 
+    generateFrontend, 
+    generateMoleculer,
+    generateBrowserPackage,
+    generateClientPackage,
+    generateCorePackage,
+    generateServerPackage,
+} from '../../index';
 
 export async function addFullstackGenerator(tree: Tree, options: AddFullstackGeneratorSchema) {
     const projectRoot = getValid(options.name) ?? 'fullstack-pro';
@@ -17,6 +27,78 @@ export async function addFullstackGenerator(tree: Tree, options: AddFullstackGen
         return packageJson;
     });
     await formatFiles(tree);
+
+    if (isValid(options.config)) {
+        const configPath = getValid(options.config);
+        if (fs.existsSync(configPath)) {
+            try {
+                const content = String(fs.readFileSync(configPath));
+                const configs = JSON.parse(content);
+                configs.parent = projectRoot;
+
+                await processConfigs(tree, configs);
+            } catch(error) {
+                console.error('Error while reading config.', error);
+            }
+        }
+    }
+}
+
+const processConfigs = async (tree: Tree, configs: any) => {
+    if (configs.servers) {
+        await generateServers(tree, configs.parent, configs.servers);
+    }
+
+    if (configs.packages && configs.packages.modules) {
+        await generatePackages(tree, configs.parent, configs.packages.modules);
+    }
+}
+
+const generateServers = async (tree: Tree, parent: string, servers: any) => {
+    for (const [serverName, serverConfig] of Object.entries(servers)) {
+        const configs: any = serverConfig;
+        configs.name = serverName;
+        configs.directory = `${parent}/servers`;
+        
+        switch(configs?.type) {
+            case 'frontend':
+                await generateFrontend(tree, configs);
+                break;
+            case 'backend':
+                await generateBackend(tree, configs);
+                break;
+            case 'moleculer':
+                await generateMoleculer(tree, configs);
+                break;
+            default:
+                break;
+        }
+    }
+}
+
+const generatePackages = async (tree: Tree, parent: string, packages: any) => {
+    for (const [packageName, packageConfig] of Object.entries(packages)) {
+        const configs: any = packageConfig;
+        configs.name = packageName;
+        configs.directory = `${parent}/packages`;
+        
+        switch((packageConfig as any)?.type) {
+            case 'packages-core':
+                await generateCorePackage(tree, configs);
+                break;
+            case 'packages-browser':
+                await generateBrowserPackage(tree, configs);
+                break;
+            case 'packages-client':
+                await generateClientPackage(tree, configs);
+                break;
+            case 'packages-server':
+                await generateServerPackage(tree, configs);
+                break;
+            default:
+                break;
+        }
+    }
 }
 
 export default addFullstackGenerator;

package/src/generators/add-fullstack/schema.d.ts

@@ -1,3 +1,4 @@
 export interface AddFullstackGeneratorSchema {
     name: string;
+    config?: string;
 }

package/src/generators/add-fullstack/schema.json

@@ -8,6 +8,10 @@
             "type": "string",
             "description": "",
             "x-prompt": "What name would you like to use?"
+        },
+        "config": {
+            "type": "string",
+            "description": "The absolute path of config file"
         }
     },
     "required": ["name"]

package/src/generators/add-moleculer/files/package.json

@@ -26,13 +26,13 @@
     },
     "dependencies": {
         "@casl/ability": "^4.1.5",
-        "@cdm-logger/client": "9.0.3",
+        "@cdm-logger/client": "^9.0.3",
         "@cdm-logger/server": "^9.0.3",
-        "@common-stack/client-core": "6.0.1-alpha.0",
-        "@common-stack/core": "6.0.1-alpha.0",
-        "@common-stack/server-core": "6.0.1-alpha.6",
-        "@common-stack/server-stack": "6.0.1-alpha.8",
-        "@common-stack/store-mongo": "6.0.1-alpha.0",
+        "@common-stack/client-core": "6.0.2-alpha.1",
+        "@common-stack/core": "6.0.2-alpha.1",
+        "@common-stack/server-core": "6.0.2-alpha.1",
+        "@common-stack/server-stack": "6.0.2-alpha.1",
+        "@common-stack/store-mongo": "6.0.2-alpha.1",
         "@container-stack/mailing-api": "5.2.1-alpha.1",
         "app-root-path": "^3.0.0",
         "body-parser": "^1.19.0",
@@ -41,11 +41,11 @@
         "dotenv": "^7.0.0",
         "envalid": "~7.2.2",
         "esm": "^3.2.25",
+        "graphql-tools": "^9.0.0",
         "helmet": "^3.21.2",
         "inversify": "^6.0.2",
         "ioredis": "^4.14.1",
         "lodash": "^4.17.15",
-        "graphql-tools": "^9.0.0",
         "moleculer": "^0.14.2",
         "mongoose": "^6.3.3",
         "mongoose-execution-time": "^1.1.0",

package/src/generators/add-moleculer/generator.ts

@@ -4,19 +4,20 @@ import { AddMoleculerGeneratorSchema } from './schema';
 import { isValid, getValid } from '../../utils';
 
 export async function addMoleculerGenerator(tree: Tree, options: AddMoleculerGeneratorSchema) {
+    const configs: any = {...options};
+    return await generateMoleculer(tree, configs);
+}
+
+export const generateMoleculer = async (tree: Tree, options: any) => {
     const projectName = getValid(options.name) ?? 'moleculer-server';
     const projectRoot = isValid(options.directory) ? `${getValid(options.directory)}/${projectName}` : projectName;
-    // addProjectConfiguration(tree, options.name, {
-    //     root: projectRoot,
-    //     projectType: 'library',
-    //     sourceRoot: `${projectRoot}/src`,
-    //     targets: {},
-    // });
+
     generateFiles(tree, path.join(__dirname, 'files'), projectRoot, options);
     updateJson(tree, `${projectRoot}/package.json`, (packageJson) => {
         packageJson['name'] = options.name;
         return packageJson;
     });
+
     await formatFiles(tree);
 }
 

package/src/generators/add-server-package/generator.spec.ts

@@ -0,0 +1,20 @@
+import { createTreeWithEmptyWorkspace } from '@nx/devkit/testing';
+import { Tree, readProjectConfiguration } from '@nx/devkit';
+
+import { addServerPackageGenerator } from './generator';
+import { AddServerPackageGeneratorSchema } from './schema';
+
+describe('add-server-package generator', () => {
+    let tree: Tree;
+    const options: AddServerPackageGeneratorSchema = { name: 'test', directory: 'lib' };
+
+    beforeEach(() => {
+        tree = createTreeWithEmptyWorkspace();
+    });
+
+    it('should run successfully', async () => {
+        await addServerPackageGenerator(tree, options);
+        const config = readProjectConfiguration(tree, 'test');
+        expect(config).toBeDefined();
+    });
+});

package/src/generators/add-server-package/generator.ts

@@ -0,0 +1,24 @@
+import { addProjectConfiguration, formatFiles, generateFiles, Tree, updateJson } from '@nx/devkit';
+import * as path from 'path';
+import { AddServerPackageGeneratorSchema } from './schema';
+import { isValid, getValid } from '../../utils';
+
+export async function addServerPackageGenerator(tree: Tree, options: AddServerPackageGeneratorSchema) {
+    const configs: any = {...options};
+    return await generateServerPackage(tree, configs);
+}
+
+export const generateServerPackage = async (tree: Tree, options: any) => {
+    const projectName = getValid(options.name) ?? 'server-package';
+    const projectRoot = isValid(options.directory) ? `${getValid(options.directory)}/${projectName}` : projectName;
+
+    generateFiles(tree, path.join(__dirname, 'files'), projectRoot, options);
+    updateJson(tree, `${projectRoot}/package.json`, (packageJson) => {
+        packageJson['name'] = projectName;
+        return packageJson;
+    });
+
+    await formatFiles(tree);
+}
+
+export default addServerPackageGenerator;

package/src/generators/add-server-package/schema.d.ts

@@ -0,0 +1,4 @@
+export interface AddServerPackageGeneratorSchema {
+    name: string;
+    directory: string;
+}

package/src/generators/add-server-package/schema.json

@@ -0,0 +1,19 @@
+{
+    "$schema": "https://json-schema.org/schema",
+    "$id": "AddServerPackage",
+    "title": "",
+    "type": "object",
+    "properties": {
+        "name": {
+            "type": "string",
+            "description": "",
+            "x-prompt": "What name would you like to use?"
+        },
+        "directory": {
+            "type": "string",
+            "description": "",
+            "x-prompt": "What directory would you like to create in?"
+        }
+    },
+    "required": ["name", "directory"]
+}

package/src/index.ts

@@ -3,3 +3,8 @@ export * from './generators/add-backend/generator';
 export * from './generators/add-fullstack/generator';
 export * from './generators/add-moleculer/generator';
 export * from './generators/add-browser-package/generator';
+export * from './generators/add-client-package/generator';
+export * from './generators/add-core-package/generator';
+export * from './generators/add-server-package/generator';
+export { default as updateDeployVersion } from './executors/update-deploy-version/executor';
+export { default as sortPackageJson } from './executors/sort-package-json/executor';

package/lib/generators/add-backend/files/knexfile.js

@@ -1,63 +0,0 @@
-// Update with your config settings.
-var path = require('path');
-require('dotenv').config({ path: process.env.ENV_FILE });
-
-var connection = {
-  host: process.env.DB_HOST,
-  user: process.env.DB_USER,
-  socketPath: process.env.DB_SOCKET_PATH,
-  password: process.env.DB_PASSWORD,
-  database: process.env.DB_DATABASE,
-  multipleStatements: true,
-  charset: 'utf8',
-};
-var DB_CLIENT = process.env.DB_TYPE || 'sqlite3';
-
-var migrations_path = path.dirname(require.resolve('@adminide-stack/store/lib/store/migrations/index'));
-var seeds_path = path.dirname(require.resolve('@adminide-stack/store/lib/store/seeds/index'));
-module.exports = {
-
-  development: {
-    client: 'sqlite3',
-    connection: {
-      filename: './dev-db.sqlite3'
-    },
-    seeds: {
-      directory: seeds_path,
-    },
-    migrations: {
-      directory: migrations_path,
-    },
-    useNullAsDefault: true,
-  },
-
-  test: {
-    client: DB_CLIENT,
-    connection: connection,
-    pool: {
-      min: 2,
-      max: 10
-    },
-    seeds: {
-      directory: seeds_path,
-    },
-    migrations: {
-      directory: migrations_path,
-    },
-    useNullAsDefault: true,
-  },
-
-  production: {
-    client: DB_CLIENT,
-    connection: connection,
-    pool: {
-      min: 2,
-      max: 200
-    },
-    migrations: {
-      directory: migrations_path,
-    },
-    useNullAsDefault: true,
-  }
-
-};

package/lib/generators/add-backend/files/src/api/remote-config.ts.template

@@ -1,11 +0,0 @@
-interface ISchemaConfig {
-    uri: string;
-    wsUri: string;
-}
-
-export const remoteSchemaDetails: ISchemaConfig[] = [
-    // {
-    // uri: 'http://localhost:8085/graphql',
-    // wsUri: 'ws://localhost:8085/graphql',
-    // },
-];

package/lib/generators/add-backend/files/src/api/resolver.ts.template

@@ -1,15 +0,0 @@
-import GraphQLJSON, { GraphQLJSONObject } from 'graphql-type-json';
-import { GraphQLDate, GraphQLTime, GraphQLDateTime } from 'graphql-iso-date';
-import { GraphQLAnyObject } from './scalar';
-import GraphQLURI from '@cdmbase/graphql-type-uri';
-
-export const resolvers = {
-    AnyObject: GraphQLAnyObject,
-    Date: GraphQLDate,
-    Time: GraphQLTime,
-    URI: GraphQLURI('URI'),
-    URIInput: GraphQLURI('URIInput'),
-    DateTime: GraphQLDateTime,
-    JSON: GraphQLJSON,
-    JSONObject: GraphQLJSONObject,
-};

package/lib/generators/add-backend/files/src/api/scalar.ts.template

@@ -1,16 +0,0 @@
-// add any scalar types
-import { GraphQLError, GraphQLScalarType, Kind } from 'graphql';
-
-// https://stackoverflow.com/questions/41557536/custom-map-keys-in-graphql-response
-export const GraphQLAnyObject = new GraphQLScalarType({
-    name: 'AnyObject',
-    description: 'Any JSON object. This type bypasses type checking.',
-    serialize: (value) => value,
-    parseValue: (value) => value,
-    parseLiteral: (ast) => {
-        if (ast.kind !== Kind.OBJECT) {
-            throw new GraphQLError(`Query error: Can only parse object but got a: ${ast.kind}`, [ast]);
-        }
-        return ast.fields;
-    },
-});