@oslo-flanders/core 0.0.3-alpha.0 → 0.0.5-alpha.0

package/lib/logging/Logger.js

@@ -1,35 +1,36 @@
-"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.BaseLogger = void 0;
-const inversify_1 = require("inversify");
-let BaseLogger = class BaseLogger {
-    error(message) {
-        return this.log('error', message);
-    }
-    warn(message) {
-        return this.log('warn', message);
-    }
-    info(message) {
-        return this.log('info', message);
-    }
-    verbose(message) {
-        return this.log('verbose', message);
-    }
-    debug(message) {
-        return this.log('debug', message);
-    }
-    silly(message) {
-        return this.log('silly', message);
-    }
-};
-BaseLogger = __decorate([
-    (0, inversify_1.injectable)()
-], BaseLogger);
-exports.BaseLogger = BaseLogger;
+"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.BaseLogger = void 0;
+require("reflect-metadata");
+const inversify_1 = require("inversify");
+let BaseLogger = class BaseLogger {
+    error(message) {
+        return this.log('error', message);
+    }
+    warn(message) {
+        return this.log('warn', message);
+    }
+    info(message) {
+        return this.log('info', message);
+    }
+    verbose(message) {
+        return this.log('verbose', message);
+    }
+    debug(message) {
+        return this.log('debug', message);
+    }
+    silly(message) {
+        return this.log('silly', message);
+    }
+};
+BaseLogger = __decorate([
+    (0, inversify_1.injectable)()
+], BaseLogger);
+exports.BaseLogger = BaseLogger;
 //# sourceMappingURL=Logger.js.map

package/lib/logging/LoggerFactory.d.ts

@@ -0,0 +1,11 @@
+import type { Logger } from '@oslo-core/logging/Logger';
+/**
+ * Instantiates new logger instances.
+ */
+export interface LoggerFactory {
+    /**
+     * Create a logger instance for the given label.
+     * @param label - A label that is used to identify the given logger.
+     */
+    createLogger: (label?: string) => Logger;
+}

package/lib/{interfaces/IGenerationService.js → logging/LoggerFactory.js}

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

package/lib/logging/VoidLogger.d.ts

@@ -1,7 +1,7 @@
-import type { Logger } from './Logger';
-import { BaseLogger } from './Logger';
-import type { LogLevel } from './LogLevel';
-export declare class VoidLogger extends BaseLogger {
-    constructor();
-    log(level: LogLevel, message: string): Logger;
-}
+import type { Logger } from '@oslo-core/logging/Logger';
+import { BaseLogger } from '@oslo-core/logging/Logger';
+import type { LogLevel } from '@oslo-core/logging/LogLevel';
+export declare class VoidLogger extends BaseLogger {
+    constructor();
+    log(level: LogLevel, message: string): Logger;
+}

package/lib/logging/VoidLogger.js

@@ -1,28 +1,28 @@
-"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);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VoidLogger = void 0;
-const inversify_1 = require("inversify");
-const Logger_1 = require("./Logger");
-let VoidLogger = class VoidLogger extends Logger_1.BaseLogger {
-    constructor() {
-        super();
-    }
-    log(level, message) {
-        return this;
-    }
-};
-VoidLogger = __decorate([
-    (0, inversify_1.injectable)(),
-    __metadata("design:paramtypes", [])
-], VoidLogger);
-exports.VoidLogger = VoidLogger;
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoidLogger = void 0;
+const inversify_1 = require("inversify");
+const Logger_1 = require("@oslo-core/logging/Logger");
+let VoidLogger = class VoidLogger extends Logger_1.BaseLogger {
+    constructor() {
+        super();
+    }
+    log(level, message) {
+        return this;
+    }
+};
+VoidLogger = __decorate([
+    (0, inversify_1.injectable)(),
+    __metadata("design:paramtypes", [])
+], VoidLogger);
+exports.VoidLogger = VoidLogger;
 //# sourceMappingURL=VoidLogger.js.map

package/lib/logging/VoidLoggerFactory.d.ts

@@ -0,0 +1,9 @@
+import type { LoggerFactory } from '@oslo-core/logging/LoggerFactory';
+import { VoidLogger } from '@oslo-core/logging/VoidLogger';
+/**
+ * A factory that always returns {@link VoidLogger}, which does nothing on log messages.
+ */
+export declare class VoidLoggerFactory implements LoggerFactory {
+    private readonly logger;
+    createLogger(label?: string): VoidLogger;
+}

