@open-mercato/shared 0.6.7-develop.6834.1.e76f4b8cbc → 0.6.7-develop.6842.1.8cd8a8883c

package/dist/lib/i18n/config.js

@@ -1,4 +1,4 @@
-const locales = ["en", "pl", "es", "de"];
+const locales = ["en", "pl", "es", "de", "ko"];
 const defaultLocale = "en";
 export {
   defaultLocale,

package/dist/lib/i18n/config.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/lib/i18n/config.ts"],
-  "sourcesContent": ["export type Locale = 'en' | 'pl' | 'es' | 'de'\n\nexport const locales: Locale[] = ['en', 'pl', 'es', 'de']\nexport const defaultLocale: Locale = 'en'\n"],
-  "mappings": "AAEO,MAAM,UAAoB,CAAC,MAAM,MAAM,MAAM,IAAI;AACjD,MAAM,gBAAwB;",
+  "sourcesContent": ["export type Locale = 'en' | 'pl' | 'es' | 'de' | 'ko'\n\nexport const locales: Locale[] = ['en', 'pl', 'es', 'de', 'ko']\nexport const defaultLocale: Locale = 'en'\n"],
+  "mappings": "AAEO,MAAM,UAAoB,CAAC,MAAM,MAAM,MAAM,MAAM,IAAI;AACvD,MAAM,gBAAwB;",
   "names": []
 }

package/dist/lib/redis/connection.js

