@hoanghainh/komagu 1.8.0 → 2.0.1

package/remediate/identity/spring/src/test/kotlin/io/komagu/security/identity/TokenValidationIntegrationTest.kt

@@ -27,7 +27,7 @@ class TokenValidationIntegrationTest {
 
     companion object {
         const val EXPECTED_ISSUER = "https://auth.komagu.test/realms/komagu"
-        const val EXPECTED_AUDIENCE = "komainu-api"
+        const val EXPECTED_AUDIENCE = "komagu-api"
         val jwtFactory = TestJwtFactory()
     }
 

package/remediate/identity/test-env/realm-komagu.json

@@ -37,7 +37,7 @@
       ]
     },
     {
-      "clientId": "komainu-api",
+      "clientId": "komagu-api",
       "name": "Komagu Resource Server API",
       "enabled": true,
       "bearerOnly": true,

package/remediate/legacy_shims/coldfusion/KomaguSecurityShim.cfc

@@ -18,12 +18,12 @@
     <cfargument name="idValue" type="any" required="true">
 
     <cfif isNull(arguments.idValue)>
-      <cfthrow type="Komainu.InvalidId" message="Identifier cannot be null.">
+      <cfthrow type="Komagu.InvalidId" message="Identifier cannot be null.">
     </cfif>
 
     <cfset var s = trim(toString(arguments.idValue))>
     <cfif len(s) EQ 0 OR NOT reFind("^[1-9][0-9]{0,18}$", s)>
-      <cfthrow type="Komainu.InvalidId" message="Identifier must be a positive canonical decimal integer.">
+      <cfthrow type="Komagu.InvalidId" message="Identifier must be a positive canonical decimal integer.">
     </cfif>
 
     <cfreturn s>
@@ -59,10 +59,10 @@
     <cfargument name="allowList" type="array" required="true">
 
     <cfif NOT arrayFind(arguments.allowList, arguments.identifier)>
-      <cfthrow type="Komainu.DisallowedIdentifier" message="Disallowed SQL identifier.">
+      <cfthrow type="Komagu.DisallowedIdentifier" message="Disallowed SQL identifier.">
     </cfif>
     <cfif NOT reFind("^[a-zA-Z_][a-zA-Z0-9_]*$", arguments.identifier)>
-      <cfthrow type="Komainu.InvalidIdentifier" message="Invalid SQL identifier format.">
+      <cfthrow type="Komagu.InvalidIdentifier" message="Invalid SQL identifier format.">
     </cfif>
     <cfreturn arguments.identifier>
   </cffunction>
@@ -99,7 +99,7 @@
       </cfquery>
 
       <cfif qOwnership.recordCount EQ 0>
-        <cfthrow type="Komainu.AccessDenied" message="Record not found or not owned.">
+        <cfthrow type="Komagu.AccessDenied" message="Record not found or not owned.">
       </cfif>
 
       <cfreturn normResId>

package/remediate/query/README.md

@@ -42,7 +42,7 @@ val safeClause = allowList.buildSortClause(userInputColumn, "DESC")
 
 The `Komagu.Security.Query.Analyzers` package inspects syntax trees during build time and inside the IDE to flag any string concatenation or string interpolation passed into raw SQL query methods:
 
-- **Diagnostic ID:** `KOMAINU001`
+- **Diagnostic ID:** `KOMAGU001`
 - **Severity:** `Warning` / `Error`
 - **Target APIs:** `FromSqlRaw`, `ExecuteSqlRaw`, `ExecuteSqlRawAsync`, `SqlQueryRaw`, `Query`, `Execute`.
 

package/remediate/query/dotnet/src/Komagu.Security.Query.Analyzers/DiagnosticIds.cs

@@ -3,5 +3,5 @@ namespace Komagu.Security.Query.Analyzers;
 public static class DiagnosticIds
 {
     // Kept after the rename so existing #pragma / .editorconfig suppressions still apply (#290).
-    public const string SqlInjectionDiagnosticId = "KOMAINU001";
+    public const string SqlInjectionDiagnosticId = "KOMAGU001";
 }

package/remediate/query/dotnet/src/Komagu.Security.Query.Analyzers/Komagu.Security.Query.Analyzers.csproj

@@ -10,7 +10,7 @@
     <Version>1.0.0-preview.1</Version>
     <Authors>Komagu Contributors</Authors>
     <Company>Komagu Security</Company>
-    <Description>Roslyn analyzer rule KOMAINU001 detecting SQL injection from string-built queries in C#.</Description>
+    <Description>Roslyn analyzer rule KOMAGU001 detecting SQL injection from string-built queries in C#.</Description>
     <PackageLicenseExpression>Apache-2.0</PackageLicenseExpression>
     <IsRoslynComponent>true</IsRoslynComponent>
     <EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>

package/remediate/query/spring/src/main/kotlin/io/komagu/security/query/detekt/KomaguRuleSetProvider.kt

@@ -9,7 +9,7 @@ import io.gitlab.arturbosch.detekt.api.RuleSetProvider
  */
 class KomaguRuleSetProvider : RuleSetProvider {
     // Kept after the rename so existing detekt.yml sections and @Suppress ids still apply (#290).
-    override val ruleSetId: String = "komainu-security"
+    override val ruleSetId: String = "komagu-security"
 
     override fun instance(config: Config): RuleSet {
         return RuleSet(

package/remediate/resilience/dr/dr_manager.py

@@ -15,18 +15,12 @@ import json
 import os
 import sys
 import time
-import warnings
 from typing import Any, Dict, List, Optional, Tuple
 
 
 def _env(name: str, default: Optional[str] = None) -> Optional[str]:
-    """Read KOMAGU_<name>, falling back to the deprecated KOMAINU_<name> (#290)."""
-    value = os.environ.get("KOMAGU_" + name)
-    if value is None:
-        value = os.environ.get("KOMAINU_" + name)
-        if value is not None:
-            warnings.warn(f"KOMAINU_{name} is deprecated, set KOMAGU_{name} instead", DeprecationWarning, stacklevel=2)
-    return default if value is None else value
+    """Read KOMAGU_<name>."""
+    return os.environ.get("KOMAGU_" + name, default)
 
 
 

package/remediate/resilience/dr/runbook.md

@@ -34,7 +34,7 @@ A Disaster Recovery failover is declared by the Incident Commander / Principal A
 ### Phase 2: Secondary Cluster Activation (大阪スタンバイ環境起動)
 1. Scale Osaka ECS tasks from 0 (warm standby) to production capacity:
    ```bash
-   aws ecs update-service --cluster komainu-production-standby-dr-cluster \
+   aws ecs update-service --cluster komagu-production-standby-dr-cluster \
      --service api-gateway --desired-count 4 --region ap-northeast-3
    ```
 2. Rehydrate relational state from S3 Object Lock Compliance WORM bucket:
@@ -43,7 +43,7 @@ A Disaster Recovery failover is declared by the Incident Commander / Principal A
    ```
 
 ### Phase 3: Route53 Traffic Cutover (DNS切替)
-1. Update DNS failover record to point to Osaka ALB (`osaka-dr-alb.komainu.internal`).
+1. Update DNS failover record to point to Osaka ALB (`osaka-dr-alb.komagu.internal`).
 2. Verify smoke test health check returns HTTP 200 on all core endpoints.
 
 ---

package/remediate/resilience/terraform/variables.tf

@@ -15,7 +15,7 @@ variable "secondary_region" {
 variable "project_name" {
   description = "Project and workload prefix"
   type        = string
-  default     = "komainu"
+  default     = "komagu"
 }
 
 variable "environment" {

package/remediate/tenancy/audit/audit_trail.py

@@ -17,18 +17,12 @@ import os
 import secrets
 import sys
 import threading
-import warnings
 from typing import Any, Dict, List, Optional, Tuple
 
 
 def _env(name: str, default: Optional[str] = None) -> Optional[str]:
-    """Read KOMAGU_<name>, falling back to the deprecated KOMAINU_<name> (#290)."""
-    value = os.environ.get("KOMAGU_" + name)
-    if value is None:
-        value = os.environ.get("KOMAINU_" + name)
-        if value is not None:
-            warnings.warn(f"KOMAINU_{name} is deprecated, set KOMAGU_{name} instead", DeprecationWarning, stacklevel=2)
-    return default if value is None else value
+    """Read KOMAGU_<name>."""
+    return os.environ.get("KOMAGU_" + name, default)
 
 
 

package/remediate/tenancy/crypto/byok_manager.py

@@ -15,18 +15,12 @@ import json
 import os
 import secrets
 import sys
-import warnings
 from typing import Any, Dict, Optional, Tuple
 
 
 def _env(name: str, default: Optional[str] = None) -> Optional[str]:
-    """Read KOMAGU_<name>, falling back to the deprecated KOMAINU_<name> (#290)."""
-    value = os.environ.get("KOMAGU_" + name)
-    if value is None:
-        value = os.environ.get("KOMAINU_" + name)
-        if value is not None:
-            warnings.warn(f"KOMAINU_{name} is deprecated, set KOMAGU_{name} instead", DeprecationWarning, stacklevel=2)
-    return default if value is None else value
+    """Read KOMAGU_<name>."""
+    return os.environ.get("KOMAGU_" + name, default)
 
 
 try:

package/remediate/tenancy/middleware/tenant_context.py

@@ -12,18 +12,12 @@ from contextlib import contextmanager
 import hmac
 import os
 import re
-import warnings
 from typing import Any, Dict, Iterator, Optional
 
 
 def _env(name: str, default: Optional[str] = None) -> Optional[str]:
-    """Read KOMAGU_<name>, falling back to the deprecated KOMAINU_<name> (#290)."""
-    value = os.environ.get("KOMAGU_" + name)
-    if value is None:
-        value = os.environ.get("KOMAINU_" + name)
-        if value is not None:
-            warnings.warn(f"KOMAINU_{name} is deprecated, set KOMAGU_{name} instead", DeprecationWarning, stacklevel=2)
-    return default if value is None else value
+    """Read KOMAGU_<name>."""
+    return os.environ.get("KOMAGU_" + name, default)
 
 
 # Context variable holding the active tenant_id for the current execution thread/coroutine

package/remediate/tenancy/sql/rls_isolation.sql

@@ -8,16 +8,16 @@
 --    In autocommit connection pools, session state expires immediately after set_current_tenant().
 -- 2. ROLE RESTRICTION: FORCE ROW LEVEL SECURITY enforces policies on table owners
 --    and standard users, but NEVER applies to PostgreSQL superusers or roles with BYPASSRLS.
---    Applications MUST connect using a non-owner, non-BYPASSRLS application role (komainu_app).
+--    Applications MUST connect using a non-owner, non-BYPASSRLS application role (komagu_app).
 
 -- 0. Provision Dedicated Non-Owner Application Role (without hard-coded password)
 -- NOTE: In production environments requiring LOGIN connections, configure passwords
--- exclusively via deployment orchestration or vault parameters (ALTER ROLE komainu_app WITH LOGIN PASSWORD ...),
+-- exclusively via deployment orchestration or vault parameters (ALTER ROLE komagu_app WITH LOGIN PASSWORD ...),
 -- NEVER hard-code credentials in committed migration scripts.
 DO $$
 BEGIN
-    IF NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'komainu_app') THEN
-        CREATE ROLE komainu_app WITH NOSUPERUSER NOBYPASSRLS NOCREATEDB NOCREATEROLE NOLOGIN;
+    IF NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'komagu_app') THEN
+        CREATE ROLE komagu_app WITH NOSUPERUSER NOBYPASSRLS NOCREATEDB NOCREATEROLE NOLOGIN;
     END IF;
 END;
 $$;
@@ -55,7 +55,7 @@ ALTER TABLE orders FORCE ROW LEVEL SECURITY;
 DROP POLICY IF EXISTS tenant_org_isolation_policy ON tenant_organizations;
 CREATE POLICY tenant_org_isolation_policy ON tenant_organizations
     FOR ALL
-    TO komainu_app
+    TO komagu_app
     USING (
         id = NULLIF(current_setting('app.current_tenant_id', true), '')
     )
@@ -67,7 +67,7 @@ CREATE POLICY tenant_org_isolation_policy ON tenant_organizations
 DROP POLICY IF EXISTS tenant_isolation_policy ON orders;
 CREATE POLICY tenant_isolation_policy ON orders
     FOR ALL
-    TO komainu_app
+    TO komagu_app
     USING (
         tenant_id = NULLIF(current_setting('app.current_tenant_id', true), '')
     )
@@ -126,11 +126,11 @@ CREATE TRIGGER trg_orders_tenant_injection
 
 -- 6. Grant Least-Privilege Access to Application Role & Revoke Public Execution
 REVOKE ALL ON FUNCTION trg_inject_current_tenant() FROM PUBLIC;
-GRANT USAGE ON SCHEMA public TO komainu_app;
-GRANT SELECT, INSERT, UPDATE, DELETE ON tenant_organizations TO komainu_app;
-GRANT SELECT, INSERT, UPDATE, DELETE ON orders TO komainu_app;
+GRANT USAGE ON SCHEMA public TO komagu_app;
+GRANT SELECT, INSERT, UPDATE, DELETE ON tenant_organizations TO komagu_app;
+GRANT SELECT, INSERT, UPDATE, DELETE ON orders TO komagu_app;
 
 REVOKE ALL ON FUNCTION set_current_tenant(VARCHAR) FROM PUBLIC;
 REVOKE ALL ON FUNCTION reset_current_tenant() FROM PUBLIC;
-GRANT EXECUTE ON FUNCTION set_current_tenant(VARCHAR) TO komainu_app;
-GRANT EXECUTE ON FUNCTION reset_current_tenant() TO komainu_app;
+GRANT EXECUTE ON FUNCTION set_current_tenant(VARCHAR) TO komagu_app;
+GRANT EXECUTE ON FUNCTION reset_current_tenant() TO komagu_app;

package/remediate/tenancy/sql/schema_per_tenant.sql

@@ -59,10 +59,10 @@ BEGIN
 
 
     -- Grant least-privilege tenant access to application role
-    IF EXISTS (SELECT 1 FROM pg_catalog.pg_roles WHERE rolname = 'komainu_app') THEN
-        EXECUTE format('GRANT USAGE ON SCHEMA %I TO komainu_app', v_schema_name);
-        EXECUTE format('GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA %I TO komainu_app', v_schema_name);
-        EXECUTE format('ALTER DEFAULT PRIVILEGES IN SCHEMA %I GRANT SELECT, INSERT, UPDATE, DELETE ON TABLES TO komainu_app', v_schema_name);
+    IF EXISTS (SELECT 1 FROM pg_catalog.pg_roles WHERE rolname = 'komagu_app') THEN
+        EXECUTE format('GRANT USAGE ON SCHEMA %I TO komagu_app', v_schema_name);
+        EXECUTE format('GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA %I TO komagu_app', v_schema_name);
+        EXECUTE format('ALTER DEFAULT PRIVILEGES IN SCHEMA %I GRANT SELECT, INSERT, UPDATE, DELETE ON TABLES TO komagu_app', v_schema_name);
     END IF;
 
 END;
@@ -101,11 +101,11 @@ $$ LANGUAGE plpgsql;
 REVOKE ALL ON FUNCTION create_tenant_schema(VARCHAR) FROM PUBLIC;
 REVOKE ALL ON FUNCTION switch_tenant_schema(VARCHAR) FROM PUBLIC;
 REVOKE ALL ON TABLE public.tenant_registry FROM PUBLIC;
--- Note: No SELECT grant on tenant_registry for komainu_app. Namespace‑only isolation is enforced; cross‑tenant queries must use tenant‑specific schemas.
+-- Note: No SELECT grant on tenant_registry for komagu_app. Namespace‑only isolation is enforced; cross‑tenant queries must use tenant‑specific schemas.
 DO $$
 BEGIN
-    IF EXISTS (SELECT 1 FROM pg_catalog.pg_roles WHERE rolname = 'komainu_app') THEN
-        GRANT EXECUTE ON FUNCTION switch_tenant_schema(VARCHAR) TO komainu_app;
+    IF EXISTS (SELECT 1 FROM pg_catalog.pg_roles WHERE rolname = 'komagu_app') THEN
+        GRANT EXECUTE ON FUNCTION switch_tenant_schema(VARCHAR) TO komagu_app;
     END IF;
 END $$;
 

package/remediate/tenancy/test_sql_postgres.py

@@ -16,7 +16,7 @@ import psycopg2
 from psycopg2 import sql
 
 # Paths to the SQL scripts relative to the repository root.
-REPO_ROOT = Path("/Users/hoanghainh/Projects/komainu")
+REPO_ROOT = Path(__file__).resolve().parents[2]
 SCHEMA_SQL = REPO_ROOT / "remediate" / "tenancy" / "sql" / "schema_per_tenant.sql"
 RLS_SQL = REPO_ROOT / "remediate" / "tenancy" / "sql" / "rls_isolation.sql"
 

package/remediate/tenancy/tests/test_tenancy.py

@@ -206,8 +206,8 @@ class TestTenantIsolationAndBYOK(unittest.TestCase):
         self.assertIn("REVOKE ALL ON ALL TABLES IN SCHEMA %I FROM PUBLIC", sql_content)
         self.assertIn("REVOKE ALL ON FUNCTION create_tenant_schema(VARCHAR) FROM PUBLIC", sql_content)
         self.assertIn("REVOKE ALL ON FUNCTION switch_tenant_schema(VARCHAR) FROM PUBLIC", sql_content)
-        self.assertIn("GRANT USAGE ON SCHEMA %I TO komainu_app", sql_content)
-        self.assertIn("GRANT EXECUTE ON FUNCTION switch_tenant_schema(VARCHAR) TO komainu_app", sql_content)
+        self.assertIn("GRANT USAGE ON SCHEMA %I TO komagu_app", sql_content)
+        self.assertIn("GRANT EXECUTE ON FUNCTION switch_tenant_schema(VARCHAR) TO komagu_app", sql_content)
 
     def test_11_rls_sql_app_role_and_tenant_organizations_security(self) -> None:
         """Verifies RLS template defines non-owner app role, protects tenant_organizations, and pins search_path."""
@@ -215,7 +215,7 @@ class TestTenantIsolationAndBYOK(unittest.TestCase):
         with open(rls_file, "r", encoding="utf-8") as f:
             sql_content = f.read()
 
-        self.assertIn("CREATE ROLE komainu_app WITH NOSUPERUSER NOBYPASSRLS", sql_content)
+        self.assertIn("CREATE ROLE komagu_app WITH NOSUPERUSER NOBYPASSRLS", sql_content)
         self.assertIn("NOLOGIN", sql_content)
         self.assertNotIn("replace_with_secure_app_password", sql_content)
         self.assertIn("ALTER TABLE tenant_organizations ENABLE ROW LEVEL SECURITY", sql_content)
@@ -225,7 +225,7 @@ class TestTenantIsolationAndBYOK(unittest.TestCase):
         self.assertIn("TRANSACTION REQUIREMENT", sql_content)
         self.assertIn("BEGIN ... COMMIT", sql_content)
         self.assertIn("REVOKE ALL ON FUNCTION set_current_tenant(VARCHAR) FROM PUBLIC", sql_content)
-        self.assertIn("GRANT EXECUTE ON FUNCTION set_current_tenant(VARCHAR) TO komainu_app", sql_content)
+        self.assertIn("GRANT EXECUTE ON FUNCTION set_current_tenant(VARCHAR) TO komagu_app", sql_content)
 
     def test_12_rls_cross_tenant_isolation_logic_simulation(self) -> None:
         """Simulates RLS policy evaluation: verifying cross-tenant records cannot be read."""

package/bin/komainu

@@ -1,16 +0,0 @@
-#!/usr/bin/env python3
-"""Deprecated `bin/komainu` entrypoint: use `bin/komagu` (#290)."""
-
-from __future__ import annotations
-
-import sys
-from pathlib import Path
-
-REPO_ROOT = Path(__file__).resolve().parent.parent
-sys.path.insert(0, str(REPO_ROOT))
-
-from operate.cli.main import main  # noqa: E402
-
-if __name__ == "__main__":
-    print("[DEPRECATED] bin/komainu was renamed to bin/komagu.", file=sys.stderr)
-    sys.exit(main())

package/bin/komainu-legacy.js

@@ -1,16 +0,0 @@
-#!/usr/bin/env node
-/**
- * Deprecated `komainu` / `komainu-guard` npm bin aliases.
- *
- * Prints a rename notice to stderr, then runs the Komagu launcher unchanged.
- * Remove in the next major release (#290).
- */
-
-'use strict';
-
-console.error(
-  '\x1b[33m[DEPRECATED]\x1b[0m `komainu` / `komainu-guard` were renamed to `komagu`. ' +
-  'Install @hoanghainh/komagu and run `komagu` instead.'
-);
-
-require('./komagu.js');

package/remediate/ekyc/tests/test_legacy_env.py

@@ -1,33 +0,0 @@
-#!/usr/bin/env python3
-"""KOMAGU_* environment variables with the deprecated KOMAINU_* fallback (#290)."""
-
-from __future__ import annotations
-
-import os
-import unittest
-import warnings
-from unittest.mock import patch
-
-from remediate.ekyc.server import tokenization, jpki_verifier
-
-MODULES = (tokenization, jpki_verifier)
-
-
-class TestLegacyEnvFallback(unittest.TestCase):
-    def test_new_name_wins_without_warning(self) -> None:
-        env = {"KOMAGU_EKYC_HMAC_KEY": "new", "KOMAINU_EKYC_HMAC_KEY": "old"}
-        for mod in MODULES:
-            with self.subTest(module=mod.__name__), patch.dict(os.environ, env), warnings.catch_warnings(record=True) as caught:
-                warnings.simplefilter("always")
-                self.assertEqual(mod._env("EKYC_HMAC_KEY"), "new")
-                self.assertEqual(caught, [])
-
-    def test_legacy_name_is_read_with_deprecation_warning(self) -> None:
-        for mod in MODULES:
-            with self.subTest(module=mod.__name__), patch.dict(os.environ, {"KOMAINU_EKYC_HMAC_KEY": "old"}, clear=True):
-                with self.assertWarnsRegex(DeprecationWarning, "KOMAINU_EKYC_HMAC_KEY is deprecated"):
-                    self.assertEqual(mod._env("EKYC_HMAC_KEY"), "old")
-
-
-if __name__ == "__main__":
-    unittest.main()

package/remediate/identity/python/tests/test_legacy_env.py

@@ -1,33 +0,0 @@
-#!/usr/bin/env python3
-"""KOMAGU_* environment variables with the deprecated KOMAINU_* fallback (#290)."""
-
-from __future__ import annotations
-
-import os
-import unittest
-import warnings
-from unittest.mock import patch
-
-from remediate.identity.python.komagu_identity import oidc_validator
-
-MODULES = (oidc_validator,)
-
-
-class TestLegacyEnvFallback(unittest.TestCase):
-    def test_new_name_wins_without_warning(self) -> None:
-        env = {"KOMAGU_ALLOW_DEV_TOKENS": "new", "KOMAINU_ALLOW_DEV_TOKENS": "old"}
-        for mod in MODULES:
-            with self.subTest(module=mod.__name__), patch.dict(os.environ, env), warnings.catch_warnings(record=True) as caught:
-                warnings.simplefilter("always")
-                self.assertEqual(mod._env("ALLOW_DEV_TOKENS"), "new")
-                self.assertEqual(caught, [])
-
-    def test_legacy_name_is_read_with_deprecation_warning(self) -> None:
-        for mod in MODULES:
-            with self.subTest(module=mod.__name__), patch.dict(os.environ, {"KOMAINU_ALLOW_DEV_TOKENS": "old"}, clear=True):
-                with self.assertWarnsRegex(DeprecationWarning, "KOMAINU_ALLOW_DEV_TOKENS is deprecated"):
-                    self.assertEqual(mod._env("ALLOW_DEV_TOKENS"), "old")
-
-
-if __name__ == "__main__":
-    unittest.main()

package/remediate/identity/spring/src/main/kotlin/io/komagu/security/identity/LegacyKomainuPropertiesPostProcessor.kt

@@ -1,60 +0,0 @@
-package io.komagu.security.identity
-
-import org.springframework.boot.SpringApplication
-import org.springframework.boot.context.config.ConfigDataEnvironmentPostProcessor
-import org.springframework.boot.env.EnvironmentPostProcessor
-import org.springframework.boot.logging.DeferredLogFactory
-import org.springframework.core.Ordered
-import org.springframework.core.env.ConfigurableEnvironment
-import org.springframework.core.env.EnumerablePropertySource
-import org.springframework.core.env.MapPropertySource
-
-/**
- * Maps deprecated pre-rename `komainu.security.*` properties (and `KOMAINU_SECURITY_*` env vars)
- * onto `komagu.security.*` (#290). The mapped values are added last, so any `komagu.security.*`
- * value set explicitly still wins. Remove in the next major release.
- */
-class LegacyKomainuPropertiesPostProcessor(logFactory: DeferredLogFactory) : EnvironmentPostProcessor, Ordered {
-
-    private val log = logFactory.getLog(javaClass)
-
-    override fun postProcessEnvironment(environment: ConfigurableEnvironment, application: SpringApplication?) {
-        val mapped = linkedMapOf<String, Any>()
-        // Property sources iterate highest precedence first, so the first legacy value seen wins.
-        environment.propertySources
-            .filterIsInstance<EnumerablePropertySource<*>>()
-            .filter { it.name != SOURCE_NAME }
-            .forEach { collectLegacy(it, mapped) }
-        if (mapped.isEmpty()) return
-        log.warn(
-            "komainu.security.* properties are deprecated, rename them to komagu.security.* " +
-                "(mapped: ${mapped.keys.joinToString()})"
-        )
-        environment.propertySources.addLast(MapPropertySource(SOURCE_NAME, mapped))
-    }
-
-    private fun collectLegacy(source: EnumerablePropertySource<*>, mapped: MutableMap<String, Any>) {
-        for (name in source.propertyNames) {
-            val current = currentName(name)
-            if (current != null && current !in mapped) {
-                source.getProperty(name)?.let { mapped[current] = it }
-            }
-        }
-    }
-
-    override fun getOrder(): Int = ConfigDataEnvironmentPostProcessor.ORDER + 1
-
-    companion object {
-        const val SOURCE_NAME = "legacyKomainuProperties"
-        private const val LEGACY_PREFIX = "komainu.security."
-        private const val LEGACY_ENV_PREFIX = "KOMAINU_SECURITY_"
-        private const val PREFIX = "komagu.security."
-
-        fun currentName(name: String): String? = when {
-            name.startsWith(LEGACY_PREFIX) -> PREFIX + name.removePrefix(LEGACY_PREFIX)
-            name.startsWith(LEGACY_ENV_PREFIX) ->
-                PREFIX + name.removePrefix(LEGACY_ENV_PREFIX).lowercase().replace('_', '.')
-            else -> null
-        }
-    }
-}

package/remediate/identity/spring/src/main/resources/META-INF/spring.factories

@@ -1,2 +0,0 @@
-org.springframework.boot.env.EnvironmentPostProcessor=\
-io.komagu.security.identity.LegacyKomainuPropertiesPostProcessor

package/remediate/identity/spring/src/test/kotlin/io/komagu/security/identity/LegacyKomainuPropertiesPostProcessorTest.kt

@@ -1,86 +0,0 @@
-package io.komagu.security.identity
-
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.Assertions.assertNull
-import org.junit.jupiter.api.Assertions.assertTrue
-import org.junit.jupiter.api.Test
-import org.springframework.boot.context.properties.bind.Binder
-import org.springframework.boot.logging.DeferredLogFactory
-import org.springframework.core.env.MapPropertySource
-import org.springframework.core.env.PropertySource
-import org.springframework.core.env.StandardEnvironment
-import org.springframework.core.env.SystemEnvironmentPropertySource
-
-class LegacyKomainuPropertiesPostProcessorTest {
-
-    private val processor = LegacyKomainuPropertiesPostProcessor(DeferredLogFactory { it.get() })
-
-    private fun bind(env: StandardEnvironment): KomaguOidcProperties =
-        Binder.get(env).bind("komagu.security.oidc", KomaguOidcProperties::class.java).orElseGet { KomaguOidcProperties() }
-
-    private fun envWith(vararg sources: PropertySource<*>): StandardEnvironment {
-        val env = StandardEnvironment()
-        env.propertySources.toList().forEach { env.propertySources.remove(it.name) }
-        sources.forEach { env.propertySources.addLast(it) }
-        return env
-    }
-
-    @Test
-    fun `legacy properties bind to the komagu prefix`() {
-        val env = envWith(
-            MapPropertySource(
-                "app",
-                mapOf(
-                    "komainu.security.oidc.issuer" to "https://auth.example.com",
-                    "komainu.security.oidc.jwk-set-uri" to "https://auth.example.com/certs",
-                    "komainu.security.oidc.clock-skew-seconds" to "30"
-                )
-            )
-        )
-        processor.postProcessEnvironment(env, null)
-
-        val props = bind(env)
-        assertEquals("https://auth.example.com", props.issuer)
-        assertEquals("https://auth.example.com/certs", props.jwkSetUri)
-        assertEquals(30L, props.clockSkewSeconds)
-    }
-
-    @Test
-    fun `explicit komagu properties win over legacy ones`() {
-        val env = envWith(
-            MapPropertySource("low", mapOf("komagu.security.oidc.audience" to "new-api")),
-            MapPropertySource("high", mapOf("komainu.security.oidc.audience" to "old-api"))
-        )
-        processor.postProcessEnvironment(env, null)
-
-        assertEquals("new-api", bind(env).audience)
-    }
-
-    @Test
-    fun `legacy environment variables are mapped`() {
-        val env = envWith(
-            SystemEnvironmentPropertySource(
-                "systemEnvironment",
-                mapOf<String, Any>("KOMAINU_SECURITY_OIDC_ALLOWINSECUREHTTPJWKS" to "true")
-            )
-        )
-        processor.postProcessEnvironment(env, null)
-
-        assertEquals(true, bind(env).allowInsecureHttpJwks)
-    }
-
-    @Test
-    fun `nothing is added without legacy properties`() {
-        val env = envWith(MapPropertySource("app", mapOf("komagu.security.oidc.audience" to "x")))
-        processor.postProcessEnvironment(env, null)
-
-        assertNull(env.propertySources.get(LegacyKomainuPropertiesPostProcessor.SOURCE_NAME))
-    }
-
-    @Test
-    fun `post processor is registered in spring factories`() {
-        val factories = javaClass.classLoader.getResource("META-INF/spring.factories")!!.readText()
-        assertTrue("org.springframework.boot.env.EnvironmentPostProcessor" in factories)
-        assertTrue(LegacyKomainuPropertiesPostProcessor::class.java.name in factories)
-    }
-}

package/remediate/resilience/tests/test_legacy_env.py

@@ -1,33 +0,0 @@
-#!/usr/bin/env python3
-"""KOMAGU_* environment variables with the deprecated KOMAINU_* fallback (#290)."""
-
-from __future__ import annotations
-
-import os
-import unittest
-import warnings
-from unittest.mock import patch
-
-from remediate.resilience.dr import dr_manager
-
-MODULES = (dr_manager,)
-
-
-class TestLegacyEnvFallback(unittest.TestCase):
-    def test_new_name_wins_without_warning(self) -> None:
-        env = {"KOMAGU_DR_METADATA_PATH": "new", "KOMAINU_DR_METADATA_PATH": "old"}
-        for mod in MODULES:
-            with self.subTest(module=mod.__name__), patch.dict(os.environ, env), warnings.catch_warnings(record=True) as caught:
-                warnings.simplefilter("always")
-                self.assertEqual(mod._env("DR_METADATA_PATH"), "new")
-                self.assertEqual(caught, [])
-
-    def test_legacy_name_is_read_with_deprecation_warning(self) -> None:
-        for mod in MODULES:
-            with self.subTest(module=mod.__name__), patch.dict(os.environ, {"KOMAINU_DR_METADATA_PATH": "old"}, clear=True):
-                with self.assertWarnsRegex(DeprecationWarning, "KOMAINU_DR_METADATA_PATH is deprecated"):
-                    self.assertEqual(mod._env("DR_METADATA_PATH"), "old")
-
-
-if __name__ == "__main__":
-    unittest.main()