refactor: move core-tools to monorepo

packages/core-tools/test/common.spec.ts

@@ -0,0 +1,35 @@
+/* eslint-disable unicorn/prefer-module */
+/*
+ * Copyright (C) 2018-2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {Logger} from '@openstapps/logger';
+import {expect} from 'chai';
+import {slow, suite, test, timeout} from '@testdeck/mocha';
+import {cwd} from 'process';
+import {getTsconfigPath} from '../src/common';
+
+process.on('unhandledRejection', (reason: unknown): void => {
+  if (reason instanceof Error) {
+    void Logger.error('UNHANDLED REJECTION', reason.stack);
+  }
+  process.exit(1);
+});
+
+@suite(timeout(20_000), slow(10_000))
+export class CommonSpec {
+  @test
+  async getTsconfigPath() {
+    expect(getTsconfigPath(__dirname)).to.be.equal(cwd());
+  }
+}

packages/core-tools/test/create-diagram.spec.ts

@@ -0,0 +1,89 @@
+/* eslint-disable unicorn/prefer-module */
+/*
+ * Copyright (C) 2018-2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {expect} from 'chai';
+import {existsSync, unlinkSync} from 'fs';
+import {slow, suite, test, timeout} from '@testdeck/mocha';
+import {createDiagram, createDiagramFromString} from '../src/uml/create-diagram';
+import {UMLConfig} from '../src/uml/uml-config';
+import {LightweightDefinition} from '../src/easy-ast/types/lightweight-definition';
+import nock = require('nock');
+import {lightweightDefinitionsFromPath} from '../src/easy-ast/easy-ast';
+import path from 'path';
+
+@suite(timeout(15_000), slow(5000))
+export class CreateDiagramSpec {
+  plantUmlConfig: UMLConfig;
+
+  definitions: LightweightDefinition[];
+
+  constructor() {
+    this.plantUmlConfig = {
+      definitions: [],
+      showAssociations: true,
+      showEnumValues: true,
+      showInheritance: true,
+      showInheritedProperties: true,
+      showOptionalProperties: true,
+      showProperties: true,
+    };
+
+    this.definitions = lightweightDefinitionsFromPath('./test/model');
+  }
+
+  @test
+  async shouldRefuseRequest() {
+    const testPlantUmlCode = 'class Test{\n}';
+    try {
+      await createDiagramFromString(testPlantUmlCode, 'http://plantuml:8080');
+    } catch (error) {
+      expect([
+        new Error('getaddrinfo ENOTFOUND plantuml plantuml:8080').message,
+        new Error('getaddrinfo EAI_AGAIN plantuml plantuml:8080').message,
+        new Error('getaddrinfo ENOTFOUND plantuml').message,
+      ]).to.include((error as NodeJS.ErrnoException).message);
+    }
+  }
+
+  /**
+   * This test will only test the functionality of the method
+   * - Converting the definitions to plantuml code
+   * - Sending the code to a server
+   * - Writing the response to a file
+   * This test will not check the file content
+   */
+  @test
+  async shouldCreateDiagrams() {
+    nock('http://plantuml:8080')
+      .persist()
+      .get(() => true)
+      .reply(200, 'This will be the file content');
+
+    let fileName = await createDiagram(this.definitions, this.plantUmlConfig, 'http://plantuml:8080');
+    let filePath = path.resolve(__dirname, '..', fileName);
+    expect(await existsSync(filePath)).to.equal(true);
+
+    await unlinkSync(fileName);
+    this.plantUmlConfig.showAssociations = false;
+
+    this.plantUmlConfig.showInheritance = false;
+    fileName = await createDiagram(this.definitions, this.plantUmlConfig, 'http://plantuml:8080');
+    filePath = path.resolve(__dirname, '..', fileName);
+    expect(await existsSync(filePath)).to.equal(true);
+    await unlinkSync(fileName);
+
+    nock.cleanAll();
+  }
+}

packages/core-tools/test/easy-ast.spec.ts