@@ -21,12 +21,17 @@ function parseRedisUrl(url) {
     const dbStr = parsed.pathname ? parsed.pathname.slice(1) : "";
     const dbParsed = dbStr !== "" ? parseInt(dbStr, 10) : NaN;
     const db = Number.isNaN(dbParsed) ? void 0 : dbParsed;
+    const familyValue = parsed.searchParams.get("family");
+    const familyParsed = familyValue !== null ? parseInt(familyValue, 10) : NaN;
+    const family = [0, 4, 6].includes(familyParsed) ? familyParsed : void 0;
     return {
       host: parsed.hostname || "localhost",
       port: parseInt(parsed.port, 10) || 6379,
-      password: parsed.password || void 0,
+      username: parsed.username ? decodeURIComponent(parsed.username) : void 0,
+      password: parsed.password ? decodeURIComponent(parsed.password) : void 0,
       db,
-      tls: parsed.protocol === "rediss:" ? {} : void 0
+      tls: parsed.protocol === "rediss:" ? {} : void 0,
+      family
     };
   } catch {
     const safeUrl = url.replace(/\/\/[^:]*:[^@]*@/, "//<redacted>@");

package/dist/lib/redis/connection.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/lib/redis/connection.ts"],
-  "sourcesContent": ["import { createLogger } from '../logger'\n\nconst logger = createLogger('shared').child({ component: 'redis' })\n\n/**\n * Shared Redis connection utilities.\n *\n * Every package that needs a Redis URL or parsed connection options\n * should import from here instead of reading env vars directly.\n *\n * The `prefix` parameter lets each subsystem define its own override:\n *   getRedisUrl('QUEUE')  \u2192 QUEUE_REDIS_URL  > REDIS_URL > null\n *   getRedisUrl('CACHE')  \u2192 CACHE_REDIS_URL  > REDIS_URL > null\n *   getRedisUrl()         \u2192 REDIS_URL > null\n *\n * Returns null when Redis is not configured so callers can explicitly\n * decide whether to fall back to a non-Redis strategy or fail loudly.\n * Use getRedisUrlOrThrow() when Redis is mandatory for the caller.\n */\n\nexport type ParsedRedisConnection = {\n  host: string\n  port: number\n  password?: string\n  db?: number\n  tls?: Record<string, unknown>\n}\n\n/**\n * Resolve a Redis URL from environment variables.\n *\n * Priority: <PREFIX>_REDIS_URL  \u2192  REDIS_URL  \u2192  null\n *\n * Returns null when no env var is set. Callers MUST NOT assume a\n * localhost default \u2014 silently connecting to localhost masks missing\n * configuration and stalls on platforms where nothing listens there\n * (e.g., WSL2 without a local Redis).\n */\nexport function getRedisUrl(prefix?: string): string | null {\n  if (prefix) {\n    const prefixed = process.env[`${prefix}_REDIS_URL`]\n    if (prefixed) return prefixed\n  }\n  return process.env.REDIS_URL || null\n}\n\n/**\n * Like getRedisUrl, but throws a descriptive error when Redis is not\n * configured. Use from code paths that require Redis (e.g. BullMQ\n * async queue, Redis cache strategy, scheduler service).\n */\nexport function getRedisUrlOrThrow(prefix?: string): string {\n  const url = getRedisUrl(prefix)\n  if (url) return url\n  const which = prefix ? `${prefix}_REDIS_URL or REDIS_URL` : 'REDIS_URL'\n  throw new Error(\n    `Redis URL is not configured. Set ${which} in your environment to use a Redis-backed strategy.`\n  )\n}\n\n/**\n * Parse a redis:// URL into a {host, port, password, db} object\n * suitable for BullMQ / ioredis structured connection options.\n *\n * @deprecated Prefer passing the full URL via `{ url: getRedisUrl(...) }` to\n * BullMQ/ioredis \u2014 this preserves rediss://, username, database, and query\n * params that structured parsing may lose. Kept for backward compatibility.\n */\nexport function parseRedisUrl(url: string): ParsedRedisConnection {\n  try {\n    const parsed = new URL(url)\n    const dbStr = parsed.pathname ? parsed.pathname.slice(1) : ''\n    const dbParsed = dbStr !== '' ? parseInt(dbStr, 10) : NaN\n    const db = Number.isNaN(dbParsed) ? undefined : dbParsed\n    return {\n      host: parsed.hostname || 'localhost',\n      port: parseInt(parsed.port, 10) || 6379,\n      password: parsed.password || undefined,\n      db,\n      tls: parsed.protocol === 'rediss:' ? {} : undefined,\n    }\n  } catch {\n    const safeUrl = url.replace(/\\/\\/[^:]*:[^@]*@/, '//<redacted>@')\n    logger.warn('Failed to parse Redis URL, falling back to localhost:6379', { url: safeUrl })\n    return { host: 'localhost', port: 6379 }\n  }\n}\n\n/**\n * Convenience: resolve the URL from env and parse it in one step.\n * Returns null when Redis is not configured.\n */\nexport function resolveRedisConnection(\n  prefix?: string,\n): (ParsedRedisConnection & { url: string }) | null {\n  const url = getRedisUrl(prefix)\n  if (!url) return null\n  return { url, ...parseRedisUrl(url) }\n}\n"],
-  "mappings": "AAAA,SAAS,oBAAoB;AAE7B,MAAM,SAAS,aAAa,QAAQ,EAAE,MAAM,EAAE,WAAW,QAAQ,CAAC;AAoC3D,SAAS,YAAY,QAAgC;AAC1D,MAAI,QAAQ;AACV,UAAM,WAAW,QAAQ,IAAI,GAAG,MAAM,YAAY;AAClD,QAAI,SAAU,QAAO;AAAA,EACvB;AACA,SAAO,QAAQ,IAAI,aAAa;AAClC;AAOO,SAAS,mBAAmB,QAAyB;AAC1D,QAAM,MAAM,YAAY,MAAM;AAC9B,MAAI,IAAK,QAAO;AAChB,QAAM,QAAQ,SAAS,GAAG,MAAM,4BAA4B;AAC5D,QAAM,IAAI;AAAA,IACR,oCAAoC,KAAK;AAAA,EAC3C;AACF;AAUO,SAAS,cAAc,KAAoC;AAChE,MAAI;AACF,UAAM,SAAS,IAAI,IAAI,GAAG;AAC1B,UAAM,QAAQ,OAAO,WAAW,OAAO,SAAS,MAAM,CAAC,IAAI;AAC3D,UAAM,WAAW,UAAU,KAAK,SAAS,OAAO,EAAE,IAAI;AACtD,UAAM,KAAK,OAAO,MAAM,QAAQ,IAAI,SAAY;AAChD,WAAO;AAAA,MACL,MAAM,OAAO,YAAY;AAAA,MACzB,MAAM,SAAS,OAAO,MAAM,EAAE,KAAK;AAAA,MACnC,UAAU,OAAO,YAAY;AAAA,MAC7B;AAAA,MACA,KAAK,OAAO,aAAa,YAAY,CAAC,IAAI;AAAA,IAC5C;AAAA,EACF,QAAQ;AACN,UAAM,UAAU,IAAI,QAAQ,oBAAoB,eAAe;AAC/D,WAAO,KAAK,6DAA6D,EAAE,KAAK,QAAQ,CAAC;AACzF,WAAO,EAAE,MAAM,aAAa,MAAM,KAAK;AAAA,EACzC;AACF;AAMO,SAAS,uBACd,QACkD;AAClD,QAAM,MAAM,YAAY,MAAM;AAC9B,MAAI,CAAC,IAAK,QAAO;AACjB,SAAO,EAAE,KAAK,GAAG,cAAc,GAAG,EAAE;AACtC;",
+  "sourcesContent": ["import { createLogger } from '../logger'\n\nconst logger = createLogger('shared').child({ component: 'redis' })\n\n/**\n * Shared Redis connection utilities.\n *\n * Every package that needs a Redis URL or parsed connection options\n * should import from here instead of reading env vars directly.\n *\n * The `prefix` parameter lets each subsystem define its own override:\n *   getRedisUrl('QUEUE')  \u2192 QUEUE_REDIS_URL  > REDIS_URL > null\n *   getRedisUrl('CACHE')  \u2192 CACHE_REDIS_URL  > REDIS_URL > null\n *   getRedisUrl()         \u2192 REDIS_URL > null\n *\n * Returns null when Redis is not configured so callers can explicitly\n * decide whether to fall back to a non-Redis strategy or fail loudly.\n * Use getRedisUrlOrThrow() when Redis is mandatory for the caller.\n */\n\nexport type ParsedRedisConnection = {\n  host: string\n  port: number\n  username?: string\n  password?: string\n  db?: number\n  tls?: Record<string, unknown>\n  family?: number\n}\n\n/**\n * Resolve a Redis URL from environment variables.\n *\n * Priority: <PREFIX>_REDIS_URL  \u2192  REDIS_URL  \u2192  null\n *\n * Returns null when no env var is set. Callers MUST NOT assume a\n * localhost default \u2014 silently connecting to localhost masks missing\n * configuration and stalls on platforms where nothing listens there\n * (e.g., WSL2 without a local Redis).\n */\nexport function getRedisUrl(prefix?: string): string | null {\n  if (prefix) {\n    const prefixed = process.env[`${prefix}_REDIS_URL`]\n    if (prefixed) return prefixed\n  }\n  return process.env.REDIS_URL || null\n}\n\n/**\n * Like getRedisUrl, but throws a descriptive error when Redis is not\n * configured. Use from code paths that require Redis (e.g. BullMQ\n * async queue, Redis cache strategy, scheduler service).\n */\nexport function getRedisUrlOrThrow(prefix?: string): string {\n  const url = getRedisUrl(prefix)\n  if (url) return url\n  const which = prefix ? `${prefix}_REDIS_URL or REDIS_URL` : 'REDIS_URL'\n  throw new Error(\n    `Redis URL is not configured. Set ${which} in your environment to use a Redis-backed strategy.`\n  )\n}\n\n/**\n * Parse a redis:// URL into structured connection options suitable for\n * BullMQ and ioredis.\n */\nexport function parseRedisUrl(url: string): ParsedRedisConnection {\n  try {\n    const parsed = new URL(url)\n    const dbStr = parsed.pathname ? parsed.pathname.slice(1) : ''\n    const dbParsed = dbStr !== '' ? parseInt(dbStr, 10) : NaN\n    const db = Number.isNaN(dbParsed) ? undefined : dbParsed\n    const familyValue = parsed.searchParams.get('family')\n    const familyParsed = familyValue !== null ? parseInt(familyValue, 10) : NaN\n    const family = [0, 4, 6].includes(familyParsed) ? familyParsed : undefined\n    return {\n      host: parsed.hostname || 'localhost',\n      port: parseInt(parsed.port, 10) || 6379,\n      username: parsed.username ? decodeURIComponent(parsed.username) : undefined,\n      password: parsed.password ? decodeURIComponent(parsed.password) : undefined,\n      db,\n      tls: parsed.protocol === 'rediss:' ? {} : undefined,\n      family,\n    }\n  } catch {\n    const safeUrl = url.replace(/\\/\\/[^:]*:[^@]*@/, '//<redacted>@')\n    logger.warn('Failed to parse Redis URL, falling back to localhost:6379', { url: safeUrl })\n    return { host: 'localhost', port: 6379 }\n  }\n}\n\n/**\n * Convenience: resolve the URL from env and parse it in one step.\n * Returns null when Redis is not configured.\n */\nexport function resolveRedisConnection(\n  prefix?: string,\n): (ParsedRedisConnection & { url: string }) | null {\n  const url = getRedisUrl(prefix)\n  if (!url) return null\n  return { url, ...parseRedisUrl(url) }\n}\n"],
+  "mappings": "AAAA,SAAS,oBAAoB;AAE7B,MAAM,SAAS,aAAa,QAAQ,EAAE,MAAM,EAAE,WAAW,QAAQ,CAAC;AAsC3D,SAAS,YAAY,QAAgC;AAC1D,MAAI,QAAQ;AACV,UAAM,WAAW,QAAQ,IAAI,GAAG,MAAM,YAAY;AAClD,QAAI,SAAU,QAAO;AAAA,EACvB;AACA,SAAO,QAAQ,IAAI,aAAa;AAClC;AAOO,SAAS,mBAAmB,QAAyB;AAC1D,QAAM,MAAM,YAAY,MAAM;AAC9B,MAAI,IAAK,QAAO;AAChB,QAAM,QAAQ,SAAS,GAAG,MAAM,4BAA4B;AAC5D,QAAM,IAAI;AAAA,IACR,oCAAoC,KAAK;AAAA,EAC3C;AACF;AAMO,SAAS,cAAc,KAAoC;AAChE,MAAI;AACF,UAAM,SAAS,IAAI,IAAI,GAAG;AAC1B,UAAM,QAAQ,OAAO,WAAW,OAAO,SAAS,MAAM,CAAC,IAAI;AAC3D,UAAM,WAAW,UAAU,KAAK,SAAS,OAAO,EAAE,IAAI;AACtD,UAAM,KAAK,OAAO,MAAM,QAAQ,IAAI,SAAY;AAChD,UAAM,cAAc,OAAO,aAAa,IAAI,QAAQ;AACpD,UAAM,eAAe,gBAAgB,OAAO,SAAS,aAAa,EAAE,IAAI;AACxE,UAAM,SAAS,CAAC,GAAG,GAAG,CAAC,EAAE,SAAS,YAAY,IAAI,eAAe;AACjE,WAAO;AAAA,MACL,MAAM,OAAO,YAAY;AAAA,MACzB,MAAM,SAAS,OAAO,MAAM,EAAE,KAAK;AAAA,MACnC,UAAU,OAAO,WAAW,mBAAmB,OAAO,QAAQ,IAAI;AAAA,MAClE,UAAU,OAAO,WAAW,mBAAmB,OAAO,QAAQ,IAAI;AAAA,MAClE;AAAA,MACA,KAAK,OAAO,aAAa,YAAY,CAAC,IAAI;AAAA,MAC1C;AAAA,IACF;AAAA,EACF,QAAQ;AACN,UAAM,UAAU,IAAI,QAAQ,oBAAoB,eAAe;AAC/D,WAAO,KAAK,6DAA6D,EAAE,KAAK,QAAQ,CAAC;AACzF,WAAO,EAAE,MAAM,aAAa,MAAM,KAAK;AAAA,EACzC;AACF;AAMO,SAAS,uBACd,QACkD;AAClD,QAAM,MAAM,YAAY,MAAM;AAC9B,MAAI,CAAC,IAAK,QAAO;AACjB,SAAO,EAAE,KAAK,GAAG,cAAc,GAAG,EAAE;AACtC;",
   "names": []
 }

