tsondb 0.2.0 → 0.4.0

package/lib/node/utils/instances.js

@@ -0,0 +1,21 @@
+import { readdir, readFile } from "node:fs/promises";
+import { basename, extname, join } from "node:path";
+import { getGitFileStatusFromStatusResult } from "./git.js";
+export const getInstancesByEntityName = async (dataRoot, entities) => Object.fromEntries(await Promise.all(entities.map(async (entity) => {
+    const entityDir = join(dataRoot, entity.name);
+    const instanceFileNames = await readdir(entityDir);
+    const instances = await Promise.all(instanceFileNames.map(async (instanceFileName) => ({
+        fileName: instanceFileName,
+        id: basename(instanceFileName, extname(instanceFileName)),
+        content: JSON.parse(await readFile(join(entityDir, instanceFileName), "utf-8")),
+    })));
+    return [entity.name, instances];
+})));
+export const attachGitStatusToInstancesByEntityName = (instancesByEntityName, dataRoot, gitRoot, gitStatus) => {
+    Object.entries(instancesByEntityName).forEach(([entityName, instances]) => {
+        instancesByEntityName[entityName] = instances.map(instanceContainer => ({
+            ...instanceContainer,
+            gitStatus: getGitFileStatusFromStatusResult(gitStatus, gitRoot, dataRoot, entityName, instanceContainer.fileName),
+        }));
+    });
+};

package/lib/node/utils/path.d.ts

@@ -0,0 +1 @@
+export declare const ensureSpecialDirStart: (path: string) => string;

package/lib/node/utils/path.js

@@ -0,0 +1,2 @@
+import { sep } from "node:path";
+export const ensureSpecialDirStart = (path) => new RegExp(`^\\.\\.?\\${sep}`).test(path) ? path : `./${path}`;

package/lib/node/utils/references.d.ts

@@ -0,0 +1,7 @@
+import type { InstanceContainer } from "../../shared/utils/instances.js";
+import type { EntityDecl } from "../schema/declarations/EntityDecl.js";
+export type ReferencesToInstances = {
+    [instanceId: string]: string[];
+};
+export declare const getReferencesToInstances: (instancesByEntityName: Record<string, InstanceContainer[]>, entitiesByName: Record<string, EntityDecl>) => ReferencesToInstances;
+export declare const updateReferencesToInstances: (entitiesByName: Record<string, EntityDecl>, referencesToInstances: ReferencesToInstances, entityName: string, instanceId: string, oldInstance: unknown, newInstance: unknown) => ReferencesToInstances;

package/lib/node/utils/references.js

@@ -0,0 +1,40 @@
+import { difference, removeAt } from "../../shared/utils/array.js";
+import { getReferencesForEntityDecl } from "../schema/declarations/EntityDecl.js";
+const addReference = (acc, reference, instanceId) => ({
+    ...acc,
+    [reference]: [...(acc[reference] ?? []), instanceId],
+});
+const addReferences = (acc, references, instanceId) => references.reduce((acc1, reference) => addReference(acc1, reference, instanceId), acc);
+const removeReference = (acc, reference, instanceId) => acc[reference]
+    ? {
+        ...acc,
+        [reference]: removeAt(acc[reference], acc[reference].indexOf(instanceId)),
+    }
+    : acc;
+const removeReferences = (acc, references, instanceId) => references.reduce((acc1, reference) => removeReference(acc1, reference, instanceId), acc);
+export const getReferencesToInstances = (instancesByEntityName, entitiesByName) => Object.entries(instancesByEntityName).reduce((acc, [entityName, instances]) => {
+    const entity = entitiesByName[entityName];
+    if (entity) {
+        return instances.reduce((acc1, instance) => {
+            const references = getReferencesForEntityDecl(entity, instance.content);
+            return addReferences(acc1, references, instance.id);
+        }, acc);
+    }
+    return acc;
+}, {});
+export const updateReferencesToInstances = (entitiesByName, referencesToInstances, entityName, instanceId, oldInstance, newInstance) => {
+    const entity = entitiesByName[entityName];
+    if (entity) {
+        if (oldInstance === undefined) {
+            return addReferences(referencesToInstances, getReferencesForEntityDecl(entity, newInstance), instanceId);
+        }
+        if (newInstance === undefined) {
+            return removeReferences(referencesToInstances, getReferencesForEntityDecl(entity, oldInstance), instanceId);
+        }
+        const oldReferences = getReferencesForEntityDecl(entity, oldInstance);
+        const newReferences = getReferencesForEntityDecl(entity, newInstance);
+        const { added, removed } = difference(oldReferences, newReferences);
+        return removeReferences(addReferences(referencesToInstances, added, instanceId), removed, instanceId);
+    }
+    return referencesToInstances;
+};

