@ruiapp/rapid-core 0.9.8 → 0.9.10

package/src/plugins/license/LicenseService.ts

@@ -1,137 +1,137 @@
-import { IRpdServer } from "~/core/server";
-import EntityManager from "~/dataAccess/entityManager";
-import { LicenseSettings, RpdCert, RpdLicense } from "./LicensePluginTypes";
-import { SystemSettingItem } from "../setting/SettingPluginTypes";
-import SettingService from "../setting/SettingService";
-import { extractCertLicense } from "./helpers/certHelper";
-import dayjs from "dayjs";
-import { get, isString } from "lodash";
-import { isNullOrUndefinedOrEmpty } from "~/utilities/typeUtility";
-
-export interface GetSystemSettingValuesInput {
-  groupCode: string;
-}
-
-export interface SetSystemSettingValuesInput {
-  groupCode: string;
-  values: Record<string, any>;
-}
-
-export interface GetUserSettingValuesInput {
-  groupCode: string;
-}
-
-export default class LicenseService {
-  #server: IRpdServer;
-  #systemSettingItemManager: EntityManager<SystemSettingItem>;
-  #encryptionKey: string;
-  #license: RpdLicense;
-
-  constructor(server: IRpdServer, encryptionKey: string) {
-    this.#server = server;
-    this.#encryptionKey = encryptionKey;
-
-    this.#systemSettingItemManager = server.getEntityManager("system_setting_item");
-  }
-
-  async loadLicense(): Promise<void> {
-    const settingService = this.#server.getService<SettingService>("settingService");
-    const licenseSettings = await settingService.getSystemSettingValues("license");
-    const { deployId, cert: certText } = licenseSettings as LicenseSettings;
-
-    if (!deployId || !certText) {
-      this.#server.getLogger().warn("License was not loaded properly.");
-      return;
-    }
-
-    try {
-      const license = this.parseLicense(deployId, certText);
-      this.#license = license;
-    } catch (error) {
-      this.#server.getLogger().error("Loading license failed.", error);
-      throw new Error("Loading license failed.");
-    }
-  }
-
-  getLicense() {
-    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;
-    }
-
-    const { neverExpire, expireDate } = this.#license.authority;
-
-    if (neverExpire) {
-      return false;
-    }
-
-    if (!expireDate) {
-      return true;
-    }
-
-    const today = dayjs(dayjs().format("YYYY-MM-DD"));
-    return today.isAfter(dayjs(expireDate));
-  }
-
-  getQuota(name: string) {
-    if (!this.#license) {
-      return null;
-    }
-
-    return get(this.#license.authority, `quota.${name}`, null);
-  }
-
-  isOutOfQuota(name: string, currentAmount: number) {
-    const quotaLimit = this.getQuota(name);
-
-    if (isNullOrUndefinedOrEmpty(quotaLimit)) {
-      return true;
-    }
-
-    let quotaLimitAmount: string | number = quotaLimit;
-    if (isString(quotaLimitAmount)) {
-      quotaLimitAmount = parseInt(quotaLimit, 10);
-    }
-
-    if (quotaLimitAmount === -1) {
-      return true;
-    }
-
-    return currentAmount > quotaLimitAmount;
-  }
-
-  isFunctionAllowed(name: string) {
-    if (!this.#license) {
-      return false;
-    }
-
-    const functions = get(this.#license.authority, "functions", []);
-    return functions.includes(name);
-  }
-}
+import { IRpdServer } from "~/core/server";
+import EntityManager from "~/dataAccess/entityManager";
+import { LicenseSettings, RpdCert, RpdLicense } from "./LicensePluginTypes";
+import { SystemSettingItem } from "../setting/SettingPluginTypes";
+import SettingService from "../setting/SettingService";
+import { extractCertLicense } from "./helpers/certHelper";
+import dayjs from "dayjs";
+import { get, isString } from "lodash";
+import { isNullOrUndefinedOrEmpty } from "~/utilities/typeUtility";
+
+export interface GetSystemSettingValuesInput {
+  groupCode: string;
+}
+
+export interface SetSystemSettingValuesInput {
+  groupCode: string;
+  values: Record<string, any>;
+}
+
+export interface GetUserSettingValuesInput {
+  groupCode: string;
+}
+
+export default class LicenseService {
+  #server: IRpdServer;
+  #systemSettingItemManager: EntityManager<SystemSettingItem>;
+  #encryptionKey: string;
+  #license: RpdLicense;
+
+  constructor(server: IRpdServer, encryptionKey: string) {
+    this.#server = server;
+    this.#encryptionKey = encryptionKey;
+
+    this.#systemSettingItemManager = server.getEntityManager("system_setting_item");
+  }
+
+  async loadLicense(): Promise<void> {
+    const settingService = this.#server.getService<SettingService>("settingService");
+    const licenseSettings = await settingService.getSystemSettingValues("license");
+    const { deployId, cert: certText } = licenseSettings as LicenseSettings;
+
+    if (!deployId || !certText) {
+      this.#server.getLogger().warn("License was not loaded properly.");
+      return;
+    }
+
+    try {
+      const license = this.parseLicense(deployId, certText);
+      this.#license = license;
+    } catch (error) {
+      this.#server.getLogger().error("Loading license failed.", error);
+      throw new Error("Loading license failed.");
+    }
+  }
+
+  getLicense() {
+    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;
+    }
+
+    const { neverExpire, expireDate } = this.#license.authority;
+
+    if (neverExpire) {
+      return false;
+    }
+
+    if (!expireDate) {
+      return true;
+    }
+
+    const today = dayjs(dayjs().format("YYYY-MM-DD"));
+    return today.isAfter(dayjs(expireDate));
+  }
+
+  getQuota(name: string) {
+    if (!this.#license) {
+      return null;
+    }
+
+    return get(this.#license.authority, `quota.${name}`, null);
+  }
+
+  isOutOfQuota(name: string, currentAmount: number) {
+    const quotaLimit = this.getQuota(name);
+
+    if (isNullOrUndefinedOrEmpty(quotaLimit)) {
+      return true;
+    }
+
+    let quotaLimitAmount: string | number = quotaLimit;
+    if (isString(quotaLimitAmount)) {
+      quotaLimitAmount = parseInt(quotaLimit, 10);
+    }
+
+    if (quotaLimitAmount === -1) {
+      return true;
+    }
+
+    return currentAmount > quotaLimitAmount;
+  }
+
+  isFunctionAllowed(name: string) {
+    if (!this.#license) {
+      return false;
+    }
+
+    const functions = get(this.#license.authority, "functions", []);
+    return functions.includes(name);
+  }
+}

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

@@ -1,18 +1,18 @@
-import { ActionHandlerContext } from "~/core/actionHandler";
-import { RapidPlugin } from "~/core/server";
-import LicenseService from "../LicenseService";
-
-export interface GetLicenseOptions {}
-
-export const code = "getLicense";
-
-export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, options: GetLicenseOptions) {
-  const { server, routerContext } = ctx;
-  const { response } = routerContext;
-
-  const licenseService = server.getService<LicenseService>("licenseService");
-
-  const license = licenseService.getLicense();
-
-  ctx.output = license;
-}
+import { ActionHandlerContext } from "~/core/actionHandler";
+import { RapidPlugin } from "~/core/server";
+import LicenseService from "../LicenseService";
+
+export interface GetLicenseOptions {}
+
+export const code = "getLicense";
+
+export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, options: GetLicenseOptions) {
+  const { server, routerContext } = ctx;
+  const { response } = routerContext;
+
+  const licenseService = server.getService<LicenseService>("licenseService");
+
+  const license = licenseService.getLicense();
+
+  ctx.output = license;
+}

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

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

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

