@ruiapp/rapid-core 0.9.5 → 0.9.7

package/dist/core/routes/healthz.d.ts

@@ -0,0 +1,12 @@
+import { ActionHandlerContext } from "../actionHandler";
+declare const _default: {
+    namespace: string;
+    name: string;
+    code: string;
+    type: "RESTful";
+    method: "GET";
+    endpoint: string;
+    handler: typeof handler;
+};
+export default _default;
+export declare function handler(ctx: ActionHandlerContext): Promise<void>;

package/dist/core/routes/index.d.ts

@@ -0,0 +1,10 @@
+declare const _default: {
+    namespace: string;
+    name: string;
+    code: string;
+    type: "RESTful";
+    method: "GET";
+    endpoint: string;
+    handler: typeof import("./healthz").handler;
+}[];
+export default _default;

package/dist/index.js

@@ -1032,18 +1032,38 @@ async function buildRoutes(server, applicationConfig) {
                 input,
             };
             await server.beforeRunRouteActions(handlerContext);
-            for (const actionConfig of routeConfig.actions) {
-                const actionCode = actionConfig.code;
-                const handler = server.getActionHandlerByCode(actionCode);
-                if (!handler) {
-                    throw new Error("Unknown handler: " + actionCode);
+            let handler = routeConfig.handler;
+            if (handler) {
+                if (lodash.isString(handler)) {
+                    handler = new Function(`return (${routeConfig.handler})`);
                 }
-                await server.beforeRunActionHandler(handlerContext, actionConfig);
-                const result = handler(handlerContext, actionConfig.config);
-                if (result instanceof Promise) {
-                    await result;
+                if (lodash.isFunction(handler)) {
+                    const result = handler(handlerContext);
+                    if (result instanceof Promise) {
+                        await result;
+                    }
+                }
+                else {
+                    throw new Error(`Invalid handler for route ${routeConfig.code}: ${routeConfig.handler}`);
+                }
+            }
+            else if (routeConfig.actions) {
+                for (const actionConfig of routeConfig.actions) {
+                    const actionCode = actionConfig.code;
+                    const handler = server.getActionHandlerByCode(actionCode);
+                    if (!handler) {
+                        throw new Error("Unknown handler: " + actionCode);
+                    }
+                    await server.beforeRunActionHandler(handlerContext, actionConfig);
+                    const result = handler(handlerContext, actionConfig.config);
+                    if (result instanceof Promise) {
+                        await result;
+                    }
                 }
             }
+            else {
+                throw new Error(`No handler or actions defined for route ${routeConfig.code}`);
+            }
             if (!isNullOrUndefined(handlerContext.output)) {
                 routerContext.json(handlerContext.output, handlerContext.status);
             }
@@ -3963,6 +3983,21 @@ class EntityManager {
     }
 }
 
+var healthz = {
+    namespace: "sys",
+    name: "sys.healthz",
+    code: "sys.healthz",
+    type: "RESTful",
+    method: "GET",
+    endpoint: "/healthz",
+    handler: handler$x,
+};
+async function handler$x(ctx) {
+    ctx.output = {};
+}
+
+var coreRoutes = [healthz];
+
 class RapidServer {
     #logger;
     #facilityFactories;
@@ -4237,7 +4272,12 @@ class RapidServer {
                 this.#entityBeforeResponseEventEmitters.on(entityWatcher.modelSingularCode, entityWatcher.handler);
             }
         }
+        this.#applicationConfig = lodash.cloneDeep(this.#bootstrapApplicationConfig);
+        this.appendApplicationConfig({
+            routes: coreRoutes,
+        });
         await this.configureApplication();
+        this.#buildedRoutes = await buildRoutes(this, this.#applicationConfig);
         if (!this.#disableCronJobs) {
             await pluginManager.registerCronJobs();
         }
@@ -4245,7 +4285,6 @@ class RapidServer {
         await pluginManager.onApplicationReady(this.#applicationConfig);
     }
     async configureApplication() {
-        this.#applicationConfig = lodash.cloneDeep(this.#bootstrapApplicationConfig);
         const pluginManager = this.#pluginManager;
         await pluginManager.onLoadingApplication(this.#applicationConfig);
         await pluginManager.configureModels(this.#applicationConfig);
@@ -4254,7 +4293,6 @@ class RapidServer {
         await pluginManager.configureRoutes(this.#applicationConfig);
         // TODO: check application configuration.
         await pluginManager.onApplicationLoaded(this.#applicationConfig);
-        this.#buildedRoutes = await buildRoutes(this, this.#applicationConfig);
     }
     registerFacilityFactory(factory) {
         this.#facilityFactories.set(factory.name, factory);
@@ -5066,7 +5104,7 @@ async function generatePasswordHash(password, salt) {
  * @returns
  */
 async function validatePassword(password, passwordHash) {
-    const isMatch = await bcrypt__default["default"].compare(password, passwordHash);
+    const isMatch = await bcrypt__default["default"].compare(password || "", passwordHash || "");
     return isMatch;
 }
 
@@ -5174,32 +5212,32 @@ class CacheFactory {
     }
 }
 
-const code$v = "listMetaModels";
-async function handler$v(plugin, ctx, options) {
+const code$w = "listMetaModels";
+async function handler$w(plugin, ctx, options) {
     const { applicationConfig } = ctx;
     ctx.output = { list: applicationConfig.models };
 }
 
 var listMetaModels = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$v,
-  handler: handler$v
+  code: code$w,
+  handler: handler$w
 });
 
-const code$u = "listMetaRoutes";
-async function handler$u(plugin, ctx, options) {
+const code$v = "listMetaRoutes";
+async function handler$v(plugin, ctx, options) {
     const { applicationConfig } = ctx;
     ctx.output = { list: applicationConfig.routes };
 }
 
 var listMetaRoutes = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$u,
-  handler: handler$u
+  code: code$v,
+  handler: handler$v
 });
 
-const code$t = "getMetaModelDetail";
-async function handler$t(plugin, ctx, options) {
+const code$u = "getMetaModelDetail";
+async function handler$u(plugin, ctx, options) {
     const { server, input } = ctx;
     const model = server.getModel(input);
     ctx.output = model;
@@ -5207,8 +5245,8 @@ async function handler$t(plugin, ctx, options) {
 
 var getMetaModelDetail = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$t,
-  handler: handler$t
+  code: code$u,
+  handler: handler$u
 });
 
 function removeFiltersWithNullValue(filters) {
@@ -5797,9 +5835,9 @@ async function runCollectionEntityActionHandler(ctx, options, code, autoMergeInp
     }
 }
 
-const code$s = "findCollectionEntities";
-async function handler$s(plugin, ctx, options) {
-    await runCollectionEntityActionHandler(ctx, options, code$s, true, false, async (entityManager, input) => {
+const code$t = "findCollectionEntities";
+async function handler$t(plugin, ctx, options) {
+    await runCollectionEntityActionHandler(ctx, options, code$t, true, false, async (entityManager, input) => {
         const { routerContext: routeContext } = ctx;
         input.filters = removeFiltersWithNullValue(input.filters);
         input.routeContext = routeContext;
@@ -5816,13 +5854,13 @@ async function handler$s(plugin, ctx, options) {
 
 var findCollectionEntities = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$s,
-  handler: handler$s
+  code: code$t,
+  handler: handler$t
 });
 
-const code$r = "findCollectionEntityById";
-async function handler$r(plugin, ctx, options) {
-    await runCollectionEntityActionHandler(ctx, options, code$r, true, true, async (entityManager, input) => {
+const code$s = "findCollectionEntityById";
+async function handler$s(plugin, ctx, options) {
+    await runCollectionEntityActionHandler(ctx, options, code$s, true, true, async (entityManager, input) => {
         const { routerContext: routeContext } = ctx;
         const { id } = input;
         const entity = await entityManager.findById({
@@ -5844,13 +5882,13 @@ async function handler$r(plugin, ctx, options) {
 
 var findCollectionEntityById = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$r,
-  handler: handler$r
+  code: code$s,
+  handler: handler$s
 });
 
-const code$q = "countCollectionEntities";
-async function handler$q(plugin, ctx, options) {
-    await runCollectionEntityActionHandler(ctx, options, code$q, true, false, async (entityManager, input) => {
+const code$r = "countCollectionEntities";
+async function handler$r(plugin, ctx, options) {
+    await runCollectionEntityActionHandler(ctx, options, code$r, true, false, async (entityManager, input) => {
         const { routerContext: routeContext } = ctx;
         input.filters = removeFiltersWithNullValue(input.filters);
         input.routeContext = routeContext;
@@ -5861,13 +5899,13 @@ async function handler$q(plugin, ctx, options) {
 
 var countCollectionEntities = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$q,
-  handler: handler$q
+  code: code$r,
+  handler: handler$r
 });
 
-const code$p = "createCollectionEntity";
-async function handler$p(plugin, ctx, options) {
-    await runCollectionEntityActionHandler(ctx, options, code$p, true, true, async (entityManager, input) => {
+const code$q = "createCollectionEntity";
+async function handler$q(plugin, ctx, options) {
+    await runCollectionEntityActionHandler(ctx, options, code$q, true, true, async (entityManager, input) => {
         const { routerContext: routeContext } = ctx;
         const output = await entityManager.createEntity({
             entity: input,
@@ -5879,16 +5917,16 @@ async function handler$p(plugin, ctx, options) {
 
 var createCollectionEntity = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$p,
-  handler: handler$p
+  code: code$q,
+  handler: handler$q
 });
 
-const code$o = "createCollectionEntitiesBatch";
-async function handler$o(plugin, ctx, options) {
+const code$p = "createCollectionEntitiesBatch";
+async function handler$p(plugin, ctx, options) {
     const { input } = ctx;
     const { noTransaction } = input;
     const { defaultInput, fixedInput } = options;
-    await runCollectionEntityActionHandler(ctx, options, code$o, false, !noTransaction, async (entityManager, input) => {
+    await runCollectionEntityActionHandler(ctx, options, code$p, false, !noTransaction, async (entityManager, input) => {
         const { routerContext: routeContext } = ctx;
         const { entities } = input;
         if (!lodash.isArray(entities)) {
@@ -5926,13 +5964,13 @@ async function createEntities(options) {
 
 var createCollectionEntitiesBatch = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$o,
-  handler: handler$o
+  code: code$p,
+  handler: handler$p
 });
 
-const code$n = "updateCollectionEntityById";
-async function handler$n(plugin, ctx, options) {
-    await runCollectionEntityActionHandler(ctx, options, code$n, true, true, async (entityManager, input) => {
+const code$o = "updateCollectionEntityById";
+async function handler$o(plugin, ctx, options) {
+    await runCollectionEntityActionHandler(ctx, options, code$o, true, true, async (entityManager, input) => {
         const { routerContext: routeContext } = ctx;
         const operation = input.$operation;
         if (operation) {
@@ -5961,15 +5999,15 @@ async function handler$n(plugin, ctx, options) {
 
 var updateCollectionEntityById = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$n,
-  handler: handler$n
+  code: code$o,
+  handler: handler$o
 });
 
-const code$m = "deleteCollectionEntities";
-async function handler$m(plugin, ctx, options) {
+const code$n = "deleteCollectionEntities";
+async function handler$n(plugin, ctx, options) {
     const { input } = ctx;
     const { noTransaction } = input;
-    await runCollectionEntityActionHandler(ctx, options, code$m, true, !noTransaction, async (entityManager, input) => {
+    await runCollectionEntityActionHandler(ctx, options, code$n, true, !noTransaction, async (entityManager, input) => {
         const { routerContext: routeContext } = ctx;
         const { filters } = input;
         if (!filters || !filters.length) {
@@ -5991,13 +6029,13 @@ async function handler$m(plugin, ctx, options) {
 
 var deleteCollectionEntities = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$m,
-  handler: handler$m
+  code: code$n,
+  handler: handler$n
 });
 
-const code$l = "deleteCollectionEntityById";
-async function handler$l(plugin, ctx, options) {
-    await runCollectionEntityActionHandler(ctx, options, code$l, true, true, async (entityManager, input) => {
+const code$m = "deleteCollectionEntityById";
+async function handler$m(plugin, ctx, options) {
+    await runCollectionEntityActionHandler(ctx, options, code$m, true, true, async (entityManager, input) => {
         const { routerContext: routeContext } = ctx;
         await entityManager.deleteById({
             id: input.id,
@@ -6009,13 +6047,13 @@ async function handler$l(plugin, ctx, options) {
 
 var deleteCollectionEntityById = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$l,
-  handler: handler$l
+  code: code$m,
+  handler: handler$m
 });
 
-const code$k = "addEntityRelations";
-async function handler$k(plugin, ctx, options) {
-    await runCollectionEntityActionHandler(ctx, options, code$k, true, true, async (entityManager, input) => {
+const code$l = "addEntityRelations";
+async function handler$l(plugin, ctx, options) {
+    await runCollectionEntityActionHandler(ctx, options, code$l, true, true, async (entityManager, input) => {
         const { routerContext: routeContext } = ctx;
         input.routeContext = routeContext;
         await entityManager.addRelations(input, plugin);
@@ -6025,13 +6063,13 @@ async function handler$k(plugin, ctx, options) {
 
 var addEntityRelations = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$k,
-  handler: handler$k
+  code: code$l,
+  handler: handler$l
 });
 
-const code$j = "removeEntityRelations";
-async function handler$j(plugin, ctx, options) {
-    await runCollectionEntityActionHandler(ctx, options, code$j, true, true, async (entityManager, input) => {
+const code$k = "removeEntityRelations";
+async function handler$k(plugin, ctx, options) {
+    await runCollectionEntityActionHandler(ctx, options, code$k, true, true, async (entityManager, input) => {
         const { routerContext: routeContext } = ctx;
         input.routeContext = routeContext;
         await entityManager.removeRelations(input, plugin);
@@ -6041,16 +6079,16 @@ async function handler$j(plugin, ctx, options) {
 
 var removeEntityRelations = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$j,
-  handler: handler$j
+  code: code$k,
+  handler: handler$k
 });
 
-const code$i = "queryDatabase";
-async function handler$i(plugin, ctx, options) {
+const code$j = "queryDatabase";
+async function handler$j(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { sql, querySingle, defaultInput, fixedInput } = options;
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    logger.debug(`Running ${code$i} handler...`, { defaultInput, fixedInput, mergedInput });
+    logger.debug(`Running ${code$j} handler...`, { defaultInput, fixedInput, mergedInput });
     const result = await server.queryDatabaseObject(sql, mergedInput);
     if (querySingle) {
         ctx.output = lodash.first(result);
@@ -6062,8 +6100,8 @@ async function handler$i(plugin, ctx, options) {
 
 var queryDatabase = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$i,
-  handler: handler$i
+  code: code$j,
+  handler: handler$j
 });
 
 /**
@@ -6241,21 +6279,21 @@ async function sendSourceResponse(proxyCtx, targetRes) {
     srcRes.body = targetRes.body;
 }
 
-const code$h = "httpProxy";
-async function handler$h(plugin, ctx, options) {
+const code$i = "httpProxy";
+async function handler$i(plugin, ctx, options) {
     const { logger } = ctx;
-    logger.debug(`Running ${code$h} handler...`);
+    logger.debug(`Running ${code$i} handler...`);
     await doProxy(ctx.routerContext, options);
 }
 
 var httpProxyActionHandler = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$h,
-  handler: handler$h
+  code: code$i,
+  handler: handler$i
 });
 
-const code$g = "mock";
-async function handler$g(plugin, ctx, options) {
+const code$h = "mock";
+async function handler$h(plugin, ctx, options) {
     const { logger, routerContext } = ctx;
     const { response } = routerContext;
     const { responseTime, responseStatus, responseHeaders, responseBody } = options;
@@ -6274,8 +6312,8 @@ function waitMilliseconds(ms) {
 
 var mockActionHandler = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$g,
-  handler: handler$g
+  code: code$h,
+  handler: handler$h
 });
 
 /**
@@ -6323,8 +6361,8 @@ class RouteManager {
     }
 }
 
-const code$f = "generateSn";
-async function handler$f(plugin, ctx, options) {
+const code$g = "generateSn";
+async function handler$g(plugin, ctx, options) {
     const { server, routerContext: routeContext } = ctx;
     const input = ctx.input;
     if (options?.ruleCode) {
@@ -6342,8 +6380,8 @@ async function handler$f(plugin, ctx, options) {
 
 var generateSn$1 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$f,
-  handler: handler$f
+  code: code$g,
+  handler: handler$g
 });
 
 var pluginActionHandlers$8 = [generateSn$1];
@@ -6923,8 +6961,8 @@ class WebhooksPlugin {
     }
 }
 
-const code$e = "changePassword";
-async function handler$e(plugin, ctx, options) {
+const code$f = "changePassword";
+async function handler$f(plugin, ctx, options) {
     const { server, input, routerContext: routeContext } = ctx;
     const { id, oldPassword, newPassword } = input;
     const userId = routeContext.state.userId;
@@ -6966,12 +7004,12 @@ async function handler$e(plugin, ctx, options) {
 
 var changePassword$1 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$e,
-  handler: handler$e
+  code: code$f,
+  handler: handler$f
 });
 
-const code$d = "createSession";
-async function handler$d(plugin, ctx, options) {
+const code$e = "createSession";
+async function handler$e(plugin, ctx, options) {
     const { server, input, routerContext: routeContext, logger } = ctx;
     const { response } = routeContext;
     const { account, password } = input;
@@ -7021,12 +7059,12 @@ async function handler$d(plugin, ctx, options) {
 
 var createSession = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$d,
-  handler: handler$d
+  code: code$e,
+  handler: handler$e
 });
 
-const code$c = "deleteSession";
-async function handler$c(plugin, ctx, options) {
+const code$d = "deleteSession";
+async function handler$d(plugin, ctx, options) {
     const { server, input, routerContext } = ctx;
     const { response } = routerContext;
     setCookie(response.headers, {
@@ -7039,12 +7077,12 @@ async function handler$c(plugin, ctx, options) {
 
 var deleteSession = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$c,
-  handler: handler$c
+  code: code$d,
+  handler: handler$d
 });
 
-const code$b = "getMyProfile";
-async function handler$b(plugin, ctx, options) {
+const code$c = "getMyProfile";
+async function handler$c(plugin, ctx, options) {
     const { server, input, routerContext } = ctx;
     const userId = routerContext.state.userId;
     if (!userId) {
@@ -7076,12 +7114,12 @@ async function handler$b(plugin, ctx, options) {
 
 var getMyProfile$2 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$b,
-  handler: handler$b
+  code: code$c,
+  handler: handler$c
 });
 
-const code$a = "resetPassword";
-async function handler$a(plugin, ctx, options) {
+const code$b = "resetPassword";
+async function handler$b(plugin, ctx, options) {
     const { server, input, routerContext: routeContext } = ctx;
     const { userId, password } = input;
     const userEntitySingularCode = plugin.options?.userEntitySingularCode || "oc_user";
@@ -7109,8 +7147,8 @@ async function handler$a(plugin, ctx, options) {
 
 var resetPassword$1 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$a,
-  handler: handler$a
+  code: code$b,
+  handler: handler$b
 });
 
 var pluginActionHandlers$7 = [changePassword$1, createSession, deleteSession, getMyProfile$2, resetPassword$1];
@@ -7365,8 +7403,8 @@ function getFileBaseName(pathname) {
     return path__default["default"].basename(pathname, extName);
 }
 
-const code$9 = "downloadDocument";
-async function handler$9(plugin, ctx, options) {
+const code$a = "downloadDocument";
+async function handler$a(plugin, ctx, options) {
     const { server, applicationConfig, routerContext: routeContext, input } = ctx;
     const { request, response } = routeContext;
     const documentDataAccessor = ctx.server.getDataAccessor({
@@ -7422,12 +7460,12 @@ async function handler$9(plugin, ctx, options) {
 
 var downloadDocumentActionHandler = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$9,
-  handler: handler$9
+  code: code$a,
+  handler: handler$a
 });
 
-const code$8 = "downloadFile";
-async function handler$8(plugin, ctx, options) {
+const code$9 = "downloadFile";
+async function handler$9(plugin, ctx, options) {
     const { server, applicationConfig, routerContext: routeContext } = ctx;
     const { request, response } = routeContext;
     //TODO: only public files can download by this handler
@@ -7453,12 +7491,12 @@ async function handler$8(plugin, ctx, options) {
 
 var downloadFileActionHandler = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$8,
-  handler: handler$8
+  code: code$9,
+  handler: handler$9
 });
 
-const code$7 = "uploadFile";
-async function handler$7(plugin, ctx, options) {
+const code$8 = "uploadFile";
+async function handler$8(plugin, ctx, options) {
     const { server, applicationConfig, routerContext, input } = ctx;
     let file = input.file || input.files;
     if (lodash.isArray(file)) {
@@ -7479,8 +7517,8 @@ async function handler$7(plugin, ctx, options) {
 
 var uploadFileActionHandler = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$7,
-  handler: handler$7
+  code: code$8,
+  handler: handler$8
 });
 
 var getMyProfile = {
@@ -7556,8 +7594,8 @@ class FileManager {
     }
 }
 
-const code$6 = "getLicense";
-async function handler$6(plugin, ctx, options) {
+const code$7 = "getLicense";
+async function handler$7(plugin, ctx, options) {
     const { server, routerContext } = ctx;
     const licenseService = server.getService("licenseService");
     const license = licenseService.getLicense();
@@ -7565,12 +7603,27 @@ async function handler$6(plugin, ctx, options) {
 }
 
 var getLicense$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$7,
+  handler: handler$7
+});
+
+const code$6 = "updateLicense";
+async function handler$6(plugin, ctx, options) {
+    const { server, routerContext } = ctx;
+    const input = ctx.input;
+    const licenseService = server.getService("licenseService");
+    const license = await licenseService.updateLicense(input.certText);
+    ctx.output = license;
+}
+
+var updateLicense$1 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   code: code$6,
   handler: handler$6
 });
 
-var pluginActionHandlers$6 = [getLicense$1];
+var pluginActionHandlers$6 = [getLicense$1, updateLicense$1];
 
 var pluginModels$5 = [];
 
@@ -7588,7 +7641,21 @@ var getLicense = {
     ],
 };
 
-var pluginRoutes$5 = [getLicense];
+var updateLicense = {
+    namespace: "svc",
+    name: "svc.updateLicense",
+    code: "svc.updateLicense",
+    type: "RESTful",
+    method: "POST",
+    endpoint: "/svc/license",
+    actions: [
+        {
+            code: "updateLicense",
+        },
+    ],
+};
+
+var pluginRoutes$5 = [getLicense, updateLicense];
 
 function getEncryptionIV(input) {
     const hash = crypto__default["default"].createHash("sha512").update(input).digest("hex");
@@ -7644,16 +7711,13 @@ class LicenseService {
     async loadLicense() {
         const settingService = this.#server.getService("settingService");
         const licenseSettings = await settingService.getSystemSettingValues("license");
-        const { deployId } = licenseSettings;
-        const certText = licenseSettings.cert;
+        const { deployId, cert: certText } = licenseSettings;
         if (!deployId || !certText) {
             this.#server.getLogger().warn("License was not loaded properly.");
             return;
         }
-        const certJSON = Buffer.from(certText, "base64").toString();
-        const cert = JSON.parse(certJSON);
         try {
-            const license = extractCertLicense(this.#encryptionKey, deployId, cert);
+            const license = this.parseLicense(deployId, certText);
             this.#license = license;
         }
         catch (error) {
@@ -7664,6 +7728,26 @@ class LicenseService {
     getLicense() {
         return this.#license;
     }
+    parseLicense(deployId, certText) {
+        const certJSON = Buffer.from(certText, "base64").toString();
+        const cert = JSON.parse(certJSON);
+        return extractCertLicense(this.#encryptionKey, deployId, cert);
+    }
+    async updateLicense(certText) {
+        const settingService = this.#server.getService("settingService");
+        const deployId = await settingService.getSystemSettingValue("license", "deployId");
+        let license;
+        try {
+            license = this.parseLicense(deployId, certText);
+        }
+        catch (error) {
+            this.#server.getLogger().error("Parse license failed.", error);
+            throw new Error("Parse license failed.");
+        }
+        await settingService.setSystemSettingValue("license", "cert", certText);
+        this.#license = license;
+        return license;
+    }
     isExpired() {
         if (!this.#license) {
             return true;

package/dist/plugins/license/LicenseService.d.ts

@@ -15,6 +15,8 @@ export default class LicenseService {
     constructor(server: IRpdServer, encryptionKey: string);
     loadLicense(): Promise<void>;
     getLicense(): RpdLicense;
+    parseLicense(deployId: string, certText: string): RpdLicense;
+    updateLicense(certText: string): Promise<RpdLicense>;
     isExpired(): boolean;
     getQuota(name: string): any;
     isOutOfQuota(name: string, currentAmount: number): boolean;

package/dist/plugins/license/actionHandlers/index.d.ts

@@ -1,3 +1,4 @@
 import * as getLicense from "./getLicense";
-declare const _default: (typeof getLicense)[];
+import * as updateLicense from "./updateLicense";
+declare const _default: (typeof getLicense | typeof updateLicense)[];
 export default _default;

package/dist/plugins/license/actionHandlers/updateLicense.d.ts

@@ -0,0 +1,9 @@
+import { ActionHandlerContext } from "../../../core/actionHandler";
+import { RapidPlugin } from "../../../core/server";
+export interface UpdateLicenseOptions {
+}
+export interface UpdateLicenseInput {
+    certText: string;
+}
+export declare const code = "updateLicense";
+export declare function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, options: UpdateLicenseOptions): Promise<void>;

package/dist/plugins/license/routes/index.d.ts

@@ -1,4 +1,4 @@
-declare const _default: {
+declare const _default: ({
     namespace: string;
     name: string;
     code: string;
@@ -8,5 +8,15 @@ declare const _default: {
     actions: {
         code: string;
     }[];
-}[];
+} | {
+    namespace: string;
+    name: string;
+    code: string;
+    type: "RESTful";
+    method: "POST";
+    endpoint: string;
+    actions: {
+        code: string;
+    }[];
+})[];
 export default _default;

package/dist/plugins/license/routes/updateLicense.d.ts

@@ -0,0 +1,12 @@
+declare const _default: {
+    namespace: string;
+    name: string;
+    code: string;
+    type: "RESTful";
+    method: "POST";
+    endpoint: string;
+    actions: {
+        code: string;
+    }[];
+};
+export default _default;

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+import { ActionHandlerContext } from "./core/actionHandler";
 import { RouteContext } from "./core/routeContext";
 import { IRpdServer, RapidPlugin } from "./core/server";
 import { ColumnSelectOptions, CountRowOptions, FindRowOptions, RowFilterOptions } from "./dataAccess/dataAccessTypes";
@@ -483,6 +484,7 @@ export interface RpdRoute {
     method: RpdHttpMethod;
     endpoint: string;
     actions?: RpdRouteActionConfig[];
+    handler?: string | ((ctx: ActionHandlerContext) => Promise<void>);
 }
 export type RpdHttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
 export interface RpdRouteActionConfig {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruiapp/rapid-core",
-  "version": "0.9.5",
+  "version": "0.9.7",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/core/routes/healthz.ts

@@ -0,0 +1,20 @@
+import { RpdRoute } from "~/types";
+import { ActionHandlerContext } from "../actionHandler";
+
+export default {
+  namespace: "sys",
+  name: "sys.healthz",
+  code: "sys.healthz",
+  type: "RESTful",
+  method: "GET",
+  endpoint: "/healthz",
+  handler,
+} satisfies RpdRoute;
+
+export async function handler(ctx: ActionHandlerContext) {
+  const { server, input, routerContext: routeContext, logger } = ctx;
+  const { response } = routeContext;
+  const {} = input;
+
+  ctx.output = {};
+}

package/src/core/routes/index.ts

@@ -0,0 +1,3 @@
+import healthz from "./healthz";
+
+export default [healthz];

package/src/core/routesBuilder.ts

@@ -5,7 +5,7 @@ import { IRpdServer } from "~/core/server";
 import { RpdApplicationConfig } from "~/types";
 import { isNullOrUndefined } from "~/utilities/typeUtility";
 import { Next, RouteContext } from "./routeContext";
-import { cloneDeep } from "lodash";
+import { cloneDeep, isFunction, isString } from "lodash";
 
 export async function buildRoutes(server: IRpdServer, applicationConfig: RpdApplicationConfig) {
   const logger = server.getLogger();
@@ -67,19 +67,37 @@ export async function buildRoutes(server: IRpdServer, applicationConfig: RpdAppl
 
       await server.beforeRunRouteActions(handlerContext);
 
-      for (const actionConfig of routeConfig.actions) {
-        const actionCode = actionConfig.code;
-        const handler = server.getActionHandlerByCode(actionCode);
-        if (!handler) {
-          throw new Error("Unknown handler: " + actionCode);
+      let handler = routeConfig.handler as any;
+      if (handler) {
+        if (isString(handler)) {
+          handler = new Function(`return (${routeConfig.handler})`) as any;
         }
 
-        await server.beforeRunActionHandler(handlerContext, actionConfig);
-
-        const result = handler(handlerContext, actionConfig.config);
-        if (result instanceof Promise) {
-          await result;
+        if (isFunction(handler)) {
+          const result = handler(handlerContext);
+          if (result instanceof Promise) {
+            await result;
+          }
+        } else {
+          throw new Error(`Invalid handler for route ${routeConfig.code}: ${routeConfig.handler}`);
+        }
+      } else if (routeConfig.actions) {
+        for (const actionConfig of routeConfig.actions) {
+          const actionCode = actionConfig.code;
+          const handler = server.getActionHandlerByCode(actionCode);
+          if (!handler) {
+            throw new Error("Unknown handler: " + actionCode);
+          }
+
+          await server.beforeRunActionHandler(handlerContext, actionConfig);
+
+          const result = handler(handlerContext, actionConfig.config);
+          if (result instanceof Promise) {
+            await result;
+          }
         }
+      } else {
+        throw new Error(`No handler or actions defined for route ${routeConfig.code}`);
       }
 
       if (!isNullOrUndefined(handlerContext.output)) {

package/src/plugins/license/LicenseService.ts

@@ -37,19 +37,15 @@ export default class LicenseService {
   async loadLicense(): Promise<void> {
     const settingService = this.#server.getService<SettingService>("settingService");
     const licenseSettings = await settingService.getSystemSettingValues("license");
-    const { deployId } = licenseSettings as LicenseSettings;
-    const certText = licenseSettings.cert;
+    const { deployId, cert: certText } = licenseSettings as LicenseSettings;
 
     if (!deployId || !certText) {
       this.#server.getLogger().warn("License was not loaded properly.");
       return;
     }
 
-    const certJSON = Buffer.from(certText, "base64").toString();
-    const cert: RpdCert = JSON.parse(certJSON);
-
     try {
-      const license = extractCertLicense(this.#encryptionKey, deployId, cert);
+      const license = this.parseLicense(deployId, certText);
       this.#license = license;
     } catch (error) {
       this.#server.getLogger().error("Loading license failed.", error);
@@ -61,6 +57,29 @@ export default class LicenseService {
     return this.#license;
   }
 
+  parseLicense(deployId: string, certText: string): RpdLicense {
+    const certJSON = Buffer.from(certText, "base64").toString();
+    const cert: RpdCert = JSON.parse(certJSON);
+    return extractCertLicense(this.#encryptionKey, deployId, cert);
+  }
+
+  async updateLicense(certText: string) {
+    const settingService = this.#server.getService<SettingService>("settingService");
+    const deployId: string = await settingService.getSystemSettingValue("license", "deployId");
+
+    let license: RpdLicense;
+    try {
+      license = this.parseLicense(deployId, certText);
+    } catch (error) {
+      this.#server.getLogger().error("Parse license failed.", error);
+      throw new Error("Parse license failed.");
+    }
+
+    await settingService.setSystemSettingValue("license", "cert", certText);
+    this.#license = license;
+    return license;
+  }
+
   isExpired() {
     if (!this.#license) {
       return true;

package/src/plugins/license/actionHandlers/index.ts

@@ -1,4 +1,5 @@
 import { IPluginActionHandler } from "~/core/actionHandler";
 import * as getLicense from "./getLicense";
+import * as updateLicense from "./updateLicense";
 
-export default [getLicense] satisfies IPluginActionHandler[];
+export default [getLicense, updateLicense] satisfies IPluginActionHandler[];

package/src/plugins/license/actionHandlers/updateLicense.ts

@@ -0,0 +1,24 @@
+import { ActionHandlerContext } from "~/core/actionHandler";
+import { RapidPlugin } from "~/core/server";
+import LicenseService from "../LicenseService";
+
+export interface UpdateLicenseOptions {}
+
+export interface UpdateLicenseInput {
+  certText: string;
+}
+
+export const code = "updateLicense";
+
+export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, options: UpdateLicenseOptions) {
+  const { server, routerContext } = ctx;
+  const { response } = routerContext;
+
+  const input: UpdateLicenseInput = ctx.input;
+
+  const licenseService = server.getService<LicenseService>("licenseService");
+
+  const license = await licenseService.updateLicense(input.certText);
+
+  ctx.output = license;
+}

package/src/plugins/license/routes/index.ts

@@ -1,3 +1,4 @@
 import getLicense from "./getLicense";
+import updateLicense from "./updateLicense";
 
-export default [getLicense];
+export default [getLicense, updateLicense];

package/src/plugins/license/routes/updateLicense.ts

@@ -0,0 +1,15 @@
+import { RpdRoute } from "~/types";
+
+export default {
+  namespace: "svc",
+  name: "svc.updateLicense",
+  code: "svc.updateLicense",
+  type: "RESTful",
+  method: "POST",
+  endpoint: "/svc/license",
+  actions: [
+    {
+      code: "updateLicense",
+    },
+  ],
+} satisfies RpdRoute;

package/src/server.ts

@@ -35,6 +35,7 @@ import { bind, cloneDeep, find, forEach, isString, merge, omit } from "lodash";
 import { Logger } from "./facilities/log/LogFacility";
 import { FacilityFactory } from "./core/facility";
 import { CronJobConfiguration } from "./types/cron-job-types";
+import coreRoutes from "./core/routes";
 
 export interface InitServerOptions {
   logger: Logger;
@@ -367,7 +368,12 @@ export class RapidServer implements IRpdServer {
       }
     }
 
+    this.#applicationConfig = cloneDeep(this.#bootstrapApplicationConfig) as RpdApplicationConfig;
+    this.appendApplicationConfig({
+      routes: coreRoutes,
+    });
     await this.configureApplication();
+    this.#buildedRoutes = await buildRoutes(this, this.#applicationConfig);
 
     if (!this.#disableCronJobs) {
       await pluginManager.registerCronJobs();
@@ -378,8 +384,6 @@ export class RapidServer implements IRpdServer {
   }
 
   async configureApplication() {
-    this.#applicationConfig = cloneDeep(this.#bootstrapApplicationConfig) as RpdApplicationConfig;
-
     const pluginManager = this.#pluginManager;
     await pluginManager.onLoadingApplication(this.#applicationConfig);
     await pluginManager.configureModels(this.#applicationConfig);
@@ -390,8 +394,6 @@ export class RapidServer implements IRpdServer {
     // TODO: check application configuration.
 
     await pluginManager.onApplicationLoaded(this.#applicationConfig);
-
-    this.#buildedRoutes = await buildRoutes(this, this.#applicationConfig);
   }
 
   registerFacilityFactory(factory: FacilityFactory) {

package/src/types.ts

@@ -1,3 +1,4 @@
+import { ActionHandlerContext } from "./core/actionHandler";
 import { RouteContext } from "./core/routeContext";
 import { IRpdServer, RapidPlugin } from "./core/server";
 import { ColumnSelectOptions, CountRowOptions, FindRowOptions, RowFilterOptions } from "./dataAccess/dataAccessTypes";
@@ -586,6 +587,7 @@ export interface RpdRoute {
   method: RpdHttpMethod;
   endpoint: string;
   actions?: RpdRouteActionConfig[];
+  handler?: string | ((ctx: ActionHandlerContext) => Promise<void>);
 }
 
 export type RpdHttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";

package/src/utilities/passwordUtility.ts

@@ -21,6 +21,6 @@ export async function generatePasswordHash(password: string, salt?: number | str
  * @returns
  */
 export async function validatePassword(password: string, passwordHash: string): Promise<boolean> {
-  const isMatch = await bcrypt.compare(password, passwordHash);
+  const isMatch = await bcrypt.compare(password || "", passwordHash || "");
   return isMatch;
 }