package/lib/logging/VoidLoggerFactory.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoidLoggerFactory = void 0;
+const VoidLogger_1 = require("@oslo-core/logging/VoidLogger");
+/**
+ * A factory that always returns {@link VoidLogger}, which does nothing on log messages.
+ */
+class VoidLoggerFactory {
+    constructor() {
+        this.logger = new VoidLogger_1.VoidLogger();
+    }
+    createLogger(label) {
+        return this.logger;
+    }
+}
+exports.VoidLoggerFactory = VoidLoggerFactory;
+//# sourceMappingURL=VoidLoggerFactory.js.map

package/lib/logging/WinstonLogger.d.ts

@@ -1,7 +1,8 @@
-import { BaseLogger } from './Logger';
-import { LogLevel } from './LogLevel';
-export declare class WinstonLogger extends BaseLogger {
-    private readonly logger;
-    constructor(logLevel: LogLevel);
-    log(level: LogLevel, message: string): this;
-}
+import { Logger as WinstonInnerLogger } from 'winston';
+import { BaseLogger } from '@oslo-core/logging/Logger';
+import type { LogLevel } from '@oslo-core/logging/LogLevel';
+export declare class WinstonLogger extends BaseLogger {
+    private readonly logger;
+    constructor(logger: WinstonInnerLogger);
+    log(level: LogLevel, message: string): this;
+}

package/lib/logging/WinstonLogger.js

@@ -1,39 +1,31 @@
-"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);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WinstonLogger = void 0;
-const inversify_1 = require("inversify");
-const winston_1 = require("winston");
-const { combine, colorize, printf } = winston_1.format;
-const Logger_1 = require("./Logger");
-const messageFormat = printf(({ level, message, messageTimestamp }) => `${new Date(Date.now()).toISOString()} ${level}: ${message}`);
-let WinstonLogger = class WinstonLogger extends Logger_1.BaseLogger {
-    constructor(logLevel) {
-        super();
-        this.logger = (0, winston_1.createLogger)({
-            level: logLevel,
-            transports: [
-                new winston_1.transports.Console(),
-            ],
-            format: combine(colorize(), messageFormat),
-        });
-    }
-    log(level, message) {
-        this.logger.log(level, message);
-        return this;
-    }
-};
-WinstonLogger = __decorate([
-    (0, inversify_1.injectable)(),
-    __metadata("design:paramtypes", [String])
-], WinstonLogger);
-exports.WinstonLogger = WinstonLogger;
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WinstonLogger = void 0;
+const inversify_1 = require("inversify");
+const winston_1 = require("winston");
+const Logger_1 = require("@oslo-core/logging/Logger");
+let WinstonLogger = class WinstonLogger extends Logger_1.BaseLogger {
+    constructor(logger) {
+        super();
+        this.logger = logger;
+    }
+    log(level, message) {
+        this.logger.log(level, message);
+        return this;
+    }
+};
+WinstonLogger = __decorate([
+    (0, inversify_1.injectable)(),
+    __metadata("design:paramtypes", [winston_1.Logger])
+], WinstonLogger);
+exports.WinstonLogger = WinstonLogger;
 //# sourceMappingURL=WinstonLogger.js.map

package/lib/logging/WinstonLoggerFactory.d.ts

@@ -0,0 +1,10 @@
+import type * as Transport from 'winston-transport';
+import type { Logger } from '@oslo-core/logging/Logger';
+import type { LoggerFactory } from '@oslo-core/logging/LoggerFactory';
+import type { LogLevel } from '@oslo-core/logging/LogLevel';
+export declare class WinstonLoggerFactory implements LoggerFactory {
+    private readonly level;
+    constructor(level: LogLevel);
+    createLogger(label?: string): Logger;
+    protected createTransports(): Transport[];
+}

package/lib/logging/WinstonLoggerFactory.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WinstonLoggerFactory = void 0;
+const winston_1 = require("winston");
+const WinstonLogger_1 = require("@oslo-core/logging/WinstonLogger");
+const { combine, colorize, printf } = winston_1.format;
+const messageFormat = printf(({ level, message, messageTimestamp }) => `${new Date(Date.now()).toISOString()} ${level}: ${message}`);
+class WinstonLoggerFactory {
+    constructor(level) {
+        this.level = level;
+    }
+    createLogger(label) {
+        return new WinstonLogger_1.WinstonLogger((0, winston_1.createLogger)({
+            level: this.level,
+            transports: this.createTransports(),
+            format: combine(colorize(), messageFormat),
+        }));
+    }
+    createTransports() {
+        return [new winston_1.transports.Console()];
+    }
+}
+exports.WinstonLoggerFactory = WinstonLoggerFactory;
+//# sourceMappingURL=WinstonLoggerFactory.js.map

