@oslo-flanders/swagger-generator 1.0.0

package/README.md

@@ -0,0 +1,40 @@
+# `OSLO Swagger Generator`
+
+> Given an OSLO-compliant RDF file, this tool generates a Swagger API from it.
+
+## Install
+```bash
+npm install @oslo-flanders/swagger-generator
+```
+
+## Global install
+To use the service from the command line anywhere, you can install it globally.
+```bash
+npm install -g @oslo-flanders/swagger-generator
+```
+
+## API
+
+The service is executed from the CLI and expects the following parameters:
+| Parameter          | Description                                                  | Required           | Possible values             |
+| ------------------ | ------------------------------------------------------------ | ------------------ | --------------------------- |
+| `--input`          | The URL or local file path of an OSLO-compliant RDF file     | :heavy_check_mark: |                             |
+| `--output`         | The name of the output file                                  | :heavy_check_mark: |                             |
+| `--language`       | The language in which the Swagger must be generated (labels) | No                 |                             |
+| `--versionSwagger` | Swagger OpenAPI specification version                        | :heavy_check_mark: |                             |
+| `--versionAPI`     | API version                                                  | :heavy_check_mark: |                             |
+| `--title`          | Title of the API document                                    | :heavy_check_mark: |                             |
+| `--description`    | Description of the API document                              | :heavy_check_mark: |                             |
+| `--contextURL`     | JSON-LD context URL of the datastandard used in the API      | :heavy_check_mark: |                             |
+| `--baseURL`        | API base URL for endpoints and PURIs                         | :heavy_check_mark: |                             |
+| `--contactName`    | Name of the person or organisation to contact about the API  | No                 |                             |
+| `--contactEmail`   | E-mail to contact for questions about the API                | No                 |                             |
+| `--contactURL`     | Link to follow as contact about the API                      | No                 |                             |
+| `--licenseName`    | Name of the license of the API                               | No                 |                             |
+| `--licenseURL`     | URL of the license of the API                                | No                 |                             |
+| `--silent`         | Suppress log messages                                        | No                 | `true` or `false` (default) |
+
+## Usage
+```bash
+oslo-generator-swagger --input report.jsonld --output swagger.json --language nl --versionSwagger 3.0.4 --versionAPI 1.0.0 --title "Mijn API" --description "Mijn API beschrijving." --contextURL http://example.com/context.jsonld --baseURL http://example.com
+```

package/bin/runner.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/bin/runner.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SwaggerGenerationServiceRunner_1 = require("../lib/SwaggerGenerationServiceRunner");
+// eslint-disable-next-line no-sync
+new SwaggerGenerationServiceRunner_1.SwaggerGenerationServiceRunner().runCliSync(process);
+//# sourceMappingURL=runner.js.map

package/index.d.ts

@@ -0,0 +1,5 @@
+import 'reflect-metadata';
+export * from './lib/SwaggerGenerationServiceRunner';
+export * from './lib/SwaggerGenerationService';
+export * from './lib/config/DependencyInjectionConfig';
+export * from './lib/config/SwaggerGenerationServiceConfiguration';

package/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+__exportStar(require("./lib/SwaggerGenerationServiceRunner"), exports);
+__exportStar(require("./lib/SwaggerGenerationService"), exports);
+__exportStar(require("./lib/config/DependencyInjectionConfig"), exports);
+__exportStar(require("./lib/config/SwaggerGenerationServiceConfiguration"), exports);
+//# sourceMappingURL=index.js.map

package/lib/SwaggerGenerationService.d.ts

@@ -0,0 +1,19 @@
+import type { IService } from '@oslo-flanders/core';
+import { QuadStore, Logger } from '@oslo-flanders/core';
+import type * as RDF from '@rdfjs/types';
+import { DataFactory } from 'rdf-data-factory';
+import { SwaggerGenerationServiceConfiguration } from './config/SwaggerGenerationServiceConfiguration';
+export declare class SwaggerGenerationService implements IService {
+    readonly logger: Logger;
+    readonly configuration: SwaggerGenerationServiceConfiguration;
+    readonly dataFactory: DataFactory<RDF.Quad>;
+    readonly store: QuadStore;
+    constructor(logger: Logger, config: SwaggerGenerationServiceConfiguration, store: QuadStore);
+    private getContact;
+    private getLicense;
+    private getTag;
+    init(): Promise<void>;
+    run(): Promise<void>;
+    createSwagger(): Object;
+    writeSwagger(swagger: Object): Promise<void>;
+}

package/lib/SwaggerGenerationService.js

