@sdkgen/fsharp-generator 0.0.0-dev.20230106165109 → 0.0.0-dev.20230109111624

package/dist/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/helpers.js

@@ -0,0 +1,488 @@
+import { ArrayType, Base64PrimitiveType, BigIntPrimitiveType, BoolPrimitiveType, BytesPrimitiveType, CnpjPrimitiveType, CpfPrimitiveType, DatePrimitiveType, DateTimePrimitiveType, EmailPrimitiveType, EnumType, FloatPrimitiveType, HexPrimitiveType, HtmlPrimitiveType, IntPrimitiveType, JsonPrimitiveType, MoneyPrimitiveType, OptionalType, StringPrimitiveType, StructType, TypeReference, UIntPrimitiveType, UrlPrimitiveType, UuidPrimitiveType, VoidPrimitiveType, XmlPrimitiveType, } from "@sdkgen/parser";
+const reservedWords = [
+    "abstract",
+    "as",
+    "base",
+    "bool",
+    "break",
+    "byte",
+    "case",
+    "catch",
+    "char",
+    "checked",
+    "class",
+    "const",
+    "continue",
+    "decimal",
+    "default",
+    "delegate",
+    "do",
+    "double",
+    "else",
+    "enum",
+    "event",
+    "explicit",
+    "extern",
+    "false",
+    "finally",
+    "fixed",
+    "float",
+    "for",
+    "foreach",
+    "goto",
+    "if",
+    "implicit",
+    "in",
+    "int",
+    "interface",
+    "internal",
+    "is",
+    "lock",
+    "long",
+    "namespace",
+    "new",
+    "null",
+    "object",
+    "operator",
+    "out",
+    "override",
+    "params",
+    "private",
+    "protected",
+    "public",
+    "readonly",
+    "ref",
+    "return",
+    "sbyte",
+    "sealed",
+    "short",
+    "sizeof",
+    "stackalloc",
+    "static",
+    "string",
+    "struct",
+    "switch",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "typeof",
+    "uint",
+    "ulong",
+    "unchecked",
+    "unsafe",
+    "ushort",
+    "using",
+    "using",
+    "static",
+    "virtual",
+    "void",
+    "volatile",
+    "while",
+    "type",
+    "end",
+    "id",
+];
+const typesWithNativeNullable = [
+    StringPrimitiveType,
+    HtmlPrimitiveType,
+    CpfPrimitiveType,
+    CnpjPrimitiveType,
+    BytesPrimitiveType,
+    EmailPrimitiveType,
+    UrlPrimitiveType,
+    UuidPrimitiveType,
+    HexPrimitiveType,
+    Base64PrimitiveType,
+    XmlPrimitiveType,
+    StructType,
+    ArrayType,
+];
+const needsTempVarForNullable = [
+    BigIntPrimitiveType,
+    DatePrimitiveType,
+    DateTimePrimitiveType,
+    FloatPrimitiveType,
+    IntPrimitiveType,
+    MoneyPrimitiveType,
+    UIntPrimitiveType,
+    ArrayType,
+];
+export function ident(name) {
+    return reservedWords.includes(name) ? `${name}'` : name;
+}
+export function capitalize(name) {
+    return name[0].toUpperCase() + name.slice(1);
+}
+export function generateTypeName(type) {
+    switch (type.constructor) {
+        case StringPrimitiveType:
+            return "string";
+        case IntPrimitiveType:
+            return "int";
+        case UIntPrimitiveType:
+            return "uint";
+        case FloatPrimitiveType:
+            return "double";
+        case BigIntPrimitiveType:
+            return "bigint";
+        case DatePrimitiveType:
+        case DateTimePrimitiveType:
+            return "DateTime";
+        case BoolPrimitiveType:
+            return "bool";
+        case BytesPrimitiveType:
+            return "byte[]";
+        case MoneyPrimitiveType:
+            return "decimal";
+        case UuidPrimitiveType:
+            return "Guid";
+        case CpfPrimitiveType:
+        case CnpjPrimitiveType:
+        case EmailPrimitiveType:
+        case HtmlPrimitiveType:
+        case UrlPrimitiveType:
+        case HexPrimitiveType:
+        case Base64PrimitiveType:
+        case XmlPrimitiveType:
+            return "string";
+        case VoidPrimitiveType:
+            return "void";
+        case JsonPrimitiveType:
+            return "JsonElement";
+        case OptionalType:
+            return `${generateTypeName(type.base)} option`;
+        case ArrayType:
+            return `${generateTypeName(type.base)} list`;
+        case StructType:
+            return type.name;
+        case EnumType:
+            return type.name;
+        case TypeReference:
+            return generateTypeName(type.type);
+        default:
+            throw new Error(`BUG: generateTypeName with ${type.constructor.name}`);
+    }
+}
+export function decodeType(type, jsonElementVar, path, targetVar, suffix = 1, maybeNull = true) {
+    switch (type.constructor) {
+        case IntPrimitiveType: {
+            return `
+              decodeInt32 ${jsonElementVar} ${path}
+            `
+                .replace(/\n {16}/gu, "\n")
+                .trim();
+        }
+        case UIntPrimitiveType: {
+            return `
+              decodeUInt32 ${jsonElementVar} ${path}
+            `
+                .replace(/\n {16}/gu, "\n")
+                .trim();
+        }
+        case MoneyPrimitiveType: {
+            return `
+                (decodeMoney ${jsonElementVar} ${path}) / 100m
+            `
+                .replace(/\n {16}/gu, "\n")
+                .trim();
+        }
+        case FloatPrimitiveType: {
+            return `
+                decodeFloat ${jsonElementVar} ${path}
+            `
+                .replace(/\n {16}/gu, "\n")
+                .trim();
+        }
+        case BigIntPrimitiveType: {
+            return `
+                decodeBigInt ${jsonElementVar} ${path}
+            `
+                .replace(/\n {16}/gu, "\n")
+                .trim();
+        }
+        case StringPrimitiveType: {
+            return `
+                decodeString ${jsonElementVar} ${path}
+            `
+                .replace(/\n {16}/gu, "\n")
+                .trim();
+        }
+        case HtmlPrimitiveType: {
+            // TODO: validate HTML
+            return `
+                decodeHtml ${jsonElementVar} ${path}
+            `
+                .replace(/\n {16}/gu, "\n")
+                .trim();
+        }
+        case CpfPrimitiveType: {
+            // TODO: validate CPF
+            return `
+                decodeCpf ${jsonElementVar} ${path}
+            `
+                .replace(/\n {16}/gu, "\n")
+                .trim();
+        }
+        case CnpjPrimitiveType: {
+            // TODO: validate CNPJ
+            return `
+                decodeCnpj ${jsonElementVar} ${path}
+            `
+                .replace(/\n {16}/gu, "\n")
+                .trim();
+        }
+        case EmailPrimitiveType: {
+            // TODO: validate Email
+            return `
+                decodeEmail ${jsonElementVar} ${path}
+            `
+                .replace(/\n {16}/gu, "\n")
+                .trim();
+        }
+        case UrlPrimitiveType: {
+            // TODO: validate URL
+            return `
+                decodeUrl ${jsonElementVar} ${path}
+            `
+                .replace(/\n {16}/gu, "\n")
+                .trim();
+        }
+        case UuidPrimitiveType: {
+            // TODO: validate UUID
+            return `
+                decodeUuid ${jsonElementVar} ${path}
+            `
+                .replace(/\n {16}/gu, "\n")
+                .trim();
+        }
+        case HexPrimitiveType: {
+            // TODO: validate Hex
+            return `
+                decodeHex ${jsonElementVar} ${path}
+            `
+                .replace(/\n {16}/gu, "\n")
+                .trim();
+        }
+        case Base64PrimitiveType: {
+            // TODO: validate Base64
+            return `
+                decodeBase64 ${jsonElementVar} ${path}
+            `
+                .replace(/\n {16}/gu, "\n")
+                .trim();
+        }
+        case XmlPrimitiveType: {
+            // TODO: validate XML
+            return `
+                decodeXml ${jsonElementVar} ${path}
+            `
+                .replace(/\n {16}/gu, "\n")
+                .trim();
+        }
+        case BoolPrimitiveType: {
+            return `
+                decodeBool ${jsonElementVar} ${path}
+            `
+                .replace(/\n {16}/gu, "\n")
+                .trim();
+        }
+        case BytesPrimitiveType: {
+            return `
+                decodeBytes ${jsonElementVar} ${path}
+            `
+                .replace(/\n {16}/gu, "\n")
+                .trim();
+        }
+        case TypeReference:
+            return decodeType(type.type, jsonElementVar, path, targetVar, suffix);
+        case OptionalType:
+            if (needsTempVarForNullable.includes(type.base.constructor)) {
+                return `match ${jsonElementVar}.ValueKind with
+                  | JsonValueKind.Null | JsonValueKind.Undefined -> None
+                  | _ ->
+                    (${decodeType(type.base, jsonElementVar, path, targetVar, suffix, false).replace(/\n/gu, "\n                    ")}) |> Some
+                `
+                    .replace(/\n {16}/gu, "\n")
+                    .trim();
+            }
+            if (type.base instanceof OptionalType || type.base instanceof ArrayType) {
+                return `
+                (>.>) decodeOptional ${decodeType(type.base, jsonElementVar, path, targetVar, suffix, false)}
+            `
+                    .replace(/\n {16}/gu, "\n")
+                    .trim();
+            }
+            return `
+                decodeOptional ${decodeType(type.base, jsonElementVar, path, targetVar, suffix, false)}
+            `
+                .replace(/\n {16}/gu, "\n")
+                .trim();
+        case EnumType:
+        case StructType:
+            return `Decode${type.name} ${jsonElementVar} ${path}`;
+        case JsonPrimitiveType:
+            if (maybeNull) {
+                return `
+                ${jsonElementVar}
+            `
+                    .replace(/\n {16}/gu, "\n")
+                    .trim();
+            }
+            return `${targetVar} <- ${jsonElementVar}`;
+        case DateTimePrimitiveType: {
+            return `
+                decodeDateTime ${jsonElementVar} ${path}
+            `
+                .replace(/\n {16}/gu, "\n")
+                .trim();
+        }
+        case DatePrimitiveType: {
+            return `
+                decodeDate ${jsonElementVar} ${path}
+            `
+                .replace(/\n {16}/gu, "\n")
+                .trim();
+        }
+        case ArrayType: {
+            return `
+                match ${jsonElementVar}.ValueKind with
+                  | JsonValueKind.Array ->
+                    let mutable list_ = List.empty
+                    for i1 in 0 .. (${jsonElementVar}.GetArrayLength() - 1) do
+                      let item = ${jsonElementVar}.[i1]
+                      let partialResult =
+                        ${decodeType(type.base, `${jsonElementVar}.[i1]`, `${path.slice(0, -1)}.{i1}"`, targetVar, suffix, false).replace(/\n/gu, "\n                      ")}
+                      list_ <- list_ |> List.append [ partialResult ]
+                    list_
+                  | _ -> raise (FatalException(${path.slice(0, -1)} must be an array."))
+            `
+                .replace(/\n {16}/gu, "\n")
+                .trim();
+        }
+        default:
+            throw new Error(`BUG: decodeType with ${type.constructor.name}`);
+    }
+}
+export function encodeType(type, valueVar, path, suffix = 1, isRef = true) {
+    switch (type.constructor) {
+        case StringPrimitiveType: {
+            return `resultWriter_.WriteStringValue(${valueVar})`;
+        }
+        case FloatPrimitiveType:
+        case UIntPrimitiveType:
+        case IntPrimitiveType: {
+            return `resultWriter_.WriteNumberValue(${valueVar})`;
+        }
+        case MoneyPrimitiveType: {
+            return `resultWriter_.WriteNumberValue(int (Math.Round(${valueVar} * 100m)))`;
+        }
+        case BigIntPrimitiveType: {
+            return `resultWriter_.WriteStringValue(${valueVar}.ToString())`;
+        }
+        case BoolPrimitiveType: {
+            return `resultWriter_.WriteBooleanValue(${valueVar})`;
+        }
+        case BytesPrimitiveType: {
+            return `resultWriter_.WriteStringValue(Convert.ToBase64String(${valueVar}))`;
+        }
+        case DateTimePrimitiveType: {
+            return `resultWriter_.WriteStringValue(${valueVar}.ToString("yyyy-MM-ddTHH:mm:ss.FFFFFF'Z'"))`;
+        }
+        case DatePrimitiveType: {
+            return `resultWriter_.WriteStringValue(${valueVar}.ToString("yyyy-MM-dd"))`;
+        }
+        // TODO: format those
+        case CpfPrimitiveType:
+        case CnpjPrimitiveType:
+        case EmailPrimitiveType:
+        case HtmlPrimitiveType:
+        case UrlPrimitiveType:
+        case UuidPrimitiveType:
+        case Base64PrimitiveType:
+        case HexPrimitiveType:
+        case XmlPrimitiveType: {
+            return `resultWriter_.WriteStringValue(${valueVar})`;
+        }
+        case OptionalType: {
+            let realBaseType = type.base;
+            while (realBaseType instanceof TypeReference) {
+                realBaseType = realBaseType.type;
+            }
+            return `
+              if (${valueVar}.IsNone) then
+                resultWriter_.WriteNullValue()
+              else
+                ${encodeType(realBaseType, `${valueVar}.Value`, path, suffix, isRef)}
+              `
+                .replace(/\n {14}/gu, "\n")
+                .trim();
+        }
+        case TypeReference:
+            return encodeType(type.type, valueVar, path, suffix, isRef);
+        case EnumType:
+            return `Encode${type.name} ${valueVar} resultWriter_ ${path}`;
+        case StructType:
+            return `Encode${type.name} ${valueVar} resultWriter_ ${path}`;
+        case JsonPrimitiveType:
+            return `${valueVar}.WriteTo(resultWriter_)`;
+        case ArrayType: {
+            return `
+              resultWriter_.WriteStartArray()
+              for i${suffix} in 0..${valueVar}.Length - 1 do
+                ${encodeType(type.base, `${valueVar}.[i${suffix}]`, `${path}`, suffix + 1).replace(/\n/gu, "\n                ")}
+              resultWriter_.WriteEndArray()
+              `
+                .replace(/\n {14}/gu, "\n")
+                .trim();
+        }
+        default:
+            throw new Error(`BUG: encodeType with ${type.constructor.name}`);
+    }
+}
+export function generateStruct(struct) {
+    return `
+type ${struct.name} = {
+  ${struct.fields.map(field => `${capitalize(field.name)}: ${generateTypeName(field.type)}`).join(";\n  ")}
+} with
+  static member Create (${struct.fields.map(field => `${ident(field.name)}: ${generateTypeName(field.type)}`).join(", ")}): ${struct.name} =
+    { ${struct.fields.map(field => `${capitalize(field.name)} = ${ident(field.name)}`).join("; ")} }
+
+let Decode${struct.name} (json_: JsonElement) (path_: string): ${struct.name} =
+  if (json_.ValueKind <> JsonValueKind.Object) then raise (FatalException($"'{path_}' must be an object."))
+  ${struct.fields
+        .map(field => `
+  let ${field.name}Json_ = decodeJsonElementStrict ${JSON.stringify(field.name)} json_ $"{path_}.${field.name}"
+  let ${ident(field.name)} =
+    ${decodeType(field.type, `${field.name}Json_`, `$"{path_}.${field.name}"`, ident(field.name)).replace(/\n/gu, "\n  ")}
+  `)
+        .join("")}
+  { ${struct.fields.map(field => `${capitalize(field.name)} = ${ident(field.name)}`).join("; ")} }
+
+let Encode${struct.name} (obj_: ${struct.name}) (resultWriter_: Utf8JsonWriter) (path_: string) =
+  resultWriter_.WriteStartObject()
+  ${struct.fields
+        .map(field => `
+  resultWriter_.WritePropertyName(${JSON.stringify(field.name)})
+  ${encodeType(field.type, `obj_.${capitalize(field.name)}`, `$"{path_}.${field.name}"`).replace(/\n/gu, "\n  ")}`)
+        .join("\n")}
+  resultWriter_.WriteEndObject()`;
+}
+export function generateEnum(type) {
+    return `
+type ${type.name} =
+  ${type.values.map(({ value }) => `| ${capitalize(value)}`).join("\n  ")}
+
+let Decode${type.name} (json_: JsonElement) (path_: string): ${type.name} =
+  if (json_.ValueKind <> JsonValueKind.String) then raise (FatalException($"'{path_}' must be a string."))
+  match json_.GetString() with
+  ${type.values.map(({ value }) => `| "${value}" -> ${type.name}.${capitalize(value)}`).join("\n  ")}
+  | _ -> raise (FatalException($"'{path_}' must be one of: (${type.values.map(({ value }) => `'${value}'`).join(", ")})."))
+
+let Encode${type.name} (obj_: ${type.name}) (resultWriter_: Utf8JsonWriter) (path_: string) =
+  match obj_ with
+  ${type.values.map(({ value }) => `| ${type.name}.${capitalize(value)} -> resultWriter_.WriteStringValue("${value}")`).join("\n  ")}
+
+`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../src/helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Type } from \"@sdkgen/parser\";\nimport {\n  ArrayType,\n  Base64PrimitiveType,\n  BigIntPrimitiveType,\n  BoolPrimitiveType,\n  BytesPrimitiveType,\n  CnpjPrimitiveType,\n  CpfPrimitiveType,\n  DatePrimitiveType,\n  DateTimePrimitiveType,\n  EmailPrimitiveType,\n  EnumType,\n  FloatPrimitiveType,\n  HexPrimitiveType,\n  HtmlPrimitiveType,\n  IntPrimitiveType,\n  JsonPrimitiveType,\n  MoneyPrimitiveType,\n  OptionalType,\n  StringPrimitiveType,\n  StructType,\n  TypeReference,\n  UIntPrimitiveType,\n  UrlPrimitiveType,\n  UuidPrimitiveType,\n  VoidPrimitiveType,\n  XmlPrimitiveType,\n} from \"@sdkgen/parser\";\n\nconst reservedWords = [\n  \"abstract\",\n  \"as\",\n  \"base\",\n  \"bool\",\n  \"break\",\n  \"byte\",\n  \"case\",\n  \"catch\",\n  \"char\",\n  \"checked\",\n  \"class\",\n  \"const\",\n  \"continue\",\n  \"decimal\",\n  \"default\",\n  \"delegate\",\n  \"do\",\n  \"double\",\n  \"else\",\n  \"enum\",\n  \"event\",\n  \"explicit\",\n  \"extern\",\n  \"false\",\n  \"finally\",\n  \"fixed\",\n  \"float\",\n  \"for\",\n  \"foreach\",\n  \"goto\",\n  \"if\",\n  \"implicit\",\n  \"in\",\n  \"int\",\n  \"interface\",\n  \"internal\",\n  \"is\",\n  \"lock\",\n  \"long\",\n  \"namespace\",\n  \"new\",\n  \"null\",\n  \"object\",\n  \"operator\",\n  \"out\",\n  \"override\",\n  \"params\",\n  \"private\",\n  \"protected\",\n  \"public\",\n  \"readonly\",\n  \"ref\",\n  \"return\",\n  \"sbyte\",\n  \"sealed\",\n  \"short\",\n  \"sizeof\",\n  \"stackalloc\",\n  \"static\",\n  \"string\",\n  \"struct\",\n  \"switch\",\n  \"this\",\n  \"throw\",\n  \"true\",\n  \"try\",\n  \"typeof\",\n  \"uint\",\n  \"ulong\",\n  \"unchecked\",\n  \"unsafe\",\n  \"ushort\",\n  \"using\",\n  \"using\",\n  \"static\",\n  \"virtual\",\n  \"void\",\n  \"volatile\",\n  \"while\",\n  \"type\",\n  \"end\",\n  \"id\",\n];\n\nconst typesWithNativeNullable: Function[] = [\n  StringPrimitiveType,\n  HtmlPrimitiveType,\n  CpfPrimitiveType,\n  CnpjPrimitiveType,\n  BytesPrimitiveType,\n  EmailPrimitiveType,\n  UrlPrimitiveType,\n  UuidPrimitiveType,\n  HexPrimitiveType,\n  Base64PrimitiveType,\n  XmlPrimitiveType,\n  StructType,\n  ArrayType,\n];\n\nconst needsTempVarForNullable: Function[] = [\n  BigIntPrimitiveType,\n  DatePrimitiveType,\n  DateTimePrimitiveType,\n  FloatPrimitiveType,\n  IntPrimitiveType,\n  MoneyPrimitiveType,\n  UIntPrimitiveType,\n  ArrayType,\n];\n\nexport function ident(name: string): string {\n  return reservedWords.includes(name) ? `${name}'` : name;\n}\n\nexport function capitalize(name: string): string {\n  return name[0].toUpperCase() + name.slice(1);\n}\n\nexport function generateTypeName(type: Type): string {\n  switch (type.constructor) {\n    case StringPrimitiveType:\n      return \"string\";\n    case IntPrimitiveType:\n      return \"int\";\n    case UIntPrimitiveType:\n      return \"uint\";\n    case FloatPrimitiveType:\n      return \"double\";\n    case BigIntPrimitiveType:\n      return \"bigint\";\n    case DatePrimitiveType:\n    case DateTimePrimitiveType:\n      return \"DateTime\";\n    case BoolPrimitiveType:\n      return \"bool\";\n    case BytesPrimitiveType:\n      return \"byte[]\";\n    case MoneyPrimitiveType:\n      return \"decimal\";\n    case UuidPrimitiveType:\n      return \"Guid\";\n    case CpfPrimitiveType:\n    case CnpjPrimitiveType:\n    case EmailPrimitiveType:\n    case HtmlPrimitiveType:\n    case UrlPrimitiveType:\n    case HexPrimitiveType:\n    case Base64PrimitiveType:\n    case XmlPrimitiveType:\n      return \"string\";\n    case VoidPrimitiveType:\n      return \"void\";\n    case JsonPrimitiveType:\n      return \"JsonElement\";\n    case OptionalType:\n      return `${generateTypeName((type as OptionalType).base)} option`;\n    case ArrayType:\n      return `${generateTypeName((type as ArrayType).base)} list`;\n    case StructType:\n      return type.name;\n    case EnumType:\n      return type.name;\n    case TypeReference:\n      return generateTypeName((type as TypeReference).type);\n    default:\n      throw new Error(`BUG: generateTypeName with ${type.constructor.name}`);\n  }\n}\n\nexport function decodeType(type: Type, jsonElementVar: string, path: string, targetVar: string, suffix = 1, maybeNull = true): string {\n  switch (type.constructor) {\n    case IntPrimitiveType: {\n      return `\n              decodeInt32 ${jsonElementVar} ${path}\n            `\n        .replace(/\\n {16}/gu, \"\\n\")\n        .trim();\n    }\n\n    case UIntPrimitiveType: {\n      return `\n              decodeUInt32 ${jsonElementVar} ${path}\n            `\n        .replace(/\\n {16}/gu, \"\\n\")\n        .trim();\n    }\n\n    case MoneyPrimitiveType: {\n      return `\n                (decodeMoney ${jsonElementVar} ${path}) / 100m\n            `\n        .replace(/\\n {16}/gu, \"\\n\")\n        .trim();\n    }\n\n    case FloatPrimitiveType: {\n      return `\n                decodeFloat ${jsonElementVar} ${path}\n            `\n        .replace(/\\n {16}/gu, \"\\n\")\n        .trim();\n    }\n\n    case BigIntPrimitiveType: {\n      return `\n                decodeBigInt ${jsonElementVar} ${path}\n            `\n        .replace(/\\n {16}/gu, \"\\n\")\n        .trim();\n    }\n\n    case StringPrimitiveType: {\n      return `\n                decodeString ${jsonElementVar} ${path}\n            `\n        .replace(/\\n {16}/gu, \"\\n\")\n        .trim();\n    }\n\n    case HtmlPrimitiveType: {\n      // TODO: validate HTML\n      return `\n                decodeHtml ${jsonElementVar} ${path}\n            `\n        .replace(/\\n {16}/gu, \"\\n\")\n        .trim();\n    }\n\n    case CpfPrimitiveType: {\n      // TODO: validate CPF\n      return `\n                decodeCpf ${jsonElementVar} ${path}\n            `\n        .replace(/\\n {16}/gu, \"\\n\")\n        .trim();\n    }\n\n    case CnpjPrimitiveType: {\n      // TODO: validate CNPJ\n      return `\n                decodeCnpj ${jsonElementVar} ${path}\n            `\n        .replace(/\\n {16}/gu, \"\\n\")\n        .trim();\n    }\n\n    case EmailPrimitiveType: {\n      // TODO: validate Email\n      return `\n                decodeEmail ${jsonElementVar} ${path}\n            `\n        .replace(/\\n {16}/gu, \"\\n\")\n        .trim();\n    }\n\n    case UrlPrimitiveType: {\n      // TODO: validate URL\n      return `\n                decodeUrl ${jsonElementVar} ${path}\n            `\n        .replace(/\\n {16}/gu, \"\\n\")\n        .trim();\n    }\n\n    case UuidPrimitiveType: {\n      // TODO: validate UUID\n      return `\n                decodeUuid ${jsonElementVar} ${path}\n            `\n        .replace(/\\n {16}/gu, \"\\n\")\n        .trim();\n    }\n\n    case HexPrimitiveType: {\n      // TODO: validate Hex\n      return `\n                decodeHex ${jsonElementVar} ${path}\n            `\n        .replace(/\\n {16}/gu, \"\\n\")\n        .trim();\n    }\n\n    case Base64PrimitiveType: {\n      // TODO: validate Base64\n      return `\n                decodeBase64 ${jsonElementVar} ${path}\n            `\n        .replace(/\\n {16}/gu, \"\\n\")\n        .trim();\n    }\n\n    case XmlPrimitiveType: {\n      // TODO: validate XML\n      return `\n                decodeXml ${jsonElementVar} ${path}\n            `\n        .replace(/\\n {16}/gu, \"\\n\")\n        .trim();\n    }\n\n    case BoolPrimitiveType: {\n      return `\n                decodeBool ${jsonElementVar} ${path}\n            `\n        .replace(/\\n {16}/gu, \"\\n\")\n        .trim();\n    }\n\n    case BytesPrimitiveType: {\n      return `\n                decodeBytes ${jsonElementVar} ${path}\n            `\n        .replace(/\\n {16}/gu, \"\\n\")\n        .trim();\n    }\n\n    case TypeReference:\n      return decodeType((type as TypeReference).type, jsonElementVar, path, targetVar, suffix);\n    case OptionalType:\n      if (needsTempVarForNullable.includes((type as OptionalType).base.constructor)) {\n        return `match ${jsonElementVar}.ValueKind with\n                  | JsonValueKind.Null | JsonValueKind.Undefined -> None\n                  | _ ->\n                    (${decodeType((type as OptionalType).base, jsonElementVar, path, targetVar, suffix, false).replace(\n                      /\\n/gu,\n                      \"\\n                    \",\n                    )}) |> Some\n                `\n          .replace(/\\n {16}/gu, \"\\n\")\n          .trim();\n      }\n\n      if ((type as ArrayType).base instanceof OptionalType || (type as ArrayType).base instanceof ArrayType) {\n        return `\n                (>.>) decodeOptional ${decodeType((type as OptionalType).base, jsonElementVar, path, targetVar, suffix, false)}\n            `\n          .replace(/\\n {16}/gu, \"\\n\")\n          .trim();\n      }\n\n      return `\n                decodeOptional ${decodeType((type as OptionalType).base, jsonElementVar, path, targetVar, suffix, false)}\n            `\n        .replace(/\\n {16}/gu, \"\\n\")\n        .trim();\n    case EnumType:\n    case StructType:\n      return `Decode${type.name} ${jsonElementVar} ${path}`;\n    case JsonPrimitiveType:\n      if (maybeNull) {\n        return `\n                ${jsonElementVar}\n            `\n          .replace(/\\n {16}/gu, \"\\n\")\n          .trim();\n      }\n\n      return `${targetVar} <- ${jsonElementVar}`;\n\n    case DateTimePrimitiveType: {\n      return `\n                decodeDateTime ${jsonElementVar} ${path}\n            `\n        .replace(/\\n {16}/gu, \"\\n\")\n        .trim();\n    }\n\n    case DatePrimitiveType: {\n      return `\n                decodeDate ${jsonElementVar} ${path}\n            `\n        .replace(/\\n {16}/gu, \"\\n\")\n        .trim();\n    }\n\n    case ArrayType: {\n      return `\n                match ${jsonElementVar}.ValueKind with\n                  | JsonValueKind.Array ->\n                    let mutable list_ = List.empty\n                    for i1 in 0 .. (${jsonElementVar}.GetArrayLength() - 1) do\n                      let item = ${jsonElementVar}.[i1]\n                      let partialResult =\n                        ${decodeType(\n                          (type as ArrayType).base,\n                          `${jsonElementVar}.[i1]`,\n                          `${path.slice(0, -1)}.{i1}\"`,\n                          targetVar,\n                          suffix,\n                          false,\n                        ).replace(/\\n/gu, \"\\n                      \")}\n                      list_ <- list_ |> List.append [ partialResult ]\n                    list_\n                  | _ -> raise (FatalException(${path.slice(0, -1)} must be an array.\"))\n            `\n        .replace(/\\n {16}/gu, \"\\n\")\n        .trim();\n    }\n\n    default:\n      throw new Error(`BUG: decodeType with ${type.constructor.name}`);\n  }\n}\n\nexport function encodeType(type: Type, valueVar: string, path: string, suffix = 1, isRef = true): string {\n  switch (type.constructor) {\n    case StringPrimitiveType: {\n      return `resultWriter_.WriteStringValue(${valueVar})`;\n    }\n\n    case FloatPrimitiveType:\n    case UIntPrimitiveType:\n    case IntPrimitiveType: {\n      return `resultWriter_.WriteNumberValue(${valueVar})`;\n    }\n\n    case MoneyPrimitiveType: {\n      return `resultWriter_.WriteNumberValue(int (Math.Round(${valueVar} * 100m)))`;\n    }\n\n    case BigIntPrimitiveType: {\n      return `resultWriter_.WriteStringValue(${valueVar}.ToString())`;\n    }\n\n    case BoolPrimitiveType: {\n      return `resultWriter_.WriteBooleanValue(${valueVar})`;\n    }\n\n    case BytesPrimitiveType: {\n      return `resultWriter_.WriteStringValue(Convert.ToBase64String(${valueVar}))`;\n    }\n\n    case DateTimePrimitiveType: {\n      return `resultWriter_.WriteStringValue(${valueVar}.ToString(\"yyyy-MM-ddTHH:mm:ss.FFFFFF'Z'\"))`;\n    }\n\n    case DatePrimitiveType: {\n      return `resultWriter_.WriteStringValue(${valueVar}.ToString(\"yyyy-MM-dd\"))`;\n    }\n\n    // TODO: format those\n    case CpfPrimitiveType:\n    case CnpjPrimitiveType:\n    case EmailPrimitiveType:\n    case HtmlPrimitiveType:\n    case UrlPrimitiveType:\n    case UuidPrimitiveType:\n    case Base64PrimitiveType:\n    case HexPrimitiveType:\n    case XmlPrimitiveType: {\n      return `resultWriter_.WriteStringValue(${valueVar})`;\n    }\n\n    case OptionalType: {\n      let realBaseType = (type as OptionalType).base;\n\n      while (realBaseType instanceof TypeReference) {\n        realBaseType = realBaseType.type;\n      }\n\n      return `\n              if (${valueVar}.IsNone) then\n                resultWriter_.WriteNullValue()\n              else\n                ${encodeType(realBaseType, `${valueVar}.Value`, path, suffix, isRef)}\n              `\n        .replace(/\\n {14}/gu, \"\\n\")\n        .trim();\n    }\n\n    case TypeReference:\n      return encodeType((type as TypeReference).type, valueVar, path, suffix, isRef);\n    case EnumType:\n      return `Encode${type.name} ${valueVar} resultWriter_ ${path}`;\n    case StructType:\n      return `Encode${type.name} ${valueVar} resultWriter_ ${path}`;\n    case JsonPrimitiveType:\n      return `${valueVar}.WriteTo(resultWriter_)`;\n    case ArrayType: {\n      return `\n              resultWriter_.WriteStartArray()\n              for i${suffix} in 0..${valueVar}.Length - 1 do\n                ${encodeType((type as ArrayType).base, `${valueVar}.[i${suffix}]`, `${path}`, suffix + 1).replace(/\\n/gu, \"\\n                \")}\n              resultWriter_.WriteEndArray()\n              `\n        .replace(/\\n {14}/gu, \"\\n\")\n        .trim();\n    }\n\n    default:\n      throw new Error(`BUG: encodeType with ${type.constructor.name}`);\n  }\n}\n\nexport function generateStruct(struct: StructType): string {\n  return `\ntype ${struct.name} = {\n  ${struct.fields.map(field => `${capitalize(field.name)}: ${generateTypeName(field.type)}`).join(\";\\n  \")}\n} with\n  static member Create (${struct.fields.map(field => `${ident(field.name)}: ${generateTypeName(field.type)}`).join(\", \")}): ${struct.name} =\n    { ${struct.fields.map(field => `${capitalize(field.name)} = ${ident(field.name)}`).join(\"; \")} }\n\nlet Decode${struct.name} (json_: JsonElement) (path_: string): ${struct.name} =\n  if (json_.ValueKind <> JsonValueKind.Object) then raise (FatalException($\"'{path_}' must be an object.\"))\n  ${struct.fields\n    .map(\n      field =>\n        `\n  let ${field.name}Json_ = decodeJsonElementStrict ${JSON.stringify(field.name)} json_ $\"{path_}.${field.name}\"\n  let ${ident(field.name)} =\n    ${decodeType(field.type, `${field.name}Json_`, `$\"{path_}.${field.name}\"`, ident(field.name)).replace(/\\n/gu, \"\\n  \")}\n  `,\n    )\n    .join(\"\")}\n  { ${struct.fields.map(field => `${capitalize(field.name)} = ${ident(field.name)}`).join(\"; \")} }\n\nlet Encode${struct.name} (obj_: ${struct.name}) (resultWriter_: Utf8JsonWriter) (path_: string) =\n  resultWriter_.WriteStartObject()\n  ${struct.fields\n    .map(\n      field =>\n        `\n  resultWriter_.WritePropertyName(${JSON.stringify(field.name)})\n  ${encodeType(field.type, `obj_.${capitalize(field.name)}`, `$\"{path_}.${field.name}\"`).replace(/\\n/gu, \"\\n  \")}`,\n    )\n    .join(\"\\n\")}\n  resultWriter_.WriteEndObject()`;\n}\n\nexport function generateEnum(type: EnumType): string {\n  return `\ntype ${type.name} =\n  ${type.values.map(({ value }) => `| ${capitalize(value)}`).join(\"\\n  \")}\n\nlet Decode${type.name} (json_: JsonElement) (path_: string): ${type.name} =\n  if (json_.ValueKind <> JsonValueKind.String) then raise (FatalException($\"'{path_}' must be a string.\"))\n  match json_.GetString() with\n  ${type.values.map(({ value }) => `| \"${value}\" -> ${type.name}.${capitalize(value)}`).join(\"\\n  \")}\n  | _ -> raise (FatalException($\"'{path_}' must be one of: (${type.values.map(({ value }) => `'${value}'`).join(\", \")}).\"))\n\nlet Encode${type.name} (obj_: ${type.name}) (resultWriter_: Utf8JsonWriter) (path_: string) =\n  match obj_ with\n  ${type.values.map(({ value }) => `| ${type.name}.${capitalize(value)} -> resultWriter_.WriteStringValue(\"${value}\")`).join(\"\\n  \")}\n\n`;\n}\n"]}

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from "./fsharp-server.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxvQkFBb0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2ZzaGFycC1zZXJ2ZXIuanNcIjtcbiJdfQ==