@teamkeel/wasm 0.240.3 → 0.240.4

package/encodeWasm.js

@@ -0,0 +1,30 @@
+const fs = require("fs");
+
+const wasmCode = fs.readFileSync(__dirname + "/dist/keel.wasm");
+const encoded = Buffer.from(wasmCode, "binary").toString("base64");
+
+fs.writeFileSync(
+  __dirname + "/dist/wasm.js",
+  `
+function asciiToBinary(str) {
+  if (typeof atob === "function") {
+    // this works in the browser
+    return atob(str);
+  } else {
+    // this works in node
+    return new Buffer(str, "base64").toString("binary");
+  }
+}
+
+function decode(encoded) {
+  var binaryString = asciiToBinary(encoded);
+  var bytes = new Uint8Array(binaryString.length);
+  for (var i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes.buffer;
+}
+
+module.exports.wasm = decode("${encoded}");
+`
+);

package/index.d.ts

@@ -0,0 +1,53 @@
+export function keel(): KeelAPI;
+
+export interface KeelAPI {
+  format: (schemaString: string) => Promise<string>;
+  validate: (
+    schemaString: string,
+    options?: ValidateOptions
+  ) => Promise<ValidationResult>;
+  completions: (
+    schemaString: string,
+    position: SimplePosition
+  ) => Promise<CompletionResult>;
+}
+
+export interface ValidateOptions {
+  color: boolean;
+}
+
+export interface SimplePosition {
+  column: number;
+  line: number;
+}
+
+export interface Position extends SimplePosition {
+  filename: string;
+  offset: number;
+}
+
+export interface CompletionItem {
+  description: string;
+  label: string;
+  insertText: string;
+  kind: string;
+}
+
+export interface CompletionResult {
+  completions: CompletionItem[];
+  ast: any;
+}
+
+export interface ValidationError {
+  code: string;
+  pos: Position;
+  endPos: Position;
+  hint: string;
+  shortMessage: string;
+  message: string;
+}
+
+export interface ValidationResult {
+  errors: ValidationError[];
+  ast: any;
+}

package/index.js

@@ -0,0 +1,65 @@
+// Needed for wasm_exec
+globalThis.crypto = require("crypto");
+
+const { transformKeys } = require("./transformKeys");
+const { wasm } = require("./dist/wasm.js");
+require("./lib/wasm_exec");
+
+const instantiate = async () => {
+  const go = new globalThis.Go();
+
+  const wasmModule = await WebAssembly.instantiate(wasm, go.importObject);
+  go.run(wasmModule.instance);
+
+  return globalThis.keel;
+};
+
+const keel = () => {
+  const validate = async (schemaString, opts) => {
+    const api = await instantiate();
+
+    const result = api.validate(schemaString, opts || {});
+
+    if (result.error) {
+      return {
+        errors: [result.error],
+        ast: null,
+      };
+    }
+
+    if (!result || !result.validationErrors) {
+      return {
+        errors: [result.error],
+        ast: null,
+      };
+    }
+
+    const {
+      validationErrors: { Errors: errors },
+      ast,
+    } = result;
+
+    const transformedErrors = (errors || []).map((err) => transformKeys(err));
+
+    return {
+      errors: transformedErrors,
+      ast: ast,
+    };
+  };
+
+  const format = async (schemaString) => {
+    const api = await instantiate();
+
+    return api.format(schemaString);
+  };
+
+  const completions = async (schemaString, position) => {
+    const api = await instantiate();
+
+    return api.completions(schemaString, position);
+  };
+
+  return { validate, format, completions };
+};
+
+module.exports.keel = keel;

package/index.test.ts

