ming_node 2.2.2 → 2.2.7

package/plugins/BaseGraphqlApi/getGraphqlSchema.js

@@ -0,0 +1,145 @@
+M=require("../../index");
+const Db=M.getMySql({});
+const{
+    GraphQLObjectType,
+    GraphQLString,
+    GraphQLInt,
+    GraphQLSchema,
+    GraphQLList,
+    GraphQLNonNull,
+    GraphQLFloat,
+    GraphQLBoolean,
+} = require('graphql');
+
+
+function getGraphTypeBySqlType(sqlType) {
+    sqlType = sqlType.toLowerCase();
+    if (sqlType.indexOf("string") >= 0 || sqlType.indexOf("varchar") >= 0 || sqlType.indexOf("text") >= 0) {
+        return GraphQLString;
+    } else if (sqlType.indexOf("int") >= 0) {
+        return GraphQLInt;
+    } else if (sqlType.indexOf("date") >= 0 || sqlType.indexOf("time") >= 0) {
+        return GraphQLString;
+    } else if (sqlType.indexOf("double") >= 0) {
+        return GraphQLFloat;
+    } else if (sqlType.indexOf("float") >= 0) {
+        return GraphQLFloat;
+    } else if (sqlType.indexOf("decimal") >= 0) {
+        return GraphQLFloat;
+    }
+    return GraphQLString;
+}
+
+
+function obj2QueryCase(obj){
+    let queryCase="1=1";
+    if(obj && Object.keys(obj).length>0){
+        for(var p in obj) {
+            queryCase=queryCase+` and ${p}='${obj[p]}' `
+        }
+    }
+    return queryCase;
+
+}
+
+async function getGraphqlSchema({dbBaseMapper,generateTime}){
+    let tableName=dbBaseMapper.tableName;
+    let tableSchema=await dbBaseMapper.getTableSchema()
+    const ResponseType =  new GraphQLObjectType({
+        name:'response',
+        fields:{
+            code:{type:GraphQLInt},
+            msg:{type:GraphQLString},
+            data:{type:GraphQLString},
+        }
+    })
+    let qlObjectTypeParams={};
+    qlObjectTypeParams.name=tableName;
+    qlObjectTypeParams.fields={};
+       tableSchema.forEach(u=>{
+           qlObjectTypeParams.fields[u.column_name]={
+                type:getGraphTypeBySqlType(u.column_type),
+                description:u.column_comment};
+         })
+    const qlObjectType = new GraphQLObjectType(qlObjectTypeParams)
+    const RootQuery = new GraphQLObjectType({
+        name:tableName+'Query',
+        fields:{
+            rows:{
+                type: new GraphQLList(qlObjectType),
+                args:{...qlObjectTypeParams.fields,
+                        page:{type:GraphQLInt, description:"页码"},
+                        num:{type:GraphQLInt, description:"每页条数"},
+                        order:{type:GraphQLInt, description:"排序"}
+                     },
+                async resolve(parentValue,args){
+                    const {page=1,num=10,order="id",...queryCase}=args;
+                    const queryCaseStr=  obj2QueryCase(queryCase);
+                    return dbBaseMapper.selectPurePageList({
+                        page,
+                        num,
+                        order,
+                        queryCase:queryCaseStr})
+                }
+            },
+            total:{
+                    type: GraphQLInt,
+                    args:qlObjectTypeParams.fields,
+                    async resolve(parentValue,args){
+                        const {page=1,num=10,order="id",...queryCase}=args;
+                        const queryCaseStr=  obj2QueryCase(queryCase);
+                        return dbBaseMapper.selectCount({queryCase:queryCaseStr})
+                    }
+            }
+        }
+    })
+
+    var mutation = new GraphQLObjectType({
+        name:tableName+"Mutation",
+        fields:{
+            add:{
+                type:ResponseType,
+                args:qlObjectTypeParams.fields,
+                async resolve(parenValue,args){
+                    if(generateTime){
+                        args.gmt_create=new Date().format("yyyy-MM-dd hh:mm:ss");
+                    }
+                    await dbBaseMapper.insert(args);
+                    return {code:0,msg:"success"}
+                }
+            },
+            update:{
+                type:ResponseType,
+                args:qlObjectTypeParams.fields,
+                async resolve(parenValue,args){
+                     const   {id,...updateObj}=args;
+                    if(generateTime){
+                        updateObj.gmt_modified=new Date().format("yyyy-MM-dd hh:mm:ss");
+                    }
+                     await dbBaseMapper.update(updateObj,`id=${id}`)
+                     return {code:0,msg:"success"}
+                   }
+                }
+            ,
+            delete:{
+                type:ResponseType,
+                args:qlObjectTypeParams.fields,
+                async resolve(parenValue,args){
+                    const queryCaseStr=  obj2QueryCase(args);
+                    await dbBaseMapper.delete(queryCaseStr);
+                    return {code:0,msg:"ok"}
+                }
+            }
+        }
+
+    })
+    const schema = new GraphQLSchema({
+        query: RootQuery,
+        mutation: mutation
+    })
+    return schema;
+}
+
+
+
+module.exports=getGraphqlSchema;

