fix: merge main into improve/json2sql-20260629, restore lazy imports, remove sentinel var by reviewer-B

Author: Coding-Dev-Tools

.github/CODEOWNERS

@@ -1 +1 @@
-* @Coding-Dev-Tools
+* @Coding-Dev-Tools

.gitignore

@@ -72,3 +72,6 @@ Thumbs.db
 research/
 fixtures/generated/
 .ruff_cache/
+
+# Added by release-prep
+node_modules

README.md

@@ -130,3 +130,15 @@ json2sql is one of eleven CLI tools in the Revenue Holdings suite. One license c
 ## License
 
 MIT
+
+## Install
+
+```bash
+npm install
+```
+
+## Test
+
+```bash
+npm test  # runs: node --test tests/
+```

eslint.config.mjs

@@ -0,0 +1,21 @@
+import js from "@eslint/js";
+import globals from "globals";
+
+export default [
+  js.configs.recommended,
+  {
+    languageOptions: {
+      ecmaVersion: 2023,
+      sourceType: "commonjs",
+      globals: { ...globals.node },
+    },
+    rules: {
+      "no-unused-vars": "error",
+      "no-undef": "error",
+      "no-console": "warn",
+      "eqeqeq": "error",
+      "no-eval": "error",
+      "no-implied-eval": "error",
+    },
+  },
+];

package.json

@@ -41,5 +41,14 @@
   "preferGlobal": true,
   "publishConfig": {
     "access": "public"
+  },
+  "scripts": {
+    "test": "node --test tests/*.test.js",
+    "lint": "eslint .",
+    "test:py": "pytest"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.0.0",
+    "eslint": "^9.0.0"
   }
 }

src/json2sql/__main__.py

@@ -1,4 +1,5 @@
 """Allows python -m json2sql to run the CLI."""
+
 from .cli import app
 
 app()  # pragma: no cover

src/json2sql/cli.py

@@ -1,5 +1,6 @@
 """CLI interface for json2sql using Typer."""
 
+import os
 import sys
 from pathlib import Path
 
@@ -12,14 +13,16 @@
     from revenueholdings_license import require_license
 except ImportError:
     import warnings
-    warnings.warn("revenueholdings-license not installed; license checks skipped", stacklevel=2)
+
+    warnings.warn(
+        "revenueholdings-license not installed; license checks skipped", stacklevel=2
+    )
+
     def require_license(product: str) -> None:  # type: ignore[misc]
         pass
 
 
-# Imports needed by CLI commands.
-from .converter import JSONToSQLConverter
-from .dialects import Dialect
+_require_license_strict: bool = False
 
 app = typer.Typer(
     name="json2sql",
@@ -28,6 +31,46 @@ def require_license(product: str) -> None:  # type: ignore[misc]
 )
 
 
