optolith-database-schema 0.10.1 → 0.11.1

package/lib/errors.js

@@ -0,0 +1,33 @@
+import { filterNullable } from "./helpers/array.js";
+import { collator } from "./helpers/i18n.js";
+/**
+ * Pretty-prints an error map.
+ * @param errorsByFile A map from file paths to the errors that occurred in
+ * them.
+ * @param printOptions Configuration options for the printer.
+ * @returns The pretty-printed error map.
+ */
+export const printErrors = (errorsByFile, printOptions = {}) => {
+    const { verbose = false } = printOptions;
+    return Object.entries(errorsByFile)
+        .sort(([filePathA], [filePathB]) => collator.compare(filePathA, filePathB))
+        .flatMap(verbose
+        ? ([filePath, errors]) => filterNullable(errors.map(printVerboseError(filePath)))
+        : ([filePath, errors]) => [
+            ...(errors
+                .filter((error) => error.keyword === "integrity" || error.keyword === "filename")
+                .map(printVerboseError(filePath))),
+            ...(errors.some(error => error.keyword !== "integrity" && error.keyword !== "filename")
+                ? [errorMessageBlock([filePath], "has schema errors")]
+                : []),
+        ])
+        .join("\n\n");
+};
+const printVerboseError = (filePath) => (error) => {
+    const pathSegments = [filePath, ...error.instancePath.split("/").slice(1)];
+    return errorMessageBlock(pathSegments, error.message ?? "");
+};
+const errorMessageBlock = (path, message) => [
+    ...path.map((segment, i) => `${" ".repeat(i * 2)}in "${segment}":`),
+    `${" ".repeat(path.length * 2)}${message}`
+].join("\n");

package/lib/helpers/array.d.ts

@@ -0,0 +1,14 @@
+declare global {
+    interface Array<T> {
+        /**
+         * Returns a `Promise` that resolves when all `Promise`s in the array
+         * resolve and rejects when any of the `Promise`s in the array rejects.
+         */
+        promiseAll<T>(this: Promise<T>[]): Promise<T[]>;
+        /**
+         * Returns an object from an array of key-value pairs.
+         */
+        objectFromEntries<K extends string, T>(this: [key: K, value: T][]): Record<K, T>;
+    }
+}
+export declare const filterNullable: <T>(arr: T[]) => NonNullable<T>[];

package/lib/helpers/array.js

@@ -0,0 +1,15 @@
+Object.defineProperty(Array.prototype, "promiseAll", {
+    configurable: true,
+    writable: true,
+    value: function promiseAll() {
+        return Promise.all(this);
+    }
+});
+Object.defineProperty(Array.prototype, "objectFromEntries", {
+    configurable: true,
+    writable: true,
+    value: function objectFromEntries() {
+        return Object.fromEntries(this);
+    }
+});
+export const filterNullable = (arr) => arr.filter((x) => x != null);

package/lib/helpers/i18n.d.ts

@@ -0,0 +1 @@
+export declare const collator: Intl.Collator;

package/lib/helpers/i18n.js

@@ -0,0 +1 @@
+export const collator = Intl.Collator(undefined, { numeric: true });

package/lib/helpers/io.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Recursively reads all files in a directory and its subdirectories.
+ * @param dirPath The path to the directory to read.
+ */
+export declare function readDirectoryRec(dirPath: string, filterName?: (entryName: string) => boolean): AsyncGenerator<string>;
+/**
+ * Reads a JSON file and parses its content.
+ * @param filePath The path to the JSON file.
+ * @returns The parsed JSON content.
+ */
+export declare const readJsonFile: (filePath: string) => Promise<unknown>;
+/**
+ * Reads a YAML file and parses its content.
+ * @param filePath The path to the YAML file.
+ * @returns The parsed YAML content.
+ */
+export declare const readYamlFile: (filePath: string) => Promise<unknown>;
+/**
+ * Changes the extension of a file path.
+ * @param path The path to the file.
+ * @param ext The new extension to use.
+ * @returns
+ */
+export declare const changeFileExtension: (path: string, ext: string) => string;
+/**
+ * Checks if a file name represents a hidden file.
+ * @param name The file name to check.
+ */
+export declare const isHiddenFileName: (name: string) => boolean;

package/lib/helpers/io.js

