optolith-database-schema 0.10.0 → 0.11.0

package/lib/validation/builders/schema.d.ts

@@ -0,0 +1,31 @@
+import type { default as AjvModule, DefinedError } from "ajv";
+import { Result } from "../../helpers/result.js";
+type Ajv = AjvModule.default;
+export type SchemaError = DefinedError;
+/**
+ * The result of validating a single file. Either the valid data or validation
+ * errors.
+ */
+export type SchemaValidationResult<T> = Result<T, SchemaError[]>;
+/**
+ * A function that validates `data` at a specific `filePath` to be of type `T`
+ * using a specified `validator`.
+ */
+export type SchemaValidator<T> = (validator: Ajv, data: unknown, filePath: string) => SchemaValidationResult<T>;
+/**
+ * Options for creating a `TypeValidator`.
+ */
+export type SchemaValidatorOptions = {
+    ignoreFileNamePattern?: boolean;
+};
+/**
+ * Creates a type validator based on the URL of the type definition source file
+ * and options. The source file URL is used to derive it’s corresponding schema
+ * location.
+ * @param importMetaUrl The `import.meta.url` value of the type definition
+ * source file.
+ * @param options
+ * @returns
+ */
+export declare const createSchemaValidator: <T>(importMetaUrl: string, options?: SchemaValidatorOptions) => SchemaValidator<T>;
+export {};

package/lib/validation/builders/schema.js

@@ -0,0 +1,32 @@
+import { basename, relative, sep } from "path";
+import { fileURLToPath } from "url";
+import { libDir } from "../../../build/config.js";
+import { changeFileExtension } from "../../helpers/io.js";
+import { error, ok } from "../../helpers/result.js";
+const schemaIdFromSourcePath = (sourcePath) => {
+    const relativePathOfType = relative(libDir, fileURLToPath(sourcePath));
+    const relativePathOfSchema = changeFileExtension(relativePathOfType, ".schema.json");
+    return "/" + relativePathOfSchema.split(sep).join("/");
+};
+/**
+ * Creates a type validator based on the URL of the type definition source file
+ * and options. The source file URL is used to derive it’s corresponding schema
+ * location.
+ * @param importMetaUrl The `import.meta.url` value of the type definition
+ * source file.
+ * @param options
+ * @returns
+ */
+export const createSchemaValidator = (importMetaUrl, options = {}) => {
+    const { ignoreFileNamePattern = false } = options;
+    const schemaId = schemaIdFromSourcePath(importMetaUrl);
+    return (validator, data, filePath) => {
+        const fileName = basename(filePath);
+        if (validator.validate(schemaId, data)) {
+            return ok(data);
+        }
+        else {
+            return error(validator.errors ?? []);
+        }
+    };
+};

package/lib/validation/filename.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Returns the numeric prefix of a filename, that is, the part before the first
+ * underscore.
+ */
+export declare const getFIlenamePrefixAsNumericId: (_data: {}, filepath: string) => number;
+/**
+ * Returns the filename without the extension.
+ */
+export declare const getFilenameAsStringId: (_data: {}, filepath: string) => string;

package/lib/validation/filename.js

@@ -0,0 +1,10 @@
+import { basename, extname } from "node:path";
+/**
+ * Returns the numeric prefix of a filename, that is, the part before the first
+ * underscore.
+ */
+export const getFIlenamePrefixAsNumericId = (_data, filepath) => Number.parseInt(/^(\d+?)_/.exec(basename(filepath))?.[1] ?? "", 10);
+/**
+ * Returns the filename without the extension.
+ */
+export const getFilenameAsStringId = (_data, filepath) => basename(filepath, extname(filepath));

package/lib/validation/raw.d.ts

@@ -0,0 +1,9 @@
+import { TypeMap } from "../config.js";
+import "../helpers/array.js";
+import { Result } from "../helpers/result.js";
+import { EntityDirectoryPaths, TypeValidationError, ValidationOptions } from "../main.js";
+import { TypeId } from "../typeConfig.js";
+export type TypeIdPair<K extends keyof TypeMap> = [id: TypeId<K>, data: TypeMap[K]];
+export type TypeValidationResult<K extends keyof TypeMap> = Result<TypeIdPair<K>, TypeValidationError[]>;
+export type TypeValidationResultsByType = [keyof TypeMap, [filePath: string, result: TypeValidationResult<keyof TypeMap>][]][];
+export declare const getRawValidationResults: (entityDirectoryPaths: EntityDirectoryPaths, options?: ValidationOptions) => Promise<TypeValidationResultsByType>;