@@ -0,0 +1,41 @@
+import { keel } from "./index";
+import { test, expect } from "vitest";
+
+test("format", async () => {
+  const api = keel();
+  const schema = `model Person { fields { name Text } }`;
+  const formatted = await api.format(schema);
+  expect(formatted).toEqual(`model Person {
+    fields {
+        name Text
+    }
+}
+`);
+});
+
+test("completions", async () => {
+  const api = keel();
+  const schema = `model Person {
+    fields { 
+        name Te 
+    }
+}`;
+  const { completions } = await api.completions(schema, {
+    line: 3,
+    column: 16,
+  });
+
+  expect(completions.map((x) => x.label)).toContain("Text");
+});
+
+test("validate", async () => {
+  const api = keel();
+  const schema = `model Person {
+    fields { 
+        name Foo
+    }
+}`;
+  const { errors } = await api.validate(schema);
+
+  expect(errors[0].message).toEqual("field name has an unsupported type Foo");
+});

package/lib/main.go

@@ -0,0 +1,266 @@
+//go:build wasm
+
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"syscall/js"
+
+	"github.com/fatih/color"
+	"github.com/graphql-go/graphql/testutil"
+	"github.com/teamkeel/keel/runtime/apis/graphql"
+	"github.com/teamkeel/keel/schema"
+	"github.com/teamkeel/keel/schema/completions"
+	"github.com/teamkeel/keel/schema/format"
+	"github.com/teamkeel/keel/schema/node"
+	"github.com/teamkeel/keel/schema/parser"
+	"github.com/teamkeel/keel/schema/reader"
+	"github.com/teamkeel/keel/schema/validation/errorhandling"
+)
+
+func init() {
+	// we have to declare our functions in an init func otherwise they aren't
+	// available in JS land at the call time.
+	js.Global().Set("keel", js.ValueOf(map[string]any{
+		"validate":          js.FuncOf(validate),
+		"format":            js.FuncOf(formatSchema),
+		"completions":       js.FuncOf(provideCompletions),
+		"getGraphQLSchemas": js.FuncOf(getGraphQLSchemas),
+	}))
+}
+
+func main() {
+	done := make(chan bool)
+	<-done
+}
+
+// newPromise wraps the provided function in a Javascript Promise
+// and returns that promise. It then either resolves or rejects
+// the promise based on whether fn returns an error or not
+func newPromise(fn func() (any, error)) any {
+	handler := js.FuncOf(func(this js.Value, args []js.Value) any {
+		resolve := args[0]
+		reject := args[1]
+
+		go func() {
+			// handle panics
+			defer func() {
+				if r := recover(); r != nil {
+					msg := "panic"
+					switch r.(type) {
+					case string:
+						msg = r.(string)
+					case error:
+						e := r.(error)
+						msg = e.Error()
+					}
+					// err should be an instance of `error`, eg `errors.New("some error")`
+					errorConstructor := js.Global().Get("Error")
+					errorObject := errorConstructor.New(msg)
+					reject.Invoke(errorObject)
+				}
+			}()
+
+			data, err := fn()
+			if err != nil {
+				// err should be an instance of `error`, eg `errors.New("some error")`
+				errorConstructor := js.Global().Get("Error")
+				errorObject := errorConstructor.New(err.Error())
+				reject.Invoke(errorObject)
+			} else {
+				resolve.Invoke(js.ValueOf(data))
+			}
+		}()
+
+		return nil
+	})
+
+	promiseConstructor := js.Global().Get("Promise")
+	return promiseConstructor.New(handler)
+}
+
+func provideCompletions(this js.Value, args []js.Value) any {
+	line := args[1].Get("line").Int()
+	column := args[1].Get("column").Int()
+
+	completions := completions.Completions(args[0].String(), &node.Position{
+		Column: column,
+		Line:   line,
+	})
+
+	untypedCompletions := toUntypedArray(completions)
+
+	return js.ValueOf(
+		map[string]any{
+			"completions": js.ValueOf(untypedCompletions),
+		},
+	)
+}
+
+// getGraphQLSchemas accepts a Keel schema string and returns
+// a map of GraphQL schemas for each API
+func getGraphQLSchemas(this js.Value, args []js.Value) any {
+
+	return newPromise(func() (any, error) {
+		builder := schema.Builder{}
+
+		protoSchema, err := builder.MakeFromInputs(&reader.Inputs{
+			SchemaFiles: []reader.SchemaFile{
+				{
+					FileName: "schema.keel",
+					Contents: args[0].String(),
+				},
+			},
+		})
+		if err != nil {
+			return nil, err
+		}
+
+		res := map[string]any{}
+
+		for _, api := range protoSchema.Apis {
+			handler := graphql.NewHandler(protoSchema, api)
+			body, err := json.Marshal(map[string]string{
+				"query": testutil.IntrospectionQuery,
+			})
+			if err != nil {
+				return nil, err
+			}
+
+			response := handler(&http.Request{
+				URL: &url.URL{
+					Path: "/" + strings.ToLower(api.Name) + "/graphql",
+				},
+				Method: http.MethodPost,
+				Body:   io.NopCloser(bytes.NewReader(body)),
+			})
+
+			if response.Status != 200 {
+				return nil, fmt.Errorf("error introspecting graphql schema: %s", response.Body)
+			}
+
+			res[api.Name] = graphql.ToGraphQLSchemaLanguage(response)
+		}
+
+		return res, nil
+	})
+}
+
+func formatSchema(this js.Value, args []js.Value) any {
+	ast, err := parser.Parse(&reader.SchemaFile{
+		FileName: "schema.keel",
+		Contents: args[0].String(),
+	})
+	if err != nil {
+		// if the schema can't be parsed then just return it as-is
+		return js.ValueOf(args[0].String())
+	}
+
+	return js.ValueOf(format.Format(ast))
+}
+
+// Type definition for this function:
+//
+//	validate(schema: string, options?: {color: boolean})
+func validate(this js.Value, args []js.Value) any {
+
+	if len(args) > 1 {
+		withColor := args[1].Get("color").Truthy()
+		if withColor {
+			color.NoColor = false
+		}
+	}
+
+	schemaFile := reader.SchemaFile{
+		FileName: "schema.keel",
+		Contents: args[0].String(),
+	}
+
+	builder := schema.Builder{}
+	var validationErrors map[string]any
+	var validationOutput string
+
+	_, err := builder.MakeFromInputs(&reader.Inputs{
+		SchemaFiles: []reader.SchemaFile{schemaFile},
+	})
+
+	if err != nil {
+		errs, ok := err.(*errorhandling.ValidationErrors)
+		if ok {
+			validationErrors, err = toMap(errs)
+			if err != nil {
+				return js.ValueOf(map[string]any{
+					"error": err.Error(),
+				})
+			}
+
+			validationOutput, err = errs.ToAnnotatedSchema([]reader.SchemaFile{
+				schemaFile,
+			})
+			if err != nil {
+				return js.ValueOf(map[string]any{
+					"error": err.Error(),
+				})
+			}
+		} else {
+			return js.ValueOf(map[string]any{
+				"error": err.Error(),
+			})
+		}
+	}
+
+	var astMap map[string]any
+	asts := builder.ASTs()
+	if len(asts) > 0 {
+		astMap, err = toMap(asts[0])
+		if err != nil {
+			return js.ValueOf(map[string]any{
+				"error": err.Error(),
+			})
+		}
+	}
+
+	return js.ValueOf(map[string]any{
+		"ast":              astMap,
+		"validationErrors": validationErrors,
+		"validationOutput": validationOutput,
+	})
+}
+
+// js.ValueOf can only marshall map[string]any to a JS object
+// so for structs we need to do the struct->json->map[string]any dance
+func toMap(v any) (map[string]any, error) {
+	b, err := json.Marshal(v)
+	if err != nil {
+		return nil, err
+	}
+
+	var res map[string]any
+	err = json.Unmarshal(b, &res)
+	return res, err
+}
+
+func toUntypedArray(items []*completions.CompletionItem) (i []any) {
+	for _, item := range items {
+		b, err := json.Marshal(item)
+
+		if err != nil {
+			continue
+		}
+		var res any
+		err = json.Unmarshal(b, &res)
+
+		if err != nil {
+			continue
+		}
+		i = append(i, res)
+	}
+
+	return i
+}