@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2021 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {expandPathToFilesSync, toUnixPath} from '../src/util/io';
+import {EasyAstSpecType} from './easy-ast/easy-ast-spec-type';
+import {lightweightProjectFromPath} from '../src/easy-ast/easy-ast';
+import {expect} from 'chai';
+import {omitBy} from 'lodash';
+
+describe('Easy AST', async () => {
+  const project = lightweightProjectFromPath('./test/easy-ast', true);
+  for (const file of expandPathToFilesSync('./test/easy-ast', file => file.endsWith('ast-test.ts'))) {
+    try {
+      const test = (await import(file))['testConfig'] as EasyAstSpecType;
+
+      it(test.testName, () => {
+        expect(omitBy(project[toUnixPath(file)], (_value, key) => key.startsWith('$'))).to.be.deep.equal(
+          test.expected,
+        );
+      });
+    } catch (error) {
+      console.error(error);
+    }
+  }
+});

packages/core-tools/test/easy-ast/alias-like.ast-test.ts

@@ -0,0 +1,68 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/*
+ * Copyright (C) 2021 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {EasyAstSpecType} from './easy-ast-spec-type';
+import {LightweightDefinitionKind} from '../../src/easy-ast/types/lightweight-definition-kind';
+
+type TestTypeAlias = number | string;
+
+enum TestEnum {
+  Foo,
+  Bar,
+}
+
+export const testConfig: EasyAstSpecType = {
+  testName: `should resolve alias-likes`,
+  expected: {
+    TestTypeAlias: {
+      name: 'TestTypeAlias',
+      kind: LightweightDefinitionKind.ALIAS_LIKE,
+      modifiers: ['type'],
+      type: {
+        flags: 1_048_576,
+        specificationTypes: [
+          {
+            value: 'string',
+            flags: 4,
+          },
+          {
+            value: 'number',
+            flags: 8,
+          },
+        ],
+      },
+    },
+    TestEnum: {
+      name: 'TestEnum',
+      kind: LightweightDefinitionKind.ALIAS_LIKE,
+      modifiers: ['enum'],
+      type: {
+        flags: 1_048_576,
+        specificationTypes: [
+          {
+            referenceName: 'Foo',
+            value: 0,
+            flags: 1280,
+          },
+          {
+            referenceName: 'Bar',
+            value: 1,
+            flags: 1280,
+          },
+        ],
+      },
+    },
+  },
+};

packages/core-tools/test/easy-ast/array-like.ast-test.ts

@@ -0,0 +1,75 @@
+/* eslint-disable @typescript-eslint/no-unused-vars,@typescript-eslint/no-empty-interface */
+/*
+ * Copyright (C) 2021 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {EasyAstSpecType} from './easy-ast-spec-type';
+import {LightweightDefinitionKind} from '../../src/easy-ast/types/lightweight-definition-kind';
+
+interface Random {}
+
+type TestArrayGeneric = Array<string>;
+type TestArrayLiteral = number[];
+type TestArrayReferenceGeneric = Array<Random>;
+type TestArrayReferenceLiteral = Random[];
+
+export const testConfig: EasyAstSpecType = {
+  testName: `should resolve array-likes`,
+  expected: {
+    TestArrayGeneric: {
+      name: 'TestArrayGeneric',
+      kind: LightweightDefinitionKind.ALIAS_LIKE,
+      modifiers: ['type'],
+      type: {
+        value: 'string',
+        flags: 4,
+        isArray: true,
+      },
+    },
+    TestArrayLiteral: {
+      name: 'TestArrayLiteral',
+      kind: LightweightDefinitionKind.ALIAS_LIKE,
+      modifiers: ['type'],
+      type: {
+        value: 'number',
+        flags: 8,
+        isArray: true,
+      },
+    },
+    TestArrayReferenceGeneric: {
+      name: 'TestArrayReferenceGeneric',
+      kind: LightweightDefinitionKind.ALIAS_LIKE,
+      modifiers: ['type'],
+      type: {
+        referenceName: 'Random',
+        flags: 524_288,
+        isArray: true,
+      },
+    },
+    TestArrayReferenceLiteral: {
+      name: 'TestArrayReferenceLiteral',
+      kind: LightweightDefinitionKind.ALIAS_LIKE,
+      modifiers: ['type'],
+      type: {
+        referenceName: 'Random',
+        flags: 524_288,
+        isArray: true,
+      },
+    },
+    Random: {
+      name: 'Random',
+      kind: LightweightDefinitionKind.CLASS_LIKE,
+      modifiers: ['interface'],
+    },
+  },
+};

packages/core-tools/test/easy-ast/class-like.ast-test.ts

@@ -0,0 +1,59 @@
+/* eslint-disable @typescript-eslint/no-unused-vars,@typescript-eslint/no-inferrable-types */
+/*
+ * Copyright (C) 2021 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {EasyAstSpecType} from './easy-ast-spec-type';
+import {LightweightDefinitionKind} from '../../src/easy-ast/types/lightweight-definition-kind';
+
+interface TestInterface {
+  foo: number;
+}
+
+class TestClass {
+  bar: string = 'test';
+}
+
+export const testConfig: EasyAstSpecType = {
+  testName: `should resolve class-likes`,
+  expected: {
+    TestInterface: {
+      name: 'TestInterface',
+      kind: LightweightDefinitionKind.CLASS_LIKE,
+      modifiers: ['interface'],
+      properties: {
+        foo: {
+          name: 'foo',
+          type: {
+            value: 'number',
+            flags: 8,
+          },
+        },
+      },
+    },
+    TestClass: {
+      name: 'TestClass',
+      kind: LightweightDefinitionKind.CLASS_LIKE,
+      modifiers: ['class'],
+      properties: {
+        bar: {
+          name: 'bar',
+          type: {
+            value: 'string',
+            flags: 4,
+          },
+        },
+      },
+    },
+  },
+};

packages/core-tools/test/easy-ast/comment.ast-test.ts

@@ -0,0 +1,161 @@
+/* eslint-disable @typescript-eslint/no-unused-vars,jsdoc/check-tag-names */
+/*
+ * Copyright (C) 2021 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {EasyAstSpecType} from './easy-ast-spec-type';
+import {LightweightDefinitionKind} from '../../src/easy-ast/types/lightweight-definition-kind';
+
+/**
+ * Class comment
+ *
+ * Class description
+ *
+ * More description
+ *
+ * @classTag classParameter1 classParameter2
+ */
+interface TestInterface {
+  /**
+   * Property comment
+   *
+   * Property description
+   *
+   * More description
+   *
+   * @propertyTag propertyParameter1 propertyParameter2
+   */
+  foo: string;
+}
+
+/**
+ * Class comment
+ *
+ * Class description
+ *
+ * More description
+ *
+ * @classTag classParameter1 classParameter2
+ */
+class TestClass {
+  /**
+   * Property comment
+   *
+   * Property description
+   *
+   * More description
+   *
+   * @propertyTag propertyParameter1 propertyParameter2
+   */
+  foo = 1;
+}
+
+/**
+ * Enum comment
+ *
+ * Enum description
+ *
+ * More description
+ *
+ * @enumTag enumParameter1
+ */
+enum TestAlias {}
+
+export const testConfig: EasyAstSpecType = {
+  testName: `should resolve comments`,
+  expected: {
+    TestInterface: {
+      comment: {
+        shortSummary: 'Class comment',
+        description: 'Class description\n\nMore description',
+        tags: [
+          {
+            name: 'classTag',
+            parameters: ['classParameter1', 'classParameter2'],
+          },
+        ],
+      },
+      name: 'TestInterface',
+      kind: LightweightDefinitionKind.CLASS_LIKE,
+      modifiers: ['interface'],
+      properties: {
+        foo: {
+          comment: {
+            shortSummary: 'Property comment',
+            description: 'Property description\n\nMore description',
+            tags: [
+              {
+                name: 'propertyTag',
+                parameters: ['propertyParameter1', 'propertyParameter2'],
+              },
+            ],
+          },
+          name: 'foo',
+          type: {
+            value: 'string',
+            flags: 4,
+          },
+        },
+      },
+    },
+    TestClass: {
+      comment: {
+        shortSummary: 'Class comment',
+        description: 'Class description\n\nMore description',
+        tags: [
+          {
+            name: 'classTag',
+            parameters: ['classParameter1', 'classParameter2'],
+          },
+        ],
+      },
+      name: 'TestClass',
+      kind: LightweightDefinitionKind.CLASS_LIKE,
+      modifiers: ['class'],
+      properties: {
+        foo: {
+          comment: {
+            shortSummary: 'Property comment',
+            description: 'Property description\n\nMore description',
+            tags: [
+              {
+                name: 'propertyTag',
+                parameters: ['propertyParameter1', 'propertyParameter2'],
+              },
+            ],
+          },
+          name: 'foo',
+          type: {
+            value: 'number',
+            flags: 8,
+          },
+        },
+      },
+    },
+    TestAlias: {
+      comment: {
+        shortSummary: 'Enum comment',
+        description: 'Enum description\n\nMore description',
+        tags: [
+          {
+            name: 'enumTag',
+            parameters: ['enumParameter1'],
+          },
+        ],
+      },
+      name: 'TestAlias',
+      kind: LightweightDefinitionKind.ALIAS_LIKE,
+      modifiers: ['enum'],
+    },
+  },
+};