package/plugins/BaseGraphqlApi/getGraphqlSchemaDemo.js

@@ -0,0 +1,76 @@
+M=require("../../index")
+
+const{
+    GraphQLObjectType,
+    GraphQLString,
+    GraphQLInt,
+    GraphQLSchema,
+    GraphQLList,
+    GraphQLNonNull
+} = require('graphql');
+
+
+
+
+function getGraphqlSchema({dbBaseMapper}){
+
+    const ResponseType =  new GraphQLObjectType({
+        name:'response',
+        fields:{
+            status:{type:GraphQLInt},
+            msg:{type:GraphQLString}
+        }
+    })
+
+    const qlObjectType = new GraphQLObjectType({
+        name:'person',
+        fields:{
+            id:{type:GraphQLInt},
+            name:{type:GraphQLString}
+        }
+    })
+
+    const RootQuery = new GraphQLObjectType({
+        name:'personQuery',
+        fields:{
+            person:{
+                type: new GraphQLList(qlObjectType),
+                args:{
+                    id:{type:GraphQLInt},
+                    name:{type:GraphQLString}
+                },
+                async resolve(parentValue,args){
+                    return Db.doSql(`select * from person`);
+                }
+            }
+        }
+    })
+
+
+
+    var mutation = new GraphQLObjectType({
+        name:"Mutation",
+        fields:{
+            addPerson:{
+                type:ResponseType,
+                args:{
+                    name:{type:GraphQLString}
+                },
+                async resolve(parenValue,args){
+                    //await personDao.insert(args.name)
+                    return {status:0,msg:"ok"}
+                }
+            }
+        }
+
+    })
+    const schema = new GraphQLSchema({
+        query: RootQuery,
+        mutation: mutation
+    })
+    return schema;
+}
+
+
+
+module.exports=getGraphqlSchema;

package/plugins/BaseGraphqlApi/index.js

@@ -0,0 +1,23 @@
+var getGraphqlSchema= require("./getGraphqlSchema")
+const { graphqlHTTP } = require('express-graphql')
+
+class BaseGraphqlApi{
+    constructor({dbBaseMapper,prefix,generateTime}) {
+        this.dbBaseMapper=dbBaseMapper;
+        this.tableName=dbBaseMapper.tableName;
+        this.prefix=prefix?prefix:tableName;
+        this.generateTime=generateTime;
+    }
+    async install(app,args){
+        let schema=await getGraphqlSchema({
+            dbBaseMapper:this.dbBaseMapper,
+            generateTime:this.generateTime}
+        );
+
+        app.mapping(`/${this.prefix}`,graphqlHTTP({
+            schema:schema,
+            graphiql:true
+        }))
+    }
+}
+module.exports = BaseGraphqlApi;

package/plugins/BaseRestApi/AbstractBaseRestApi.js