@@ -1,24 +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;
-}
+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/helpers/certHelper.ts

@@ -1,21 +1,21 @@
-import { RpdCert } from "../LicensePluginTypes";
-import { decryptData, getEncryptionIV, validateDigitalSignature, generatePubKeyFileContent } from "./cryptoHelper";
-
-export function extractCertLicense(encryptionKey: string, deployId: string, cert: RpdCert) {
-  const iv = getEncryptionIV(deployId);
-  const signature = cert.sig;
-  const pub = generatePubKeyFileContent(cert.pub);
-  const valid = validateDigitalSignature(cert.lic, "base64", signature, "base64", pub);
-  if (!valid) {
-    throw new Error("Certification validate failed.");
-  }
-
-  try {
-    const licenseText = decryptData(cert.lic, "base64", "utf-8", encryptionKey, iv, cert.tag);
-    return JSON.parse(licenseText);
-  } catch (ex) {
-    throw new Error("Certification parse failed.", {
-      cause: ex,
-    });
-  }
-}
+import { RpdCert } from "../LicensePluginTypes";
+import { decryptData, getEncryptionIV, validateDigitalSignature, generatePubKeyFileContent } from "./cryptoHelper";
+
+export function extractCertLicense(encryptionKey: string, deployId: string, cert: RpdCert) {
+  const iv = getEncryptionIV(deployId);
+  const signature = cert.sig;
+  const pub = generatePubKeyFileContent(cert.pub);
+  const valid = validateDigitalSignature(cert.lic, "base64", signature, "base64", pub);
+  if (!valid) {
+    throw new Error("Certification validate failed.");
+  }
+
+  try {
+    const licenseText = decryptData(cert.lic, "base64", "utf-8", encryptionKey, iv, cert.tag);
+    return JSON.parse(licenseText);
+  } catch (ex) {
+    throw new Error("Certification parse failed.", {
+      cause: ex,
+    });
+  }
+}

