npm - @oslo-flanders/swagger-generator - Versions diffs - 1.0.2 → 1.0.4 - Mend

@oslo-flanders/swagger-generator 1.0.2 → 1.0.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/bin/runner.js +0 -0
package/lib/SwaggerGenerationService.d.ts +6 -6
package/lib/SwaggerGenerationService.js +336 -115
package/lib/config/SwaggerGenerationServiceConfiguration.js +2 -3
package/lib/constants/Swagger.d.ts +5 -2
package/lib/constants/Swagger.js +13 -4
package/lib/enums/Properties.d.ts +1 -1
package/lib/enums/Properties.js +54 -31
package/lib/types/Swagger.d.ts +51 -50
package/lib/utils/swaggerUtils.d.ts +5 -5
package/lib/utils/swaggerUtils.js +46 -25
package/package.json +1 -1

package/bin/runner.js CHANGED Viewed

File without changes

package/lib/SwaggerGenerationService.d.ts CHANGED Viewed

@@ -1,19 +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 getProbleemdetailsContent;
+    private getProbleemdetailsLink;
     private getContact;
     private getLicense;
-    private getTag;
     init(): Promise<void>;
     run(): Promise<void>;
-    createSwagger(): Object;
-    writeSwagger(swagger: Object): Promise<void>;
+    createSwagger(schemas: any, links: any): Object;
+    createSchemas(): Object;
+    createLinks(): Object;
+    writeJSON(json: Object, outputPath: string): Promise<void>;
 }

package/lib/SwaggerGenerationService.js CHANGED Viewed

@@ -1,10 +1,33 @@
 "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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 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 __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
@@ -14,20 +37,37 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SwaggerGenerationService = void 0;
 const core_1 = require("@oslo-flanders/core");
+const path = __importStar(require("path"));
 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;
     }