@@ -0,0 +1,271 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwaggerGenerationService = void 0;
+const core_1 = require("@oslo-flanders/core");
+const promises_1 = require("fs/promises");
+const inversify_1 = require("inversify");
+const rdf_data_factory_1 = require("rdf-data-factory");
+const SwaggerGenerationServiceConfiguration_1 = require("./config/SwaggerGenerationServiceConfiguration");
+const Properties_1 = require("./enums/Properties");
+const swaggerUtils_1 = require("./utils/swaggerUtils");
+const Swagger_1 = require("./constants/Swagger");
+let SwaggerGenerationService = class SwaggerGenerationService {
+    constructor(logger, config, store) {
+        this.dataFactory = new rdf_data_factory_1.DataFactory();
+        this.logger = logger;
+        this.configuration = config;
+        this.store = store;
+    }
+    getContact() {
+        /* If no contact information is provided, the whole block may not appear */
+        if (!this.configuration.contactName &&
+            !this.configuration.contactURL &&
+            !this.configuration.contactEmail)
+            return undefined;
+        return {
+            name: this.configuration.contactName,
+            url: this.configuration.contactURL,
+            email: this.configuration.contactEmail,
+        };
+    }
+    getLicense() {
+        /* If no license information is provided, the whole block may not appear */
+        if (!this.configuration.licenseName && !this.configuration.licenseURL)
+            return undefined;
+        return {
+            name: this.configuration.licenseName,
+            url: this.configuration.licenseURL,
+        };
+    }
+    getTag(subject) {
+        var _a;
+        if ((_a = this.store
+            .getAssignedUri(subject)) === null || _a === void 0 ? void 0 : _a.value.startsWith(this.configuration.baseURL)) {
+            return 'OSLO datastandaarden';
+        }
+        return 'Externe datastandaarden';
+    }
+    async init() {
+        return this.store.addQuadsFromFile(this.configuration.input);
+    }
+    async run() {
+        /* Create Swagger as JSON */
+        const swagger = this.createSwagger();
+        /* Write Swagger to file */
+        await this.writeSwagger(swagger);
+    }
+    createSwagger() {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const swagger = {
+            openapi: this.configuration.versionSwagger,
+            info: {
+                title: this.configuration.title,
+                description: this.configuration.description,
+                contact: this.getContact(),
+                license: this.getLicense(),
+                version: this.configuration.versionAPI,
+            },
+            servers: [
+                {
+                    url: this.configuration.baseURL,
+                    description: 'Basis URL',
+                },
+            ],
+            paths: {},
+            components: {
+                schemas: {},
+            },
+        };
+        /* Create endpoint for each Class */
+        let links = {};
+        for (const classId of this.store.findSubjects(core_1.ns.rdf('type'), core_1.ns.owl('Class'))) {
+            let label = (_a = (0, core_1.getApplicationProfileLabel)(classId, this.store, this.configuration.language)) === null || _a === void 0 ? void 0 : _a.value;
+            const definition = (_b = (0, core_1.getApplicationProfileDefinition)(classId, this.store, this.configuration.language)) === null || _b === void 0 ? void 0 : _b.value;
+            const usageNote = (_c = (0, core_1.getApplicationProfileDefinition)(classId, this.store, this.configuration.language)) === null || _c === void 0 ? void 0 : _c.value;
+            let attributes = {};
+            let requiredAttributes = {};
+            /* Get all attributes in a recursive manner for inheritance */
+            let attributeIds = [];
+            attributeIds = (0, swaggerUtils_1.findAllAttributes)(classId, attributeIds, this.store);
+            if (!label) {
+                this.logger.error(`Unknown class label for ${classId.value}`);
+                continue;
+            }
+            /* Class labels should be always pascal cased */
+            label = (0, swaggerUtils_1.toPascalCase)(label);
+            attributes[label] = [];
+            requiredAttributes[label] = [];
+            links[label] = {};
+            /* Find all attributes for object */
+            for (const attributeId of attributeIds) {
+                let attributeLabel = (_d = (0, core_1.getApplicationProfileLabel)(attributeId, this.store, this.configuration.language)) === null || _d === void 0 ? void 0 : _d.value;
+                const attributeMinCount = (0, core_1.getMinCount)(attributeId, this.store);
+                const attributeMaxCount = (0, core_1.getMaxCount)(attributeId, this.store);
+                const attributeRangeId = this.store.getRange(attributeId);
+                const attributeDefinition = (_e = (0, core_1.getApplicationProfileDefinition)(attributeId, this.store, this.configuration.language)) === null || _e === void 0 ? void 0 : _e.value;
+                const attributeUsageNote = (_f = (0, core_1.getApplicationProfileUsageNote)(attributeId, this.store, this.configuration.language)) === null || _f === void 0 ? void 0 : _f.value;
+                if (!attributeLabel) {
+                    this.logger.error(`Unknown label for attribute ${attributeId.value}`);
+                    continue;
+                }
+                /* Attribute labels should be always camel cased */
+                attributeLabel = (0, swaggerUtils_1.toCamelCase)(attributeLabel);
+                if (!attributeRangeId) {
+                    this.logger.error(`Unknown range for attribute ${attributeId.value}`);
+                    continue;
+                }
+                const attributeDatatypeId = (_g = this.store.getAssignedUri(attributeRangeId)) === null || _g === void 0 ? void 0 : _g.value;
+                const attributeDatatypeLabel = (_h = (0, core_1.getApplicationProfileLabel)(attributeRangeId, this.store, this.configuration.language)) === null || _h === void 0 ? void 0 : _h.value;
+                if (!attributeDatatypeId || !attributeDatatypeLabel) {
+                    this.logger.error(`Unknown datatype for attribute ${attributeId.value}`);
+                    continue;
+                }
+                if (!attributeMinCount || !attributeMaxCount) {
+                    this.logger.error(`Unknown cardinality for attribute ${attributeId.value}`);
+                    continue;
+                }
+                /* Arrays must be introduced into the schema if the max cardinality is 2 or more */
+                const type = 'object';
+                const description = `${attributeDefinition}${attributeUsageNote ? ' ' + attributeUsageNote : ''}`;
+                const properties = (0, Properties_1.mapProperties)(attributeDatatypeId, attributeDatatypeLabel, this.configuration.baseURL);
+                const requiredProperties = properties
+                    ? Object.keys(properties)
+                    : undefined;
+                if (attributeMaxCount != '0' && attributeMaxCount != '1') {
+                    attributes[label][`${label}.${attributeLabel}`] = {
+                        type: 'array',
+                        description: `Lijst van ${attributeDatatypeLabel} items.`,
+                        items: {
+                            type: type,
+                            description: description,
+                            properties: properties,
+                            required: requiredProperties,
+                        },
+                        minItems: parseInt(attributeMinCount),
+                        maxItems: attributeMaxCount == '*'
+                            ? undefined
+                            : parseInt(attributeMaxCount),
+                    };
+                    /* Regular property with a cardinality of [0..0], [0..1], [1..1] */
+                }
+                else {
+                    attributes[label][`${label}.${attributeLabel}`] = {
+                        type: type,
+                        description: description,
+                        properties: properties,
+                        required: requiredProperties,
+                    };
+                }
+                /* Only require properties which are not arrays since those have their own cardinality checks */
+                if (attributeMinCount == '1')
+                    requiredAttributes[label].push(`${label}.${attributeLabel}`);
+                /* Create all possible links for endpoint */
+                if (!(0, core_1.isStandardDatatype)(attributeDatatypeId)) {
+                    links[label][`${attributeDatatypeLabel}GET`] = {
+                        operationId: `${attributeDatatypeLabel}GET`,
+                        parameters: {
+                            /* Referring to response body always starts with the same prefix */
+                            id: `$response.body#/${label}.${attributeLabel}/@id`,
+                        },
+                        description: `Het \`@id\` attribuut van de waarde van \`${label}.${attributeLabel}\` kan gebruikt worden om het gerefereerde object van het type \`${attributeDatatypeLabel}\` op te halen.`,
+                    };
+                }
+            }
+            /* Create an endpoint for each object to have PURIs for each object */
+            swagger.paths[`/id/${label}/{id}`] = {
+                get: {
+                    summary: definition,
+                    description: usageNote,
+                    operationId: `${label}GET`,
+                    tags: [this.getTag(classId)],
+                    parameters: [
+                        {
+                            name: 'id',
+                            required: true,
+                            in: 'path',
+                            description: `Identificator van een ${label} object.`,
+                            schema: {
+                                type: 'string',
+                            },
+                        },
+                    ],
+                    responses: {
+                        200: {
+                            description: `${label} object gevonden.`,
+                            content: {
+                                [core_1.OutputFormat.JsonLd]: {
+                                    schema: {
+                                        $ref: `#/components/schemas/${label}`,
+                                    },
+                                },
+                            },
+                            links: links[label],
+                        },
+                        400: {
+                            description: `Ontbrekende informatie bij het opvragen een ${label} object.`,
+                        },
+                        404: {
+                            description: `${label} object met gegeven ID niet gevonden.`,
+                        },
+                    },
+                },
+            };
+            /* Create components for each schema */
+            swagger.components.schemas[label] = {
+                type: 'object',
+                description: definition,
+                properties: {
+                    '@context': {
+                        type: 'string',
+                        format: 'uri',
+                        enum: [this.configuration.contextURL],
+                    },
+                    '@id': {
+                        type: 'string',
+                        format: 'uri',
+                        pattern: `^${this.configuration.baseURL.replace(Swagger_1.RE_SLASH, '\\/').replace(Swagger_1.RE_DOT, '\\.')}id\\/${label}\\/\\d`,
+                    },
+                    '@type': {
+                        type: 'array',
+                        description: 'Lijst van object types (klasse)',
+                        items: {
+                            type: 'string',
+                            description: `${label} type`,
+                            enum: [label],
+                        },
+                        minItems: 1,
+                    },
+                    ...attributes[label],
+                },
+                required: ['@context', '@id', '@type', ...requiredAttributes[label]],
+            };
+        }
+        return swagger;
+    }
+    async writeSwagger(swagger) {
+        const data = JSON.stringify(swagger, null, 2);
+        await (0, promises_1.writeFile)(this.configuration.output, data);
+    }
+};
+SwaggerGenerationService = __decorate([
+    (0, inversify_1.injectable)(),
+    __param(0, (0, inversify_1.inject)(core_1.ServiceIdentifier.Logger)),
+    __param(1, (0, inversify_1.inject)(core_1.ServiceIdentifier.Configuration)),
+    __param(2, (0, inversify_1.inject)(core_1.ServiceIdentifier.QuadStore)),
+    __metadata("design:paramtypes", [Object, SwaggerGenerationServiceConfiguration_1.SwaggerGenerationServiceConfiguration,
+        core_1.QuadStore])
+], SwaggerGenerationService);
+exports.SwaggerGenerationService = SwaggerGenerationService;
+//# sourceMappingURL=SwaggerGenerationService.js.map

