@oslo-flanders/core 0.0.9-alpha.0 → 0.0.11-alpha.0

package/index.d.ts

@@ -0,0 +1,21 @@
+import 'reflect-metadata';
+export * from '@oslo-core/lib/interfaces/AppRunner';
+export * from '@oslo-core/lib/interfaces/IConfiguration';
+export * from '@oslo-core/lib/interfaces/IOutputHandler';
+export * from '@oslo-core/lib/interfaces/IService';
+export * from '@oslo-core/lib/utils/fetchFileOrUrl';
+export * from '@oslo-core/lib/utils/namespaces';
+export * from '@oslo-core/lib/utils/uniqueId';
+export * from '@oslo-core/lib/store/QuadStore';
+export * from '@oslo-core/lib/ServiceIdentifier';
+export * from '@oslo-core/lib/enums/Scope';
+export * from '@oslo-core/lib/enums/PropertyTypes';
+export * from '@oslo-core/lib/logging/LogLevel';
+export * from '@oslo-core/lib/logging/Logger';
+export * from '@oslo-core/lib/logging/VoidLogger';
+export * from '@oslo-core/lib/logging/WinstonLogger';
+export * from '@oslo-core/lib/logging/LogUtil';
+export * from '@oslo-core/lib/logging/LoggerFactory';
+export * from '@oslo-core/lib/logging/VoidLoggerFactory';
+export * from '@oslo-core/lib/logging/WinstonLoggerFactory';
+export * from '@oslo-core/lib/utils/storeUtils';

package/index.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+// Extra manually added alias was required for nested NPM packages:
+// https://github.com/ilearnio/module-alias?tab=readme-ov-file#using-within-another-npm-package
+const moduleAlias = require('module-alias');
+moduleAlias.addAliases({
+    '@oslo-core': `${__dirname}`,
+});
+__exportStar(require("@oslo-core/lib/interfaces/AppRunner"), exports);
+__exportStar(require("@oslo-core/lib/interfaces/IConfiguration"), exports);
+__exportStar(require("@oslo-core/lib/interfaces/IOutputHandler"), exports);
+__exportStar(require("@oslo-core/lib/interfaces/IService"), exports);
+__exportStar(require("@oslo-core/lib/utils/fetchFileOrUrl"), exports);
+__exportStar(require("@oslo-core/lib/utils/namespaces"), exports);
+__exportStar(require("@oslo-core/lib/utils/uniqueId"), exports);
+__exportStar(require("@oslo-core/lib/store/QuadStore"), exports);
+__exportStar(require("@oslo-core/lib/ServiceIdentifier"), exports);
+__exportStar(require("@oslo-core/lib/enums/Scope"), exports);
+__exportStar(require("@oslo-core/lib/enums/PropertyTypes"), exports);
+__exportStar(require("@oslo-core/lib/logging/LogLevel"), exports);
+__exportStar(require("@oslo-core/lib/logging/Logger"), exports);
+__exportStar(require("@oslo-core/lib/logging/VoidLogger"), exports);
+__exportStar(require("@oslo-core/lib/logging/WinstonLogger"), exports);
+__exportStar(require("@oslo-core/lib/logging/LogUtil"), exports);
+__exportStar(require("@oslo-core/lib/logging/LoggerFactory"), exports);
+__exportStar(require("@oslo-core/lib/logging/VoidLoggerFactory"), exports);
+__exportStar(require("@oslo-core/lib/logging/WinstonLoggerFactory"), exports);
+__exportStar(require("@oslo-core/lib/utils/storeUtils"), exports);
+//# sourceMappingURL=index.js.map

package/lib/ServiceIdentifier.d.ts

