smg-wasm 1.1.0

WebAssembly runtime and module management for Shepherd Model Gateway
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

package smg:storage;

/// Shared types for storage hook interfaces.
interface storage-hook-types {
    /// A key-value entry from the request context.
    record context-entry {
        key: string,
        value: string,
    }

    /// Identifies which storage operation is being hooked.
    enum operation {
        create-conversation,
        get-conversation,
        update-conversation,
        delete-conversation,
        create-item,
        link-item,
        link-items,
        list-items,
        get-item,
        is-item-linked,
        delete-item,
        store-response,
        get-response,
        delete-response,
        get-response-chain,
        list-identifier-responses,
        delete-identifier-responses,
    }

    /// An extra column name-value pair to persist alongside core data.
    record extra-column {
        name: string,
        value: string,
    }

    /// Result from a before-hook.
    variant before-result {
        /// Continue with the operation, optionally providing extra columns.
        do-continue(list<extra-column>),
        /// Reject the operation with a reason.
        reject(string),
    }
}

/// Before-hook interface: called before a storage operation executes.
interface storage-hook-before {
    use storage-hook-types.{context-entry, operation, before-result};

    /// Called before a storage operation.
    ///
    /// `op` identifies the operation.
    /// `context` contains request-scoped key-value pairs (e.g. tenant ID).
    /// `payload` is the JSON-serialised operation arguments.
    ///
    /// Return `do-continue` to proceed (with optional extra columns)
    /// or `reject` to abort.
    before: func(
        op: operation,
        context: list<context-entry>,
        payload: string,
    ) -> before-result;
}

/// After-hook interface: called after a storage operation succeeds.
interface storage-hook-after {
    use storage-hook-types.{context-entry, operation, extra-column};

    /// Called after a storage operation completes successfully.
    ///
    /// `op` identifies the operation.
    /// `context` contains request-scoped key-value pairs.
    /// `payload` is the original JSON arguments.
    /// `result-json` is the JSON-serialised operation result.
    /// `extra` contains extra columns from the before-hook.
    ///
    /// Returns (possibly modified) extra columns.
    after: func(
        op: operation,
        context: list<context-entry>,
        payload: string,
        result-json: string,
        extra: list<extra-column>,
    ) -> list<extra-column>;
}

world storage-hook {
    export storage-hook-before;
    export storage-hook-after;
}