added java package

Author: modelorona

.github/dependabot.yml

@@ -21,3 +21,7 @@ updates:
     directory: "/packages/rust" # Location of package manifests
     schedule:
       interval: "weekly"
+  - package-ecosystem: "maven" # See documentation for possible values
+    directory: "/packages/java" # Location of package manifests
+    schedule:
+      interval: "weekly"

.github/workflows/ci.yml

@@ -39,6 +39,14 @@ jobs:
         with:
           python-version: "3.14"
 
+      - name: Setup Java
+        # actions/setup-java@v5
+        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654
+        with:
+          distribution: temurin
+          java-version: "25"
+          cache: maven
+
       - name: Install dependencies
         run: pnpm install --frozen-lockfile
 

.github/workflows/release.yml

@@ -61,6 +61,14 @@ jobs:
         with:
           python-version: "3.14"
 
+      - name: Setup Java
+        # actions/setup-java@v5
+        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654
+        with:
+          distribution: temurin
+          java-version: "25"
+          cache: maven
+
       - name: Install dependencies
         run: pnpm install --frozen-lockfile
 
@@ -114,14 +122,17 @@ jobs:
       - name: Rust crate dry-run
         run: cargo publish --manifest-path packages/rust/Cargo.toml --locked --dry-run
 
+      - name: Build Java package
+        run: mvn -q -f packages/java/pom.xml -DskipTests package
+
       - name: Build Python package
         run: |
           python -m pip install build==1.5.0
           python -m build packages/python
 
       - name: Commit version bump
         run: |
-          git add packages/js/package.json packages/python/pyproject.toml packages/rust/Cargo.toml packages/rust/Cargo.lock
+          git add packages/js/package.json packages/java/pom.xml packages/python/pyproject.toml packages/rust/Cargo.toml packages/rust/Cargo.lock
           git commit -m "release v${{ steps.version.outputs.version }}"
 
       - name: Push version commit

README.md

@@ -10,7 +10,7 @@ SAP HANA, Athena, Spanner, Google Cloud Storage, Azure Blob, Azure Data Lake
 Storage, Azure Files, Azure Cosmos DB, Business Central, TallyPrime, Amazon S3,
 and local file paths.
 
-This repository contains JavaScript, Go, Python, and Rust implementations,
+This repository contains JavaScript, Go, Python, Rust, and Java implementations,
 shared Connparse Definition Specification (CPDS) YAML definitions, and shared
 compatibility fixtures.
 
@@ -20,6 +20,7 @@ compatibility fixtures.
 - Go: `github.com/clidey/connparse/packages/go`
 - Python: `connparse`
 - Rust: `connparse`
+- Java: `io.github.clidey:connparse`
 
 ## Repository Layout
 
@@ -35,14 +36,16 @@ packages/
   go/            Go implementation
   python/        Python implementation
   rust/          Rust crate implementation
+  java/          Java implementation
 ```
 
 ## Install
 
 The JavaScript package has one runtime dependency: `yaml`, used to load CPDS
 definition files. The Go package uses `github.com/goccy/go-yaml` for the same
-CPDS loader API. The Python parser uses the standard library at runtime. The Rust
-crate uses `serde` and `serde_json` for the shared JSON-shaped contract.
+CPDS loader API. The Python and Java parsers use the standard library at
+runtime. The Rust crate uses `serde` and `serde_json` for the shared
+JSON-shaped contract.
 
 ```bash
 npm install @clidey/connparse
@@ -60,6 +63,7 @@ pnpm test
 pnpm test:go
 pnpm test:python
 pnpm test:rust