package/dist/lib/version.js

@@ -1,4 +1,4 @@
-const APP_VERSION = "0.6.7-develop.6834.1.e76f4b8cbc";
+const APP_VERSION = "0.6.7-develop.6842.1.8cd8a8883c";
 const appVersion = APP_VERSION;
 export {
   APP_VERSION,

package/dist/lib/version.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/lib/version.ts"],
-  "sourcesContent": ["// Build-time generated version\nexport const APP_VERSION = '0.6.7-develop.6834.1.e76f4b8cbc';\nexport const appVersion = APP_VERSION;\n"],
+  "sourcesContent": ["// Build-time generated version\nexport const APP_VERSION = '0.6.7-develop.6842.1.8cd8a8883c';\nexport const appVersion = APP_VERSION;\n"],
   "mappings": "AACO,MAAM,cAAc;AACpB,MAAM,aAAa;",
   "names": []
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-mercato/shared",
-  "version": "0.6.7-develop.6834.1.e76f4b8cbc",
+  "version": "0.6.7-develop.6842.1.8cd8a8883c",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",
@@ -105,7 +105,7 @@
     "@mikro-orm/core": "^7.1.8",
     "@mikro-orm/decorators": "^7.1.8",
     "@mikro-orm/postgresql": "^7.1.8",
-    "@open-mercato/cache": "0.6.7-develop.6834.1.e76f4b8cbc",
+    "@open-mercato/cache": "0.6.7-develop.6842.1.8cd8a8883c",
     "@types/sanitize-html": "^2.16.1",
     "dotenv": "^17.4.2",
     "pino": "^10.3.1",

package/src/lib/bootstrap/__tests__/dynamicLoader.generatedCacheRecovery.test.ts

@@ -0,0 +1,192 @@
+/**
+ * @jest-environment node
+ *
+ * Integration guard for #4526/#4693: compileAndImport must await its dynamic
+ * import so that an import-time rejection settles inside the try block.
+ * Returning the promise unawaited let the rejection escape the surrounding try,
+ * which made the MikroORM v7 generated-cache recovery in the catch dead code for
+ * exactly the failure it exists to repair. The one-line fix shipped in #4540;
+ * this file is the end-to-end coverage for it.
+ *
+ * Two sibling suites cover this area and neither subsumes the other:
+ *
+ * - dynamicLoader.cacheRecovery.test.ts mocks ../generatedCacheRecovery in full
+ *   and asserts how the loader *reacts* to a rejecting import (recovery is
+ *   invoked once, the retry is capped at one, the error propagates when no
+ *   recovery applies).
+ * - generatedCacheRecovery.test.ts exercises the recovery module directly,
+ *   without going through the loader.
+ * - This file runs the REAL recovery module from the loader's catch, so the
+ *   loader ↔ recovery seam is covered end to end: the on-disk marker, its
+ *   `runtime-import-error` reason and the deleted-file list are asserted against
+ *   what the production module actually writes. Nothing else in the repository
+ *   reaches that reason.
+ *
+ * The fixture reproduces the window the catch exists for: a stale compiled file
+ * that the startup scan (ensureMikroOrmV7GeneratedCacheCompatibility) cannot see
+ * because it appears only once loading is already under way. The staged .mjs
+ * therefore carries no decorator import at scan time — it writes a stale sibling
+ * and then rejects with the error Node raises for a v6 decorator import, which
+ * is what the import-time recovery is meant to repair.
+ *
+ * The assertions stop at the recovery boundary on purpose. Jest's module
+ * registry keeps serving a file it has already evaluated, so the guarded retry
+ * re-runs the rejecting module from memory no matter what recovery wrote to
+ * disk — the outcome of the retry is a property of the test runner, not of the
+ * loader. What #4526 broke, and what this guards, is that the catch runs at
+ * all: before the fix the rejection escaped the try, so no import-time recovery
+ * ever happened.
+ */
+import crypto from 'node:crypto'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { loadBootstrapData } from '../dynamicLoader'
+
+const STALE_SIBLING_BASENAME = 'stale-entity.generated.mjs'
+
+/**
+ * The decorator import is assembled at runtime rather than written literally:
+ * a literal would make this fixture itself match the startup scan's staleness
+ * pattern, so the scan would delete the cache before the import ever runs and
+ * the import-time path under test would never be exercised.
+ */
+const REJECTING_COMPILED_SOURCE = [
+  "const nodeFs = require('node:fs')",
+  "const nodePath = require('node:path')",
+  "const quote = String.fromCharCode(39)",
+  "const staleImport = 'import { Entity, PrimaryKey } from ' + quote + '@mikro-orm/core' + quote",
+  `nodeFs.writeFileSync(nodePath.join(__dirname, ${JSON.stringify(STALE_SIBLING_BASENAME)}), staleImport + '\\nexport const stale = true\\n')`,
+  `throw new Error('The requested module ' + quote + '@mikro-orm/core' + quote + ' does not provide an export named ' + quote + 'Entity' + quote)`,
+].join('\n')
+
+/**
+ * Jest resolves the loader's dynamic import through its own CommonJS registry,
+ * so a staged .mjs has to be CommonJS to evaluate at all — esbuild's real ESM
+ * output fails under the runner with "Unexpected token 'export'". The .ts
+ * sources stay honest ESM: they are what the loader recompiles from once
+ * recovery has deleted the cache.
+ */
+const GENERATED_MODULES: Record<string, { ts: string; compiled: string }> = {
+  'entities.ids.generated': { ts: 'export const E = {}', compiled: 'module.exports = { E: {} }' },
+  'modules.cli.generated': { ts: 'export const modules = []', compiled: 'module.exports = { modules: [] }' },
+  'entities.generated': { ts: 'export const entities = []', compiled: 'module.exports = { entities: [] }' },
+  'di.generated': { ts: 'export const diRegistrars = []', compiled: 'module.exports = { diRegistrars: [] }' },
+}
+
+function contentHash(content: Buffer | string): string {
+  return crypto.createHash('sha256').update(content).digest('hex')
+}
+
+/**
+ * Replace a compiled cache entry with staged content the runner can evaluate,
+ * keeping the loader's own cache metadata authoritative.
+ *
+ * The loader validates a cache entry by hashing (#4724): it recompiles unless
+ * the sibling `.cache.json` matches both the source and the compiled output.
+ * Only `outputHash` is rewritten here — `version`, `inputHash` and
+ * `dependencies` stay exactly as the loader wrote them, so the fixture models a
+ * cache that is internally consistent and simply stale, and it cannot drift out
+ * of step with the cache format the way a hand-built metadata file would.
+ */
+function stageCompiledCache(generatedDir: string, baseName: string, compiled: string) {
+  const jsPath = path.join(generatedDir, `${baseName}.mjs`)
+  const metadataPath = `${jsPath}.cache.json`
+
+  fs.writeFileSync(jsPath, compiled)
+  const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf8'))
+  metadata.outputHash = contentHash(fs.readFileSync(jsPath))
+  fs.writeFileSync(metadataPath, JSON.stringify(metadata))
+}
+
+function hasCacheMetadata(generatedDir: string, baseName: string): boolean {
+  return fs.existsSync(path.join(generatedDir, `${baseName}.mjs.cache.json`))
+}
+
+describe('compileAndImport — generated-cache recovery is reachable (#4526)', () => {
+  let appRoot: string
+  let generatedDir: string
+  let warnSpy: jest.SpyInstance
+
+  /**
+   * Let the loader compile the generated sources so it writes real cache
+   * metadata for each of them, replacing each compiled output with the
+   * runner-evaluable staged content as it appears.
+   *
+   * The loader writes a module's metadata before importing it, so an import
+   * failing here (esbuild's ESM output under Jest's CommonJS registry) is
+   * expected and irrelevant — the metadata is the only thing this step is
+   * after. That failure does abort the rest of the load, though, so one pass
+   * only reaches the modules the loader got to: entities.ids first and alone,
+   * then the remainder together. Repeating the pass lets each newly staged
+   * module unblock the next batch, and the loop ends on the first pass that
+   * loads cleanly, which is precisely when every module is staged.
+   *
+   * jest.resetModules() between passes is load-bearing. Jest keys its registry
+   * on the resolved path and ignores the loader's `?cache=` query, so without
+   * the reset a module would keep being served from its first (ESM, failing)
+   * evaluation and no later pass could make progress.
+   *
+   * None of these failures carries a decorator-export error, so no recovery
+   * runs and no marker is written during setup; both tests below would fail
+   * loudly if one were.
+   */
+  async function primeAndStageCompiledCaches() {
+    const baseNames = Object.keys(GENERATED_MODULES)
+    for (let pass = 0; pass <= baseNames.length; pass += 1) {
+      let loadedCleanly = true
+      await loadBootstrapData(appRoot).catch(() => { loadedCleanly = false })
+      jest.resetModules()
+      if (loadedCleanly) return
+      for (const baseName of baseNames) {
+        if (!hasCacheMetadata(generatedDir, baseName)) continue
+        stageCompiledCache(generatedDir, baseName, GENERATED_MODULES[baseName].compiled)
+      }
+    }
+    throw new Error('[internal] loader never reached a fully staged generated cache')
+  }
+
+  beforeEach(async () => {
+    appRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'om-bootstrap-4526-'))
+    generatedDir = path.join(appRoot, '.mercato', 'generated')
+    fs.mkdirSync(generatedDir, { recursive: true })
+    fs.writeFileSync(
+      path.join(appRoot, 'tsconfig.json'),
+      JSON.stringify({ compilerOptions: { target: 'ES2022', module: 'ESNext' } }),
+    )
+    for (const [baseName, source] of Object.entries(GENERATED_MODULES)) {
+      fs.writeFileSync(path.join(generatedDir, `${baseName}.ts`), source.ts)
+    }
+    warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
+
+    await primeAndStageCompiledCaches()
+  })
+
+  afterEach(() => {
+    warnSpy.mockRestore()
+    fs.rmSync(appRoot, { recursive: true, force: true })
+  })
+
+  it('runs cache recovery when the compiled cache rejects on import', async () => {
+    const rejectingPath = path.join(generatedDir, 'entities.ids.generated.mjs')
+    stageCompiledCache(generatedDir, 'entities.ids.generated', REJECTING_COMPILED_SOURCE)
+
+    await loadBootstrapData(appRoot).catch(() => undefined)
+
+    const markerPath = path.join(generatedDir, '.mikro-orm-v7-cache-recovery.json')
+    expect(fs.existsSync(markerPath)).toBe(true)
+
+    const marker = JSON.parse(fs.readFileSync(markerPath, 'utf8'))
+    expect(marker.reason).toBe('runtime-import-error')
+    expect(marker.deletedFiles).toContain(rejectingPath)
+    expect(marker.deletedFiles).toContain(path.join(generatedDir, STALE_SIBLING_BASENAME))
+
+    expect(fs.readFileSync(rejectingPath, 'utf8')).not.toContain('does not provide an export named')
+  })
+
+  it('does not run recovery when the compiled cache imports cleanly', async () => {
+    await loadBootstrapData(appRoot)
+
+    expect(fs.existsSync(path.join(generatedDir, '.mikro-orm-v7-cache-recovery.json'))).toBe(false)
+  })
+})

