d6cee80cab3350e63d20bd40f8cb937e70944426
[erdiag.git] / parser.js
1 // ER diagram description parser
2 class ErDiags
3 {
4 constructor(description, output, image)
5 {
6 this.entities = { };
7 this.inheritances = [ ];
8 this.associations = [ ];
9 this.tables = { };
10 this.mcdParsing(description);
11 this.mldParsing();
12 this.output = output || "compact";
13 this.image = image || "svg";
14 }
15
16 static CARDINAL(symbol)
17 {
18 let res = { "*": "0,n", "+": "1,n", "?": "0,1", "1": "1,1" } [ symbol[0] ];
19 if (symbol.length >= 2)
20 {
21 if (symbol[1] == 'R')
22 res = '(' + res + ')';
23 else if (['>','<'].includes(symbol[1]))
24 res += symbol[1];
25 }
26 return res;
27 }
28
29 ///////////////////////////////
30 // PARSING STAGE 1: text to MCD
31 ///////////////////////////////
32
33 // Parse a textual description into a json object
34 mcdParsing(text)
35 {
36 let lines = text.split("\n");
37 lines.push(""); //easier parsing: always empty line at the end
38 let start = -1;
39 for (let i=0; i < lines.length; i++)
40 {
41 lines[i] = lines[i].trim();
42 // Empty line ?
43 if (lines[i].length == 0)
44 {
45 if (start >= 0) //there is some group of lines to parse
46 {
47 this.parseThing(lines, start, i);
48 start = -1;
49 }
50 }
51 else //not empty line: just register starting point
52 {
53 if (start < 0)
54 start = i;
55 }
56 }
57 }
58
59 // Parse a group of lines into entity, association, ...
60 parseThing(lines, start, end) //start included, end excluded
61 {
62 switch (lines[start].charAt(0))
63 {
64 case '[':
65 // Entity = { name: { attributes, [weak] } }
66 let name = lines[start].match(/[^\[\]"\s]+/)[0];
67 let entity = { attributes: this.parseAttributes(lines, start+1, end) };
68 if (lines[start].charAt(1) == '[')
69 entity.weak = true;
70 this.entities[name] = entity;
71 break;
72 case 'i': //inheritance (arrows)
73 this.inheritances = this.inheritances.concat(this.parseInheritance(lines, start+1, end));
74 break;
75 case '{': //association
76 // Association = { [name], [attributes], [weak], entities: ArrayOf entity indices }
77 let relationship = { };
78 let nameRes = lines[start].match(/[^{}"\s]+/);
79 if (nameRes !== null)
80 relationship.name = nameRes[0];
81 if (lines[start].charAt(1) == '{')
82 relationship.weak = true;
83 this.associations.push(Object.assign({}, relationship, this.parseAssociation(lines, start+1, end)));
84 break;
85 }
86 }
87
88 // attributes: ArrayOf {name, [isKey], [type], [qualifiers]}
89 parseAttributes(lines, start, end)
90 {
91 let attributes = [ ];
92 for (let i=start; i<end; i++)
93 {
94 let field = { };
95 let line = lines[i];
96 if (line.charAt(0) == '+')
97 {
98 field.isKey = true;
99 line = line.slice(1);
100 }
101 field.name = line.match(/[^"\s]+/)[0];
102 let sqlClues = line.substring(field.name.length).trim();
103 if (sqlClues.length > 0)
104 {
105 field.type = sqlClues.match(/[^\s]+/)[0]; //type is always the first indication (mandatory)
106 field.qualifiers = sqlClues.substring(field.type.length);
107 }
108 attributes.push(field);
109 }
110 return attributes;
111 }
112
113 // GroupOf Inheritance: { parent, children: ArrayOf entity indices }
114 parseInheritance(lines, start, end)
115 {
116 let inheritance = [];
117 for (let i=start; i<end; i++)
118 {
119 let lineParts = lines[i].split(" ");
120 let children = [];
121 for (let j=1; j<lineParts.length; j++)
122 children.push(lineParts[j]);
123 inheritance.push({ parent:lineParts[0], children: children });
124 }
125 return inheritance;
126 }
127
128 // Association (parsed here): {
129 // entities: ArrayOf entity names + cardinality,
130 // [attributes: ArrayOf {name, [isKey], [type], [qualifiers]}]
131 // }
132 parseAssociation(lines, start, end)
133 {
134 let assoce = { };
135 let entities = [];
136 let i = start;
137 while (i < end)
138 {
139 if (lines[i].charAt(0) == '-')
140 {
141 assoce.attributes = this.parseAttributes(lines, i+1, end);
142 break;
143 }
144 else
145 {
146 // Read entity name + cardinality
147 let lineParts = lines[i].split(" ");
148 entities.push({ name:lineParts[0], card:lineParts[1] });
149 }
150 i++;
151 }
152 assoce.entities = entities;
153 return assoce;
154 }
155
156 //////////////////////////////
157 // PARSING STAGE 2: MCD to MLD
158 //////////////////////////////
159
160 // From entities + relationships to tables
161 mldParsing()
162 {
163 // Pass 1: initialize tables
164 Object.keys(this.entities).forEach( name => {
165 let newTable = [ ]; //array of fields
166 this.entities[name].attributes.forEach( attr => {
167 let newField = {
168 name: attr.name,
169 type: attr.type,
170 isKey: attr.isKey,
171 };
172 if (!!attr.qualifiers && !!attr.qualifiers.match(/references/i))
173 {
174 Object.assign(newField, {ref: attr.qualifiers.match(/references ([^\s]+)/i)[1]});
175 newField.qualifiers = attr.qualifiers.replace(/references [^\s]+/i, "");
176 }
177 newTable.push(newField);
178 });
179 this.tables[name] = newTable;
180 });
181 // Add foreign keys information for children (inheritance). TODO: allow several levels
182 // NOTE: modelisation assume each child has its own table, refering parent (other options exist)
183 this.inheritances.forEach( inh => {
184 let idx = this.tables[inh.parent].findIndex( item => { return item.isKey; });
185 inh.children.forEach( c => {
186 this.tables[c].push({
187 name: inh.parent + "_id",
188 type: this.tables[inh.parent][idx].type,
189 isKey: true,
190 <<<<<<< HEAD
191 qualifiers: (this.tables[inh.parent][idx].qualifiers || "") + " foreign key references " + inh.parent,
192 ref: inh.parent,
193 =======
194 qualifiers: this.tables[inh.parent][idx].qualifiers || "",
195 ref: inh.parent + "(" + this.tables[inh.parent][idx].name + ")",
196 >>>>>>> 40b4a9d230d105a61e22bef0a63a6e8d515524e9
197 });
198 });
199 });
200 // Pass 2: parse associations, add foreign keys when cardinality is 0,1 or 1,1
201 this.associations.forEach( a => {
202 let newTableAttrs = [ ];
203 let hasZeroOne = false;
204 a.entities.forEach( e => {
205 if (['?','1'].includes(e.card[0]))
206 {
207 hasZeroOne = true;
208 // Foreign key apparition (for each entity in association minus current one, for each identifying attribute)
209 a.entities.forEach( e2 => {
210 if (e2.name == e.name)
211 return;
212 this.entities[e2.name].attributes.forEach( attr => {
213 if (attr.isKey)
214 {
215 // For "weak tables", foreign keys become part of the key
216 const isKey = e.card.length >= 2 && e.card[1] == 'R';
217 this.tables[e.name].push({
218 isKey: isKey,
219 name: e2.name + "_" + attr.name,
220 type: attr.type,
221 qualifiers: !isKey && e.card[0]=='1' ? "not null" : "",
222 ref: e2.name + "(" + attr.name + ")",
223 });
224 }
225 });
226 });
227 }
228 else
229 {
230 // Add all keys in current entity
231 let fields = this.entities[e.name].attributes.filter( attr => { return attr.isKey; });
232 newTableAttrs.push({
233 fields: fields,
234 entity: e.name,
235 });
236 }
237 });
238 if (!hasZeroOne && newTableAttrs.length > 1)
239 {
240 // Ok, really create a new table
241 let newTable = {
242 name: a.name || newTableAttrs.map( item => { return item.entity; }).join("_"),
243 fields: [ ],
244 };
245 newTableAttrs.forEach( item => {
246 item.fields.forEach( f => {
247 newTable.fields.push({
248 name: item.entity + "_" + f.name,
249 isKey: true,
250 type: f.type,
251 qualifiers: f.qualifiers || "",
252 ref: item.entity + "(" + f.name + ")",
253 });
254 });
255 });
256 // Check for duplicates (in case of self-relationship), rename if needed
257 newTable.fields.forEach( (f,i) => {
258 const idx = newTable.fields.findIndex( item => { return item.name == f.name; });
259 if (idx < i)
260 {
261 // Current field is a duplicate
262 let suffix = 2;
263 let newName = f.name + suffix;
264 while (newTable.fields.findIndex( item => { return item.name == newName; }) >= 0)
265 {
266 suffix++;
267 newName = f.name + suffix;
268 }
269 f.name = newName;
270 }
271 });
272 // Add relationship potential own attributes
273 (a.attributes || [ ]).forEach( attr => {
274 newTable.fields.push({
275 name: attr.name,
276 isKey: false,
277 type: attr.type,
278 qualifiers: attr.qualifiers,
279 });
280 });
281 this.tables[newTable.name] = newTable.fields;
282 }
283 });
284 }
285
286 /////////////////////////////////
287 // DRAWING + GET SQL FROM PARSING
288 /////////////////////////////////
289
290 // "Modèle conceptuel des données". TODO: option for graph size
291 // NOTE: randomizing helps to obtain better graphs (sometimes)
292 drawMcd(id, mcdStyle) //mcdStyle: bubble, or compact
293 {
294 let element = document.getElementById(id);
295 mcdStyle = mcdStyle || "compact";
296 // Build dot graph input
297 let mcdDot = 'graph {\n';
298 mcdDot += 'rankdir="LR";\n';
299 // Nodes:
300 if (mcdStyle == "compact")
301 mcdDot += 'node [shape=plaintext];\n';
302 _.shuffle(Object.keys(this.entities)).forEach( name => {
303 if (mcdStyle == "bubble")
304 {
305 mcdDot += '"' + name + '" [shape=rectangle, label="' + name + '"';
306 if (this.entities[name].weak)
307 mcdDot += ', peripheries=2';
308 mcdDot += '];\n';
309 if (!!this.entities[name].attributes)
310 {
311 this.entities[name].attributes.forEach( a => {
312 let label = (a.isKey ? '#' : '') + a.name;
313 let attrName = name + '_' + a.name;
314 mcdDot += '"' + attrName + '" [shape=ellipse, label="' + label + '"];\n';
315 if (Math.random() < 0.5)
316 mcdDot += '"' + attrName + '" -- "' + name + '";\n';
317 else
318 mcdDot += '"' + name + '" -- "' + attrName + '";\n';
319 });
320 }
321 }
322 else
323 {
324 mcdDot += '"' + name + '" [label=<';
325 if (this.entities[name].weak)
326 {
327 mcdDot += '<table port="name" BORDER="1" ALIGN="LEFT" CELLPADDING="0" CELLSPACING="3" CELLBORDER="0">' +
328 '<tr><td><table BORDER="1" ALIGN="LEFT" CELLPADDING="5" CELLSPACING="0">\n';
329 }
330 else
331 mcdDot += '<table port="name" BORDER="1" ALIGN="LEFT" CELLPADDING="5" CELLSPACING="0">\n';
332 mcdDot += '<tr><td BGCOLOR="#ae7d4e" BORDER="0"><font COLOR="#FFFFFF">' + name + '</font></td></tr>\n';
333 if (!!this.entities[name].attributes)
334 {
335 this.entities[name].attributes.forEach( a => {
336 let label = (a.isKey ? '<u>' : '') + a.name + (a.isKey ? '</u>' : '');
337 mcdDot += '<tr><td BGCOLOR="#FFFFFF" BORDER="0" ALIGN="LEFT"><font COLOR="#000000" >' + label + '</font></td></tr>\n';
338 });
339 }
340 mcdDot += '</table>';
341 if (this.entities[name].weak)
342 mcdDot += '</td></tr></table>';
343 mcdDot += '>];\n';
344 }
345 });
346 // Inheritances:
347 _.shuffle(this.inheritances).forEach( i => {
348 // TODO: node shape = triangle fill yellow. See
349 // https://merise.developpez.com/faq/?page=MCD#CIF-ou-dependance-fonctionnelle-de-A-a-Z
350 // https://merise.developpez.com/faq/?page=MLD#Comment-transformer-un-MCD-en-MLD
351 // https://www.developpez.net/forums/d1088964/general-developpement/alm/modelisation/structure-agregation-l-association-d-association/
352 _.shuffle(i.children).forEach( c => {
353 if (Math.random() < 0.5)
354 mcdDot += '"' + c + '":name -- "' + i.parent + '":name [dir="forward",arrowhead="vee",';
355 else
356 mcdDot += '"' + i.parent + '":name -- "' + c + '":name [dir="back",arrowtail="vee",';
357 mcdDot += 'style="dashed"];\n';
358 });
359 });
360 // Relationships:
361 if (mcdStyle == "compact")
362 mcdDot += 'node [shape=rectangle, style=rounded];\n';
363 let assoceCounter = 0;
364 _.shuffle(this.associations).forEach( a => {
365 let name = a.name || "_assoce" + assoceCounter++;
366 if (mcdStyle == "bubble")
367 {
368 mcdDot += '"' + name + '" [shape="diamond", style="filled", color="lightgrey", label="' + name + '"';
369 if (a.weak)
370 mcdDot += ', peripheries=2';
371 mcdDot += '];\n';
372 if (!!a.attributes)
373 {
374 a.attributes.forEach( attr => {
375 let label = (attr.isKey ? '#' : '') + attr.name;
376 mcdDot += '"' + name + '_' + attr.name + '" [shape=ellipse, label="' + label + '"];\n';
377 let attrName = name + '_' + attr.name;
378 if (Math.random() < 0.5)
379 mcdDot += '"' + attrName + '" -- "' + name + '";\n';
380 else
381 mcdDot += '"' + name + '" -- "' + attrName + '";\n';
382 });
383 }
384 }
385 else
386 {
387 let label = '<' + name + '>';
388 if (!!a.attributes)
389 {
390 a.attributes.forEach( attr => {
391 let attrLabel = (attr.isKey ? '#' : '') + attr.name;
392 label += '\\n' + attrLabel;
393 });
394 }
395 mcdDot += '"' + name + '" [color="lightgrey", label="' + label + '"';
396 if (a.weak)
397 mcdDot += ', peripheries=2';
398 mcdDot += '];\n';
399 }
400 _.shuffle(a.entities).forEach( e => {
401 if (Math.random() < 0.5)
402 mcdDot += '"' + e.name + '":name -- "' + name + '"';
403 else
404 mcdDot += '"' + name + '" -- "' + e.name + '":name';
405 mcdDot += '[label="' + ErDiags.CARDINAL(e.card) + '"];\n';
406 });
407 });
408 mcdDot += '}';
409 if (this.output == "graph") //draw graph in element
410 element.innerHTML = "<img src='scripts/getGraph_" + this.image + ".php?dot=" + encodeURIComponent(mcdDot) + "'/>";
411 else //just show dot input
412 element.innerHTML = mcdDot.replace(/</g,"&lt;").replace(/>/g,"&gt;");
413 }
414
415 // "Modèle logique des données", from MCD without anomalies
416 drawMld(id)
417 {
418 let element = document.getElementById(id);
419 // Build dot graph input (assuming foreign keys not already present...)
420 let mldDot = 'graph {\n';
421 mldDot += 'rankdir="LR";\n';
422 mldDot += 'node [shape=plaintext];\n';
423 let links = "";
424 _.shuffle(Object.keys(this.tables)).forEach( name => {
425 mldDot += '"' + name + '" [label=<<table BORDER="1" ALIGN="LEFT" CELLPADDING="5" CELLSPACING="0">\n';
426 mldDot += '<tr><td BGCOLOR="#ae7d4e" BORDER="0"><font COLOR="#FFFFFF">' + name + '</font></td></tr>\n';
427 this.tables[name].forEach( f => {
428 let label = (f.isKey ? '<u>' : '') + (!!f.ref ? '#' : '') + f.name + (f.isKey ? '</u>' : '');
429 mldDot += '<tr><td port="' + f.name + '"' + ' BGCOLOR="#FFFFFF" BORDER="0" ALIGN="LEFT"><font COLOR="#000000" >' + label + '</font></td></tr>\n';
430 if (!!f.ref)
431 {
432 const refPort = f.ref.slice(0,-1).replace('(',':');
433 if (Math.random() < 0.5)
434 links += refPort + ' -- "' + name+'":"'+f.name + '" [dir="forward",arrowhead="dot"';
435 else
436 links += '"'+name+'":"'+f.name+'" -- ' + refPort + ' [dir="back",arrowtail="dot"';
437 links += ']\n;';
438 }
439 });
440 mldDot += '</table>>];\n';
441 });
442 mldDot += links + '\n';
443 mldDot += '}';
444 if (this.output == "graph")
445 element.innerHTML = "<img src='scripts/getGraph_" + this.image + ".php?dot=" + encodeURIComponent(mldDot) + "'/>";
446 else
447 element.innerHTML = mldDot.replace(/</g,"&lt;").replace(/>/g,"&gt;");
448 }
449
450 fillSql(id)
451 {
452 let element = document.getElementById(id);
453 if (!!this.sqlText)
454 {
455 element.innerHTML = this.sqlText;
456 return;
457 }
458 let sqlText = "";
459 Object.keys(this.tables).forEach( name => {
460 sqlText += "CREATE TABLE " + name + " (\n";
461 let key = "";
462 let foreignKey = [ ];
463 this.tables[name].forEach( f => {
464 let type = f.type || (f.isKey ? "INTEGER" : "TEXT");
465 if (!!f.ref)
466 foreignKey.push({name: f.name, ref: f.ref});
467 sqlText += "\t" + f.name + " " + type + " " + (f.qualifiers || "") + ",\n";
468 if (f.isKey)
469 key += (key.length>0 ? "," : "") + f.name;
470 });
471 sqlText += "\tPRIMARY KEY (" + key + ")";
472 foreignKey.forEach( f => {
473 let refParts = f.ref.split("(");
474 const table = refParts[0];
475 const field = refParts[1].slice(0,-1); //remove last parenthesis
476 sqlText += ",\n\tFOREIGN KEY (" + f.name + ") REFERENCES " + table + "(" + field + ")";
477 });
478 sqlText += "\n);\n";
479 });
480 this.sqlText = sqlText;
481 element.innerHTML = "<pre><code>" + sqlText + "</code></pre>";
482 }
483 }