@@ -0,0 +1,59 @@
+const M=require("../../index");
+
+class AbstractBaseRest{
+
+    constructor({tableName,prefix,generateTime=false}) {
+        this.tableName=tableName;
+        this.prefix=prefix?prefix:tableName;
+        this.generateTime=generateTime;
+    }
+
+    async add(obj){}
+    async delete(obj){}
+    async list({page,num,...queryCase}){}
+    async listAll(obj){}
+    async update(obj){}
+    async getChildenList(id,queryCase){}
+
+    install(app,args){
+        app.post(`${this.prefix}`,async (req,res)=>{
+            const params=req.params;
+            if(this.generateTime){
+                params.gmt_create=new Date();
+            }
+            let r=await this.add(params)
+            res.send(M.successResult(r));
+        })
+        app.delete(`${this.prefix}`,async (req,res)=>{
+            let r=await this.delete(req.params);
+            res.send(M.successResult(r));
+        });
+
+        /**
+         * 修改
+         */
+        app.put(`${this.prefix}`,async (req,res)=>{
+            const params=req.params;
+            if(this.generateTime){
+                params.gmt_modified=new Date();
+            }
+            await this.update(params);
+            res.send(M.successResult());
+        });
+
+        app.get(`${this.prefix}/:id`,async (req,res)=>{
+            const {id,page,num,...queryCase}=req.params;
+            if(id==undefined){
+                let r=await this.list({page,num,queryCase});
+                res.send(M.successResult(r));
+            }else {
+                let r=await this.getById(req.params.id);
+                res.send(M.successResult(r));
+            }
+        });
+    }
+}
+
+
+
+module.exports = AbstractBaseRest;

package/plugins/BaseRestApi/ApiCloudBaseRestApi.js

@@ -0,0 +1,56 @@
+/**
+ * 数据源为内存的rpc风格接口
+ */
+const AbstractBaseRestApi=require("./AbstractBaseRestApi");
+
+
+class ApiCloudBaseRestApi extends AbstractBaseRestApi{
+    constructor(props) {
+        super(props);
+        this.appid=props.appid;
+        this.appkey=props.appkey;
+        this.apiCloudClient = props.apiCloudClient;
+        this.tableClient= this.apiCloudClient.tableClient(props.tableName);
+    }
+    async add(obj){
+       let r= await this.tableClient.add(obj);
+       return r;
+    }
+
+    async delete(obj){
+        let r= await this.tableClient.delete(obj);
+        return r;
+    }
+
+    async getById(id){
+        let r=await this.tableClient.list({id},null,null,"sort");
+        return r[0];
+    }
+
+    async list({page=1,num=10,queryCase}){
+        page=Number.parseInt(page);
+        num=Number.parseInt(num);
+        let limit=num;
+        let skip= (page-1)*num
+        let r=await this.tableClient.list(queryCase,limit,skip,"createdAt ASC");
+        return r;
+    }
+
+    async listAll(obj){
+        let r=await this.tableClient.list(obj,null,null,"sort");
+        return r;
+    }
+
+    async update(obj){
+        let r=  await this.tableClient.update(obj);
+        return r;
+    }
+
+    async getChildenList(id,caseObj){
+        let r= this.listAll({parent_id:id,...caseObj});
+        return r;
+    }
+}
+
+
+module.exports = ApiCloudBaseRestApi;

package/plugins/BaseRestApi/FileBaseRestApi.js

@@ -0,0 +1,62 @@
+/**
+ * 数据源为内存的rpc风格接口
+ */
+const M=require("../../index")
+const AbstractBaseRestApi=require("./AbstractBaseRestApi");
+
+class FileBaseRestApi extends AbstractBaseRestApi{
+    constructor(props) {
+        super(props);
+    }
+    async add(obj){
+        obj.id = M.randomStr();
+        M.addObjToFile(this.tableName, obj);
+        return obj;
+    }
+
+    async delete(obj){
+        let r=0;
+        if (obj) {
+            r= M.deleteObjByPropFile(this.tableName, obj);
+        } else {
+            r=M.writeObjToFile(this.tableName,[]);
+        }
+        return r;
+    }
+
+    async getById(id){
+        let r=M.getById(this.tableName,id);
+        return r;
+    }
+
+    async list({page=1,num=10,queryCase}){
+        page=Number.parseInt(page);
+        num=Number.parseInt(num);
+        if (page <= 0) page = 1;
+        let rows =await this.listAll(queryCase);
+        let total = rows.length;
+        rows = rows.splice((page - 1) * num, num)
+        return {rows, total}
+    }
+
+    async listAll(obj){
+        if (obj) {
+            return M.listAllObjByPropFile(this.tableName, obj);
+        } else {
+            return M.getObjByFile(this.tableName);
+        }
+    }
+
+    async update(obj){
+        let r=  M.updateObjByIdFile(this.tableName,obj);
+        return r;
+    }
+
+    async getChildenList(id,caseObj){
+        let r= this.listAll({parent_id:id,...caseObj});
+        return r;
+    }
+}
+
+
+module.exports = FileBaseRestApi;

