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

package/index.d.ts

@@ -1,13 +1,12 @@
 import 'reflect-metadata';
 export * from './lib/interfaces/AppRunner';
 export * from './lib/interfaces/IConfiguration';
-export * from './lib/interfaces/IConversionService';
-export * from './lib/interfaces/IGenerationService';
 export * from './lib/interfaces/IOutputHandler';
+export * from './lib/interfaces/IService';
 export * from './lib/utils/fetchFileOrUrl';
 export * from './lib/utils/namespaces';
 export * from './lib/utils/uniqueId';
-export * from './lib/utils/N3StoreFunctions';
+export * from './lib/store/QuadStore';
 export * from './lib/ServiceIdentifier';
 export * from './lib/enums/Scope';
 export * from './lib/enums/PropertyTypes';
@@ -15,3 +14,7 @@ export * from './lib/logging/LogLevel';
 export * from './lib/logging/Logger';
 export * from './lib/logging/VoidLogger';
 export * from './lib/logging/WinstonLogger';
+export * from './lib/logging/LogUtil';
+export * from './lib/logging/LoggerFactory';
+export * from './lib/logging/VoidLoggerFactory';
+export * from './lib/logging/WinstonLoggerFactory';

package/index.js

@@ -17,13 +17,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
 __exportStar(require("./lib/interfaces/AppRunner"), exports);
 __exportStar(require("./lib/interfaces/IConfiguration"), exports);
-__exportStar(require("./lib/interfaces/IConversionService"), exports);
-__exportStar(require("./lib/interfaces/IGenerationService"), exports);
 __exportStar(require("./lib/interfaces/IOutputHandler"), exports);
+__exportStar(require("./lib/interfaces/IService"), exports);
 __exportStar(require("./lib/utils/fetchFileOrUrl"), exports);
 __exportStar(require("./lib/utils/namespaces"), exports);
 __exportStar(require("./lib/utils/uniqueId"), exports);
-__exportStar(require("./lib/utils/N3StoreFunctions"), exports);
+__exportStar(require("./lib/store/QuadStore"), exports);
 __exportStar(require("./lib/ServiceIdentifier"), exports);
 __exportStar(require("./lib/enums/Scope"), exports);
 __exportStar(require("./lib/enums/PropertyTypes"), exports);
@@ -31,4 +30,8 @@ __exportStar(require("./lib/logging/LogLevel"), exports);
 __exportStar(require("./lib/logging/Logger"), exports);
 __exportStar(require("./lib/logging/VoidLogger"), exports);
 __exportStar(require("./lib/logging/WinstonLogger"), exports);
+__exportStar(require("./lib/logging/LogUtil"), exports);
+__exportStar(require("./lib/logging/LoggerFactory"), exports);
+__exportStar(require("./lib/logging/VoidLoggerFactory"), exports);
+__exportStar(require("./lib/logging/WinstonLoggerFactory"), exports);
 //# sourceMappingURL=index.js.map

package/lib/ServiceIdentifier.d.ts

@@ -1,7 +1,7 @@
 export declare class ServiceIdentifier {
-    static readonly ConversionService: unique symbol;
-    static readonly GenerationService: unique symbol;
+    static readonly Service: unique symbol;
     static readonly Configuration: unique symbol;
     static readonly OutputHandler: unique symbol;
     static readonly Logger: unique symbol;
+    static readonly QuadStore: unique symbol;
 }

package/lib/ServiceIdentifier.js

@@ -7,9 +7,9 @@ exports.ServiceIdentifier = void 0;
 class ServiceIdentifier {
 }
 exports.ServiceIdentifier = ServiceIdentifier;
-ServiceIdentifier.ConversionService = Symbol.for('ConversionService');
-ServiceIdentifier.GenerationService = Symbol.for('GenerationService');
+ServiceIdentifier.Service = Symbol.for('Service');
 ServiceIdentifier.Configuration = Symbol.for('Configuration');
 ServiceIdentifier.OutputHandler = Symbol.for('OutputHandler');
 ServiceIdentifier.Logger = Symbol.for('Logger');
+ServiceIdentifier.QuadStore = Symbol.for('QuadStore');
 //# sourceMappingURL=ServiceIdentifier.js.map

package/lib/interfaces/AppRunner.d.ts

@@ -1,4 +1,7 @@
 /// <reference types="node" />