@@ -0,0 +1,51 @@
+import { readFile, readdir } from "fs/promises";
+import { basename, dirname, extname, join } from "path";
+import YAML from "yaml";
+/**
+ * Recursively reads all files in a directory and its subdirectories.
+ * @param dirPath The path to the directory to read.
+ */
+export async function* readDirectoryRec(dirPath, filterName = () => true) {
+    const dirEntries = await readdir(dirPath, { withFileTypes: true });
+    for (const dirEntry of dirEntries) {
+        if (filterName(dirEntry.name)) {
+            const dirEntryPath = join(dirPath, dirEntry.name);
+            if (dirEntry.isDirectory()) {
+                yield* readDirectoryRec(dirEntryPath);
+            }
+            else {
+                yield dirEntryPath;
+            }
+        }
+    }
+}
+/**
+ * Reads a JSON file and parses its content.
+ * @param filePath The path to the JSON file.
+ * @returns The parsed JSON content.
+ */
+export const readJsonFile = async (filePath) => {
+    const fileContent = await readFile(filePath, "utf-8");
+    return JSON.parse(fileContent);
+};
+/**
+ * Reads a YAML file and parses its content.
+ * @param filePath The path to the YAML file.
+ * @returns The parsed YAML content.
+ */
+export const readYamlFile = async (filePath) => {
+    const fileContent = await readFile(filePath, "utf-8");
+    return YAML.parse(fileContent);
+};
+/**
+ * Changes the extension of a file path.
+ * @param path The path to the file.
+ * @param ext The new extension to use.
+ * @returns
+ */
+export const changeFileExtension = (path, ext) => join(dirname(path), basename(path, extname(path)) + ext);
+/**
+ * Checks if a file name represents a hidden file.
+ * @param name The file name to check.
+ */
+export const isHiddenFileName = (name) => !name.startsWith(".");

package/lib/helpers/objectPath.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A path segment descriptor is either a key or an index.
+ */
+export type PathSegmentDescriptor = {
+    k: string;
+} | {
+    i: number;
+};
+/**
+ * A path descriptor is a list of path segment descriptors.
+ */
+export type PathDescriptor = PathSegmentDescriptor[];
+export declare const printPathDescriptor: (pathDescriptor: PathDescriptor) => string;

package/lib/helpers/objectPath.js

@@ -0,0 +1,3 @@
+export const printPathDescriptor = (pathDescriptor) => pathDescriptor
+    .map(segment => "k" in segment ? segment.k : segment.i)
+    .join("/");

package/lib/helpers/pair.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Map the second element of a pair using a function that receives both
+ * elements.
+ */
+export declare const mapSecond: <A, B, C>(f: (second: B, first: A) => C) => (pair: [A, B]) => [A, C];
+/**
+ * Map the second element of a pair using a function that receives both
+ * elements and returns a `Promise`.
+ */
+export declare const mapSecondAsync: <A, B, C>(f: (second: B, first: A) => Promise<C>) => (pair: [A, B]) => Promise<[A, C]>;
+/**
+ * Map a value using a function into the second value of a pair with the
+ * original value.
+ */
+export declare const mapToSecond: <A, B>(f: (value: A) => B) => (value: A) => [A, B];
+/**
+ * Map a value using a function that returns a `Promise` into the second value
+ * of a pair with the original value.
+ */
+export declare const mapToSecondAsync: <A, B>(f: (value: A) => Promise<B>) => (value: A) => Promise<[A, B]>;

package/lib/helpers/pair.js

@@ -0,0 +1,20 @@
+/**
+ * Map the second element of a pair using a function that receives both
+ * elements.
+ */
+export const mapSecond = (f) => (pair) => [pair[0], f(pair[1], pair[0])];
+/**
+ * Map the second element of a pair using a function that receives both
+ * elements and returns a `Promise`.
+ */
+export const mapSecondAsync = (f) => async (pair) => [pair[0], await f(pair[1], pair[0])];
+/**
+ * Map a value using a function into the second value of a pair with the
+ * original value.
+ */
+export const mapToSecond = (f) => (value) => [value, f(value)];
+/**
+ * Map a value using a function that returns a `Promise` into the second value
+ * of a pair with the original value.
+ */
+export const mapToSecondAsync = (f) => async (value) => [value, await f(value)];

package/lib/helpers/result.d.ts