packages/core-tools/test/easy-ast/default-generics.ast-test.ts

@@ -0,0 +1,66 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/*
+ * Copyright (C) 2021 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {EasyAstSpecType} from './easy-ast-spec-type';
+import {LightweightDefinitionKind} from '../../src/easy-ast/types/lightweight-definition-kind';
+
+interface Test1<T = number> {
+  foo: T;
+}
+
+interface Test2 {
+  bar: Test1;
+}
+
+export const testConfig: EasyAstSpecType = {
+  testName: `should resolve default generics`,
+  expected: {
+    Test1: {
+      name: 'Test1',
+      kind: LightweightDefinitionKind.CLASS_LIKE,
+      modifiers: ['interface'],
+      typeParameters: ['T'],
+      properties: {
+        foo: {
+          name: 'foo',
+          type: {
+            referenceName: 'T',
+            flags: 262_144,
+          },
+        },
+      },
+    },
+    Test2: {
+      name: 'Test2',
+      kind: LightweightDefinitionKind.CLASS_LIKE,
+      modifiers: ['interface'],
+      properties: {
+        bar: {
+          name: 'bar',
+          type: {
+            referenceName: 'Test1',
+            flags: 524_288,
+            genericsTypes: [
+              {
+                value: 'number',
+                flags: 8,
+              },
+            ],
+          },
+        },
+      },
+    },
+  },
+};

packages/core-tools/test/easy-ast/easy-ast-spec-type.ts

@@ -0,0 +1,20 @@
+/*
+ * Copyright (C) 2021 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {LightweightFile} from '../../src/easy-ast/types/lightweight-project';
+
+export interface EasyAstSpecType {
+  testName: string;
+  expected: LightweightFile;
+}

packages/core-tools/test/easy-ast/enum-specified-value.ast-test.ts

@@ -0,0 +1,73 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/*
+ * Copyright (C) 2021 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {EasyAstSpecType} from './easy-ast-spec-type';
+import {LightweightDefinitionKind} from '../../src/easy-ast/types/lightweight-definition-kind';
+
+enum TestAuto {
+  Foo,
+  Bar,
+}
+
+enum TestSpecified {
+  YES = 'yes',
+  NO = 'no',
+}
+
+export const testConfig: EasyAstSpecType = {
+  testName: `should resolve auto and specified enums`,
+  expected: {
+    TestAuto: {
+      name: 'TestAuto',
+      kind: LightweightDefinitionKind.ALIAS_LIKE,
+      modifiers: ['enum'],
+      type: {
+        flags: 1_048_576,
+        specificationTypes: [
+          {
+            referenceName: 'Foo',
+            value: 0,
+            flags: 1280,
+          },
+          {
+            referenceName: 'Bar',
+            value: 1,
+            flags: 1280,
+          },
+        ],
+      },
+    },
+    TestSpecified: {
+      name: 'TestSpecified',
+      kind: LightweightDefinitionKind.ALIAS_LIKE,
+      modifiers: ['enum'],
+      type: {
+        flags: 1_048_576,
+        specificationTypes: [
+          {
+            referenceName: 'YES',
+            value: 'yes',
+            flags: 1152,
+          },
+          {
+            referenceName: 'NO',
+            value: 'no',
+            flags: 1152,
+          },
+        ],
+      },
+    },
+  },
+};

packages/core-tools/test/easy-ast/generics.ast-test.ts

@@ -0,0 +1,80 @@
+/* eslint-disable @typescript-eslint/no-empty-interface,@typescript-eslint/no-unused-vars */
+/*
+ * Copyright (C) 2021 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {EasyAstSpecType} from './easy-ast-spec-type';
+import {LightweightDefinitionKind} from '../../src/easy-ast/types/lightweight-definition-kind';
+
+interface $Random {}
+
+interface Generics {
+  baz: Foo<number, $Random>;
+}
+
+interface Foo<T, S> {
+  foo: T;
+  bar: S;
+}
+
+export const testConfig: EasyAstSpecType = {
+  testName: `should resolve generics`,
+  expected: {
+    Generics: {
+      name: 'Generics',
+      kind: LightweightDefinitionKind.CLASS_LIKE,
+      modifiers: ['interface'],
+      properties: {
+        baz: {
+          name: 'baz',
+          type: {
+            referenceName: 'Foo',
+            flags: 524_288,
+            genericsTypes: [
+              {
+                value: 'number',
+                flags: 8,
+              },
+              {
+                referenceName: '$Random',
+                flags: 524_288,
+              },
+            ],
+          },
+        },
+      },
+    },
+    Foo: {
+      name: 'Foo',
+      kind: LightweightDefinitionKind.CLASS_LIKE,
+      modifiers: ['interface'],
+      typeParameters: ['T', 'S'],
+      properties: {
+        foo: {
+          name: 'foo',
+          type: {
+            referenceName: 'T',
+            flags: 262_144,
+          },
+        },
+        bar: {
+          name: 'bar',
+          type: {
+            referenceName: 'S',
+            flags: 262_144,
+          },
+        },
+      },
+    },
+  },
+};

packages/core-tools/test/easy-ast/index-signature.ast-test.ts

@@ -0,0 +1,69 @@
+/* eslint-disable @typescript-eslint/no-empty-interface,@typescript-eslint/no-unused-vars */
+/*
+ * Copyright (C) 2021 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {EasyAstSpecType} from './easy-ast-spec-type';
+import {LightweightDefinitionKind} from '../../src/easy-ast/types/lightweight-definition-kind';
+
+interface $Random {}
+
+interface IndexSignatureObject {
+  [key: string]: $Random;
+}
+
+interface IndexSignaturePrimitive {
+  [key: string]: number;
+}
+
+export const testConfig: EasyAstSpecType = {
+  testName: `should resolve index signatures`,
+  expected: {
+    IndexSignatureObject: {
+      name: 'IndexSignatureObject',
+      kind: LightweightDefinitionKind.CLASS_LIKE,
+      modifiers: ['interface'],
+      indexSignatures: {
+        key: {
+          name: 'key',
+          indexSignatureType: {
+            value: 'string',
+            flags: 4,
+          },
+          type: {
+            referenceName: '$Random',
+            flags: 524_288,
+          },
+        },
+      },
+    },
+    IndexSignaturePrimitive: {
+      name: 'IndexSignaturePrimitive',
+      kind: LightweightDefinitionKind.CLASS_LIKE,
+      modifiers: ['interface'],
+      indexSignatures: {
+        key: {
+          name: 'key',
+          indexSignatureType: {
+            value: 'string',
+            flags: 4,
+          },
+          type: {
+            value: 'number',
+            flags: 8,
+          },
+        },
+      },
+    },
+  },
+};

packages/core-tools/test/easy-ast/ineritance.ast-test.ts

@@ -0,0 +1,82 @@
+/* eslint-disable @typescript-eslint/no-unused-vars,@typescript-eslint/no-inferrable-types */
+/*
+ * Copyright (C) 2021 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {EasyAstSpecType} from './easy-ast-spec-type';
+import {LightweightDefinitionKind} from '../../src/easy-ast/types/lightweight-definition-kind';
+
+interface $BaseInterface<T> {
+  foo: T;
+}
+
+interface $BaseInterface2 {
+  bar: string;
+}
+
+class $BaseClass {}
+
+class InheritingClass extends $BaseClass implements $BaseInterface<number>, $BaseInterface2 {
+  bar: string = '';
+
+  foo: number = 1;
+}
+
+export const testConfig: EasyAstSpecType = {
+  testName: `inheritance`,
+  expected: {
+    InheritingClass: {
+      name: 'InheritingClass',
+      kind: LightweightDefinitionKind.CLASS_LIKE,
+      modifiers: ['class'],
+      implementedDefinitions: [
+        {
+          referenceName: '$BaseInterface',
+          genericsTypes: [
+            {
+              value: 'number',
+              flags: 8,
+            },
+          ],
+          flags: 524_288,
+        },
+        {
+          referenceName: '$BaseInterface2',
+          flags: 524_288,
+        },
+      ],
+      extendedDefinitions: [
+        {
+          referenceName: '$BaseClass',
+          flags: 524_288,
+        },
+      ],
+      properties: {
+        foo: {
+          name: 'foo',
+          type: {
+            value: 'number',
+            flags: 8,
+          },
+        },
+        bar: {
+          name: 'bar',
+          type: {
+            value: 'string',
+            flags: 4,
+          },
+        },
+      },
+    },
+  },
+};

packages/core-tools/test/easy-ast/nested.ast-test.ts

@@ -0,0 +1,61 @@
+/* eslint-disable @typescript-eslint/no-empty-interface,@typescript-eslint/no-unused-vars */
+/*
+ * Copyright (C) 2021 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {EasyAstSpecType} from './easy-ast-spec-type';
+import {LightweightDefinitionKind} from '../../src/easy-ast/types/lightweight-definition-kind';
+
+interface NestedObject {
+  nested: {
+    deeplyNested: {
+      aNumber: number;
+    };
+  };
+}
+
+export const testConfig: EasyAstSpecType = {
+  testName: `should handle nested/type literals`,
+  expected: {
+    NestedObject: {
+      name: 'NestedObject',
+      kind: LightweightDefinitionKind.CLASS_LIKE,
+      modifiers: ['interface'],
+      properties: {
+        nested: {
+          name: 'nested',
+          type: {
+            flags: 524_288,
+          },
+          properties: {
+            deeplyNested: {
+              name: 'deeplyNested',
+              type: {
+                flags: 524_288,
+              },
+              properties: {
+                aNumber: {
+                  name: 'aNumber',
+                  type: {
+                    flags: 8,
+                    value: 'number',
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+};

packages/core-tools/test/easy-ast/primitive-types.ast-test.ts

@@ -0,0 +1,99 @@
+/* eslint-disable @typescript-eslint/no-unused-vars,@typescript-eslint/no-explicit-any */
+/*
+ * Copyright (C) 2021 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {EasyAstSpecType} from './easy-ast-spec-type';
+import {LightweightDefinitionKind} from '../../src/easy-ast/types/lightweight-definition-kind';
+
+interface Test {
+  number_type: number;
+  string_type: string;
+  boolean_type: boolean;
+  any_type: any;
+  unknown_type: unknown;
+  null_type: null;
+  undefined_type: undefined;
+}
+
+export const testConfig: EasyAstSpecType = {
+  testName: `should interpret primitive types correctly`,
+  expected: {
+    Test: {
+      name: 'Test',
+      kind: LightweightDefinitionKind.CLASS_LIKE,
+      modifiers: ['interface'],
+      properties: {
+        number_type: {
+          name: 'number_type',
+          type: {
+            value: 'number',
+            flags: 8,
+          },
+        },
+        string_type: {
+          name: 'string_type',
+          type: {
+            value: 'string',
+            flags: 4,
+          },
+        },
+        boolean_type: {
+          name: 'boolean_type',
+          type: {
+            value: 'boolean',
+            flags: 1_048_592,
+            specificationTypes: [
+              {
+                value: 'false',
+                flags: 512,
+              },
+              {
+                value: 'true',
+                flags: 512,
+              },
+            ],
+          },
+        },
+        any_type: {
+          name: 'any_type',
+          type: {
+            value: 'any',
+            flags: 1,
+          },
+        },
+        unknown_type: {
+          name: 'unknown_type',
+          type: {
+            value: 'unknown',
+            flags: 2,
+          },
+        },
+        null_type: {
+          name: 'null_type',
+          type: {
+            value: 'null',
+            flags: 65_536,
+          },
+        },
+        undefined_type: {
+          name: 'undefined_type',
+          type: {
+            value: 'undefined',
+            flags: 32_768,
+          },
+        },
+      },
+    },
+  },
+};

packages/core-tools/test/easy-ast/stack-overflow.ast-test.ts

@@ -0,0 +1,61 @@
+/* eslint-disable @typescript-eslint/no-unused-vars,@typescript-eslint/no-explicit-any */
+/*
+ * Copyright (C) 2021 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {EasyAstSpecType} from './easy-ast-spec-type';
+import {LightweightDefinitionKind} from '../../src/easy-ast/types/lightweight-definition-kind';
+
+interface Foo<T extends Bar<string>> {
+  bar: T;
+}
+
+interface Bar<T> {
+  foo: T;
+}
+
+export const testConfig: EasyAstSpecType = {
+  testName: `should ignore type constraints`,
+  expected: {
+    Foo: {
+      name: 'Foo',
+      kind: LightweightDefinitionKind.CLASS_LIKE,
+      modifiers: ['interface'],
+      typeParameters: ['T'],
+      properties: {
+        bar: {
+          name: 'bar',
+          type: {
+            referenceName: 'T',
+            flags: 262_144,
+          },
+        },
+      },
+    },
+    Bar: {
+      name: 'Bar',
+      kind: LightweightDefinitionKind.CLASS_LIKE,
+      modifiers: ['interface'],
+      typeParameters: ['T'],
+      properties: {
+        foo: {
+          name: 'foo',
+          type: {
+            referenceName: 'T',
+            flags: 262_144,
+          },
+        },
+      },
+    },
+  },
+};

packages/core-tools/test/model/src/test-class.ts

@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2018-2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {TestFirstUnion} from './test-union';
+
+export class TestClass<T> {
+  test2: T;
+
+  test4: TestFirstUnion;
+
+  constructor(type: T) {
+    this.test2 = type;
+    this.test4 = 'test1';
+  }
+
+  /**
+   * Should not be processed at all
+   */
+  testClassFunction(): boolean {
+    return true;
+  }
+}
+
+export class TestSecondClass extends TestClass<string> {}