package/lib/node/utils/render.d.ts

@@ -0,0 +1,9 @@
+export declare const prefixLines: (prefix: string, text: string, includeEmptyLines?: boolean) => string;
+export declare const applyIndentation: (indentLevel: number, text: string, spaces: number) => string;
+export declare const joinSyntax: (...syntaxes: (string | undefined)[]) => string;
+export type RenderResult = [imports: {
+    [sourcePath: string]: string[];
+}, syntax: string];
+export declare const combineSyntaxes: (syntaxes: (RenderResult | string | undefined)[], separator?: string) => RenderResult;
+export declare const syntax: (strings: TemplateStringsArray, ...values: (RenderResult | string | undefined)[]) => RenderResult;
+export declare const indent: (spaces: number, indentLevel: number, text: RenderResult) => RenderResult;

package/lib/node/utils/render.js

@@ -0,0 +1,34 @@
+import { EOL } from "node:os";
+import { mergeObjects } from "../../shared/utils/object.js";
+export const prefixLines = (prefix, text, includeEmptyLines = false) => text
+    .split(EOL)
+    .map(line => (includeEmptyLines || line.length > 0 ? prefix + line : line))
+    .join(EOL);
+export const applyIndentation = (indentLevel, text, spaces) => prefixLines(" ".repeat(spaces * indentLevel), text);
+export const joinSyntax = (...syntaxes) => syntaxes.filter(syntax => syntax !== undefined).join("");
+const emptyRenderResult = [{}, ""];
+export const combineSyntaxes = (syntaxes, separator = "") => syntaxes
+    .filter(syntax => syntax !== undefined)
+    .reduce((acc, value, i) => typeof value === "string"
+    ? [acc[0], acc[1] + (i === 0 ? "" : separator) + value]
+    : [mergeArraysByKey(acc[0], value[0]), acc[1] + (i === 0 ? "" : separator) + value[1]], emptyRenderResult);
+const mergeArraysByKey = (...arrayGroups) => arrayGroups.reduce((acc, arrayGroup) => mergeObjects(acc, arrayGroup, (a, b) => a.concat(b)), {});
+export const syntax = (strings, ...values) => strings.reduce((acc, str, i) => {
+    const nextValue = values[i];
+    if (typeof nextValue === "string") {
+        return [acc[0], acc[1] + str.replace(/\n/g, EOL) + nextValue];
+    }
+    else if (Array.isArray(nextValue)) {
+        return [
+            mergeArraysByKey(acc[0], nextValue[0]),
+            acc[1] + str.replace(/\n/g, EOL) + nextValue[1],
+        ];
+    }
+    else {
+        return [acc[0], acc[1] + str.replace(/\n/g, EOL)];
+    }
+}, emptyRenderResult);
+export const indent = (spaces, indentLevel, text) => [
+    text[0],
+    prefixLines(" ".repeat(spaces * indentLevel), text[1]),
+];

package/lib/shared/api.d.ts

