Package and Publish Your Standards

Now that you’ve created reusable configuration components, let’s package them so they can be shared across projects and teams. This tutorial shows how to publish your ScheduledGreeting workflow and StandardRepoFiles as a versioned Typeflows package by structuring them for distribution, configuring build files for publishing, and making them available through artifact repositories.

Prerequisites

• Completion of the Writing Reusable Configuration tutorial
• Familiarity with your language’s package manager (Gradle/Maven)
• Access to an artifact repository (GitHub Packages, Maven Central, or local repository)

Step 1: Prepare Your Package

First, let’s move your configurations from the Typeflows export structure into a standard library structure. This transforms them from something that generates files for this repository into a reusable library that other repositories can consume:

class ScheduledGreeting(
	private val name: String,
	private val cronSchedule: Cron,
	private val message: String
) : Builder<Workflow> {

	override fun build() = Workflow(name) {
		on += Schedule {
			cron += cronSchedule
		}

		jobs += Job("greet", UBUNTU_LATEST) {
			steps += RunCommand("echo '$message'")
		}
	}
}

public class ScheduledGreeting implements Builder<Workflow> {
	private final String name;
	private final Cron cronSchedule;
	private final String message;

	public ScheduledGreeting(String name, Cron cronSchedule, String message) {
		this.name = name;
		this.cronSchedule = cronSchedule;
		this.message = message;
	}

	@Override
	public Workflow build() {
		return Workflow.create(name, workflow -> {
			workflow.on.add(Schedule.create(schedule -> {
				schedule.cron.add(cronSchedule);
			}));

			workflow.jobs.add(Job.create("greet", UBUNTU_LATEST, job -> {
				job.steps.add(RunCommand.create("echo " + message));
			}));
		});
	}
}

Additionally, let’s add a StandardRepoFiles configuration that packages common repository files that we don’t want to represent as code:

class StandardRepoFiles : Builder<TypeflowsResources> {
	override fun build() = TypeflowsResources.of(StandardRepoFiles::class.java)
}

public class StandardRepoFiles implements Builder<TypeflowsResources> {
	@Override
	public TypeflowsResources build() {
		return TypeflowsResources.of(StandardRepoFiles.class);
	}
}

And the corresponding resource file that will be packaged:

MIT License

Copyright (c) 2024 Example Corp

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

Notice the structural changes:

From Typeflows Export Structure to Standard Package Structure: We’re moving from the Typeflows-specific layout to the standard package structure for your language, following its established conventions for publishable libraries.

Key Aspects:

1. Standard Package Layout: Using your language’s conventions for publishable libraries
2. Package Namespace: The configurations use a clear namespace following your language’s conventions, making it clear where the code comes from when others import it
3. Builder Pattern: Both ScheduledGreeting and StandardRepoFiles implement Builder<T>, which is the standard pattern for creating reusable Typeflows components
4. Resource Packaging: TypeflowsResources packages files from the associated resource directory into your configuration library

The Builder pattern is crucial because it allows other Typeflows repositories to instantiate your configurations with different parameters while maintaining type safety.

Why the Builder Pattern?

Typeflows treats configurations as data. Your ScheduledGreeting doesn’t become a workflow - it produces workflow data.

This separation means:

• Builders contain logic and parameters
• Configurations are pure data structures
• One builder creates many configuration variations
• Resources are packaged as reusable file collections

This is the “Typeflows Way” - your classes are factories that build configurations, not configurations themselves.

Step 2: Configure Publishing

Next, add build configuration to make your package publishable. This includes metadata like name, version, and dependencies:

plugins {
	kotlin("jvm")
	id("maven-publish")
}

group = "com.example"
artifact = "typeflows-standards"
version = "1.0.0"

repositories {
	mavenCentral()
}

dependencies {
	implementation("io.typeflows:typeflows-github:1.0.0")
}

publishing {
	publications {
		create<MavenPublication>("maven") {
			from(components["java"])

			pom {
				name.set("Typeflows Standards")
				description.set("Reusable Typeflows components for team standardisation")
				url.set("https://github.com/example/typeflows-standards")
			}
		}
	}

	repositories {
		maven {
			name = "GitHubPackages"
			url = uri("https://maven.pkg.github.com/example/typeflows-standards")
			credentials {
				username = System.getenv("GITHUB_ACTOR")
				password = System.getenv("GITHUB_TOKEN")
			}
		}
	}
}

<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 
		 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>com.example</groupId>
	<artifactId>typeflows-standards</artifactId>
	<version>1.0.0</version>
	<packaging>jar</packaging>

	<name>docs.how_to.composing_llm_agent_instructions.Typeflows Standards</name>
	<description>Reusable docs.how_to.composing_llm_agent_instructions.Typeflows components for team standardisation</description>
	<url>https://github.com/example/typeflows-standards</url>

	<properties>
		<maven.compiler.source>21</maven.compiler.source>
		<maven.compiler.target>21</maven.compiler.target>
		<typeflows.version>1.0.0</typeflows.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>io.typeflows</groupId>
			<artifactId>typeflows-github</artifactId>
			<version>${typeflows.version}</version>
		</dependency>
	</dependencies>

	<distributionManagement>
		<repository>
			<id>github</id>
			<name>GitHub Packages</name>
			<url>https://maven.pkg.github.com/example/typeflows-standards</url>
		</repository>
	</distributionManagement>
</project>

Key points in the configuration:

• Package Coordinates: The unique identifier for your package in the repository
• Version: Start with 1.0.0 following semantic versioning
• Typeflows Dependency: Your package depends on Typeflows core libraries
• Publishing Configuration: Specifies where to publish and with what credentials

Step 3: Build and Publish

Now you can build and publish your package:

# Build and publish to repository
./gradlew build publish

# Output:
# > Task :compileKotlin
# > Task :compileJava NO-SOURCE
# > Task :processResources NO-SOURCE
# > Task :classes
# > Task :jar
# > Task :generateMetadataFileForMavenPublication
# > Task :generatePomFileForMavenPublication
# > Task :publishMavenPublicationToGitHubPackagesRepository
# > Task :publish
# 
# BUILD SUCCESSFUL in 3s

# Build and publish to repository
mvn package deploy

# Output:
# [INFO] --- maven-compiler-plugin:3.8.1:compile (default-compile) @ typeflows-standards ---
# [INFO] Changes detected - recompiling the module!
# [INFO] Compiling 1 source file to target/classes
# [INFO] 
# [INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ typeflows-standards ---
# [INFO] Building jar: target/typeflows-standards-1.0.0.jar
# [INFO] 
# [INFO] --- maven-deploy-plugin:2.7:deploy (default-deploy) @ typeflows-standards ---
# [INFO] Uploading to github: https://maven.pkg.github.com/example/typeflows-standards
# [INFO] BUILD SUCCESS

The build process creates a package artifact containing your ScheduledGreeting class, StandardRepoFiles class, and the packaged resource files, and the publish step uploads it to your configured repository.

Conclusion

Your ScheduledGreeting and StandardRepoFiles are now shareable packages, demonstrating the “Share” phase of the Typeflows Cycle.

Key capabilities of your package:

• Type-safe instantiation via Builder pattern
• Resource packaging for reusable file collections
• Semantic versioning for controlled updates
• Standard dependency management