tsondb 0.20.7 → 0.20.8

package/dist/src/node/bin/tsondb.js

@@ -48,6 +48,12 @@ const passedArguments = parseArguments({
         },
         format: {
             name: "format",
+            options: {
+                check: {
+                    name: "check",
+                    type: Boolean,
+                },
+            },
         },
         name: {
             name: "name",
@@ -144,9 +150,15 @@ else {
             break;
         }
         case "format": {
-            debug(`running command: format`);
             const db = await createDB(config, config.validationOptions, true);
-            await db.format();
+            if (passedArguments.command.options?.check === true) {
+                debug(`running command: format --check`);
+                await db.checkFormat();
+            }
+            else {
+                debug(`running command: format`);
+                await db.format();
+            }
             break;
         }
         case "name": {

package/dist/src/node/index.d.ts

@@ -64,6 +64,26 @@ export interface ValidationOptions {
      * If set, translations will be validated according to the provided options.
      */
     checkTranslations?: TranslationValidationOptions;
+    /**
+     * Special options for validating Markdown content in the database.
+     */
+    markdown?: Partial<MarkdownValidationOptions>;
+}
+/**
+ * Special options for validating Markdown content in the database.
+ */
+export interface MarkdownValidationOptions {
+    /**
+     * Checks for the existence of referenced entities and possibly instances in attributed strings. If the attribute names are not specified via an object, the default attribute names `entity` and `instance` will be used.
+     */
+    checkInstanceReferencesInAttributedStrings?: boolean | {
+        entityKey: string;
+        instanceKey: string;
+    };
+    /**
+     * If set, keys in attributed strings will be checked agains the provided list of keys or regular expression. Keys for `checkInstanceReferencesInAttributedStrings` are included automatically and do not need to be specified again.
+     */
+    checkAttributedStringKeys?: string[] | RegExp;
 }
 /**
  * Options for validating translations in the database.
@@ -114,6 +134,10 @@ export declare class TSONDB<T extends DefaultTSONDBTypes = DefaultTSONDBTypes> {
      * Formats the data on disk according to the current in-memory representation.
      */
     format(): Promise<void>;
+    /**
+     * Checks if the data on disk is formatted according to the current in-memory representation.
+     */
+    checkFormat(): Promise<void>;
     /**
      * Reloads the data from disk into memory.
      */

package/dist/src/node/index.js

@@ -15,14 +15,14 @@ import {} from "./schema/dsl/index.js";
 import {} from "./schema/generatedTypeHelpers.js";
 import { isEntityDeclWithParentReference } from "./schema/guards.js";
 import { serializeNode } from "./schema/treeOperations/serialization.js";
-import { createReferenceValidator, validateDeclReferentialIntegrity, validateDeclStructuralIntegrity, } from "./schema/treeOperations/validation.js";
+import { createEntityNameValidator, createReferenceValidator, validateDeclReferentialIntegrity, validateDeclStructuralIntegrity, } from "./schema/treeOperations/validation.js";
 import { Transaction } from "./transaction.js";
 import { checkCustomConstraintsForAllEntities } from "./utils/customConstraints.js";
 import { DatabaseInMemory } from "./utils/databaseInMemory.js";
 import { applyStepsToDisk } from "./utils/databaseOnDisk.js";
 import { getAllInstanceOverviewsByEntityName, getDisplayNameFromEntityInstance, getInstanceOverview, getInstanceOverviewsByEntityName, } from "./utils/displayName.js";
 import { countError, countErrors, getErrorMessageForDisplay, HTTPError, wrapErrorsIfAny, } from "./utils/error.js";
-import { getFileNameForId, writeInstance } from "./utils/files.js";
+import { formatInstance, getFileNameForId, readInstance, writeInstance } from "./utils/files.js";
 import { attachGitStatusToDatabaseInMemory } from "./utils/git.js";
 import { getReferencesToInstances, isReferencedByOtherInstances, } from "./utils/references.js";
 import { checkUniqueConstraintsForAllEntities } from "./utils/unique.js";
@@ -210,11 +210,12 @@ export class TSONDB {
             if (!skipStructuralValidation) {
                 if (checkReferentialIntegrity) {
                     debug("Checking referential integrity ...");
+                    const entityNameValidator = createEntityNameValidator(this.#schema.isEntityName.bind(this.#schema), true);
                     const referenceValidator = createReferenceValidator(this.#schema.isEntityName.bind(this.#schema), data, true);
                     const referenceErrors = onlyEntities
                         .flatMap(entity => parallelizeErrors(data
                         .getAllInstanceContainersOfEntity(entity.name)
-                        .map(instance => wrapErrorsIfAny(`in file ${styleText("white", `"${this.#dataRootPath}${sep}${styleText("bold", join(entity.name, getFileNameForId(instance.id)))}"`)}`, validateDeclReferentialIntegrity(validationContext, referenceValidator, [], entity, [], instance.content)))))
+                        .map(instance => wrapErrorsIfAny(`in file ${styleText("white", `"${this.#dataRootPath}${sep}${styleText("bold", join(entity.name, getFileNameForId(instance.id)))}"`)}`, validateDeclReferentialIntegrity(validationContext, entityNameValidator, referenceValidator, [], entity, [], instance.content)))))
                         .toSorted((a, b) => a.message.localeCompare(b.message));
                     if (referenceErrors.length > 0) {
                         const errorCount = countErrors(referenceErrors);
@@ -287,6 +288,31 @@ export class TSONDB {
         }, true);
         debug("All data is formatted");
     }
+    /**
+     * Checks if the data on disk is formatted according to the current in-memory representation.
+     */
+    async checkFormat() {
+        debug("Check database formatting ...");
+        let counter = 0;
+        await this.#data.forEachInstance(async (entityName, instance) => {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const entity = this.#schema.getEntity(entityName);
+            const instanceOnDisk = await readInstance(this.#dataRootPath, entity, instance.id);
+            const currentFormatted = formatInstance(entity, instance.content, this.#formatterOptions);
+            if (instanceOnDisk !== currentFormatted) {
+                console.log(`Instance ${styleText("yellow", instance.id)} of entity ${styleText("cyan", entityName)} is not formatted correctly.`);
+                counter++;
+            }
+        }, true);
+        if (counter === 0) {
+            console.log(styleText("green", "All data is formatted"));
+        }
+        else {
+            console.error(styleText("red", `${counter.toFixed()} formatting error${counter === 1 ? "" : "s"} found`, {
+                stream: stderr,
+            }));
+        }
+    }
     /**
      * Reloads the data from disk into memory.
      */

package/dist/src/node/schema/treeOperations/validation.d.ts

@@ -7,13 +7,15 @@ export type IdentifierToCheck = {
     name: string;
     value: unknown;
 };
+export type EntityNameValidator = (entityName: unknown) => Error[];
 export type ReferenceValidator = (entityName: string, instanceId: unknown) => ReferenceError[];
 export interface ValidationContext {
     useStyling: boolean;
     validationOptions: ValidationOptions;
 }
+export declare const createEntityNameValidator: (isEntityName: (name: string) => boolean, useStyling: boolean) => EntityNameValidator;
 export declare const createReferenceValidator: <EM extends AnyEntityMap>(isEntityName: (name: string) => name is Extract<keyof EM, string>, databaseInMemory: DatabaseInMemory<EM>, useStyling: boolean) => ReferenceValidator;
 export declare const validateDeclStructuralIntegrity: (helpers: ValidationContext, inDecls: Decl[], decl: Decl, typeArgs: Type[], value: unknown) => TypeError[];
 export declare const validateTypeStructuralIntegrity: (helpers: ValidationContext, inDecls: Decl[], type: Type, value: unknown) => TypeError[];
-export declare const validateDeclReferentialIntegrity: (helpers: ValidationContext, checkReferentialIntegrity: ReferenceValidator, inDecls: Decl[], decl: Decl, typeArgs: Type[], value: unknown) => ReferenceError[];
-export declare const validateTypeReferentialIntegrity: (helpers: ValidationContext, checkReferentialIntegrity: ReferenceValidator, inDecls: Decl[], type: Type, value: unknown) => ReferenceError[];
+export declare const validateDeclReferentialIntegrity: (helpers: ValidationContext, checkEntityName: EntityNameValidator, checkReferentialIntegrity: ReferenceValidator, inDecls: Decl[], decl: Decl, typeArgs: Type[], value: unknown) => ReferenceError[];
+export declare const validateTypeReferentialIntegrity: (helpers: ValidationContext, checkEntityName: EntityNameValidator, checkReferentialIntegrity: ReferenceValidator, inDecls: Decl[], type: Type, value: unknown) => ReferenceError[];

package/dist/src/node/schema/treeOperations/validation.js

@@ -1,3 +1,5 @@
+import { validate as validateBlockMarkdown, validateInline as validateInlineMarkdown, } from "@elyukai/markdown/validate";
+import { isNotNullish } from "@elyukai/utils/nullable";
 import { assertExhaustive } from "@elyukai/utils/typeSafety";
 import { MessageError, parseMessage, validate } from "messageformat";
 import { ENUM_DISCRIMINATOR_KEY } from "../../../shared/schema/declarations/EnumDecl.js";
@@ -16,6 +18,9 @@ import { getTypeArgumentsRecord } from "../dsl/declarations/Decl.js";
 import { createEntityIdentifierType } from "../dsl/declarations/EntityDecl.js";
 import { isChildEntitiesType } from "../guards.js";
 import { resolveTypeArguments } from "./typeResolution.js";
+export const createEntityNameValidator = (isEntityName, useStyling) => entityName => typeof entityName === "string" && isEntityName(entityName)
+    ? []
+    : [ReferenceError(`Invalid entity name ${json(entityName, useStyling)}`)];
 export const createReferenceValidator = (isEntityName, databaseInMemory, useStyling) => (entityName, instanceId) => isEntityName(entityName)
     ? typeof instanceId === "string" &&
         databaseInMemory.hasInstanceOfEntityById(entityName, instanceId)
@@ -86,6 +91,69 @@ const validateTranslationObjectStructuralIntegrity = (context, allKeysAreRequire
         }),
     ]);
 };
+const DEFAULT_ENTITY_KEY = "entity";
+const DEFAULT_INSTANCE_KEY = "instance";
+const normalizeAttributedStringReferenceKeys = (option) => option === true ? { entityKey: DEFAULT_ENTITY_KEY, instanceKey: DEFAULT_INSTANCE_KEY } : option;
+const createStructuralAttributedStringKeyValidator = (validationOptions) => {
+    const { checkInstanceReferencesInAttributedStrings: checkAttrRefs, checkAttributedStringKeys } = validationOptions.markdown ?? {};
+    if (checkAttributedStringKeys !== undefined) {
+        const generalTest = Array.isArray(checkAttributedStringKeys)
+            ? key => checkAttributedStringKeys.includes(key)
+            : key => checkAttributedStringKeys.test(key);
+        if (checkAttrRefs === true || typeof checkAttrRefs === "object") {
+            const { entityKey, instanceKey } = normalizeAttributedStringReferenceKeys(checkAttrRefs);
+            const additionalValidKeys = [entityKey, instanceKey];
+            return key => generalTest(key) || additionalValidKeys.includes(key);
+        }
+        return generalTest;
+    }
+    return undefined;
+};
+const createStructuralAttributedStringValidator = (validationOptions) => {
+    const keyValidator = createStructuralAttributedStringKeyValidator(validationOptions);
+    if (keyValidator === undefined) {
+        return undefined;
+    }
+    return attributes => Object.keys(attributes)
+        .map(attributeName => keyValidator(attributeName)
+        ? undefined
+        : new TypeError(`invalid attribute key "${attributeName}" in attributed string`))
+        .filter(isNotNullish);
+};
+const createReferentialAttributedStringValidator = (entityValidator, referenceValidator, validationOptions) => {
+    const { checkInstanceReferencesInAttributedStrings: checkAttrRefs } = validationOptions.markdown ?? {};
+    if (checkAttrRefs === true || typeof checkAttrRefs === "object") {
+        const { entityKey, instanceKey } = normalizeAttributedStringReferenceKeys(checkAttrRefs);
+        return attributes => {
+            if (entityKey in attributes) {
+                const entityName = attributes[entityKey];
+                const entityErrors = entityValidator(entityName);
+                if (entityErrors.length > 0) {
+                    return entityErrors;
+                }
+                if (instanceKey in attributes && typeof entityName === "string") {
+                    const instanceId = attributes[instanceKey];
+                    return referenceValidator(entityName, instanceId);
+                }
+            }
+            return [];
+        };
+    }
+    return undefined;
+};
+const validateMarkdownString = (type, value, validator) => {
+    if (type.markdown !== undefined && typeof value === "string") {
+        switch (type.markdown) {
+            case "inline":
+                return validateInlineMarkdown(value, { validateAttributes: validator });
+            case "block":
+                return validateBlockMarkdown(value, { validateAttributes: validator });
+            default:
+                return assertExhaustive(type.markdown);
+        }
+    }
+    return [];
+};
 export const validateTypeStructuralIntegrity = (helpers, inDecls, type, value) => {
     switch (type.kind) {
         case NodeKind.ArrayType: {
@@ -149,7 +217,10 @@ export const validateTypeStructuralIntegrity = (helpers, inDecls, type, value) =
             if (typeof value !== "string") {
                 return [TypeError(`expected a string, but got ${json(value, helpers.useStyling)}`)];
             }
-            return validateStringConstraints(type, value);
+            return parallelizeErrors([
+                ...validateStringConstraints(type, value),
+                ...validateMarkdownString(type, value, createStructuralAttributedStringValidator(helpers.validationOptions)),
+            ]);
         }
         case NodeKind.TypeArgumentType: {
             throw new TypeError(`generic argument "${type.argument.name}" has not been replaced with a concrete type`);
@@ -212,13 +283,13 @@ export const validateTypeStructuralIntegrity = (helpers, inDecls, type, value) =
             return assertExhaustive(type);
     }
 };
-export const validateDeclReferentialIntegrity = (helpers, checkReferentialIntegrity, inDecls, decl, typeArgs, value) => {
+export const validateDeclReferentialIntegrity = (helpers, checkEntityName, checkReferentialIntegrity, inDecls, decl, typeArgs, value) => {
     switch (decl.kind) {
         case NodeKind.EntityDecl:
-            return validateTypeReferentialIntegrity(helpers, checkReferentialIntegrity, inDecls, decl.type.value, value);
+            return validateTypeReferentialIntegrity(helpers, checkEntityName, checkReferentialIntegrity, inDecls, decl.type.value, value);
         case NodeKind.EnumDecl:
         case NodeKind.TypeAliasDecl:
-            return validateTypeReferentialIntegrity(helpers, checkReferentialIntegrity, [...inDecls, decl], resolveTypeArguments(getTypeArgumentsRecord(decl, typeArgs), decl.type.value, [
+            return validateTypeReferentialIntegrity(helpers, checkEntityName, checkReferentialIntegrity, [...inDecls, decl], resolveTypeArguments(getTypeArgumentsRecord(decl, typeArgs), decl.type.value, [
                 ...inDecls,
                 decl,
             ]), value);
@@ -226,11 +297,11 @@ export const validateDeclReferentialIntegrity = (helpers, checkReferentialIntegr
             return assertExhaustive(decl);
     }
 };
-export const validateTypeReferentialIntegrity = (helpers, checkReferentialIntegrity, inDecls, type, value) => {
+export const validateTypeReferentialIntegrity = (helpers, checkEntityName, checkReferentialIntegrity, inDecls, type, value) => {
     switch (type.kind) {
         case NodeKind.ArrayType:
             return Array.isArray(value)
-                ? parallelizeErrors(value.map((item, index) => wrapErrorsIfAny(`at index ${key(index.toString(), helpers.useStyling)}`, validateTypeReferentialIntegrity(helpers, checkReferentialIntegrity, inDecls, type.items, item))))
+                ? parallelizeErrors(value.map((item, index) => wrapErrorsIfAny(`at index ${key(index.toString(), helpers.useStyling)}`, validateTypeReferentialIntegrity(helpers, checkEntityName, checkReferentialIntegrity, inDecls, type.items, item))))
                 : [];
         case NodeKind.ObjectType: {
             if (typeof value !== "object" || value === null || Array.isArray(value)) {
@@ -242,7 +313,7 @@ export const validateTypeReferentialIntegrity = (helpers, checkReferentialIntegr
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 const prop = type.properties[propName];
                 if (value[propName] !== undefined) {
-                    return wrapErrorsIfAny(`at object key ${key(`"${propName}"`, helpers.useStyling)}`, validateTypeReferentialIntegrity(helpers, checkReferentialIntegrity, inDecls, prop.type, value[propName]));
+                    return wrapErrorsIfAny(`at object key ${key(`"${propName}"`, helpers.useStyling)}`, validateTypeReferentialIntegrity(helpers, checkEntityName, checkReferentialIntegrity, inDecls, prop.type, value[propName]));
                 }
                 return undefined;
             }));
@@ -253,12 +324,12 @@ export const validateTypeReferentialIntegrity = (helpers, checkReferentialIntegr
         case NodeKind.ReferenceIdentifierType:
             return checkReferentialIntegrity(type.entity.name, value);
         case NodeKind.IncludeIdentifierType:
-            return validateDeclReferentialIntegrity(helpers, checkReferentialIntegrity, inDecls, type.reference, type.args, value);
+            return validateDeclReferentialIntegrity(helpers, checkEntityName, checkReferentialIntegrity, inDecls, type.reference, type.args, value);
         case NodeKind.NestedEntityMapType: {
             if (typeof value !== "object" || value === null || Array.isArray(value)) {
                 return [];
             }
-            return parallelizeErrors(Object.keys(value).map(propName => wrapErrorsIfAny(`at nested entity map ${entity(`"${type.name}"`, helpers.useStyling)} at key ${key(`"${propName}"`, helpers.useStyling)}`, validateTypeReferentialIntegrity(helpers, checkReferentialIntegrity, inDecls, type.type.value, value[propName]).concat(checkReferentialIntegrity(type.secondaryEntity.name, propName)))));
+            return parallelizeErrors(Object.keys(value).map(propName => wrapErrorsIfAny(`at nested entity map ${entity(`"${type.name}"`, helpers.useStyling)} at key ${key(`"${propName}"`, helpers.useStyling)}`, validateTypeReferentialIntegrity(helpers, checkEntityName, checkReferentialIntegrity, inDecls, type.type.value, value[propName]).concat(checkReferentialIntegrity(type.secondaryEntity.name, propName)))));
         }
         case NodeKind.EnumType: {
             if (typeof value !== "object" ||
@@ -274,15 +345,16 @@ export const validateTypeReferentialIntegrity = (helpers, checkReferentialIntegr
                 type.values[enumCase].type !== null &&
                 enumCase in value
                 ? parallelizeErrors([
-                    wrapErrorsIfAny(`at enum case ${key(`"${enumCase}"`, helpers.useStyling)}`, validateTypeReferentialIntegrity(helpers, checkReferentialIntegrity, inDecls, type.values[enumCase].type, value[enumCase])),
+                    wrapErrorsIfAny(`at enum case ${key(`"${enumCase}"`, helpers.useStyling)}`, validateTypeReferentialIntegrity(helpers, checkEntityName, checkReferentialIntegrity, inDecls, type.values[enumCase].type, value[enumCase])),
                 ])
                 : [];
         }
+        case NodeKind.StringType:
+            return validateMarkdownString(type, value, createReferentialAttributedStringValidator(checkEntityName, checkReferentialIntegrity, helpers.validationOptions));
         case NodeKind.BooleanType:
         case NodeKind.DateType:
         case NodeKind.FloatType:
         case NodeKind.IntegerType:
-        case NodeKind.StringType:
         case NodeKind.ChildEntitiesType:
         case NodeKind.TranslationObjectType:
             return [];

package/dist/src/node/server/index.js

@@ -35,7 +35,7 @@ export const createServer = (db, config) => {
         defaultLocales,
         locales: defaultLocales,
         homeLayoutSections,
-        validationOptions: validationOptions ?? {},
+        validationOptions: { ...(validationOptions ?? {}), markdown: undefined },
     };
     app.use((req, _res, next) => {
         debug("%s %s", req.method, req.originalUrl);

package/dist/src/node/utils/files.d.ts

@@ -3,6 +3,7 @@ import type { FormatterOptions } from "../config.ts";
 import { type EntityDecl } from "../schema/dsl/index.ts";
 export declare const getFileNameForId: (id: string) => string;
 export declare const getPathToInstance: (dataRoot: string, entityName: string, id: string) => string;
+export declare const readInstance: (dataRoot: string, entity: EntityDecl, id: string) => Promise<string>;
 export declare const writeInstance: (dataRoot: string, entity: EntityDecl, id: string, instance: InstanceContent, formatterOptions: Partial<FormatterOptions> | undefined) => Promise<void>;
 export declare const deleteInstance: (dataRoot: string, entityName: string, id: string) => Promise<void>;
 export declare const formatInstance: (entity: EntityDecl, instanceContent: InstanceContent, options: Partial<FormatterOptions> | undefined) => string;

package/dist/src/node/utils/files.js

@@ -1,9 +1,12 @@
-import { rm, writeFile } from "node:fs/promises";
+import { readFile, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import {} from "../schema/dsl/index.js";
 import { formatValue } from "../schema/treeOperations/format.js";
 export const getFileNameForId = (id) => `${id}.json`;
 export const getPathToInstance = (dataRoot, entityName, id) => join(dataRoot, entityName, getFileNameForId(id));
+export const readInstance = (dataRoot, entity, id) => readFile(getPathToInstance(dataRoot, entity.name, id), {
+    encoding: "utf-8",
+});
 export const writeInstance = (dataRoot, entity, id, instance, formatterOptions) => writeFile(getPathToInstance(dataRoot, entity.name, id), formatInstance(entity, instance, formatterOptions), {
     encoding: "utf-8",
 });

package/dist/src/shared/validation/string.js

@@ -19,9 +19,9 @@ export const validateStringConstraints = (constraints, value) => parallelizeErro
             ? TypeError(`string does not match the pattern ${pattern.toString()}`)
             : undefined;
     })(),
-    (() => {
+    ...(() => {
         if (constraints.markdown === undefined) {
-            return undefined;
+            return [];
         }
         switch (constraints.markdown) {
             case "inline":

package/dist/src/web/web.js

@@ -3404,7 +3404,7 @@ const inlineNode = combineParsers([
     leafParser(defaultInlineSyntaxStartSequences)
 ]);
 const inlineMarkdown = inlineNode.many();
-const _parseInlineMarkdown = (syntax, keepSyntax = false, preserveEscapes = false)=>{
+const inline_parseInlineMarkdown = (syntax, keepSyntax = false, preserveEscapes = false)=>{
     const results = inlineMarkdown.evalT({
         indentation: 0,
         keepSyntax,
@@ -3415,8 +3415,8 @@ const _parseInlineMarkdown = (syntax, keepSyntax = false, preserveEscapes = fals
     if (remaining.length > 0) throw new Error(`Failed to parse the entire string. Remaining: "${remaining}"`);
     return result;
 };
-const parseInlineMarkdown = (syntax)=>_parseInlineMarkdown(syntax, false);
-const parseInlineMarkdownForSyntaxHighlighting = (syntax)=>_parseInlineMarkdown(syntax, true);
+const parseInlineMarkdown = (syntax)=>inline_parseInlineMarkdown(syntax, false);
+const parseInlineMarkdownForSyntaxHighlighting = (syntax)=>inline_parseInlineMarkdown(syntax, true);
 const isNullish = (value)=>null == value;
 const isNotNullish = (value)=>!isNullish(value);
 const sortObjectKeysByIndex = (obj, keys)=>Object.fromEntries([
@@ -3660,8 +3660,21 @@ const tableCaptionRowSyntax = sepByKeepFlat(StateTParser.string("|#").then((star
                                 },
                                 block_asText(endSpace + newline)
                             ]))))))), block_indentation);
-const tableHeaderRow = tableRow(tableContentCellGuard.then(()=>inlineMarkdown), false);
-const tableHeaderRowSyntax = tableRowSyntax(tableContentCellGuard.then(()=>inlineMarkdown), false);
+const tableHeaderRow = tableRow(tableContentCellGuard.then(()=>inlineMarkdown).htoken().then((content)=>StateTParser.lookahead(StateTParser.string("||")).then(()=>StateTParser.string("|")).many().map((span)=>({
+            content,
+            span: span.length > 0 ? span.length + 1 : void 0
+        }))), false);
+const tableHeaderRowSyntax = tableRowSyntax(tableContentCellGuard.then(()=>inlineMarkdown.then((content)=>anySpacesT.then((trailingSpace)=>StateTParser.lookahead(StateTParser.string("||")).then(()=>StateTParser.string("|")).many().map((span)=>[
+                    ...content,
+                    block_asText(trailingSpace),
+                    ...span.length > 0 ? [
+                        {
+                            type: "syntax",
+                            blockType: "table",
+                            content: "|".repeat(span.length)
+                        }
+                    ] : []
+                ])))), false);
 const tableSeparatorRow = tableRow(tableHeaderSeparatorCell.htoken());
 const tableSeparatorRowSyntax = tableRowSyntax(tableHeaderSeparatorCell.then((separator)=>anySpacesT.map((trailingSpaces)=>[
             {
@@ -3723,10 +3736,6 @@ const tableSectionPlainSeparatorRowSyntax = tableRowSyntax(tableSectionSeparator
         ])));
 const tableBodyRow = tableSectionSubheaderWithSeparatorRow.orFirstW(tableSectionPlainSeparatorRow).orFirstW(tableNormalRow);
 const tableBodyRowSyntax = tableSectionSubheaderWithSeparatorRowSyntax.orFirstW(tableSectionPlainSeparatorRowSyntax).orFirstW(tableNormalRowSyntax);
-const mapCell = (cell)=>({
-        type: "tableCell",
-        content: trimLastNodeEnd(cell)
-    });
 const mapCellObj = (cell)=>omitUndefinedKeys({
         type: "tableCell",
         content: trimLastNodeEnd(cell.content),
@@ -3762,7 +3771,7 @@ const table = tableCaptionRow.then((caption)=>(0 === caption.length ? StateTPars
                         columns: separators.map((cell)=>omitUndefinedKeys({
                                 alignment: getAlignmentFromSeparator(cell)
                             })),
-                        header: header.map(mapCell),
+                        header: header.map(mapCellObj),
                         rows: sectionRows(rows)
                     }))))));
 const tableSyntax = tableCaptionRowSyntax.then((caption)=>(0 === caption.length ? StateTParser.of([]) : block_indentation).then((indentBetweenCaptionAndHeader)=>tableHeaderRowSyntax.then((header)=>newlineT.then((headerNewline)=>tableSeparatorRowSyntax.then((separators)=>newlineT.then((separatorsNewline)=>sepBy1KeepFlat(tableBodyRowSyntax, newlineT.map(asSingleText)).map((rows)=>[
@@ -3790,7 +3799,7 @@ const finalBlockMarkdownSyntax = anyBlankLines.then((leadingsNewlines)=>blockMar
                     content: "\n"
                 } : node)
         ])));
-const _parseBlockMarkdown = (syntax, keepSyntax = false, preserveEscapes = false)=>{
+const block_parseBlockMarkdown = (syntax, keepSyntax = false, preserveEscapes = false)=>{
     const results = finalBlockMarkdown.evalT({
         indentation: 0,
         keepSyntax,
@@ -3812,7 +3821,7 @@ const _parseBlockMarkdown = (syntax, keepSyntax = false, preserveEscapes = false
     ];
     return result;
 };
-const parseBlockMarkdown = (syntax)=>_parseBlockMarkdown(syntax);
+const parseBlockMarkdown = (syntax)=>block_parseBlockMarkdown(syntax);
 const parseBlockMarkdownForSyntaxHighlighting = (syntax)=>{
     const results = finalBlockMarkdownSyntax.evalT({
         indentation: 0,
@@ -5444,6 +5453,17 @@ const ReferenceIdentifierTypeInput = ({ type, value, instanceNamesByEntity, disa
         ]
     });
 };
+const getBuilderForNode = (builder, node)=>builder[node.type];
+const renderInline = (node, builder, ...args)=>{
+    const parseInner = (node, ...args)=>getBuilderForNode(builder, node)(node, parseInner, ...args);
+    return parseInner(node, ...args);
+};
+const render = (node, builder, ...args)=>{
+    const parseInnerInline = (node, ...args)=>getBuilderForNode(builder, node)(node, parseInnerInline, ...args);
+    const parseInner = (node, ...args)=>getBuilderForNode(builder, node)(node, parseInner, parseInnerInline, ...args);
+    return parseInner(node, ...args);
+};
+const passThroughInnerFlat = (node, validateInner, ...args)=>node.content.flatMap((content)=>validateInner(content, ...args));
 class InternalMarkdownError extends Error {
     constructor(message){
         super(message);
@@ -5471,31 +5491,79 @@ const positionInStringToColumnAndRow = (position, string)=>{
         column
     };
 };
-const validateInline = (markdown)=>{
+const emptyErrors = ()=>[];
+const inlineValidationMap = {
+    attributed: (node, validateInner, options)=>passThroughInnerFlat(node, validateInner, options).concat(options?.validateAttributes?.(node.attributes) ?? []),
+    bold: passThroughInnerFlat,
+    italic: passThroughInnerFlat,
+    link: passThroughInnerFlat,
+    superscript: passThroughInnerFlat,
+    code: emptyErrors,
+    footnoteRef: emptyErrors,
+    text: emptyErrors
+};
+const collectInlineValidationErrors = (nodes, options)=>nodes.flatMap((node)=>renderInline(node, inlineValidationMap, options));
+const blockValidationMap = {
+    container: (node, validateInner, _validateInnerInline, options)=>node.content.flatMap((content)=>validateInner(content, options)),
+    definitionList: (node, validateInner, validateInnerInline, options)=>node.content.flatMap((itemGroup)=>[
+                ...itemGroup.terms.flatMap((term)=>term.flatMap((content)=>validateInnerInline(content, options))),
+                ...itemGroup.descriptions.flatMap((description)=>description.flatMap((content)=>validateInner(content, options)))
+            ]),
+    footnote: (node, validateInner, _validateInnerInline, options)=>node.content.flatMap((content)=>validateInner(content, options)),
+    heading: (node, _validateInner, validateInnerInline, options)=>node.content.flatMap((content)=>validateInnerInline(content, options)),
+    list: (node, validateInner, _validateInnerInline, options)=>node.content.flatMap((item)=>item.content.flatMap((content)=>validateInner(content, options))),
+    paragraph: (node, _validateInner, validateInnerInline, options)=>node.content.flatMap((content)=>"break" === content.type ? [] : validateInnerInline(content, options)),
+    table: (node, _validateInner, validateInnerInline, options)=>[
+            ...node.caption?.flatMap((captionLine)=>captionLine.flatMap((content)=>validateInnerInline(content, options))) ?? [],
+            ...node.header.flatMap((cell)=>cell.content.flatMap((content)=>validateInnerInline(content, options))),
+            ...checkTableRowsAreSections(node.rows) ? node.rows.flatMap((section)=>[
+                    ...section.header?.flatMap((cell)=>cell.content.flatMap((content)=>validateInnerInline(content, options))) ?? [],
+                    ...section.rows.flatMap((row)=>row.cells.flatMap((cell)=>cell.content.flatMap((content)=>validateInnerInline(content, options))))
+                ]) : node.rows.flatMap((row)=>row.cells.flatMap((cell)=>cell.content.flatMap((content)=>validateInnerInline(content, options))))
+        ]
+};
+const validationMap = {
+    ...inlineValidationMap,
+    ...blockValidationMap
+};
+const collectBlockValidationErrors = (nodes, options)=>nodes.flatMap((node)=>render(node, validationMap, options));
+const validateInline = (markdown, options)=>{
     const results = inlineMarkdown.evalT({
         indentation: 0,
         keepSyntax: false,
         preserveEscapes: false
     }).parse(markdown);
-    if (!isNotEmpty(results)) return new InternalMarkdownError("Failed to parse inline Markdown");
-    const [_, remaining] = results[0];
+    if (!isNotEmpty(results)) return [
+        new InternalMarkdownError("Failed to parse inline Markdown")
+    ];
+    const [nodes, remaining] = results[0];
     if (remaining.length > 0) {
         const { row, column } = positionInStringToColumnAndRow(markdown.length - remaining.length, markdown);
-        return new MarkdownSyntaxError(row, column, remaining);
+        return [
+            new MarkdownSyntaxError(row, column, remaining)
+        ];
     }
+    if (options?.validateAttributes !== void 0) return collectInlineValidationErrors(nodes, options);
+    return [];
 };
-const validate = (markdown)=>{
+const validate = (markdown, options)=>{
     const results = finalBlockMarkdown.evalT({
         indentation: 0,
         keepSyntax: false,
         preserveEscapes: false
     }).parse(markdown);
-    if (!isNotEmpty(results)) return new InternalMarkdownError("Failed to parse Markdown");
-    const [_, remaining] = results[0];
+    if (!isNotEmpty(results) || void 0 === results[0][0] && markdown.length > 0) return [
+        new InternalMarkdownError("Failed to parse Markdown")
+    ];
+    const [nodes = [], remaining] = results[0];
     if (remaining.length > 0) {
         const { row, column } = positionInStringToColumnAndRow(markdown.length - remaining.length, markdown);
-        return new MarkdownSyntaxError(row, column, remaining);
+        return [
+            new MarkdownSyntaxError(row, column, remaining)
+        ];
     }
+    if (options?.validateAttributes !== void 0) return collectBlockValidationErrors(nodes, options);
+    return [];
 };
 const validateStringConstraints = (constraints, value)=>parallelizeErrors([
         void 0 !== constraints.minLength && value.length < constraints.minLength ? RangeError(`expected a string with at least ${constraints.minLength.toString()} character${1 === constraints.minLength ? "" : "s"}, but got ${value.length.toString()} character${1 === value.length ? "" : "s"}`) : void 0,
@@ -5505,8 +5573,8 @@ const validateStringConstraints = (constraints, value)=>parallelizeErrors([
             const pattern = "string" == typeof constraints.pattern ? new RegExp(constraints.pattern) : constraints.pattern;
             return pattern.test(value) ? void 0 : TypeError(`string does not match the pattern ${pattern.toString()}`);
         })(),
-        (()=>{
-            if (void 0 === constraints.markdown) return;
+        ...(()=>{
+            if (void 0 === constraints.markdown) return [];
             switch(constraints.markdown){
                 case "inline":
                     return validateInline(value);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsondb",
-  "version": "0.20.7",
+  "version": "0.20.8",
   "description": "",
   "license": "ISC",
   "author": "Lukas Obermann",
@@ -53,7 +53,7 @@
     "typescript-eslint": "^8.70.1"
   },
   "dependencies": {
-    "@elyukai/markdown": "^0.3.4",
+    "@elyukai/markdown": "^0.4.0",
     "@elyukai/utils": "^0.3.6",
     "@preact/signals": "^2.11.2",
     "debug": "^4.4.3",