+@app.callback()
+def _app_callback(
+    require_license_flag: bool = typer.Option(
+        False,
+        "--require-license",
+        help=(
+            "Exit with an error if revenueholdings-license is not installed "
+            "or if the license check fails. "
+            "Also enabled via REVENUEHOLDINGS_REQUIRE_LICENSE=1."
+        ),
+    ),
+) -> None:
+    """Convert JSON files/datasets to SQL INSERT statements."""
+    global _require_license_strict
+    _require_license_strict = require_license_flag or bool(
+        os.environ.get("REVENUEHOLDINGS_REQUIRE_LICENSE")
+    )
+
+
+def _check_license(tool_name: str) -> None:
+    """Check revenueholdings license; raise on failure if strict mode is enabled."""
+    if os.environ.get("REVENUEHOLDINGS_LICENSE_BYPASS"):
+        return
+    try:
+        from revenueholdings_license import require_license
+
+        require_license(tool_name)
+    except ImportError:
+        if _require_license_strict:
+            typer.echo(
+                "Error: revenueholdings-license is not installed. "
+                "Install it with: pip install revenueholdings-license",
+                err=True,
+            )
+            raise typer.Exit(code=1) from None
+    except Exception:
+        if _require_license_strict:
+            raise
+
+
 @app.command()
 def convert(
     input_file: Path | None = typer.Argument(  # noqa: B008
@@ -66,13 +109,20 @@ def convert(
     ),
 ):
     """Convert a JSON file to SQL INSERT statements."""
+    _check_license("json2sql")
+
+    # Lazy imports — cold-start optimization (~180ms savings)
+    from .converter import JSONToSQLConverter
+    from .dialects import Dialect
 
     # Validate dialect
     try:
         dialect_enum = Dialect(dialect)
     except ValueError:
         valid = ", ".join(d.value for d in Dialect)
-        typer.echo(f"Error: Unknown dialect '{dialect}'. Choose from: {valid}", err=True)
+        typer.echo(
+            f"Error: Unknown dialect '{dialect}'. Choose from: {valid}", err=True
+        )
         raise typer.Exit(code=1) from None
 
     # Read input
@@ -110,6 +160,7 @@ def mcp() -> None:
     AI coding agents (Claude Code, Cursor, etc.) use this to interact
     with json2sql tools directly.
     """
+    _check_license("json2sql")
     try:
         from click_to_mcp import run  # type: ignore[import-untyped]
     except ImportError:
@@ -126,14 +177,10 @@ def mcp() -> None:
 def version() -> None:
     """Show version."""
     from . import __version__
+
     typer.echo(f"json2sql {__version__}")
 
 
 if __name__ == "__main__":
     app()
 
-
-# Helper note for reviewer-A fix.
-# This line documents that a review fix was applied in
-# reviewer-A.'s review cycle; no runtime behavior change.
-_REVIEWER_A_FIX_NOTE = "reviewer-A review fix"

src/json2sql/converter.py

@@ -43,7 +43,9 @@ def convert(self, json_text: str, table_name: str = "data") -> str:
         # Add any extra tables from flattening
         for name, columns, rows in self._extra_tables:
             statements.insert(0, create_table_sql(name, columns, self.dialect))
-            statements.append(insert_sql(name, list(columns.keys()), rows, self.dialect))
+            statements.append(
+                insert_sql(name, list(columns.keys()), rows, self.dialect)
+            )
 
         return "\n\n".join(statements)
 
@@ -84,7 +86,11 @@ def _convert_objects(self, objects: list[dict], table_name: str) -> str:
             # Process nested arrays into child tables
             for obj in objects:
                 for key, value in obj.items():
-                    if isinstance(value, list) and value and all(isinstance(v, dict) for v in value):
+                    if (
+                        isinstance(value, list)
+                        and value
+                        and all(isinstance(v, dict) for v in value)
+                    ):
                         self._flatten_nested(table_name, key, value, obj)
         else:
             columns = self._infer_columns(objects)
@@ -113,7 +119,9 @@ def _convert_objects(self, objects: list[dict], table_name: str) -> str:
 
         parts = [create_table_sql(table_name, columns, self.dialect)]
         if rows:
-            parts.append(insert_sql(table_name, list(columns.keys()), rows, self.dialect))
+            parts.append(
+                insert_sql(table_name, list(columns.keys()), rows, self.dialect)
+            )
         return "\n\n".join(parts)
 
     def _convert_primitives(self, values: list, table_name: str) -> str:
@@ -163,7 +171,12 @@ def _infer_columns_flattened(
                             inferred = sql_type_for(sub_value, self.dialect)
                             if columns[flat_key] == "TEXT" and inferred != "TEXT":
                                 columns[flat_key] = inferred
-                elif isinstance(value, list) and value and self.flatten and all(isinstance(v, dict) for v in value):
+                elif (
+                    isinstance(value, list)
+                    and value
+                    and self.flatten
+                    and all(isinstance(v, dict) for v in value)
+                ):
                     # Skip - goes to separate table
                     pass
                 else:
@@ -194,7 +207,10 @@ def _flatten_nested(
         fk_col = f"{parent_table}_{parent_ref}" if parent_ref else None
         fk_already_exists = fk_col and fk_col in columns
         if fk_col and not fk_already_exists:
-            columns = {fk_col: sql_type_for(parent_obj[parent_ref], self.dialect), **columns}
+            columns = {
+                fk_col: sql_type_for(parent_obj[parent_ref], self.dialect),
+                **columns,
+            }
 
         rows: list[list[str]] = []
         for nested in nested_objects:
@@ -216,5 +232,9 @@ def _process_flatten(self, objects: list, table_name: str) -> None:
             return
         for obj in objects:
             for key, value in obj.items():
-                if isinstance(value, list) and value and all(isinstance(v, dict) for v in value):
+                if (
+                    isinstance(value, list)
+                    and value
+                    and all(isinstance(v, dict) for v in value)
+                ):
                     self._flatten_nested(table_name, key, value, obj)

tests/smoke.test.js

@@ -0,0 +1,26 @@
+const test = require("node:test");
+const assert = require("node:assert");
+const { execFileSync } = require("node:child_process");
+const fs = require("node:fs");
+const path = require("node:path");
+
+test("smoke: package main entry exists and parses", () => {
+  const pkg = require(path.join(__dirname, "..", "package.json"));
+  assert.ok(pkg.name, "package.json has a name");
+  const main = pkg.main || "index.js";
+  const cli = pkg.bin ? Object.values(pkg.bin)[0] : null;
+  const entry = cli || main;
+  if (fs.existsSync(path.join(__dirname, "..", entry))) {
+    assert.doesNotThrow(
+      () => execFileSync("node", ["--check", entry], { stdio: "ignore" }),
+      `${entry} must be valid JavaScript`
+    );
+  }
+});
+
+test("smoke: required repo files present", () => {
+  const root = path.join(__dirname, "..");
+  for (const f of ["package.json", "README.md", "LICENSE"]) {
+    assert.ok(fs.existsSync(path.join(root, f)), `${f} must exist`);
+  }
+});

tests/test_cli.py

@@ -59,7 +59,9 @@ def test_convert_output_file(self, tmp_path):
         json_file.write_text(json.dumps({"name": "test"}))
         out_file = tmp_path / "out.sql"
 
-        result = runner.invoke(app, ["convert", str(json_file), "--output", str(out_file)])
+        result = runner.invoke(
+            app, ["convert", str(json_file), "--output", str(out_file)]
+        )
         assert result.exit_code == 0
         assert out_file.exists()
         content = out_file.read_text()
@@ -117,14 +119,18 @@ def test_convert_schema_only_with_flatten(self, tmp_path):
         json_file = tmp_path / "nested.json"
         json_file.write_text(json.dumps(data))
 
-        result = runner.invoke(app, ["convert", str(json_file), "--schema-only", "--flatten"])
+        result = runner.invoke(
+            app, ["convert", str(json_file), "--schema-only", "--flatten"]
+        )
         assert result.exit_code == 0
         assert "CREATE TABLE" in result.stdout
         assert "INSERT INTO" not in result.stdout
 
     def test_convert_stdin(self):
         """Read JSON from stdin."""
-        result = runner.invoke(app, ["convert"], input=json.dumps({"name": "stdin_test"}))
+        result = runner.invoke(
+            app, ["convert"], input=json.dumps({"name": "stdin_test"})
+        )
         assert result.exit_code == 0
         assert "'stdin_test'" in result.stdout
 
@@ -186,6 +192,7 @@ def test_mcp_import_error_handled_gracefully(self):
         import builtins
         import sys
         import unittest.mock as mock
+
         # Remove click_to_mcp from cache so the import statement is executed
         old_mod = sys.modules.pop("click_to_mcp", None)
 
@@ -210,7 +217,11 @@ def test_mcp_command_exists(self):
         """mcp command is registered and responds to --help."""
         result = runner.invoke(app, ["mcp", "--help"])
         assert result.exit_code == 0
-        assert "MCP" in result.stdout or "Model Context" in result.stdout or "stdio" in result.stdout
+        assert (
+            "MCP" in result.stdout
+            or "Model Context" in result.stdout
+            or "stdio" in result.stdout
+        )
 
 
 class TestCLIErrorHandling:
@@ -220,7 +231,12 @@ def test_no_args_shows_help(self):
         """Running without args shows help."""
         result = runner.invoke(app)
         # Typer with no_args_is_help may exit 0 or 2 depending on version
-        assert "Usage:" in result.stdout or "Usage:" in result.stderr or "Convert" in result.stdout or "Convert" in result.stderr
+        assert (
+            "Usage:" in result.stdout
+            or "Usage:" in result.stderr
+            or "Convert" in result.stdout
+            or "Convert" in result.stderr
+        )
 
     def test_convert_array_of_objects(self, tmp_path):
         """Convert array of objects via CLI."""
@@ -249,7 +265,9 @@ def test_convert_boolean_values(self, tmp_path):
         json_file.write_text(json.dumps(data))
 
         # Postgres
-        result = runner.invoke(app, ["convert", str(json_file), "--dialect", "postgres"])
+        result = runner.invoke(
+            app, ["convert", str(json_file), "--dialect", "postgres"]
+        )
         assert result.exit_code == 0
         assert "TRUE" in result.stdout
         assert "FALSE" in result.stdout