packages/core-tools/test/model/src/test-enum.ts

@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2018-2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+export enum TestFirstEnum {
+  TEST1,
+  TEST2,
+  TEST3,
+}
+
+export enum TestSecondEnum {
+  TEST1 = 'one',
+  TEST2 = 'two',
+  TEST3 = 'three',
+}

packages/core-tools/test/model/src/test-interface.ts

@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2018-2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {TestClass, TestSecondClass} from './test-class';
+import {TestFirstEnum} from './test-enum';
+import {TestThirdUnion} from './test-union';
+
+export interface TestInterface {
+  articleBody: string[];
+  categorySpecificValues?: {[s: string]: string};
+  inputType: 'multipleChoice';
+  maintainer: TestThirdUnion | TestFirstEnum;
+  remainingAttendeeCapacity?: number;
+  test1: Array<TestThirdUnion | typeof TestFirstEnum>;
+  test2: TestClass<string>;
+  test3: 'test1' | 'test2';
+  test4: TestSecondClass;
+  universityRole: keyof TestFirstEnum;
+}
+
+export interface TestSecondInterface {
+  [k: string]: string;
+}

packages/core-tools/test/model/src/test-union.ts

@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2018-2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+export type TestFirstUnion = 'test1' | 'test2';
+
+export type TestSecondUnion = 'test3';
+
+export type TestThirdUnion = TestFirstUnion | TestSecondUnion;
+
+export type TestFourthUnion<T extends TestFirstUnion> = T extends TestFirstUnion ? TestFirstUnion : never;