@@ -1,5 +1,5 @@
-import { SerializedDecl } from "../schema/declarations/Declaration.js";
-import { InstanceContainer } from "./utils/instances.js";
+import type { SerializedDecl } from "../node/schema/declarations/Declaration.js";
+import type { InstanceContainer, InstanceContainerOverview } from "./utils/instances.js";
 export interface GetAllDeclarationsResponseBody<D extends SerializedDecl = SerializedDecl> {
     declarations: {
         declaration: D;
@@ -40,3 +40,20 @@ export interface GetAllInstancesResponseBody {
         }[];
     };
 }
+export interface GitStatusResponseBody {
+    commitsAhead: number;
+    commitsBehind: number;
+    instances: {
+        [entity: string]: InstanceContainerOverview[];
+    };
+}
+export interface GetAllGitBranchesResponseBody {
+    allBranches: string[];
+    currentBranch: string;
+}
+export interface CreateCommitRequestBody {
+    message: string;
+}
+export interface CreateBranchRequestBody {
+    branchName: string;
+}

package/lib/shared/utils/array.d.ts

@@ -0,0 +1,19 @@
+export declare const removeAt: <T>(arr: T[], index: number) => T[];
+export declare const insertAt: <T>(arr: T[], index: number, item: T) => T[];
+/**
+ * Calculates the difference between two arrays, including duplicated values.
+ * @param oldArr - The original array.
+ * @param newArr - The new array to compare against.
+ * @returns An object containing the added and removed elements.
+ */
+export declare const difference: <T>(oldArr: T[], newArr: T[]) => ArrayDiffResult<T>;
+export interface ArrayDiffResult<T> {
+    /**
+     * Elements in `newArr` that are not in `oldArr`.
+     */
+    added: T[];
+    /**
+     * Elements in `oldArr` that are not in `newArr`.
+     */
+    removed: T[];
+}

package/lib/shared/utils/array.js

@@ -0,0 +1,30 @@
+export const removeAt = (arr, index) => {
+    if (index < 0 || index >= arr.length) {
+        throw new RangeError(`index ${index.toString()} is out of bounds for array of length ${arr.length.toString()}`);
+    }
+    return [...arr.slice(0, index), ...arr.slice(index + 1)];
+};
+export const insertAt = (arr, index, item) => {
+    if (index < 0 || index > arr.length) {
+        throw new RangeError(`index ${index.toString()} is out of bounds for array of length ${arr.length.toString()}`);
+    }
+    return [...arr.slice(0, index), item, ...arr.slice(index)];
+};
+/**
+ * Calculates the difference between two arrays, including duplicated values.
+ * @param oldArr - The original array.
+ * @param newArr - The new array to compare against.
+ * @returns An object containing the added and removed elements.
+ */
+export const difference = (oldArr, newArr) => newArr.reduce((acc, item) => {
+    const oldIndex = acc.removed.indexOf(item);
+    const newIndex = acc.added.indexOf(item);
+    if (oldIndex > -1) {
+        return {
+            ...acc,
+            removed: removeAt(acc.removed, oldIndex),
+            added: removeAt(acc.added, newIndex),
+        };
+    }
+    return acc;
+}, { removed: oldArr, added: newArr });

package/lib/shared/utils/displayName.d.ts

@@ -1,2 +1,2 @@
-import { SerializedEntityDecl } from "../../schema/index.js";
+import type { SerializedEntityDecl } from "../../node/schema/index.js";
 export declare const getDisplayNameFromEntityInstance: (entity: SerializedEntityDecl, instance: unknown, defaultName: string, locales?: string[]) => string;

package/lib/shared/utils/displayName.js

@@ -23,9 +23,11 @@ export const getDisplayNameFromEntityInstance = (entity, instance, defaultName,
         const availableLocales = Object.keys(localeMap ?? {});
         return availableLocales.length === 0
             ? defaultName
-            : locales.reduce((name, locale) => name ??
+            : (locales.reduce((name, locale) => name ??
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 getValueAtPath(localeMap[locale], pathInLocaleMap), undefined) ??
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 getValueAtPath(localeMap[availableLocales[0]], pathInLocaleMap) ??
-                defaultName;
+                defaultName);
     }
 };