package/src/lib/i18n/__tests__/config.test.ts

@@ -0,0 +1,8 @@
+import { defaultLocale, locales, type Locale } from '../config'
+
+describe('supported application locales', () => {
+  it('registers Korean without changing the default locale', () => {
+    expect(locales).toEqual<Locale[]>(['en', 'pl', 'es', 'de', 'ko'])
+    expect(defaultLocale).toBe('en')
+  })
+})

package/src/lib/i18n/config.ts

@@ -1,4 +1,4 @@
-export type Locale = 'en' | 'pl' | 'es' | 'de'
+export type Locale = 'en' | 'pl' | 'es' | 'de' | 'ko'
 
-export const locales: Locale[] = ['en', 'pl', 'es', 'de']
+export const locales: Locale[] = ['en', 'pl', 'es', 'de', 'ko']
 export const defaultLocale: Locale = 'en'

package/src/lib/redis/__tests__/connection.test.ts

@@ -5,9 +5,11 @@ describe('parseRedisUrl', () => {
     expect(parseRedisUrl('rediss://:secret@example.cache.amazonaws.com:6379/2')).toEqual({
       host: 'example.cache.amazonaws.com',
       port: 6379,
+      username: undefined,
       password: 'secret',
       db: 2,
       tls: {},
+      family: undefined,
     })
   })
 
