feat(cli): allow wildcards when matching lockedKeys, ignoredKeys, injectLocale (#1029)

* feat(cli): lockedKeys with wildcards

* feat(cli): injectLocale with wildcards

* feat(cli): ignoredKeys with wildcards

* fix(cli): ensure correct key order even with JSON arrays

Author: mathio

.changeset/chatty-cameras-occur.md

@@ -0,0 +1,5 @@
+---
+"lingo.dev": patch
+---
+
+allow wildcards when matching lockedKeys, ignoredKeys, injectLocale

packages/cli/src/cli/loaders/ensure-key-order.spec.ts

@@ -19,6 +19,41 @@ describe("ensure-key-order loader", () => {
     expect(result).toEqual({ a: 11, b: 22, c: 33 });
   });
 
+  it("should reorder keys in objects of nested arrays to match original input order on push", async () => {
+    const originalInput = [
+      { a: 1, b: 2, c: 3 },
+      { a: 4, b: 5, c: 6 },
+      {
+        values: [
+          { a: 7, b: 8, c: 9 },
+          { a: 10, b: 11, c: 12 },
+        ],
+      },
+    ];
+    await loader.pull("en", originalInput);
+    const data = [
+      { b: 22, a: 11, c: 33 },
+      { b: 55, c: 66, a: 44 },
+      {
+        values: [
+          { b: 88, c: 99, a: 77 },
+          { c: 122, b: 111, a: 100 },
+        ],
+      },
+    ];
+    const result = await loader.push("en", data);
+    expect(result).toEqual([
+      { a: 11, b: 22, c: 33 },
+      { a: 44, b: 55, c: 66 },
+      {
+        values: [
+          { a: 77, b: 88, c: 99 },
+          { a: 100, b: 111, c: 122 },
+        ],
+      },
+    ]);
+  });
+
   it("should reorder falsy keys to match original input order on push", async () => {
     const originalInput = {
       a: 1,

packages/cli/src/cli/loaders/ensure-key-order.ts

@@ -23,6 +23,10 @@ function reorderKeys(
   data: Record<string, any>,
   originalInput: Record<string, any>,
 ): Record<string, any> {
+  if (_.isArray(originalInput) && _.isArray(data)) {
+    // If both are arrays, recursively reorder keys in each element
+    return data.map((item, idx) => reorderKeys(item, originalInput[idx] ?? {}));
+  }
   if (!_.isObject(data) || _.isArray(data) || _.isDate(data)) {
     return data;
   }

packages/cli/src/cli/loaders/ignored-keys.spec.ts

@@ -6,7 +6,7 @@ const defaultLocale = "en";
 const targetLocale = "es";
 
 // Common ignored keys list used across tests
-const IGNORED_KEYS = ["meta", "todo"];
+const IGNORED_KEYS = ["meta", "todo", "pages/*/title"];
 
 /**
  * Creates a fresh loader instance with the default locale already set.
@@ -83,4 +83,100 @@ describe("ignored-keys loader", () => {
       todo: "todo es",
     });
   });
+
+  it("should omit keys matching wildcard patterns when pulling the default locale", async () => {
+    const loader = createLoader();
+    const input = {
+      greeting: "hello",
+      meta: "some meta information",
+      "pages/0/title": "Title 0",
+      "pages/0/content": "Content 0",
+      "pages/foo/title": "Foo Title",
+      "pages/foo/content": "Foo Content",
+      "pages/bar/notitle": "No Title",
+      "pages/bar/content": "No Content",
+    };
+    const result = await loader.pull(defaultLocale, input);
+    expect(result).toEqual({
+      greeting: "hello",
+      "pages/0/content": "Content 0",
+      "pages/foo/content": "Foo Content",
+      "pages/bar/notitle": "No Title",
+      "pages/bar/content": "No Content",
+    });
+  });
+
+  it("should omit keys matching wildcard patterns when pulling a target locale", async () => {
+    const loader = createLoader();
+    await loader.pull(defaultLocale, {
+      greeting: "hello",
+      meta: "meta en",
+      "pages/0/title": "Title 0",
+      "pages/0/content": "Content 0",
+      "pages/foo/title": "Foo Title",
+      "pages/foo/content": "Foo Content",
+      "pages/bar/notitle": "No Title",
+      "pages/bar/content": "No Content",
+    });
+    const targetInput = {
+      greeting: "hola",
+      meta: "meta es",
+      "pages/0/title": "Title 0",
+      "pages/0/content": "Contenido 0",
+      "pages/foo/title": "Foo Title",
+      "pages/foo/content": "Contenido Foo",
+      "pages/bar/notitle": "No Title",
+      "pages/bar/content": "No Content",
+    };
+    const result = await loader.pull(targetLocale, targetInput);
+    expect(result).toEqual({
+      greeting: "hola",
+      "pages/0/content": "Contenido 0",
+      "pages/foo/content": "Contenido Foo",
+      "pages/bar/notitle": "No Title",
+      "pages/bar/content": "No Content",
+    });
+  });
+
+  it("should merge wildcard-ignored keys back when pushing a target locale", async () => {
+    const loader = createLoader();
+    await loader.pull(defaultLocale, {
+      greeting: "hello",
+      meta: "meta en",
+      "pages/0/title": "Title 0",
+      "pages/0/content": "Content 0",
+      "pages/foo/title": "Foo Title",
+      "pages/foo/content": "Foo Content",
+      "pages/bar/notitle": "No Title",
+      "pages/bar/content": "No Content",
+    });
+    await loader.pull(targetLocale, {
+      greeting: "hola",
+      meta: "meta es",
+      "pages/0/title": "Título 0",
+      "pages/0/content": "Contenido 0",
+      "pages/foo/title": "Título Foo",
+      "pages/foo/content": "Contenido Foo",
+      "pages/bar/notitle": "No Título",
+      "pages/bar/content": "Contenido Bar",
+    });
+    const dataToPush = {
+      greeting: "hola",
+      "pages/0/content": "Contenido Nuveo",
+      "pages/foo/content": "Contenido Nuevo Foo",
+      "pages/bar/notitle": "No Título",
+      "pages/bar/content": "Contenido Nuevo Bar",
+    };
+    const pushResult = await loader.push(targetLocale, dataToPush);
+    expect(pushResult).toEqual({
+      greeting: "hola",
+      meta: "meta es",
+      "pages/0/title": "Título 0",
+      "pages/0/content": "Contenido Nuveo",
+      "pages/foo/title": "Título Foo",
+      "pages/foo/content": "Contenido Nuevo Foo",
+      "pages/bar/notitle": "No Título",
+      "pages/bar/content": "Contenido Nuevo Bar",
+    });
+  });
 });

packages/cli/src/cli/loaders/ignored-keys.ts

@@ -1,18 +1,30 @@
 import { ILoader } from "./_types";
 import { createLoader } from "./_utils";
 import _ from "lodash";
+import { minimatch } from "minimatch";
 
 export default function createIgnoredKeysLoader(
   ignoredKeys: string[],
 ): ILoader<Record<string, any>, Record<string, any>> {
   return createLoader({
     pull: async (locale, data) => {
-      const result = _.chain(data).omit(ignoredKeys).value();
+      const result = _.omitBy(data, (value, key) =>
+        _isIgnoredKey(key, ignoredKeys),
+      );
       return result;
     },
     push: async (locale, data, originalInput, originalLocale, pullInput) => {
-      const result = _.merge({}, data, _.pick(pullInput, ignoredKeys));
+      const ignoredSubObject = _.pickBy(pullInput, (value, key) =>
+        _isIgnoredKey(key, ignoredKeys),
+      );
+      const result = _.merge({}, data, ignoredSubObject);
       return result;
     },
   });
 }
+
+function _isIgnoredKey(key: string, ignoredKeys: string[]) {
+  return ignoredKeys.some(
+    (ignoredKey) => key.startsWith(ignoredKey) || minimatch(key, ignoredKey),
+  );
+}

packages/cli/src/cli/loaders/inject-locale.spec.ts

@@ -46,6 +46,35 @@ describe("createInjectLocaleLoader", () => {
       const result = await loader.pull(locale, data);
       expect(result).toEqual({});
     });
+
+    it("should omit keys matching wildcard pattern where value matches locale", async () => {
+      const loader = createInjectLocaleLoader([
+        "pages.*.locale",
+        "meta/*/lang",
+      ]);
+      loader.setDefaultLocale(locale);
+      const data = {
+        pages: {
+          foo: { locale: "en", value: 1 },
+          bar: { locale: "en", value: 2 },
+          baz: { locale: "fr", value: 3 },
+        },
+        other: 42,
+        "meta/a/lang": "en",
+        "meta/b/lang": "fr",
+        "meta/c/lang": "en",
+      };
+      const result = await loader.pull(locale, data);
+      expect(result).toEqual({
+        pages: {
+          foo: { value: 1 },
+          bar: { value: 2 },
+          baz: { locale: "fr", value: 3 },
+        },
+        other: 42,
+        "meta/b/lang": "fr",
+      });
+    });
   });
 
   describe("push", () => {
@@ -137,5 +166,43 @@ describe("createInjectLocaleLoader", () => {
       await loader.pull(originalLocale, originalInput);
       const data = { value: 2, meta: { other: 2 } };
     });
+
+    it("should set wildcard-matched keys to new locale if they matched originalLocale", async () => {
+      const loader = createInjectLocaleLoader([
+        "pages.*.locale",
+        "meta/*/lang",
+      ]);
+      loader.setDefaultLocale(originalLocale);
+      const originalInput = {
+        pages: {
+          foo: { locale: "en", value: 1 },
+          bar: { locale: "en", value: 2 },
+          baz: { locale: "fr", value: 3 },
+        },
+        "meta/a/lang": "en",
+        "meta/b/lang": "fr",
+        "meta/c/lang": "en",
+      };
+      await loader.pull(originalLocale, originalInput);
+      const data = {
+        pages: {
+          foo: { value: 10 },
+          bar: { value: 20 },
+          baz: { locale: "fr", value: 30 },
+        },
+        "meta/b/lang": "fr",
+      };
+      const result = await loader.push("de", data);
+      expect(result).toEqual({
+        pages: {
+          foo: { locale: "de", value: 10 },
+          bar: { locale: "de", value: 20 },
+          baz: { locale: "fr", value: 30 },
+        },
+        "meta/a/lang": "de",
+        "meta/b/lang": "fr",
+        "meta/c/lang": "de",
+      });
+    });
   });
 });