package/lib/shared/utils/git.d.ts

@@ -0,0 +1,12 @@
+export type GitFileStatus = {
+    index: GitFileStatusCode;
+    workingDir: GitFileStatusCode;
+};
+export declare const isChangedInIndex: (fileStatus: GitFileStatus) => boolean;
+export declare const isChangedInWorkingDir: (fileStatus: GitFileStatus) => boolean;
+export type GitFileStatusCode = " " | "M" | "T" | "A" | "D" | "R" | "C" | "U" | "m" | "?" | "!";
+export declare const isUnchangedStatus: (code: GitFileStatusCode) => boolean;
+export type GitFileStatusForDisplay = "U" | "M" | "A" | "D" | "R" | undefined;
+export declare const hasFileChanges: (fileStatus: GitFileStatus | undefined) => boolean;
+export declare const getGitStatusForDisplay: (fileStatus: GitFileStatus | undefined) => GitFileStatusForDisplay;
+export declare const getLabelForGitStatus: (status: GitFileStatusForDisplay) => string;

package/lib/shared/utils/git.js

@@ -0,0 +1,98 @@
+export const isChangedInIndex = (fileStatus) => {
+    const { index } = fileStatus;
+    switch (index) {
+        case "M":
+        case "T":
+        case "A":
+        case "D":
+        case "R":
+        case "C":
+        case "U":
+            return true;
+        case " ":
+        case "m":
+        case "?":
+        case "!":
+            return false;
+    }
+};
+export const isChangedInWorkingDir = (fileStatus) => {
+    const { workingDir } = fileStatus;
+    switch (workingDir) {
+        case "M":
+        case "T":
+        case "A":
+        case "D":
+        case "R":
+        case "C":
+        case "U":
+        case "?":
+            return true;
+        case " ":
+        case "m":
+        case "!":
+            return false;
+    }
+};
+const unchangedStatusCodes = new Set([" ", "!", "C", "T", "m", "U"]);
+export const isUnchangedStatus = (code) => unchangedStatusCodes.has(code);
+export const hasFileChanges = (fileStatus) => {
+    if (fileStatus === undefined) {
+        return false;
+    }
+    const { index, workingDir } = fileStatus;
+    return !isUnchangedStatus(index) || !isUnchangedStatus(workingDir);
+};
+export const getGitStatusForDisplay = (fileStatus) => {
+    if (fileStatus === undefined) {
+        return undefined;
+    }
+    const { index, workingDir } = fileStatus;
+    switch (workingDir) {
+        case " ":
+            switch (index) {
+                case " ":
+                    return undefined;
+                case "M":
+                    return "M";
+                case "A":
+                    return "A";
+                case "D":
+                    return "D";
+                case "R":
+                    return "R";
+                case "?":
+                    return "U";
+                default:
+                    return undefined;
+            }
+        case "M":
+            return "M";
+        case "A":
+            return "A";
+        case "D":
+            return "D";
+        case "R":
+            return "R";
+        case "?":
+            return "U";
+        default:
+            return undefined;
+    }
+};
+export const getLabelForGitStatus = (status) => {
+    switch (status) {
+        case "U":
+            return "untracked";
+        case "M":
+            return "modified";
+        case "A":
+            return "sdded";
+        case "D":
+            return "deleted";
+        case "R":
+            return "renamed";
+        default:
+            return "";
+    }
+};

package/lib/shared/utils/instances.d.ts

@@ -1,6 +1,16 @@
+import type { SerializedEntityDecl } from "../../node/schema/index.js";
+import type { GitFileStatus } from "./git.js";
 export interface InstanceContainer {
     fileName: string;
     id: string;
     content: unknown;
+    gitStatus?: GitFileStatus;
 }
+export interface InstanceContainerOverview {
+    fileName: string;
+    id: string;
+    gitStatus?: GitFileStatus;
+    displayName: string;
+}
+export declare const getInstanceContainerOverview: (entity: SerializedEntityDecl, instanceContainer: InstanceContainer, locales?: string[]) => InstanceContainerOverview;
 export type InstancesByEntityName = Record<string, InstanceContainer[]>;