package/lib/SwaggerGenerationServiceRunner.d.ts

@@ -0,0 +1,7 @@
+import type { CliArgv } from '@oslo-flanders/core';
+import { AppRunner } from '@oslo-flanders/core';
+import type { SwaggerGenerationService } from '../lib/SwaggerGenerationService';
+import type { SwaggerGenerationServiceConfiguration } from './config/SwaggerGenerationServiceConfiguration';
+export declare class SwaggerGenerationServiceRunner extends AppRunner<SwaggerGenerationService, SwaggerGenerationServiceConfiguration> {
+    runCli(argv: CliArgv): Promise<void>;
+}

package/lib/SwaggerGenerationServiceRunner.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwaggerGenerationServiceRunner = void 0;
+const core_1 = require("@oslo-flanders/core");
+const yargs_1 = __importDefault(require("yargs"));
+const DependencyInjectionConfig_1 = require("./config/DependencyInjectionConfig");
+class SwaggerGenerationServiceRunner extends core_1.AppRunner {
+    async runCli(argv) {
+        const yargv = (0, yargs_1.default)(argv.slice(2))
+            .usage('node ./bin/runner.js [args]')
+            .option('input', {
+            describe: 'The input file to generate a Swagger OpenAPI JSON file from.',
+            default: 'input.jsonld',
+        })
+            .option('output', {
+            describe: 'Name of the output file.',
+            default: 'openapi.json',
+        })
+            .option('versionSwagger', {
+            describe: 'Version of the Swagger specification used for generation.',
+        })
+            .option('versionAPI', { describe: 'API version.' })
+            .option('language', { describe: 'API language tag.', default: 'nl' })
+            .option('title', { describe: 'API title.' })
+            .option('description', { describe: 'API description.' })
+            .option('contextURL', { describe: 'API JSON-LD Context URL.' })
+            .option('baseURL', { describe: 'API base URL.' })
+            .option('contactName', { describe: 'API contact name.' })
+            .option('contactEmail', { describe: 'API contact e-mail.' })
+            .option('contactURL', { describe: 'API contact URL.' })
+            .option('licenseName', { describe: 'API license name.' })
+            .option('licenseURL', { describe: 'API license URL.' })
+            .option('silent', {
+            describe: 'All logs are suppressed',
+            default: false,
+            boolean: true,
+        })
+            .demandOption([
+            'input',
+            'output',
+            'versionSwagger',
+            'versionAPI',
+            'title',
+            'contextURL',
+            'baseURL',
+        ])
+            .help('h')
+            .alias('h', 'help');
+        const params = await yargv.parse();
+        this.startApp(params, DependencyInjectionConfig_1.container).catch((error) => console.error(error));
+    }
+}
+exports.SwaggerGenerationServiceRunner = SwaggerGenerationServiceRunner;
+//# sourceMappingURL=SwaggerGenerationServiceRunner.js.map