package/lib/validation/raw.js

@@ -0,0 +1,55 @@
+import { readdir } from "fs/promises";
+import { join } from "path";
+import { jsonSchemaDir, jsonSchemaSpec } from "../../build/config.js";
+import { configMap } from "../config.js";
+import "../helpers/array.js";
+import { collator } from "../helpers/i18n.js";
+import { isHiddenFileName, readYamlFile } from "../helpers/io.js";
+import { mapSecond, mapSecondAsync, mapToSecondAsync } from "../helpers/pair.js";
+import { Result, isOk } from "../helpers/result.js";
+import { validateFileName } from "./builders/naming.js";
+import { getPreparedSchemaValidator } from "./schema.js";
+const getFiles = async (path) => (await readdir(path))
+    .sort(collator.compare)
+    .filter(isHiddenFileName)
+    .map(fileName => join(path, fileName))
+    .map(mapToSecondAsync(async (filePath) => {
+    try {
+        return await readYamlFile(filePath);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            error.message = `in "${filePath}":\n  ${error.message}`;
+        }
+        return null;
+    }
+}))
+    .promiseAll();
+const validateStructuralIntegrityOfFiles = (validator, typeConfig, validateFileName, files) => files.map(mapSecond((data, path) => {
+    const schemaValidationResult = typeConfig.schemaValidator(validator, data, path);
+    const fileNameValidationResult = validateFileName(path);
+    return Result.map(Result.combine(schemaValidationResult, fileNameValidationResult, (data, _) => data, (schemaErrors, fileNameErrors) => [...schemaErrors, ...fileNameErrors]), data => [typeConfig.id(data, path), data]);
+}));
+const validateSemanticAndReferencialIntegrityOfFiles = (validators, typeConfig, results) => results.map(mapSecond((res, path) => Result.reduce(res, ([id, data]) => Result.map(typeConfig.integrityValidator(validators, data, path), () => [id, data]), errors => Result.error(errors))));
+export const getRawValidationResults = async (entityDirectoryPaths, options = {}) => {
+    const { checkIntegrity = false } = options;
+    const validator = await getPreparedSchemaValidator(jsonSchemaSpec, {}, jsonSchemaDir);
+    const entityDirectoryPathEntries = Object.entries(entityDirectoryPaths);
+    const structuralIntegrityResults = await Promise.all(entityDirectoryPathEntries.map(mapSecondAsync(async (path, typeName) => {
+        const files = await getFiles(path);
+        return validateStructuralIntegrityOfFiles(validator, configMap[typeName], validateFileName, files);
+    })));
+    if (checkIntegrity) {
+        const identityIntegrityValidators = Object.fromEntries(structuralIntegrityResults.map(mapSecond(results => {
+            const idCount = results.reduce((mp, [_, result]) => isOk(result) ? mp.set(result.value[0], (mp.get(result.value[0]) ?? 0) + 1) : mp, new Map());
+            return {
+                isUnique: (id) => (idCount.get(id) ?? 0) === 1,
+                exists: (id) => idCount.has(id),
+            };
+        })));
+        return structuralIntegrityResults.map(mapSecond((results, typeName) => validateSemanticAndReferencialIntegrityOfFiles({ identity: identityIntegrityValidators }, configMap[typeName], results)));
+    }
+    else {
+        return structuralIntegrityResults;
+    }
+};

package/lib/validation/schema.d.ts

