README.md

@@ -6,9 +6,6 @@ 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
 
@@ -26,7 +23,7 @@ enum TestEnum {
 type Test {
   testen: TestEnum;
   someString: string;
-  someNumber?: number;
+  someNumber: number;
   array: string[];
   map: {number, TestEnum};
 }
@@ -47,8 +44,4 @@ 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.
 
-## TODOS
-
-1. Documentation
-2. Null Checks/Enforcements in all languages
-3. More and better tests
+//TODO: Make Documentation better

examples/import.jrpc

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

package.json

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

src/index.ts

@@ -4,15 +4,13 @@ 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(pkg.version)
+   .version("1.0.0")
    .command(
       "compile <input>",
       "Compile source",

src/ir.ts

@@ -14,7 +14,6 @@ export interface TypeFieldDefinition {
    name: string;
    type: string;
    array: boolean;
-   optional: boolean;
    map?: string;
 }
 
@@ -128,7 +127,6 @@ 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,7 +16,6 @@ export interface ImportStatement extends DefinitionNode {
 export interface TypeFieldStatement extends DefinitionNode {
    type: "type_field";
    name: string;
-   optional: boolean;
    fieldtype: string;
    array: boolean;
    map?: string;
@@ -140,7 +139,8 @@ 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 '${currentToken.value
+            `Unexpected token value, expected ${types.join(" | ")}, received '${
+               currentToken.value
             }'`,
             currentToken
          );
@@ -170,11 +170,6 @@ 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;
@@ -203,7 +198,6 @@ export default function parse(tokens: Token[], file: string): Parsed {
          array,
          map: mapKey,
          location: { file, idx },
-         optional
       };
    };
 

src/targets/rust.ts

@@ -1,6 +1,6 @@
 import chalk from "chalk";
 import { CompileTarget } from "../compile";
-import { TypeDefinition, EnumDefinition, ServiceDefinition, Step, IR } from "../ir";
+import { TypeDefinition, EnumDefinition, ServiceDefinition, Step } from "../ir";
 import { lineAppender, LineAppender } from "../utils";
 
 const conversion = {
@@ -71,36 +71,17 @@ 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, `${fn} ${opts}Vec<${toRustType(field.type)}>${opte},`);
+            a(1, `pub ${field.name}: Vec<${toRustType(field.type)}>,`);
          } else if (field.map) {
             a(
                1,
-               `${fn} ${opts}HashMap<${toRustType(
+               `pub ${field.name}: HashMap<${toRustType(
                   field.map
-               )}, ${toRustType(field.type)}>${opte},`
+               )}, ${toRustType(field.type)}>,`
             );
          } else {
-            a(1, `${fn} ${opts}${toRustType(field.type)}${opte},`);
+            a(1, `pub ${field.name}: ${toRustType(field.type)},`);
          }
       }
       a(0, `}`);
@@ -120,7 +101,7 @@ export class RustTarget extends CompileTarget<{ rust_crate: string }> {
       a(0, `#[repr(i64)]`);
       a(
          0,
-         "#[derive(Clone, Copy, Debug, Eq, PartialEq, IntEnum)]"
+         "#[derive(Clone, Copy, Debug, Eq, PartialEq, IntEnum, Deserialize, Serialize)]"
       );
       a(0, `pub enum ${definition.name} {`);
       for (const field of definition.values) {
@@ -161,7 +142,6 @@ 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(),`);
@@ -226,7 +206,6 @@ 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, `}`);
@@ -237,7 +216,6 @@ 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> {`
@@ -257,7 +235,6 @@ 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,7 +33,8 @@ export class TypescriptTarget extends CompileTarget {
    }
 
    private generateImport(imports: string, path: string) {
-      return `import ${imports} from "${path + (this.flavour === "esm" ? ".ts" : "")
+      return `import ${imports} from "${
+         path + (this.flavour === "esm" ? ".ts" : "")
       }";\n`;
    }
 
@@ -88,7 +89,7 @@ export class TypescriptTarget extends CompileTarget {
             } else {
                type = toJSType(field.type);
             }
-            return `${field.name}${field.optional ? "?" : ""}: ${type}; `;
+            return `${field.name}?: ${type}; `;
          })
       );
 
@@ -124,18 +125,10 @@ export class TypescriptTarget extends CompileTarget {
          );
          a(1, `let res = new ${def.name}() as any;`);
          def.fields.forEach((field) => {
-            if (field.optional) {
             a(
                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,
@@ -342,7 +335,8 @@ export class TypescriptTarget extends CompileTarget {
             `ctx: T`,
          ].join(", ");
          const retVal = fnc.return
-            ? `Promise<${toJSType(fnc.return.type) + (fnc.return.array ? "[]" : "")
+            ? `Promise<${
+                 toJSType(fnc.return.type) + (fnc.return.array ? "[]" : "")
               }>`
             : `void`;
          a(1, `abstract ${fnc.name}(${params}): ${retVal};`);
@@ -387,7 +381,8 @@ export class TypescriptTarget extends CompileTarget {
             2,
             `return this.${fnc.name}.call(this, ...p)` + //TODO: Refactor. This line is way to compicated for anyone to understand, including me
                (fnc.return
-               ? `.then(${fnc.return?.array
+                  ? `.then(${
+                       fnc.return?.array
                           ? `res => res.map(e => apply_${fnc.return.type}(e))`
                           : `res => apply_${fnc.return.type}(res)`
                     });`

templates/Rust/Cargo.toml

@@ -6,10 +6,11 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-int-enum = { version ="0.5.0", features = ["serde", "convert"] }
+int-enum = "0.5.0"
 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,24 +1,14 @@
-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(form_verficiation_error_message(type, field));
+      super(
+         "Parameter verification failed! " +
+            (type ? "Expected " + type + "! " : "") +
+            (field ? "At: " + field + "! " : "")
+      );
    }
 }