namespace-guard 0.4.0 → 0.6.1

package/dist/cli.mjs

@@ -13,29 +13,51 @@ var DEFAULT_MESSAGES = {
 };
 function extractMaxLength(pattern) {
   const testStrings = ["a", "1", "a1", "a-1"];
-  for (let len = 100; len >= 1; len--) {
+  let lo = 1;
+  let hi = 100;
+  let best = 30;
+  while (lo <= hi) {
+    const mid = Math.floor((lo + hi) / 2);
+    let anyMatch = false;
     for (const chars of testStrings) {
-      const s = chars.repeat(Math.ceil(len / chars.length)).slice(0, len);
-      if (pattern.test(s)) return len;
+      const s = chars.repeat(Math.ceil(mid / chars.length)).slice(0, mid);
+      if (pattern.test(s)) {
+        anyMatch = true;
+        break;
+      }
+    }
+    if (anyMatch) {
+      best = mid;
+      lo = mid + 1;
+    } else {
+      hi = mid - 1;
     }
   }
-  return 30;
+  return best;
 }
 function createDefaultSuggest(pattern) {
   const maxLen = extractMaxLength(pattern);
   return (identifier) => {
+    const seen = /* @__PURE__ */ new Set();
     const candidates = [];
     for (let i = 1; i <= 9; i++) {
       const hyphenated = `${identifier}-${i}`;
-      if (hyphenated.length <= maxLen) candidates.push(hyphenated);
+      if (hyphenated.length <= maxLen) {
+        seen.add(hyphenated);
+        candidates.push(hyphenated);
+      }
       const compact = `${identifier}${i}`;
-      if (compact.length <= maxLen) candidates.push(compact);
+      if (compact.length <= maxLen) {
+        seen.add(compact);
+        candidates.push(compact);
+      }
     }
     if (identifier.length >= maxLen - 1) {
       for (let i = 1; i <= 9; i++) {
         const suffix = String(i);
         const truncated = identifier.slice(0, maxLen - suffix.length) + suffix;
-        if (truncated !== identifier && !candidates.includes(truncated)) {
+        if (truncated !== identifier && !seen.has(truncated)) {
+          seen.add(truncated);
           candidates.push(truncated);
         }
       }
@@ -43,6 +65,184 @@ function createDefaultSuggest(pattern) {
     return candidates;
   };
 }
+var SUFFIX_WORDS = ["dev", "io", "app", "hq", "pro", "team", "labs", "hub", "go", "one"];
+function createRandomDigitsStrategy(pattern) {
+  const maxLen = extractMaxLength(pattern);
+  return (identifier) => {
+    const seen = /* @__PURE__ */ new Set();
+    const candidates = [];
+    for (let i = 0; i < 15; i++) {
+      const digits = String(Math.floor(100 + Math.random() * 9900));
+      const candidate = `${identifier}-${digits}`;
+      if (candidate.length <= maxLen && !seen.has(candidate)) {
+        seen.add(candidate);
+        candidates.push(candidate);
+      }
+    }
+    return candidates;
+  };
+}
+function createSuffixWordsStrategy(pattern) {
+  const maxLen = extractMaxLength(pattern);
+  return (identifier) => {
+    const candidates = [];
+    for (const word of SUFFIX_WORDS) {
+      const candidate = `${identifier}-${word}`;
+      if (candidate.length <= maxLen) {
+        candidates.push(candidate);
+      }
+    }
+    return candidates;
+  };
+}
+function createShortRandomStrategy(pattern) {
+  const maxLen = extractMaxLength(pattern);
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  return (identifier) => {
+    const seen = /* @__PURE__ */ new Set();
+    const candidates = [];
+    for (let i = 0; i < 10; i++) {
+      let suffix = "";
+      for (let j = 0; j < 3; j++) {
+        suffix += chars[Math.floor(Math.random() * chars.length)];
+      }
+      const candidate = `${identifier}-${suffix}`;
+      if (candidate.length <= maxLen && !seen.has(candidate)) {
+        seen.add(candidate);
+        candidates.push(candidate);
+      }
+    }
+    return candidates;
+  };
+}
+function createScrambleStrategy(_pattern) {
+  return (identifier) => {
+    const seen = /* @__PURE__ */ new Set();
+    const candidates = [];
+    const chars = identifier.split("");
+    for (let i = 0; i < chars.length - 1; i++) {
+      if (chars[i] !== chars[i + 1]) {
+        const swapped = [...chars];
+        [swapped[i], swapped[i + 1]] = [swapped[i + 1], swapped[i]];
+        const candidate = swapped.join("");
+        if (candidate !== identifier && !seen.has(candidate)) {
+          seen.add(candidate);
+          candidates.push(candidate);
+        }
+      }
+    }
+    return candidates;
+  };
+}
+function createSimilarStrategy(pattern) {
+  const maxLen = extractMaxLength(pattern);
+  const nearby = {
+    a: "sqwz",
+    b: "vngh",
+    c: "xdfv",
+    d: "sfce",
+    e: "wrd",
+    f: "dgcv",
+    g: "fhtb",
+    h: "gjyn",
+    i: "uko",
+    j: "hknm",
+    k: "jli",
+    l: "kop",
+    m: "njk",
+    n: "bmhj",
+    o: "ipl",
+    p: "ol",
+    q: "wa",
+    r: "eft",
+    s: "adwz",
+    t: "rgy",
+    u: "yij",
+    v: "cfgb",
+    w: "qase",
+    x: "zsdc",
+    y: "tuh",
+    z: "xas",
+    "0": "19",
+    "1": "02",
+    "2": "13",
+    "3": "24",
+    "4": "35",
+    "5": "46",
+    "6": "57",
+    "7": "68",
+    "8": "79",
+    "9": "80"
+  };
+  const prefixes = ["the", "my", "x", "i"];
+  const suffixes = ["x", "o", "i", "z"];
+  return (identifier) => {
+    const seen = /* @__PURE__ */ new Set();
+    const candidates = [];
+    function add(c) {
+      if (c.length >= 2 && c.length <= maxLen && c !== identifier && pattern.test(c) && !seen.has(c)) {
+        seen.add(c);
+        candidates.push(c);
+      }
+    }
+    for (let i = 0; i < identifier.length; i++) {
+      add(identifier.slice(0, i) + identifier.slice(i + 1));
+    }
+    for (let i = 0; i < identifier.length; i++) {
+      const ch = identifier[i];
+      const neighbours = nearby[ch] ?? "";
+      for (const n of neighbours) {
+        add(identifier.slice(0, i) + n + identifier.slice(i + 1));
+      }
+    }
+    for (const p of prefixes) {
+      add(p + identifier);
+    }
+    for (const s of suffixes) {
+      add(identifier + s);
+    }
+    return candidates;
+  };
+}
+function createStrategy(name, pattern) {
+  switch (name) {
+    case "sequential":
+      return createDefaultSuggest(pattern);
+    case "random-digits":
+      return createRandomDigitsStrategy(pattern);
+    case "suffix-words":
+      return createSuffixWordsStrategy(pattern);
+    case "short-random":
+      return createShortRandomStrategy(pattern);
+    case "scramble":
+      return createScrambleStrategy(pattern);
+    case "similar":
+      return createSimilarStrategy(pattern);
+  }
+}
+function resolveGenerator(suggest, pattern) {
+  if (suggest?.generate) return suggest.generate;
+  const strategyInput = suggest?.strategy ?? ["sequential", "random-digits"];
+  if (typeof strategyInput === "function") return strategyInput;
+  const names = Array.isArray(strategyInput) ? strategyInput : [strategyInput];
+  const generators = names.map((name) => createStrategy(name, pattern));
+  if (generators.length === 1) return generators[0];
+  return (identifier) => {
+    const lists = generators.map((g) => g(identifier));
+    const seen = /* @__PURE__ */ new Set();
+    const result = [];
+    const maxListLen = Math.max(...lists.map((l) => l.length));
+    for (let i = 0; i < maxListLen; i++) {
+      for (const list of lists) {
+        if (i < list.length && !seen.has(list[i])) {
+          seen.add(list[i]);
+          result.push(list[i]);
+        }
+      }
+    }
+    return result;
+  };
+}
 function normalize(raw) {
   return raw.trim().toLowerCase().replace(/^@+/, "");
 }
@@ -81,6 +281,8 @@ function createNamespaceGuard(config, adapter) {
     const cached = cacheMap.get(key);
     if (cached && cached.expires > now) {
       cacheHits++;
+      cacheMap.delete(key);
+      cacheMap.set(key, cached);
       return cached.promise;
     }
     cacheMisses++;
@@ -108,6 +310,24 @@ function createNamespaceGuard(config, adapter) {
     }
     return null;
   }
+  async function checkDbOnly(value, scope) {
+    const findOptions = config.caseInsensitive ? { caseInsensitive: true } : void 0;
+    const checks = config.sources.map(async (source) => {
+      const existing = await cachedFindOne(source, value, findOptions);
+      if (!existing) return null;
+      if (source.scopeKey) {
+        const scopeValue = scope[source.scopeKey];
+        const idColumn = source.idColumn ?? "id";
+        const existingId = existing[idColumn];
+        if (scopeValue && existingId && scopeValue === String(existingId)) {
+          return null;
+        }
+      }
+      return source.name;
+    });
+    const results = await Promise.all(checks);
+    return !results.some((r) => r !== null);
+  }
   async function check(identifier, scope = {}, options) {
     const normalized = normalize(identifier);
     if (!pattern.test(normalized)) {
@@ -157,16 +377,45 @@ function createNamespaceGuard(config, adapter) {
         source: collision
       };
       if (config.suggest && !options?.skipSuggestions) {
-        const generate = config.suggest.generate ?? createDefaultSuggest(pattern);
+        const generate = resolveGenerator(config.suggest, pattern);
         const max = config.suggest.max ?? 3;
         const candidates = generate(normalized);
         const suggestions = [];
-        for (const candidate of candidates) {
-          if (suggestions.length >= max) break;
-          if (!pattern.test(candidate)) continue;
-          const candidateResult = await check(candidate, scope, { skipSuggestions: true });
-          if (candidateResult.available) {
-            suggestions.push(candidate);
+        const passedSync = candidates.filter(
+          (c) => pattern.test(c) && !reservedMap.has(c)
+        );
+        for (let i = 0; i < passedSync.length && suggestions.length < max; i += max) {
+          const batch = passedSync.slice(i, i + max);
+          let validated = batch;
+          if (validators.length > 0) {
+            const validationResults = await Promise.all(
+              batch.map(async (c) => {
+                for (const validator of validators) {
+                  try {
+                    const rejection = await validator(c);
+                    if (rejection) return null;
+                  } catch {
+                    return null;
+                  }
+                }
+                return c;
+              })
+            );
+            validated = validationResults.filter(
+              (c) => c !== null
+            );
+          }
+          if (validated.length > 0) {
+            const dbResults = await Promise.all(
+              validated.map(async (c) => ({
+                candidate: c,
+                available: await checkDbOnly(c, scope)
+              }))
+            );
+            for (const { candidate, available } of dbResults) {
+              if (suggestions.length >= max) break;
+              if (available) suggestions.push(candidate);
+            }
           }
         }
         if (suggestions.length > 0) {

package/dist/index.d.mts

@@ -9,6 +9,8 @@ type NamespaceSource = {
     /** Scope key for ownership checks — allows users to update their own slug without a false collision */
     scopeKey?: string;
 };
+/** Built-in suggestion strategy names. */
+type SuggestStrategyName = "sequential" | "random-digits" | "suffix-words" | "short-random" | "scramble" | "similar";
 /** Configuration for a namespace guard instance. */
 type NamespaceConfig = {
     /** Reserved names — flat list, Set, or categorized record */
@@ -32,10 +34,12 @@ type NamespaceConfig = {
     } | null>>;
     /** Enable conflict resolution suggestions when a slug is taken */
     suggest?: {
-        /** Generate candidate slugs (default: appends -1 through -9) */
-        generate?: (identifier: string) => string[];
+        /** Named strategy, array of strategies to compose, or custom generator function (default: `["sequential", "random-digits"]`) */
+        strategy?: SuggestStrategyName | SuggestStrategyName[] | ((identifier: string) => string[]);
         /** Max suggestions to return (default: 3) */
         max?: number;
+        /** @deprecated Use `strategy` instead. Custom generator function. */
+        generate?: (identifier: string) => string[];
     };
     /** Enable in-memory caching of adapter lookups */
     cache?: {
@@ -161,4 +165,4 @@ declare function createNamespaceGuard(config: NamespaceConfig, adapter: Namespac
 /** The guard instance returned by `createNamespaceGuard`. */
 type NamespaceGuard = ReturnType<typeof createNamespaceGuard>;
 
-export { type CheckResult, type FindOneOptions, type NamespaceAdapter, type NamespaceConfig, type NamespaceGuard, type NamespaceSource, type OwnershipScope, createNamespaceGuard, createProfanityValidator, normalize };
+export { type CheckResult, type FindOneOptions, type NamespaceAdapter, type NamespaceConfig, type NamespaceGuard, type NamespaceSource, type OwnershipScope, type SuggestStrategyName, createNamespaceGuard, createProfanityValidator, normalize };

package/dist/index.d.ts

@@ -9,6 +9,8 @@ type NamespaceSource = {
     /** Scope key for ownership checks — allows users to update their own slug without a false collision */
     scopeKey?: string;
 };
+/** Built-in suggestion strategy names. */
+type SuggestStrategyName = "sequential" | "random-digits" | "suffix-words" | "short-random" | "scramble" | "similar";
 /** Configuration for a namespace guard instance. */
 type NamespaceConfig = {
     /** Reserved names — flat list, Set, or categorized record */
@@ -32,10 +34,12 @@ type NamespaceConfig = {
     } | null>>;
     /** Enable conflict resolution suggestions when a slug is taken */
     suggest?: {
-        /** Generate candidate slugs (default: appends -1 through -9) */
-        generate?: (identifier: string) => string[];
+        /** Named strategy, array of strategies to compose, or custom generator function (default: `["sequential", "random-digits"]`) */
+        strategy?: SuggestStrategyName | SuggestStrategyName[] | ((identifier: string) => string[]);
         /** Max suggestions to return (default: 3) */
         max?: number;
+        /** @deprecated Use `strategy` instead. Custom generator function. */
+        generate?: (identifier: string) => string[];
     };
     /** Enable in-memory caching of adapter lookups */
     cache?: {
@@ -161,4 +165,4 @@ declare function createNamespaceGuard(config: NamespaceConfig, adapter: Namespac
 /** The guard instance returned by `createNamespaceGuard`. */
 type NamespaceGuard = ReturnType<typeof createNamespaceGuard>;
 
-export { type CheckResult, type FindOneOptions, type NamespaceAdapter, type NamespaceConfig, type NamespaceGuard, type NamespaceSource, type OwnershipScope, createNamespaceGuard, createProfanityValidator, normalize };
+export { type CheckResult, type FindOneOptions, type NamespaceAdapter, type NamespaceConfig, type NamespaceGuard, type NamespaceSource, type OwnershipScope, type SuggestStrategyName, createNamespaceGuard, createProfanityValidator, normalize };