nsgm-cli 2.0.25 → 2.1.1

package/lib/server/graphql.js

@@ -1,112 +1,175 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var express_graphql_1 = require("express-graphql");
-var graphql_1 = require("graphql");
-var fs_1 = __importDefault(require("fs"));
-var lodash_1 = __importDefault(require("lodash"));
-var path_1 = require("path");
-var date_1 = __importDefault(require("./plugins/date"));
-var defaultPath = (0, path_1.resolve)(__dirname, './modules/');
-var typeDefFileName = 'schema.js';
-var resolverFileName = 'resolver.js';
-var curFolder = process.cwd();
-var outModulesPath = (0, path_1.resolve)(curFolder + '/server/modules/');
-var handleOutPlugins = function () {
-    var result = {};
-    var outPluginsPath = (0, path_1.resolve)(curFolder + '/server/plugins/');
-    if (fs_1.default.existsSync(outPluginsPath)) {
-        var list = fs_1.default.readdirSync(outPluginsPath);
-        list.forEach(function (item) {
-            var resolverPath = (0, path_1.resolve)(outPluginsPath + '/' + item);
-            var stat = fs_1.default.statSync(resolverPath);
-            var isFile = stat.isFile();
-            if (isFile) {
-                result = __assign({}, require(resolverPath));
+const express_graphql_1 = require("express-graphql");
+const graphql_1 = require("graphql");
+const fs_1 = __importDefault(require("fs"));
+const lodash_1 = __importDefault(require("lodash"));
+const path_1 = require("path");
+const date_1 = __importDefault(require("./plugins/date"));
+// 缓存已生成的 schema 和 resolvers
+let cachedSchema = null;
+let cachedResolvers = null;
+const defaultPath = (0, path_1.resolve)(__dirname, './modules/');
+const typeDefFileName = 'schema.js';
+const resolverFileName = 'resolver.js';
+const curFolder = process.cwd();
+const outModulesPath = (0, path_1.resolve)(`${curFolder}/server/modules/`);
+const handleOutPlugins = () => {
+    let result = {};
+    const outPluginsPath = (0, path_1.resolve)(`${curFolder}/server/plugins/`);
+    if (!fs_1.default.existsSync(outPluginsPath)) {
+        return result;
+    }
+    try {
+        const list = fs_1.default.readdirSync(outPluginsPath);
+        list.forEach((item) => {
+            const resolverPath = (0, path_1.resolve)(`${outPluginsPath}/${item}`);
+            if (!fs_1.default.existsSync(resolverPath))
+                return;
+            const stat = fs_1.default.statSync(resolverPath);
+            const isFile = stat.isFile();
+            if (isFile && (item.endsWith('.js') || item.endsWith('.ts'))) {
+                const pluginModule = require(resolverPath);
+                result = {
+                    ...result,
+                    ...(pluginModule.default || pluginModule)
+                };
             }
         });
     }
+    catch (error) {
+        console.warn('⚠️  Error loading plugins:', error);
+    }
     return result;
 };
 function generateTypeDefsAndResolvers() {
-    var querySchemes = [
-        "\n        _: Boolean\n    "
-    ];
-    var mutationSchemes = [
-        "\n        _: Boolean\n    "
-    ];
-    var subscriptionSchemes = [
-        "\n        _: Boolean\n    "
-    ];
-    var typeSchemes = [];
-    var resolvers = __assign(__assign({}, date_1.default), handleOutPlugins());
-    var scalars = lodash_1.default.keys(resolvers);
-    var scalarStr = '';
-    lodash_1.default.each(scalars, function (item, index) {
-        scalarStr += 'scalar ' + item + '\n    ';
+    // 如果已有缓存且在生产环境，直接返回缓存
+    if (process.env.NODE_ENV === 'production' && cachedSchema && cachedResolvers) {
+        return {
+            schemaStr: cachedSchema,
+            resolvers: cachedResolvers
+        };
+    }
+    const querySchemes = ['_: Boolean'];
+    const mutationSchemes = ['_: Boolean'];
+    const subscriptionSchemes = ['_: Boolean'];
+    const typeSchemes = [];
+    const resolvers = {
+        ...date_1.default,
+        ...handleOutPlugins()
+    };
+    const scalars = lodash_1.default.keys(resolvers);
+    let scalarStr = '';
+    lodash_1.default.each(scalars, (item) => {
+        scalarStr += `scalar ${item}\n    `;
     });
     // console.log('resolvers', resolvers, _.keys(resolvers), scalarStr)
-    var _generateAllComponentRecursive = function (path) {
-        if (path === void 0) { path = defaultPath; }
-        if (fs_1.default.existsSync(path)) {
-            var list = fs_1.default.readdirSync(path);
-            list.forEach(function (item) {
-                var resolverPath = path + '/' + item;
-                var stat = fs_1.default.statSync(resolverPath);
-                var isDir = stat.isDirectory();
-                var isFile = stat.isFile();
+    const _generateAllComponentRecursive = (path = defaultPath) => {
+        if (!fs_1.default.existsSync(path))
+            return;
+        try {
+            const list = fs_1.default.readdirSync(path);
+            list.forEach((item) => {
+                const resolverPath = `${path}/${item}`;
+                if (!fs_1.default.existsSync(resolverPath))
+                    return;
+                const stat = fs_1.default.statSync(resolverPath);
+                const isDir = stat.isDirectory();
+                const isFile = stat.isFile();
                 if (isDir) {
                     _generateAllComponentRecursive(resolverPath);
                 }
                 else if (isFile && item === typeDefFileName) {
-                    // console.log('resolverPath1', resolverPath)
-                    var schemaObj = require(resolverPath);
-                    if (schemaObj.default !== undefined)
-                        schemaObj = schemaObj.default;
-                    var query = schemaObj.query, mutation = schemaObj.mutation, subscription = schemaObj.subscription, type = schemaObj.type;
-                    if (query !== '')
-                        querySchemes.push(query);
-                    if (mutation !== '')
-                        mutationSchemes.push(mutation);
-                    if (subscription !== '')
-                        subscriptionSchemes.push(subscription);
-                    if (type !== '')
-                        typeSchemes.push(type);
+                    try {
+                        let schemaObj = require(resolverPath);
+                        if (schemaObj.default !== undefined)
+                            schemaObj = schemaObj.default;
+                        const { query, mutation, subscription, type } = schemaObj;
+                        if (query && query !== '')
+                            querySchemes.push(query);
+                        if (mutation && mutation !== '')
+                            mutationSchemes.push(mutation);
+                        if (subscription && subscription !== '')
+                            subscriptionSchemes.push(subscription);
+                        if (type && type !== '')
+                            typeSchemes.push(type);
+                    }
+                    catch (error) {
+                        console.warn(`⚠️  Error loading schema from ${resolverPath}:`, error);
+                    }
                 }
                 else if (isFile && item === resolverFileName) {
-                    // console.log('resolverPath2', resolverPath)
-                    var resolversObj_1 = require(resolverPath);
-                    if (resolversObj_1.default !== undefined)
-                        resolversObj_1 = resolversObj_1.default;
-                    Object.keys(resolversObj_1).forEach(function (k) {
-                        if (!resolvers[k])
-                            resolvers[k] = {};
-                        resolvers[k] = resolversObj_1[k];
-                    });
+                    try {
+                        let resolversObj = require(resolverPath);
+                        if (resolversObj.default !== undefined)
+                            resolversObj = resolversObj.default;
+                        Object.keys(resolversObj).forEach((k) => {
+                            if (!resolvers[k])
+                                resolvers[k] = {};
+                            resolvers[k] = resolversObj[k];
+                        });
+                    }
+                    catch (error) {
+                        console.warn(`⚠️  Error loading resolver from ${resolverPath}:`, error);
+                    }
                 }
             });
         }
+        catch (error) {
+            console.warn(`⚠️  Error reading directory ${path}:`, error);
+        }
     };
     _generateAllComponentRecursive();
     _generateAllComponentRecursive(outModulesPath);
-    return { querySchemes: querySchemes, mutationSchemes: mutationSchemes, subscriptionSchemes: subscriptionSchemes, typeSchemes: typeSchemes, resolvers: resolvers, scalarStr: scalarStr };
+    const schemaStr = `
+    ${scalarStr}
+
+    type Query { 
+        ${querySchemes.join('\n')} 
+    }
+
+    type Mutation { 
+        ${mutationSchemes.join('\n')} 
+    }
+
+    type Subscription { 
+        ${subscriptionSchemes.join('\n')} 
+    }
+
+    ${typeSchemes.join('\n')}
+  `;
+    // 在生产环境中缓存结果
+    if (process.env.NODE_ENV === 'production') {
+        cachedSchema = schemaStr;
+        cachedResolvers = resolvers;
+    }
+    return { querySchemes, mutationSchemes, subscriptionSchemes, typeSchemes, resolvers, scalarStr, schemaStr };
 }
-var _a = generateTypeDefsAndResolvers(), querySchemesV = _a.querySchemes, mutationSchemesV = _a.mutationSchemes, subscriptionSchemesV = _a.subscriptionSchemes, typeSchemesV = _a.typeSchemes, resolversV = _a.resolvers, scalarStrV = _a.scalarStr;
-var schemaStr = "\n    ".concat(scalarStrV, "\n\n    type Query { \n        ").concat(querySchemesV.join('\n'), " \n    }\n\n    type Mutation { \n        ").concat(mutationSchemesV.join('\n'), " \n    }\n\n    type Subscription { \n        ").concat(subscriptionSchemesV.join('\n'), " \n    }\n\n    ").concat(typeSchemesV.join('\n'), "\n");
-exports.default = (function (command) {
+const generateResult = generateTypeDefsAndResolvers();
+const { querySchemes: querySchemesV, mutationSchemes: mutationSchemesV, subscriptionSchemes: subscriptionSchemesV, typeSchemes: typeSchemesV, resolvers: resolversV, scalarStr: scalarStrV, schemaStr: generatedSchemaStr } = generateResult;
+// 使用生成的 schema 或构建新的 schema
+const schemaStr = generatedSchemaStr ||
+    `
+    ${scalarStrV}
+
+    type Query { 
+        ${querySchemesV?.join('\n') || '_: Boolean'} 
+    }
+
+    type Mutation { 
+        ${mutationSchemesV?.join('\n') || '_: Boolean'} 
+    }
+
+    type Subscription { 
+        ${subscriptionSchemesV?.join('\n') || '_: Boolean'} 
+    }
+
+    ${typeSchemesV?.join('\n') || ''}
+`;
+exports.default = (command) => {
     if (command === 'dev') {
         console.log('schemaStr', schemaStr);
         console.log('resolvers', resolversV);
@@ -116,4 +179,4 @@ exports.default = (function (command) {
         rootValue: resolversV,
         graphiql: true
     });
-});
+};

package/lib/server/plugins/date.js

@@ -3,32 +3,32 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var moment_1 = __importDefault(require("moment"));
-var language_1 = require("graphql/language");
-var graphql_1 = require("graphql");
-var customScalarDate = new graphql_1.GraphQLScalarType({
+const dayjs_1 = __importDefault(require("dayjs"));
+const language_1 = require("graphql/language");
+const graphql_1 = require("graphql");
+const customScalarDate = new graphql_1.GraphQLScalarType({
     name: 'Date',
     description: 'Date custom scalar type',
-    parseValue: function (value) {
-        var date = (0, moment_1.default)(value);
+    parseValue: (value) => {
+        const date = (0, dayjs_1.default)(value);
         if (!date.isValid()) {
             throw new Error('Invalid date format');
         }
         return date.valueOf(); // Ensure this returns a number
     },
-    serialize: function (value) {
-        var date = (0, moment_1.default)(value);
+    serialize: (value) => {
+        const date = (0, dayjs_1.default)(value);
         if (!date.isValid()) {
             throw new Error('Invalid date format');
         }
         return date.format('YYYY-MM-DD HH:mm:ss:SSS'); // Ensure this returns a string
     },
-    parseLiteral: function (ast) {
+    parseLiteral: (ast) => {
         if (ast.kind === language_1.Kind.INT) {
             return parseInt(ast.value, 10);
         }
         else if (ast.kind === language_1.Kind.STRING) {
-            var date = (0, moment_1.default)(ast.value);
+            const date = (0, dayjs_1.default)(ast.value);
             if (!date.isValid()) {
                 throw new Error('Invalid date format');
             }

package/lib/server/utils/graphql-cache.d.ts

@@ -0,0 +1,9 @@
+export declare const graphqlCacheMiddleware: (req: any, res: any, next: any) => any;
+export declare const clearGraphQLCache: () => void;
+export declare const getCacheStats: () => {
+    size: number;
+    entries: {
+        query: string;
+        age: number;
+    }[];
+};

package/lib/server/utils/graphql-cache.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCacheStats = exports.clearGraphQLCache = exports.graphqlCacheMiddleware = void 0;
+// GraphQL 查询缓存中间件
+const queryCache = new Map();
+const CACHE_TTL = 5 * 60 * 1000; // 5分钟
+const graphqlCacheMiddleware = (req, res, next) => {
+    const { query, variables } = req.body || {};
+    // 只缓存查询操作，不缓存变更操作
+    if (!query || query.trim().startsWith('mutation')) {
+        return next();
+    }
+    const cacheKey = JSON.stringify({ query, variables });
+    const now = Date.now();
+    // 检查缓存
+    const cached = queryCache.get(cacheKey);
+    if (cached && now - cached.timestamp < CACHE_TTL) {
+        console.log('🚀 GraphQL cache hit for:', `${query.substring(0, 50)}...`);
+        return res.json(cached.data);
+    }
+    // 拦截响应以存储缓存
+    const originalSend = res.send;
+    res.send = function (body) {
+        try {
+            const data = typeof body === 'string' ? JSON.parse(body) : body;
+            // 只缓存成功的查询结果
+            if (!data.errors) {
+                queryCache.set(cacheKey, {
+                    data,
+                    timestamp: now
+                });
+                // 清理过期缓存
+                cleanExpiredCache();
+            }
+        }
+        catch (error) {
+            console.warn('⚠️  GraphQL cache error:', error);
+        }
+        originalSend.call(this, body);
+    };
+    next();
+};
+exports.graphqlCacheMiddleware = graphqlCacheMiddleware;
+// 清理过期缓存
+function cleanExpiredCache() {
+    const now = Date.now();
+    for (const [key, entry] of queryCache.entries()) {
+        if (now - entry.timestamp > CACHE_TTL) {
+            queryCache.delete(key);
+        }
+    }
+}
+// 清空缓存的函数
+const clearGraphQLCache = () => {
+    queryCache.clear();
+    console.log('🧹 GraphQL cache cleared');
+};
+exports.clearGraphQLCache = clearGraphQLCache;
+// 获取缓存统计
+const getCacheStats = () => {
+    return {
+        size: queryCache.size,
+        entries: Array.from(queryCache.keys()).map((key) => ({
+            query: `${key.substring(0, 100)}...`,
+            age: Date.now() - queryCache.get(key).timestamp
+        }))
+    };
+};
+exports.getCacheStats = getCacheStats;