> ## Documentation Index
> Fetch the complete documentation index at: https://grandcentral.backbase.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Set up the project

> Naming conventions, project layout, prerequisites, connector styles, and first-time configuration

After provisioning your repository from `grandcentral-connector-template` (see [Request repository creation](/platform/developer-guides/get-started/overview#request-repository-creation)), the provisioning workflow has already:

* Set the `pom.xml` artifact ID equal to the repository name
* Set the initial project version to `0.1.0-SNAPSHOT`
* Cleaned `CHANGELOG.md`
* Run `mvn clean verify` to confirm the repository is buildable

Before you scaffold operations, work through the following conventions, layout, and configuration steps.

## Naming conventions

Use these names consistently across the project. Camel-K relies on several of them at runtime.

* **Repository and artifact**: `gc-{vendor}-{domain}-connector`. The repository name and the Maven `artifactId` are identical.
* **Inbound connectors**: for vendor-initiated callbacks or events into Grand Central, append the `-inbound-connector` suffix: `gc-{vendor}-{domain}-inbound-connector`.
* **Connector class**: `{Vendor}{Domain}Connector` extending `org.apache.camel.builder.RouteBuilder`. The Java filename must match the class name exactly.
* **Java package**: `com.backbase.gc.connector`.
* **Route IDs**:
  * Never call `.routeId(...)`. Camel-K assigns IDs automatically; manual IDs cause Kubernetes deployment conflicts.
  * Use `direct://operationId` with a double slash for routes that map 1:1 to an OpenAPI `operationId`.
  * Use `direct:internalRouteName` with a single slash for internal sub-routes.
* **Resource files in `src/main/resources/`**:
  * `{op}-{entity}-schema-validation.json`: Draft-07 JSON Schema
  * `{op}-{entity}-request-transformation.json`: JOLT request spec
  * `{op}-{entity}-response-transformation.json`: JOLT response spec
  * `{op}-{entity}-request-transformation.xslt`: XSLT request stylesheet for SOAP
  * `{op}-{entity}-response-transformation.xslt`: XSLT response stylesheet for SOAP
* **Test classes in `src/test/java/com/backbase/gc/connector/`**:
  * `{Vendor}{Domain}ConnectorTest.java`: route integration test
  * `{Op}{Entity}TransformationTest.java`: JOLT/XSLT unit test
  * `{Op}{Entity}SchemaValidationTest.java`: JSON Schema unit test

## Project layout

```text theme={"system"}
pom.xml
src/
├── main/
│   ├── java/com/backbase/gc/connector/
│   │   └── {Vendor}{Domain}Connector.java
│   └── resources/
│       ├── application.properties
│       ├── {op}-{entity}-schema-validation.json
│       ├── {op}-{entity}-request-transformation.json
│       └── {op}-{entity}-response-transformation.json
└── test/
    ├── java/com/backbase/gc/connector/
    │   ├── {Vendor}{Domain}ConnectorTest.java
    │   ├── {Op}{Entity}TransformationTest.java
    │   └── {Op}{Entity}SchemaValidationTest.java
    └── resources/
        ├── mock-{entity}-{scenario}-response.json
        └── expected-{op}-{entity}-response.json
```

## Connector styles

Three connector styles exist. The vendor's integration type determines which to use.

| Style           | When to use                                                   | Transformation | HTTP kamelet                                                                     |
| --------------- | ------------------------------------------------------------- | -------------- | -------------------------------------------------------------------------------- |
| REST/JSON       | Vendor exposes a REST API with JSON                           | JOLT (`.json`) | `gc-http-caller`                                                                 |
| SOAP/XML        | Vendor exposes a SOAP/WSDL API with XML                       | XSLT (`.xslt`) | `{vendor}-api-caller` (from vendor SDK if available, otherwise create a new one) |
| Event / Generic | Pull from a third-party REST API and push to ASB (or polling) | JOLT (`.json`) | `gc-http-caller` (GET to source, POST to ASB)                                    |

## First-time configuration checklist

| Step | What to do                                                                             | Where                                           |
| ---- | -------------------------------------------------------------------------------------- | ----------------------------------------------- |
| 1    | Set `api.artifact-id` to the Grand Central OpenAPI spec the connector implements       | `pom.xml` `<properties>`                        |
| 2    | Set `api.artifact-version` to the spec version chosen earlier                          | `pom.xml` `<properties>`                        |
| 3    | Align the connector project version's MAJOR.MINOR with the spec MAJOR.MINOR            | `pom.xml` `<version>`                           |
| 4    | Set the `grandcentral-bom` parent version chosen earlier                               | `pom.xml` `<parent>`                            |
| 5    | Add the vendor SDK dependency for SOAP styles, or none for pure REST                   | `pom.xml` `<dependencies>`                      |
| 6    | Configure your local `~/.m2/settings.xml` to authenticate against the JFrog repository | Local Maven settings (Optional if done already) |

Pin the OpenAPI spec from `pom.xml`:

```xml theme={"system"}
<properties>
    <api.artifact-id>grandcentral-{domain}-api</api.artifact-id>
    <api.artifact-version>2.0.0</api.artifact-version>
</properties>
```

The `camel-restdsl-openapi-plugin`, inherited from `grandcentral-bom`, reads that spec at build time, generates the Camel REST DSL, and wires it to your `direct://...` routes.

## Next step

With the project scaffolded and pinned, move on to the route layout. See [Anatomy of a connector](/platform/developer-guides/build/anatomy-of-a-connector).