package/lib/config/DependencyInjectionConfig.d.ts

@@ -0,0 +1,2 @@
+import { Container } from 'inversify';
+export declare const container: Container;

package/lib/config/DependencyInjectionConfig.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.container = void 0;
+const core_1 = require("@oslo-flanders/core");
+const inversify_1 = require("inversify");
+const SwaggerGenerationService_1 = require("../SwaggerGenerationService");
+const SwaggerGenerationServiceConfiguration_1 = require("./SwaggerGenerationServiceConfiguration");
+exports.container = new inversify_1.Container();
+exports.container.bind(core_1.ServiceIdentifier.Configuration)
+    .to(SwaggerGenerationServiceConfiguration_1.SwaggerGenerationServiceConfiguration)
+    .inSingletonScope();
+exports.container.bind(core_1.ServiceIdentifier.Service)
+    .to(SwaggerGenerationService_1.SwaggerGenerationService)
+    .inSingletonScope();
+exports.container.bind(core_1.ServiceIdentifier.QuadStore)
+    .to(core_1.QuadStore);
+//# sourceMappingURL=DependencyInjectionConfig.js.map

package/lib/config/SwaggerGenerationServiceConfiguration.d.ts

@@ -0,0 +1,74 @@
+import type { IConfiguration, YargsParams } from '@oslo-flanders/core';
+export declare class SwaggerGenerationServiceConfiguration implements IConfiguration {
+    /**
+     * Local path or URL to (OSLO compliant) RDF file to generate JSON-LD context from
+     */
+    private _input;
+    /**
+     * Local path to write the JSON-LD context to
+     */
+    private _output;
+    /**
+     * The language of the labels that are used in the context
+     */
+    private _language;
+    /**
+     * Swagger version
+     */
+    private _versionSwagger;
+    /**
+     * API metadata: version
+     */
+    private _versionAPI;
+    /**
+     * API metadata: title
+     */
+    private _title;
+    /**
+     * API metadata: description
+     */
+    private _description;
+    /**
+     * API metadata: JSON-LD context URL
+     */
+    private _contextURL;
+    /**
+     * API metadata: base URL
+     */
+    private _baseURL;
+    /**
+     * API metadata: contact name
+     */
+    private _contactName;
+    /**
+     * API metadata: contact URL
+     */
+    private _contactURL;
+    /**
+     * API metadata: contact email
+     */
+    private _contactEmail;
+    /**
+     * API metadata: license name
+     */
+    private _licenseName;
+    /**
+     * API metadata: license URL
+     */
+    private _licenseURL;
+    createFromCli(params: YargsParams): Promise<void>;
+    get input(): string;
+    get output(): string;
+    get language(): string;
+    get versionSwagger(): string;
+    get versionAPI(): string;
+    get title(): string;
+    get description(): string | undefined;
+    get contextURL(): string;
+    get baseURL(): string;
+    get contactName(): string | undefined;
+    get contactURL(): string | undefined;
+    get contactEmail(): string | undefined;
+    get licenseName(): string | undefined;
+    get licenseURL(): string | undefined;
+}

