@teamkeel/wasm 0.0.1

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,70 @@
+export function format(schema: string): Promise<string>;
+
+export function validate(req: ValidateRequest): Promise<ValidationResult>;
+
+export function completions(
+  req: GetCompletionsRequest
+): Promise<CompletionResult>;
+
+export function getDefinition(
+  req: GetDefinitionRequest
+): Promise<DefinitionResult>;
+
+export interface DefinitionResult {
+  schema?: Position;
+  function?: { name: string };
+}
+
+export interface SchemaDefinition {
+  schema: SchemaDefinition;
+}
+
+export interface GetCompletionsRequest {
+  position: Position;
+  schemaFiles: SchemaFile[];
+  config?: string;
+}
+
+export interface GetDefinitionRequest {
+  position: Position;
+  schemaFiles: SchemaFile[];
+}
+
+export interface ValidateRequest {
+  schemaFiles: SchemaFile[];
+  config?: string;
+}
+
+export interface SchemaFile {
+  filename: string;
+  contents: string;
+}
+
+export interface Position {
+  filename: string;
+  line: number;
+  column: number;
+}
+
+export interface CompletionItem {
+  description: string;
+  label: string;
+  insertText: string;
+  kind: string;
+}
+
+export interface CompletionResult {
+  completions: CompletionItem[];
+}
+
+export interface ValidationError {
+  code: string;
+  pos: Position;
+  endPos: Position;
+  hint: string;
+  message: string;
+}
+
+export interface ValidationResult {
+  errors: ValidationError[];
+}

package/index.js

@@ -0,0 +1,43 @@
+require("./lib/wasm_exec_node");
+
+const { wasm } = require("./dist/wasm.js");
+
+async function keel() {
+  if (globalThis.keel) {
+    return globalThis.keel;
+  }
+
+  const go = new globalThis.Go();
+
+  const wasmModule = await WebAssembly.instantiate(wasm, go.importObject);
+  go.run(wasmModule.instance);
+
+  return globalThis.keel;
+}
+
+async function format() {
+  const api = await keel();
+  return api.format(...arguments);
+}
+
+async function validate() {
+  const api = await keel();
+  return api.validate(...arguments);
+}
+
+async function completions() {
+  const api = await keel();
+  return api.completions(...arguments);
+}
+
+async function getDefinition() {
+  const api = await keel();
+  return api.getDefinition(...arguments);
+}
+
+module.exports = {
+  format,
+  validate,
+  completions,
+  getDefinition,
+};

package/index.test.ts