package/lib/shared/utils/instances.js

@@ -1 +1,8 @@
-export {};
+import { getDisplayNameFromEntityInstance } from "./displayName.js";
+export const getInstanceContainerOverview = (entity, instanceContainer, locales) => {
+    const { content: _, ...rest } = instanceContainer;
+    return {
+        ...rest,
+        displayName: getDisplayNameFromEntityInstance(entity, instanceContainer.content, instanceContainer.id, locales),
+    };
+};

package/lib/{utils → shared/utils}/lazy.js

@@ -1,4 +1,4 @@
-import { assertExhaustive } from "../shared/utils/typeSafety.js";
+import { assertExhaustive } from "./typeSafety.js";
 /**
  * A lazy value that is only evaluated when it is needed.
  */

package/lib/shared/utils/markdown.d.ts

@@ -0,0 +1,14 @@
+type TextNode = {
+    kind: "text";
+    content: string;
+};
+export type InlineMarkdownNode = {
+    kind: "bold" | "italic";
+    content: InlineMarkdownNode[];
+} | TextNode;
+export type BlockMarkdownNode = {
+    kind: "paragraph";
+    content: InlineMarkdownNode[];
+} | TextNode;
+export declare const parseBlockMarkdown: (text: string) => BlockMarkdownNode[];
+export {};

package/lib/shared/utils/markdown.js

@@ -0,0 +1,42 @@
+const boldWithItalicRule = {
+    pattern: /\*\*(.*?\*.+?\*.*?)\*\*/,
+    map: (result, parseInside) => ({ kind: "bold", content: parseInside(result[1] ?? "") }),
+};
+const italicWithBoldRule = {
+    pattern: /\*(.*?\*\*.+?\*\*.*?)\*/,
+    map: (result, parseInside) => ({ kind: "italic", content: parseInside(result[1] ?? "") }),
+};
+const boldRule = {
+    pattern: /\*\*(.+?)\*\*/,
+    map: (result, parseInside) => ({ kind: "bold", content: parseInside(result[1] ?? "") }),
+};
+const italicRule = {
+    pattern: /\*(.+?)\*/,
+    map: (result, parseInside) => ({ kind: "italic", content: parseInside(result[1] ?? "") }),
+};
+const rules = [boldWithItalicRule, italicWithBoldRule, boldRule, italicRule];
+export const parseBlockMarkdown = (text) => text.split(/\n{2,}/).map(par => ({ kind: "paragraph", content: parseInlineMarkdown(par) }));
+const parseForRules = (rules, text) => {
+    if (text.length === 0) {
+        return [];
+    }
+    const activeRule = rules[0];
+    if (activeRule === undefined) {
+        return [{ kind: "text", content: text }];
+    }
+    const res = activeRule.pattern.exec(text);
+    if (res && (activeRule.predicate?.(res) ?? true)) {
+        const { index } = res;
+        const before = text.slice(0, index);
+        const after = text.slice(index + res[0].length);
+        return [
+            ...(before.length > 0 ? parseForRules(rules.slice(1), before) : []),
+            activeRule.map(res, text => parseForRules(rules.slice(1), text)),
+            ...(after.length > 0 ? parseForRules(rules, after) : []),
+        ];
+    }
+    else {
+        return parseForRules(rules.slice(1), text);
+    }
+};
+const parseInlineMarkdown = (text) => parseForRules(rules, text);

package/lib/shared/utils/object.d.ts

@@ -1,2 +1,6 @@
 export declare const sortObjectKeys: (obj: Record<string, unknown>, keys: string[]) => Record<string, unknown>;
 export declare const sortObjectKeysAlphabetically: (obj: Record<string, unknown>) => Record<string, unknown>;
