protoc-gen-ts-temporal 0.0.1

protoc plugin that emits a typed TypeScript Temporal client from temporal.v1.* annotated protos
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

//! Cross-method invariants on a parsed `ServiceModel`.
//!
//! Anything that requires looking at more than one method, or comparing
//! attached refs against declared rpcs, lives here. Single-method shape
//! checks belong in `parse.rs`.

use std::collections::HashSet;

use anyhow::{Result, bail};

use crate::model::*;

pub fn validate(svc: &ServiceModel) -> Result<()> {
    no_name_collisions(svc)?;
    workflows_have_task_queue(svc)?;
    signals_return_empty(svc)?;
    refs_resolve(svc)?;
    Ok(())
}

/// A workflow needs a non-empty resolved task_queue — either set on the
/// workflow itself or inherited from the enclosing service's
/// `ServiceOptions.task_queue` default.
fn workflows_have_task_queue(svc: &ServiceModel) -> Result<()> {
    for w in &svc.workflows {
        if svc.resolved_task_queue(w).is_empty() {
            bail!(
                "{}.{}: workflow {:?} has no task_queue. Set option (temporal.v1.workflow) = {{ task_queue: \"...\" }} on the rpc, or option (temporal.v1.service) = {{ task_queue: \"...\" }} on the service.",
                svc.package,
                svc.service,
                w.rpc_method
            );
        }
    }
    Ok(())
}

/// Workflow, signal, query, update, and activity registered names share the
/// same namespace from a client's perspective — collisions would yield
/// unreachable methods on the generated handle.
fn no_name_collisions(svc: &ServiceModel) -> Result<()> {
    let entries = svc
        .workflows
        .iter()
        .map(|w| {
            (
                w.registered_name.as_deref().unwrap_or(&w.rpc_method),
                "workflow",
            )
        })
        .chain(
            svc.signals
                .iter()
                .map(|s| (s.registered_name.as_str(), "signal")),
        )
        .chain(
            svc.queries
                .iter()
                .map(|q| (q.registered_name.as_str(), "query")),
        )
        .chain(
            svc.updates
                .iter()
                .map(|u| (u.registered_name.as_str(), "update")),
        )
        .chain(
            svc.activities
                .iter()
                .map(|a| (a.registered_name.as_str(), "activity")),
        );

    let mut seen: HashSet<&str> = HashSet::new();
    for (name, kind) in entries {
        if !seen.insert(name) {
            bail!(
                "{}.{}: name {:?} ({}) collides with another method registered name",
                svc.package,
                svc.service,
                name,
                kind
            );
        }
    }
    Ok(())
}

/// Temporal signals are fire-and-forget — they can't return values. The
/// generator special-cases `google.protobuf.Empty` outputs.
fn signals_return_empty(svc: &ServiceModel) -> Result<()> {
    for s in &svc.signals {
        if !s.output_type.is_empty {
            bail!(
                "{}.{}: signal rpc {:?} must return google.protobuf.Empty, got {}",
                svc.package,
                svc.service,
                s.rpc_method,
                s.output_type.full_name
            );
        }
    }
    Ok(())
}

/// Every `WorkflowOptions.{signal,query,update}.ref` must point at a method
/// in the same service with the matching annotation.
fn refs_resolve(svc: &ServiceModel) -> Result<()> {
    let signal_methods: HashSet<&str> = svc.signals.iter().map(|s| s.rpc_method.as_str()).collect();
    let query_methods: HashSet<&str> = svc.queries.iter().map(|q| q.rpc_method.as_str()).collect();
    let update_methods: HashSet<&str> = svc.updates.iter().map(|u| u.rpc_method.as_str()).collect();

    for w in &svc.workflows {
        for r in &w.attached_signals {
            if !signal_methods.contains(r.method.as_str()) {
                bail!(
                    "{}.{}: workflow {:?} references unknown signal ref {:?}",
                    svc.package,
                    svc.service,
                    w.rpc_method,
                    r.method
                );
            }
        }
        for r in &w.attached_queries {
            if !query_methods.contains(r.method.as_str()) {
                bail!(
                    "{}.{}: workflow {:?} references unknown query ref {:?}",
                    svc.package,
                    svc.service,
                    w.rpc_method,
                    r.method
                );
            }
        }
        for r in &w.attached_updates {
            if !update_methods.contains(r.method.as_str()) {
                bail!(
                    "{}.{}: workflow {:?} references unknown update ref {:?}",
                    svc.package,
                    svc.service,
                    w.rpc_method,
                    r.method
                );
            }
        }
    }
    Ok(())
}