@teamkeel/wasm 0.329.0 → 0.330.1

package/index.d.ts

@@ -1,14 +1,9 @@
 export function format(schema: string): Promise<string>;
 
-export function validate(
-  schemaString: string,
-  configFile: string
-): Promise<ValidationResult>;
+export function validate(req: ValidateRequest): Promise<ValidationResult>;
 
 export function completions(
-  schemaString: string,
-  position: SimplePosition,
-  configFile: string
+  req: GetCompletionsRequest
 ): Promise<CompletionResult>;
 
 export function getDefinition(
@@ -24,24 +19,31 @@ 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 SimplePosition {
-  column: number;
-  line: number;
-}
-
-export interface Position extends SimplePosition {
+export interface Position {
   filename: string;
-  offset: number;
+  line: number;
+  column: number;
 }
 
 export interface CompletionItem {

package/index.test.ts

@@ -40,33 +40,121 @@ test("completions", async () => {
         name Te 
     }
 }`;
-  const result = await completions(
-    schema,
-    {
+  const result = await completions({
+    schemaFiles: [
+      {
+        filename: "schema.keel",
+        contents: schema,
+      },
+    ],
+    position: {
+      filename: "schema.keel",
       line: 3,
       column: 16,
     },
-    configFile
-  );
+  });
 
   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(schema, configFile);
+  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(schema, configFile);
+  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 "}")`);
@@ -77,7 +165,6 @@ test("getDefinition", async () => {
     position: {
       line: 7,
       column: 21,
-      offset: 0,
       filename: "myschema.keel",
     },
     schemaFiles: [
@@ -112,7 +199,6 @@ test("getDefinition - no result", async () => {
     position: {
       line: 1,
       column: 1,
-      offset: 0,
       filename: "myschema.keel",
     },
     schemaFiles: [

package/lib/main.go

@@ -78,15 +78,50 @@ func newPromise(fn func() (any, error)) any {
 	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) {
-		line := args[1].Get("line").Int()
-		column := args[1].Get("column").Int()
+		positionArg := args[0].Get("position")
+		pos := &node.Position{
+			Filename: positionArg.Get("filename").String(),
+			Line:     positionArg.Get("line").Int(),
+			Column:   positionArg.Get("column").Int(),
+		}
 
-		completions := completions.Completions(args[0].String(), &node.Position{
-			Column: column,
-			Line:   line,
-		}, args[2].String())
+		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)
 
@@ -155,28 +190,46 @@ func formatSchema(this js.Value, args []js.Value) any {
 	})
 }
 
-// Type definition for this function:
+// Expected argument to validate API:
 //
-//	validate(schema: string)
+//	{
+//		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) {
-		schemaFile := reader.SchemaFile{
-			FileName: "schema.keel",
-			Contents: args[0].String(),
+
+		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{}
 
-		if args[1].Truthy() {
-			config, err := config.LoadFromBytes([]byte(args[1].String()))
-			if err != nil {
-				return nil, err
+		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
 			}
-			builder.Config = config
 		}
 
 		_, err := builder.MakeFromInputs(&reader.Inputs{
-			SchemaFiles: []reader.SchemaFile{schemaFile},
+			SchemaFiles: schemaFiles,
 		})
 
 		if err != nil {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamkeel/wasm",
-  "version": "0.329.0",
+  "version": "0.330.1",
   "description": "A wrapper around the Keel WASM binary",
   "main": "./index.js",
   "types": "./index.d.ts",