package/lib/store/QuadStore.d.ts

@@ -0,0 +1,165 @@
+import type * as RDF from '@rdfjs/types';
+export declare class QuadStore {
+    private readonly store;
+    constructor();
+    addQuads(quads: RDF.Quad[]): void;
+    addQuad(quad: RDF.Quad): void;
+    addQuadsFromFile(file: string): Promise<void>;
+    findQuads(subject: RDF.Term | null, predicate: RDF.Term | null, object: RDF.Term | null, graph?: RDF.Term | null): RDF.Quad[];
+    findQuad(subject: RDF.Term | null, predicate: RDF.Term | null, object: RDF.Term | null, graph?: RDF.Term | null): RDF.Quad | undefined;
+    findSubjects(predicate: RDF.Term, object: RDF.Term, graph?: RDF.Term | null): RDF.Term[];
+    findSubject(predicate: RDF.Term, object: RDF.Term, graph?: RDF.Term | null): RDF.Term | undefined;
+    findObjects(subject: RDF.Term, predicate: RDF.Term, graph?: RDF.Term | null): RDF.Term[];
+    findObject(subject: RDF.Term, predicate: RDF.Term, graph?: RDF.Term | null): RDF.Term | undefined;
+    /**
+     * Finds the subject where predicate is 'rdf:type' and object 'oslo:Package'
+     * @returns a RDF.NamedNode or undefined
+     */
+    getPackageId(): RDF.NamedNode | undefined;
+    /**
+     * Finds all subjects where predicate is 'rdf:type' and object 'owl:Class'
+     * @returns an array of RDF.NamedNodes
+     */
+    getClassIds(graph?: RDF.Term | null): RDF.NamedNode[];
+    /**
+     * Finds all subjects where predicate is 'rdf:type' and object 'owl:DatatypeProperty'
+     * @returns an array of RDF.NamedNodes
+     */
+    getDatatypePropertyIds(graph?: RDF.Term | null): RDF.NamedNode[];
+    /**
+     * Finds all subjects where predicate is 'rdf:type' and object 'owl:ObjectProperty'
+     * @returns an array of RDF.NamedNodes
+     */
+    getObjectPropertyIds(graph?: RDF.Term | null): RDF.NamedNode[];
+    /**
+     * For a given subject, the quad store is queried to find the assigned URI
+     * @param subject The subject for which the assigned URI is to be retrieved
+     * @param store The quad store
+     * @returns An RDF.NamedNode or undefined if not found
+     */
+    getAssignedUri(subject: RDF.Term, graph?: RDF.Term | null): RDF.NamedNode | undefined;
+    /**
+     * Find all quads with a label predicate (vocLabel, apLabel and diagramLabel) for a given subject
+     * @param subject The RDF.Term to find the labels for
+     * @param store A N3 quad store
+     * @returns An array of RDF.Quads
+     */
+    getLabels(subject: RDF.Term, graph?: RDF.Term | null): RDF.Quad[];
+    /**
+     * Finds the oslo:vocLabel whose language tag matches the given language
+     * @param subject The RDF.Term to find the oslo:vocLabel for
+     * @param store A N3 quad store
+     * @param language A language tag
+     * @returns An RDF.Literal or undefined if not found
+     */
+    getVocLabel(subject: RDF.Term, language?: string, graph?: RDF.Term | null): RDF.Literal | undefined;
+    /**
+     * Finds the oslo:apLabel whose language tag matches the given language
+     * @param subject The RDF.Term to find the oslo:apLabel for
+     * @param store A N3 quad store
+     * @param language A language tag
+     * @returns An RDF.Literal or undefined if not found
+     */
+    getApLabel(subject: RDF.Term, language?: string, graph?: RDF.Term | null): RDF.Literal | undefined;
+    /**
+     * Finds the oslo:diagramLabel for a given subject
+     * @param subject The RDF.Term to find the oslo:diagramLabel for
+     * @param store A N3 quad store
+     * @param language A language tag
+     * @returns An RDF.Literal or undefined if not found
+     */
+    getDiagramLabel(subject: RDF.Term, graph?: RDF.Term | null): RDF.Literal | undefined;
+    /**
+     * Find all definitions for a given subject
+     * @param subject The RDF.Term to find the definitions for
+     * @param store A N3 quad store
+     * @returns An array of RDF.Literals
+     */
+    getDefinitions(subject: RDF.Term, graph?: RDF.Term | null): RDF.Quad[];
+    /**
+     * Finds the oslo:vocDefinition whose language tag matches the given language
+     * @param subject The RDF.Term to find the oslo:vocDefinition for
+     * @param store A N3 quad store
+     * @param language A language tag
+     * @returns An RDF.Literal or undefined if not found
+     */
+    getVocDefinition(subject: RDF.Term, language?: string, graph?: RDF.Term | null): RDF.Literal | undefined;
+    /**
+     * Finds the oslo:apDefinition whose language tag matches the given language
+     * @param subject The RDF.Term to find the oslo:apDefinition for
+     * @param store A N3 quad store
+     * @param language A language tag
+     * @returns An RDF.Literal or undefined if not found
+     */
+    getApDefinition(subject: RDF.Term, language?: string, graph?: RDF.Term | null): RDF.Literal | undefined;
+    /**
+     * Finds the rdfs:range of a given RDF.Term
+     * @param subject The RDF.Term to find the range of
+     * @param store A N3 quad store
+     * @returns An RDF.Term or undefined if not found
+     */
+    getRange(subject: RDF.Term, graph?: RDF.Term | null): RDF.NamedNode | undefined;
+    /**
+     * Finds the rdfs:domain of a given RDF.Term
+     * @param subject The RDF.Term to find the domain of
+     * @param store A N3 quad store
+     * @returns An RDF.Term or undefined if not found
+     */
+    getDomain(subject: RDF.Term, graph?: RDF.Term | null): RDF.NamedNode | undefined;
+    /**
+     * Finds all the usageNotes (voc and ap) of a given RDF.Term
+     * @param subject The RDF.Term to find the usage notes for
+     * @param store A N3 quad store
+     * @returns An array of RDF.Literals
+     */
+    getUsageNotes(subject: RDF.Term, graph?: RDF.Term | null): RDF.Quad[];
+    /**
+     * Finds the oslo:vocUsageNote of which the language tag matches the given language
+     * @param subject The RDF.Term to find the vocabulary usage note for
+     * @param store A N3 quad store
+     * @param language A language tag
+     * @returns An RDF.Literal or undefined if not found
+     */
+    getVocUsageNote(subject: RDF.Term, language?: string, graph?: RDF.Term | null): RDF.Literal | undefined;
+    /**
+     * Finds the oslo:apUsageNote of which the language tag matches the given language
+     * @param subject The RDF.Term to find the application profile usage note for
+     * @param store A N3 quad store
+     * @param language A language tag
+     * @returns An RDF.Literal or undefined if not found
+     */
+    getApUsageNote(subject: RDF.Term, language?: string, graph?: RDF.Term | null): RDF.Literal | undefined;
+    /**
+     * Finds the example:scope of a given subject
+     * @param subject The RDF.Term to find the scope for
+     * @returns An RDF.NamedNode or undefined if not found
+     */
+    getScope(subject: RDF.Term, graph?: RDF.Term | null): RDF.NamedNode | undefined;
+    /**
+     * Finds the shacl:minCardinality for a given subject
+     * @param subject The RDF.Term to find the shacl:minCardinaly for
+     * @returns An RDF.Literal or undefined if not found
+     */
+    getMinCardinality(subject: RDF.Term, graph?: RDF.Term | null): RDF.Literal | undefined;
+    /**
+     * Finds the shacl:maxCardinality for a given subject
+     * @param subject The RDF.Term to find the shacl:maxCardinaly for
+     * @returns An RDF.Literal or undefined if not found
+     */
+    getMaxCardinality(subject: RDF.Term, graph?: RDF.Term | null): RDF.Literal | undefined;
+    /**
+     * Finds all the rdfs:subClassOf of a given RDF.Term
+     * @param subject the RDF.Term to find the parents of
+     * @param store A N3 quad store
+     * @returns An array of RDF.Terms
+     */
+    getParentsOfClass(subject: RDF.Term, graph?: RDF.Term | null): RDF.NamedNode[];
+    /**
+     * Finds the rdfs:subPropertyOf of a given RDF.Term
+     * @param subject The RDF.Term to find the parent of
+     * @param store A N3 quad store
+     * @returns An RDF.Term or undefined if not found
+     */
+    getParentOfProperty(subject: RDF.Term, graph?: RDF.Term | null): RDF.NamedNode | undefined;
+    getCodelist(subject: RDF.Term, graph?: RDF.Term | null): RDF.NamedNode | undefined;
+}