+export declare const mergeObjects: <T>(obj1: Record<string, T>, obj2: Record<string, T>, solveConflict: (a: T, b: T) => T) => Record<string, T>;
+export type Leaves<T> = T extends object ? {
+    [K in keyof T]: T[K] extends unknown[] ? never : `${Exclude<K, symbol>}${Leaves<T[K]> extends never ? "" : `.${Leaves<T[K]>}`}`;
+}[keyof T] : never;

package/lib/shared/utils/object.js

@@ -1,2 +1,7 @@
 export const sortObjectKeys = (obj, keys) => Object.fromEntries(keys.flatMap(key => (obj[key] === undefined ? [] : [[key, obj[key]]])));
 export const sortObjectKeysAlphabetically = (obj) => Object.fromEntries(Object.entries(obj).sort(([keyA], [keyB]) => keyA.localeCompare(keyB)));
+export const mergeObjects = (obj1, obj2, solveConflict) => Object.entries(obj2).reduce((acc, [key, value]) => ({
+    ...acc,
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    [key]: Object.hasOwn(acc, key) ? solveConflict(acc[key], value) : value,
+}), obj1);

package/lib/{utils → shared/utils}/result.js

@@ -24,11 +24,11 @@ export const reduce = (result, fok, ferror) => (isOk(result) ? fok(result.value)
 /**
  * Maps the value of a result to a new value.
  */
-export const map = (result, f) => (isOk(result) ? ok(f(result.value)) : result);
+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 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))

package/lib/shared/utils/string.d.ts

@@ -4,3 +4,4 @@ export declare const toCamelCase: (str: string) => string;
 export declare const toKebabCase: (str: string) => string;
 export declare const toSnakeCase: (str: string) => string;
 export declare const toTitleCase: (str: string) => string;
+export declare const commonPrefix: (...strs: string[]) => string;

package/lib/shared/utils/string.js

@@ -5,14 +5,17 @@ const separator = /[^a-z0-9]/;
 const lastChar = (str) => str[str.length - 1];
 const lastElement = (arr) => arr[arr.length - 1];
 const isAllUppercase = (str) => str === str.toUpperCase();
