@sdkgen/fsharp-generator 0.0.0-dev.20230109202609 → 0.0.0-dev.20230110171718

package/dist/src/fsharp-server.d.ts

@@ -0,0 +1,2 @@
+import type { AstRoot } from "@sdkgen/parser";
+export declare function generateFSharpServerSource(ast: AstRoot): string;

package/dist/src/fsharp-server.js

@@ -0,0 +1,90 @@
+import { astToJson, VoidPrimitiveType } from "@sdkgen/parser";
+import { capitalize, decodeType, encodeType, generateEnum, generateStruct, generateTypeName, ident } from "./helpers.js";
+export function generateFSharpServerSource(ast) {
+    let code = `module rec SdkgenGenerated
+open Sdkgen.Runtime
+open Sdkgen.Helpers
+open Sdkgen.Context
+open System.Threading.Tasks
+open System.Text.Json
+open System
+open System.Globalization
+#if NET5_0
+// To use tasks as computation expression in .NET 5 install https://www.nuget.org/packages/TaskBuilder.fs/
+open FSharp.Control.Tasks.V2.ContextInsensitive
+#endif
+`;
+    for (const error of ast.errors) {
+        code += `
+type ${error.name}Exception =
+  inherit SdkgenException
+
+  new(message: string) = {
+    inherit SdkgenException("${error.name}", message, null)
+  }
+
+  new(message: string, inner: Exception) = {
+    inherit SdkgenException("${error.name}", message, inner)
+  }\n`;
+    }
+    for (const type of ast.enumTypes) {
+        code += `\n${generateEnum(type)}\n`;
+    }
+    for (const type of ast.structTypes) {
+        code += `\n${generateStruct(type)}\n`;
+    }
+    code += `
+type Api() =`;
+    for (const op of ast.operations) {
+        const returnTypeAngle = op.returnType instanceof VoidPrimitiveType ? "" : `<${generateTypeName(op.returnType)}>`;
+        const argsInRecord = op.args.length > 0 ? `{| ${op.args.map(arg => `${arg.name}: ${generateTypeName(arg.type)};`).join("")} |} ->` : "";
+        code += `
+  member val ${capitalize(op.name)}: Context -> ${argsInRecord} Task${returnTypeAngle} =
+    fun _ -> (raise (FatalException("Function '${op.name}' not implemented.")))
+    with get, set
+    `;
+    }
+    code += `
+  interface BaseApi with
+    member __.ExecuteFunction(context_: Context, resultWriter_: Utf8JsonWriter) : Task =
+        task {
+          match context_.Name with`;
+    for (const op of ast.operations) {
+        code += `
+          | ${JSON.stringify(op.name)} ->`;
+        for (const arg of op.args) {
+            code += `
+            let ${arg.name}Json_ =
+              match context_.Args.TryGetValue(${JSON.stringify(arg.name)}) with
+              | true, v -> v
+              | _ -> raise (FatalException("'${op.name}().args.${arg.name}' must be set to a value of type ${arg.type.name}."))
+
+            let ${ident(arg.name)} =
+              ${decodeType(arg.type, `${arg.name}Json_`, `"${op.name}().args.${arg.name}"`, ident(arg.name)).replace(/\n/gu, "\n            ")}`;
+        }
+        if (op.returnType instanceof VoidPrimitiveType) {
+            code += `
+
+            do! (__.${capitalize(op.name)} context_ ${op.args.length > 0 ? "{|" : ""} ${op.args
+                .map(arg => `${arg.name} = ${ident(arg.name)}`)
+                .join("; ")} ${op.args.length > 0 ? "|}" : ""})
+      `;
+        }
+        else {
+            code += `
+
+            let! result_ = (__.${capitalize(op.name)} context_ ${op.args.length > 0 ? "{|" : ""} ${op.args
+                .map(arg => `${arg.name} = ${ident(arg.name)}`)
+                .join("; ")} ${op.args.length > 0 ? "|}" : ""})
+            ${encodeType(op.returnType, `result_`, `"${op.name}().ret"`, 1, false).replace(/\n/gu, "\n            ")}`;
+        }
+    }
+    code += `
+
+          | _ -> raise (FatalException($"Unknown function '{context_.Name}'."))
+        } :> Task`;
+    code += `
+    member __.GetAstJson() = """${JSON.stringify(astToJson(ast), null, 4).replace(/\n/gu, "\n        ")}""";`;
+    return code;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fsharp-server.js","sourceRoot":"","sources":["../../src/fsharp-server.ts"],"names":[],"mappings":"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","sourcesContent":["import type { AstRoot } from \"@sdkgen/parser\";\nimport { astToJson, VoidPrimitiveType } from \"@sdkgen/parser\";\n\nimport { capitalize, decodeType, encodeType, generateEnum, generateStruct, generateTypeName, ident } from \"./helpers.js\";\n\nexport function generateFSharpServerSource(ast: AstRoot): string {\n  let code = `module rec SdkgenGenerated\nopen Sdkgen.Runtime\nopen Sdkgen.Helpers\nopen Sdkgen.Context\nopen System.Threading.Tasks\nopen System.Text.Json\nopen System\nopen System.Globalization\n#if NET5_0\n// To use tasks as computation expression in .NET 5 install https://www.nuget.org/packages/TaskBuilder.fs/\nopen FSharp.Control.Tasks.V2.ContextInsensitive\n#endif\n`;\n\n  for (const error of ast.errors) {\n    code += `\ntype ${error.name}Exception =\n  inherit SdkgenException\n\n  new(message: string) = {\n    inherit SdkgenException(\"${error.name}\", message, null)\n  }\n\n  new(message: string, inner: Exception) = {\n    inherit SdkgenException(\"${error.name}\", message, inner)\n  }\\n`;\n  }\n\n  for (const type of ast.enumTypes) {\n    code += `\\n${generateEnum(type)}\\n`;\n  }\n\n  for (const type of ast.structTypes) {\n    code += `\\n${generateStruct(type)}\\n`;\n  }\n\n  code += `\ntype Api() =`;\n\n  for (const op of ast.operations) {\n    const returnTypeAngle = op.returnType instanceof VoidPrimitiveType ? \"\" : `<${generateTypeName(op.returnType)}>`;\n\n    const argsInRecord = op.args.length > 0 ? `{| ${op.args.map(arg => `${arg.name}: ${generateTypeName(arg.type)};`).join(\"\")} |} ->` : \"\";\n\n    code += `\n  member val ${capitalize(op.name)}: Context -> ${argsInRecord} Task${returnTypeAngle} =\n    fun _ -> (raise (FatalException(\"Function '${op.name}' not implemented.\")))\n    with get, set\n    `;\n  }\n\n  code += `\n  interface BaseApi with\n    member __.ExecuteFunction(context_: Context, resultWriter_: Utf8JsonWriter) : Task =\n        task {\n          match context_.Name with`;\n\n  for (const op of ast.operations) {\n    code += `\n          | ${JSON.stringify(op.name)} ->`;\n    for (const arg of op.args) {\n      code += `\n            let ${arg.name}Json_ =\n              match context_.Args.TryGetValue(${JSON.stringify(arg.name)}) with\n              | true, v -> v\n              | _ -> raise (FatalException(\"'${op.name}().args.${arg.name}' must be set to a value of type ${arg.type.name}.\"))\n\n            let ${ident(arg.name)} =\n              ${decodeType(arg.type, `${arg.name}Json_`, `\"${op.name}().args.${arg.name}\"`, ident(arg.name)).replace(/\\n/gu, \"\\n            \")}`;\n    }\n\n    if (op.returnType instanceof VoidPrimitiveType) {\n      code += `\n\n            do! (__.${capitalize(op.name)} context_ ${op.args.length > 0 ? \"{|\" : \"\"} ${op.args\n        .map(arg => `${arg.name} = ${ident(arg.name)}`)\n        .join(\"; \")} ${op.args.length > 0 ? \"|}\" : \"\"})\n      `;\n    } else {\n      code += `\n\n            let! result_ = (__.${capitalize(op.name)} context_ ${op.args.length > 0 ? \"{|\" : \"\"} ${op.args\n        .map(arg => `${arg.name} = ${ident(arg.name)}`)\n        .join(\"; \")} ${op.args.length > 0 ? \"|}\" : \"\"})\n            ${encodeType(op.returnType, `result_`, `\"${op.name}().ret\"`, 1, false).replace(/\\n/gu, \"\\n            \")}`;\n    }\n  }\n\n  code += `\n\n          | _ -> raise (FatalException($\"Unknown function '{context_.Name}'.\"))\n        } :> Task`;\n\n  code += `\n    member __.GetAstJson() = \"\"\"${JSON.stringify(astToJson(ast), null, 4).replace(/\\n/gu, \"\\n        \")}\"\"\";`;\n\n  return code;\n}\n"]}

package/dist/src/helpers.d.ts

@@ -0,0 +1,9 @@
+import type { Type } from "@sdkgen/parser";
+import { EnumType, StructType } from "@sdkgen/parser";
+export declare function ident(name: string): string;
+export declare function capitalize(name: string): string;
+export declare function generateTypeName(type: Type): string;
+export declare function decodeType(type: Type, jsonElementVar: string, path: string, targetVar: string, suffix?: number, maybeNull?: boolean): string;
+export declare function encodeType(type: Type, valueVar: string, path: string, suffix?: number, isRef?: boolean): string;
+export declare function generateStruct(struct: StructType): string;
+export declare function generateEnum(type: EnumType): string;