@@ -0,0 +1,7 @@
+export declare class ServiceIdentifier {
+    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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceIdentifier = void 0;
+/* eslint-disable eslint-comments/disable-enable-pair */
+/* eslint-disable @typescript-eslint/no-extraneous-class */
+// This must be a class, because it must be possible to extend it in implementations
+class ServiceIdentifier {
+}
+exports.ServiceIdentifier = ServiceIdentifier;
+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/enums/PropertyTypes.d.ts

@@ -0,0 +1,5 @@
+export declare enum PropertyType {
+    DataTypeProperty = "http://www.w3.org/2002/07/owl#DatatypeProperty",
+    ObjectProperty = "http://www.w3.org/2002/07/owl#ObjectProperty",
+    Property = "http://www.w3.org/1999/02/22-rdf-syntax-ns#Property"
+}

package/lib/enums/PropertyTypes.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyType = void 0;
+var PropertyType;
+(function (PropertyType) {
+    PropertyType["DataTypeProperty"] = "http://www.w3.org/2002/07/owl#DatatypeProperty";
+    PropertyType["ObjectProperty"] = "http://www.w3.org/2002/07/owl#ObjectProperty";
+    PropertyType["Property"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#Property";
+})(PropertyType = exports.PropertyType || (exports.PropertyType = {}));
+//# sourceMappingURL=PropertyTypes.js.map

package/lib/enums/Scope.d.ts

@@ -0,0 +1,6 @@
+export declare enum Scope {
+    InPackage = "https://data.vlaanderen.be/id/concept/scope/InPackage",
+    InPublicationEnvironment = "https://data.vlaanderen.be/id/concept/scope/InPublicationEnvironment",
+    External = "https://data.vlaanderen.be/id/concept/scope/External",
+    Undefined = "https://data.vlaanderen.be/id/concept/scope/Undefined"
+}

package/lib/enums/Scope.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scope = void 0;
+var Scope;
+(function (Scope) {
+    Scope["InPackage"] = "https://data.vlaanderen.be/id/concept/scope/InPackage";
+    Scope["InPublicationEnvironment"] = "https://data.vlaanderen.be/id/concept/scope/InPublicationEnvironment";
+    Scope["External"] = "https://data.vlaanderen.be/id/concept/scope/External";
+    Scope["Undefined"] = "https://data.vlaanderen.be/id/concept/scope/Undefined";
+})(Scope = exports.Scope || (exports.Scope = {}));
+//# sourceMappingURL=Scope.js.map

package/lib/interfaces/AppRunner.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import type { Container } from 'inversify';
+import type { IConfiguration } from '@oslo-core/lib/interfaces/IConfiguration';
+import type { IService } from '@oslo-core/lib/interfaces/IService';
+export type CliArgv = string[];
+export type YargsParams = {
+    [x: string]: unknown;
+    _: (string | number)[];
+    $0: string;
+} | {
+    [x: string]: unknown;
+    _: (string | number)[];
+    $0: string;
+};
+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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppRunner = void 0;
+const process_1 = require("process");
+const LogUtil_1 = require("@oslo-core/lib/logging/LogUtil");
+const ServiceIdentifier_1 = require("@oslo-core/lib/ServiceIdentifier");
+class AppRunner {
+    runCliSync(process) {
+        this.runCli(process.argv).catch((error) => {
+            process_1.stderr.write(error.message);
+            // eslint-disable-next-line unicorn/no-process-exit
+            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/IConfiguration.d.ts

@@ -0,0 +1,7 @@
+import type { YargsParams } from '@oslo-core/lib/interfaces/AppRunner';
+/**
+ * Interface that must be implemented by classes that contain configuration properties
+ */
+export interface IConfiguration {
+    createFromCli: (params: YargsParams) => Promise<void>;
+}

package/lib/interfaces/IConfiguration.js

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

package/lib/interfaces/IOutputHandler.d.ts

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

package/lib/interfaces/IOutputHandler.js

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

package/lib/interfaces/IService.d.ts

@@ -0,0 +1,11 @@
+import type { IConfiguration } from '@oslo-core/lib/interfaces/IConfiguration';
+import type { Logger } from '@oslo-core/lib/logging/Logger';
+/**
+ * Interface that must be implemented by conversion of generation services
+ */
+export interface IService {
+    logger: Logger;
+    configuration: IConfiguration;
+    init: () => Promise<void>;
+    run: () => Promise<void>;
+}

package/lib/interfaces/IService.js

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

package/lib/logging/LogLevel.d.ts

@@ -0,0 +1,5 @@
+export declare const LOG_LEVELS: readonly ["error", "warn", "info", "verbose", "debug", "silly"];
+/**
+ * Different log levels, from most important to least important.
+ */
+export type LogLevel = typeof LOG_LEVELS[number];

package/lib/logging/LogLevel.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOG_LEVELS = void 0;
+exports.LOG_LEVELS = ['error', 'warn', 'info', 'verbose', 'debug', 'silly'];
+//# sourceMappingURL=LogLevel.js.map

package/lib/logging/LogUtil.d.ts

@@ -0,0 +1,4 @@
+import type { YargsParams } from '@oslo-core/lib/interfaces/AppRunner';
+import type { Logger } from '@oslo-core/lib/logging/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("@oslo-core/lib/logging/VoidLoggerFactory");
+const WinstonLoggerFactory_1 = require("@oslo-core/lib/logging/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

@@ -0,0 +1,20 @@
+import 'reflect-metadata';
+import type { LogLevel } from '@oslo-core/lib/logging/LogLevel';
+export interface Logger {
+    log: (level: LogLevel, message: string) => Logger;
+    error: (message: string) => Logger;
+    warn: (message: string) => Logger;
+    info: (message: string) => Logger;
+    verbose: (message: string) => Logger;
+    debug: (message: string) => Logger;
+    silly: (message: string) => Logger;
+}
+export declare abstract class BaseLogger implements Logger {
+    abstract log(level: LogLevel, message: string): Logger;
+    error(message: string): Logger;
+    warn(message: string): Logger;
+    info(message: string): Logger;
+    verbose(message: string): Logger;
+    debug(message: string): Logger;
+    silly(message: string): Logger;
+}

package/lib/logging/Logger.js

@@ -0,0 +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;
+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/lib/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/logging/LoggerFactory.js

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

package/lib/logging/VoidLogger.d.ts

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

package/lib/logging/VoidLogger.js

@@ -0,0 +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("@oslo-core/lib/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/lib/logging/LoggerFactory';
+import { VoidLogger } from '@oslo-core/lib/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/lib/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

@@ -0,0 +1,8 @@
+import { Logger as WinstonInnerLogger } from 'winston';
+import { BaseLogger } from '@oslo-core/lib/logging/Logger';
+import type { LogLevel } from '@oslo-core/lib/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

@@ -0,0 +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 Logger_1 = require("@oslo-core/lib/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/lib/logging/Logger';
+import type { LoggerFactory } from '@oslo-core/lib/logging/LoggerFactory';
+import type { LogLevel } from '@oslo-core/lib/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/lib/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;
+}

package/lib/store/QuadStore.js

@@ -0,0 +1,306 @@
+"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("@oslo-core/lib/utils/fetchFileOrUrl");
+const namespaces_1 = require("@oslo-core/lib/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, graph = null) {
+        return this.store.getQuads(subject, predicate, object, graph);
+    }
+    findQuad(subject, predicate, object, graph = null) {
+        return this.findQuads(subject, predicate, object, graph).shift();
+    }
+    findSubjects(predicate, object, graph = null) {
+        return this.store.getSubjects(predicate, object, graph);
+    }
+    findSubject(predicate, object, graph = null) {
+        return this.findSubjects(predicate, object, graph).shift();
+    }
+    findObjects(subject, predicate, graph = null) {
+        return this.store.getObjects(subject, predicate, graph);
+    }
+    findObject(subject, predicate, graph = null) {
+        return this.findObjects(subject, predicate, graph).shift();
+    }
+    /**
+     * Finds the subject where predicate is 'rdf:type' and object 'oslo:Package'
+     * @returns a RDF.NamedNode or undefined
+     */
+    getPackageId() {
+        return (this.store.getSubjects(namespaces_1.ns.rdf('type'), namespaces_1.ns.oslo('Package'), null).shift());
+    }
+    /**
+     * Finds all subjects where predicate is 'rdf:type' and object 'owl:Class'
+     * @returns an array of RDF.NamedNodes
+     */
+    getClassIds(graph = null) {
+        return (this.store.getSubjects(namespaces_1.ns.rdf('type'), namespaces_1.ns.owl('Class'), graph));
+    }
+    /**
+     * Finds all subjects where predicate is 'rdf:type' and object 'owl:DatatypeProperty'
+     * @returns an array of RDF.NamedNodes
+     */
+    getDatatypePropertyIds(graph = null) {
+        return (this.store.getSubjects(namespaces_1.ns.rdf('type'), namespaces_1.ns.owl('DatatypeProperty'), graph));
+    }
+    /**
+     * Finds all subjects where predicate is 'rdf:type' and object 'owl:ObjectProperty'
+     * @returns an array of RDF.NamedNodes
+     */
+    getObjectPropertyIds(graph = null) {
+        return (this.store.getSubjects(namespaces_1.ns.rdf('type'), namespaces_1.ns.owl('ObjectProperty'), graph));
+    }
+    /**
+     * 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, graph = null) {
+        return (this.store.getObjects(subject, namespaces_1.ns.oslo('assignedURI'), graph).shift());
+    }
+    /**
+     * 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, graph = null) {
+        const vocLabel = this.store.getQuads(subject, namespaces_1.ns.oslo('vocLabel'), null, graph);
+        const apLabel = this.store.getQuads(subject, namespaces_1.ns.oslo('apLabel'), null, graph);
+        const diagramLabel = this.store.getQuads(subject, namespaces_1.ns.oslo('diagramLabel'), null, graph);
+        return vocLabel.concat(apLabel).concat(diagramLabel);
+    }
+    /**
+     * 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, language, graph = null) {
+        var _a;
+        return (_a = this.getLabels(subject, graph).find((x) => x.predicate.equals(namespaces_1.ns.oslo('vocLabel')) &&
+            x.object.language === (language || ''))) === null || _a === void 0 ? void 0 : _a.object;
+    }
+    /**
+     * 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, language, graph = null) {
+        var _a;
+        return (_a = this.getLabels(subject, graph).find((x) => x.predicate.equals(namespaces_1.ns.oslo('apLabel')) &&
+            x.object.language === (language || ''))) === null || _a === void 0 ? void 0 : _a.object;
+    }
+    /**
+     * 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, graph = null) {
+        var _a;
+        return (_a = this.getLabels(subject, graph).find((x) => x.predicate.equals(namespaces_1.ns.oslo('diagramLabel')))) === null || _a === void 0 ? void 0 : _a.object;
+    }
+    /**
+     * 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, graph = null) {
+        const vocDefinitions = this.store.getQuads(subject, namespaces_1.ns.oslo('vocDefinition'), null, graph);
+        const apDefinitions = this.store.getQuads(subject, namespaces_1.ns.oslo('apDefinition'), null, graph);
+        return vocDefinitions.concat(apDefinitions);
+    }
+    /**
+     * 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, language, graph = null) {
+        var _a;
+        return (_a = this.getDefinitions(subject, graph).find((x) => x.predicate.equals(namespaces_1.ns.oslo('vocDefinition')) &&
+            x.object.language === (language || ''))) === null || _a === void 0 ? void 0 : _a.object;
+    }
+    /**
+     * 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, language, graph = null) {
+        var _a;
+        return (_a = this.getDefinitions(subject, graph).find((x) => x.predicate.equals(namespaces_1.ns.oslo('apDefinition')) &&
+            x.object.language === (language || ''))) === null || _a === void 0 ? void 0 : _a.object;
+    }
+    /**
+     * 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, graph = null) {
+        return (this.store.getObjects(subject, namespaces_1.ns.rdfs('range'), graph).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, graph = null) {
+        return (this.store.getObjects(subject, namespaces_1.ns.rdfs('domain'), graph).shift());
+    }
+    /**
+     * 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, graph = null) {
+        const vocUsageNotes = this.store.getQuads(subject, namespaces_1.ns.oslo('vocUsageNote'), null, graph);
+        const apUsageNotes = this.store.getQuads(subject, namespaces_1.ns.oslo('apUsageNote'), null, graph);
+        return vocUsageNotes.concat(apUsageNotes);
+    }
+    /**
+     * 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, language, graph = null) {
+        var _a;
+        return (_a = this.getUsageNotes(subject, graph).find((x) => x.predicate.equals(namespaces_1.ns.oslo('vocUsageNote')) &&
+            x.object.language === (language || ''))) === null || _a === void 0 ? void 0 : _a.object;
+    }
+    /**
+     * 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, language, graph = null) {
+        var _a;
+        return (_a = this.getUsageNotes(subject, graph).find((x) => x.predicate.equals(namespaces_1.ns.oslo('apUsageNote')) &&
+            x.object.language === (language || ''))) === null || _a === void 0 ? void 0 : _a.object;
+    }
+    /**
+     * 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, graph = null) {
+        return (this.store.getObjects(subject, namespaces_1.ns.oslo('scope'), graph).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, graph = null) {
+        return (this.store.getObjects(subject, namespaces_1.ns.shacl('minCount'), graph).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, graph = null) {
+        return (this.store.getObjects(subject, namespaces_1.ns.shacl('maxCount'), graph).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, graph = null) {
+        return (this.store.getObjects(subject, namespaces_1.ns.rdfs('subClassOf'), graph));
+    }
+    /**
+     * 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, graph = null) {
+        return (this.store.getObjects(subject, namespaces_1.ns.rdfs('subPropertyOf'), graph).shift());
+    }
+    getCodelist(subject, graph = null) {
+        return (this.store.getObjects(subject, namespaces_1.ns.oslo('codelist'), graph).shift());
+    }
+};
+QuadStore = __decorate([
+    (0, inversify_1.injectable)(),
+    __metadata("design:paramtypes", [])
+], QuadStore);
+exports.QuadStore = QuadStore;
+//# sourceMappingURL=QuadStore.js.map

package/lib/utils/fetchFileOrUrl.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="node" />
+export declare function fetchFileOrUrl(file: string): Promise<Buffer>;

package/lib/utils/fetchFileOrUrl.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchFileOrUrl = void 0;
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const node_fetch_1 = __importDefault(require("node-fetch"));
+async function fetchFileOrUrl(file) {
+    if (file.startsWith('http://') || file.startsWith('https://')) {
+        return (await (0, node_fetch_1.default)(file)).buffer();
+    }
+    if (file.startsWith('file://')) {
+        file = file.slice(7);
+    }
+    if (!(0, fs_1.existsSync)(file) || !(await (0, promises_1.stat)(file)).isFile()) {
+        throw new Error(`Path does not refer to a valid file: ${file}`);
+    }
+    return (0, promises_1.readFile)(file);
+}
+exports.fetchFileOrUrl = fetchFileOrUrl;
+//# sourceMappingURL=fetchFileOrUrl.js.map

package/lib/utils/namespaces.d.ts

@@ -0,0 +1,24 @@
+declare enum Prefixes {
+    adms = "http://www.w3.org/ns/adms#",
+    dcat = "http://www.w3.org/ns/dcat#",
+    dcterms = "http://purl.org/dc/terms/",
+    foaf = "http://xmlns.com/foaf/0.1/",
+    owl = "http://www.w3.org/2002/07/owl#",
+    vlaanderen = "https://data.vlaanderen.be/ns/",
+    void = "http://rdfs.org/ns/void#",
+    rdf = "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+    rdfs = "http://www.w3.org/2000/01/rdf-schema#",
+    qb = "http://purl.org/linked-data/cube#",
+    skos = "http://www.w3.org/2004/02/skos/core#",
+    xsd = "http://www.w3.org/2001/XMLSchema#",
+    person = "http://www.w3.org/ns/person#",
+    vann = "http://purl.org/vocab/vann/",
+    shacl = "http://w3.org/ns/shacl#",
+    prov = "http://www.w3.org/ns/prov#",
+    oslo = "https://implementatie.data.vlaanderen.be/ns/oslo-toolchain#"
+}
+export type Namespace = {
+    [T in keyof typeof Prefixes]: Function;
+};
+export declare const ns: Namespace;
+export {};

package/lib/utils/namespaces.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ns = void 0;
+const rdf_data_factory_1 = require("rdf-data-factory");
+const factory = new rdf_data_factory_1.DataFactory();
+var Prefixes;
+(function (Prefixes) {
+    Prefixes["adms"] = "http://www.w3.org/ns/adms#";
+    Prefixes["dcat"] = "http://www.w3.org/ns/dcat#";
+    Prefixes["dcterms"] = "http://purl.org/dc/terms/";
+    Prefixes["foaf"] = "http://xmlns.com/foaf/0.1/";
+    Prefixes["owl"] = "http://www.w3.org/2002/07/owl#";
+    Prefixes["vlaanderen"] = "https://data.vlaanderen.be/ns/";
+    Prefixes["void"] = "http://rdfs.org/ns/void#";
+    Prefixes["rdf"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
+    Prefixes["rdfs"] = "http://www.w3.org/2000/01/rdf-schema#";
+    Prefixes["qb"] = "http://purl.org/linked-data/cube#";
+    Prefixes["skos"] = "http://www.w3.org/2004/02/skos/core#";
+    Prefixes["xsd"] = "http://www.w3.org/2001/XMLSchema#";
+    Prefixes["person"] = "http://www.w3.org/ns/person#";
+    Prefixes["vann"] = "http://purl.org/vocab/vann/";
+    Prefixes["shacl"] = "http://w3.org/ns/shacl#";
+    Prefixes["prov"] = "http://www.w3.org/ns/prov#";
+    Prefixes["oslo"] = "https://implementatie.data.vlaanderen.be/ns/oslo-toolchain#";
+})(Prefixes || (Prefixes = {}));
+const vocab = () => {
+    const namespaces = {};
+    for (const prefix in Prefixes) {
+        const expansion = Prefixes[prefix];
+        namespaces[prefix] = (localName = '') => factory.namedNode(expansion + localName);
+    }
+    return namespaces;
+};
+exports.ns = vocab();
+//# sourceMappingURL=namespaces.js.map

package/lib/utils/storeUtils.d.ts

@@ -0,0 +1,10 @@
+import type * as RDF from '@rdfjs/types';
+import type { QuadStore } from '@oslo-core/lib/store/QuadStore';
+export declare function getApplicationProfileLabel(subject: RDF.Term, store: QuadStore, language?: string | null): RDF.Literal | undefined;
+export declare function getVocabularyLabel(subject: RDF.Term, store: QuadStore, language?: string | null): RDF.Literal | undefined;
+export declare function getApplicationProfileDefinition(subject: RDF.Term, store: QuadStore, language?: string | null): RDF.Literal | undefined;
+export declare function getVocabularyDefinition(subject: RDF.Term, store: QuadStore, language?: string | null): RDF.Literal | undefined;
+export declare function getApplicationProfileUsageNote(subject: RDF.Term, store: QuadStore, language?: string | null): RDF.Literal | undefined;
+export declare function getVocabularyUsageNote(subject: RDF.Term, store: QuadStore, language?: string | null): RDF.Literal | undefined;
+export declare function getMinCount(subject: RDF.Term, store: QuadStore): string | undefined;
+export declare function getMaxCount(subject: RDF.Term, store: QuadStore): string | undefined;

package/lib/utils/storeUtils.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMaxCount = exports.getMinCount = exports.getVocabularyUsageNote = exports.getApplicationProfileUsageNote = exports.getVocabularyDefinition = exports.getApplicationProfileDefinition = exports.getVocabularyLabel = exports.getApplicationProfileLabel = void 0;
+const namespaces_1 = require("@oslo-core/lib/utils/namespaces");
+function getApplicationProfileLabel(subject, store, language = null) {
+    var _a, _b, _c;
+    const labels = store.getLabels(subject);
+    if (labels.some(x => x.predicate.equals(namespaces_1.ns.oslo('apLabel')))) {
+        return (_a = labels
+            .find(x => x.predicate.equals(namespaces_1.ns.oslo('apLabel')) &&
+            x.object.language === (language || ''))) === null || _a === void 0 ? void 0 : _a.object;
+    }
+    if (labels.some(x => x.predicate.equals(namespaces_1.ns.oslo('vocLabel')))) {
+        return (_b = labels.find(x => x.predicate.equals(namespaces_1.ns.oslo('vocLabel')) &&
+            x.object.language === (language || ''))) === null || _b === void 0 ? void 0 : _b.object;
+    }
+    return (_c = labels.find(x => x.predicate.equals(namespaces_1.ns.oslo('diagramLabel')))) === null || _c === void 0 ? void 0 : _c.object;
+}
+exports.getApplicationProfileLabel = getApplicationProfileLabel;
+function getVocabularyLabel(subject, store, language = null) {
+    var _a, _b;
+    const labels = store.getLabels(subject);
+    if (labels.some(x => x.predicate.equals(namespaces_1.ns.oslo('vocLabel')))) {
+        return (_a = labels
+            .find(x => x.predicate.equals(namespaces_1.ns.oslo('vocLabel')) &&
+            x.object.language === (language || ''))) === null || _a === void 0 ? void 0 : _a.object;
+    }
+    return (_b = labels.find(x => x.predicate.equals(namespaces_1.ns.oslo('diagramLabel')))) === null || _b === void 0 ? void 0 : _b.object;
+}
+exports.getVocabularyLabel = getVocabularyLabel;
+function getApplicationProfileDefinition(subject, store, language = null) {
+    var _a, _b;
+    const definitions = store.getDefinitions(subject);
+    if (definitions.some(x => x.predicate.equals(namespaces_1.ns.oslo('apDefinition')))) {
+        return (_a = definitions
+            .find(x => x.predicate.equals(namespaces_1.ns.oslo('apDefinition')) &&
+            x.object.language === (language || ''))) === null || _a === void 0 ? void 0 : _a.object;
+    }
+    if (definitions.some(x => x.predicate.equals(namespaces_1.ns.oslo('vocDefinition')))) {
+        return (_b = definitions
+            .find(x => x.predicate.equals(namespaces_1.ns.oslo('vocDefinition')) &&
+            x.object.language === (language || ''))) === null || _b === void 0 ? void 0 : _b.object;
+    }
+    return undefined;
+}
+exports.getApplicationProfileDefinition = getApplicationProfileDefinition;
+function getVocabularyDefinition(subject, store, language = null) {
+    var _a;
+    const definitions = store.getDefinitions(subject);
+    if (definitions.some(x => x.predicate.equals(namespaces_1.ns.oslo('vocDefinition')))) {
+        return (_a = definitions
+            .find(x => x.predicate.equals(namespaces_1.ns.oslo('vocDefinition')) &&
+            x.object.language === (language || ''))) === null || _a === void 0 ? void 0 : _a.object;
+    }
+    return undefined;
+}
+exports.getVocabularyDefinition = getVocabularyDefinition;
+function getApplicationProfileUsageNote(subject, store, language = null) {
+    var _a, _b;
+    const usageNotes = store.getUsageNotes(subject);
+    if (usageNotes.some(x => x.predicate.equals(namespaces_1.ns.oslo('apUsageNote')))) {
+        return (_a = usageNotes
+            .find(x => x.predicate.equals(namespaces_1.ns.oslo('apUsageNote')) &&
+            x.object.language === (language || ''))) === null || _a === void 0 ? void 0 : _a.object;
+    }
+    if (usageNotes.some(x => x.predicate.equals(namespaces_1.ns.oslo('vocUsageNote')))) {
+        return (_b = usageNotes
+            .find(x => x.predicate.equals(namespaces_1.ns.oslo('vocUsageNote')) &&
+            x.object.language === (language || ''))) === null || _b === void 0 ? void 0 : _b.object;
+    }
+    return undefined;
+}
+exports.getApplicationProfileUsageNote = getApplicationProfileUsageNote;
+function getVocabularyUsageNote(subject, store, language = null) {
+    var _a;
+    const usageNotes = store.getUsageNotes(subject);
+    if (usageNotes.some(x => x.predicate.equals(namespaces_1.ns.oslo('vocUsageNote')))) {
+        return (_a = usageNotes
+            .find(x => x.predicate.equals(namespaces_1.ns.oslo('vocUsageNote')) &&
+            x.object.language === (language || ''))) === null || _a === void 0 ? void 0 : _a.object;
+    }
+    return undefined;
+}
+exports.getVocabularyUsageNote = getVocabularyUsageNote;
+function getMinCount(subject, store) {
+    var _a;
+    return (_a = store.findObject(subject, namespaces_1.ns.shacl('minCount'))) === null || _a === void 0 ? void 0 : _a.value;
+}
+exports.getMinCount = getMinCount;
+function getMaxCount(subject, store) {
+    var _a;
+    return (_a = store.findObject(subject, namespaces_1.ns.shacl('maxCount'))) === null || _a === void 0 ? void 0 : _a.value;
+}
+exports.getMaxCount = getMaxCount;
+//# sourceMappingURL=storeUtils.js.map

package/lib/utils/uniqueId.d.ts

@@ -0,0 +1 @@
+export declare function uniqueId(guid: string, label: string, id: number): string;

package/lib/utils/uniqueId.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniqueId = void 0;
+const crypto_js_1 = require("crypto-js");
+function uniqueId(guid, label, id) {
+    const object = {
+        guid,
+        label,
+        id,
+    };
+    return (0, crypto_js_1.SHA256)(JSON.stringify(object)).toString();
+}
+exports.uniqueId = uniqueId;
+//# sourceMappingURL=uniqueId.js.map

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@oslo-flanders/core",
-  "version": "0.0.9-alpha.0",
+  "version": "0.0.11-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",
   "license": "MIT",
   "main": "index.js",
   "_moduleAliases": {
-    "@oslo-core": "./lib"
+    "@oslo-core": "./"
   },
   "directories": {
     "lib": "lib"
@@ -43,7 +43,7 @@
     ],
     "testEnvironment": "node",
     "moduleNameMapper": {
-      "^@oslo-core/(.*)$": "<rootDir>/lib/$1"
+      "^@oslo-core/(.*)$": "<rootDir>/$1"
     }
   },
   "scripts": {