@@ -0,0 +1,57 @@
+/**
+ * A result is either a value or an error.
+ */
+export type Result<T, E> = Ok<T> | Error<E>;
+/**
+ * A result that contains a value.
+ */
+export type Ok<T> = {
+    readonly tag: "Ok";
+    readonly value: T;
+};
+/**
+ * A result that contains an error.
+ */
+export type Error<E> = {
+    readonly tag: "Error";
+    readonly error: E;
+};
+/**
+ * Creates a result that contains a value.
+ */
+export declare const ok: <T>(value: T) => Result<T, never>;
+/**
+ * Checks if a result contains a value.
+ */
+export declare const isOk: <T, E>(result: Result<T, E>) => result is Ok<T>;
+/**
+ * Creates a result that contains an error.
+ */
+export declare const error: <E>(error: E) => Result<never, E>;
+/**
+ * Checks if a result contains an error.
+ */
+export declare const isError: <T, E>(result: Result<T, E>) => result is Error<E>;
+/**
+ * Reduces a result to a value of a common type.
+ */
+export declare const reduce: <T, E, R>(result: Result<T, E>, fok: (value: T) => R, ferror: (error: E) => R) => R;
+/**
+ * Maps the value of a result to a new value.
+ */
+export declare const map: <T, U, E>(result: Result<T, E>, f: (value: T) => U) => Result<U, E>;
+/**
+ * Maps an error to a new error.
+ */
+export declare const mapError: <T, E, F>(result: Result<T, E>, f: (value: E) => F) => Result<T, F>;
+export declare const combine: <T1, T2, TR, E1, E2, ER>(result1: Result<T1, E1>, result2: Result<T2, E2>, fok: (value1: T1, value2: T2) => TR, ferror: (error1: E1, error2: E2) => ER) => Result<TR, E1 | E2 | ER>;
+export declare const Result: Readonly<{
+    ok: <T>(value: T) => Result<T, never>;
+    isOk: <T_1, E>(result: Result<T_1, E>) => result is Ok<T_1>;
+    error: <E_1>(error: E_1) => Result<never, E_1>;
+    isError: <T_2, E_2>(result: Result<T_2, E_2>) => result is Error<E_2>;
+    reduce: <T_3, E_3, R>(result: Result<T_3, E_3>, fok: (value: T_3) => R, ferror: (error: E_3) => R) => R;
+    map: <T_4, U, E_4>(result: Result<T_4, E_4>, f: (value: T_4) => U) => Result<U, E_4>;
+    mapError: <T_5, E_5, F>(result: Result<T_5, E_5>, f: (value: E_5) => F) => Result<T_5, F>;
+    combine: <T1, T2, TR, E1, E2, ER>(result1: Result<T1, E1>, result2: Result<T2, E2>, fok: (value1: T1, value2: T2) => TR, ferror: (error1: E1, error2: E2) => ER) => Result<TR, E1 | E2 | ER>;
+}>;

package/lib/helpers/result.js

@@ -0,0 +1,45 @@
+/**
+ * Creates a result that contains a value.
+ */
+export const ok = (value) => ({ tag: "Ok", value });
+/**
+ * Checks if a result contains a value.
+ */
+export const isOk = (result) => result.tag === "Ok";
+/**
+ * Creates a result that contains an error.
+ */
+export const error = (error) => ({ tag: "Error", error });
+/**
+ * Checks if a result contains an error.
+ */
+export const isError = (result) => result.tag === "Error";
+/**
+ * Reduces a result to a value of a common type.
+ */
+export const reduce = (result, fok, ferror) => isOk(result) ? fok(result.value) : ferror(result.error);
+/**
+ * Maps the value of a result to a new value.
+ */
+export const map = (result, f) => isOk(result) ? ok(f(result.value)) : result;
+/**
+ * Maps an error to a new error.
+ */
+export const mapError = (result, f) => isError(result) ? error(f(result.error)) : result;
+export const combine = (result1, result2, fok, ferror) => isOk(result1)
+    ? isOk(result2)
+        ? ok(fok(result1.value, result2.value))
+        : result2
+    : isOk(result2)
+        ? result1
+        : error(ferror(result1.error, result2.error));
+export const Result = Object.freeze({
+    ok,
+    isOk,
+    error,
+    isError,
+    reduce,
+    map,
+    mapError,
+    combine,
+});

package/lib/helpers/typeSafety.d.ts

@@ -0,0 +1,6 @@
+/**
+ * This function is used to make sure that the `switch` is exhaustive. Place it
+ * in the `default` case of the `switch`.
+ * @param x The value that is used in the `switch`.
+ */
+export declare function assertExhaustive(x: never): never;

package/lib/helpers/typeSafety.js

@@ -0,0 +1,8 @@
+/**
+ * This function is used to make sure that the `switch` is exhaustive. Place it
+ * in the `default` case of the `switch`.
+ * @param x The value that is used in the `switch`.
+ */
+export function assertExhaustive(x) {
+    throw new Error("The switch is not exhaustive.");
+}

