yaml-admin-api 0.0.76 → 0.0.78

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yaml-admin-api",
-  "version": "0.0.76",
+  "version": "0.0.78",
   "license": "MIT",
   "description": "YAML Admin API package",
   "type": "commonjs",

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

@@ -19,6 +19,19 @@ const asyncErrorHandler = (fn) => (req, res, next) => {
 
 const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options }) => {
 
+    // entity 속성이 있으면 해당 값을 실제 collection 이름으로 사용
+    const collection_name = yml_entity.entity || entity_name
+
+    // filter 배열을 객체로 변환
+    let default_filter = {}
+    if (Array.isArray(yml_entity.filter)) {
+        yml_entity.filter.forEach(f => {
+            default_filter[f.name] = f.value
+        })
+    } else if (yml_entity.filter) {
+        default_filter = yml_entity.filter
+    }
+
     const auth = withConfig({ db, jwt_secret: yml.login["jwt-secret"] });
     const passwordEncoding = yml.login['password-encoding']
     const api_host = yml["api-host"].uri;
@@ -76,6 +89,32 @@ const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options })
         return key
     }
 
+    // unique 검사 함수
+    const checkUnique = async (entity, excludeId = null) => {
+        const uniqueFields = yml_entity.unique
+        if (!uniqueFields || uniqueFields.length === 0) return
+
+        const f = {}
+        for (const field of uniqueFields) {
+            f[field.name] = entity[field.name]
+        }
+
+        // 자기 자신 제외 (update 시)
+        if (excludeId !== null) {
+            f[key_field.name] = { $ne: excludeId }
+        }
+
+        const existing = await db.collection(collection_name).findOne(f)
+        if (existing) {
+            const fieldNames = uniqueFields.map(u => {
+                const fieldDef = yml_entity.fields?.find(field => field.name === u.name)
+                return fieldDef?.label || u.name
+            }).join(', ')
+            const fieldValues = uniqueFields.map(u => entity[u.name]).join(', ')
+            throw new Error("duplicate key of [" + fieldNames + "] - [" + fieldValues + "]")
+        }
+    }
+
     const parseValueByType = (value, field) => {
         const { type, reference_entity, reference_match } = field
         if(value == 'not null')
@@ -177,7 +216,7 @@ const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options })
      * @param {*} entity_name 
      */
     const recalcurateAutoGenerateIndex = async (db, entity_name) => {
-        const list = await db.collection(entity_name).find({})
+        const list = await db.collection(collection_name).find({})
             .project({ [key_field.name]: 1, _id: 0 })
             .sort({ [key_field.name]: -1 }).limit(1).toArray()
         const counter = await db.collection('counters').findOne({ _id: entity_name })
@@ -241,28 +280,31 @@ const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options })
             f['name'] = { $regex: ".*" + name + ".*" };
         f.remove = { $ne: true }
 
+        // default_filter 적용
+        Object.assign(f, default_filter)
+
         //Custom f list Start
 
         //Custom f list End
 
         const projection = (key_field.name == '_id' ? {} : { _id: false })
-        if(yml.debug)
-            console.log('list', entity_name, f)
-
         let list, count;
         let aggregate = await makeApiGenerateAggregate(db, entity_name, yml_entity, yml, options)
 
         if(aggregate?.length > 0) {
             aggregate = [...aggregate, {$match: f}]
-            const countResult = await db.collection(entity_name).aggregate([...aggregate, { $count: 'count' }]).toArray()
+            const countResult = await db.collection(collection_name).aggregate([...aggregate, { $count: 'count' }]).toArray()
             count = countResult.length > 0 ? countResult[0].count : 0
 
             aggregate = [...aggregate, { $sort: s }, { $skip: parseInt(_start) }, { $limit: l }]
-            list = await db.collection(entity_name).aggregate(aggregate).toArray()
-        } else 
-        {
-            count = await db.collection(entity_name).find(f).project(projection).sort(s).count()
-            list = await db.collection(entity_name).find(f).project(projection).sort(s).skip(parseInt(_start)).limit(l).toArray()
+            if(yml.debug)
+                console.log('list', entity_name, JSON.stringify(aggregate, null, 2))
+            list = await db.collection(collection_name).aggregate(aggregate).toArray()
+        } else {
+            if(yml.debug)
+                console.log('list', entity_name, f)
+            count = await db.collection(collection_name).find(f).project(projection).sort(s).count()
+            list = await db.collection(collection_name).find(f).project(projection).sort(s).skip(parseInt(_start)).limit(l).toArray()
         }
 
         if(yml.debug)
@@ -334,7 +376,7 @@ const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options })
         if (entityId) {
             let f = {}
             f[key_field.name] = entityId
-            let already = await db.collection(entity_name).findOne(f)
+            let already = await db.collection(collection_name).findOne(f)
             if (already)
                 throw new Error("duplicate key of [" + key_field.name + "] - [" + entityId + "]")
         }
@@ -343,11 +385,17 @@ const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options })
         entity['update_date'] = entity['create_date'] = new Date()
         entity['create_admin_id'] = req.user.id
 
+        // default_filter 값을 entity에 자동 적용
+        Object.assign(entity, default_filter)
+
+        // unique 검사
+        await checkUnique(entity)
+
         //Custom Create Start
 
         //Custom Create End
 
-        var r = await db.collection(entity_name).insertOne(entity);
+        var r = await db.collection(collection_name).insertOne(entity);
         //Custom Create Tail Start
         if(options?.listener?.entityCreated)
             await options.listener.entityCreated(db, entity_name, entity)
