Skip to content

Commit 6cb1049

Browse files
raphael-goetzraphael-goetz
committed
feat: wip mapper
1 parent dfdb817 commit 6cb1049

File tree

8 files changed

+388
-243
lines changed

8 files changed

+388
-243
lines changed

‎reader/ts/index.ts‎

Lines changed: 6 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,2 +1,6 @@
1-
export { Definition } from './src/parser.js';
2-
export type { Feature, MetaType, Meta } from './src/types.js';
1+
import {Definition} from "./src/parser.ts";
2+
3+
export { Definition } from './src/parser.ts';
4+
export type { Feature, MetaType, Meta } from './src/types.ts';
5+
6+
const def = Definition("../../definitions/")

‎reader/ts/src/mapper/dataTypeMapper.ts‎

Lines changed: 154 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,154 @@
1+
import {
2+
DefinitionDataType,
3+
DefinitionDataType_Variant,
4+
DefinitionDataTypeRule
5+
} from "@code0-tech/tucana/pb/shared.data_type_pb.ts";
6+
import {getTranslationConnection} from "./helper.ts";
7+
import {
8+
DataType,
9+
DataTypeRule,
10+
DataTypeRuleConnection, DataTypeRulesContainsKeyConfig,
11+
DataTypeRulesContainsTypeConfig, DataTypeRulesInputTypesConfig, DataTypeRulesItemOfCollectionConfig,
12+
DataTypeRulesNumberRangeConfig, DataTypeRulesParentTypeConfig, DataTypeRulesRegexConfig, DataTypeRulesVariant,
13+
DataTypeVariant
14+
} from "@code0-tech/sagittarius-graphql-types";
15+
16+
function mapDataType(dataType: DefinitionDataType | undefined): DataType | null {
17+
if (dataType == undefined) {
18+
return null
19+
}
20+
21+
return {
22+
genericKeys: dataType.genericKeys,
23+
identifier: dataType.identifier,
24+
name: getTranslationConnection(dataType.name),
25+
rules: createRules(dataType.rules),
26+
variant: getDataTypeVariant(dataType.variant)
27+
}
28+
}
29+
30+
function createRules(rule: DefinitionDataTypeRule[]): DataTypeRuleConnection {
31+
return {
32+
count: rule.length,
33+
nodes: rule.map(r => {
34+
console.log(r)
35+
const config: any = r.config
36+
if (config.ContainsType) {
37+
const ruleConfig: DataTypeRulesContainsTypeConfig = {
38+
dataTypeIdentifier: null, //TODO
39+
}
40+
const rule: DataTypeRule = {
41+
variant: DataTypeRulesVariant.ContainsType,
42+
config: ruleConfig
43+
}
44+
return rule;
45+
}
46+
47+
if (config.ContainsKey) {
48+
const ruleConfig: DataTypeRulesContainsKeyConfig = {
49+
dataTypeIdentifier: null, //TODO
50+
key: null,
51+
}
52+
const rule: DataTypeRule = {
53+
variant: DataTypeRulesVariant.ContainsKey,
54+
config: ruleConfig
55+
}
56+
return rule;
57+
}
58+
59+
if (config.ItemOfCollection) {
60+
const ruleConfig: DataTypeRulesItemOfCollectionConfig = {
61+
items: null, //TODO
62+
}
63+
const rule: DataTypeRule = {
64+
variant: DataTypeRulesVariant.ItemOfCollection,
65+
config: ruleConfig
66+
}
67+
return rule;
68+
}
69+
70+
if (config.NumberRange) {
71+
const ruleConfig: DataTypeRulesNumberRangeConfig = {
72+
from: null, //TODO
73+
steps: null, //TODO
74+
to: null, //TODO
75+
}
76+
const rule : DataTypeRule = {
77+
variant: DataTypeRulesVariant.NumberRange,
78+
config: ruleConfig
79+
}
80+
return rule;
81+
}
82+
83+
if (config.Regex) {
84+
const ruleConfig: DataTypeRulesRegexConfig = {
85+
pattern: null, //TODO
86+
}
87+
const rule : DataTypeRule = {
88+
variant: DataTypeRulesVariant.Regex,
89+
config: ruleConfig
90+
}
91+
return rule;
92+
}
93+
94+
if (config.InputTypes) {
95+
const ruleConfig: DataTypeRulesInputTypesConfig = {
96+
inputTypes: null, //TODO
97+
}
98+
const rule : DataTypeRule = {
99+
variant: DataTypeRulesVariant.InputType,
100+
config: ruleConfig
101+
}
102+
return rule;
103+
}
104+
105+
if (config.ReturnType) {
106+
const ruleConfig: DataTypeRulesParentTypeConfig = {
107+
dataTypeIdentifier: null, //TODO
108+
}
109+
const rule : DataTypeRule = {
110+
variant: DataTypeRulesVariant.ReturnType,
111+
config: ruleConfig
112+
}
113+
return rule;
114+
}
115+
116+
if (config.ParentType) {
117+
const ruleConfig: DataTypeRulesParentTypeConfig = {
118+
dataTypeIdentifier: null, //TODO
119+
}
120+
const rule : DataTypeRule = {
121+
variant: DataTypeRulesVariant.ParentType,
122+
config: ruleConfig
123+
}
124+
return rule;
125+
}
126+
127+
throw new Error(`Unknown rule: ${rule}`)
128+
}
129+
)
130+
}
131+
}
132+
133+
function getDataTypeVariant(variant: DefinitionDataType_Variant): DataTypeVariant {
134+
switch (variant) {
135+
case DefinitionDataType_Variant.ARRAY:
136+
return DataTypeVariant.Array
137+
case DefinitionDataType_Variant.DATATYPE:
138+
return DataTypeVariant.DataType;
139+
case DefinitionDataType_Variant.ERROR:
140+
return DataTypeVariant.Error;
141+
case DefinitionDataType_Variant.NODE:
142+
return DataTypeVariant.Node;
143+
case DefinitionDataType_Variant.OBJECT:
144+
return DataTypeVariant.Object;
145+
case DefinitionDataType_Variant.PRIMITIVE:
146+
return DataTypeVariant.Primitive;
147+
case DefinitionDataType_Variant.TYPE:
148+
return DataTypeVariant.Type;
149+
default:
150+
throw new Error(`Unknown variant: ${variant}`);
151+
}
152+
}
153+
154+
export {mapDataType}