@@ -1,22 +1,6 @@
-import Ajv, { DefinedError } from "ajv";
-export declare type FileNameError = {
-    keyword: "filename";
-    instancePath: string;
-    message: string;
-};
-export declare type TypeValidationResult<T> = {
-    tag: "Ok";
-    value: T;
-} | {
-    tag: "Error";
-    errors: TypeValidationResultErrors;
-};
-export declare type TypeValidationResultErrors = {
-    fileNameError?: FileNameError;
-    schemaErrors: DefinedError[];
-};
-export declare type TypeValidator<T> = (validator: Ajv, data: unknown, filePath: string) => TypeValidationResult<T>;
-export declare type TypeValidatorOptions = {
-    ignoreFileNamePattern?: boolean;
-};
-export declare const validateSchemaCreator: <T>(importMetaUrl: string, { ignoreFileNamePattern }?: TypeValidatorOptions) => TypeValidator<T>;
+import AjvModule from "ajv";
+import Ajv2019Module from "ajv/dist/2019.js";
+import Ajv2020Module from "ajv/dist/2020.js";
+import { JsonSchemaSpec } from "optolith-tsjsonschemamd/renderers";
+import "../helpers/array.js";
+export declare const getPreparedSchemaValidator: (jsonSchemaSpec: JsonSchemaSpec, validatorOptions: AjvModule.Options | undefined, jsonSchemaDir: string) => Promise<Ajv2019Module.default | Ajv2020Module.default>;

package/lib/validation/schema.js