+    getProbleemdetailsContent() {
+        return {
+            [core_1.OutputFormat.JsonProblem]: {
+                schema: {
+                    $ref: '#/components/schemas/Probleemdetail',
+                },
+            },
+        };
+    }
+    getProbleemdetailsLink(label) {
+        return {
+            'Probleemdetail.type': {
+                operationId: `${label}GET`,
+                parameters: {
+                    type: `$response.body#/type`,
+                },
+                description: 'De waarde van het attribuut `type` kan gebruikt worden om het gerefereerde object van het type `ProblemDetails` op te halen.',
+            },
+        };
+    }
     getContact() {
         /* If no contact information is provided, the whole block may not appear */
         if (!this.configuration.contactName &&
@@ -49,25 +89,37 @@ let SwaggerGenerationService = class SwaggerGenerationService {
             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);
+        /* Create Swagger schemas */
+        const schemas = this.createSchemas();
+        for (const label of Object.keys(schemas))
+            await this.writeJSON(schemas[label], `swagger/components/schemas/${label}.json`);
+        /* Create Swagger links */
+        const links = this.createLinks();
+        for (const label of Object.keys(links))
+            await this.writeJSON(links[label], `swagger/components/links/${label}.json`);
+        /* Create self-standing referenceable components */
+        const components = {
+            openapi: this.configuration.versionSwagger,
+            info: {
+                title: `Components of ${this.configuration.title}`,
+                description: this.configuration.description,
+                contact: this.getContact(),
+                license: this.getLicense(),
+                version: this.configuration.versionAPI,
+            },
+            components: { schemas, links },
+        };
+        await this.writeJSON(components, `swagger/components.json`);
+        /* Create Swagger endpoint paths as example */
+        const swagger = this.createSwagger(schemas, links);
+        await this.writeJSON(swagger, 'swagger/example.json');
     }
-    createSwagger() {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
+    createSwagger(schemas, links) {
+        var _a, _b, _c;
         const swagger = {
             openapi: this.configuration.versionSwagger,
             info: {
@@ -84,36 +136,173 @@ let SwaggerGenerationService = class SwaggerGenerationService {
                 },
             ],
             paths: {},
-            components: {
-                schemas: {},
-            },
         };
-        /* Create endpoint for each Class */
-        let links = {};
+        const hasRootClasses = this.store.findSubjects(core_1.ns.rdf('type'), core_1.ns.oslo('RootClass')).length > 0;
+        /* Create endpoint for each Class which is marked as RootClass, if none, generate all */
         for (const classId of this.store.findSubjects(core_1.ns.rdf('type'), core_1.ns.owl('Class'))) {
+            if (hasRootClasses && !this.store.isRootClass(classId))
+                continue;
+            const filteredLinks = {};
             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;
+            const usageNote = (_c = (0, core_1.getApplicationProfileUsageNote)(classId, this.store, this.configuration.language)) === null || _c === void 0 ? void 0 : _c.value;
+            if (!label) {
+                this.logger.error(`Unknown class label for ${classId.value}`);
+                continue;
+            }
+            /* Class labels should be always pascal cased */
+            label = (0, core_1.toPascalCase)(label);
+            /* Only keep links which are related to the class */
+            for (const key of Object.keys(links)) {
+                if (key.startsWith(`${label}.`))
+                    filteredLinks[key] = links[key];
+            }
+            /* 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`,
+                    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: filteredLinks,
+                        },
+                        /* Error codes follow the RFC 7807 */
+                        400: {
+                            description: 'Invalid data supplied.',
+                            content: this.getProbleemdetailsContent(),
+                            links: this.getProbleemdetailsLink(label),
+                        },
+                        401: {
+                            description: 'Invalid authorization.',
+                            content: this.getProbleemdetailsContent(),
+                            links: this.getProbleemdetailsLink(label),
+                        },
+                        403: {
+                            description: 'Authentication failed.',
+                            content: this.getProbleemdetailsContent(),
+                            links: this.getProbleemdetailsLink(label),
+                        },
+                        404: {
+                            description: 'Resource not found.',
+                            content: this.getProbleemdetailsContent(),
+                            links: this.getProbleemdetailsLink(label),
+                        },
+                        412: {
+                            description: 'Pre-condition failed.',
+                            content: this.getProbleemdetailsContent(),
+                            links: this.getProbleemdetailsLink(label),
+                        },
+                        500: {
+                            description: 'Unexpected Server Error.',
+                            content: this.getProbleemdetailsContent(),
+                            links: this.getProbleemdetailsLink(label),
+                        },
+                        502: {
+                            description: 'Bad Gateway.',
+                            content: this.getProbleemdetailsContent(),
+                            links: this.getProbleemdetailsLink(label),
+                        },
+                        503: {
+                            description: 'Service unavailable.',
+                            content: this.getProbleemdetailsContent(),
+                            links: this.getProbleemdetailsLink(label),
+                        },
+                        504: {
+                            description: 'Gateway Timeout.',
+                            content: this.getProbleemdetailsContent(),
+                            links: this.getProbleemdetailsLink(label),
+                        },
+                    },
+                },
+            };
+        }
+        /* Inline schemas */
+        swagger.components = {
+            schemas: {},
+        };
+        for (const schemaLabel of Object.keys(schemas))
+            swagger.components.schemas[schemaLabel] = schemas[schemaLabel];
+        return swagger;
+    }
+    createSchemas() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const schemas = {};
+        /* Create schema for each enumeration */
+        for (const enumId of this.store.findSubjects(core_1.ns.oslo('assignedURI'), core_1.ns.skos('Concept'))) {
+            let label = (_a = (0, core_1.getApplicationProfileLabel)(enumId, this.store, this.configuration.language)) === null || _a === void 0 ? void 0 : _a.value;
+            if (!label) {
+                this.logger.error(`Unknown enum label for ${enumId.value}`);
+                continue;
+            }
+            /* Class labels should be always pascal cased */
+            label = (0, core_1.toPascalCase)(label);
+            schemas[label] = {
+                title: label,
+                type: 'object',
+                description: `Enumeratie van ${label}`,
+                properties: {
+                    '@id': {
+                        type: 'string',
+                        format: 'uri',
+                    },
+                },
+                required: ['@id'],
+            };
+        }
+        /* Create schema for each Class and Datatype */
+        for (const classId of [
+            ...this.store.findSubjects(core_1.ns.rdf('type'), core_1.ns.owl('Class')),
+            ...this.store.findSubjects(core_1.ns.rdf('type'), core_1.ns.rdfs('Datatype')),
+        ]) {
+            const assignedUri = this.store.getAssignedUri(classId);
+            /* Primitive datatypes may not be generated */
+            if (assignedUri && [...core_1.DataTypes.values()].includes(assignedUri.value))
+                continue;
+            /* Abstract classes may not be generated to avoid that they are instantiated */
+            if (this.store.isAbstractClass(classId))
+                continue;
+            let label = (_b = (0, core_1.getApplicationProfileLabel)(classId, this.store, this.configuration.language)) === null || _b === void 0 ? void 0 : _b.value;
+            const definition = (_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);
+            attributeIds = (0, core_1.findAllAttributes)(classId, attributeIds, this.store, this.logger);
             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);
