Add better error message to VerificationError

README.md

@@ -6,6 +6,9 @@ Type/Service definition language and code generator for json-rpc 2.0. Currently
 | ------- | --------------------------------- |
 | ts-node | Typescript for NodeJS             |
 | ts-esm  | Typescript in ESM format for Deno |
+| rust    | Rust                              |
+| dart    | Dart                              |
+| c#      | C#                                |
 
 ## Usage
 
@@ -23,7 +26,7 @@ enum TestEnum {
 type Test {
   testen: TestEnum;
   someString: string;
-  someNumber: number;
+  someNumber?: number;
   array: string[];
   map: {number, TestEnum};
 }
@@ -44,4 +47,8 @@ Then run the generator like this `jrpc compile test.jrpc -o=ts-node:output/`.
 
 This will generate the Client and Server code in the specified folder.
 
-//TODO: Make Documentation better
+## TODOS
+
+1. Documentation
+2. Null Checks/Enforcements in all languages
+3. More and better tests

examples/import.jrpc

@@ -1,5 +1,5 @@
 type TestAtom {
-   val_number: float;
+   val_number?: float;
-   val_boolean: boolean;
+   val_boolean?: boolean;
-   val_string: string;
+   val_string?: string;
 }

package.json

@@ -1,6 +1,6 @@
 {
    "name": "@hibas123/jrpcgen",
-   "version": "1.2.0",
+   "version": "1.2.6",
    "main": "lib/index.js",
    "license": "MIT",
    "packageManager": "yarn@3.1.1",

src/index.ts

@@ -4,13 +4,15 @@ import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import startCompile, { Target, Targets } from "./process";
 
+const pkg = require("../package.json");
+
 import dbg from "debug";
 const log = dbg("app");
 
 dbg.disable();
 
 yargs(hideBin(process.argv))
-   .version("1.0.0")
+   .version(pkg.version)
    .command(
       "compile <input>",
       "Compile source",

src/ir.ts

@@ -14,6 +14,7 @@ export interface TypeFieldDefinition {
    name: string;
    type: string;
    array: boolean;
+   optional: boolean;
    map?: string;
 }
 
@@ -127,6 +128,7 @@ export default function get_ir(parsed: Parsed): IR {
                type: field.fieldtype,
                array: field.array,
                map: field.map,
+               optional: field.optional,
             };
          });
          steps.push([

src/parser.ts

@@ -16,6 +16,7 @@ export interface ImportStatement extends DefinitionNode {
 export interface TypeFieldStatement extends DefinitionNode {
    type: "type_field";
    name: string;
+   optional: boolean;
    fieldtype: string;
    array: boolean;
    map?: string;
@@ -139,8 +140,7 @@ export default function parse(tokens: Token[], file: string): Parsed {
    const checkTypes = (...types: string[]) => {
       if (types.indexOf(currentToken.type) < 0) {
          throw new ParserError(
-            `Unexpected token value, expected ${types.join(" | ")}, received '${
+            `Unexpected token value, expected ${types.join(" | ")}, received '${currentToken.value
-               currentToken.value
             }'`,
             currentToken
          );
@@ -170,6 +170,11 @@ export default function parse(tokens: Token[], file: string): Parsed {
       const idx = currentToken.startIdx;
       let name = currentToken.value;
       eatToken();
+      let optional = false;
+      if (currentToken.type === "questionmark") {
+         eatToken("?");
+         optional = true;
+      }
       eatToken(":");
 
       let array = false;
@@ -198,6 +203,7 @@ export default function parse(tokens: Token[], file: string): Parsed {
          array,
          map: mapKey,
          location: { file, idx },
+         optional
       };
    };
 
@@ -303,9 +309,9 @@ export default function parse(tokens: Token[], file: string): Parsed {
       eatToken("(");
       let args: string[] = [];
       let first = true;
-      while(currentToken.value !== ")") {
+      while (currentToken.value !== ")") {
-         if(first) {
+         if (first) {
-            first= false;
+            first = false;
          } else {
             eatToken(",");
          }
@@ -399,8 +405,8 @@ export default function parse(tokens: Token[], file: string): Parsed {
       let functions: ServiceFunctionStatement[] = [];
 
       while (currentToken.type !== "curly_close") {
-         let decorators:Decorators = new Map;
+         let decorators: Decorators = new Map;
-         while(currentToken.type == "at") {
+         while (currentToken.type == "at") {
             parseFunctionDecorator(decorators);
          }
 
@@ -427,8 +433,8 @@ export default function parse(tokens: Token[], file: string): Parsed {
 
       let [key] = eatText()
       let value: string = undefined;
-      if(currentToken.type == "string") {
+      if (currentToken.type == "string") {
-         value = currentToken.value.slice(1,-1);
+         value = currentToken.value.slice(1, -1);
          eatToken();
       } else {
          [value] = eatText()
@@ -437,8 +443,8 @@ export default function parse(tokens: Token[], file: string): Parsed {
       eatToken(";");
 
       return {
-         type :"define",
+         type: "define",
-         location: {file, idx},
+         location: { file, idx },
          key,
          value
       }

src/process.ts

@@ -18,7 +18,7 @@ import { ZIGTarget } from "./targets/zig";
 import { DartTarget } from "./targets/dart";
 import { URL } from "url";
 
-class CatchedError extends Error {}
+class CatchedError extends Error { }
 
 const log = dbg("app");
 

src/targets/rust.ts

@@ -1,6 +1,6 @@
 import chalk from "chalk";
 import { CompileTarget } from "../compile";
-import { TypeDefinition, EnumDefinition, ServiceDefinition, Step } from "../ir";
+import { TypeDefinition, EnumDefinition, ServiceDefinition, Step, IR } from "../ir";
 import { lineAppender, LineAppender } from "../utils";
 
 const conversion = {
@@ -71,17 +71,36 @@ export class RustTarget extends CompileTarget<{ rust_crate: string }> {
       a(0, `#[derive(Clone, Debug, Serialize, Deserialize)]`);
       a(0, `pub struct ${definition.name} {`);
       for (const field of definition.fields) {
+         a(1, `#[allow(non_snake_case)]`);
+
+         let fn = `pub ${field.name}:`;
+         if (field.name == "type") {
+            // TODO: Add other keywords as well!
+            console.log(
+               chalk.yellow("[RUST] WARNING:"),
+               "Field name 'type' is not allowed in Rust. Renaming to 'type_'"
+            );
+            fn = `pub type_:`;
+            a(1, `#[serde(rename = "type")]`);
+         }
+         let opts = "";
+         let opte = "";
+         if (field.optional) {
+            opts = "Option<";
+            opte = ">";
+         }
+
          if (field.array) {
-            a(1, `pub ${field.name}: Vec<${toRustType(field.type)}>,`);
+            a(1, `${fn} ${opts}Vec<${toRustType(field.type)}>${opte},`);
          } else if (field.map) {
             a(
                1,
-               `pub ${field.name}: HashMap<${toRustType(
+               `${fn} ${opts}HashMap<${toRustType(
                   field.map
-               )}, ${toRustType(field.type)}>,`
+               )}, ${toRustType(field.type)}>${opte},`
             );
          } else {
-            a(1, `pub ${field.name}: ${toRustType(field.type)},`);
+            a(1, `${fn} ${opts}${toRustType(field.type)}${opte},`);
          }
       }
       a(0, `}`);
@@ -101,7 +120,7 @@ export class RustTarget extends CompileTarget<{ rust_crate: string }> {
       a(0, `#[repr(i64)]`);
       a(
          0,
-         "#[derive(Clone, Copy, Debug, Eq, PartialEq, IntEnum, Deserialize, Serialize)]"
+         "#[derive(Clone, Copy, Debug, Eq, PartialEq, IntEnum)]"
       );
       a(0, `pub enum ${definition.name} {`);
       for (const field of definition.values) {
@@ -142,6 +161,7 @@ export class RustTarget extends CompileTarget<{ rust_crate: string }> {
          let ret = fnc.return
             ? typeToRust(fnc.return.type, fnc.return.array)
             : "()";
+         a(1, `#[allow(non_snake_case)]`);
          a(1, `pub async fn ${fnc.name}(&self, ${params}) -> Result<${ret}> {`);
          a(2, `let l_req = JRPCRequest {`);
          a(3, `jsonrpc: "2.0".to_owned(),`);
@@ -206,6 +226,7 @@ export class RustTarget extends CompileTarget<{ rust_crate: string }> {
          let ret = fnc.return
             ? typeToRust(fnc.return.type, fnc.return.array)
             : "()";
+         a(1, `#[allow(non_snake_case)]`);
          a(1, `async fn ${fnc.name}(&self, ${params}) -> Result<${ret}>;`);
       }
       a(0, `}`);
@@ -216,6 +237,7 @@ export class RustTarget extends CompileTarget<{ rust_crate: string }> {
       a(0, `}`);
       a(0, ``);
       a(0, `impl ${definition.name}Handler {`);
+      //TODO: Maybe add a new definition like, pub fn new2<T>(implementation: T) where T: ${definition.name} + Sync + Send + 'static {}
       a(
          1,
          `pub fn new(implementation: Box<dyn ${definition.name} + Sync + Send + 'static>) -> Arc<Self> {`
@@ -235,6 +257,7 @@ export class RustTarget extends CompileTarget<{ rust_crate: string }> {
       a(1, `fn get_id(&self) -> String { "${definition.name}".to_owned() }`);
       a(0, ``);
 
+      a(1, `#[allow(non_snake_case)]`);
       a(
          1,
          `async fn handle(&self, msg: &JRPCRequest, function: &str) -> Result<(bool, Value)> {`

src/targets/typescript.ts

@@ -33,9 +33,8 @@ export class TypescriptTarget extends CompileTarget {
    }
 
    private generateImport(imports: string, path: string) {
-      return `import ${imports} from "${
+      return `import ${imports} from "${path + (this.flavour === "esm" ? ".ts" : "")
-         path + (this.flavour === "esm" ? ".ts" : "")
+         }";\n`;
-      }";\n`;
    }
 
    private generateImports(
@@ -89,7 +88,7 @@ export class TypescriptTarget extends CompileTarget {
             } else {
                type = toJSType(field.type);
             }
-            return `${field.name}?: ${type}; `;
+            return `${field.name}${field.optional ? "?" : ""}: ${type}; `;
          })
       );
 
@@ -125,10 +124,18 @@ export class TypescriptTarget extends CompileTarget {
          );
          a(1, `let res = new ${def.name}() as any;`);
          def.fields.forEach((field) => {
-            a(
+            if (field.optional) {
-               1,
+               a(
-               `if(data["${field.name}"] !== null && data["${field.name}"] !== undefined) {`
+                  1,
-            );
+                  `if(data["${field.name}"] !== null && data["${field.name}"] !== undefined) {`
+               );
+            } else {
+               a(
+                  1,
+                  `if(data["${field.name}"] === null || data["${field.name}"] === undefined) throw new VerificationError("${def.name}", "${field.name}", data["${field.name}"]);`
+               );
+               a(1, `else {`);
+            }
             if (field.array) {
                a(
                   2,
@@ -203,9 +210,9 @@ export class TypescriptTarget extends CompileTarget {
             "{ RequestObject, ResponseObject, ErrorCodes, Logging }",
             "./service_base"
          ) +
-            this.generateImport(" { VerificationError }", "./ts_base") +
+         this.generateImport(" { VerificationError }", "./ts_base") +
-            "\n\n" +
+         "\n\n" +
-            this.getTemplate("ts_service_client.ts")
+         this.getTemplate("ts_service_client.ts")
       );
 
       const { a, getResult } = LineAppender();
@@ -300,9 +307,9 @@ export class TypescriptTarget extends CompileTarget {
             "{ RequestObject, ResponseObject, ErrorCodes, Logging }",
             "./service_base"
          ) +
-            this.generateImport(" { VerificationError }", "./ts_base") +
+         this.generateImport(" { VerificationError }", "./ts_base") +
-            "\n\n" +
+         "\n\n" +
-            this.getTemplate("ts_service_server.ts")
+         this.getTemplate("ts_service_server.ts")
       );
 
       this.generateImports(a, def);
@@ -335,9 +342,8 @@ export class TypescriptTarget extends CompileTarget {
             `ctx: T`,
          ].join(", ");
          const retVal = fnc.return
-            ? `Promise<${
+            ? `Promise<${toJSType(fnc.return.type) + (fnc.return.array ? "[]" : "")
-                 toJSType(fnc.return.type) + (fnc.return.array ? "[]" : "")
+            }>`
-              }>`
             : `void`;
          a(1, `abstract ${fnc.name}(${params}): ${retVal};`);
 
@@ -380,13 +386,12 @@ export class TypescriptTarget extends CompileTarget {
          a(
             2,
             `return this.${fnc.name}.call(this, ...p)` + //TODO: Refactor. This line is way to compicated for anyone to understand, including me
-               (fnc.return
+            (fnc.return
-                  ? `.then(${
+               ? `.then(${fnc.return?.array
-                       fnc.return?.array
+                  ? `res => res.map(e => apply_${fnc.return.type}(e))`
-                          ? `res => res.map(e => apply_${fnc.return.type}(e))`
+                  : `res => apply_${fnc.return.type}(res)`
-                          : `res => apply_${fnc.return.type}(res)`
+               });`
-                    });`
+               : "")
-                  : "")
          );
          a(1, `}`);
          a(0, ``);

templates/Rust/Cargo.toml

@@ -6,11 +6,10 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-int-enum = "0.5.0"
+int-enum = { version ="0.5.0", features = ["serde", "convert"] }
 serde = { version = "1.0.147", features = ["derive"] }
 serde_json = "1.0.88"
 nanoid = "0.4.0"
 tokio = { version = "1.22.0", features = ["full"] }
 log = "0.4.17"
-simple_logger = { version = "4.0.0", features = ["threads", "colored", "timestamps", "stderr"] }
 async-trait = "0.1.59"

templates/ts_base.ts

@@ -1,14 +1,24 @@
+import { isGeneratorFunction } from "util/types";
+
+function form_verficiation_error_message(type?: string, field?: string) {
+   let msg = "Parameter verification failed! ";
+   if (type && field) {
+      msg += `At ${type}.${field}! `;
+   } else if (type) {
+      msg += `At type ${type}! `;
+   } else if (field) {
+      msg += `At field ${field}! `;
+   }
+   return msg;
+}
+
 export class VerificationError extends Error {
    constructor(
       public readonly type?: string,
       public readonly field?: string,
       public readonly value?: any
    ) {
-      super(
+      super(form_verficiation_error_message(type, field));
-         "Parameter verification failed! " +
-            (type ? "Expected " + type + "! " : "") +
-            (field ? "At: " + field + "! " : "")
-      );
    }
 }
 
@@ -33,4 +43,4 @@ export function apply_boolean(data: any) {
    return Boolean(data);
 }
 
-export function apply_void(data: any) {}
+export function apply_void(data: any) { }