+pnpm test:java
 pnpm check:package
 ```
 

package.json

@@ -9,12 +9,13 @@
     "verify:definitions": "node tools/verify-definitions.mjs",
     "verify:definitions:strict": "node tools/verify-definitions.mjs --strict-suggestions",
     "sync:versions": "node tools/sync-versions.mjs",
-    "test": "pnpm test:js && pnpm test:go && pnpm test:python && pnpm test:rust",
+    "test": "pnpm test:js && pnpm test:go && pnpm test:python && pnpm test:rust && pnpm test:java",
     "test:js": "pnpm --filter @clidey/connparse test",
     "test:go": "cd packages/go && GOCACHE=$(pwd)/../../.cache/go-build GOMODCACHE=$(pwd)/../../.cache/go-mod go test ./...",
     "test:python": "PYTHONPATH=packages/python/src python3 -m unittest discover -s packages/python/tests",
     "test:rust": "cd packages/rust && CARGO_TARGET_DIR=../../.cache/cargo-target CARGO_HOME=../../.cache/cargo-home cargo test",
-    "check": "pnpm check:versions && pnpm verify:definitions:strict && pnpm check:schemas && pnpm check:conformance && pnpm check:generated && pnpm check:tools && pnpm check:js && pnpm check:go && pnpm check:python && pnpm check:rust",
+    "test:java": "node tools/test-java.mjs",
+    "check": "pnpm check:versions && pnpm verify:definitions:strict && pnpm check:schemas && pnpm check:conformance && pnpm check:generated && pnpm check:tools && pnpm check:js && pnpm check:go && pnpm check:python && pnpm check:rust && pnpm check:java",
     "check:conformance": "node tools/conformance-runner.mjs --quiet",
     "check:generated": "node tools/generate-definitions.mjs --check",
     "check:package": "node tools/package-consumption-test.mjs",
@@ -24,7 +25,8 @@
     "check:js": "pnpm --filter @clidey/connparse check",
     "check:go": "cd packages/go && GOCACHE=$(pwd)/../../.cache/go-build GOMODCACHE=$(pwd)/../../.cache/go-mod go test ./...",
     "check:python": "python3 -m compileall -q packages/python/src packages/python/tests packages/python/scripts && PYTHONPATH=packages/python/src node tools/conformance-runner.mjs --skip-coverage -- python3 packages/python/scripts/conformance.py",
-    "check:rust": "cd packages/rust && CARGO_TARGET_DIR=../../.cache/cargo-target CARGO_HOME=../../.cache/cargo-home cargo fmt --check && CARGO_TARGET_DIR=../../.cache/cargo-target CARGO_HOME=../../.cache/cargo-home cargo test"
+    "check:rust": "cd packages/rust && CARGO_TARGET_DIR=../../.cache/cargo-target CARGO_HOME=../../.cache/cargo-home cargo fmt --check && CARGO_TARGET_DIR=../../.cache/cargo-target CARGO_HOME=../../.cache/cargo-home cargo test",
+    "check:java": "node tools/test-java.mjs"
   },
   "devDependencies": {}
 }

packages/java/README.md

@@ -0,0 +1,84 @@
+# connparse for Java
+
+Connparse parses connection strings from databases, caches, object storage,
+files, and cloud systems into one structured object.
+
+It supports PostgreSQL, MySQL, MariaDB, SQLite, DuckDB, ClickHouse, Redis,
+Memcached, Elasticsearch, MongoDB, CockroachDB, QuestDB, YugabyteDB, TiDB,
+Valkey, Dragonfly, OpenSearch, FerretDB, ElastiCache, DocumentDB, SQL Server,
+Oracle, Snowflake, Cassandra, BigQuery, Redshift, Aurora, Neo4j, Trino,
+Databricks, DynamoDB, StarRocks, SAP HANA, Athena, Spanner, Google Cloud
+Storage, Azure Blob, Azure Data Lake Storage, Azure Files, Azure Cosmos DB,
+Business Central, TallyPrime, Amazon S3, and local file paths.
+
+CPDS means Connparse Definition Specification. The Java package embeds generated
+definitions from the shared CPDS YAML files in `specs/definitions`.
+
+## Usage
+
+```java
+import io.github.clidey.connparse.Connparse;
+import io.github.clidey.connparse.ParseOptions;
+import io.github.clidey.connparse.ParseResult;
+
+ParseResult result = Connparse.parse(
+    "postgres://user:pass@localhost:5432/app?sslmode=require"
+);
+
+if (!result.ok) {
+    System.err.println(result.errors);
+} else {
+    System.out.println(result.value.safe);
+    System.out.println(result.value.resource.name);
+}
+```
+
+The parsed value contains the same top-level fields as the other packages:
+
+```json
+{
+  "scheme": "postgres",
+  "type": "database",
+  "authority": { "host": "localhost", "port": 5432 },
+  "resource": { "type": "database", "name": "app" },
+  "path": "",
+  "query": { "sslmode": "require" },
+  "fragment": null,
+  "credentials": { "username": "user", "password": "pass" },
+  "options": {},
+  "raw": "postgres://user:pass@localhost:5432/app?sslmode=require",
+  "safe": "postgres://user:***@localhost:5432/app?sslmode=require"
+}
+```
+
+## Provider Hints
+
+Some inputs need a provider because the string itself does not identify one:
+
+```java
+ParseResult result = Connparse.parse(
+    "host=db.example.com dbname=app user=alice",
+    new ParseOptions().withProvider("postgres")
+);
+```
+
+## Strict Mode
+
+By default, unknown query parameters become warnings. Strict mode rejects them:
+
+```java
+ParseResult result = Connparse.parse(
+    "postgres://localhost/app?unexpected=1",
+    new ParseOptions().withStrict(true)
+);
+```
+
+## Development
+
+From the repository root:
+
+```bash
+pnpm test:java
+pnpm check:java
+pnpm generate:definitions
+```

packages/java/pom.xml

@@ -0,0 +1,39 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <groupId>io.github.clidey</groupId>
+  <artifactId>connparse</artifactId>
+  <version>0.3.0</version>
+  <packaging>jar</packaging>
+
+  <name>connparse</name>
+  <description>Parse database connection strings, DSNs, URLs, file paths, and cloud storage URIs.</description>
+  <url>https://github.com/clidey/connparse</url>
+
+  <licenses>
+    <license>
+      <name>Apache License 2.0</name>
+      <url>https://www.apache.org/licenses/LICENSE-2.0.txt</url>
+    </license>
+  </licenses>
+
+  <developers>
+    <developer>
+      <id>clidey</id>
+      <name>Clidey</name>
+    </developer>
+  </developers>
+
+  <scm>
+    <connection>scm:git:https://github.com/clidey/connparse.git</connection>
+    <developerConnection>scm:git:ssh://git@github.com/clidey/connparse.git</developerConnection>
+    <url>https://github.com/clidey/connparse</url>
+  </scm>
+
+  <properties>
+    <maven.compiler.release>17</maven.compiler.release>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+  </properties>
+</project>

packages/java/src/main/java/io/github/clidey/connparse/Address.java

@@ -0,0 +1,76 @@
+package io.github.clidey.connparse;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public final class Address {
+    public final String scheme;
+    public final String type;
+    public final Map<String, Object> authority;
+    public final Resource resource;
+    public final String path;
+    public final Map<String, Object> query;
+    public final String fragment;
+    public final Map<String, String> credentials;
+    public final Map<String, Object> options;
+    public final String raw;
+    public final String safe;
+
+    public Address(
+            String scheme,
+            String type,
+            Map<String, Object> authority,
+            Resource resource,
+            String path,
+            Map<String, Object> query,
+            String fragment,
+            Map<String, String> credentials,
+            Map<String, Object> options,
+            String raw,
+            String safe) {
+        this.scheme = scheme == null ? "" : scheme;
+        this.type = type == null ? "unknown" : type;
+        this.authority = new LinkedHashMap<>(authority == null ? Map.of() : authority);
+        this.resource = resource == null ? new Resource("none", null) : resource;
+        this.path = path == null ? "" : path;
+        this.query = new LinkedHashMap<>(query == null ? Map.of() : query);
+        this.fragment = fragment;
+        this.credentials = new LinkedHashMap<>(credentials == null ? Map.of() : credentials);
+        this.options = new LinkedHashMap<>(options == null ? Map.of() : options);
+        this.raw = raw == null ? "" : raw;
+        this.safe = safe == null ? "" : safe;
+    }
+
+    public Map<String, Object> toMap() {
+        Map<String, Object> output = new LinkedHashMap<>();
+        output.put("scheme", scheme);
+        output.put("type", type);
+        output.put("authority", authority);
+        output.put("resource", resource.toMap());
+        output.put("path", path);
+        output.put("query", query);
+        output.put("fragment", fragment);
+        output.put("credentials", credentials);
+        output.put("options", options);
+        output.put("raw", raw);
+        output.put("safe", safe);
+        return output;
+    }
+
+    public static final class Resource {
+        public final String type;
+        public final String name;
+
+        public Resource(String type, String name) {
+            this.type = type == null ? "none" : type;
+            this.name = name;
+        }
+
+        public Map<String, Object> toMap() {
+            Map<String, Object> output = new LinkedHashMap<>();
+            output.put("type", type);
+            output.put("name", name);
+            return output;
+        }
+    }
+}