yaml-admin-api 0.0.19 → 0.0.20

package/README.md

@@ -209,7 +209,7 @@ Export response
 ```
 Import response
 ```json
-{ "r": true, "msg": "Import success - <n> rows effected" }
+{ "r": true, "msg": "Import success - <n> new rows inserted" }
 ```
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yaml-admin-api",
-  "version": "0.0.19",
+  "version": "0.0.20",
   "license": "MIT",
   "description": "YAML Admin API package",
   "type": "commonjs",
@@ -19,6 +19,7 @@
     "bcryptjs": "^3.0.2",
     "jsonwebtoken": "^9.0.2",
     "moment": "^2.30.1",
+    "moment-timezone": "^0.6.0",
     "mongodb": "^6.18.0",
     "request": "^2.88.2",
     "uuid": "^11.1.0",

package/src/crud/chart-api-generator.js

@@ -0,0 +1,393 @@
+const { withConfig } = require('../login/auth.js');
+const moment = require('moment-timezone');
+const { makeMongoSortFromYml } = require('./crud-common.js');
+
+/**
+
+ * @param {*} app 
+ * @param {*} db 
+ * @param {*} yml 
+ */
+const generateChartApi = async (app, db, yml) => {
+    const { front } = yml;
+    const dashboard = front?.dashboard;
+    if (!dashboard)
+        return;
+
+    const chartComponents = dashboard.filter(m => m.component === 'chart');
+    if (chartComponents.length === 0)
+        return;
+
+    const auth = withConfig({ db, jwt_secret: yml.login["jwt-secret"] });
+
+    const createChartDataTypeDate = async (chart, {from_date}) => {
+        const r = {
+            options: {
+                chart: { id: chart.id },
+                xaxis: { categories: [] }
+            },
+            colors: [],
+            series: []
+        }
+        const { x, y, relation } = chart;
+        if (y && Array.isArray(y.series)) {
+            const definedColors = y.series.map(s => s && s.color).filter(Boolean);
+            if (definedColors.length > 0) {
+                r.options.colors = definedColors;
+            }
+        }
+
+        const { field, entity : entity_x, format, gap, limit, desc, timezone } = x;
+        const { entity : entity_y } = y;
+
+        for (const s of y.series) {
+            const { label } = s;
+            const match = evaluateIfToMatch(s['if']);
+
+            let lookup_list = []
+            if (relation) {
+                let x_chain = relation_chain_y_to_x.find(f=>f.entity === entity_x)
+                let lookup = {
+                    from: entity_y,
+                    let: { root_x_key: `$${x_chain.match_from}` },
+                    pipeline: [],
+                      as: entity_y,
+                }
+
+                for(let i=0;i<relation_chain_y_to_x.length;i++) {
+                    const m = relation_chain_y_to_x[i]
+                    lookup.pipeline.push({
+                        $lookup: {
+                            from: m.entity,
+                            localField: m.match_from,
+                            foreignField: m.match,
+                            as: m.entity
+                        },
+                    })
+                    lookup.pipeline.push({ $unwind: `$${m.entity}` })
+                }
+
+                lookup.pipeline.push({ $match: { $expr: { $eq: [`$${x_chain.match}`, `$$root_x_key`] } } },)
+                lookup.pipeline.push({ $count: 'n' })
+                lookup_list.push({$lookup:lookup})
+                lookup_list.push({
+                    $unwind: {
+                        path: `$${entity_y}`,
+                        preserveNullAndEmptyArrays:true,
+                    },
+                })
+            }
+
+            let group_list = []
+            group_list.push({
+                $group: {
+                    _id: {
+                        $dateTrunc: {
+                            date: `$${field}`,
+                            unit: gap,
+                            timezone: timezone
+                        }
+                    },
+                    "count": { "$sum": 1 }
+                }
+            })
+
+            let a = [
+                { $match: {server_id:148, parent_id:null}},
+                ...lookup_list,
+                { $match: match},
+                ...group_list,
+                { $sort: { _id: -1 } },
+            ]
+
+            if(limit)
+                a.push({ $limit: limit })
+
+            const list = await db.collection(entity_x).aggregate(a).toArray();
+            
+            list.map(m => {
+                if (format)
+                    return moment.tz(m._id, timezone).format(format);
+                else
+                    return m._id;
+            });
+
+            if(!from_date)
+                from_date = moment().tz(timezone).format('YYYYMMDD');
+            
+            r.options.xaxis.categories = []
+            let cmoment = moment.tz(from_date, timezone);
+            for(let i=0; i<limit; i++) {
+                r.options.xaxis.categories.push(cmoment.format(format));
+                cmoment.add(-1, gap)
+            }
+            if(!desc)
+                r.options.xaxis.categories.reverse();
+            r.series.push({ name: label, data: r.options.xaxis.categories.map(m=>{
+                return list.find(l=>moment.tz(l._id, timezone).format(format) === m)?.count || 0;
+            })});
+        }
+
+        return r
+    }
+
+    const createChartDataTypeField = async (chart) => {
+        const r = {
+            options: {
+                chart: { id: chart.id },
+                xaxis: { categories: [] }
+            },
+            colors: [],
+            series: []
+        }
+        const { x, y, relation } = chart;
+        if (y && Array.isArray(y.series)) {
+            const definedColors = y.series.map(s => s && s.color).filter(Boolean);
+            if (definedColors.length > 0) {
+                r.options.colors = definedColors;
+            }
+        }
+
+        const { field, entity : entity_x, format, gap, limit, desc, sort } = x;
+        const { entity : entity_y } = y;
+
+        for (const s of y.series) {
+            const { label } = s;
+            
+            let match_list = []
+            if(s['if'] && !relation)
+                match_list.push({ $match: evaluateIfToMatch(s['if'])})
+
+            let lookup_list = []
+            if (relation) {
+                if(!relation.chain)
+                    throw new Error('relation.chain is required');
+                if(!relation.match)
+                    throw new Error('relation.match is required');
+
+                let lookup = {
+                    from: entity_y,
+                    let: { root_x_key: `$${relation.match.x}` },
+                    pipeline: [],
+                      as: entity_y,
+                }
+
+                for(let i=0;i<relation.chain.length;i++) {
+                    const m = relation.chain[i]
+                    lookup.pipeline.push({
+                        $lookup: {
+                            from: m.entity,
+                            localField: m.match_from,
+                            foreignField: m.match,
+                            as: m.entity
+                        },
+                    })
+                    lookup.pipeline.push({ $unwind: `$${m.entity}` })
+                }
+
+                
+                if(s['if'])
+                    lookup.pipeline.push({ $match: evaluateIfToMatch(s['if'])})
+
+                lookup.pipeline.push({ $match: { $expr: { $eq: [`$${relation.match.with}`, `$$root_x_key`] } } },)
+                lookup.pipeline.push({ $count: 'n' })
+                lookup_list.push({$lookup:lookup})
+                lookup_list.push({
+                    $unwind: {
+                        path: `$${entity_y}`,
+                        preserveNullAndEmptyArrays:true,
+                    },
+                })
+            }
+
+            let group_sort_field = {}
+            sort && sort.map(m=>{
+                group_sort_field[m.name] = {
+                    $max: `$${m.name}`
+                  }
+            })
+
+            let group_list = []
+            if(relation) {
+                group_list.push({
+                    $group: {
+                        _id: `$${field}`,
+                        "count": { "$sum": `$${entity_y}.n` },
+                        ...group_sort_field
+                    }
+                })
+            } else {
+                group_list.push({
+                    $group: {
+                        _id: `$${field}`,
+                        "count": { "$sum": 1 },
+                        ...group_sort_field
+                    }
+                })
+            }
+
+            let a = [
+                { $match: {server_id:148, parent_id:null}},
+                ...lookup_list,
+            ]
+
+            a.push(...group_list)
+            
+            if(sort)
+                a.push({ $sort: makeMongoSortFromYml(sort) })
+
+            if(limit)
+                a.push({ $limit: limit })
+
+            //debug
+            if(chart.debug)
+                console.log('a', entity_x, JSON.stringify(a, null, 2))
+
+            const list = await db.collection(entity_x).aggregate(a).toArray();
+
+            r.options.xaxis.categories = list.map(m => m._id);
+            r.series.push({ name: label, data: list.map(m => m.count) });
+        }
+
+        return r
+    }
+
+    for (const chart of chartComponents) {
+        const { id } = chart;
+        console.log('generateChartApi', chart.id)
+
+        /**
+         return sample {
+            options: {
+                chart: {
+                    id: "basic-bar"
+                },
+                xaxis: {
+                    categories: [1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998]
+                }
+            },
+            series: [
+                {
+                    name: "series-1",
+                    data: [30, 40, 45, 50, 49, 60, 70, 91]
+                },
+                {
+                    name: "series-2",
+                    data: [30, 40, 45, 50, 49, 60, 70, 91]
+                }
+            ]
+        }
+        */
+        app.get(`/api/chart/${id}`, auth.isAuthenticated, async (req, res) => {
+            try {
+                const { x } = chart;
+                let r
+                if (x.type == 'date') {
+                    let {from_date} = req.query //YYYYMMDD
+                    r = await createChartDataTypeDate(chart, {from_date});
+                } else if(x.type == 'field') {
+                    r = await createChartDataTypeField(chart);
+                } else {
+                    throw new Error('x.type is not date or field');
+                }
+
+                res.json(r);
+            } catch (e) {
+                console.error(e);
+                res.status(400).json({ r: false, msg: e.message });
+            }
+        })
+    }
+}
+/**
+ * 'lock==true' or 'lock!=true' to mongodb match format like {lock:true} , {lock:{$ne:true}}
+ * @param {*} expression  
+ * @returns 
+ */
+function evaluateIfToMatch(expression) {
+    if (!expression || typeof expression !== 'string') return {};
+    const exp = expression.trim();
+
+    // Support shorthand truthy checks: "flag" => { flag: true }, "!flag" => { flag: { $ne: true } }
+    if (!/[=!<>]/.test(exp)) {
+        if (exp.startsWith('!')) {
+            const field = exp.substring(1).trim();
+            if (!field) return {};
+            return { [field]: { $ne: true } };
+        }
+        return { [exp]: true };
+    }
+
+    const match = exp.match(/^(.+?)(==|!=|>=|<=|>|<)\s*(.+)$/);
+    if (!match) return {};
+
+    const field = match[1].trim();
+    const op = match[2];
+    const rightRaw = match[3].trim();
+
+    const parseLiteral = (raw) => {
+        if (raw === undefined || raw === null) return raw;
+        let v = raw.trim();
+
+        // strip quotes if wrapped
+        if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith('\'') && v.endsWith('\''))) {
+            return v.substring(1, v.length - 1);
+        }
+        if (v.toLowerCase() === 'true') return true;
+        if (v.toLowerCase() === 'false') return false;
+        if (v.toLowerCase() === 'null') return null;
+
+        // Array or object JSON
+        if (v.startsWith('[') || v.startsWith('{')) {
+            try {
+                // allow single-quoted json by converting to double quotes conservatively
+                const normalized = v.replace(/'([^']*)'/g, '"$1"');
+                return JSON.parse(normalized);
+            } catch (e) {
+                // fallthrough
+            }
+        }
+
+        // number
+        const num = Number(v);
+        if (!Number.isNaN(num) && v !== '') return num;
+
+        // ISO date
+        const isoDateRegex = /^\d{4}-\d{2}-\d{2}(?:[T\s]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?(?:Z|[+-]\d{2}:?\d{2})?)?$/;
+        if (isoDateRegex.test(v)) {
+            const d = new Date(v);
+            if (!isNaN(d.getTime())) return d;
+        }
+
+        return v;
+    };
+
+    const value = parseLiteral(rightRaw);
+
+    switch (op) {
+        case '==':
+            if (Array.isArray(value)) return { [field]: { $in: value } };
+            return { [field]: value };
+        case '!=':
+            if (Array.isArray(value)) return { [field]: { $nin: value } };
+            return { [field]: { $ne: value } };
+        case '>':
+            return { [field]: { $gt: value } };
+        case '>=':
+            return { [field]: { $gte: value } };
+        case '<':
+            return { [field]: { $lt: value } };
+        case '<=':
+            return { [field]: { $lte: value } };
+        default:
+            return {};
+    }
+}
+
+function getPath(obj, path) {
+    return path.split('.').reduce((acc, k) => (acc && acc[k] !== undefined ? acc[k] : undefined), obj);
+}
+
+module.exports = {
+    generateChartApi
+}

package/src/crud/crud-common.js

@@ -0,0 +1,12 @@
+const makeMongoSortFromYml = (sort) => {
+    sort = sort || []
+    let r = {}
+    sort.map(m=>{ 
+        r[m.name] = m.desc == true ? -1 : 1
+    })
+    return r
+}
+
+module.exports = {
+    makeMongoSortFromYml
+}

package/src/crud/entity-api-generator.js

@@ -8,6 +8,14 @@ const XLSX = require('xlsx');
 const moment = require('moment');
 const { withConfigLocal } = require('../upload/localUpload.js');
 const { withConfigS3 } = require('../upload/s3Upload.js');
+const { makeMongoSortFromYml } = require('./crud-common.js');
+
+const asyncErrorHandler = (fn) => (req, res, next) => {
+    return Promise.resolve(fn(req, res, next)).catch(async e=>{
+        console.error(e);
+        res.status(400).json({ status: 400, statusText: 'error', message: e.message })
+    });
+}
 
 const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options }) => {
 
@@ -16,6 +24,7 @@ const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options })
     const api_host = yml["api-host"].uri;
     let isS3 = yml.upload.s3
     let host_image = isS3 ? yml.upload.s3.base_url : yml.upload.local.base_url
+
     const uploader = yml.upload.s3 ? withConfigS3({
         access_key_id: yml.upload.s3.access_key_id,
         secret_access_key: yml.upload.s3.secret_access_key,
@@ -43,7 +52,7 @@ const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options })
 
     const generateKey = async () => {
         if (key_field.type == 'integer')
-            return await genEntityIdWithKey(db, key_field.name)
+            return await genEntityIdWithKey(db, entity_name)
         else if (key_field.type == 'string')
             return uuidv4()
         return null
@@ -67,10 +76,12 @@ const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options })
     }
 
     const parseValueByType = (value, field) => {
-        const { type, reference_entity, reference_field } = field
+        const { type, reference_entity, reference_match } = field
         if (type == 'reference') {
             const referenceEntity = yml.entity[reference_entity]
-            const referenceField = referenceEntity.fields.find(f => f.name == reference_field)
+            const referenceField = referenceEntity.fields.find(f => f.name == reference_match)
+            if(!referenceField)
+                throw new Error(`Reference field ${reference_match} not found in ${reference_entity}`)
             return parseValueByTypeCore(value, referenceField)
         } else {
             return parseValueByTypeCore(value, field)
@@ -79,7 +90,10 @@ const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options })
     const parseValueByTypeCore = (value, field) => {
         const { type } = field
         if (type == 'integer')
-            return parseInt(value)
+            if(value)
+                return parseInt(value)
+            else
+                return null
         else if (type == 'string')
             return value
         else if (type == 'objectId')
@@ -111,6 +125,8 @@ const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options })
                 m[field.name] = await mediaToFront(m[field.name], field.private)
             }
         }
+
+        let apiGenerateFields = await makeApiGenerateFields(db, entity_name, yml_entity, yml, options, list)
     }
 
     const mediaKeyToFullUrl = async (key, private) => {
@@ -128,7 +144,8 @@ const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options })
 
     const mediaToFront = async (media, private) => {
         if (media && typeof media == 'string') {
-            media= { src: url }
+            const url = media
+            media = { src: url }
             media.image_preview = await mediaKeyToFullUrl(url, private)
         } else if (media && typeof media == 'object') {
             let { image, video, src } = media
@@ -142,7 +159,8 @@ const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options })
     
 
     //list
-    app.get(`/${entity_name}`, auth.isAuthenticated, async (req, res) => {
+    app.get(`/${entity_name}`, auth.isAuthenticated, asyncErrorHandler(async (req, res) => {
+        //검색 파라미터
         var s = {};
         var _sort = req.query._sort;
         var _order = req.query._order;
@@ -162,15 +180,20 @@ const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options })
                 if (Array.isArray(q)) {
                     f[field.name] = { $in: q.map(v => parseValueByType(v, field)) };
                 } else {
-                    if (search?.exact != false || field.type == 'integer')
+                    if (search?.exact != false || field.type == 'integer') {
                         f[field.name] = parseValueByType(q, field)
-                    else
+                    } else
                         f[field.name] = { $regex: ".*" + q + ".*" };
                 }
+            } else {
+                //empty query - $exists : false
+                if(req.query[field.name] == '')
+                    f[field.name] = null
             }
         })
 
         //console.log('f', f)
+        //console.log('s', s)
 
         var name = req.query.name;
         if (name == null && req.query.q)
@@ -193,9 +216,10 @@ const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options })
 
         //Custom list End
         await addInfo(db, list)
+
         res.header('X-Total-Count', count);
         res.json(list);
-    });
+    }));
 
 
     const constructEntity = async (req, entityId) => {
@@ -204,7 +228,20 @@ const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options })
         if (entityId)
             entity[key_field.name] = entityId
 
-        yml_entity.fields.forEach(field => {
+        yml_entity.fields
+        .filter(f => !['password', 'length'].includes(f.type))
+        //exclude field by api_generate
+        .filter(f => {
+            if(!yml_entity.api_generate)
+                return true;
+            if(yml_entity.api_generate[f.name])
+                return false;
+            if(f.name.includes('.') && yml_entity.api_generate[f.name.split('.')[0]]) {
+                return false;
+            }
+            return true;
+        })
+        .forEach(field => {
             if (!field.key)
                 entity[field.name] = req.body[field.name]
         })
@@ -212,7 +249,8 @@ const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options })
 
         let passwordFields = yml_entity.fields.filter(f => f.type == 'password').map(f => f.name)
         for(let f of passwordFields) {
-            entity[f] = await passwordEncrypt(req.body[f])
+            if(req.body[f])
+                entity[f] = await passwordEncrypt(req.body[f])
         }
         //Custom ConstructEntity Start
 
@@ -222,7 +260,7 @@ const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options })
     };
 
     //create
-    app.post(`/${entity_name}`, auth.isAuthenticated, async (req, res) => {
+    app.post(`/${entity_name}`, auth.isAuthenticated, asyncErrorHandler(async (req, res) => {
         let entityId
         if (key_field.autogenerate)
             entityId = await generateKey()
@@ -234,7 +272,7 @@ const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options })
             f[key_field.name] = entityId
             let already = await db.collection(entity_name).findOne(f)
             if (already)
-                return res.status(400).json({ status: 400, statusText: 'error', message: "duplicate key [" + entityId + "]" });
+                throw new Error("duplicate key of [" + key_field.name + "] - [" + entityId + "]")
         }
 
         const entity = await constructEntity(req, entityId);
@@ -247,14 +285,14 @@ const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options })
 
         var r = await db.collection(entity_name).insertOne(entity);
         //Custom Create Tail Start
-
+        options?.listener?.entityCreated?.(db, entity_name, entity)
         //Custom Create Tail End
 
         const generatedId = entityId || r.insertedId
         entity.id = (key_field.type == 'objectId') ? generatedId?.toString() : generatedId;
 
         res.json(entity);
-    });
+    }));
 
 
     //edit
@@ -275,18 +313,20 @@ const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options })
         let f = {}
         f[key_field.name] = entityId
 
-        for(let field of yml_entity.fields) {
-            if(['mp4', 'image', 'file'].includes(field.type)) {
+        for (let field of yml_entity.fields) {
+            if (['mp4', 'image', 'file'].includes(field.type)) {
                 let a = entity[field.name]
-                delete a.image_preview
-                delete a.video_preview
+                if (a) {
+                    delete a.image_preview
+                    delete a.video_preview
+                }
             }
         }
 
         await db.collection(entity_name).updateOne(f, { $set: entity });
 
         //Custom Create Tail Start
-
+        options?.listener?.entityUpdated?.(db, entity_name, entity)
         //Custom Create Tail End
 
         // Ensure React-Admin receives an `id` in the response
@@ -332,6 +372,8 @@ const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options })
         else
             await db.collection(entity_name).deleteOne(f);
 
+        options?.listener?.entityDeleted?.(db, entity_name, entity)
+
         res.json(entity);
     });
 
@@ -386,17 +428,17 @@ const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options })
             let header = list[0]
             list.shift();
 
-            let upsert = yml_entity.crud.list.import.upsert || true
-
-            const fields = yml_entity.crud.list.import.fields.map(m => m)
-            fields.map(field => {
+            let upsert = yml_entity.crud.import.upsert || true
+            let fields = yml_entity.crud.import.fields.map(m => m)
+            fields = fields.map(field => {
                 let original = yml_entity.fields.find(f => f.name == field.name)
-                field.type = original.type
+                return original
             })
 
             let key_field = yml_entity.fields.find(f => f.key)
             let bulk = []
-            list.map(m => {
+            let opsMeta = []
+            for(let m of list) {
                 let f = {}
 
                 let m_obj = {}
@@ -405,18 +447,30 @@ const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options })
                 })
 
                 f[key_field.name] = getKeyFromEntity(m_obj)
-                if (!f[key_field.name])
-                    return
+                if (!f[key_field.name]) {
+                    if(key_field.autogenerate) {
+                        f[key_field.name] = await generateKey()
+                    } else {
+                        continue
+                    }
+                }
+
                 let entity = {}
                 fields.forEach(field => {
-                    if (field.type == 'integer')
+                    if (field.type == 'integer') {
                         entity[field.name] = parseInt(m_obj[field.name])
-                    else if (field.type == 'password')
-                        entity[field.name] = passwordEncrypt(m_obj[field.name] + '')
+                    } else if (field.type == 'reference') {
+                        entity[field.name] = parseValueByType(m_obj[field.name], field)
+                    } else if (field.type == 'password')
+                        entity[field.name] = passwordEncrypt((m_obj[field.name] || '') + '')
                     else
-                        entity[field.name] = m_obj[field.name] + ''
+                        entity[field.name] = (m_obj[field.name] || '') + ''
                 })
 
+                delete entity[key_field.name]
+
+                const opIndex = bulk.length
+                opsMeta.push({ index: opIndex, key: f[key_field.name], entity })
                 bulk.push({
                     updateOne: {
                         filter: f,
@@ -424,10 +478,127 @@ const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options })
                         upsert: upsert
                     }
                 })
+            }
+
+            let result = await db.collection(entity_name).bulkWrite(bulk);
+            //result에서 update entity와 created entity list로 추출 해서 options?.listener?.entityCreated?.(entity_name, createdEntity)와 options?.listener?.entityUpdated?.(entity_name, updateEntity) 호출
+            try {
+                const upsertIndexToId = new Map()
+                if (result && result.upsertedIds) {
+                    Object.keys(result.upsertedIds).forEach(k => {
+                        const idx = parseInt(k)
+                        upsertIndexToId.set(idx, result.upsertedIds[k])
+                    })
+                }
+                if (result && typeof result.getUpsertedIds === 'function') {
+                    const arr = result.getUpsertedIds()
+                    if (Array.isArray(arr)) {
+                        arr.forEach(({ index, _id }) => {
+                            upsertIndexToId.set(index, _id)
+                        })
+                    }
+                }
+
+                const createdList = []
+                const updatedList = []
+                for (let meta of opsMeta) {
+                    if (upsertIndexToId.has(meta.index)) createdList.push(meta)
+                    else updatedList.push(meta)
+                }
+
+                // created
+                for (let { key, entity } of createdList) {
+                    const createdEntity = { ...entity }
+                    createdEntity[key_field.name] = key
+                    createdEntity.id = (key_field.type == 'objectId') ? (key && key.toString ? key.toString() : key) : key
+                    options?.listener?.entityCreated?.(db, entity_name, createdEntity)
+                }
+
+                // updated (include matched-but-not-modified as existing)
+                for (let { key, entity } of updatedList) {
+                    const updateEntity = { ...entity }
+                    updateEntity[key_field.name] = key
+                    updateEntity.id = (key_field.type == 'objectId') ? (key && key.toString ? key.toString() : key) : key
+                    options?.listener?.entityUpdated?.(db, entity_name, updateEntity)
+                }
+            } catch (e) {
+                // ignore listener errors to not break import
+            }
+            
+        
+            res.json({ r: true, msg: 'Import success - ' + result.upsertedCount + ' new rows inserted' });
+        })
+    }
+}
+
+/**
+ * ex)
+ * data_list
+ *  place: [{
+ *   id:1
+ *  }]
+ * 
+ * path = "place.id"
+ * @param {*} obj 
+ * @param {*} path 
+ * @returns 
+ */
+const matchPathInObject = (obj, path) => {
+    let r = obj[path]
+    if(!r && path.includes('.')) {
+        const parts = path.split('.')
+        let c = obj
+        for(let part of parts) {
+            c = c[part]
+            if(!c)
+                break;
+        }
+        r = c
+    }
+        
+    return r
+}
+
+const makeApiGenerateFields = async (db, entity_name, yml_entity, yml, options, data_list) => {
+    const apiGenerate = yml_entity.api_generate
+    if(!apiGenerate)
+        return;
+    for(let key in apiGenerate) {
+        
+        const apiGenerateItem = apiGenerate[key]
+        let { entity, field, fields, match, sort, limit, single, match_from } = apiGenerateItem
+
+        sort = sort || []
+        sort = makeMongoSortFromYml(sort)
+        limit = limit || 1000
+        
+        let match_from_list = data_list.map(m=>matchPathInObject(m, match_from))
+
+        match_from_list = match_from_list.filter(m=>m)
+        const f = { [match]: {$in:match_from_list} }
+        const projection = {[match]:1}
+
+        if(field)
+            projection[field] = 1
+        else
+            fields.map(m=>{
+                projection[m.name] = 1
             })
 
-            let result = await db.collection('delivery').bulkWrite(bulk);
-            res.json({ r: true, msg: 'Import success - ' + result.upsertedCount + ' rows effected' });
+        const result = await db.collection(entity).find(f).project(projection).sort(sort).limit(limit).toArray()
+        data_list.map(m=>{
+            let found = result.filter(f=>matchPathInObject(f, match) === matchPathInObject(m, match_from))
+            if(single) {
+                if(field)
+                    m[key] = found.length > 0 ? found[0][field] : null
+                else 
+                    m[key] = found.length > 0 ? found[0] : null
+            } else {
+                if(field)
+                    m[key] = found.map(f=>f[field])
+                else
+                    m[key] = found
+            }
         })
     }
 }

package/src/index.js

@@ -1,3 +1,3 @@
 const registerRoutes = require('./yml-admin-api.js');
-
-module.exports = { registerRoutes };
+const { genEntityIdWithKey } = require('./common/util.js');
+module.exports = { registerRoutes, genEntityIdWithKey };

package/src/yml-admin-api.js

@@ -3,6 +3,7 @@ const fs = require('fs').promises;
 const yaml = require('yaml');
 const { generateEntityApi } = require('./crud/entity-api-generator');
 const { generateLoginApi } = require('./crud/login-api-generator');
+const { generateChartApi } = require('./crud/chart-api-generator');
 const { withConfig } = require('./login/auth.js');
 const { generateUploadApi } = require('./upload/upload-api-generator');
 
@@ -47,6 +48,8 @@ async function registerRoutes(app, options = {}) {
   }
 
   await generateLoginApi(app, db, yml)
+  await generateChartApi(app, db, yml)
+  
   entity && Object.keys(entity).forEach(async (entity_name) => {
     await generateEntityApi({
       app, db,