harn-modules 0.7.29

Cross-file module graph and import resolution utilities for Harn
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

import { filter_nil } from "std/collections"
import { merge } from "std/json"
import { wait_for } from "std/monitors"

var linear_connector_config = {}

pub fn configure(config) {
  linear_connector_config = filter_nil(config ?? {})
  return linear_connector_config
}

pub fn reset() {
  linear_connector_config = {}
}

fn __call(method, params = {}) {
  return connector_call("linear", method, filter_nil(merge(linear_connector_config, params ?? {})))
}

pub fn list_issues(filter = nil, options = nil) {
  return __call("list_issues", filter_nil(options ?? {} + {filter: filter}))
}

pub fn update_issue(id, changes, options = nil) {
  return __call("update_issue", options ?? {} + {id: id, changes: changes})
}

pub fn create_comment(issue_id, body, options = nil) {
  return __call("create_comment", options ?? {} + {issue_id: issue_id, body: body})
}

pub fn search(query, options = nil) {
  return __call("search", options ?? {} + {query: query})
}

pub fn graphql(query, variables = nil, options = nil) {
  return __call("graphql", filter_nil(options ?? {} + {query: query, variables: variables}))
}

fn __linear_event(log_event) {
  return log_event?.payload?.event
}

fn __linear_payload(log_event) {
  return __linear_event(log_event)?.provider_payload
}

fn __linear_issue_matches(payload, issue_id) {
  return issue_id == nil
    || payload?.issue?.id == issue_id
    || payload?.issue?.identifier == issue_id
    || payload?.issue?.number == issue_id
}

fn __linear_state_matches(issue, target_state) {
  return target_state == nil
    || issue?.state?.id == target_state
    || issue?.state?.name == target_state
    || issue?.state?.type == target_state
}

/** issue_state_source. */
pub fn issue_state_source(issue_id, target_state = nil, options = nil) {
  return {
    label: "linear.issue_state:" + to_string(issue_id) + ":" + to_string(target_state ?? "*"),
    prefers_push: true,
    poll: { ctx ->
    let payload = __linear_payload(ctx?.last_push_event)
    if payload != nil && __linear_issue_matches(payload, issue_id) {
      return {
    matched: __linear_state_matches(payload.issue, target_state),
    issue: payload.issue,
    state: payload?.issue?.state,
    event: payload,
  }
    }
    let response = graphql(
    "query HarnMonitorIssue($id: String!) { issue(id: $id) { id identifier title state { id name type } } }",
    {id: issue_id},
    options,
  )
    let issue = response?.data?.issue
    return {
    matched: __linear_state_matches(issue, target_state),
    issue: issue,
    state: issue?.state,
    event: nil,
  }
  },
    push_filter: { log_event ->
    let event = __linear_event(log_event)
    let payload = __linear_payload(log_event)
    return event?.provider == "linear"
    && event?.kind == "issue"
    && __linear_issue_matches(payload, issue_id)
    && __linear_state_matches(payload?.issue, target_state)
  },
  }
}

/** wait_until_issue_state. */
pub fn wait_until_issue_state(issue_id, target_state, options = nil) {
  return wait_for(
    merge(
    options ?? {},
    {source: issue_state_source(issue_id, target_state, options), condition: { state -> state.matched }},
  ),
  )
}