package/plugins/BaseRestApi/MemoryBaseRestApi.js

@@ -0,0 +1,50 @@
+/**
+ * 数据源为内存的rpc风格接口
+ */
+const MemoryDb=require("../../module/MemoryDb");
+const AbstractBaseRestApi=require("./AbstractBaseRestApi");
+
+class MemoryBaseRestApi extends AbstractBaseRestApi{
+
+    constructor(props) {
+       super(props);
+       this.memoryDb=new MemoryDb(props.tableName);
+    }
+    async add(obj){
+        let r= this.memoryDb.add(obj);
+        return r;
+    }
+
+    async delete(obj){
+        let r= this.memoryDb.deleteAll(obj);
+        return r;
+    }
+
+    async getById(id){
+        let r=this.memoryDb.getById(id);
+        return r;
+    }
+
+    async list({page,num,queryCase}){
+        let r= this.memoryDb.listByPage(page,num,queryCase);
+        return r;
+    }
+
+    async listAll(obj){
+        let r= this.memoryDb.listAll(obj);
+        return r;
+    }
+
+    async update(obj){
+        let r= this.memoryDb.update(obj);
+        return r;
+    }
+
+    async getChildenList(id,caseObj){
+        let r= this.memoryDb.listAll({parent_id:id,...caseObj});
+        return r;
+    }
+}
+
+
+module.exports = MemoryBaseRestApi;

package/plugins/BaseRestApi/MongoDbBaseRestApi.js

@@ -0,0 +1,75 @@
+/**
+ * @type {MemoryDb|{}}
+ */
+const M=require("../../index");
+const AbstractBaseRestApi=require("./AbstractBaseRestApi");
+
+
+class MongoDbBaseRestApi extends AbstractBaseRestApi{
+    constructor(props) {
+        super(props);
+        this.mongoDb=M.mongoDb;
+    }
+
+    async add(obj){
+        let r= this.mongoDb.insert(this.tableName,obj);
+        return r;
+    }
+
+    async delete(obj){
+        let r= this.mongoDb.remove(this.tableName,{
+            _id:  M.mongoDb.ObjectID(obj.id)
+        });
+        return r;
+    }
+
+    async getById(id){
+        let r=await this.mongoDb.getById(this.tableName,id);
+        return r;
+    }
+
+    async list({page=1,num=10,queryCase}){
+        page=Number.parseInt(page);
+        num=Number.parseInt(num);
+        let tableName=this.tableName;
+        return new Promise(async (resolve,reject)=>{
+            this.mongoDb.connect().then((db)=>{
+                var result=db.collection(this.tableName).find(queryCase,{
+                    skip:(page-1)*num,
+                    limit:num
+                });
+                result.toArray(async function(err,docs){
+                    if(err){
+                        reject(err);
+                        return;
+                    }
+                    let total=await db.collection(tableName).count(queryCase);
+                    resolve({rows:docs,total:total});
+                })
+            })
+        })
+    }
+
+
+    async listAll(obj){
+        let r= this.mongoDb.find(this.tableName,obj);
+        return r;
+    }
+
+    async update(obj){
+        let {id,...newObj}=obj;
+        let r= this.mongoDb.update(this.tableName,{
+            _id:  M.mongoDb.ObjectID(id)
+        },newObj);
+        return r;
+    }
+
+    async getChildenList(id,caseObj){
+        let r= this.listAll({parent_id:id,...caseObj});
+        return r;
+    }
+
+}
+
+
+module.exports = MongoDbBaseRestApi;

package/plugins/BaseRestApi/MysqlBaseRestApi.js

