@ruiapp/rapid-core 0.1.65 → 0.1.67

package/dist/index.js

@@ -3669,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;
@@ -3702,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
 });
 
 /**
@@ -4082,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);
@@ -4100,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({
@@ -4122,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);
@@ -4137,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,
@@ -4157,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.");
@@ -4189,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;
@@ -4221,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,
@@ -4240,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);
@@ -4258,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);
@@ -4276,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);
@@ -4297,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
 });
 
 /**
@@ -4469,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
 });
 
 /**
@@ -4526,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) {
@@ -4545,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",
@@ -4640,7 +4640,7 @@ var SequenceAutoIncrementRecord = {
     ],
 };
 
-var pluginModels$2 = [SequenceRule, SequenceAutoIncrementRecord];
+var pluginModels$3 = [SequenceRule, SequenceAutoIncrementRecord];
 
 var generateSn = {
     namespace: "svc",
@@ -4656,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) {
@@ -4873,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;
@@ -5124,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;
@@ -5167,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;
@@ -5215,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, {
@@ -5233,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) {
@@ -5268,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({
@@ -5301,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",
@@ -5362,7 +5362,7 @@ var AccessToken = {
     ],
 };
 
-var pluginModels$1 = [AccessToken];
+var pluginModels$2 = [AccessToken];
 
 var changePassword = {
     namespace: "auth",
@@ -5434,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
@@ -5456,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;
@@ -5520,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({
@@ -5549,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({
@@ -5574,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)) {
@@ -5600,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 = {
@@ -5646,7 +5646,7 @@ var signout = {
     ],
 };
 
-var pluginRoutes$2 = [getMyProfile, signin, signout];
+var pluginRoutes$3 = [getMyProfile, signin, signout];
 
 /**
  * File manager plugin
@@ -5673,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;
@@ -5714,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);
         }
     }
@@ -5751,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: "name",
+            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: "name",
+            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: "name",
+            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: "name",
+            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;
@@ -6293,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;