@ruiapp/rapid-core 0.1.63 → 0.1.66

package/dist/index.js

@@ -1093,7 +1093,12 @@ function validateValue(name, value) {
         return;
     for (let i = 0; i < value.length; i++) {
         const c = value.charAt(i);
-        if (c < String.fromCharCode(0x21) || c == String.fromCharCode(0x22) || c == String.fromCharCode(0x2c) || c == String.fromCharCode(0x3b) || c == String.fromCharCode(0x5c) || c == String.fromCharCode(0x7f)) {
+        if (c < String.fromCharCode(0x21) ||
+            c == String.fromCharCode(0x22) ||
+            c == String.fromCharCode(0x2c) ||
+            c == String.fromCharCode(0x3b) ||
+            c == String.fromCharCode(0x5c) ||
+            c == String.fromCharCode(0x7f)) {
             throw new Error("RFC2616 cookie '" + name + "' cannot contain character '" + c + "'");
         }
         if (c > String.fromCharCode(0x80)) {
@@ -1340,6 +1345,13 @@ var bootstrapApplicationConfig = {
                     type: "text",
                     required: false,
                 },
+                {
+                    name: "displayPropertyCode",
+                    code: "displayPropertyCode",
+                    columnName: "display_property_code",
+                    type: "text",
+                    required: false,
+                },
                 {
                     name: "properties",
                     code: "properties",
@@ -1800,8 +1812,10 @@ var bootstrapApplicationConfig$1 = /*#__PURE__*/Object.freeze({
 
 function isRelationProperty(property) {
     return property.type === "relation" || property.type === "relation[]";
-}
-
+}
+function isOneRelationProperty(property) {
+    return isRelationProperty(property) && property.relation === "one";
+}
 function getEntityPropertiesIncludingBase(server, model) {
     if (!model.base) {
         return model.properties;
@@ -1817,10 +1831,7 @@ function getEntityPropertiesIncludingBase(server, model) {
             return property;
         });
     }
-    return [
-        ...baseProperties,
-        ...model.properties,
-    ];
+    return [...baseProperties, ...model.properties];
 }
 function getEntityPropertyByCode(server, model, propertyCode) {
     return getEntityProperty(server, model, (e) => e.code === propertyCode);
@@ -1897,8 +1908,8 @@ function mapEntityToDbRow(server, model, entity) {
     if (!entity) {
         return result;
     }
-    const row = result.row = {};
-    const baseRow = result.baseRow = {};
+    const row = (result.row = {});
+    const baseRow = (result.baseRow = {});
     if (!model.properties || !model.properties.length) {
         return result;
     }
@@ -1946,25 +1957,80 @@ function mapPropertyNameToColumnName(model, propertyName) {
     return property.columnName || property.code;
 }
 
-function getEntityPartChanges(before, after) {
+function getEntityPartChanges(server, model, before, after) {
     if (!before) {
         throw new Error("Argument 'before' can not be null.");
     }
     if (!after) {
         throw new Error("Argument 'after' can not be null.");
     }
-    let changed = null;
+    let changed = false;
+    let changes = {};
     for (const key in after) {
-        if (after[key] != before[key]) {
-            if (changed) {
-                changed[key] = after[key];
+        const property = getEntityPropertyByCode(server, model, key);
+        if (isOneRelationProperty(property)) {
+            const afterValue = after[key];
+            const beforeValue = before[key] || before[property.targetIdColumnName];
+            if (afterValue) {
+                if (lodash.isNumber(afterValue)) {
+                    if (beforeValue) {
+                        if (lodash.isNumber(beforeValue)) {
+                            if (afterValue != beforeValue) {
+                                changed = true;
+                                changes[key] = afterValue;
+                            }
+                        }
+                        else {
+                            if (afterValue != beforeValue.id) {
+                                changed = true;
+                                changes[key] = afterValue;
+                            }
+                        }
+                    }
+                    else {
+                        changed = true;
+                        changes[key] = afterValue;
+                    }
+                }
+                else {
+                    if (beforeValue) {
+                        if (lodash.isNumber(beforeValue)) {
+                            if (afterValue.id != beforeValue) {
+                                changed = true;
+                                changes[key] = afterValue;
+                            }
+                        }
+                        else {
+                            if (afterValue.id != beforeValue.id) {
+                                changed = true;
+                                changes[key] = afterValue;
+                            }
+                        }
+                    }
+                    else {
+                        changed = true;
+                        changes[key] = afterValue;
+                    }
+                }
             }
             else {
-                changed = { [key]: after[key] };
+                if (beforeValue) {
+                    changed = true;
+                    changes[key] = null;
+                }
             }
         }
+        else {
+            if (after[key] != before[key]) {
+                changed = true;
+                changes[key] = after[key];
+            }
+        }
+    }
+    if (changed) {
+        return changes;
     }
-    return changed;
+    return null;
 }
 
 function getNowStringWithTimezone() {
@@ -2572,7 +2638,7 @@ async function createEntity(server, dataAccessor, options, plugin) {
                 targetRow[property.targetIdColumnName] = targetEntityId;
             }
         }
-        else {
+        else if (lodash.isNumber(fieldValue)) {
             // fieldValue is id;
             const targetEntityId = fieldValue;
             const targetEntity = await findById(server, targetDataAccessor, {
@@ -2585,6 +2651,10 @@ async function createEntity(server, dataAccessor, options, plugin) {
             newEntityOneRelationProps[property.code] = targetEntity;
             targetRow[property.targetIdColumnName] = targetEntityId;
         }
+        else {
+            newEntityOneRelationProps[property.code] = null;
+            targetRow[property.targetIdColumnName] = null;
+        }
     }
     let newBaseRow;
     if (model.base) {
@@ -2693,14 +2763,15 @@ async function updateEntityById(server, dataAccessor, options, plugin) {
         throw new Error("Id is required when updating an entity.");
     }
     const entity = await findById(server, dataAccessor, {
-        id,
         routeContext,
+        id,
+        keepNonPropertyFields: true,
     });
     if (!entity) {
         throw new Error(`${model.namespace}.${model.singularCode}  with id "${id}" was not found.`);
     }
     let { entityToSave } = options;
-    let changes = getEntityPartChanges(entity, entityToSave);
+    let changes = getEntityPartChanges(server, model, entity, entityToSave);
     if (!changes && !options.operation) {
         return entity;
     }
@@ -2730,7 +2801,7 @@ async function updateEntityById(server, dataAccessor, options, plugin) {
         sender: plugin,
         routeContext: options.routeContext,
     });
-    changes = getEntityPartChanges(entity, entityToSave);
+    changes = getEntityPartChanges(server, model, entity, entityToSave);
     const oneRelationPropertiesToUpdate = [];
     const manyRelationPropertiesToUpdate = [];
     lodash.keys(changes).forEach((propertyCode) => {
@@ -2778,7 +2849,7 @@ async function updateEntityById(server, dataAccessor, options, plugin) {
                 targetRow[property.targetIdColumnName] = targetEntityId;
             }
         }
-        else {
+        else if (lodash.isNumber(fieldValue)) {
             // fieldValue is id;
             const targetEntityId = fieldValue;
             const targetEntity = await findById(server, targetDataAccessor, {
@@ -2791,6 +2862,10 @@ async function updateEntityById(server, dataAccessor, options, plugin) {
             updatedEntityOneRelationProps[property.code] = targetEntity;
             targetRow[property.targetIdColumnName] = targetEntityId;
         }
+        else {
+            updatedEntityOneRelationProps[property.code] = null;
+            targetRow[property.targetIdColumnName] = null;
+        }
     }
     let updatedRow = row;
     if (Object.keys(row).length) {
@@ -3024,11 +3099,11 @@ class EntityManager {
                 const command = `INSERT INTO ${queryBuilder.quoteTable({
                     schema: relationProperty.linkSchema,
                     tableName: relationProperty.linkTableName,
-                })} (${queryBuilder.quoteObject(relationProperty.selfIdColumnName)}, ${queryBuilder.quoteObject(relationProperty.targetIdColumnName)})
-    SELECT $1, $2 WHERE NOT EXISTS (
-      SELECT ${queryBuilder.quoteObject(relationProperty.selfIdColumnName)}, ${queryBuilder.quoteObject(relationProperty.targetIdColumnName)}
-        FROM ${queryBuilder.quoteTable({ schema: relationProperty.linkSchema, tableName: relationProperty.linkTableName })}
-        WHERE ${queryBuilder.quoteObject(relationProperty.selfIdColumnName)}=$1 AND ${queryBuilder.quoteObject(relationProperty.targetIdColumnName)}=$2
+                })} (${queryBuilder.quoteObject(relationProperty.selfIdColumnName)}, ${queryBuilder.quoteObject(relationProperty.targetIdColumnName)})
+    SELECT $1, $2 WHERE NOT EXISTS (
+      SELECT ${queryBuilder.quoteObject(relationProperty.selfIdColumnName)}, ${queryBuilder.quoteObject(relationProperty.targetIdColumnName)}
+        FROM ${queryBuilder.quoteTable({ schema: relationProperty.linkSchema, tableName: relationProperty.linkTableName })}
+        WHERE ${queryBuilder.quoteObject(relationProperty.selfIdColumnName)}=$1 AND ${queryBuilder.quoteObject(relationProperty.targetIdColumnName)}=$2
       )`;
                 const params = [id, relation.id];
                 await server.queryDatabaseObject(command, params);
@@ -3068,7 +3143,7 @@ class EntityManager {
         const { queryBuilder } = server;
         if (relationProperty.linkTableName) {
             for (const relation of relations) {
-                const command = `DELETE FROM ${queryBuilder.quoteTable({ schema: relationProperty.linkSchema, tableName: relationProperty.linkTableName })}
+                const command = `DELETE FROM ${queryBuilder.quoteTable({ schema: relationProperty.linkSchema, tableName: relationProperty.linkTableName })}
     WHERE ${queryBuilder.quoteObject(relationProperty.selfIdColumnName)}=$1 AND ${queryBuilder.quoteObject(relationProperty.targetIdColumnName)}=$2;`;
                 const params = [id, relation.id];
                 await server.queryDatabaseObject(command, params);
@@ -3594,32 +3669,32 @@ async function generateJwtSecretKey() {
     return encode(exportedKey);
 }
 
-const code$p = "listMetaModels";
-async function handler$p(plugin, ctx, options) {
+const code$r = "listMetaModels";
+async function handler$r(plugin, ctx, options) {
     const { applicationConfig } = ctx;
     ctx.output = { list: applicationConfig.models };
 }
 
 var listMetaModels = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$p,
-  handler: handler$p
+  code: code$r,
+  handler: handler$r
 });
 
-const code$o = "listMetaRoutes";
-async function handler$o(plugin, ctx, options) {
+const code$q = "listMetaRoutes";
+async function handler$q(plugin, ctx, options) {
     const { applicationConfig } = ctx;
     ctx.output = { list: applicationConfig.routes };
 }
 
 var listMetaRoutes = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$o,
-  handler: handler$o
+  code: code$q,
+  handler: handler$q
 });
 
-const code$n = "getMetaModelDetail";
-async function handler$n(plugin, ctx, options) {
+const code$p = "getMetaModelDetail";
+async function handler$p(plugin, ctx, options) {
     const { server, input } = ctx;
     const model = server.getModel(input);
     ctx.output = model;
@@ -3627,8 +3702,8 @@ async function handler$n(plugin, ctx, options) {
 
 var getMetaModelDetail = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$n,
-  handler: handler$n
+  code: code$p,
+  handler: handler$p
 });
 
 /**
@@ -3779,7 +3854,10 @@ async function syncDatabaseSchema(server, applicationConfig) {
                 }
                 else if (property.relation === "many") {
                     if (property.linkTableName) {
-                        const tableInDb = lodash.find(tablesInDb, { table_schema: property.linkSchema || server.databaseConfig.dbDefaultSchema, table_name: property.linkTableName });
+                        const tableInDb = lodash.find(tablesInDb, {
+                            table_schema: property.linkSchema || server.databaseConfig.dbDefaultSchema,
+                            table_name: property.linkTableName,
+                        });
                         if (!tableInDb) {
                             columnDDL = generateLinkTableDDL(queryBuilder, {
                                 linkSchema: property.linkSchema,
@@ -4004,9 +4082,9 @@ function transformFilterWithSubFilters(filter) {
     return filter;
 }
 
-const code$m = "findCollectionEntities";
-async function handler$m(plugin, ctx, options) {
-    await runCollectionEntityActionHandler(ctx, options, code$m, async (entityManager, input) => {
+const code$o = "findCollectionEntities";
+async function handler$o(plugin, ctx, options) {
+    await runCollectionEntityActionHandler(ctx, options, code$o, async (entityManager, input) => {
         input.filters = removeFiltersWithNullValue(input.filters);
         input.routeContext = ctx.routerContext;
         const entities = await entityManager.findEntities(input);
@@ -4022,14 +4100,14 @@ async function handler$m(plugin, ctx, options) {
 
 var findCollectionEntities = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$m,
-  handler: handler$m
+  code: code$o,
+  handler: handler$o
 });
 
-const code$l = "findCollectionEntityById";
-async function handler$l(plugin, ctx, options) {
+const code$n = "findCollectionEntityById";
+async function handler$n(plugin, ctx, options) {
     const { logger, server, input } = ctx;
-    logger.debug(`Running ${code$l} handler...`, { input });
+    logger.debug(`Running ${code$n} handler...`, { input });
     const { id } = input;
     const entityManager = server.getEntityManager(options.singularCode);
     const entity = await entityManager.findById({
@@ -4044,13 +4122,13 @@ async function handler$l(plugin, ctx, options) {
 
 var findCollectionEntityById = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$l,
-  handler: handler$l
+  code: code$n,
+  handler: handler$n
 });
 
-const code$k = "countCollectionEntities";
-async function handler$k(plugin, ctx, options) {
-    await runCollectionEntityActionHandler(ctx, options, code$k, (entityManager, input) => {
+const code$m = "countCollectionEntities";
+async function handler$m(plugin, ctx, options) {
+    await runCollectionEntityActionHandler(ctx, options, code$m, (entityManager, input) => {
         input.filters = removeFiltersWithNullValue(input.filters);
         input.routeContext = ctx.routerContext;
         return entityManager.count(input);
@@ -4059,16 +4137,16 @@ async function handler$k(plugin, ctx, options) {
 
 var countCollectionEntities = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$k,
-  handler: handler$k
+  code: code$m,
+  handler: handler$m
 });
 
-const code$j = "createCollectionEntity";
-async function handler$j(plugin, ctx, options) {
+const code$l = "createCollectionEntity";
+async function handler$l(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    logger.debug(`Running ${code$j} handler...`, { defaultInput, fixedInput, mergedInput });
+    logger.debug(`Running ${code$l} handler...`, { defaultInput, fixedInput, mergedInput });
     const entityManager = server.getEntityManager(options.singularCode);
     const output = await entityManager.createEntity({
         entity: input,
@@ -4079,15 +4157,15 @@ async function handler$j(plugin, ctx, options) {
 
 var createCollectionEntity = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$j,
-  handler: handler$j
+  code: code$l,
+  handler: handler$l
 });
 
-const code$i = "createCollectionEntitiesBatch";
-async function handler$i(plugin, ctx, options) {
+const code$k = "createCollectionEntitiesBatch";
+async function handler$k(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
-    logger.debug(`Running ${code$i} handler...`, { defaultInput, fixedInput, input });
+    logger.debug(`Running ${code$k} handler...`, { defaultInput, fixedInput, input });
     const { entities } = input;
     if (!lodash.isArray(entities)) {
         throw new Error("input.entities should be an array.");
@@ -4111,16 +4189,16 @@ async function handler$i(plugin, ctx, options) {
 
 var createCollectionEntitiesBatch = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$i,
-  handler: handler$i
+  code: code$k,
+  handler: handler$k
 });
 
-const code$h = "updateCollectionEntityById";
-async function handler$h(plugin, ctx, options) {
+const code$j = "updateCollectionEntityById";
+async function handler$j(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    logger.debug(`Running ${code$h} handler...`, { defaultInput, fixedInput, mergedInput });
+    logger.debug(`Running ${code$j} handler...`, { defaultInput, fixedInput, mergedInput });
     const operation = mergedInput.$operation;
     if (operation) {
         delete mergedInput.$operation;
@@ -4143,14 +4221,14 @@ async function handler$h(plugin, ctx, options) {
 
 var updateCollectionEntityById = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$h,
-  handler: handler$h
+  code: code$j,
+  handler: handler$j
 });
 
-const code$g = "deleteCollectionEntityById";
-async function handler$g(plugin, ctx, options) {
+const code$i = "deleteCollectionEntityById";
+async function handler$i(plugin, ctx, options) {
     const { logger, server, input } = ctx;
-    logger.debug(`Running ${code$g} handler...`);
+    logger.debug(`Running ${code$i} handler...`);
     const entityManager = server.getEntityManager(options.singularCode);
     await entityManager.deleteById({
         id: input.id,
@@ -4162,16 +4240,16 @@ async function handler$g(plugin, ctx, options) {
 
 var deleteCollectionEntityById = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$g,
-  handler: handler$g
+  code: code$i,
+  handler: handler$i
 });
 
-const code$f = "addEntityRelations";
-async function handler$f(plugin, ctx, options) {
+const code$h = "addEntityRelations";
+async function handler$h(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    logger.debug(`Running ${code$f} handler...`, { defaultInput, fixedInput, mergedInput });
+    logger.debug(`Running ${code$h} handler...`, { defaultInput, fixedInput, mergedInput });
     const entityManager = server.getEntityManager(options.singularCode);
     mergedInput.routeContext = ctx.routerContext;
     await entityManager.addRelations(mergedInput, plugin);
@@ -4180,16 +4258,16 @@ async function handler$f(plugin, ctx, options) {
 
 var addEntityRelations = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$f,
-  handler: handler$f
+  code: code$h,
+  handler: handler$h
 });
 
-const code$e = "removeEntityRelations";
-async function handler$e(plugin, ctx, options) {
+const code$g = "removeEntityRelations";
+async function handler$g(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    logger.debug(`Running ${code$e} handler...`, { defaultInput, fixedInput, mergedInput });
+    logger.debug(`Running ${code$g} handler...`, { defaultInput, fixedInput, mergedInput });
     mergedInput.routeContext = ctx.routerContext;
     const entityManager = server.getEntityManager(options.singularCode);
     await entityManager.removeRelations(mergedInput, plugin);
@@ -4198,16 +4276,16 @@ async function handler$e(plugin, ctx, options) {
 
 var removeEntityRelations = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$e,
-  handler: handler$e
+  code: code$g,
+  handler: handler$g
 });
 
-const code$d = "queryDatabase";
-async function handler$d(plugin, ctx, options) {
+const code$f = "queryDatabase";
+async function handler$f(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { sql, querySingle, defaultInput, fixedInput } = options;
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    logger.debug(`Running ${code$d} handler...`, { defaultInput, fixedInput, mergedInput });
+    logger.debug(`Running ${code$f} handler...`, { defaultInput, fixedInput, mergedInput });
     const result = await server.queryDatabaseObject(sql, mergedInput);
     if (querySingle) {
         ctx.output = lodash.first(result);
@@ -4219,8 +4297,8 @@ async function handler$d(plugin, ctx, options) {
 
 var queryDatabase = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$d,
-  handler: handler$d
+  code: code$f,
+  handler: handler$f
 });
 
 /**
@@ -4391,17 +4469,17 @@ async function sendSourceResponse(proxyCtx, targetRes) {
     srcRes.body = targetRes.body;
 }
 
-const code$c = "httpProxy";
-async function handler$c(plugin, ctx, options) {
+const code$e = "httpProxy";
+async function handler$e(plugin, ctx, options) {
     const { logger } = ctx;
-    logger.debug(`Running ${code$c} handler...`);
+    logger.debug(`Running ${code$e} handler...`);
     await doProxy(ctx.routerContext, options);
 }
 
 var httpProxy = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$c,
-  handler: handler$c
+  code: code$e,
+  handler: handler$e
 });
 
 /**
@@ -4448,8 +4526,8 @@ class RouteManager {
     }
 }
 
-const code$b = "generateSn";
-async function handler$b(plugin, ctx, options) {
+const code$d = "generateSn";
+async function handler$d(plugin, ctx, options) {
     const { server, routerContext } = ctx;
     const input = ctx.input;
     if (options?.ruleCode) {
@@ -4467,11 +4545,11 @@ async function handler$b(plugin, ctx, options) {
 
 var generateSn$1 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$b,
-  handler: handler$b
+  code: code$d,
+  handler: handler$d
 });
 
-var pluginActionHandlers$4 = [generateSn$1];
+var pluginActionHandlers$5 = [generateSn$1];
 
 var SequenceRule = {
     maintainedBy: "sequencePlugin",
@@ -4562,7 +4640,7 @@ var SequenceAutoIncrementRecord = {
     ],
 };
 
-var pluginModels$2 = [SequenceRule, SequenceAutoIncrementRecord];
+var pluginModels$3 = [SequenceRule, SequenceAutoIncrementRecord];
 
 var generateSn = {
     namespace: "svc",
@@ -4578,7 +4656,7 @@ var generateSn = {
     ],
 };
 
-var pluginRoutes$4 = [generateSn];
+var pluginRoutes$5 = [generateSn];
 
 const segmentType$5 = "literal";
 async function resolveSegmentValue$5(server, ruleCode, config, input) {
@@ -4795,19 +4873,19 @@ class SequencePlugin {
         return [];
     }
     async registerActionHandlers(server) {
-        for (const actionHandler of pluginActionHandlers$4) {
+        for (const actionHandler of pluginActionHandlers$5) {
             server.registerActionHandler(this, actionHandler);
         }
     }
     async configureModels(server, applicationConfig) {
-        server.appendApplicationConfig({ models: pluginModels$2 });
+        server.appendApplicationConfig({ models: pluginModels$3 });
     }
     async configureServices(server, applicationConfig) {
         this.#sequenceService = new SequenceService(server);
         server.registerService("sequenceService", this.#sequenceService);
     }
     async configureRoutes(server, applicationConfig) {
-        server.appendApplicationConfig({ routes: pluginRoutes$4 });
+        server.appendApplicationConfig({ routes: pluginRoutes$5 });
     }
     async onApplicationLoaded(server, applicationConfig) {
         const models = server.getApplicationConfig().models;
@@ -5046,8 +5124,8 @@ class WebhooksPlugin {
     }
 }
 
-const code$a = "changePassword";
-async function handler$a(plugin, ctx, options) {
+const code$c = "changePassword";
+async function handler$c(plugin, ctx, options) {
     const { server, input, routerContext } = ctx;
     const { id, oldPassword, newPassword } = input;
     const userId = routerContext.state.userId;
@@ -5089,12 +5167,12 @@ async function handler$a(plugin, ctx, options) {
 
 var changePassword$1 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$a,
-  handler: handler$a
+  code: code$c,
+  handler: handler$c
 });
 
-const code$9 = "createSession";
-async function handler$9(plugin, ctx, options) {
+const code$b = "createSession";
+async function handler$b(plugin, ctx, options) {
     const { server, input, routerContext } = ctx;
     const { response } = routerContext;
     const { account, password } = input;
@@ -5137,12 +5215,12 @@ async function handler$9(plugin, ctx, options) {
 
 var createSession = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$9,
-  handler: handler$9
+  code: code$b,
+  handler: handler$b
 });
 
-const code$8 = "deleteSession";
-async function handler$8(plugin, ctx, options) {
+const code$a = "deleteSession";
+async function handler$a(plugin, ctx, options) {
     const { server, input, routerContext } = ctx;
     const { response } = routerContext;
     setCookie(response.headers, {
@@ -5155,12 +5233,12 @@ async function handler$8(plugin, ctx, options) {
 
 var deleteSession = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$8,
-  handler: handler$8
+  code: code$a,
+  handler: handler$a
 });
 
-const code$7 = "getMyProfile";
-async function handler$7(plugin, ctx, options) {
+const code$9 = "getMyProfile";
+async function handler$9(plugin, ctx, options) {
     const { server, input, routerContext } = ctx;
     const userId = routerContext.state.userId;
     if (!userId) {
@@ -5190,12 +5268,12 @@ async function handler$7(plugin, ctx, options) {
 
 var getMyProfile$2 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$7,
-  handler: handler$7
+  code: code$9,
+  handler: handler$9
 });
 
-const code$6 = "resetPassword";
-async function handler$6(plugin, ctx, options) {
+const code$8 = "resetPassword";
+async function handler$8(plugin, ctx, options) {
     const { server, input, routerContext } = ctx;
     const { userId, password } = input;
     const userDataAccessor = server.getDataAccessor({
@@ -5223,11 +5301,11 @@ async function handler$6(plugin, ctx, options) {
 
 var resetPassword$1 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$6,
-  handler: handler$6
+  code: code$8,
+  handler: handler$8
 });
 
-var pluginActionHandlers$3 = [changePassword$1, createSession, deleteSession, getMyProfile$2, resetPassword$1];
+var pluginActionHandlers$4 = [changePassword$1, createSession, deleteSession, getMyProfile$2, resetPassword$1];
 
 var AccessToken = {
     maintainedBy: "authManager",
@@ -5284,7 +5362,7 @@ var AccessToken = {
     ],
 };
 
-var pluginModels$1 = [AccessToken];
+var pluginModels$2 = [AccessToken];
 
 var changePassword = {
     namespace: "auth",
@@ -5356,7 +5434,7 @@ var signout$1 = {
     ],
 };
 
-var pluginRoutes$3 = [changePassword, getMyProfile$1, resetPassword, signin$1, signout$1];
+var pluginRoutes$4 = [changePassword, getMyProfile$1, resetPassword, signin$1, signout$1];
 
 /**
  * Auth manager plugin
@@ -5378,15 +5456,15 @@ class AuthPlugin {
         return [];
     }
     async registerActionHandlers(server) {
-        for (const actionHandler of pluginActionHandlers$3) {
+        for (const actionHandler of pluginActionHandlers$4) {
             server.registerActionHandler(this, actionHandler);
         }
     }
     async configureModels(server, applicationConfig) {
-        server.appendApplicationConfig({ models: pluginModels$1 });
+        server.appendApplicationConfig({ models: pluginModels$2 });
     }
     async configureRoutes(server, applicationConfig) {
-        server.appendApplicationConfig({ routes: pluginRoutes$3 });
+        server.appendApplicationConfig({ routes: pluginRoutes$4 });
     }
     async onPrepareRouteContext(server, routeContext) {
         const request = routeContext.request;
@@ -5442,8 +5520,8 @@ async function appendFile(path, data) {
     });
 }
 
-const code$5 = "downloadDocument";
-async function handler$5(plugin, ctx, options) {
+const code$7 = "downloadDocument";
+async function handler$7(plugin, ctx, options) {
     const { server, applicationConfig, routerContext, input } = ctx;
     const { request, response } = routerContext;
     const documentDataAccessor = ctx.server.getDataAccessor({
@@ -5471,12 +5549,12 @@ async function handler$5(plugin, ctx, options) {
 
 var downloadDocumentActionHandler = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$5,
-  handler: handler$5
+  code: code$7,
+  handler: handler$7
 });
 
-const code$4 = "downloadFile";
-async function handler$4(plugin, ctx, options) {
+const code$6 = "downloadFile";
+async function handler$6(plugin, ctx, options) {
     const { server, applicationConfig, routerContext, input } = ctx;
     const { request, response } = routerContext;
     const dataAccessor = ctx.server.getDataAccessor({
@@ -5496,12 +5574,12 @@ async function handler$4(plugin, ctx, options) {
 
 var downloadFileActionHandler = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$4,
-  handler: handler$4
+  code: code$6,
+  handler: handler$6
 });
 
-const code$3 = "uploadFile";
-async function handler$3(plugin, ctx, options) {
+const code$5 = "uploadFile";
+async function handler$5(plugin, ctx, options) {
     const { server, applicationConfig, routerContext, input } = ctx;
     let file = input.file || input.files;
     if (lodash.isArray(file)) {
@@ -5522,8 +5600,8 @@ async function handler$3(plugin, ctx, options) {
 
 var uploadFileActionHandler = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$3,
-  handler: handler$3
+  code: code$5,
+  handler: handler$5
 });
 
 var getMyProfile = {
@@ -5568,7 +5646,7 @@ var signout = {
     ],
 };
 
-var pluginRoutes$2 = [getMyProfile, signin, signout];
+var pluginRoutes$3 = [getMyProfile, signin, signout];
 
 /**
  * File manager plugin
@@ -5595,23 +5673,23 @@ class FileManager {
         server.registerActionHandler(this, uploadFileActionHandler);
     }
     async configureRoutes(server, applicationConfig) {
-        server.appendApplicationConfig({ routes: pluginRoutes$2 });
+        server.appendApplicationConfig({ routes: pluginRoutes$3 });
     }
 }
 
-const code$2 = "runServerOperation";
-async function handler$2(plugin, ctx, options) {
+const code$4 = "runServerOperation";
+async function handler$4(plugin, ctx, options) {
     const { operation } = options;
     await operation(ctx);
 }
 
 var runServerOperation = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$2,
-  handler: handler$2
+  code: code$4,
+  handler: handler$4
 });
 
-var pluginActionHandlers$2 = [runServerOperation];
+var pluginActionHandlers$3 = [runServerOperation];
 
 class ServerOperationPlugin {
     #operations;
@@ -5636,7 +5714,7 @@ class ServerOperationPlugin {
     async initPlugin(server) { }
     async registerMiddlewares(server) { }
     async registerActionHandlers(server) {
-        for (const actionHandler of pluginActionHandlers$2) {
+        for (const actionHandler of pluginActionHandlers$3) {
             server.registerActionHandler(this, actionHandler);
         }
     }
@@ -5673,6 +5751,652 @@ class ServerOperationPlugin {
     async onApplicationReady(server, applicationConfig) { }
 }
 
+const code$3 = "getUserSettingValues";
+async function handler$3(plugin, ctx, options) {
+    const { server, routerContext } = ctx;
+    const userId = routerContext.state.userId;
+    if (!userId) {
+        ctx.status = 401;
+        ctx.output = {
+            error: {
+                message: "You are not signed in.",
+            },
+        };
+        return;
+    }
+    const input = ctx.input;
+    if (options?.groupCode) {
+        input.groupCode = options.groupCode;
+    }
+    if (!input.groupCode) {
+        throw new Error(`Group code is required when getting system setting values.`);
+    }
+    const settingService = server.getService("settingService");
+    const settingValues = await settingService.getUserSettingValues(userId, input.groupCode);
+    ctx.output = settingValues;
+}
+
+var getUserSettingValues$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$3,
+  handler: handler$3
+});
+
+const code$2 = "getSystemSettingValues";
+async function handler$2(plugin, ctx, options) {
+    const { server, routerContext } = ctx;
+    const input = ctx.input;
+    if (options?.groupCode) {
+        input.groupCode = options.groupCode;
+    }
+    if (!input.groupCode) {
+        throw new Error(`Group code is required when getting system setting values.`);
+    }
+    const settingService = server.getService("settingService");
+    const settingValues = await settingService.getSystemSettingValues(input.groupCode);
+    ctx.output = settingValues;
+}
+
+var getSystemSettingValues$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$2,
+  handler: handler$2
+});
+
+var pluginActionHandlers$2 = [getUserSettingValues$1, getSystemSettingValues$1];
+
+var SystemSettingGroupSetting = {
+    maintainedBy: "settingPlugin",
+    namespace: "svc",
+    name: "system_setting_group_setting",
+    singularCode: "system_setting_group_setting",
+    pluralCode: "system_setting_group_settings",
+    schema: "public",
+    tableName: "system_setting_group_settings",
+    properties: [
+        {
+            name: "id",
+            code: "id",
+            columnName: "id",
+            type: "integer",
+            required: true,
+            autoIncrement: true,
+        },
+        {
+            name: "code",
+            code: "code",
+            columnName: "code",
+            type: "text",
+            required: true,
+        },
+        {
+            name: "name",
+            code: "name",
+            columnName: "scnameope",
+            type: "text",
+            required: false,
+        },
+        {
+            name: "description",
+            code: "description",
+            columnName: "description",
+            type: "text",
+            required: false,
+        },
+        {
+            name: "permissionAssignments",
+            code: "permissionAssignments",
+            columnName: "permission_assignments",
+            type: "json",
+            required: false,
+        },
+        {
+            name: "items",
+            code: "items",
+            type: "relation[]",
+            targetSingularCode: "system_setting_item_setting",
+            selfIdColumnName: "group_id",
+        },
+    ],
+};
+
+var SystemSettingItem = {
+    maintainedBy: "settingPlugin",
+    namespace: "svc",
+    name: "system_setting_item",
+    singularCode: "system_setting_item",
+    pluralCode: "system_setting_items",
+    schema: "public",
+    tableName: "system_setting_items",
+    properties: [
+        {
+            name: "id",
+            code: "id",
+            columnName: "id",
+            type: "integer",
+            required: true,
+            autoIncrement: true,
+        },
+        {
+            name: "groupCode",
+            code: "groupCode",
+            columnName: "group_code",
+            type: "text",
+            required: true,
+        },
+        {
+            name: "itemCode",
+            code: "itemCode",
+            columnName: "item_code",
+            type: "text",
+            required: true,
+        },
+        {
+            name: "value",
+            code: "value",
+            columnName: "value",
+            type: "json",
+            required: false,
+        },
+    ],
+};
+
+var SystemSettingItemSetting = {
+    maintainedBy: "settingPlugin",
+    namespace: "svc",
+    name: "system_setting_item_setting",
+    singularCode: "system_setting_item_setting",
+    pluralCode: "system_setting_item_settings",
+    schema: "public",
+    tableName: "system_setting_item_settings",
+    properties: [
+        {
+            name: "id",
+            code: "id",
+            columnName: "id",
+            type: "integer",
+            required: true,
+            autoIncrement: true,
+        },
+        {
+            name: "group",
+            code: "group",
+            type: "relation",
+            targetSingularCode: "system_setting_group_setting",
+            targetIdColumnName: "group_id",
+            required: true,
+        },
+        {
+            name: "orderNum",
+            code: "orderNum",
+            columnName: "order_num",
+            type: "integer",
+            required: true,
+            defaultValue: "0",
+        },
+        {
+            name: "type",
+            code: "type",
+            columnName: "type",
+            type: "text",
+            required: true,
+        },
+        {
+            name: "code",
+            code: "code",
+            columnName: "code",
+            type: "text",
+            required: true,
+        },
+        {
+            name: "name",
+            code: "name",
+            columnName: "scnameope",
+            type: "text",
+            required: false,
+        },
+        {
+            name: "description",
+            code: "description",
+            columnName: "description",
+            type: "text",
+            required: false,
+        },
+        {
+            name: "config",
+            code: "config",
+            columnName: "config",
+            type: "json",
+            required: false,
+        },
+    ],
+};
+
+var UserSettingGroupSetting = {
+    maintainedBy: "settingPlugin",
+    namespace: "svc",
+    name: "user_setting_group_setting",
+    singularCode: "user_setting_group_setting",
+    pluralCode: "user_setting_group_settings",
+    schema: "public",
+    tableName: "user_setting_group_settings",
+    properties: [
+        {
+            name: "id",
+            code: "id",
+            columnName: "id",
+            type: "integer",
+            required: true,
+            autoIncrement: true,
+        },
+        {
+            name: "code",
+            code: "code",
+            columnName: "code",
+            type: "text",
+            required: true,
+        },
+        {
+            name: "name",
+            code: "name",
+            columnName: "scnameope",
+            type: "text",
+            required: false,
+        },
+        {
+            name: "description",
+            code: "description",
+            columnName: "description",
+            type: "text",
+            required: false,
+        },
+        {
+            name: "permissionAssignments",
+            code: "permissionAssignments",
+            columnName: "permission_assignments",
+            type: "json",
+            required: false,
+        },
+        {
+            name: "items",
+            code: "items",
+            type: "relation[]",
+            targetSingularCode: "user_setting_item_setting",
+            selfIdColumnName: "group_id",
+        },
+    ],
+};
+
+var UserSettingItem = {
+    maintainedBy: "settingPlugin",
+    namespace: "svc",
+    name: "user_setting_item",
+    singularCode: "user_setting_item",
+    pluralCode: "user_setting_items",
+    schema: "public",
+    tableName: "user_setting_items",
+    properties: [
+        {
+            name: "id",
+            code: "id",
+            columnName: "id",
+            type: "integer",
+            required: true,
+            autoIncrement: true,
+        },
+        {
+            name: "ownerId",
+            code: "ownerId",
+            columnName: "owner_id",
+            type: "integer",
+            required: true,
+        },
+        {
+            name: "groupCode",
+            code: "groupCode",
+            columnName: "group_code",
+            type: "text",
+            required: true,
+        },
+        {
+            name: "itemCode",
+            code: "itemCode",
+            columnName: "item_code",
+            type: "text",
+            required: true,
+        },
+        {
+            name: "value",
+            code: "value",
+            columnName: "value",
+            type: "json",
+            required: false,
+        },
+    ],
+};
+
+var UserSettingItemSetting = {
+    maintainedBy: "settingPlugin",
+    namespace: "svc",
+    name: "user_setting_item_setting",
+    singularCode: "user_setting_item_setting",
+    pluralCode: "user_setting_item_settings",
+    schema: "public",
+    tableName: "user_setting_item_settings",
+    properties: [
+        {
+            name: "id",
+            code: "id",
+            columnName: "id",
+            type: "integer",
+            required: true,
+            autoIncrement: true,
+        },
+        {
+            name: "group",
+            code: "group",
+            type: "relation",
+            targetSingularCode: "user_setting_group_setting",
+            targetIdColumnName: "group_id",
+            required: true,
+        },
+        {
+            name: "orderNum",
+            code: "orderNum",
+            columnName: "order_num",
+            type: "integer",
+            required: true,
+            defaultValue: "0",
+        },
+        {
+            name: "type",
+            code: "type",
+            columnName: "type",
+            type: "text",
+            required: true,
+        },
+        {
+            name: "code",
+            code: "code",
+            columnName: "code",
+            type: "text",
+            required: true,
+        },
+        {
+            name: "name",
+            code: "name",
+            columnName: "scnameope",
+            type: "text",
+            required: false,
+        },
+        {
+            name: "description",
+            code: "description",
+            columnName: "description",
+            type: "text",
+            required: false,
+        },
+        {
+            name: "config",
+            code: "config",
+            columnName: "config",
+            type: "json",
+            required: false,
+        },
+    ],
+};
+
+var pluginModels$1 = [SystemSettingGroupSetting, SystemSettingItem, SystemSettingItemSetting, UserSettingGroupSetting, UserSettingItem, UserSettingItemSetting];
+
+var getUserSettingValues = {
+    namespace: "svc",
+    name: "svc.getUserSettingValues",
+    code: "svc.getUserSettingValues",
+    type: "RESTful",
+    method: "GET",
+    endpoint: "/svc/userSettingValues",
+    actions: [
+        {
+            code: "getUserSettingValues",
+        },
+    ],
+};
+
+var getSystemSettingValues = {
+    namespace: "svc",
+    name: "svc.getSystemSettingValues",
+    code: "svc.getSystemSettingValues",
+    type: "RESTful",
+    method: "GET",
+    endpoint: "/svc/systemSettingValues",
+    actions: [
+        {
+            code: "getSystemSettingValues",
+        },
+    ],
+};
+
+var pluginRoutes$2 = [getUserSettingValues, getSystemSettingValues];
+
+class SettingService {
+    #server;
+    #systemSettingItemManager;
+    #userSettingItemManager;
+    constructor(server) {
+        this.#server = server;
+        this.#systemSettingItemManager = server.getEntityManager("system_setting_item");
+        this.#userSettingItemManager = server.getEntityManager("user_setting_item");
+    }
+    //#region System Setting
+    async getSystemSettingItems(groupCode) {
+        return await this.#systemSettingItemManager.findEntities({
+            filters: [
+                {
+                    operator: "eq",
+                    field: "groupCode",
+                    value: groupCode,
+                },
+            ],
+        });
+    }
+    async getSystemSettingValues(groupCode) {
+        const settingItems = await this.getSystemSettingItems(groupCode);
+        return settingItems.reduce((settingValues, settingItem) => {
+            settingValues[settingItem.itemCode] = settingItem.value;
+            return settingValues;
+        }, {});
+    }
+    async getSystemSettingValue(groupCode, itemCode) {
+        const settingItem = await this.#systemSettingItemManager.findEntity({
+            filters: [
+                {
+                    operator: "eq",
+                    field: "groupCode",
+                    value: groupCode,
+                },
+                {
+                    operator: "eq",
+                    field: "itemCode",
+                    value: itemCode,
+                },
+            ],
+        });
+        return settingItem ? settingItem.value : null;
+    }
+    async setSystemSettingValue(groupCode, itemCode, value) {
+        const settingItem = await this.#systemSettingItemManager.findEntity({
+            filters: [
+                {
+                    operator: "eq",
+                    field: "groupCode",
+                    value: groupCode,
+                },
+                {
+                    operator: "eq",
+                    field: "itemCode",
+                    value: itemCode,
+                },
+            ],
+        });
+        if (settingItem) {
+            await this.#systemSettingItemManager.updateEntityById({
+                id: settingItem.id,
+                entityToSave: {
+                    value,
+                },
+            });
+        }
+        else {
+            await this.#systemSettingItemManager.createEntity({
+                entity: {
+                    groupCode,
+                    itemCode,
+                    value,
+                },
+            });
+        }
+    }
+    async setSystemSettingValues(groupCode, settingValues) {
+        for (const itemCode in settingValues) {
+            const value = settingValues[itemCode];
+            await this.setSystemSettingValue(groupCode, itemCode, value);
+        }
+    }
+    //#endregion
+    //#region User Setting
+    async getUserSettingItems(ownerId, groupCode) {
+        return await this.#userSettingItemManager.findEntities({
+            filters: [
+                {
+                    operator: "eq",
+                    field: "ownerId",
+                    value: ownerId,
+                },
+                {
+                    operator: "eq",
+                    field: "groupCode",
+                    value: groupCode,
+                },
+            ],
+        });
+    }
+    async getUserSettingValues(ownerId, groupCode) {
+        const settingItems = await this.getUserSettingItems(ownerId, groupCode);
+        return settingItems.reduce((settingValues, settingItem) => {
+            settingValues[settingItem.itemCode] = settingItem.value;
+            return settingValues;
+        }, {});
+    }
+    async getUserSettingValue(ownerId, groupCode, itemCode) {
+        const settingItem = await this.#systemSettingItemManager.findEntity({
+            filters: [
+                {
+                    operator: "eq",
+                    field: "ownerId",
+                    value: ownerId,
+                },
+                {
+                    operator: "eq",
+                    field: "groupCode",
+                    value: groupCode,
+                },
+                {
+                    operator: "eq",
+                    field: "itemCode",
+                    value: itemCode,
+                },
+            ],
+        });
+        return settingItem ? settingItem.value : null;
+    }
+    async setUserSettingValue(ownerId, groupCode, itemCode, value) {
+        const settingItem = await this.#userSettingItemManager.findEntity({
+            filters: [
+                {
+                    operator: "eq",
+                    field: "ownerId",
+                    value: ownerId,
+                },
+                {
+                    operator: "eq",
+                    field: "groupCode",
+                    value: groupCode,
+                },
+                {
+                    operator: "eq",
+                    field: "itemCode",
+                    value: itemCode,
+                },
+            ],
+        });
+        if (settingItem) {
+            await this.#userSettingItemManager.updateEntityById({
+                id: settingItem.id,
+                entityToSave: {
+                    value,
+                },
+            });
+        }
+        else {
+            await this.#systemSettingItemManager.createEntity({
+                entity: {
+                    ownerId: ownerId,
+                    groupCode,
+                    itemCode,
+                    value,
+                },
+            });
+        }
+    }
+    async setUserSettingValues(ownerId, groupCode, settingValues) {
+        for (const itemCode in settingValues) {
+            const value = settingValues[itemCode];
+            await this.setUserSettingValue(ownerId, groupCode, itemCode, value);
+        }
+    }
+}
+
+/**
+ * Setting plugin
+ */
+class SettingPlugin {
+    #settingService;
+    get settingService() {
+        return this.#settingService;
+    }
+    get code() {
+        return "settingPlugin";
+    }
+    get description() {
+        return null;
+    }
+    get extendingAbilities() {
+        return [];
+    }
+    get configurableTargets() {
+        return [];
+    }
+    get configurations() {
+        return [];
+    }
+    async registerActionHandlers(server) {
+        for (const actionHandler of pluginActionHandlers$2) {
+            server.registerActionHandler(this, actionHandler);
+        }
+    }
+    async configureModels(server, applicationConfig) {
+        server.appendApplicationConfig({ models: pluginModels$1 });
+    }
+    async configureServices(server, applicationConfig) {
+        this.#settingService = new SettingService(server);
+        server.registerService("settingService", this.#settingService);
+    }
+    async configureRoutes(server, applicationConfig) {
+        server.appendApplicationConfig({ routes: pluginRoutes$2 });
+    }
+    async onApplicationLoaded(server, applicationConfig) { }
+}
+
 const code$1 = "runCronJob";
 async function handler$1(plugin, ctx, options) {
     const { server, routerContext } = ctx;
@@ -6179,9 +6903,9 @@ class EntityAccessControlPlugin {
         if (!userId) {
             return;
         }
-        const actions = await server.queryDatabaseObject(`select distinct a.* from sys_actions a
-      inner join oc_role_sys_action_links ra on a.id = ra.action_id
-      inner join oc_role_user_links ru on ru.role_id = ra.role_id
+        const actions = await server.queryDatabaseObject(`select distinct a.* from sys_actions a
+      inner join oc_role_sys_action_links ra on a.id = ra.action_id
+      inner join oc_role_user_links ru on ru.role_id = ra.role_id
       where ru.user_id = $1;`, [userId]);
         routeContext.state.allowedActions = actions.map((item) => item.code);
     }
@@ -6215,6 +6939,7 @@ exports.RouteContext = RouteContext;
 exports.RouteManagePlugin = RouteManager;
 exports.SequencePlugin = SequencePlugin;
 exports.ServerOperationPlugin = ServerOperationPlugin;
+exports.SettingPlugin = SettingPlugin;
 exports.StateMachinePlugin = StateMachinePlugin;
 exports.WebhooksPlugin = WebhooksPlugin;
 exports.bootstrapApplicationConfig = bootstrapApplicationConfig$1;