package/lib/config/SwaggerGenerationServiceConfiguration.js

@@ -0,0 +1,99 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwaggerGenerationServiceConfiguration = void 0;
+const inversify_1 = require("inversify");
+let SwaggerGenerationServiceConfiguration = class SwaggerGenerationServiceConfiguration {
+    async createFromCli(params) {
+        this._input = params.input;
+        this._output = params.output;
+        this._language = params.language;
+        this._versionSwagger = params.versionSwagger;
+        this._versionAPI = params.versionAPI;
+        this._title = params.title;
+        this._description = params.description;
+        this._contextURL = params.contextURL;
+        this._baseURL = params.baseURL;
+        this._contactName = params.contactName;
+        this._contactURL = params.contactURL;
+        this._contactEmail = params.contactEmail;
+        this._licenseName = params.licenseName;
+        this._licenseURL = params.licenseURL;
+    }
+    get input() {
+        if (!this._input) {
+            throw new Error(`Trying to access property "input" before it was set.`);
+        }
+        return this._input;
+    }
+    get output() {
+        if (!this._output) {
+            throw new Error(`Trying to access property "output" before it was set.`);
+        }
+        return this._output;
+    }
+    get language() {
+        if (!this._language) {
+            throw new Error(`Trying to access property "language" before it was set.`);
+        }
+        return this._language;
+    }
+    get versionSwagger() {
+        if (!this._versionSwagger) {
+            throw new Error(`Trying to access property "versionSwagger" before it was set.`);
+        }
+        return this._versionSwagger;
+    }
+    get versionAPI() {
+        if (!this._versionAPI) {
+            throw new Error(`Trying to access property "versionAPI" before it was set.`);
+        }
+        return this._versionAPI;
+    }
+    get title() {
+        if (!this._title) {
+            throw new Error(`Trying to access property "title" before it was set.`);
+        }
+        return this._title;
+    }
+    get description() {
+        return this._description;
+    }
+    get contextURL() {
+        if (!this._contextURL) {
+            throw new Error(`Trying access property "contextURL" before it was set.`);
+        }
+        return this._contextURL;
+    }
+    get baseURL() {
+        if (!this._baseURL) {
+            throw new Error(`Trying access property "baseURL" before it was set.`);
+        }
+        return this._baseURL;
+    }
+    get contactName() {
+        return this._contactName;
+    }
+    get contactURL() {
+        return this._contactURL;
+    }
+    get contactEmail() {
+        return this._contactEmail;
+    }
+    get licenseName() {
+        return this._licenseName;
+    }
+    get licenseURL() {
+        return this._licenseURL;
+    }
+};
+SwaggerGenerationServiceConfiguration = __decorate([
+    (0, inversify_1.injectable)()
+], SwaggerGenerationServiceConfiguration);
+exports.SwaggerGenerationServiceConfiguration = SwaggerGenerationServiceConfiguration;
+//# sourceMappingURL=SwaggerGenerationServiceConfiguration.js.map