+            label = (0, core_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 attributeDomainId = this.store.getDomain(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) {
@@ -121,39 +310,65 @@ let SwaggerGenerationService = class SwaggerGenerationService {
                     continue;
                 }
                 /* Attribute labels should be always camel cased */
-                attributeLabel = (0, swaggerUtils_1.toCamelCase)(attributeLabel);
+                attributeLabel = (0, core_1.toCamelCase)(attributeLabel);
                 if (!attributeRangeId) {
                     this.logger.error(`Unknown range for attribute ${attributeId.value}`);
                     continue;
                 }
+                if (!attributeDomainId) {
+                    this.logger.error(`Unknown domain 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;
+                let 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;
                 }
+                attributeDatatypeLabel = (0, core_1.toPascalCase)(attributeDatatypeLabel);
+                const attributeDatatypeAbstract = this.store.isAbstractClass(attributeRangeId);
+                /* Attribute datatypes may have a super class assigned, but any subclass of this super class must be allowed */
+                const subclasses = [];
+                for (const subclassId of this.store.findSubjects(core_1.ns.rdfs('subClassOf'), attributeRangeId)) {
+                    const subclassLabel = (_j = (0, core_1.getApplicationProfileLabel)(subclassId, this.store, this.configuration.language)) === null || _j === void 0 ? void 0 : _j.value;
+                    if (!subclassLabel) {
+                        console.error(`Unable to retrieve subclass label of ${subclassId}`);
+                        continue;
+                    }
+                    subclasses.push((0, core_1.toPascalCase)(subclassLabel));
+                }
+                /* Cardinality */
                 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 properties = (0, Properties_1.mapProperties)(attributeDatatypeId, attributeDatatypeLabel, subclasses, attributeDatatypeAbstract);
                 const requiredProperties = properties
                     ? Object.keys(properties)
                     : undefined;
+                /* Primitive datatypes are objects with properties */
+                let item = {};
+                if ([...core_1.DataTypes.values()].includes(attributeDatatypeId)) {
+                    item = {
+                        type: 'object',
+                        description: description,
+                        properties: properties,
+                        required: requiredProperties,
+                    };
+                    /* Schema references are $ref, not objects */
+                }
+                else {
+                    item = properties;
+                }
                 if (attributeMaxCount != '0' && attributeMaxCount != '1') {
-                    attributes[label][`${label}.${attributeLabel}`] = {
+                    /* minItems must be 1, empty arrays are removed by not including the attribute, even if minCount == 0 */
+                    attributes[label][attributeLabel] = {
                         type: 'array',
                         description: `Lijst van ${attributeDatatypeLabel} items.`,
-                        items: {
-                            type: type,
-                            description: description,
-                            properties: properties,
-                            required: requiredProperties,
-                        },
-                        minItems: parseInt(attributeMinCount),
+                        items: item,
+                        minItems: Math.max(parseInt(attributeMinCount), 1),
                         maxItems: attributeMaxCount == '*'
                             ? undefined
                             : parseInt(attributeMaxCount),
@@ -161,102 +376,108 @@ let SwaggerGenerationService = class SwaggerGenerationService {
                     /* 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,
-                    };
+                    attributes[label][attributeLabel] = item;
                 }
                 /* 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.`,
-                    };
-                }
+                    requiredAttributes[label].push(attributeLabel);
             }
-            /* 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.`,
-                        },
+            /* Remove duplicates in requiredAttributes list which may be introduced due to redefine/subsetting in inheritance */
+            requiredAttributes[label] = [...new Set(requiredAttributes[label])];
+            /* Root classes require a @context property, add it here if needed */
+            let context = {};
+            if (this.store.isRootClass(classId)) {
+                context = {
+                    '@context': {
+                        type: 'string',
+                        description: 'URI of the JSON-LD versioned context file for this response.',
+                        pattern: `^${this.configuration.contextURL}$`.replace(/\//g, '\\/'),
                     },
-                },
-            };
+                };
+            }
             /* Create components for each schema */