@@ -0,0 +1,72 @@
+/**
+ * @type {MemoryDb|{}}
+ */
+
+const BaseMapper=require("../../module/BaseMapper");
+const AbstractBaseRestApi=require("./AbstractBaseRestApi");
+
+
+class MysqlBaseRestApi extends AbstractBaseRestApi{
+    constructor(props) {
+        super(props);
+        this.dbBaseMapper= new BaseMapper(this.tableName);
+    }
+
+    async add(obj){
+        if(obj.gmt_create){
+            obj.gmt_create=obj.gmt_create.format("yyyy-MM-dd hh:mm:ss");
+        }
+        let r= this.dbBaseMapper.insert(obj);
+        return r;
+    }
+
+    async delete(obj){
+        let r= this.dbBaseMapper.delete(obj);
+        return r;
+    }
+
+    async getById(id){
+        let r=await this.dbBaseMapper.selectById({id});
+        return r;
+    }
+
+    async list({page,num,queryCase}){
+        let queryCaseStr= MysqlBaseRestApi.obj2QueryCase(queryCase);
+        let r= this.dbBaseMapper.selectPage({page,num,queryCase:queryCaseStr});
+        return r;
+    }
+
+    async listAll(obj){
+        let queryCase= MysqlBaseRestApi.obj2QueryCase(obj);
+        let r= this.dbBaseMapper.selectList({queryCase:queryCase});
+        return r;
+    }
+
+    async update(obj){
+        if(obj.gmt_modified){
+            obj.gmt_modified=obj.gmt_modified.format("yyyy-MM-dd hh:mm:ss");
+        }
+        let {id,...newObj}=obj;
+        let r= this.dbBaseMapper.update(newObj,`id=${id}`);
+        return r;
+    }
+
+    async getChildenList(id,caseObj){
+        let r= this.listAll({parent_id:id,...caseObj});
+        return r;
+    }
+
+    static obj2QueryCase(obj){
+        let queryCase="1=1";
+        if(obj && Object.keys(obj).length>0){
+            for(var p in obj) {
+                queryCase=queryCase+` and ${p}='${obj[p]}' `
+            }
+        }
+        return queryCase;
+
+    }
+}
+
+
+module.exports = MysqlBaseRestApi;

package/plugins/BaseRpcApi/AbstractBaseRpcApi.js

@@ -0,0 +1,72 @@
+const CollectionUtils=require("../../utils/common/CollectionUtils");
+const M=require("../../index");
+
+class AbstractBaseRpcApi{
+
+    constructor({tableName,prefix,generateTime=false}) {
+        this.tableName=tableName;
+        this.prefix=prefix?prefix:tableName;
+        this.generateTime=generateTime;
+    }
+
+    async add(obj){}
+    async delete(obj){}
+    async list({page,num,...queryCase}){}
+    async listAll(obj){}
+    async update(obj){}
+    async getChildenList(id,queryCase){}
+
+    install(app,args){
+        app.post(`${this.prefix}/add`,async (req,res)=>{
+            const params=req.params;
+            if(this.generateTime){
+                params.gmt_create=new Date();
+            }
+            let r=await this.add(params)
+            res.send(M.successResult(r));
+        })
+        app.post(`${this.prefix}/delete`,async (req,res)=>{
+            let r=await this.delete(req.params);
+            res.send(M.successResult(r));
+        });
+
+        app.post(`${this.prefix}/update`,async (req,res)=>{
+            const params=req.params;
+            if(this.generateTime){
+                params.gmt_modified=new Date();
+            }
+            await this.update(params);
+            res.send(M.successResult());
+        });
+
+        app.get(`${this.prefix}/getById`,async (req,res)=>{
+            let r=await this.getById(req.params.id);
+            res.send(M.successResult(r));
+        });
+
+        app.get(`${this.prefix}/listAll`,async (req,res)=>{
+            const params=req.params;
+            let r=await this.listAll(params);
+            res.send(M.successResult(r));
+        });
+
+        app.get(`${this.prefix}/list`,async (req,res)=>{
+            const {page,num,...queryCase}=req.params;
+            let r=await this.list({page,num,queryCase});
+            res.send(M.successResult(r));
+        })
+
+        /**
+         * 如果有parent_id才能返回树
+         */
+        app.get(`${this.prefix}/tree`,async (req,res)=>{
+            const {parent_id,...queryCase}=req.params;
+            let r=await  CollectionUtils.selectTree(this.getChildenList.bind(this), parent_id,queryCase);
+            res.send(M.successResult(r));
+        })
+    }
+}
+
+
+
+module.exports = AbstractBaseRpcApi;