@ruiapp/rapid-configure-tools 0.3.0 → 0.4.1

package/dist/meta-file-generator/generators/model-locales-generator.d.ts

@@ -0,0 +1 @@
+export declare function generateSdRpdModelLocales(declarationsDirectory: string): void;

package/dist/mod.js

@@ -374,6 +374,136 @@ function generateSdRpdModelTypes(declarationsDirectory) {
     generateEntityTypes(metaDir);
 }
 
+function generateDictionaryLocales(metaDir) {
+    const dictionaries = require(path__default["default"].join(metaDir, "data-dictionary-models")).default;
+    const codes = [];
+    const linguals = new Set();
+    for (const dictionary of dictionaries) {
+        if (dictionary.locales) {
+            for (const locale of Object.keys(dictionary.locales)) {
+                linguals.add(locale);
+            }
+        }
+        for (const entry of dictionary.entries) {
+            if (entry.locales) {
+                for (const locale of Object.keys(entry.locales)) {
+                    linguals.add(locale);
+                }
+            }
+        }
+    }
+    codes.push(`const dictionaryLocales: Record<string, {translation: Record<string, any>}> = {`);
+    for (const lingual of linguals) {
+        codes.push(`  "${lingual}": {`);
+        codes.push(`    translation: {`);
+        codes.push(`      dictionaries: {`);
+        for (const dictionary of dictionaries) {
+            const dictionaryLocale = dictionary.locales?.[lingual];
+            codes.push(`        "${dictionary.code}": {`);
+            if (dictionaryLocale) {
+                codes.push(`          name: "${dictionaryLocale.name}",`);
+                codes.push(`          description: "${dictionaryLocale.description}",`);
+            }
+            codes.push(`        entries: {`);
+            for (const entry of dictionary.entries) {
+                let entryLocaleName;
+                let entryLocaleDescription;
+                const entryLocale = entry.locales?.[lingual];
+                if (entryLocale) {
+                    entryLocaleName = entryLocale.name || dictionaryLocale?.entries?.[entry.value]?.name;
+                    entryLocaleDescription = entryLocale.description || dictionaryLocale?.entries?.[entry.value]?.description;
+                }
+                if (entryLocaleName || entryLocaleDescription) {
+                    codes.push(`          "${entry.value}": {`);
+                    if (entryLocaleName) {
+                        codes.push(`            name: "${entryLocaleName}",`);
+                    }
+                    if (entryLocaleDescription) {
+                        codes.push(`            description: "${entryLocaleDescription}",`);
+                    }
+                    codes.push(`          },`);
+                }
+            }
+            codes.push(`        },`);
+            codes.push(`      },`);
+        }
+        codes.push(`      },`);
+        codes.push(`    },`);
+        codes.push(`  },`);
+    }
+    codes.push(`};`);
+    codes.push(`export default dictionaryLocales;`);
+    const fileName = path__default["default"].join(metaDir, "data-dictionary-locales.ts");
+    fs__default["default"].writeFileSync(fileName, codes.join("\n"));
+}
+function generateEntityLocales(metaDir) {
+    const entities = require(path__default["default"].join(metaDir, "entity-models")).default;
+    const codes = [];
+    const linguals = new Set();
+    for (const entity of entities) {
+        if (entity.locales) {
+            for (const locale of Object.keys(entity.locales)) {
+                linguals.add(locale);
+            }
+        }
+        for (const field of entity.fields) {
+            if (field.locales) {
+                for (const locale of Object.keys(field.locales)) {
+                    linguals.add(locale);
+                }
+            }
+        }
+    }
+    codes.push(`const entityLocales: Record<string, {translation: Record<string, any>}> = {`);
+    for (const lingual of linguals) {
+        codes.push(`  "${lingual}": {`);
+        codes.push(`    translation: {`);
+        codes.push(`      entities: {`);
+        for (const entity of entities) {
+            const entityLocale = entity.locales?.[lingual];
+            codes.push(`      "${entity.code}": {`);
+            if (entityLocale) {
+                codes.push(`        name: "${entityLocale.name}",`);
+                codes.push(`        description: "${entityLocale.description}",`);
+            }
+            codes.push(`        fields: {`);
+            for (const field of entity.fields) {
+                let fieldLocaleName;
+                let fieldLocaleDescription;
+                const fieldLocale = field.locales?.[lingual];
+                if (fieldLocale) {
+                    fieldLocaleName = fieldLocale.name || entityLocale?.fields?.[field.code]?.name;
+                    fieldLocaleDescription = fieldLocale.description || entityLocale?.fields?.[field.code]?.description;
+                }
+                if (fieldLocaleName || fieldLocaleDescription) {
+                    codes.push(`          "${field.code}": {`);
+                    if (fieldLocaleName) {
+                        codes.push(`            name: "${fieldLocaleName}",`);
+                    }
+                    if (fieldLocaleDescription) {
+                        codes.push(`            description: "${fieldLocaleDescription}",`);
+                    }
+                    codes.push(`          },`);
+                }
+            }
+            codes.push(`        },`);
+            codes.push(`      },`);
+        }
+        codes.push(`      },`);
+        codes.push(`    },`);
+        codes.push(`  },`);
+    }
+    codes.push(`};`);
+    codes.push(`export default entityLocales;`);
+    const fileName = path__default["default"].join(metaDir, "entity-locales.ts");
+    fs__default["default"].writeFileSync(fileName, codes.join("\n"));
+}
+function generateSdRpdModelLocales(declarationsDirectory) {
+    const metaDir = path__default["default"].join(declarationsDirectory, "meta");
+    generateDictionaryLocales(metaDir);
+    generateEntityLocales(metaDir);
+}
+
 class MetaFileGenerator {
     generateFiles(option) {
         let { declarationsDirectory } = option;
@@ -389,6 +519,8 @@ class MetaFileGenerator {
         generateModelCodes(declarationsDirectory);
         console.log("generateSdRpdModelTypes");
         generateSdRpdModelTypes(declarationsDirectory);
+        console.log("generateSdRpdModelLocales");
+        generateSdRpdModelLocales(declarationsDirectory);
         console.log("Done.");
     }
 }
@@ -509,20 +641,20 @@ function newDictionaryUpdater(rapidConfigApi) {
             return entity.code === input.code;
         },
         isEntityChanged(inputEntity, remoteEntity) {
-            const changedFieldNames = detectChangedFields(inputEntity, remoteEntity, ["name", "valueType", "description"]);
+            const changedFieldNames = detectChangedFields(inputEntity, remoteEntity, ["name", "valueType", "description", "locales"]);
             if (changedFieldNames.length) {
                 console.log(`${this.modelType} ${this.inputTitlePrinter(inputEntity)} changed with these fields:`, changedFieldNames);
             }
             return changedFieldNames.length > 0;
         },
         async createEntity(input) {
-            const createEntityInput = lodash.pick(input, ["code", "name", "valueType", "level", "description"]);
+            const createEntityInput = lodash.pick(input, ["code", "name", "valueType", "level", "description", "locales"]);
             const res = await rapidConfigApi.post(`meta/data_dictionaries`, createEntityInput);
             return res.data;
         },
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         async updateEntity(input, remoteEntity, mainEntity, inputIndex) {
-            const updateEntityInput = lodash.pick(input, ["code", "name", "valueType", "level", "description"]);
+            const updateEntityInput = lodash.pick(input, ["code", "name", "valueType", "level", "description", "locales"]);
             const res = await rapidConfigApi.patch(`meta/data_dictionaries/${remoteEntity.id}`, updateEntityInput);
             return res.data;
         },
@@ -559,7 +691,7 @@ function newDictionaryEntryUpdater(rapidConfigApi) {
             return entity.name === input.name;
         },
         isEntityChanged(inputEntity, remoteEntity) {
-            const changedFieldNames = detectChangedFields(inputEntity, remoteEntity, ["value", "description"]);
+            const changedFieldNames = detectChangedFields(inputEntity, remoteEntity, ["value", "description", "locales"]);
             if (changedFieldNames.length) {
                 console.log(`${this.modelType} ${this.inputTitlePrinter(inputEntity)} changed with these fields:`, changedFieldNames);
             }
@@ -633,6 +765,7 @@ function newModelUpdater(rapidConfigApi) {
                 "indexes",
                 "permissionPolicies",
                 "softDelete",
+                "locales",
             ]);
             if (changedFieldNames.length) {
                 console.log(`${this.modelType} ${this.inputTitlePrinter(inputEntity)} changed with these fields:`, changedFieldNames);
@@ -718,6 +851,7 @@ function newPropertyUpdater(rapidConfigApi) {
                 "linkDbSchema",
                 "entityDeletingReaction",
                 "readonly",
+                "locales",
             ]);
             if (changedFieldNames.length) {
                 console.log(`${this.modelType} ${this.inputTitlePrinter(inputEntity)} changed with these fields:`, changedFieldNames);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruiapp/rapid-configure-tools",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "",
   "main": "dist/mod.js",
   "keywords": [],
@@ -20,7 +20,7 @@
     "axios-cookiejar-support": "^4.0.7",
     "lodash": "^4.17.21",
     "tough-cookie": "^4.1.3",
-    "@ruiapp/rapid-extension": "^0.3.32"
+    "@ruiapp/rapid-extension": "^0.4.2"
   },
   "dependencies": {},
   "scripts": {

package/src/meta-file-generator/generators/model-locales-generator.ts

@@ -0,0 +1,154 @@
+import fs from "fs";
+import path from "path";
+import type { RapidDataDictionary, RapidEntity, RapidField } from "@ruiapp/rapid-extension";
+
+function generateDictionaryLocales(metaDir: string) {
+  const dictionaries: RapidDataDictionary[] = require(path.join(metaDir, "data-dictionary-models")).default;
+
+  const codes: string[] = [];
+
+  const linguals: Set<string> = new Set();
+  for (const dictionary of dictionaries) {
+    if (dictionary.locales) {
+      for (const locale of Object.keys(dictionary.locales)) {
+        linguals.add(locale);
+      }
+    }
+    for (const entry of dictionary.entries) {
+      if (entry.locales) {
+        for (const locale of Object.keys(entry.locales)) {
+          linguals.add(locale);
+        }
+      }
+    }
+  }
+
+  codes.push(`const dictionaryLocales: Record<string, {translation: Record<string, any>}> = {`);
+  for (const lingual of linguals) {
+    codes.push(`  "${lingual}": {`);
+    codes.push(`    translation: {`);
+    codes.push(`      dictionaries: {`);
+
+    for (const dictionary of dictionaries) {
+      const dictionaryLocale = dictionary.locales?.[lingual];
+      codes.push(`        "${dictionary.code}": {`);
+      if (dictionaryLocale) {
+        codes.push(`          name: "${dictionaryLocale.name}",`);
+        codes.push(`          description: "${dictionaryLocale.description}",`);
+      }
+
+      codes.push(`        entries: {`);
+      for (const entry of dictionary.entries) {
+        let entryLocaleName;
+        let entryLocaleDescription;
+        const entryLocale = entry.locales?.[lingual];
+        if (entryLocale) {
+          entryLocaleName = entryLocale.name || dictionaryLocale?.entries?.[entry.value]?.name;
+          entryLocaleDescription = entryLocale.description || dictionaryLocale?.entries?.[entry.value]?.description;
+        }
+
+        if (entryLocaleName || entryLocaleDescription) {
+          codes.push(`          "${entry.value}": {`);
+          if (entryLocaleName) {
+            codes.push(`            name: "${entryLocaleName}",`);
+          }
+          if (entryLocaleDescription) {
+            codes.push(`            description: "${entryLocaleDescription}",`);
+          }
+          codes.push(`          },`);
+        }
+      }
+      codes.push(`        },`);
+      codes.push(`      },`);
+    }
+
+    codes.push(`      },`);
+    codes.push(`    },`);
+    codes.push(`  },`);
+  }
+  codes.push(`};`);
+
+  codes.push(`export default dictionaryLocales;`);
+
+  const fileName = path.join(metaDir, "data-dictionary-locales.ts");
+  fs.writeFileSync(fileName, codes.join("\n"));
+}
+
+function generateEntityLocales(metaDir: string) {
+  const entities: RapidEntity[] = require(path.join(metaDir, "entity-models")).default;
+
+  const codes: string[] = [];
+
+  const linguals: Set<string> = new Set();
+  for (const entity of entities) {
+    if (entity.locales) {
+      for (const locale of Object.keys(entity.locales)) {
+        linguals.add(locale);
+      }
+    }
+    for (const field of entity.fields) {
+      if (field.locales) {
+        for (const locale of Object.keys(field.locales)) {
+          linguals.add(locale);
+        }
+      }
+    }
+  }
+
+  codes.push(`const entityLocales: Record<string, {translation: Record<string, any>}> = {`);
+  for (const lingual of linguals) {
+    codes.push(`  "${lingual}": {`);
+    codes.push(`    translation: {`);
+    codes.push(`      entities: {`);
+
+    for (const entity of entities) {
+      const entityLocale = entity.locales?.[lingual];
+      codes.push(`      "${entity.code}": {`);
+      if (entityLocale) {
+        codes.push(`        name: "${entityLocale.name}",`);
+        codes.push(`        description: "${entityLocale.description}",`);
+      }
+
+      codes.push(`        fields: {`);
+      for (const field of entity.fields) {
+        let fieldLocaleName;
+        let fieldLocaleDescription;
+        const fieldLocale = field.locales?.[lingual];
+        if (fieldLocale) {
+          fieldLocaleName = fieldLocale.name || entityLocale?.fields?.[field.code]?.name;
+          fieldLocaleDescription = fieldLocale.description || entityLocale?.fields?.[field.code]?.description;
+        }
+
+        if (fieldLocaleName || fieldLocaleDescription) {
+          codes.push(`          "${field.code}": {`);
+          if (fieldLocaleName) {
+            codes.push(`            name: "${fieldLocaleName}",`);
+          }
+          if (fieldLocaleDescription) {
+            codes.push(`            description: "${fieldLocaleDescription}",`);
+          }
+          codes.push(`          },`);
+        }
+      }
+      codes.push(`        },`);
+      codes.push(`      },`);
+    }
+
+    codes.push(`      },`);
+    codes.push(`    },`);
+    codes.push(`  },`);
+  }
+  codes.push(`};`);
+
+  codes.push(`export default entityLocales;`);
+
+  const fileName = path.join(metaDir, "entity-locales.ts");
+  fs.writeFileSync(fileName, codes.join("\n"));
+}
+
+export function generateSdRpdModelLocales(declarationsDirectory: string) {
+  const metaDir = path.join(declarationsDirectory, "meta");
+
+  generateDictionaryLocales(metaDir);
+  generateEntityLocales(metaDir);
+}

package/src/meta-file-generator/mod.ts

@@ -2,6 +2,7 @@ import path from "path";
 import { generateModelIndexFiles } from "./generators/model-index-generator";
 import { generateModelCodes, generateDictionaryCodes } from "./generators/model-codes-generator";
 import { generateSdRpdModelTypes } from "./generators/model-types-generator";
+import { generateSdRpdModelLocales } from "./generators/model-locales-generator";
 
 export interface FileGenerateOption {
   declarationsDirectory: string;
@@ -24,6 +25,8 @@ export default class MetaFileGenerator {
     generateModelCodes(declarationsDirectory);
     console.log("generateSdRpdModelTypes");
     generateSdRpdModelTypes(declarationsDirectory);
+    console.log("generateSdRpdModelLocales");
+    generateSdRpdModelLocales(declarationsDirectory);
     console.log("Done.");
   }
 }

package/src/rapid-models-updater/DictionaryEntryUpdater.ts

@@ -42,7 +42,7 @@ export function newDictionaryEntryUpdater(rapidConfigApi: AxiosInstance) {
     },
 
     isEntityChanged(inputEntity, remoteEntity) {
-      const changedFieldNames = detectChangedFields(inputEntity, remoteEntity, ["value", "description"]);
+      const changedFieldNames = detectChangedFields(inputEntity, remoteEntity, ["value", "description", "locales"]);
       if (changedFieldNames.length) {
         console.log(`${this.modelType} ${this.inputTitlePrinter(inputEntity)} changed with these fields:`, changedFieldNames);
       }

package/src/rapid-models-updater/DictionaryUpdater.ts

@@ -30,7 +30,7 @@ export function newDictionaryUpdater(rapidConfigApi: AxiosInstance) {
     },
 
     isEntityChanged(inputEntity, remoteEntity) {
-      const changedFieldNames = detectChangedFields(inputEntity, remoteEntity, ["name", "valueType", "description"]);
+      const changedFieldNames = detectChangedFields(inputEntity, remoteEntity, ["name", "valueType", "description", "locales"]);
       if (changedFieldNames.length) {
         console.log(`${this.modelType} ${this.inputTitlePrinter(inputEntity)} changed with these fields:`, changedFieldNames);
       }
@@ -38,14 +38,14 @@ export function newDictionaryUpdater(rapidConfigApi: AxiosInstance) {
     },
 
     async createEntity(input) {
-      const createEntityInput: CreateDataDictionaryInput = pick(input, ["code", "name", "valueType", "level", "description"]);
+      const createEntityInput: CreateDataDictionaryInput = pick(input, ["code", "name", "valueType", "level", "description", "locales"]);
       const res = await rapidConfigApi.post(`meta/data_dictionaries`, createEntityInput);
       return res.data;
     },
 
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     async updateEntity(input, remoteEntity, mainEntity, inputIndex) {
-      const updateEntityInput: UpdateDataDictionaryInput = pick(input, ["code", "name", "valueType", "level", "description"]);
+      const updateEntityInput: UpdateDataDictionaryInput = pick(input, ["code", "name", "valueType", "level", "description", "locales"]);
       const res = await rapidConfigApi.patch(`meta/data_dictionaries/${remoteEntity.id}`, updateEntityInput);
       return res.data;
     },

package/src/rapid-models-updater/ModelUpdater.ts

@@ -45,6 +45,7 @@ export function newModelUpdater(rapidConfigApi: AxiosInstance) {
         "indexes",
         "permissionPolicies",
         "softDelete",
+        "locales",
       ]);
       if (changedFieldNames.length) {
         console.log(`${this.modelType} ${this.inputTitlePrinter(inputEntity)} changed with these fields:`, changedFieldNames);

package/src/rapid-models-updater/PropertyUpdater.ts

@@ -55,6 +55,7 @@ export function newPropertyUpdater(rapidConfigApi: AxiosInstance) {
         "linkDbSchema",
         "entityDeletingReaction",
         "readonly",
+        "locales",
       ]);
       if (changedFieldNames.length) {
         console.log(`${this.modelType} ${this.inputTitlePrinter(inputEntity)} changed with these fields:`, changedFieldNames);