‎reader/ts/src/mapper/dataTypeSorter.ts‎

Lines changed: 115 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,115 @@
1+
import {
2+
DefinitionDataType,
3+
DefinitionDataTypeRule
4+
} from "@code0-tech/tucana/pb/shared.data_type_pb.ts";
5+
import {DataTypeIdentifier} from "@code0-tech/tucana/pb/shared.data_type_pb.ts";
6+
7+
function topologicalSort(items: { type: string; dependsOn: string[] }[]) {
8+
const map = new Map<string, { type: string; dependsOn: string[] }>();
9+
const visited = new Set<string>();
10+
const visiting = new Set<string>();
11+
const result: { type: string; dependsOn: string[] }[] = [];
12+
13+
// Build a lookup map
14+
for (const item of items) {
15+
map.set(item.type, item);
16+
}
17+
18+
// Recursive DFS
19+
function visit(type: string) {
20+
if (visited.has(type)) return;
21+
if (visiting.has(type)) {
22+
throw new Error(`Cyclic dependency detected involving "${type}"`);
23+
}
24+
25+
visiting.add(type);
26+
const item = map.get(type);
27+
if (item) {
28+
for (const dep of item.dependsOn) {
29+
visit(dep);
30+
}
31+
result.push(item);
32+
}
33+
visiting.delete(type);
34+
visited.add(type);
35+
}
36+
37+
// Visit all nodes
38+
for (const item of items) {
39+
visit(item.type);
40+
}
41+
42+
return result;
43+
}
44+
45+
function resolveDataTypeIdentifier(dataTypeIdentifier: DataTypeIdentifier | undefined): string[] {
46+
const result: string[] = [];
47+
48+
if (dataTypeIdentifier == undefined) {
49+
return result
50+
}
51+
52+
const dataType: any = dataTypeIdentifier!
53+
54+
if (dataType.type.GenericType) {
55+
result.push(dataType.type.GenericType.data_type_identifier)
56+
// @ts-ignore
57+
dataType.type.GenericType.generic_mappers.forEach(mapper => {
58+
// @ts-ignore
59+
mapper.source.forEach(source => {
60+
result.push(...resolveDataTypeIdentifier(source))
61+
})
62+
})
63+
return result
64+
}
65+
66+
if (dataType.type.DataTypeIdentifier) {
67+
return [dataType.type.DataTypeIdentifier]
68+
}
69+
70+
return result;
71+
}
72+
73+
function getDependencies(rule: DefinitionDataTypeRule): string[] {
74+
const config: any = rule.config;
75+
if (config.ContainsType) {
76+
const dataTypeIdentifier = config.ContainsType.data_type_identifier
77+
return resolveDataTypeIdentifier(dataTypeIdentifier)
78+
}
79+
80+
if (config.InputTypes) {
81+
// @ts-ignore
82+
const dataTypes = config.InputTypes.input_types.map(input => input.data_type_identifier)
83+
return dataTypes.map(resolveDataTypeIdentifier).flat()
84+
}
85+
86+
if (config.ParentType) {
87+
return resolveDataTypeIdentifier(config.ParentType.parent_type)
88+
}
89+
90+
if (config.ReturnType) {
91+
return resolveDataTypeIdentifier(config.ReturnType.data_type_identifier)
92+
}
93+
94+
return []
95+
}
96+
97+
function sortDataTypes(types: DefinitionDataType[]) {
98+
const identifiable = types.map(type => {
99+
const dependencies = type.rules?.map(rule => getDependencies(rule)).flat() ?? []
100+
return {
101+
type: type.identifier,
102+
dependsOn: dependencies
103+
}
104+
})
105+
106+
const sorted = topologicalSort(identifiable)
107+
108+
for (const item of sorted) {
109+
console.log(item)
110+
}
111+
112+
return sorted.map(item => types.find(type => type.identifier === item.type))
113+
}
114+
115+
export {sortDataTypes}