+import type { Container } from 'inversify';
+import type { IConfiguration } from './IConfiguration';
+import type { IService } from './IService';
 export declare type CliArgv = string[];
 export declare type YargsParams = {
     [x: string]: unknown;
@@ -9,7 +12,8 @@ export declare type YargsParams = {
     _: (string | number)[];
     $0: string;
 };
-export declare abstract class AppRunner {
+export declare abstract class AppRunner<T extends IService, K extends IConfiguration> {
     runCliSync(process: NodeJS.Process): void;
     abstract runCli(argv: CliArgv): Promise<void>;
+    startApp(params: YargsParams, container: Container): Promise<void>;
 }

package/lib/interfaces/AppRunner.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AppRunner = void 0;
 const process_1 = require("process");
+const LogUtil_1 = require("../logging/LogUtil");
+const ServiceIdentifier_1 = require("../ServiceIdentifier");
 class AppRunner {
     runCliSync(process) {
         this.runCli(process.argv).catch((error) => {
@@ -10,6 +12,16 @@ class AppRunner {
             process.exit(1);
         });
     }
+    async startApp(params, container) {
+        const configuration = container.get(ServiceIdentifier_1.ServiceIdentifier.Configuration);
+        await configuration.createFromCli(params);
+        (0, LogUtil_1.setLoggerFactory)(params);
+        container.bind(ServiceIdentifier_1.ServiceIdentifier.Logger).toDynamicValue(() => (0, LogUtil_1.createLogger)()).inSingletonScope();
+        const service = container.get(ServiceIdentifier_1.ServiceIdentifier.Service);
+        service.init()
+            .then(() => service.run())
+            .catch(error => console.error(error));
+    }
 }
 exports.AppRunner = AppRunner;
 //# sourceMappingURL=AppRunner.js.map

package/lib/interfaces/IOutputHandler.d.ts

@@ -1,7 +1,7 @@
-import type { Quad, Store } from 'n3';
+import type { QuadStore } from '../store/QuadStore';
 /**
  * Writes the triples in an RDF store to a write stream
  */
 export interface IOutputHandler {
-    write: (store: Store<Quad>, writeStream: any) => Promise<void>;
+    write: (store: QuadStore, writeStream: any) => Promise<void>;
 }

package/lib/interfaces/{IConversionService.d.ts → IService.d.ts}

@@ -1,10 +1,11 @@
 import type { Logger } from '../logging/Logger';
 import type { IConfiguration } from './IConfiguration';
 /**
- * Interface that must be implemented by classes that convert a UML diagram to an RDF file
+ * Interface that must be implemented by conversion of generation services
  */
-export interface IConversionService {
+export interface IService {
     logger: Logger;
     configuration: IConfiguration;
+    init: () => Promise<void>;
     run: () => Promise<void>;
 }

package/lib/interfaces/{IConversionService.js → IService.js}

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

package/lib/logging/LogUtil.d.ts

@@ -0,0 +1,4 @@
+import type { YargsParams } from '../interfaces/AppRunner';
+import type { Logger } from './Logger';
+export declare function createLogger(): Logger;
+export declare function setLoggerFactory(params: YargsParams): void;

package/lib/logging/LogUtil.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setLoggerFactory = exports.createLogger = void 0;
+const VoidLoggerFactory_1 = require("./VoidLoggerFactory");
+const WinstonLoggerFactory_1 = require("./WinstonLoggerFactory");
+let loggerFactory = new VoidLoggerFactory_1.VoidLoggerFactory();
+function createLogger() {
+    return loggerFactory.createLogger();
+}
+exports.createLogger = createLogger;
+function setLoggerFactory(params) {
+    if (!params.silent) {
+        loggerFactory = new WinstonLoggerFactory_1.WinstonLoggerFactory(params.logLevel);
+    }
+}
+exports.setLoggerFactory = setLoggerFactory;
+//# sourceMappingURL=LogUtil.js.map

package/lib/logging/Logger.d.ts

@@ -1,3 +1,4 @@
+import 'reflect-metadata';
 import type { LogLevel } from './LogLevel';
 export interface Logger {
     log: (level: LogLevel, message: string) => Logger;

package/lib/logging/Logger.js

@@ -7,6 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseLogger = void 0;
+require("reflect-metadata");
 const inversify_1 = require("inversify");
 let BaseLogger = class BaseLogger {
     error(message) {

package/lib/logging/LoggerFactory.d.ts

@@ -0,0 +1,11 @@
+import type { Logger } from './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
+//# sourceMappingURL=LoggerFactory.js.map

package/lib/logging/VoidLoggerFactory.d.ts

@@ -0,0 +1,9 @@
+import type { LoggerFactory } from './LoggerFactory';
+import { VoidLogger } from './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("./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 { Logger as WinstonInnerLogger } from 'winston';
 import { BaseLogger } from './Logger';
-import { LogLevel } from './LogLevel';
+import type { LogLevel } from './LogLevel';
 export declare class WinstonLogger extends BaseLogger {
     private readonly logger;
-    constructor(logLevel: LogLevel);
+    constructor(logger: WinstonInnerLogger);
     log(level: LogLevel, message: string): this;
 }

package/lib/logging/WinstonLogger.js

@@ -12,19 +12,11 @@ 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) {
+    constructor(logger) {
         super();
-        this.logger = (0, winston_1.createLogger)({
-            level: logLevel,
-            transports: [
-                new winston_1.transports.Console(),
-            ],
-            format: combine(colorize(), messageFormat),
-        });
+        this.logger = logger;
     }
     log(level, message) {
         this.logger.log(level, message);
@@ -33,7 +25,7 @@ let WinstonLogger = class WinstonLogger extends Logger_1.BaseLogger {
 };
 WinstonLogger = __decorate([
     (0, inversify_1.injectable)(),
-    __metadata("design:paramtypes", [String])
+    __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 './Logger';
+import type { LoggerFactory } from './LoggerFactory';
+import type { LogLevel } from './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("./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,180 @@
+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): RDF.Quad[];
+    findQuad(subject: RDF.Term | null, predicate: RDF.Term | null, object: RDF.Term | null): RDF.Quad | undefined;
+    findSubjects(predicate: RDF.Term, object: RDF.Term): RDF.Term[];
+    findSubject(predicate: RDF.Term, object: RDF.Term): RDF.Term | undefined;
+    findObjects(subject: RDF.Term, predicate: RDF.Term): RDF.Term[];
+    findObject(subject: RDF.Term, predicate: RDF.Term): RDF.Term | undefined;
+    /**
+     * Finds the subject where predicate is 'rdf:type' and object 'example: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(): RDF.NamedNode[];
+    /**
+   * Finds all subjects where predicate is 'rdf:type' and object 'owl:DatatypeProperty'
+   * @returns an array of RDF.NamedNodes
+   */
+    getDatatypePropertyIds(): RDF.NamedNode[];
+    /**
+   * Finds all subjects where predicate is 'rdf:type' and object 'owl:ObjectProperty'
+   * @returns an array of RDF.NamedNodes
+   */
+    getObjectPropertyIds(): 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): RDF.NamedNode | undefined;
+    /**
+     * Find all rdfs:labels for a given subject
+     * @param subject The RDF.Term to find the rdfs:labels for
+     * @param store A N3 quad store
+     * @returns An array of RDF.Literals
+     */
+    getLabels(subject: RDF.Term): RDF.Literal[];
+    /**
+     * Finds the rdfs:label whose language tag matches the given language
+     * @param subject The RDF.Term to find the rdfs:label for
+     * @param store A N3 quad store
+     * @param language A language tag
+     * @returns An RDF.Literal or undefined if not found
+     */
+    getLabel(subject: RDF.Term, language?: string): RDF.Literal | undefined;
+    /**
+     * Find all rdfs:comments for a given subject
+     * @param subject The RDF.Term to find the rdfs:comments for
+     * @param store A N3 quad store
+     * @returns An array of RDF.Literals
+     */
+    getDefinitions(subject: RDF.Term): RDF.Literal[];
+    /**
+     * Finds the rdfs:comment whose language tag matches the given language
+     * @param subject The RDF.Term to find the rdfs:comment for
+     * @param store A N3 quad store
+     * @param language A language tag
+     * @returns An RDF.Literal or undefined if not found
+     */
+    getDefinition(subject: RDF.Term, language?: string): 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): 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): RDF.NamedNode | undefined;
+    /**
+     * Finds all the vann:usageNotes 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): RDF.Literal[];
+    /**
+     * Finds the vann:usageNote of which the language tag matches the given language
+     * @param subject The RDF.Term to find the usage note for
+     * @param store A N3 quad store
+     * @param language A language tag
+     * @returns An RDF.Literal or undefined if not found
+     */
+    getUsageNote(subject: RDF.Term, language?: string): 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): 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): 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): 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): 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): RDF.NamedNode | undefined;
+    /**
+     * Find the subject of the statement that matches the given subject, predicate and object
+     * @param statementSubject The subject to match the statement subject
+     * @param statementPredicate The predicate to match the statement predicate
+     * @param statementObject The object to match the statement object
+     * @param store An N3 quad store
+     * @returns an RDF.Term or undefined if none found
+     */
+    getTargetStatementId(statementSubject: RDF.Term, statementPredicate: RDF.Term, statementObject: RDF.Term): RDF.Term | undefined;
+    /**
+     * Finds the assigned URI in rdf:Statements
+     * @param subject The statement subject
+     * @param predicate The statement predicate
+     * @param object The statement object for which the assigned URI must be found
+     * @param store A N3 quad store
+     * @returns An RDF.Term or undefined if not found
+     */
+    getAssignedUriViaStatements(subject: RDF.Term, predicate: RDF.Term, object: RDF.Term): RDF.NamedNode | undefined;
+    /**
+     * Finds the rdfs:label for an RDF.Term in rdf:Statements
+     * @param subject The statement subject
+     * @param predicate The statement predicate
+     * @param object The statement object for which the label must be found
+     * @param store A N3 quad store
+     * @param language A language tag
+     * @returns An RDF.Literal or undefined if not found
+     */
+    getLabelViaStatements(subject: RDF.Term, predicate: RDF.Term, object: RDF.Term, language: string): RDF.Literal | undefined;
+    /**
+     * Finds the rdfs:comment for an RDF.Term in rdf:Statements
+     * @param subject The statement subject
+     * @param predicate The statement predicate
+     * @param object The statement object for which the definition must be found
+     * @param store A N3 quad store
+     * @param language A language tag
+     * @returns An RDF.Literal or undefined if not found
+     */
+    getDefinitionViaStatements(subject: RDF.Term, predicate: RDF.Term, object: RDF.Term, language: string): RDF.Literal | undefined;
+    /**
+     * Finds the vann:usageNote for an RDF.Term in rdf:Statements
+     * @param subject The statement subject
+     * @param predicate The statement predicate
+     * @param object The statement object for which the usage note must be found
+     * @param store A N3 quad store
+     * @param language A language tag
+     * @returns An RDF.Literal or undefined if not found
+     */
+    getUsageNoteViaStatements(subject: RDF.Term, predicate: RDF.Term, object: RDF.Term, language: string): RDF.Literal | undefined;
+}

