chore: refactor flat loader (#471)

Author: mathio

packages/cli/src/cli/loaders/flat.spec.ts

@@ -17,7 +17,7 @@ describe("flat loader", () => {
         messages: { "1": "foo", "2": "bar" },
         years: ["January 13, 2025", "February 14, 2025"],
       });
-      await loader.pull("en", {}); // run again to ensure state is preserved
+      await loader.pull("es", {}); // run again to ensure state is preserved
       const output = await loader.push("en", {
         "messages/1": "foo",
         "messages/2": "bar",

packages/cli/src/cli/loaders/flat.ts

@@ -1,36 +1,55 @@
 import { flatten, unflatten } from "flat";
 import { ILoader } from "./_types";
-import { createLoader } from "./_utils";
+import { composeLoaders, createLoader } from "./_utils";
 import _ from "lodash";
 
 export const OBJECT_NUMERIC_KEY_PREFIX = "__lingodotdev__obj__";
 
-export default function createFlatLoader(): ILoader<Record<string, any>, Record<string, string>> {
-  let denormalizedKeysMap: Record<string, string> = {};
+export default function createFlatLoader() {
+  return composeLoaders(createDenormalizeLoader(), createNormalizeLoader());
+}
+
+type DenormalizeResult = {
+  denormalized: Record<string, string>;
+  keysMap: Record<string, string>;
+};
 
+function createDenormalizeLoader(): ILoader<Record<string, any>, DenormalizeResult> {
   return createLoader({
     pull: async (locale, input) => {
-      const denormalized = denormalizeObjectKeys(input || {});
-      const flattened: Record<string, string> = flatten(denormalized, {
+      const inputDenormalized = denormalizeObjectKeys(input || {});
+      const denormalized: Record<string, string> = flatten(inputDenormalized, {
         delimiter: "/",
         transformKey(key) {
           return encodeURIComponent(String(key));
         },
       });
-      denormalizedKeysMap = { ...denormalizedKeysMap, ...buildDenormalizedKeysMap(flattened) };
-      const normalized = normalizeObjectKeys(flattened);
+      const keysMap = buildDenormalizedKeysMap(denormalized);
+      return { denormalized, keysMap };
+    },
+    push: async (locale, { denormalized }) => {
+      const normalized = normalizeObjectKeys(denormalized);
       return normalized;
     },
-    push: async (locale, data) => {
-      const denormalized = mapDenormalizedKeys(data, denormalizedKeysMap);
-      const unflattened: Record<string, any> = unflatten(denormalized || {}, {
+  });
+}
+
+function createNormalizeLoader(): ILoader<DenormalizeResult, Record<string, string>> {
+  return createLoader({
+    pull: async (locale, input) => {
+      const normalized = normalizeObjectKeys(input.denormalized);
+      return normalized;
+    },
+    push: async (locale, data, originalInput) => {
+      const keysMap = originalInput?.keysMap ?? {};
+      const input = mapDenormalizedKeys(data, keysMap);
+      const denormalized: Record<string, any> = unflatten(input, {
         delimiter: "/",
         transformKey(key) {
           return decodeURIComponent(String(key));
         },
       });
-      const normalized = normalizeObjectKeys(unflattened);
-      return normalized;
+      return { denormalized, keysMap: keysMap || {} };
     },
   });
 }
@@ -53,7 +72,7 @@ export function buildDenormalizedKeysMap(obj: Record<string, string>) {
 export function mapDenormalizedKeys(obj: Record<string, any>, denormalizedKeysMap: Record<string, string>) {
   return Object.keys(obj).reduce(
     (acc, key) => {
-      const denormalizedKey = denormalizedKeysMap[key];
+      const denormalizedKey = denormalizedKeysMap[key] ?? key;
       acc[denormalizedKey] = obj[key];
       return acc;
     },