@@ -0,0 +1,219 @@
+import { format, validate, completions, getDefinition } from "./index";
+import { test, expect } from "vitest";
+
+const configFile = `
+environment:
+  default:
+    - name: "TEST"
+      value: "test"
+
+  staging:
+    - name: "TEST_2"
+      value: "test2"
+
+secrets:
+  - name: API_KEY
+    required:
+      - "production"
+`;
+
+test("format", async () => {
+  const schema = `model Person { fields { name Text } }`;
+  const formatted = await format(schema);
+  expect(formatted).toEqual(`model Person {
+    fields {
+        name Text
+    }
+}
+`);
+});
+
+test("format - invalid schema", async () => {
+  const schema = `model    Person    {`;
+  const formatted = await format(schema);
+  expect(formatted).toEqual(schema);
+});
+
+test("completions", async () => {
+  const schema = `model Person {
+    fields { 
+        name Te 
+    }
+}`;
+  const result = await completions({
+    schemaFiles: [
+      {
+        filename: "schema.keel",
+        contents: schema,
+      },
+    ],
+    position: {
+      filename: "schema.keel",
+      line: 3,
+      column: 16,
+    },
+  });
+
+  expect(result.completions.map((x) => x.label)).toContain("Text");
+});
+
+test("completions - multi file", async () => {
+  const result = await completions({
+    schemaFiles: [
+      {
+        filename: "schema.keel",
+        contents: `
+model Person {
+  fields { 
+    name 
+  }
+}`,
+      },
+      {
+        filename: "other.keel",
+        contents: `
+enum Category {
+  Sport
+  Finance
+}
+        `,
+      },
+    ],
+    position: {
+      filename: "schema.keel",
+      line: 4,
+      column: 10,
+    },
+  });
+
+  expect(result.completions.map((x) => x.label)).toContain("Category");
+});
+
+test("completions - with config", async () => {
+  const result = await completions({
+    schemaFiles: [
+      {
+        filename: "schema.keel",
+        contents: `
+model Person {
+  @permission(
+    expression: ctx.secrets.
+  )
+}`,
+      },
+    ],
+    position: {
+      filename: "schema.keel",
+      line: 4,
+      column: 29,
+    },
+    config: configFile,
+  });
+
+  expect(result.completions.map((x) => x.label)).toContain("API_KEY");
+});
+
+test("validate", async () => {
+  const schema = `model Person {
+    fields { 
+        name Foo
+    }
+}`;
+  const { errors } = await validate({
+    schemaFiles: [{ filename: "schema.keel", contents: schema }],
+    config: configFile,
+  });
+
+  expect(errors[0].message).toEqual("field name has an unsupported type Foo");
+});
+
+test("validate - multi file", async () => {
+  const schemaA = `model Customer {
+    fields { 
+        orders Order[]
+    }
+}`;
+  const schemaB = `model Order {
+  fields { 
+      customer Customer
+  }
+}`;
+  const { errors } = await validate({
+    schemaFiles: [
+      { filename: "customer.keel", contents: schemaA },
+      { filename: "hobby.keel", contents: schemaB },
+    ],
+  });
+
+  expect(errors.length).toEqual(0);
+});
+
+test("validate - invalid schema", async () => {
+  const schema = `model Person {
+    fields {`;
+  const { errors } = await validate({
+    schemaFiles: [{ filename: "schema.keel", contents: schema }],
+    config: configFile,
+  });
+
+  expect(errors[0].code).toEqual("E025");
+  expect(errors[0].message).toEqual(` unexpected token "<EOF>" (expected "}")`);
+});
+
+test("getDefinition", async () => {
+  const result = await getDefinition({
+    position: {
+      line: 7,
+      column: 21,
+      filename: "myschema.keel",
+    },
+    schemaFiles: [
+      {
+        filename: "myschema.keel",
+        contents: `
+model Person {
+  fields {
+    name Text
+  }
+  operations {
+    list getPeople(name) 
+  }
+}
+        `,
+      },
+    ],
+  });
+
+  expect(result).toEqual({
+    function: null,
+    schema: {
+      filename: "myschema.keel",
+      line: 4,
+      column: 5,
+    },
+  });
+});
+
+test("getDefinition - no result", async () => {
+  const result = await getDefinition({
+    position: {
+      line: 1,
+      column: 1,
+      filename: "myschema.keel",
+    },
+    schemaFiles: [
+      {
+        filename: "myschema.keel",
+        contents: `
+model Person {
+  fields {
+    name Text
+  }
+}
+        `,
+      },
+    ],
+  });
+
+  expect(result).toBeNull();
+});

package/lib/main.go

