Compose platform → services → workflows

Prerequisites: addressing, dynamic linking, and SpellContract. Run saved Intermediate lesson 26 from a checkout, or unpack the complete collection so its _dynamic_world.py helper stays beside the script.

The application has three categories with separate books and owners:

Category	Owns	Needs from the previous category
`platform`	`ConfigStore`	Nothing
`services`	`ReportService`	`ConfigContract` named `platform`
`workflows`	`ReportWorkflow`	`ReportingContract` named `reporting`

For the first edge, conjure the provider and consumer, link, pull the provider's spell, and meld the service. Repeat the same five steps for the next edge using that completed service as the provider's product.

Read the result

The script asserts that workflow.service is service: the resolved service crosses the second boundary. Its run() result combines the workflow, report, and the region value returned by the platform store. Inspect all three class definitions in the complete linked example alongside the core operations below.

When applying this pattern, give each root an application owner and end those owned runtimes explicitly. Keep the scoped-cleanup pattern beside the composition pattern; construction and shutdown are both part of your design.

The workflow in code

These are the core steps from the saved example. Use its complete linked script for all class definitions and setup.

def main() -> None:
    # One book per CATEGORY - each book is that category's recipe list.
    platform_book = dynamic_spellbook()
    config_id = platform_book.bind(
        spell=ConfigStore, existence="unique",
        spellframe=ConfigContract, binding_name="platform",
    )
    services_book = dynamic_spellbook()
    service_id = services_book.bind(
        spell=ReportService, existence="unique",
        spellframe=ReportingContract, binding_name="reporting",
    )
    workflows_book = dynamic_spellbook()
    workflow_id = workflows_book.bind(spell=ReportWorkflow, existence="unique")

    # ---- EDGE 1: platform feeds services ----
    platform = platform_book.conjure(dynamic=True, name="platform")  # 1) provider
    services = services_book.conjure(dynamic=True, name="services")  # 2) consumer
    platform.link(services)                                          # 3) link AFTER both
    services.add_spell_to_contract(                                  # 4) pull
        spell_id=config_id, conduit=platform, permissions="create",
    )
    service = services.meld(spell_id=service_id)                        # 5) meld after the fact

    # ---- EDGE 2: services feeds workflows (same cycle, one level up) ----
    workflows = workflows_book.conjure(dynamic=True, name="workflows")
    services.link(workflows)
    workflows.add_spell_to_contract(
        spell_id=service_id, conduit=services, permissions="create",
    )
    workflow = workflows.meld(spell_id=workflow_id)

    assert workflow.service is service  # the finished product crossed the edge
    print("category chain resolved:", workflow.run())
    print("factory types were just conduit names:",
          platform.name, "->", services.name, "->", workflows.name)

Runnable examples

Conduit categories as factories — Intermediate 26
Late binding with spellcontract — Intermediate 36
Clusters unique per cluster — Intermediate 25

All intermediate examples · Level contents · Full contents

Canonical page source