packages/core-tools/test/model/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../../node_modules/@openstapps/configuration/tsconfig.json",
+  "exclude": []
+}

packages/core-tools/test/posix-path.spec.ts

@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2022 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {expect} from 'chai';
+import {toPosixPath} from '../src/util/posix-path';
+import path from 'path';
+
+describe('posix-path', function () {
+  it('should convert Windows paths', function () {
+    expect(toPosixPath('a\\b\\c', path.win32.sep)).to.be.equal('a/b/c');
+  });
+
+  it('should leave POSIX paths untouched', function () {
+    expect(toPosixPath('a/b/c', path.posix.sep)).to.be.equal('a/b/c');
+  });
+
+  it('should replace Windows drive letters', function () {
+    expect(toPosixPath('C:\\a\\b\\c', path.win32.sep)).to.be.equal('/a/b/c');
+  });
+
+  it('should leave POSIX root separator untouched', function () {
+    expect(toPosixPath('/a/b/c', path.posix.sep)).to.be.equal('/a/b/c');
+  });
+});

packages/core-tools/test/schema.spec.ts

@@ -0,0 +1,81 @@
+/* eslint-disable unicorn/prefer-module */
+/*
+ * Copyright (C) 2018-2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {Logger} from '@openstapps/logger';
+import {expect} from 'chai';
+import {slow, suite, test, timeout} from '@testdeck/mocha';
+import {Converter} from '../src/schema';
+import path from 'path';
+
+process.on('unhandledRejection', (error: unknown) => {
+  if (error instanceof Error) {
+    void Logger.error('UNHANDLED REJECTION', error.stack);
+  }
+  process.exit(1);
+});
+
+@suite(timeout(40_000), slow(10_000))
+export class SchemaSpec {
+  @test
+  async getSchema() {
+    const converter = new Converter(path.join(__dirname, '..', 'src', 'resources'));
+
+    const schema = converter.getSchema('Foo', '0.0.1');
+    expect(schema).to.be.deep.equal({
+      $id: 'https://core.stapps.tu-berlin.de/v0.0.1/lib/schema/Foo.json',
+      $schema: 'http://json-schema.org/draft-07/schema#',
+      additionalProperties: false,
+      definitions: {
+        FooType: {
+          description: 'This is a simple type declaration for usage in the Foo interface.',
+          const: 'Foo',
+          type: 'string',
+        },
+        SCFoo: {
+          additionalProperties: false,
+          description:
+            'This is a simple interface declaration for testing the schema generation and validation.',
+          properties: {
+            lorem: {
+              description: 'Dummy parameter',
+              enum: ['lorem', 'ipsum'],
+              type: 'string',
+            },
+            type: {
+              $ref: '#/definitions/FooType',
+              description: 'String literal type property',
+            },
+          },
+          required: ['lorem', 'type'],
+          type: 'object',
+        },
+      },
+      description: 'This is a simple interface declaration for testing the schema generation and validation.',
+      properties: {
+        lorem: {
+          description: 'Dummy parameter',
+          enum: ['lorem', 'ipsum'],
+          type: 'string',
+        },
+        type: {
+          $ref: '#/definitions/FooType',
+          description: 'String literal type property',
+        },
+      },
+      required: ['lorem', 'type'],
+      type: 'object',
+    });
+  }
+}

packages/core-tools/test/validate.spec.ts

@@ -0,0 +1,87 @@
+/* eslint-disable unicorn/prefer-module */
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {Logger} from '@openstapps/logger';
+import {expect} from 'chai';
+import {existsSync, mkdirSync, writeFileSync} from 'fs';
+import {JSONSchema7 as Schema} from 'json-schema';
+import {slow, suite, test, timeout} from '@testdeck/mocha';
+import rimraf from 'rimraf';
+import {Foo} from '../src/resources/foo';
+import {Converter} from '../src/schema';
+import {Validator} from '../src/validate';
+import path from 'path';
+
+process.on('unhandledRejection', (error: unknown) => {
+  if (error instanceof Error) {
+    void Logger.error('UNHANDLED REJECTION', error.stack);
+  }
+  process.exit(1);
+});
+
+const tmpdir = path.join(__dirname, 'tmp');
+const fooInstance: Foo = {
+  lorem: 'ipsum',
+  type: 'Foo',
+};
+
+@suite(timeout(40_000), slow(5000))
+export class ValidateSpec {
+  static converter: Converter;
+
+  static schema: Schema;
+
+  static before() {
+    this.converter = new Converter(path.join(__dirname, '..', 'src', 'resources'));
+    this.schema = this.converter.getSchema('Foo', '0.0.1');
+    if (!existsSync(tmpdir)) {
+      mkdirSync(tmpdir);
+    }
+    writeFileSync(path.join(tmpdir, 'SCFoo.json'), JSON.stringify(this.schema, undefined, 2));
+  }
+
+  static after() {
+    rimraf(tmpdir, error => {
+      // tslint:disable-next-line: no-unused-expression
+      expect(error, `Unable to remove temporary directory for tests at: ${tmpdir}`).to.be.null;
+    });
+  }
+
+  @test
+  async validateBySchemaIdentifyingString() {
+    const validator = new Validator();
+    await validator.addSchemas(tmpdir);
+    const validationResult = validator.validate(fooInstance, 'SCFoo');
+    // tslint:disable-next-line: no-unused-expression
+    expect(validationResult.errors, JSON.stringify(validationResult.errors, undefined, 2)).to.be.empty;
+  }
+
+  @test
+  async validateBySchemaInstance() {
+    const validator = new Validator();
+    const validationResult = validator.validate(fooInstance, ValidateSpec.schema);
+    // tslint:disable-next-line: no-unused-expression
+    expect(validationResult.errors, JSON.stringify(validationResult.errors, undefined, 2)).to.be.empty;
+  }
+
+  @test
+  async validateIntrinsic() {
+    const validator = new Validator();
+    await validator.addSchemas(tmpdir);
+    const validationResult = validator.validate(fooInstance);
+    // tslint:disable-next-line: no-unused-expression
+    expect(validationResult.errors, JSON.stringify(validationResult.errors, undefined, 2)).to.be.empty;
+  }
+}