mdmodels 0.2.10

A tool to generate models, code and schemas from markdown files
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

{#
    This macro renders an attribute name as an object key, quoting it when it is
    not a plain identifier (e.g. when it contains a dash like `coupling-scheme`).
    Quoting preserves the original wire name without needing an alias.
#}
{% macro key(attr) -%}
{%- if (attr.name | to_identifier) != attr.name -%}"{{ attr.name }}"{%- else -%}{{ attr.name }}{%- endif -%}
{%- endmacro %}

{#
    This macro determines whether the type is multiple
#}
{% macro is_multiple(attr) %}
  {%- if attr.multiple -%}[]{%- endif -%}
{% endmacro %}

{#
    This macro returns the type
#}
{% macro get_type(attr) %}
  {%- if attr.dtypes[0] in object_names -%}
  {{ attr.dtypes[0] }}
  {%- else -%}
  {{ attr.dtypes[0] }}
  {%- endif -%}
{% endmacro %}

{#
    This macro determines whether the type is optional
#}
{% macro is_optional(attr) %}
  {%- if attr.required is false -%}?{%- endif -%}
{% endmacro %}

{#
    This macro wraps a codec type
#}
{% macro wrap_codec_type(dtype, attr) %}
  {%- if attr.multiple -%}
  D.array({{ codec_type(dtype, attr) }})
  {%- elif attr.required is false -%}
  D.nullable({{ codec_type(dtype, attr) }})
  {%- else -%}
  {{ codec_type(dtype, attr) }}
  {%- endif -%}
{% endmacro %}

{#
    This macro wraps a codec type
#}
{% macro codec_type(dtype, attr) %}
  {%- if dtype in object_names or dtype in enum_names -%}
  {{ dtype }}Codec
  {%- else -%}
  D.{{ dtype }}
  {%- endif -%}
{% endmacro %}

{# ########################## #}
{# Code structure starts here #}
{# ########################## #}
import * as D from 'io-ts/Decoder';
import { isLeft } from "fp-ts/Either";

// Generic validate function
export function validate<T>(codec: D.Decoder<unknown, T>, value: unknown): T {
  const result = codec.decode(value);
  if (isLeft(result)) {
    throw new Error(D.draw(result.left));
  }
  return result.right;
}

// JSON-LD Types
export interface JsonLdContext {
  [key: string]: any;
}

export interface JsonLd {
  '@context'?: JsonLdContext;
  '@id'?: string;
  '@type'?: string;
}

// {{ title }} Type definitions
{%- for object in objects %}
/**
{%- if object.docstring %}
    {{ wrap(object.docstring, 70, "", "    ") }}
{% endif %}

{%- for attr in object.attributes %}
    * @param {{ attr.name }} {%- if attr.docstring %} - {{ wrap(attr.docstring, 70, "", "             ", None) }}{%- endif %}
{%- endfor %}
**/
export interface {{ object.name }} extends JsonLd {
  {%- for attr in object.attributes %}
  {{ key(attr) }}{{ is_optional(attr) }}: {{ get_type(attr) }}{{ is_multiple(attr) }} {%- if attr.required is false %} | null{% endif %};
  {%- endfor %}
}

export const {{ object.name }}Codec = D.lazy("{{ object.name }}", () => D.struct({
  {%- for attr in object.attributes %}
    {{ key(attr) }}: {{ wrap_codec_type(get_type(attr), attr) }},
  {%- endfor %}
}));

{% endfor %}

{%- if enums | length > 0 %}
// {{ title }} Enum definitions
{%- for enum in enums %}
{%- if enum.docstring %}
/**
 * {{ wrap(enum.docstring, 70, " ", "    ", None) }}
**/
{%- endif %}
export enum {{ enum.name }} {
  {%- for key, value in enum.mappings | dictsort %}
  {{ key }} = '{{ value }}',
  {%- endfor %}
}

export const {{ enum.name }}Codec = D.union(
  {%- for key, value in enum.mappings | dictsort %}
  D.literal({{ enum.name }}.{{ key }}),
  {%- endfor %}
);
{% endfor %}
{% endif %}