@@ -377,6 +425,7 @@ const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options })
 
         let f = {}
         f[key_field.name] = entityId
+        Object.assign(f, default_filter)
 
         for (let field of yml_entity.fields) {
             if (['mp4', 'image', 'file'].includes(field.type)) {
@@ -388,7 +437,10 @@ const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options })
             }
         }
 
-        await db.collection(entity_name).updateOne(f, { $set: entity });
+        // unique 검사 (자기 자신 제외)
+        await checkUnique(entity, entityId)
+
+        await db.collection(collection_name).updateOne(f, { $set: entity });
 
         //Custom Create Tail Start
         if(options?.listener?.entityUpdated)
@@ -405,16 +457,17 @@ const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options })
     app.get(`${api_prefix}/${entity_name}/:id`, auth.isAuthenticated, asyncErrorHandler(async (req, res) => {
         let f = {}
         f[key_field.name] = parseKey(req.params.id)
+        Object.assign(f, default_filter)
 
         let aggregate = await makeApiGenerateAggregate(db, entity_name, yml_entity, yml, options)
 
         let m
         if(aggregate?.length > 0) {
             aggregate = [{$match: f}, ...aggregate, { $limit: 1 }]
-            const result = await db.collection(entity_name).aggregate(aggregate).toArray()
+            const result = await db.collection(collection_name).aggregate(aggregate).toArray()
             m = result.length > 0 ? result[0] : null
         } else {
-            m = await db.collection(entity_name).findOne(f);
+            m = await db.collection(collection_name).findOne(f);
         }
 
         if (!m)
@@ -433,7 +486,8 @@ const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options })
     app.delete(`${api_prefix}/${entity_name}/:id`, auth.isAuthenticated, asyncErrorHandler(async (req, res) =>{
         let f = {}
         f[key_field.name] = parseKey(req.params.id)
-        const entity = await db.collection(entity_name).findOne(f);
+        Object.assign(f, default_filter)
+        const entity = await db.collection(collection_name).findOne(f);
         if (!entity)
             return res.status(404).send('Not found');
 
@@ -448,9 +502,9 @@ const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options })
         if (customDelete)
             ;
         else if (softDelete)
-            await db.collection(entity_name).updateOne(f, { $set: { remove: true } });
+            await db.collection(collection_name).updateOne(f, { $set: { remove: true } });
         else
-            await db.collection(entity_name).deleteOne(f);
+            await db.collection(collection_name).deleteOne(f);
 
         if(options?.listener?.entityDeleted)
             await options.listener.entityDeleted(db, entity_name, entity)
@@ -469,7 +523,7 @@ const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options })
             //{ label: '상품', value: row => row.product_list?.map(m=>m.total_name).join(',') },
 
             let f = req.body.filter || {}
-            const list = await db.collection(entity_name).find(f).project({
+            const list = await db.collection(collection_name).find(f).project({
                 _id: false,
             }).toArray();
 
@@ -564,7 +618,7 @@ const generateCrud = async ({ app, db, entity_name, yml_entity, yml, options })
                 })
             }
 
-            let result = await db.collection(entity_name).bulkWrite(bulk);
+            let result = await db.collection(collection_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()
@@ -704,6 +758,15 @@ const makeApiGenerateAggregate = async (db, entity_name, yml_entity, yml, option
             { $match: { $expr: { $eq: ['$' + match, '$$local_key'] } } }
         ]
 
+        // filter 처리
+        if (Array.isArray(apiGenerateItem.filter)) {
+            let filterMatch = {}
+            apiGenerateItem.filter.forEach(f => {
+                filterMatch[f.name] = f.value
+            })
+            innerPipeline.push({ $match: filterMatch })
+        }
+
         // single일 때 max _id로 하나만 선택 ($match 바로 다음에)
         if(single) {
             innerPipeline.push({ $sort: { _id: -1 } })
@@ -763,84 +826,6 @@ const makeApiGenerateAggregate = async (db, entity_name, yml_entity, yml, option
     return aggregate
 }
 
-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 projection = {[match]:1}
-
-        const aggregate = [
-            { $match: { [match]: {$in:match_from_list} } },
-        ]
-
-        if(field)
-            projection[field] = 1
-        else if(fields){
-            fields.map(m=>{
-                projection[m.name] = 1
-            })
-
-            fields.map(m=>{
-                if(m.type == 'reference') {
-                    let project = { _id: 0 }
-
-                    if(m.field)
-                        project[m.field] = 1
-                    else
-                        m.fields.map(f=>{
-                            project[f.name] = 1
-                        })
-
-                    aggregate.push({ $lookup: {
-                        from: m.reference_entity,
-                        let: { local_key: '$'+m.reference_from },
-                        pipeline: [
-                            { $match: { $expr: { $eq: ["$"+m.reference_match, "$$local_key"] } } },
-                            { $project: project }
-                        ],
-                        as: m.name
-                    } })
-                    if(m.single)
-                        aggregate.push({ $unwind: `$${m.name}` })
-                
-                    if(m.field)
-                        aggregate.push({ $addFields: { [m.field]: `$${m.name}.${m.field}` } })
-                }
-            })
-        }
-
-        const result = await db.collection(entity)
-            .aggregate(aggregate)
-            .project(projection)
-            .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
-            }
-        })
-    }
-}
-
 const generateEntityApi = async ({ app, db, entity_name, entity, yml, options }) => {
     await generateCrud({ app, db, entity_name, yml_entity: entity, yml, options })
 }