-            swagger.components.schemas[label] = {
+            schemas[label] = {
+                title: 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`,
                     },
+                    /* Do not allow double typing for strict validation and problems with Swagger tooling (discriminator keyword) */
                     '@type': {
-                        type: 'array',
-                        description: 'Lijst van object types (klasse)',
-                        items: {
-                            type: 'string',
-                            description: `${label} type`,
-                            /* enum validation breaks codegen, see https://vlaamseoverheid.atlassian.net/browse/DATAST-46 */
-                        },
-                        minItems: 1,
+                        type: 'string',
+                        description: `Object type (klasse ${label})`,
+                        pattern: `^${label}\$`,
                     },
                     ...attributes[label],
+                    ...context,
                 },
-                required: ['@context', '@id', '@type', ...requiredAttributes[label]],
+                required: ['@type', ...requiredAttributes[label]],
             };
         }
-        return swagger;
+        return schemas;
+    }
+    createLinks() {
+        var _a, _b, _c, _d;
+        let links = {};
+        /* Create link for each Class, datatypes are always nested. */
+        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;
+            /* Abstract classes may not be instantiated so they cannot have links */
+            if (this.store.isAbstractClass(classId))
+                continue;
+            /* Get all attributes in a recursive manner for inheritance */
+            let attributeIds = [];
+            attributeIds = (0, core_1.findAllAttributes)(classId, attributeIds, this.store, this.logger);
+            if (!label) {
+                this.logger.error(`Unknown class label for ${classId.value}`);
+                continue;
+            }
+            /* Class labels should be always pascal cased */
+            label = (0, core_1.toPascalCase)(label);
+            /* Find all attributes for object */
+            for (const attributeId of attributeIds) {
+                let attributeLabel = (_b = (0, core_1.getApplicationProfileLabel)(attributeId, this.store, this.configuration.language)) === null || _b === void 0 ? void 0 : _b.value;
+                const attributeRangeId = this.store.getRange(attributeId);
+                if (!attributeLabel) {
+                    this.logger.error(`Unknown label for attribute ${attributeId.value}`);
+                    continue;
+                }
+                /* Attribute labels should be always camel cased */
+                attributeLabel = (0, core_1.toCamelCase)(attributeLabel);
+                if (!attributeRangeId) {
+                    this.logger.error(`Unknown range for attribute ${attributeId.value}`);
+                    continue;
+                }
+                const attributeDatatypeId = (_c = this.store.getAssignedUri(attributeRangeId)) === null || _c === void 0 ? void 0 : _c.value;
+                let attributeDatatypeLabel = (_d = (0, core_1.getApplicationProfileLabel)(attributeRangeId, this.store, this.configuration.language)) === null || _d === void 0 ? void 0 : _d.value;
+                if (!attributeDatatypeId || !attributeDatatypeLabel) {
+                    this.logger.error(`Unknown datatype for attribute ${attributeId.value}`);
+                    continue;
+                }
+                attributeDatatypeLabel = (0, core_1.toPascalCase)(attributeDatatypeLabel);
+                /* Create all possible links for endpoint */
+                if (!(0, core_1.isStandardDatatype)(attributeDatatypeId)) {
+                    links[`${label}.${attributeLabel}`] = {
+                        operationId: `${label}GET`,
+                        parameters: {
+                            /* Referring to response body always starts with the same prefix */
+                            id: `$response.body#/${label}.${attributeLabel}/@id`,
+                        },
+                        description: `De waarde van het attribuut \`@id\` kan gebruikt worden om het gerefereerde object van het type \`${attributeDatatypeLabel}\` op te halen.`,
+                    };
+                }
+            }
+        }
+        return links;
     }