package/lib/store/QuadStore.js

@@ -0,0 +1,330 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuadStore = void 0;
+const inversify_1 = require("inversify");
+const N3 = __importStar(require("n3"));
+const rdf_parse_1 = __importDefault(require("rdf-parse"));
+const fetchFileOrUrl_1 = require("../utils/fetchFileOrUrl");
+const namespaces_1 = require("../utils/namespaces");
+let QuadStore = class QuadStore {
+    constructor() {
+        this.store = new N3.Store();
+    }
+    addQuads(quads) {
+        this.store.addQuads(quads);
+    }
+    addQuad(quad) {
+        this.store.addQuad(quad);
+    }
+    async addQuadsFromFile(file) {
+        const buffer = await (0, fetchFileOrUrl_1.fetchFileOrUrl)(file);
+        const textStream = require('streamify-string')(buffer.toString());
+        return new Promise((resolve, reject) => {
+            rdf_parse_1.default.parse(textStream, { path: file })
+                .on('data', (quad) => this.store.addQuad(quad))
+                .on('error', (error) => reject(error))
+                .on('end', () => resolve());
+        });
+    }
+    findQuads(subject, predicate, object) {
+        return this.store.getQuads(subject, predicate, object, null);
+    }
+    findQuad(subject, predicate, object) {
+        return this.findQuads(subject, predicate, object).shift();
+    }
+    findSubjects(predicate, object) {
+        return this.store.getSubjects(predicate, object, null);
+    }
+    findSubject(predicate, object) {
+        return this.findSubjects(predicate, object).shift();
+    }
+    findObjects(subject, predicate) {
+        return this.store.getObjects(subject, predicate, null);
+    }
+    findObject(subject, predicate) {
+        return this.findObjects(subject, predicate).shift();
+    }
+    /**
+     * Finds the subject where predicate is 'rdf:type' and object 'example:Package'
+     * @returns a RDF.NamedNode or undefined
+     */
+    getPackageId() {
+        return this.store.getSubjects(namespaces_1.ns.rdf('type'), namespaces_1.ns.example('Package'), null).shift();
+    }
+    /**
+     * Finds all subjects where predicate is 'rdf:type' and object 'owl:Class'
+     * @returns an array of RDF.NamedNodes
+     */
+    getClassIds() {
+        return this.store.getSubjects(namespaces_1.ns.rdf('type'), namespaces_1.ns.owl('Class'), null);
+    }
+    /**
+   * Finds all subjects where predicate is 'rdf:type' and object 'owl:DatatypeProperty'
+   * @returns an array of RDF.NamedNodes
+   */
+    getDatatypePropertyIds() {
+        return this.store.getSubjects(namespaces_1.ns.rdf('type'), namespaces_1.ns.owl('DatatypeProperty'), null);
+    }
+    /**
+   * Finds all subjects where predicate is 'rdf:type' and object 'owl:ObjectProperty'
+   * @returns an array of RDF.NamedNodes
+   */
+    getObjectPropertyIds() {
+        return this.store.getSubjects(namespaces_1.ns.rdf('type'), namespaces_1.ns.owl('ObjectProperty'), null);
+    }
+    /**
+     * 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) {
+        return this.store.getObjects(subject, namespaces_1.ns.example('assignedUri'), null).shift();
+    }
+    /**
+     * Find all rdfs:labels for a given subject
+     * @param subject The RDF.Term to find the rdfs:labels for
+     * @param store A N3 quad store
+     * @returns An array of RDF.Literals
+     */
+    getLabels(subject) {
+        return this.store.getObjects(subject, namespaces_1.ns.rdfs('label'), null);
+    }
+    /**
+     * Finds the rdfs:label whose language tag matches the given language
+     * @param subject The RDF.Term to find the rdfs:label for
+     * @param store A N3 quad store
+     * @param language A language tag
+     * @returns An RDF.Literal or undefined if not found
+     */
+    getLabel(subject, language) {
+        return this.getLabels(subject).find(x => x.language === (language || ''));
+    }
+    /**
+     * Find all rdfs:comments for a given subject
+     * @param subject The RDF.Term to find the rdfs:comments for
+     * @param store A N3 quad store
+     * @returns An array of RDF.Literals
+     */
+    getDefinitions(subject) {
+        return this.store.getObjects(subject, namespaces_1.ns.rdfs('comment'), null);
+    }
+    /**
+     * Finds the rdfs:comment whose language tag matches the given language
+     * @param subject The RDF.Term to find the rdfs:comment for
+     * @param store A N3 quad store
+     * @param language A language tag
+     * @returns An RDF.Literal or undefined if not found
+     */
+    getDefinition(subject, language) {
+        return this.getDefinitions(subject).find(x => x.language === (language || ''));
+    }
+    /**
+     * 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) {
+        return this.store.getObjects(subject, namespaces_1.ns.rdfs('range'), null).shift();
+    }
+    /**
+     * 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) {
+        return this.store.getObjects(subject, namespaces_1.ns.rdfs('domain'), null).shift();
+    }
+    /**
+     * Finds all the vann:usageNotes 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) {
+        return this.store.getObjects(subject, namespaces_1.ns.vann('usageNote'), null);
+    }
+    /**
+     * Finds the vann:usageNote of which the language tag matches the given language
+     * @param subject The RDF.Term to find the usage note for
+     * @param store A N3 quad store
+     * @param language A language tag
+     * @returns An RDF.Literal or undefined if not found
+     */
+    getUsageNote(subject, language) {
+        return this.getUsageNotes(subject).find(x => x.language === (language || ''));
+    }
+    /**
+     * 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) {
+        return this.store.getObjects(subject, namespaces_1.ns.example('scope'), null).shift();
+    }
+    /**
+     * 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) {
+        return this.store.getObjects(subject, namespaces_1.ns.shacl('minCount'), null).shift();
+    }
+    /**
+   * 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) {
+        return this.store.getObjects(subject, namespaces_1.ns.shacl('maxCount'), null).shift();
+    }
+    /**
+     * 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) {
+        return this.store.getObjects(subject, namespaces_1.ns.rdfs('subClassOf'), null);
+    }
+    /**
+     * 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) {
+        return this.store.getObjects(subject, namespaces_1.ns.rdfs('subPropertyOf'), null).shift();
+    }
+    /**
+     * Find the subject of the statement that matches the given subject, predicate and object
+     * @param statementSubject The subject to match the statement subject
+     * @param statementPredicate The predicate to match the statement predicate
+     * @param statementObject The object to match the statement object
+     * @param store An N3 quad store
+     * @returns an RDF.Term or undefined if none found
+     */
+    getTargetStatementId(statementSubject, statementPredicate, statementObject) {
+        const statementIds = this.store.getSubjects(namespaces_1.ns.rdf('type'), namespaces_1.ns.rdf('Statement'), null);
+        const statementSubjectPredicateSubjects = this.store.getSubjects(namespaces_1.ns.rdf('subject'), statementSubject, null);
+        const statementPredicatePredicateSubjects = this.store.getSubjects(namespaces_1.ns.rdf('predicate'), statementPredicate, null);
+        const statementObjectPredicateSubjects = this.store.getSubjects(namespaces_1.ns.rdf('object'), statementObject, null);
+        const targetIds = statementIds
+            .filter(x => statementSubjectPredicateSubjects.some(y => y.value === x.value))
+            .filter(x => statementPredicatePredicateSubjects.some(y => y.value === x.value))
+            .filter(x => statementObjectPredicateSubjects.some(y => y.value === x.value));
+        if (targetIds.length > 1) {
+            throw new Error(`Found multiple statements with subject "${statementSubject.value}", predicate "${statementPredicate.value}" and object "${statementObject.value}".`);
+        }
+        return targetIds.shift();
+    }
+    /**
+     * Finds the assigned URI in rdf:Statements
+     * @param subject The statement subject
+     * @param predicate The statement predicate
+     * @param object The statement object for which the assigned URI must be found
+     * @param store A N3 quad store
+     * @returns An RDF.Term or undefined if not found
+     */
+    getAssignedUriViaStatements(subject, predicate, object) {
+        const statementId = this.getTargetStatementId(subject, predicate, object);
+        if (!statementId) {
+            return undefined;
+        }
+        return this.getAssignedUri(statementId);
+    }
+    /**
+     * Finds the rdfs:label for an RDF.Term in rdf:Statements
+     * @param subject The statement subject
+     * @param predicate The statement predicate
+     * @param object The statement object for which the label must be found
+     * @param store A N3 quad store
+     * @param language A language tag
+     * @returns An RDF.Literal or undefined if not found
+     */
+    getLabelViaStatements(subject, predicate, object, language) {
+        const statementId = this.getTargetStatementId(subject, predicate, object);
+        if (!statementId) {
+            return undefined;
+        }
+        const label = this.getLabel(statementId, language);
+        return label || this.getLabel(statementId);
+    }
+    /**
+     * Finds the rdfs:comment for an RDF.Term in rdf:Statements
+     * @param subject The statement subject
+     * @param predicate The statement predicate
+     * @param object The statement object for which the definition must be found
+     * @param store A N3 quad store
+     * @param language A language tag
+     * @returns An RDF.Literal or undefined if not found
+     */
+    getDefinitionViaStatements(subject, predicate, object, language) {
+        const statementId = this.getTargetStatementId(subject, predicate, object);
+        if (!statementId) {
+            return undefined;
+        }
+        const definition = this.getDefinition(statementId, language);
+        return definition || this.getDefinition(statementId);
+    }
+    /**
+     * Finds the vann:usageNote for an RDF.Term in rdf:Statements
+     * @param subject The statement subject
+     * @param predicate The statement predicate
+     * @param object The statement object for which the usage note must be found
+     * @param store A N3 quad store
+     * @param language A language tag
+     * @returns An RDF.Literal or undefined if not found
+     */
+    getUsageNoteViaStatements(subject, predicate, object, language) {
+        const statementId = this.getTargetStatementId(subject, predicate, object);
+        if (!statementId) {
+            return undefined;
+        }
+        const usageNote = this.getUsageNote(statementId, language);
+        return usageNote || this.getUsageNote(statementId);
+    }
+};
+QuadStore = __decorate([
+    (0, inversify_1.injectable)(),
+    __metadata("design:paramtypes", [])
+], QuadStore);
+exports.QuadStore = QuadStore;
+//# sourceMappingURL=QuadStore.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oslo-flanders/core",
-  "version": "0.0.3-alpha.0",
+  "version": "0.0.4-alpha.0",
   "description": "Core interfaces and utilities",
   "author": "Digitaal Vlaanderen <https://data.vlaanderen.be/id/organisatie/OVO002949>",
   "homepage": "https://github.com/informatievlaanderen/OSLO-UML-Transformer/tree/main/packages/oslo-core#readme",