package/lib/constants/Swagger.d.ts

@@ -0,0 +1,2 @@
+export declare const RE_DOT: RegExp;
+export declare const RE_SLASH: RegExp;

package/lib/constants/Swagger.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RE_SLASH = exports.RE_DOT = void 0;
+/* Regex for escaping URIs when using patterns in OpenAPI JSON */
+exports.RE_DOT = /\./gi;
+exports.RE_SLASH = /\//gi;
+//# sourceMappingURL=Swagger.js.map

package/lib/enums/Properties.d.ts

@@ -0,0 +1 @@
+export declare const mapProperties: (datatype: string, label: string, baseURI: string) => object;

package/lib/enums/Properties.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapProperties = void 0;
+const core_1 = require("@oslo-flanders/core");
+const Swagger_1 = require("../constants/Swagger");
+/* eslint-disable */
+const Properties = new Map([
+    [core_1.ns.rdf('langString').value, { '@value': { type: 'string' }, '@language': { type: 'string', enum: ['nl'] } }],
+    [core_1.ns.xsd('string').value, { '@value': { type: 'string' } }],
+    [core_1.ns.xsd('anyURI').value, { '@id': { type: 'string', format: 'uri' } }],
+    [core_1.ns.xsd('dateTime').value, { '@value': { type: 'string', format: 'date-time' }, '@type': { type: 'string', enum: ['DateTime'] } }],
+    [core_1.ns.xsd('date').value, { '@value': { type: 'string', format: 'date' }, '@type': { type: 'string', enum: ['Date'] } }],
+    [core_1.ns.xsd('boolean').value, { '@value': { type: 'boolean' }, '@type': { type: 'string', enum: ['Boolean'] } }],
+    [core_1.ns.xsd('integer').value, { '@value': { type: 'number', format: 'int64' }, '@type': { type: 'string', enum: ['Integer'] } }],
+    [core_1.ns.xsd('long').value, { '@value': { type: 'number', format: 'int64', minimum: -9223372036854775808, maximum: 9223372036854775807 }, '@type': { type: 'string', enum: ['Long'] } }],
+    [core_1.ns.xsd('float').value, { '@value': { type: 'number', format: 'float' }, '@type': { type: 'string', enum: ['Float'] } }],
+    [core_1.ns.xsd('double').value, { '@value': { type: 'number', format: 'double' }, '@type': { type: 'string', enum: ['Double'] } }],
+    [core_1.ns.xsd('int').value, { '@value': { type: 'number', format: 'int32', minimum: -2147483648, maximum: 2147483647 }, '@type': { type: 'string', enum: ['Int'] } }],
+    [core_1.ns.xsd('short').value, { '@value': { type: 'number', format: 'int32', minimum: -32768, maximum: 32767 }, '@type': { type: 'string', enum: ['Short'] } }],
+    [core_1.ns.xsd('byte').value, { '@value': { type: 'number', format: 'int32', minimum: -128, maximum: 127 }, '@type': { type: 'string', enum: ['Byte'] } }],
+    [core_1.ns.xsd('hexBinary').value, { '@value': { type: 'string', format: 'binary' }, '@type': { type: 'string', enum: ['HexBinary'] } }],
+    [core_1.ns.xsd('base64Binary').value, { '@value': { type: 'string', format: 'byte' }, '@type': { type: 'string', enum: ['Base64Binary'] } }],
+    [core_1.ns.xsd('nonNegativeInteger').value, { '@value': { type: 'number', format: 'int64' }, '@type': { type: 'string', enum: ['NonNegativeInteger'] } }],
+    [core_1.ns.xsd('nonPositiveInteger').value, { '@value': { type: 'number', format: 'int64' }, '@type': { type: 'string', enum: ['NonPositiveInteger'] } }],
+    [core_1.ns.xsd('negativeInteger').value, { '@value': { type: 'number', format: 'int64', maximum: 0 }, '@type': { type: 'string', enum: ['NegativeInteger'] } }],
+    [core_1.ns.xsd('positiveInteger').value, { '@value': { type: 'number', format: 'int64', minimum: 1 }, '@type': { type: 'string', enum: ['PositiveInteger'] } }],
+    [core_1.ns.xsd('unsignedLong').value, { '@value': { type: 'number', format: 'int64', minimum: 0, maximum: 18446744073709551615 }, '@type': { type: 'string', enum: ['UnsignedLong'] } }],
+    [core_1.ns.xsd('unsignedInt').value, { '@value': { type: 'number', format: 'int32', minimum: 0, maximum: 4294967295 }, '@type': { type: 'string', enum: ['UnsignedInt'] } }],
+    [core_1.ns.xsd('unsignedShort').value, { '@value': { type: 'number', format: 'int32', minimum: 0, maximum: 65535 }, '@type': { type: 'string', enum: ['UnsignedShort'] } }],
+    [core_1.ns.xsd('unsignedByte').value, { '@value': { type: 'number', format: 'int32', minimum: 0, maximum: 255 }, '@type': { type: 'string', enum: ['UnsignedByte'] } }],
+    [core_1.ns.xsd('decimal').value, { '@value': { type: 'string', pattern: '(+|-)?([0-9]+(.[0-9]*)?|.[0-9]+)' }, '@type': { type: 'string', enum: ['Decimal'] } }],
+]);
+/* eslint-enable */
+const mapProperties = (datatype, label, baseURI) => {
+    if (Properties.has(datatype)) {
+        return Properties.get(datatype);
+    }
+    return {
+        '@id': {
+            type: 'string',
+            format: 'uri',
+            pattern: `^${baseURI.replace(Swagger_1.RE_SLASH, '\\/').replace(Swagger_1.RE_DOT, '\\.')}id\\/${label}\\/\\d`,
+        },
+    };
+};
+exports.mapProperties = mapProperties;
+//# sourceMappingURL=Properties.js.map