packages/cli/src/cli/loaders/inject-locale.ts

@@ -1,6 +1,7 @@
 import _ from "lodash";
 import { ILoader } from "./_types";
 import { createLoader } from "./_utils";
+import { minimatch } from "minimatch";
 
 export default function createInjectLocaleLoader(
   injectLocaleKeys?: string[],
@@ -39,7 +40,30 @@ function _getKeysWithLocales(
   injectLocaleKeys: string[],
   locale: string,
 ) {
-  return injectLocaleKeys.filter((key) => {
-    return _.get(data, key) === locale;
+  const allKeys = _getAllKeys(data);
+  return allKeys.filter((key) => {
+    return (
+      injectLocaleKeys.some((pattern) => minimatch(key, pattern)) &&
+      _.get(data, key) === locale
+    );
   });
 }
+
+// Helper to get all deep keys in lodash path style (e.g., 'a.b.c')
+function _getAllKeys(obj: Record<string, any>, prefix = ""): string[] {
+  let keys: string[] = [];
+  for (const key in obj) {
+    if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
+    const path = prefix ? `${prefix}.${key}` : key;
+    if (
+      typeof obj[key] === "object" &&
+      obj[key] !== null &&
+      !Array.isArray(obj[key])
+    ) {
+      keys = keys.concat(_getAllKeys(obj[key], path));
+    } else {
+      keys.push(path);
+    }
+  }
+  return keys;
+}