@@ -1,34 +1,33 @@
-import { basename, dirname, extname, join, relative, sep } from "path";
-import { fileURLToPath } from "url";
-import { libDir } from "../../config/directories.js";
-const baseNamePattern = /^(?:0|[1-9][0-9]*)_(?:[A-Z][a-zA-Z]*|[1-9][0-9]*)(?:-(?:[a-zA-Z]+|[1-9][0-9]*))*\.yml$/;
-const fileNameError = (fileName) => ({
-    keyword: "filename",
-    instancePath: "",
-    message: `the file name "${fileName}" does not match the pattern ${baseNamePattern.source}`
-});
-const changeFileExtension = (path, ext) => join(dirname(path), basename(path, extname(path)) + ext);
-const schemaIdFromSourcePath = (sourcePath) => {
-    const relativePathOfType = relative(libDir, fileURLToPath(sourcePath));
-    const relativePathOfSchema = changeFileExtension(relativePathOfType, ".schema.json");
-    return "/" + relativePathOfSchema.split(sep).join("/");
+import addFormatsModule from "ajv-formats";
+import Ajv2019Module from "ajv/dist/2019.js";
+import Ajv2020Module from "ajv/dist/2020.js";
+import { JsonSchemaSpec } from "optolith-tsjsonschemamd/renderers";
+import "../helpers/array.js";
+import { isHiddenFileName, readDirectoryRec, readJsonFile } from "../helpers/io.js";
+import { assertExhaustive } from "../helpers/typeSafety.js";
+const Ajv2019 = Ajv2019Module.default;
+const Ajv2020 = Ajv2020Module.default;
+const addFormats = addFormatsModule.default;
+const createSchemaValidator = (jsonSchemaSpec, validatorOptions = {}) => {
+    switch (jsonSchemaSpec) {
+        case JsonSchemaSpec.Draft_07:
+        case JsonSchemaSpec.Draft_2019_09:
+            return new Ajv2019(validatorOptions);
+        case JsonSchemaSpec.Draft_2020_12:
+            return new Ajv2020(validatorOptions);
+        default:
+            assertExhaustive(jsonSchemaSpec);
+    }
 };
-export const validateSchemaCreator = (importMetaUrl, { ignoreFileNamePattern = false } = {}) => {
-    const schemaId = schemaIdFromSourcePath(importMetaUrl);
-    return (validator, data, filePath) => {
-        const fileName = basename(filePath);
-        const correctFileName = ignoreFileNamePattern || baseNamePattern.test(fileName);
-        if (validator.validate(schemaId, data) && correctFileName) {
-            return { tag: "Ok", value: data };
-        }
-        else {
-            return {
-                tag: "Error",
-                errors: {
-                    fileNameError: correctFileName ? undefined : fileNameError(fileName),
-                    schemaErrors: validator.errors ?? [],
-                }
-            };
-        }
-    };
+const registerAllJsonSchemaDocuments = async (jsonSchemaDir, validator) => {
+    for await (const jsonSchemaPath of readDirectoryRec(jsonSchemaDir, isHiddenFileName)) {
+        const jsonSchema = await readJsonFile(jsonSchemaPath);
+        validator.addSchema(jsonSchema);
+    }
+};
+export const getPreparedSchemaValidator = async (jsonSchemaSpec, validatorOptions = {}, jsonSchemaDir) => {
+    const validator = createSchemaValidator(jsonSchemaSpec, validatorOptions);
+    await registerAllJsonSchemaDocuments(jsonSchemaDir, validator);
+    addFormats(validator);
+    return validator;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "optolith-database-schema",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "Definitions and utilities for the flat-file database of Optolith, a character creation tool for the Pen and Paper RPG “The Dark Eye 5”, and its external integrations into other software.",
   "keywords": [
     "tde",
@@ -9,7 +9,12 @@
     "dasschwarzeauge"
   ],
   "main": "./lib/main.js",
-  "types": "./lib/main.d.ts",
+  "exports": {
+    ".": "./lib/main.js",
+    "./errors": "./lib/errors.js",
+    "./config": "./lib/config.js",
+    "./types/*": "./lib/types/*.js"
+  },
   "scripts": {
     "build:ts": "tsc",
     "watch:ts": "tsc -w",
@@ -22,15 +27,15 @@
   "author": "Lukas Obermann",
   "license": "MPL-2.0",
   "dependencies": {
-    "ajv": "^8.11.0",
+    "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
-    "yaml": "^2.1.1"
+    "yaml": "^2.2.2"
   },
   "devDependencies": {
-    "@types/node": "^18.0.0",
+    "@types/node": "^20.2.3",
     "optolith-tsjsonschemamd": "^0.5.20",
     "standard-version": "^9.5.0",
-    "typescript": "^4.7.4"
+    "typescript": "^5.0.4"
   },
   "repository": "github:elyukai/optolith-database-schema",
   "bugs": {

package/schema/Locale.schema.json

@@ -1,15 +1,8 @@
 {
   "$schema": "https://json-schema.org/draft/2019-09/schema",
   "$id": "/Locale.schema.json",
-  "$ref": "#/$defs/Locales",
+  "$ref": "#/$defs/Locale",
   "$defs": {
-    "Locales": {
-      "title": "Supported locales",
-      "type": "array",
-      "items": {
-        "$ref": "#/$defs/Locale"
-      }
-    },
     "Locale": {
       "title": "Supported locale",
       "type": "object",

package/config/directories.d.ts

@@ -1,4 +0,0 @@
-export const sourceDir: string
-export const libDir: string
-export const jsonSchemaDir: string
-export const markdownDir: string

package/config/directories.js

@@ -1,14 +0,0 @@
-// @ts-check
-
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
-
-// @ts-ignore
-const root = join(dirname(fileURLToPath(import.meta.url)), "..")
-
-const typesDir = main => join(root, main, "types")
-
-export const sourceDir = typesDir("src")
-export const libDir = typesDir("lib")
-export const jsonSchemaDir = join(root, "schema")
-export const markdownDir = join(root, "docs", "reference")

package/lib/validation/integrity.d.ts

@@ -1,16 +0,0 @@
-export interface ReferencialIntegrityValidators {
-    checkLocaleId: (localeId: string) => boolean;
-}
-export declare const getReferencialIntegrityErrors: <T extends string | number>(ids: T[], check: (id: T) => boolean) => T[];
-export declare const getReferencialIntegrityErrorsWith: <T, U extends string | number>(elements: T[], transform: (element: T) => U, check: (id: U) => boolean) => T[];
-interface Translatable<T> {
-    /**
-     * All translations for the entry, identified by IETF language tag (BCP47).
-     * @minProperties 1
-     */
-    translations: {
-        [localeId: string]: T;
-    };
-}
-export declare const getReferencialIntegrityErrorsForTranslatable: <T>(translatable: Translatable<T>, checkLocaleId: (id: string) => boolean) => string[];
-export {};

package/lib/validation/integrity.js

@@ -1,3 +0,0 @@
-export const getReferencialIntegrityErrors = (ids, check) => ids.filter(id => !check(id));
-export const getReferencialIntegrityErrorsWith = (elements, transform, check) => elements.filter(element => !check(transform(element)));
-export const getReferencialIntegrityErrorsForTranslatable = (translatable, checkLocaleId) => getReferencialIntegrityErrors(Object.keys(translatable.translations), checkLocaleId);