package/lib/main.d.ts

@@ -1,20 +1,55 @@
 import { TypeMap } from "./config.js";
-import { TypeValidationResultErrors } from "./validation/schema.js";
-type Result = {
-    tag: "Ok";
-    value: {
-        [K in keyof TypeMap]: TypeMap[K][];
-    };
-} | {
-    tag: "Error";
-    errors: Record<string, TypeValidationResultErrors>;
+import "./helpers/array.js";
+import { Result } from "./helpers/result.js";
+import { TypeId } from "./typeConfig.js";
+import { IntegrityError } from "./validation/builders/integrity.js";
+import { FileNameError } from "./validation/builders/naming.js";
+import { SchemaError } from "./validation/builders/schema.js";
+/**
+ * Options for validating data files.
+ */
+export type ValidationOptions = {
+    /**
+     * Whether to check the integrity of the data files. This includes checking
+     * for referencial integrity (i.e. whether all referenced entities exist).
+     * @default false
+     */
+    checkIntegrity?: boolean;
 };
+/**
+ * A type validation may fail because of the data not matching the schema, the
+ * file name not matching a pattern, or integrity issues.
+ */
+export type TypeValidationError = IntegrityError | FileNameError | SchemaError;
+/**
+ * A map of all valid entries, grouped by entity type.
+ */
+export type ValidResults = {
+    [K in keyof TypeMap]: [id: TypeId<keyof TypeMap>, data: TypeMap[keyof TypeMap]][];
+};
+/**
+ * A dictionary of entity types and their data’s associated locations.
+ */
 export type EntityDirectoryPaths = {
     [K in keyof TypeMap]: string;
 };
-export declare const validate: (entityDirPaths: EntityDirectoryPaths, checkIntegrity: boolean) => Promise<Result>;
-export declare const printErrors: (errorsByFile: Record<string, TypeValidationResultErrors>, printOptions?: PrintOptions) => string;
-export type PrintOptions = {
-    verbose?: boolean;
-};
+type StrictResults = Result<ValidResults, Record<string, TypeValidationError[]>>;
+/**
+ * If the database has no validation issues, returns the whole data set as a map
+ * of entity types to their data. If there are any errors, only the errors will
+ * be returned instead.
+ * @param entityDirPaths THe paths to the directories containing the data to be
+ * validated.
+ * @param options Configuration options for the validation.
+ * @returns Either the whole data set or the errors.
+ */
+export declare const getAllValidDataOrErrors: (entityDirPaths: EntityDirectoryPaths, options?: ValidationOptions) => Promise<StrictResults>;
+/**
+ * Returns all valid data as a map of entity types to their data.
+ * @param entityDirPaths THe paths to the directories containing the data to be
+ * validated.
+ * @param options Configuration options for the validation.
+ * @returns The valid data.
+ */
+export declare const getAllValidData: (entityDirPaths: EntityDirectoryPaths, options?: ValidationOptions) => Promise<ValidResults>;
 export {};

package/lib/main.js

@@ -1,142 +1,55 @@
-import addFormats from "ajv-formats";
-import Ajv2019 from "ajv/dist/2019.js";
-import Ajv2020 from "ajv/dist/2020.js";
-import { lstat, readdir, readFile } from "fs/promises";
-import { join } from "path";
-import YAML from "yaml";
-import { jsonSchemaDir } from "../config/directories.js";
-import { typeValidatorMap } from "./config.js";
-const readdirRecursive = async (dirPath) => {
-    const directoryEntries = await readdir(dirPath, { withFileTypes: true });
-    const flattenedRecursivePaths = await Promise.all(directoryEntries
-        .filter(dirEntry => !dirEntry.name.startsWith("."))
-        .map(async (dirEntry) => {
-        const absoluteEntryPath = join(dirPath, dirEntry.name);
-        if (dirEntry.isDirectory()) {
-            return (await readdirRecursive(absoluteEntryPath));
-        }
-        else if (dirEntry.isFile()) {
-            return [absoluteEntryPath];
-        }
-        else {
-            return [];
-        }
-    }));
-    return flattenedRecursivePaths.flat();
-};
-const registerAllJsonSchemaDocuments = async (validatorOptions) => {
-    const readFileAsUtf8 = (path) => readFile(path, "utf-8");
-    const readFilesAsUtf8 = (paths) => Promise.all(paths.map(readFileAsUtf8));
-    const parseJson = (json) => JSON.parse(json);
-    const schemes = (await readFilesAsUtf8(await readdirRecursive(jsonSchemaDir))).map(parseJson);
-    const META_SCHEMA_ID_2020_12 = "https://json-schema.org/draft/2020-12/schema";
-    const validator = schemes[0]?.$schema === META_SCHEMA_ID_2020_12
-        ? new Ajv2020(validatorOptions)
-        : new Ajv2019(validatorOptions);
-    const registerSchemaInValidator = (jsonSchema) => { validator.addSchema(jsonSchema); };
-    schemes.forEach(registerSchemaInValidator);
-    return validator;
-};
-const collator = Intl.Collator(undefined, { numeric: true });
-const readDataFileAssocsFromDirectory = async (dirPath) => {
-    const filenames = await readdir(dirPath);
-    filenames.sort(collator.compare);
-    return await Promise.all(filenames
-        .filter(fileName => !fileName.startsWith("."))
-        .map(async (fileName) => {
-        const filePath = join(dirPath, fileName);
-        try {
-            const fileContent = YAML.parse(await readFile(join(dirPath, fileName), "utf-8"));
-            return [filePath, fileContent];
-        }
-        catch (error) {
-            if (error instanceof Error) {
-                error.message = `in "${filePath}":\n  ${error.message}`;
-            }
-            return [filePath, null];
-        }
-    }));
-};
-const validateAllFromType = async (validator, typeName, path) => {
-    const isFile = (await lstat(path)).isFile();
-    const typeValidator = typeValidatorMap[typeName];
-    if (isFile) {
-        return { [path]: typeValidator(validator, await readFile(path, "utf-8"), path) };
-    }
-    else {
-        const dataFiles = await readDataFileAssocsFromDirectory(path);
-        return Object.fromEntries(dataFiles.map(([filePath, fileContent]) => [filePath, typeValidator(validator, fileContent, filePath)]));
-    }
-};
-const rawResultMapToResult = (rawResultMap) => Object.entries(rawResultMap).reduce((result, [typeName, typeResults]) => Object.entries(typeResults).reduce((outerResult, [filePath, fileResult]) => {
-    if (outerResult.tag === "Ok" && fileResult.tag === "Ok") {
-        return {
-            tag: "Ok",
-            value: {
-                ...outerResult.value,
-                [typeName]: [...(outerResult.value[typeName] ?? []), fileResult.value]
-            }
-        };
+import "./helpers/array.js";
+import { mapSecond } from "./helpers/pair.js";
+import { Result, error, isError, isOk, ok } from "./helpers/result.js";
+import { getRawValidationResults } from "./validation/raw.js";
+const rawResultMapToResult = (rawResultMap) => rawResultMap.reduce((result, [typeName, typeResults]) => typeResults.reduce((outerResult, [filePath, fileResult]) => {
+    if (isOk(outerResult) && isOk(fileResult)) {
+        return ok({
+            ...outerResult.value,
+            [typeName]: [...(outerResult.value[typeName] ?? []), fileResult.value]
+        });
     }
-    else if (outerResult.tag === "Ok" && fileResult.tag === "Error") {
-        return {
-            tag: "Error",
-            errors: {
-                [filePath]: fileResult.errors
-            }
-        };
+    else if (isOk(outerResult) && isError(fileResult)) {
+        return error({
+            [filePath]: fileResult.error
+        });
     }
-    else if (outerResult.tag === "Error" && fileResult.tag === "Error") {
-        return {
-            tag: "Error",
-            errors: {
-                ...outerResult.errors,
-                [filePath]: fileResult.errors
-            }
-        };
+    else if (isError(outerResult) && isError(fileResult)) {
+        return error({
+            ...outerResult.error,
+            [filePath]: fileResult.error
+        });
     }
     else {
         return outerResult;
     }
-}, result), ({
-    tag: "Ok",
-    value: {}
-}));
-export const validate = async (entityDirPaths, checkIntegrity) => {
-    const validator = await registerAllJsonSchemaDocuments({});
-    addFormats(validator);
-    const rawResultMap = Object.fromEntries((await Promise.all(Object.entries(entityDirPaths)
-        .map(async ([typeName, path]) => [
-        typeName,
-        await validateAllFromType(validator, typeName, path)
-    ]))));
+}, result), ok({}));
+const filterResultMapByValidData = (rawResultMap) => rawResultMap
+    .map(mapSecond((typeResults) => typeResults
+    .filter((typeResult) => Result.isOk(typeResult[1]))
+    .map(fileResult => fileResult[1].value)))
+    .objectFromEntries();
+/**
+ * If the database has no validation issues, returns the whole data set as a map
+ * of entity types to their data. If there are any errors, only the errors will
+ * be returned instead.
+ * @param entityDirPaths THe paths to the directories containing the data to be
+ * validated.
+ * @param options Configuration options for the validation.
+ * @returns Either the whole data set or the errors.
+ */
+export const getAllValidDataOrErrors = async (entityDirPaths, options = {}) => {
+    const rawResultMap = await getRawValidationResults(entityDirPaths, options);
     return rawResultMapToResult(rawResultMap);
 };
-export const printErrors = (errorsByFile, printOptions = {}) => {
-    const { verbose = false } = printOptions;
-    return Object.entries(errorsByFile)
-        .sort(([filePathA], [filePathB]) => collator.compare(filePathA, filePathB))
-        .flatMap(([filePath, errors]) => {
-        if (verbose) {
-            return filterNullable([
-                errors.fileNameError ? errorMessageBlock([filePath], errors.fileNameError.message) : undefined,
-                ...errors.schemaErrors.map(error => {
-                    const pathSegments = [filePath, ...error.instancePath.split("/").slice(1)];
-                    return errorMessageBlock(pathSegments, error.message ?? "");
-                })
-            ]);
-        }
-        else {
-            return filterNullable([
-                errors.fileNameError ? errorMessageBlock([filePath], errors.fileNameError.message) : undefined,
-                errors.schemaErrors.length > 0 ? errorMessageBlock([filePath], "does not match schema") : undefined
-            ]);
-        }
-    })
-        .join("\n\n");
+/**
+ * Returns all valid data as a map of entity types to their data.
+ * @param entityDirPaths THe paths to the directories containing the data to be
+ * validated.
+ * @param options Configuration options for the validation.
+ * @returns The valid data.
+ */
+export const getAllValidData = async (entityDirPaths, options = {}) => {
+    const rawResultMap = await getRawValidationResults(entityDirPaths, options);
+    return filterResultMapByValidData(rawResultMap);
 };
-const errorMessageBlock = (path, message) => [
-    ...path.map((segment, i) => `${" ".repeat(i * 2)}in "${segment}":`),
-    `${" ".repeat(path.length * 2)}${message}`
-].join("\n");
-const filterNullable = (arr) => arr.filter((x) => x != null);

package/lib/typeConfig.d.ts

@@ -0,0 +1,10 @@
+import { TypeMap, configMap } from "./config.js";
+import { IntegrityValidator } from "./validation/builders/integrity.js";
+import { SchemaValidator } from "./validation/builders/schema.js";
+export type TypeId<K extends keyof TypeMap> = ReturnType<(typeof configMap)[K]["id"]>;
+export type TypeConfig<T, ID extends string | number = number> = {
+    name: string;
+    id: (data: T, filepath: string) => ID;
+    integrityValidator: IntegrityValidator<T>;
+    schemaValidator: SchemaValidator<T>;
+};

package/lib/typeConfig.js

@@ -0,0 +1 @@
+export {};

package/lib/types/Advantage.d.ts

@@ -1,6 +1,7 @@
 /**
  * @main Advantage
  */
+import { TypeConfig } from "../typeConfig.js";
 import * as Activatable from "./_Activatable.js";
 import { LocaleMap } from "./_LocaleMap.js";
 import { AdvantageDisadvantagePrerequisites } from "./_Prerequisite.js";
@@ -59,4 +60,4 @@ export type AdvantageTranslation = {
     ap_value_append?: Activatable.AdventurePointsValueAppend;
     errata?: Errata;
 };
-export declare const validateSchema: import("../validation/schema.js").TypeValidator<Advantage>;
+export declare const config: TypeConfig<Advantage>;

package/lib/types/Advantage.js

@@ -1,5 +1,12 @@
 /**
  * @main Advantage
  */
-import { validateSchemaCreator } from "../validation/schema.js";
-export const validateSchema = validateSchemaCreator(import.meta.url);
+import { todo } from "../validation/builders/integrity.js";
+import { createSchemaValidator } from "../validation/builders/schema.js";
+import { getFIlenamePrefixAsNumericId } from "../validation/filename.js";
+export const config = {
+    name: "Advantage",
+    id: getFIlenamePrefixAsNumericId,
+    integrityValidator: todo("Advantage"),
+    schemaValidator: createSchemaValidator(import.meta.url),
+};