-    async writeSwagger(swagger) {
-        const data = JSON.stringify(swagger, null, 2);
-        await (0, promises_1.writeFile)(this.configuration.output, data);
+    async writeJSON(json, outputPath) {
+        const data = JSON.stringify(json, null, 2);
+        const filePath = path.join(this.configuration.output, outputPath);
+        (0, core_1.ensureOutputDirectory)(path.dirname(filePath));
+        await (0, promises_1.writeFile)(filePath, data);
     }
 };
 SwaggerGenerationService = __decorate([

package/lib/config/SwaggerGenerationServiceConfiguration.js CHANGED Viewed

@@ -10,7 +10,6 @@ exports.SwaggerGenerationServiceConfiguration = void 0;
 const inversify_1 = require("inversify");
 let SwaggerGenerationServiceConfiguration = class SwaggerGenerationServiceConfiguration {
     async createFromCli(params) {
-        console.log(params.title);
         this._input = params.input;
         this._output = params.output;
         this._language = params.language;
@@ -67,13 +66,13 @@ let SwaggerGenerationServiceConfiguration = class SwaggerGenerationServiceConfig
     }
     get contextURL() {
         if (!this._contextURL) {
-            throw new Error(`Trying access property "contextURL" before it was set.`);
+            throw new Error(`Trying to 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.`);
+            throw new Error(`Trying to access property "baseURL" before it was set.`);
         }
         return this._baseURL;
     }

package/lib/constants/Swagger.d.ts CHANGED Viewed

@@ -1,2 +1,5 @@
-export declare const RE_DOT: RegExp;
-export declare const RE_SLASH: RegExp;
+export declare const ERROR_RESPONSES: {
+    code: string;
+    description: string;
+}[];
+export declare const PROBLEEM_DETAILS_SCHEMA_REF = "#/components/schemas/ProbleemDetails";

package/lib/constants/Swagger.js CHANGED Viewed

@@ -1,7 +1,16 @@
 "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;
+exports.PROBLEEM_DETAILS_SCHEMA_REF = exports.ERROR_RESPONSES = void 0;
+exports.ERROR_RESPONSES = [
+    { code: '400', description: 'Invalid data supplied.' },
+    { code: '401', description: 'Invalid authorization.' },
+    { code: '403', description: 'Authentication failed.' },
+    { code: '404', description: 'Resource not found.' },
+    { code: '412', description: 'Pre-condition failed.' },
+    { code: '500', description: 'Unexpected Server Error.' },
+    { code: '502', description: 'Bad Gateway.' },
+    { code: '503', description: 'Service unavailable.' },
+    { code: '504', description: 'Gateway Timeout.' },
+];
+exports.PROBLEEM_DETAILS_SCHEMA_REF = '#/components/schemas/ProbleemDetails';
 //# sourceMappingURL=Swagger.js.map

package/lib/enums/Properties.d.ts CHANGED Viewed

	@@ -1 +1 @@
1	- export declare const mapProperties: (datatype: string, label: string, ~~baseURI~~: string) => object;
1	+ export declare const mapProperties: (datatype: string, label: string, subclasses: string[], abstract: boolean) => object;

package/lib/enums/Properties.js CHANGED Viewed

@@ -1,47 +1,70 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mapProperties = void 0;
+/* eslint-disable @typescript-eslint/no-loss-of-precision */
 const core_1 = require("@oslo-flanders/core");
-const Swagger_1 = require("../constants/Swagger");
-/* eslint-disable */
+/* eslint-disable max-len */
 const Properties = new Map([
-    [core_1.ns.rdf('langString').value, { '@value': { type: 'string' }, '@language': { type: 'string', enum: ['nl'] } }],
+    [core_1.ns.rdf('langString').value, { '@value': { type: 'string' }, '@language': { type: 'string', pattern: '^nl$' } }],
+    [core_1.ns.rdfs('Literal').value, { '@value': { type: 'string' } }],
     [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'] } }],
+    [core_1.ns.xsd('dateTime').value, { '@value': { type: 'string', format: 'date-time' }, '@type': { type: 'string', pattern: '^DateTime$' } }],
+    [core_1.ns.xsd('date').value, { '@value': { type: 'string', format: 'date' }, '@type': { type: 'string', pattern: '^Date$' } }],
+    [core_1.ns.xsd('boolean').value, { '@value': { type: 'boolean' }, '@type': { type: 'string', pattern: '^Boolean$' } }],
+    [core_1.ns.xsd('integer').value, { '@value': { type: 'number', format: 'int64' }, '@type': { type: 'string', pattern: '^Integer$' } }],
+    [core_1.ns.xsd('long').value, { '@value': { type: 'number', format: 'int64', minimum: -9223372036854776000, maximum: 9223372036854776000 }, '@type': { type: 'string', pattern: '^Long$' } }],
+    [core_1.ns.xsd('float').value, { '@value': { type: 'number', format: 'float' }, '@type': { type: 'string', pattern: '^Float$' } }],
+    [core_1.ns.xsd('double').value, { '@value': { type: 'number', format: 'double' }, '@type': { type: 'string', pattern: '^Double$' } }],
+    [core_1.ns.xsd('int').value, { '@value': { type: 'number', format: 'int32', minimum: -2147483648, maximum: 2147483647 }, '@type': { type: 'string', pattern: '^Int$' } }],
+    [core_1.ns.xsd('short').value, { '@value': { type: 'number', format: 'int32', minimum: -32768, maximum: 32767 }, '@type': { type: 'string', pattern: '^Short$' } }],
+    [core_1.ns.xsd('byte').value, { '@value': { type: 'number', format: 'int32', minimum: -128, maximum: 127 }, '@type': { type: 'string', pattern: '^Byte$' } }],
+    [core_1.ns.xsd('hexBinary').value, { '@value': { type: 'string', format: 'binary' }, '@type': { type: 'string', pattern: '^HexBinary$' } }],
+    [core_1.ns.xsd('base64Binary').value, { '@value': { type: 'string', format: 'byte' }, '@type': { type: 'string', pattern: '^Base64Binary$' } }],
+    [core_1.ns.xsd('nonNegativeInteger').value, { '@value': { type: 'number', format: 'int64' }, '@type': { type: 'string', pattern: '^NonNegativeInteger$' } }],
+    [core_1.ns.xsd('nonPositiveInteger').value, { '@value': { type: 'number', format: 'int64' }, '@type': { type: 'string', pattern: '^NonPositiveInteger$' } }],
+    [core_1.ns.xsd('negativeInteger').value, { '@value': { type: 'number', format: 'int64', maximum: 0 }, '@type': { type: 'string', pattern: '^NegativeInteger$' } }],
+    [core_1.ns.xsd('positiveInteger').value, { '@value': { type: 'number', format: 'int64', minimum: 1 }, '@type': { type: 'string', pattern: '^PositiveInteger$' } }],
+    [core_1.ns.xsd('unsignedLong').value, { '@value': { type: 'number', format: 'int64', minimum: 0, maximum: 18446744073709552000 }, '@type': { type: 'string', pattern: '^UnsignedLong$' } }],
+    [core_1.ns.xsd('unsignedInt').value, { '@value': { type: 'number', format: 'int32', minimum: 0, maximum: 4294967295 }, '@type': { type: 'string', pattern: '^UnsignedInt$' } }],
+    [core_1.ns.xsd('unsignedShort').value, { '@value': { type: 'number', format: 'int32', minimum: 0, maximum: 65535 }, '@type': { type: 'string', pattern: '^UnsignedShort$' } }],
+    [core_1.ns.xsd('unsignedByte').value, { '@value': { type: 'number', format: 'int32', minimum: 0, maximum: 255 }, '@type': { type: 'string', pattern: '^UnsignedByte$' } }],
+    [core_1.ns.xsd('decimal').value, { '@value': { type: 'string', pattern: '(+|-)?([0-9]+(.[0-9]*)?|.[0-9]+)' }, '@type': { type: 'string', pattern: '^Decimal$' } }],
 ]);
-/* eslint-enable */
-const mapProperties = (datatype, label, baseURI) => {
+/* eslint-enable max-len*/
+const mapProperties = (datatype, label, subclasses, abstract) => {
+    /* Primitive data type conversion from Linked Data to Swagger */
     if (Properties.has(datatype)) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         return Properties.get(datatype);
     }
+    /* Multiple subclasses requires a discriminator to link both the superclass and subclasses as schemas */
+    if (subclasses.length > 0) {
+        const mapping = {};
+        const oneOf = [];
+        /* Only allow super class if it is not abstract */
+        if (!abstract) {
+            mapping[label] = `#/components/schemas/${label}`;
+            oneOf.push({ $ref: `#/components/schemas/${label}` });
+        }
+        for (const subclass of subclasses) {
+            const ref = `#/components/schemas/${subclass}`;
+            oneOf.push({ $ref: ref });
+            mapping[subclass] = ref;
+        }
+        return {
+            oneOf,
+            discriminator: {
+                propertyName: '@type',
+                mapping,
+            },
+        };
+    }
+    /* Regular schemas without any subclassing */
     return {
-        '@id': {
-            type: 'string',
-            format: 'uri',
-            pattern: `^${baseURI.replace(Swagger_1.RE_SLASH, '\\/').replace(Swagger_1.RE_DOT, '\\.')}id\\/${label}\\/\\d`,
-        },
+        $ref: `#/components/schemas/${label}`,
     };
 };
 exports.mapProperties = mapProperties;
+/* eslint-enable */
 //# sourceMappingURL=Properties.js.map

package/lib/types/Swagger.d.ts CHANGED Viewed

@@ -2,8 +2,8 @@ export interface SwaggerRoot {
     openapi: string;
     info: SwaggerInfo;
     servers: SwaggerServer[];
-    paths: SwaggerPaths;
-    components: SwaggerComponents;
+    paths: Record<string, SwaggerPath>;
+    components?: SwaggerComponents;
 }
 export interface SwaggerInfo {
     title: string;
@@ -25,68 +25,69 @@ 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 SwaggerComponents {
+    schemas: Record<string, SwaggerSchema>;
+    links?: Record<string, SwaggerLink>;
+}
+export interface SwaggerPath {
+    get?: SwaggerPathOperation;
+    post?: SwaggerPathOperation;
+    put?: SwaggerPathOperation;
+    delete?: SwaggerPathOperation;
+    patch?: SwaggerPathOperation;
 }
-export interface SwaggerPathsOperation {
+export interface SwaggerPathOperation {
     tags?: string[];
     summary?: string;
     description?: string;
     operationId?: string;
-    parameters?: SwaggerPathsOperationParameter[];
-    requestBody?: SwaggerPathsOperationRequestBody;
-    responses?: SwaggerPathsOperationResponses;
+    parameters?: SwaggerParameter[];
+    requestBody?: SwaggerRequestBody;
+    responses: Record<string, SwaggerResponse>;
 }
-export interface SwaggerPathsOperationParameter {
-    name?: string;
+export interface SwaggerParameter {
+    name: string;
     description?: string;
     in: string;
     required: boolean;
-    schema: SwaggerPathsOperationParameterSchema;
-}
-export interface SwaggerPathsOperationParameterSchema {
-    type: string;
+    schema: {
+        type: string;
+    };
 }
-export interface SwaggerPathsOperationRequestBody {
+export interface SwaggerRequestBody {
     description?: string;
-    content: SwaggerPathsOperationRequestBodyContent;
-}
-export type SwaggerPathsOperationRequestBodyContent = Record<string, SwaggerPathsOperationRequestBodyContentValue>;
-export interface SwaggerPathsOperationRequestBodyContentValue {
-    schema: SwaggerPathsOperationRequestBodyContentValueSchema;
-    example?: SwaggerPathsOperationRequestBodyContentValueExample;
-}
-export interface SwaggerPathsOperationRequestBodyContentValueSchema {
+    content: Record<string, {
+        schema: SwaggerSchema | SchemaRef;
+        example?: Record<string, string>;
+    }>;
+}
+export interface SwaggerResponse {
+    description: string;
+    content?: Record<string, {
+        schema: SchemaRef;
+    }>;
+    links?: Record<string, SwaggerLink>;
+}
+export interface SwaggerSchema {
+    title?: string;
     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;
+    pattern?: string;
+    format?: string;
+    minimum?: number;
+    maximum?: number;
+    minItems?: number;
+    maxItems?: number;
+    enum?: string[];
+    items?: SwaggerSchema | SchemaRef;
+    properties?: Record<string, SwaggerSchema | SchemaRef>;
     required?: string[];
 }
-export type SwaggerComponentsValueProperties = Record<string, SwaggerComponentsValuePropertiesValue>;
-export interface SwaggerComponentsValuePropertiesValue {
-    type: string;
-    description?: string;
-    enum?: string[];
-    items?: SwaggerComponentsValuePropertiesValueItems;
+export interface SchemaRef {
+    $ref: string;
 }
-export interface SwaggerComponentsValuePropertiesValueItems {
-    type: string;
-    description?: string;
-    properties?: SwaggerComponentsValueProperties;
-    required?: string[];
+export interface SwaggerLink {
+    operationId: string;
+    parameters: Record<string, string>;
+    description: string;
 }

package/lib/utils/swaggerUtils.d.ts CHANGED Viewed

@@ -1,5 +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;
+import type { SwaggerLink, SwaggerResponse, SwaggerInfoContact, SwaggerInfoLicense } from '../types/Swagger';
+export declare function getContact(contactName?: string, contactURL?: string, contactEmail?: string): SwaggerInfoContact | undefined;
+export declare function getLicense(licenseName?: string, licenseURL?: string): SwaggerInfoLicense | undefined;
+export declare function buildErrorResponses(label: string): Record<string, SwaggerResponse>;
+export declare function filterLinksByClass(links: Record<string, SwaggerLink>, classLabel: string): Record<string, SwaggerLink>;

package/lib/utils/swaggerUtils.js CHANGED Viewed

@@ -1,32 +1,53 @@
 "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.filterLinksByClass = exports.buildErrorResponses = exports.getLicense = exports.getContact = void 0;
+/* eslint-disable max-len */
+const OutputFormat_1 = require("@oslo-flanders/core/lib/enums/OutputFormat");
+const Swagger_1 = require("../constants/Swagger");
+function getProbleemdetailsContent() {
+    return {
+        [OutputFormat_1.OutputFormat.JsonProblem]: {
+            schema: { $ref: Swagger_1.PROBLEEM_DETAILS_SCHEMA_REF },
+        },
+    };
+}
+function getProbleemdetailsLink(label) {
+    return {
+        'ProbleemDetails.type': {
+            operationId: `${label}GET`,
+            parameters: { type: '$response.body#/type' },
+            description: 'De waarde van het attribuut `type` kan gebruikt worden om het gerefereerde object van het type `ProblemDetails` op te halen.',
+        },
+    };
 }
-exports.findAllAttributes = findAllAttributes;
-function removeCaret(text) {
-    return text.replace(/^\^/u, '');
+function getContact(contactName, contactURL, contactEmail) {
+    if (!contactName && !contactURL && !contactEmail)
+        return undefined;
+    return { name: contactName, url: contactURL, email: contactEmail };
 }
-function toPascalCase(text) {
-    return removeCaret(text)
-        .replace(/(?:^\w|[A-Z]|\b\w)/gu, (word, index) => word.toUpperCase())
-        .replace(/\s+/gu, '');
+exports.getContact = getContact;
+function getLicense(licenseName, licenseURL) {
+    if (!licenseName && !licenseURL)
+        return undefined;
+    return { name: licenseName, url: licenseURL };
+}
+exports.getLicense = getLicense;
+function buildErrorResponses(label) {
+    const responses = {};
+    for (const { code, description } of Swagger_1.ERROR_RESPONSES) {
+        responses[code] = {
+            description,
+            content: getProbleemdetailsContent(),
+            links: getProbleemdetailsLink(label),
+        };
+    }
+    return responses;
 }
-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.buildErrorResponses = buildErrorResponses;
+function filterLinksByClass(links, classLabel) {
+    const prefix = `${classLabel}.`;
+    return Object.fromEntries(Object.entries(links).filter(([key]) => key.startsWith(prefix)));
 }
-exports.toCamelCase = toCamelCase;
+exports.filterLinksByClass = filterLinksByClass;
+/* eslint-enable*/
 //# sourceMappingURL=swaggerUtils.js.map

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@oslo-flanders/swagger-generator",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "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",