@@ -15,9 +17,23 @@ describe('parseRedisUrl', () => {
     expect(parseRedisUrl('redis://:secret@localhost:6379/0')).toEqual({
       host: 'localhost',
       port: 6379,
+      username: undefined,
       password: 'secret',
       db: 0,
       tls: undefined,
+      family: undefined,
+    })
+  })
+
+  it('preserves ACL credentials and supported address-family options', () => {
+    expect(parseRedisUrl('rediss://app%2Duser:p%40ss@example.com:6380/4?family=6')).toEqual({
+      host: 'example.com',
+      port: 6380,
+      username: 'app-user',
+      password: 'p@ss',
+      db: 4,
+      tls: {},
+      family: 6,
     })
   })
 })

package/src/lib/redis/connection.ts

@@ -21,9 +21,11 @@ const logger = createLogger('shared').child({ component: 'redis' })
 export type ParsedRedisConnection = {
   host: string
   port: number
+  username?: string
   password?: string
   db?: number
   tls?: Record<string, unknown>
+  family?: number
 }
 
 /**
@@ -59,12 +61,8 @@ export function getRedisUrlOrThrow(prefix?: string): string {
 }
 
 /**
- * Parse a redis:// URL into a {host, port, password, db} object
- * suitable for BullMQ / ioredis structured connection options.
- *
- * @deprecated Prefer passing the full URL via `{ url: getRedisUrl(...) }` to
- * BullMQ/ioredis — this preserves rediss://, username, database, and query
- * params that structured parsing may lose. Kept for backward compatibility.
+ * Parse a redis:// URL into structured connection options suitable for
+ * BullMQ and ioredis.
  */
 export function parseRedisUrl(url: string): ParsedRedisConnection {
   try {
@@ -72,12 +70,17 @@ export function parseRedisUrl(url: string): ParsedRedisConnection {
     const dbStr = parsed.pathname ? parsed.pathname.slice(1) : ''
     const dbParsed = dbStr !== '' ? parseInt(dbStr, 10) : NaN
     const db = Number.isNaN(dbParsed) ? undefined : dbParsed
+    const familyValue = parsed.searchParams.get('family')
+    const familyParsed = familyValue !== null ? parseInt(familyValue, 10) : NaN
+    const family = [0, 4, 6].includes(familyParsed) ? familyParsed : undefined
     return {
       host: parsed.hostname || 'localhost',
       port: parseInt(parsed.port, 10) || 6379,
-      password: parsed.password || undefined,
+      username: parsed.username ? decodeURIComponent(parsed.username) : undefined,
+      password: parsed.password ? decodeURIComponent(parsed.password) : undefined,
       db,
       tls: parsed.protocol === 'rediss:' ? {} : undefined,
+      family,
     }
   } catch {
     const safeUrl = url.replace(/\/\/[^:]*:[^@]*@/, '//<redacted>@')