-export const splitStringParts = (str) => [...str].reduce((acc, char, i, strArr) => {
+export const splitStringParts = (str) => [...new Intl.Segmenter().segment(str)].reduce((acc, segment, i, strArr) => {
+    const char = segment.segment;
     if (acc.length === 0) {
         return letterOrDigit.test(char) ? [char] : acc;
     }
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const lastPart = lastElement(acc);
     if (uppercase.test(char)) {
         const lastCharOfLastPart = lastChar(lastPart);
-        const nextChar = strArr[i + 1];
+        const nextSegment = strArr[i + 1];
+        const nextChar = nextSegment?.segment;
         if (lastCharOfLastPart === undefined ||
             (uppercase.test(lastCharOfLastPart) && (nextChar === undefined || separator.test(nextChar)))) {
             return [...acc.slice(0, -1), lastPart + char];
@@ -47,6 +50,15 @@ export const toKebabCase = (str) => splitStringParts(str)
 export const toSnakeCase = (str) => splitStringParts(str)
     .map(part => part.toLowerCase())
     .join("_");
-export const toTitleCase = (str) => splitStringParts(str)
-    .map(part => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+export const toTitleCase = (str) => splitStringParts(isAllUppercase(str) ? str.toLowerCase() : str)
+    .map(part => isAllUppercase(part) ? part : part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
     .join(" ");
+export const commonPrefix = (...strs) => {
+    if (strs.length === 0) {
+        return "";
+    }
+    return strs.reduce((accPrefix, str) => {
+        const indexOfDifference = Array.from(accPrefix).findIndex((char, i) => str[i] !== char);
+        return indexOfDifference === -1 ? accPrefix : accPrefix.slice(0, indexOfDifference);
+    });
+};

package/lib/shared/utils/validation.js

@@ -1,14 +1,15 @@
 import { gte, lte } from "./compare.js";
 export const parallelizeErrors = (errors) => errors.filter(error => error !== undefined);
+const normalizeLabel = (label) => Array.isArray(label) ? label : [label, label + "s"];
 export const validateLengthRangeBound = (end, label, rangeBound, value) => {
     if (rangeBound === undefined) {
         return;
     }
     const [operator, description] = end === "lower" ? [gte, "least"] : [lte, "most"];
     const length = value.length;
-    const normalizedLabel = Array.isArray(label) ? label : [label, label + "s"];
+    const normalizedLabel = normalizeLabel(label);
     if (!operator(length, rangeBound)) {
-        return RangeError(`Expected at ${description} ${rangeBound} ${normalizedLabel[rangeBound === 1 ? 0 : 1]}, but got ${length} ${normalizedLabel[length === 1 ? 0 : 1]}`);
+        return RangeError(`expected at ${description} ${rangeBound.toString()} ${normalizedLabel[rangeBound === 1 ? 0 : 1]}, but got ${length.toString()} ${normalizedLabel[length === 1 ? 0 : 1]}`);
     }
     return;
 };

package/lib/shared/validation/number.js

@@ -18,8 +18,8 @@ export const validateRangeBound = (end, rangeBound, value) => {
         : normalizedRangeBound.isExclusive
             ? [lt, "less than"]
             : [lte, "less than or equal"];
-    if (operator(value, normalizedRangeBound.value)) {
-        return RangeError(`expected a value ${description} ${normalizedRangeBound.value}, but got ${value}`);
+    if (!operator(value, normalizedRangeBound.value)) {
+        return RangeError(`expected a value ${description} ${normalizedRangeBound.value.toString()}, but got ${value.toString()}`);
     }
     return;
 };
@@ -28,7 +28,7 @@ export const validateMultipleOf = (multipleOf, value) => {
         return;
     }
     if (value % multipleOf !== 0) {
-        return RangeError(`expected a value that is a multiple of ${multipleOf}, but got ${value}`);
+        return RangeError(`expected a value that is a multiple of ${multipleOf.toString()}, but got ${value.toString()}`);
     }
     return;
 };

package/lib/shared/validation/object.js

@@ -1,11 +1,12 @@
 import { parallelizeErrors, validateLengthRangeBound } from "../utils/validation.js";
 export const validateObjectConstraints = (constraints, expectedKeys, value) => {
     const label = ["property", "properties"];
+    const actualKeys = Object.keys(value);
     return parallelizeErrors([
-        validateLengthRangeBound("lower", label, constraints.minProperties, expectedKeys),
-        validateLengthRangeBound("upper", label, constraints.maxProperties, expectedKeys),
+        validateLengthRangeBound("lower", label, constraints.minProperties, actualKeys),
+        validateLengthRangeBound("upper", label, constraints.maxProperties, actualKeys),
         ...(constraints.additionalProperties !== true
-            ? Object.keys(value).flatMap(valueKey => expectedKeys.includes(valueKey)
+            ? actualKeys.flatMap(valueKey => expectedKeys.includes(valueKey)
                 ? []
                 : [TypeError(`object does not allow unknown keys and key "${valueKey}" is not known`)])
             : []),

package/lib/shared/validation/string.js

@@ -1,15 +1,20 @@
 import { parallelizeErrors } from "../utils/validation.js";
 export const validateStringConstraints = (constraints, value) => parallelizeErrors([
     constraints.minLength !== undefined && value.length < constraints.minLength
-        ? RangeError(`expected a string with at least ${constraints.minLength} character${constraints.minLength === 1 ? "" : "s"}, but got ${value.length} character${value.length === 1 ? "" : "s"}`)
+        ? RangeError(`expected a string with at least ${constraints.minLength.toString()} character${constraints.minLength === 1 ? "" : "s"}, but got ${value.length.toString()} character${value.length === 1 ? "" : "s"}`)
         : undefined,
     constraints.maxLength !== undefined && value.length > constraints.maxLength
-        ? RangeError(`expected a string with at most ${constraints.maxLength} character${constraints.maxLength === 1 ? "" : "s"}, but got ${value.length} character${value.length === 1 ? "" : "s"}`)
+        ? RangeError(`expected a string with at most ${constraints.maxLength.toString()} character${constraints.maxLength === 1 ? "" : "s"}, but got ${value.length.toString()} character${value.length === 1 ? "" : "s"}`)
         : undefined,
-    constraints.pattern !== undefined &&
-        !(typeof constraints.pattern === "string"
+    (() => {
+        if (constraints.pattern === undefined) {
+            return undefined;
+        }
+        const pattern = typeof constraints.pattern === "string"
             ? new RegExp(constraints.pattern)
-            : constraints.pattern).test(value)
-        ? TypeError(`string does not match the pattern ${constraints.pattern}`)
-        : undefined,
+            : constraints.pattern;
+        return !pattern.test(value)
+            ? TypeError(`string does not match the pattern ${pattern.toString()}`)
+            : undefined;
+    })(),
 ]);

package/lib/web/api.d.ts

@@ -0,0 +1,24 @@
+import type { SerializedEntityDecl } from "../node/schema/declarations/EntityDecl.js";
+import type { CreateInstanceOfEntityResponseBody, DeleteInstanceOfEntityResponseBody, GetAllDeclarationsResponseBody, GetAllGitBranchesResponseBody, GetAllInstancesOfEntityResponseBody, GetAllInstancesResponseBody, GetDeclarationResponseBody, GetInstanceOfEntityResponseBody, GitStatusResponseBody, UpdateInstanceOfEntityResponseBody } from "../shared/api.js";
+export declare const getAllDeclarations: (kind?: "Entity" | "Enum" | "TypeAlias") => Promise<GetAllDeclarationsResponseBody>;
+export declare const getAllEntities: () => Promise<GetAllDeclarationsResponseBody<SerializedEntityDecl>>;
+export declare const getEntityByName: (name: string) => Promise<GetDeclarationResponseBody<SerializedEntityDecl>>;
+export declare const getInstancesByEntityName: (name: string) => Promise<GetAllInstancesOfEntityResponseBody>;
+export declare const createInstanceByEntityNameAndId: (name: string, content: unknown, id?: string) => Promise<CreateInstanceOfEntityResponseBody>;
+export declare const getInstanceByEntityNameAndId: (name: string, id: string) => Promise<GetInstanceOfEntityResponseBody>;
+export declare const updateInstanceByEntityNameAndId: (name: string, id: string, content: unknown) => Promise<UpdateInstanceOfEntityResponseBody>;
+export declare const deleteInstanceByEntityNameAndId: (name: string, id: string) => Promise<DeleteInstanceOfEntityResponseBody>;
+export declare const getAllInstances: (locales: string[]) => Promise<GetAllInstancesResponseBody>;
+export declare const getGitStatus: (locales: string[]) => Promise<GitStatusResponseBody>;
+export declare const stageAllFiles: () => Promise<void>;
+export declare const stageAllFilesOfEntity: (entityName: string) => Promise<void>;
+export declare const stageFileOfEntity: (entityName: string, id: string) => Promise<void>;
+export declare const unstageAllFiles: () => Promise<void>;
+export declare const unstageAllFilesOfEntity: (entityName: string) => Promise<void>;
+export declare const unstageFileOfEntity: (entityName: string, id: string) => Promise<void>;
+export declare const commitStagedFiles: (message: string) => Promise<DeleteInstanceOfEntityResponseBody>;
+export declare const pushCommits: () => Promise<DeleteInstanceOfEntityResponseBody>;
+export declare const pullCommits: () => Promise<DeleteInstanceOfEntityResponseBody>;
+export declare const getBranches: () => Promise<GetAllGitBranchesResponseBody>;
+export declare const createBranch: (branchName: string) => Promise<void>;
+export declare const switchBranch: (branchName: string) => Promise<void>;