package/lib/types/Swagger.d.ts

@@ -0,0 +1,92 @@
+export interface SwaggerRoot {
+    openapi: string;
+    info: SwaggerInfo;
+    servers: SwaggerServer[];
+    paths: SwaggerPaths;
+    components: SwaggerComponents;
+}
+export interface SwaggerInfo {
+    title: string;
+    description?: string;
+    contact?: SwaggerInfoContact;
+    license?: SwaggerInfoLicense;
+    version: string;
+}
+export interface SwaggerInfoContact {
+    name?: string;
+    url?: string;
+    email?: string;
+}
+export interface SwaggerInfoLicense {
+    name?: string;
+    url?: string;
+}
+export interface SwaggerServer {
+    url: string;
+    description?: string;
+}
+export type SwaggerPaths = Record<string, SwaggerPathsOperations>;
+export interface SwaggerPathsOperations {
+    get?: SwaggerPathsOperation;
+    post?: SwaggerPathsOperation;
+    put?: SwaggerPathsOperation;
+    delete?: SwaggerPathsOperation;
+    patch?: SwaggerPathsOperation;
+}
+export interface SwaggerPathsOperation {
+    tags?: string[];
+    summary?: string;
+    description?: string;
+    operationId?: string;
+    parameters?: SwaggerPathsOperationParameter[];
+    requestBody?: SwaggerPathsOperationRequestBody;
+    responses?: SwaggerPathsOperationResponses;
+}
+export interface SwaggerPathsOperationParameter {
+    name?: string;
+    description?: string;
+    in: string;
+    required: boolean;
+    schema: SwaggerPathsOperationParameterSchema;
+}
+export interface SwaggerPathsOperationParameterSchema {
+    type: string;
+}
+export interface SwaggerPathsOperationRequestBody {
+    description?: string;
+    content: SwaggerPathsOperationRequestBodyContent;
+}
+export type SwaggerPathsOperationRequestBodyContent = Record<string, SwaggerPathsOperationRequestBodyContentValue>;
+export interface SwaggerPathsOperationRequestBodyContentValue {
+    schema: SwaggerPathsOperationRequestBodyContentValueSchema;
+    example?: SwaggerPathsOperationRequestBodyContentValueExample;
+}
+export interface SwaggerPathsOperationRequestBodyContentValueSchema {
+    type: string;
+}
+export type SwaggerPathsOperationRequestBodyContentValueExample = Record<string, string>;
+export interface SwaggerPathsOperationResponses {
+}
+export interface SwaggerComponents {
+    schemas: SwaggerComponentsSchemas;
+}
+export type SwaggerComponentsSchemas = Record<string, SwaggerComponentsSchemasValue>;
+export interface SwaggerComponentsSchemasValue {
+    type?: string;
+    description?: string;
+    properties?: SwaggerComponentsValueProperties;
+    required?: string[];
+}
+export type SwaggerComponentsValueProperties = Record<string, SwaggerComponentsValuePropertiesValue>;
+export interface SwaggerComponentsValuePropertiesValue {
+    type: string;
+    description?: string;
+    enum?: string[];
+    items?: SwaggerComponentsValuePropertiesValueItems;
+}
+export interface SwaggerComponentsValuePropertiesValueItems {
+    type: string;
+    description?: string;
+    properties?: SwaggerComponentsValueProperties;
+    required?: string[];
+}