@@ -0,0 +1,285 @@
+//go:build wasm
+
+package main
+
+import (
+	"encoding/json"
+	"syscall/js"
+
+	"github.com/teamkeel/keel/config"
+	"github.com/teamkeel/keel/schema"
+	"github.com/teamkeel/keel/schema/completions"
+	"github.com/teamkeel/keel/schema/definitions"
+	"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),
+		"getDefinition": js.FuncOf(getDefinition),
+	}))
+}
+
+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)
+}
+
+// Expected argument to definitions API:
+//
+//	{
+//		position: {
+//			filename: "",
+//			line: 1,
+//			column: 1,
+//		},
+//		schemaFiles: [
+//			{
+//				filename: "",
+//				contents: "",
+//			},
+//		],
+//		config: "",
+//	}
+func provideCompletions(this js.Value, args []js.Value) any {
+	return newPromise(func() (any, error) {
+		positionArg := args[0].Get("position")
+		pos := &node.Position{
+			Filename: positionArg.Get("filename").String(),
+			Line:     positionArg.Get("line").Int(),
+			Column:   positionArg.Get("column").Int(),
+		}
+
+		schemaFilesArg := args[0].Get("schemaFiles")
+		schemaFiles := []*reader.SchemaFile{}
+		for i := 0; i < schemaFilesArg.Length(); i++ {
+			f := schemaFilesArg.Index(i)
+			schemaFiles = append(schemaFiles, &reader.SchemaFile{
+				FileName: f.Get("filename").String(),
+				Contents: f.Get("contents").String(),
+			})
+		}
+
+		configSrc := args[0].Get("config")
+		var cfg *config.ProjectConfig
+		if configSrc.Truthy() {
+			// We don't care about errors here, if we can get a config object
+			// back we'll use it, if not then we'll run validation without it
+			cfg, _ = config.LoadFromBytes([]byte(configSrc.String()))
+		}
+
+		completions := completions.Completions(schemaFiles, pos, cfg)
+
+		untypedCompletions := toUntypedArray(completions)
+
+		return map[string]any{
+			"completions": js.ValueOf(untypedCompletions),
+		}, nil
+	})
+}
+
+// Expected argument to definitions API:
+//
+//	{
+//		position: {
+//			filename: "",
+//			line: 1,
+//			column: 1,
+//		},
+//		schemaFiles: [
+//			{
+//				filename: "",
+//				contents: "",
+//			},
+//		],
+//	}
+func getDefinition(this js.Value, args []js.Value) any {
+	return newPromise(func() (any, error) {
+		positionArg := args[0].Get("position")
+		pos := definitions.Position{
+			Filename: positionArg.Get("filename").String(),
+			Line:     positionArg.Get("line").Int(),
+			Column:   positionArg.Get("column").Int(),
+		}
+
+		schemaFilesArg := args[0].Get("schemaFiles")
+		schemaFiles := []*reader.SchemaFile{}
+		for i := 0; i < schemaFilesArg.Length(); i++ {
+			f := schemaFilesArg.Index(i)
+			schemaFiles = append(schemaFiles, &reader.SchemaFile{
+				FileName: f.Get("filename").String(),
+				Contents: f.Get("contents").String(),
+			})
+		}
+
+		def := definitions.GetDefinition(schemaFiles, pos)
+		if def == nil {
+			return nil, nil
+		}
+
+		return toMap(def)
+	})
+}
+
+func formatSchema(this js.Value, args []js.Value) any {
+	return newPromise(func() (any, error) {
+		src := args[0].String()
+		ast, err := parser.Parse(&reader.SchemaFile{
+			FileName: "schema.keel",
+			Contents: src,
+		})
+		if err != nil {
+			// if the schema can't be parsed then just return it as-is
+			return src, nil
+		}
+
+		return format.Format(ast), nil
+	})
+}
+
+// Expected argument to validate API:
+//
+//	{
+//		schemaFiles: [
+//			{
+//				filename: "",
+//				contents: "",
+//			},
+//		],
+//		config: "<YAML config file>"
+//	}
+//
+// The config file source is optional.
+func validate(this js.Value, args []js.Value) any {
+	return newPromise(func() (any, error) {
+
+		schemaFilesArg := args[0].Get("schemaFiles")
+		schemaFiles := []reader.SchemaFile{}
+		for i := 0; i < schemaFilesArg.Length(); i++ {
+			f := schemaFilesArg.Index(i)
+			schemaFiles = append(schemaFiles, reader.SchemaFile{
+				FileName: f.Get("filename").String(),
+				Contents: f.Get("contents").String(),
+			})
+		}
+
+		builder := schema.Builder{}
+
+		configSrc := args[0].Get("config")
+		if configSrc.Truthy() {
+			// We don't care about errors here, if we can get a config object
+			// back we'll use it, if not then we'll run validation without it
+			config, _ := config.LoadFromBytes([]byte(configSrc.String()))
+			if config != nil {
+				builder.Config = config
+			}
+		}
+
+		_, err := builder.MakeFromInputs(&reader.Inputs{
+			SchemaFiles: schemaFiles,
+		})
+
+		if err != nil {
+			errs, ok := err.(*errorhandling.ValidationErrors)
+			if !ok {
+				return nil, err
+			}
+
+			validationErrors, err := toMap(errs)
+			if err != nil {
+				return nil, err
+			}
+
+			return validationErrors, nil
+		}
+
+		return map[string]any{
+			"errors": []any{},
+		}, nil
+	})
+}
+
+// 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
+}