‎reader/ts/src/mapper/flowTypeMapper.ts‎

Lines changed: 36 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,36 @@
1+
import {FlowType as TucanaFlowType, FlowTypeSetting as TucanaFlowTypeSetting} from "@code0-tech/tucana/pb/shared.flow_definition_pb.ts"
2+
import {FlowType, FlowTypeSetting} from "@code0-tech/sagittarius-graphql-types";
3+
import {getDataType, getTranslationConnection} from "./helper.ts";
4+
import {Meta, MetaType} from "../types.ts";
5+
6+
function mapFlowType(meta: Meta): FlowType | null {
7+
if (meta.type != MetaType.FlowType) {
8+
console.error(`Expected FlowType, got ${meta.type}`);
9+
return null;
10+
}
11+
12+
const parsed = JSON.parse(meta.data) as TucanaFlowType;
13+
return {
14+
identifier: parsed.identifier,
15+
inputType: getDataType(parsed.inputTypeIdentifier),
16+
returnType: getDataType(parsed.returnTypeIdentifier),
17+
flowTypeSettings: createFlowTypeSetting(parsed.settings),
18+
names: getTranslationConnection(parsed.name),
19+
descriptions: getTranslationConnection(parsed.description),
20+
editable: parsed.editable
21+
}
22+
}
23+
24+
function createFlowTypeSetting(settings: TucanaFlowTypeSetting[]): FlowTypeSetting[] {
25+
return settings.map(setting => {
26+
return {
27+
names: getTranslationConnection(setting.name),
28+
descriptions: getTranslationConnection(setting.description),
29+
dataType: getDataType(setting.dataTypeIdentifier),
30+
identifier: setting.identifier,
31+
unique: setting.unique
32+
}
33+
})
34+
}
35+
36+
export {mapFlowType}

‎reader/ts/src/mapper/functionMapper.ts‎

Lines changed: 42 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,42 @@
1+
import {Meta, MetaType} from "../types.ts";
2+
import {FunctionDefinition, ParameterDefinitionConnection} from "@code0-tech/sagittarius-graphql-types";
3+
import {
4+
RuntimeFunctionDefinition as TucanaFunction,
5+
RuntimeParameterDefinition
6+
} from "@code0-tech/tucana/pb/shared.runtime_function_pb.ts";
7+
import {getDataTypeIdentifier, getTranslationConnection} from "./helper.ts";
8+
9+
function mapFunction(meta:Meta): FunctionDefinition | null {
10+
if (meta.type != MetaType.RuntimeFunction) {
11+
console.error(`Expected RuntimeFunction, got ${meta.type}`);
12+
return null;
13+
}
14+
15+
const parsed = JSON.parse(meta.data) as TucanaFunction;
16+
return {
17+
genericKeys: parsed.genericKeys,
18+
names: getTranslationConnection(parsed.name),
19+
descriptions: getTranslationConnection(parsed.description),
20+
documentations: getTranslationConnection(parsed.documentation),
21+
deprecationMessages: getTranslationConnection(parsed.deprecationMessage),
22+
throwsError: parsed.throwsError,
23+
returnType: getDataTypeIdentifier(parsed.returnTypeIdentifier),
24+
parameterDefinitions: getParameterDefinitionConnection(parsed.runtimeParameterDefinitions),
25+
}
26+
}
27+
28+
function getParameterDefinitionConnection(def: RuntimeParameterDefinition[]): ParameterDefinitionConnection {
29+
return {
30+
count: def.length,
31+
nodes: def.map(node => {
32+
return {
33+
names: getTranslationConnection(node.name),
34+
descriptions: getTranslationConnection(node.description),
35+
documentations: getTranslationConnection(node.documentation),
36+
dataType: getDataTypeIdentifier(node.dataTypeIdentifier)
37+
}
38+
})
39+
}
40+
}
41+
42+
export {mapFunction}

‎reader/ts/src/mapper/helper.ts‎

Lines changed: 21 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,21 @@
1+
import {DataType, DataTypeIdentifier, TranslationConnection} from "@code0-tech/sagittarius-graphql-types";
2+
import {Translation} from "@code0-tech/tucana/pb/shared.translation_pb.ts";
3+
4+
function getDataType(identifier: string | undefined): DataType {
5+
// @ts-ignore
6+
return null
7+
}
8+
9+
function getDataTypeIdentifier(identifier: string): DataTypeIdentifier {
10+
// @ts-ignore
11+
return null
12+
}
13+
14+
function getTranslationConnection(translation: Translation[]): TranslationConnection {
15+
return {
16+
count: translation.length,
17+
nodes: translation,
18+
}
19+
}
20+
21+
export {getDataType, getDataTypeIdentifier, getTranslationConnection}

0 commit comments

Comments
 (0)