package/lib/types/Swagger.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Swagger.js.map

package/lib/utils/swaggerUtils.d.ts

@@ -0,0 +1,5 @@
+import type { QuadStore } from '@oslo-flanders/core';
+import type * as RDF from '@rdfjs/types';
+export declare function findAllAttributes(subject: RDF.Term, attributeIds: RDF.Term[], store: QuadStore): RDF.Term[];
+export declare function toPascalCase(text: string): string;
+export declare function toCamelCase(text: string): string;

package/lib/utils/swaggerUtils.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCamelCase = exports.toPascalCase = exports.findAllAttributes = void 0;
+const core_1 = require("@oslo-flanders/core");
+function findAllAttributes(subject, attributeIds, store) {
+    const parentIds = store.findObjects(subject, core_1.ns.rdfs('subClassOf'));
+    attributeIds = [
+        ...attributeIds,
+        ...store.findSubjects(core_1.ns.rdfs('domain'), subject),
+    ];
+    for (const parentId of parentIds) {
+        attributeIds = findAllAttributes(parentId, attributeIds, store);
+    }
+    return attributeIds;
+}
+exports.findAllAttributes = findAllAttributes;
+function removeCaret(text) {
+    return text.replace(/^\^/u, '');
+}
+function toPascalCase(text) {
+    return removeCaret(text)
+        .replace(/(?:^\w|[A-Z]|\b\w)/gu, (word, index) => word.toUpperCase())
+        .replace(/\s+/gu, '');
+}
+exports.toPascalCase = toPascalCase;
+function toCamelCase(text) {
+    return removeCaret(text)
+        .replace(/(?:^\w|[A-Z]|\b\w)/gu, (word, index) => index === 0 ? word.toLowerCase() : word.toUpperCase())
+        .replace(/\s+/gu, '');
+}
+exports.toCamelCase = toCamelCase;
+//# sourceMappingURL=swaggerUtils.js.map

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@oslo-flanders/swagger-generator",
+  "version": "1.0.0",
+  "description": "Generate OpenAPI Swagger YAML documentation.",
+  "author": "Digitaal Vlaanderen <https://data.vlaanderen.be/id/organisatie/OVO002949>",
+  "homepage": "https://github.com/informatievlaanderen/OSLO-UML-Transformer/tree/main/packages/oslo-generator-swagger#readme",
+  "license": "MIT",
+  "main": "index.js",
+  "bin": {
+    "oslo-generator-swagger": "./bin/runner.js"
+  },
+  "directories": {
+    "lib": "lib",
+    "bin": "bin",
+    "test": "test"
+  },
+  "files": [
+    "lib/**/*.d.ts",
+    "lib/**/*.js",
+    "bin/**/*.d.ts",
+    "bin/**/*.js",
+    "index.d.ts",
+    "index.js"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Informatievlaanderen/OSLO-UML-Transformer.git"
+  },
+  "scripts": {
+    "build": "npm run build:ts",
+    "build:ts": "tsc",
+    "test:integration": "node \"../../node_modules/jest/bin/jest.js\" --group=integration --config ../../jest.config.ts ./packages/oslo-generator-swagger/",
+    "test:unit": "node \"../../node_modules/jest/bin/jest.js\" --group=unit --config ../../jest.config.ts ./packages/oslo-generator-swagger/"
+  },
+  "bugs": {
+    "url": "https://github.com/Informatievlaanderen/OSLO-UML-Transformer/issues"
+  },
+  "devDependencies": {
+    "@rdfjs/types": "^1.1.0",
+    "@types/streamify-array": "^1.0.0"
+  },
+  "dependencies": {
+    "@oslo-flanders/core": "^1.0.0",
+    "inversify": "^6.0.1",
+    "n3": "^1.16.2",
+    "rdf-data-factory": "^1.1.1",
+    "rdf-parse": "^2.3.2",
+    "rdf-serialize": "^2.2.2",
+    "reflect-metadata": "^0.1.13",
+    "streamify-array": "^1.0.1",
+    "streamify-string": "^1.0.1",
+    "yargs": "^17.6.0"
+  },
+  "gitHead": "beaa3821b72a7df104ff61af49fed6c1140fadd8"
+}