package/src/plugins/license/helpers/cryptoHelper.ts

@@ -1,47 +1,47 @@
-import crypto, { BinaryToTextEncoding } from "crypto";
-
-export function getEncryptionIV(input: string) {
-  const hash = crypto.createHash("sha512").update(input).digest("hex");
-  return hash.substring(0, 12);
-}
-
-export function generatePubKeyFileContent(base64EncodedPubKey: string) {
-  return `-----BEGIN PUBLIC KEY-----\n${base64EncodedPubKey}\n-----END PUBLIC KEY-----`;
-}
-
-const ENC_ALGORITHM: crypto.CipherGCMTypes = "aes-256-gcm";
-
-// Decrypt data
-export function decryptData(
-  encryptedData: string,
-  encryptedDataEncoding: BufferEncoding,
-  decryptedDataEncoding: BufferEncoding,
-  encryptionKey: string,
-  encryptionIV: string,
-  authTag: string,
-) {
-  const decipher = crypto.createDecipheriv(ENC_ALGORITHM, Buffer.from(encryptionKey, "base64"), encryptionIV);
-  decipher.setAuthTag(Buffer.from(authTag, "base64"));
-  const buff = Buffer.from(encryptedData, encryptedDataEncoding);
-  return Buffer.concat([decipher.update(buff), decipher.final()]).toString(decryptedDataEncoding); // Decrypts data and converts to utf8
-}
-
-export function generateDigitalSignature(data: string, dataEncoding: BufferEncoding, privateKey: string): string {
-  const sign = crypto.createSign("RSA-SHA256");
-  const buffer = Buffer.from(data, dataEncoding);
-  sign.update(buffer);
-  return sign.sign(privateKey, "base64");
-}
-
-export function validateDigitalSignature(
-  data: string,
-  dataEncoding: BufferEncoding,
-  signature: string,
-  signatureEncoding: BinaryToTextEncoding,
-  publicKey: string,
-): boolean {
-  const verify = crypto.createVerify("RSA-SHA256");
-  const buffer = Buffer.from(data, dataEncoding);
-  verify.update(buffer);
-  return verify.verify(publicKey, signature, signatureEncoding);
-}
+import crypto, { BinaryToTextEncoding } from "crypto";
+
+export function getEncryptionIV(input: string) {
+  const hash = crypto.createHash("sha512").update(input).digest("hex");
+  return hash.substring(0, 12);
+}
+
+export function generatePubKeyFileContent(base64EncodedPubKey: string) {
+  return `-----BEGIN PUBLIC KEY-----\n${base64EncodedPubKey}\n-----END PUBLIC KEY-----`;
+}
+
+const ENC_ALGORITHM: crypto.CipherGCMTypes = "aes-256-gcm";
+
+// Decrypt data
+export function decryptData(
+  encryptedData: string,
+  encryptedDataEncoding: BufferEncoding,
+  decryptedDataEncoding: BufferEncoding,
+  encryptionKey: string,
+  encryptionIV: string,
+  authTag: string,
+) {
+  const decipher = crypto.createDecipheriv(ENC_ALGORITHM, Buffer.from(encryptionKey, "base64"), encryptionIV);
+  decipher.setAuthTag(Buffer.from(authTag, "base64"));
+  const buff = Buffer.from(encryptedData, encryptedDataEncoding);
+  return Buffer.concat([decipher.update(buff), decipher.final()]).toString(decryptedDataEncoding); // Decrypts data and converts to utf8
+}
+
+export function generateDigitalSignature(data: string, dataEncoding: BufferEncoding, privateKey: string): string {
+  const sign = crypto.createSign("RSA-SHA256");
+  const buffer = Buffer.from(data, dataEncoding);
+  sign.update(buffer);
+  return sign.sign(privateKey, "base64");
+}
+
+export function validateDigitalSignature(
+  data: string,
+  dataEncoding: BufferEncoding,
+  signature: string,
+  signatureEncoding: BinaryToTextEncoding,
+  publicKey: string,
+): boolean {
+  const verify = crypto.createVerify("RSA-SHA256");
+  const buffer = Buffer.from(data, dataEncoding);
+  verify.update(buffer);
+  return verify.verify(publicKey, signature, signatureEncoding);
+}

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

@@ -1 +1 @@
-export default [];
+export default [];

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

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

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

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

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

@@ -1,15 +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;
+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;