mirror of
https://github.com/DeBrosOfficial/orama.git
synced 2026-06-16 23:14:13 +00:00
bd26af2cb1
- Add "orama" to the list of host module registration names to support
common developer intuition and prevent instantiation errors.
- Add comprehensive regression tests to ensure all aliases ("env",
"host", "orama") remain registered.
- Update SDK documentation to clarify import conventions and alias
support.
94 lines
3.0 KiB
Go
94 lines
3.0 KiB
Go
// Package fn provides a tiny, TinyGo-compatible SDK for writing Orama serverless functions.
|
|
//
|
|
// A function is a Go program that reads JSON input from stdin and writes JSON output to stdout.
|
|
// This package handles the boilerplate so you only write your handler logic.
|
|
//
|
|
// Example:
|
|
//
|
|
// package main
|
|
//
|
|
// import "github.com/DeBrosOfficial/network/sdk/fn"
|
|
//
|
|
// func main() {
|
|
// fn.Run(func(input []byte) ([]byte, error) {
|
|
// var req struct{ Name string `json:"name"` }
|
|
// fn.ParseJSON(input, &req)
|
|
// if req.Name == "" { req.Name = "World" }
|
|
// return fn.JSON(map[string]string{"greeting": "Hello, " + req.Name + "!"})
|
|
// })
|
|
// }
|
|
//
|
|
// # Host functions and WASM imports
|
|
//
|
|
// Functions written using only this SDK do NOT need any //go:wasmimport
|
|
// directives — input flows through stdin and output through stdout, both
|
|
// of which the runtime provides via WASI.
|
|
//
|
|
// If you need direct access to host functions (db_query, pubsub_publish,
|
|
// http_fetch, etc.) declare them via //go:wasmimport. The CANONICAL host
|
|
// module name is "env":
|
|
//
|
|
// //go:wasmimport env db_query
|
|
// func dbQuery(queryPtr, queryLen, argsPtr, argsLen uint32) uint64
|
|
//
|
|
// For backward compatibility, the runtime ALSO exposes the same export
|
|
// set under the names "host" and "orama". You may use any of the three
|
|
// interchangeably — they resolve to identical function tables. New code
|
|
// should prefer "env" because it matches the WASI/TinyGo convention and
|
|
// what every example in this SDK uses.
|
|
//
|
|
// //go:wasmimport env db_query // canonical (preferred)
|
|
// //go:wasmimport host db_query // alias, supported indefinitely
|
|
// //go:wasmimport orama db_query // alias, supported indefinitely
|
|
//
|
|
// All three names produce identical runtime behavior. If you see the
|
|
// runtime error `module[X] not instantiated`, your function imported
|
|
// from a name other than the three above — fix the directive.
|
|
package fn
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
)
|
|
|
|
// HandlerFunc is the signature for a serverless function handler.
|
|
// It receives the raw JSON input bytes and returns raw JSON output bytes.
|
|
type HandlerFunc func(input []byte) (output []byte, err error)
|
|
|
|
// Run reads input from stdin, calls the handler, and writes the output to stdout.
|
|
// If the handler returns an error, it writes a JSON error response to stdout and exits with code 1.
|
|
func Run(handler HandlerFunc) {
|
|
input, err := io.ReadAll(os.Stdin)
|
|
if err != nil {
|
|
writeError(fmt.Sprintf("failed to read input: %v", err))
|
|
os.Exit(1)
|
|
}
|
|
|
|
output, err := handler(input)
|
|
if err != nil {
|
|
writeError(err.Error())
|
|
os.Exit(1)
|
|
}
|
|
|
|
if output != nil {
|
|
os.Stdout.Write(output)
|
|
}
|
|
}
|
|
|
|
// JSON marshals a value to JSON bytes. Convenience wrapper around json.Marshal.
|
|
func JSON(v interface{}) ([]byte, error) {
|
|
return json.Marshal(v)
|
|
}
|
|
|
|
// ParseJSON unmarshals JSON bytes into a value. Convenience wrapper around json.Unmarshal.
|
|
func ParseJSON(data []byte, v interface{}) error {
|
|
return json.Unmarshal(data, v)
|
|
}
|
|
|
|
func writeError(msg string) {
|
|
resp, _ := json.Marshal(map[string]string{"error": msg})
|
|
os.Stdout.Write(resp)
|
|
}
|