@@ -50,13 +50,15 @@
   },
   "dependencies": {
     "crypto-js": "^4.1.1",
+    "inversify": "^6.0.1",
     "n3": "^1.16.2",
     "node-fetch": "^2.6.7",
     "rdf-data-factory": "^1.1.1",
     "rdf-parse": "^2.1.1",
     "reflect-metadata": "^0.1.13",
     "streamify-string": "^1.0.1",
-    "winston": "^3.8.2"
+    "winston": "^3.8.2",
+    "winston-transport": "^4.5.0"
   },
   "devDependencies": {
     "@rdfjs/types": "^1.1.0",

package/lib/interfaces/IGenerationService.d.ts

@@ -1,8 +0,0 @@
-import type { IConfiguration } from './IConfiguration';
-/**
- * Interface that must be implemented by classes that use an RDF file as input and generates an artefact
- */
-export interface IGenerationService {
-    configuration: IConfiguration;
-    run: () => Promise<void>;
-}

package/lib/utils/N3StoreFunctions.d.ts

@@ -1,136 +0,0 @@
-import type * as RDF from '@rdfjs/types';
-import * as N3 from 'n3';
-/**
- * Given a local file, it is parsed and added to an in-memory quad store
- * @param fileOrUrl Local path of the input file
- * @returns A N3 quad store
- */
-export declare function createN3Store(file: string): Promise<N3.Store>;
-/**
- * Find the subject of the statement that matches the given subject, predicate and object
- * @param statementSubject The subject to match the statement subject
- * @param statementPredicate The predicate to match the statement predicate
- * @param statementObject The object to match the statement object
- * @param store An N3 quad store
- * @returns an RDF.Term or undefined if none found
- */
-export declare function getTargetStatementId(statementSubject: RDF.Term, statementPredicate: RDF.Term, statementObject: RDF.Term, store: N3.Store): RDF.Term | undefined;
-/**
- * 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
- */
-export declare function getAssignedUri(subject: RDF.Term, store: N3.Store): RDF.Term | undefined;
-/**
- * Finds the assigned URI in rdf:Statements
- * @param subject The statement subject
- * @param predicate The statement predicate
- * @param object The statement object for which the assigned URI must be found
- * @param store A N3 quad store
- * @returns An RDF.Term or undefined if not found
- */
-export declare function getAssignedUriViaStatements(subject: RDF.Term, predicate: RDF.Term, object: RDF.Term, store: N3.Store): RDF.Term | undefined;
-/**
- * Find all rdfs:labels for a given subject
- * @param subject The RDF.Term to find the rdfs:labels for
- * @param store A N3 quad store
- * @returns An array of RDF.Literals
- */
-export declare function getLabels(subject: RDF.Term, store: N3.Store): RDF.Literal[];
-/**
- * Finds the rdfs:label whose language tag matches the given language
- * @param subject The RDF.Term to find the rdfs:label for
- * @param store A N3 quad store
- * @param language A language tag
- * @returns An RDF.Literal or undefined if not found
- */
-export declare function getLabel(subject: RDF.Term, store: N3.Store, language?: string): RDF.Literal | undefined;
-/**
- * Finds the rdfs:label for an RDF.Term in rdf:Statements
- * @param subject The statement subject
- * @param predicate The statement predicate
- * @param object The statement object for which the label must be found
- * @param store A N3 quad store
- * @param language A language tag
- * @returns An RDF.Literal or undefined if not found
- */
-export declare function getLabelViaStatements(subject: RDF.Term, predicate: RDF.Term, object: RDF.Term, store: N3.Store, language: string): RDF.Literal | undefined;
-/**
- * Find all rdfs:comments for a given subject
- * @param subject The RDF.Term to find the rdfs:comments for
- * @param store A N3 quad store
- * @returns An array of RDF.Literals
- */
-export declare function getDefinitions(subject: RDF.Term, store: N3.Store): RDF.Literal[];
-/**
- * Finds the rdfs:comment whose language tag matches the given language
- * @param subject The RDF.Term to find the rdfs:comment for
- * @param store A N3 quad store
- * @param language A language tag
- * @returns An RDF.Literal or undefined if not found
- */
-export declare function getDefinition(subject: RDF.Term, store: N3.Store, language?: string): RDF.Literal | undefined;
-/**
- * Finds the rdfs:comment for an RDF.Term in rdf:Statements
- * @param subject The statement subject
- * @param predicate The statement predicate
- * @param object The statement object for which the definition must be found
- * @param store A N3 quad store
- * @param language A language tag
- * @returns An RDF.Literal or undefined if not found
- */
-export declare function getDefinitionViaStatements(subject: RDF.Term, predicate: RDF.Term, object: RDF.Term, store: N3.Store, language: string): 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
- */
-export declare function getParentsOfClass(subject: RDF.Term, store: N3.Store): RDF.Term[];
-/**
- * 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
- */
-export declare function getParentOfProperty(subject: RDF.Term, store: N3.Store): RDF.Term | 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
- */
-export declare function getRange(subject: RDF.Term, store: N3.Store): RDF.Term | 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
- */
-export declare function getDomain(subject: RDF.Term, store: N3.Store): RDF.Term | undefined;
-/**
- * Finds all the vann:usageNotes 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
- */
-export declare function getUsageNotes(subject: RDF.Term, store: N3.Store): RDF.Literal[];
-/**
- * Finds the vann:usageNote of which the language tag matches the given language
- * @param subject The RDF.Term to find the usage note for
- * @param store A N3 quad store
- * @param language A language tag
- * @returns An RDF.Literal or undefined if not found
- */
-export declare function getUsageNote(subject: RDF.Term, store: N3.Store, language?: string): RDF.Literal | undefined;
-/**
- * Finds the vann:usageNote for an RDF.Term in rdf:Statements
- * @param subject The statement subject
- * @param predicate The statement predicate
- * @param object The statement object for which the usage note must be found
- * @param store A N3 quad store
- * @param language A language tag
- * @returns An RDF.Literal or undefined if not found
- */
-export declare function getUsageNoteViaStatements(subject: RDF.Term, predicate: RDF.Term, object: RDF.Term, store: N3.Store, language: string): RDF.Literal | undefined;

package/lib/utils/N3StoreFunctions.js

@@ -1,257 +0,0 @@
-"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 __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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUsageNoteViaStatements = exports.getUsageNote = exports.getUsageNotes = exports.getDomain = exports.getRange = exports.getParentOfProperty = exports.getParentsOfClass = exports.getDefinitionViaStatements = exports.getDefinition = exports.getDefinitions = exports.getLabelViaStatements = exports.getLabel = exports.getLabels = exports.getAssignedUriViaStatements = exports.getAssignedUri = exports.getTargetStatementId = exports.createN3Store = void 0;
-const N3 = __importStar(require("n3"));
-const rdf_parse_1 = __importDefault(require("rdf-parse"));
-const fetchFileOrUrl_1 = require("./fetchFileOrUrl");
-const namespaces_1 = require("./namespaces");
-/**
- * Given a local file, it is parsed and added to an in-memory quad store
- * @param fileOrUrl Local path of the input file
- * @returns A N3 quad store
- */
-async function createN3Store(file) {
-    const store = new N3.Store();
-    const buffer = await (0, fetchFileOrUrl_1.fetchFileOrUrl)(file);
-    const textStream = require('streamify-string')(buffer.toString());
-    return new Promise((resolve, reject) => {
-        rdf_parse_1.default.parse(textStream, { path: file })
-            .on('data', (quad) => store.addQuad(quad))
-            .on('error', (error) => reject(error))
-            .on('end', () => resolve(store));
-    });
-}
-exports.createN3Store = createN3Store;
-/**
- * Find the subject of the statement that matches the given subject, predicate and object
- * @param statementSubject The subject to match the statement subject
- * @param statementPredicate The predicate to match the statement predicate
- * @param statementObject The object to match the statement object
- * @param store An N3 quad store
- * @returns an RDF.Term or undefined if none found
- */
-function getTargetStatementId(statementSubject, statementPredicate, statementObject, store) {
-    const statementIds = store.getSubjects(namespaces_1.ns.rdf('type'), namespaces_1.ns.rdf('Statement'), null);
-    const statementSubjectPredicateSubjects = store.getSubjects(namespaces_1.ns.rdf('subject'), statementSubject, null);
-    const statementPredicatePredicateSubjects = store.getSubjects(namespaces_1.ns.rdf('predicate'), statementPredicate, null);
-    const statementObjectPredicateSubjects = store.getSubjects(namespaces_1.ns.rdf('object'), statementObject, null);
-    const targetIds = statementIds
-        .filter(x => statementSubjectPredicateSubjects.some(y => y.value === x.value))
-        .filter(x => statementPredicatePredicateSubjects.some(y => y.value === x.value))
-        .filter(x => statementObjectPredicateSubjects.some(y => y.value === x.value));
-    if (targetIds.length > 1) {
-        throw new Error(`Found multiple statements with subject "${statementSubject.value}", predicate "${statementPredicate.value}" and object "${statementObject.value}".`);
-    }
-    return targetIds.shift();
-}
-exports.getTargetStatementId = getTargetStatementId;
-/**
- * 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
- */
-function getAssignedUri(subject, store) {
-    return store.getObjects(subject, namespaces_1.ns.example('assignedUri'), null).shift();
-}
-exports.getAssignedUri = getAssignedUri;
-/**
- * Finds the assigned URI in rdf:Statements
- * @param subject The statement subject
- * @param predicate The statement predicate
- * @param object The statement object for which the assigned URI must be found
- * @param store A N3 quad store
- * @returns An RDF.Term or undefined if not found
- */
-function getAssignedUriViaStatements(subject, predicate, object, store) {
-    const statementId = getTargetStatementId(subject, predicate, object, store);
-    if (!statementId) {
-        return undefined;
-    }
-    return getAssignedUri(statementId, store);
-}
-exports.getAssignedUriViaStatements = getAssignedUriViaStatements;
-/**
- * Find all rdfs:labels for a given subject
- * @param subject The RDF.Term to find the rdfs:labels for
- * @param store A N3 quad store
- * @returns An array of RDF.Literals
- */
-function getLabels(subject, store) {
-    return store.getObjects(subject, namespaces_1.ns.rdfs('label'), null);
-}
-exports.getLabels = getLabels;
-/**
- * Finds the rdfs:label whose language tag matches the given language
- * @param subject The RDF.Term to find the rdfs:label for
- * @param store A N3 quad store
- * @param language A language tag
- * @returns An RDF.Literal or undefined if not found
- */
-function getLabel(subject, store, language) {
-    return getLabels(subject, store).find(x => x.language === (language || ''));
-}
-exports.getLabel = getLabel;
-/**
- * Finds the rdfs:label for an RDF.Term in rdf:Statements
- * @param subject The statement subject
- * @param predicate The statement predicate
- * @param object The statement object for which the label must be found
- * @param store A N3 quad store
- * @param language A language tag
- * @returns An RDF.Literal or undefined if not found
- */
-function getLabelViaStatements(subject, predicate, object, store, language) {
-    const statementId = getTargetStatementId(subject, predicate, object, store);
-    if (!statementId) {
-        return undefined;
-    }
-    const label = getLabel(statementId, store, language);
-    return label || getLabel(statementId, store);
-}
-exports.getLabelViaStatements = getLabelViaStatements;
-/**
- * Find all rdfs:comments for a given subject
- * @param subject The RDF.Term to find the rdfs:comments for
- * @param store A N3 quad store
- * @returns An array of RDF.Literals
- */
-function getDefinitions(subject, store) {
-    return store.getObjects(subject, namespaces_1.ns.rdfs('comment'), null);
-}
-exports.getDefinitions = getDefinitions;
-/**
- * Finds the rdfs:comment whose language tag matches the given language
- * @param subject The RDF.Term to find the rdfs:comment for
- * @param store A N3 quad store
- * @param language A language tag
- * @returns An RDF.Literal or undefined if not found
- */
-function getDefinition(subject, store, language) {
-    return getDefinitions(subject, store).find(x => x.language === (language || ''));
-}
-exports.getDefinition = getDefinition;
-/**
- * Finds the rdfs:comment for an RDF.Term in rdf:Statements
- * @param subject The statement subject
- * @param predicate The statement predicate
- * @param object The statement object for which the definition must be found
- * @param store A N3 quad store
- * @param language A language tag
- * @returns An RDF.Literal or undefined if not found
- */
-function getDefinitionViaStatements(subject, predicate, object, store, language) {
-    const statementId = getTargetStatementId(subject, predicate, object, store);
-    if (!statementId) {
-        return undefined;
-    }
-    const definition = getDefinition(statementId, store, language);
-    return definition || getDefinition(statementId, store);
-}
-exports.getDefinitionViaStatements = getDefinitionViaStatements;
-/**
- * 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
- */
-function getParentsOfClass(subject, store) {
-    return store.getObjects(subject, namespaces_1.ns.rdfs('subClassOf'), null);
-}
-exports.getParentsOfClass = getParentsOfClass;
-/**
- * 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
- */
-function getParentOfProperty(subject, store) {
-    return store.getObjects(subject, namespaces_1.ns.rdfs('subPropertyOf'), null).shift();
-}
-exports.getParentOfProperty = getParentOfProperty;
-/**
- * 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
- */
-function getRange(subject, store) {
-    return store.getObjects(subject, namespaces_1.ns.rdfs('range'), null).shift();
-}
-exports.getRange = getRange;
-/**
- * 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
- */
-function getDomain(subject, store) {
-    return store.getObjects(subject, namespaces_1.ns.rdfs('domain'), null).shift();
-}
-exports.getDomain = getDomain;
-/**
- * Finds all the vann:usageNotes 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
- */
-function getUsageNotes(subject, store) {
-    return store.getObjects(subject, namespaces_1.ns.vann('usageNote'), null);
-}
-exports.getUsageNotes = getUsageNotes;
-/**
- * Finds the vann:usageNote of which the language tag matches the given language
- * @param subject The RDF.Term to find the usage note for
- * @param store A N3 quad store
- * @param language A language tag
- * @returns An RDF.Literal or undefined if not found
- */
-function getUsageNote(subject, store, language) {
-    return getUsageNotes(subject, store).find(x => x.language === (language || ''));
-}
-exports.getUsageNote = getUsageNote;
-/**
- * Finds the vann:usageNote for an RDF.Term in rdf:Statements
- * @param subject The statement subject
- * @param predicate The statement predicate
- * @param object The statement object for which the usage note must be found
- * @param store A N3 quad store
- * @param language A language tag
- * @returns An RDF.Literal or undefined if not found
- */
-function getUsageNoteViaStatements(subject, predicate, object, store, language) {
-    const statementId = getTargetStatementId(subject, predicate, object, store);
-    if (!statementId) {
-        return undefined;
-    }
-    const usageNote = getUsageNote(statementId, store, language);
-    return usageNote || getUsageNote(statementId, store);
-}
-exports.getUsageNoteViaStatements = getUsageNoteViaStatements;
-//# sourceMappingURL=N3StoreFunctions.js.map