tsondb 0.12.5 → 0.12.7

package/dist/src/node/schema/declarations/EntityDecl.d.ts

@@ -1,28 +1,30 @@
 import { Lazy } from "../../../shared/utils/lazy.ts";
-import type { Leaves } from "../../../shared/utils/object.ts";
 import type { DisplayNameCustomizer } from "../../utils/displayName.ts";
-import type { GetNestedDeclarations, GetReferences, Predicate, Serializer, TypeArgumentsResolver, Validator } from "../Node.ts";
+import type { GetNestedDeclarations, GetReferences, Predicate, Serialized, TypeArgumentsResolver, Validator } from "../Node.ts";
 import { NodeKind } from "../Node.ts";
 import type { MemberDecl, ObjectType } from "../types/generic/ObjectType.ts";
 import { StringType } from "../types/primitives/StringType.ts";
-import type { AsType } from "../types/Type.ts";
+import type { NestedEntityMapType } from "../types/references/NestedEntityMapType.ts";
 import type { BaseDecl } from "./Declaration.ts";
 import { TypeAliasDecl } from "./TypeAliasDecl.ts";
 export type GenericEntityDisplayName = string | {
     pathToLocaleMap?: string;
     pathInLocaleMap?: string;
 } | null;
-export type EntityDisplayName<T extends TConstraint> = Leaves<AsType<ObjectType<T>>> | {
+export type EntityDisplayName<T extends TConstraint> = PathTo<T, StringType> | {
     /**
      * @default "translations"
      */
-    pathToLocaleMap?: Leaves<AsType<ObjectType<T>>>;
+    pathToLocaleMap?: PathTo<T, NestedEntityMapType>;
     /**
      * @default "name"
      */
     pathInLocaleMap?: string;
 } | null;
 type TConstraint = Record<string, MemberDecl>;
+type PathTo<T extends TConstraint, R> = {
+    [K in keyof T]: T[K] extends MemberDecl<infer V> ? V extends R ? K : R extends V ? string : T[K] extends ObjectType<infer P> ? `${Extract<K, string>}.${PathTo<P, R>}` : never : never;
+}[Extract<keyof T, string>];
 export interface EntityDecl<Name extends string = string, T extends TConstraint = TConstraint, FK extends Extract<keyof T, string> | undefined = Extract<keyof T, string> | undefined> extends BaseDecl<Name, []> {
     kind: NodeKind["EntityDecl"];
     namePlural: string;
@@ -31,7 +33,7 @@ export interface EntityDecl<Name extends string = string, T extends TConstraint
     /**
      * @default "name"
      */
-    displayName?: EntityDisplayName<T>;
+    displayName?: GenericEntityDisplayName;
     displayNameCustomizer?: DisplayNameCustomizer<ObjectType<T>>;
     isDeprecated?: boolean;
 }
@@ -75,5 +77,5 @@ export declare const addEphemeralUUIDToType: <T extends TConstraint>(decl: Entit
 }>;
 export declare const createEntityIdentifierType: () => StringType;
 export declare const createEntityIdentifierTypeAsDecl: <Name extends string>(decl: EntityDecl<Name>) => TypeAliasDecl<`${Name}_ID`, StringType, []>;
-export declare const serializeEntityDecl: Serializer<EntityDecl>;
+export declare const serializeEntityDecl: <Name extends string, T extends TConstraint, FK extends Extract<keyof T, string> | undefined>(type: EntityDecl<Name, T, FK>) => Serialized<EntityDecl<Name, T, FK>>;
 export declare const getReferencesForEntityDecl: GetReferences<EntityDecl>;

package/dist/src/node/schema/declarations/EntityDecl.js

@@ -49,12 +49,12 @@ export const createEntityIdentifierTypeAsDecl = (decl) => TypeAliasDecl(decl.sou
     name: (decl.name + "_ID"),
     type: createEntityIdentifierType,
 });
-export const serializeEntityDecl = (type) => ({
+export const serializeEntityDecl = ((type) => ({
     ...type,
     type: serializeObjectType(type.type.value),
     displayName: typeof type.displayName === "function"
         ? null
         : type.displayName,
     displayNameCustomizer: type.displayNameCustomizer !== undefined,
-});
+}));
 export const getReferencesForEntityDecl = (decl, value, inDecl) => getReferencesForObjectType(decl.type.value, value, [...inDecl, decl]);

package/dist/src/node/schema/declarations/EnumDecl.d.ts

@@ -1,3 +1,4 @@
+import { type EnumValue } from "../../../shared/schema/declarations/EnumDecl.ts";
 import { Lazy } from "../../../shared/utils/lazy.ts";
 import type { GetNestedDeclarations, GetReferences, Predicate, Serializer, TypeArgumentsResolver, ValidatorOfParamDecl } from "../Node.ts";
 import { NodeKind } from "../Node.ts";
@@ -33,3 +34,4 @@ export declare const resolveTypeArgumentsInEnumDecl: TypeArgumentsResolver<EnumD
 export declare const serializeEnumDecl: Serializer<EnumDecl>;
 export declare const getReferencesForEnumDecl: GetReferences<EnumDecl>;
 export declare const cases: <T extends TConstraint>(decl: EnumDecl<string, T>) => EnumCaseDecl<T[keyof T]["type"]>[];
+export declare const getAnyEnumCaseValue: <K extends string, V>(enumValue: { [Key in K]: EnumValue<Key, V>; }[K]) => V;

package/dist/src/node/schema/declarations/EnumDecl.js

@@ -1,3 +1,4 @@
+import { ENUM_DISCRIMINATOR_KEY, } from "../../../shared/schema/declarations/EnumDecl.js";
 import { Lazy } from "../../../shared/utils/lazy.js";
 import { onlyKeys } from "../../../shared/utils/object.js";
 import { NodeKind } from "../Node.js";
@@ -46,3 +47,4 @@ export const serializeEnumDecl = decl => ({
 });
 export const getReferencesForEnumDecl = (decl, value, inDecl) => getReferencesForEnumType(decl.type.value, value, [...inDecl, decl]);
 export const cases = (decl) => Object.values(decl.type.value.values);
+export const getAnyEnumCaseValue = (enumValue) => enumValue[enumValue[ENUM_DISCRIMINATOR_KEY]];

package/dist/src/node/schema/types/Type.d.ts

@@ -25,14 +25,28 @@ type EnumCaseTypeAsType<Case extends string, T extends Type | null> = T extends
 } : {
     kind: Case;
 };
-export type AsDeepType<T extends Type> = T extends ArrayType<infer I> ? AsType<I>[] : T extends ObjectType<infer P> ? {
+type EnumCaseTypeAsDeepType<Case extends string, T extends Type | null> = T extends object ? {
+    kind: Case;
+} & {
+    [AV in Case]: AsDeepType<T>;
+} : {
+    kind: Case;
+};
+type MemberDeclsAsType<P extends Record<string, MemberDecl>> = {
     [K in keyof P]: P[K] extends MemberDecl<Type, true> ? AsType<P[K]["type"]> : AsType<P[K]["type"]> | undefined;
-} : T extends BooleanType ? boolean : T extends DateType ? Date : T extends FloatType ? number : T extends IntegerType ? number : T extends StringType ? string : T extends TypeArgumentType ? unknown : T extends IncludeIdentifierType<TypeParameter[], infer Decl> ? Decl extends TypeAliasDecl<string, infer TA> ? AsType<TA> : Decl extends EnumDecl<string, infer EC> ? AsType<EnumType<EC>> : unknown : T extends NestedEntityMapType ? unknown : T extends ReferenceIdentifierType ? string : T extends ChildEntitiesType ? string[] : T extends EnumType<infer EC> ? EC extends Record<string, EnumCaseDecl> ? {
-    [Case in keyof EC]: EnumCaseTypeAsType<Case & string, EC[Case]["type"]>;
+};
+type MemberDeclsAsDeepType<P extends Record<string, MemberDecl>> = {
+    [K in keyof P]: P[K] extends MemberDecl<Type, true> ? AsDeepType<P[K]["type"]> : // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents -- it does make a difference here
+    AsDeepType<P[K]["type"]> | undefined;
+};
+export type AsDeepType<T extends Type> = T extends ArrayType<infer I> ? AsDeepType<I>[] : T extends ObjectType<infer P> ? MemberDeclsAsDeepType<P> : T extends BooleanType ? boolean : T extends DateType ? Date : T extends FloatType ? number : T extends IntegerType ? number : T extends StringType ? string : T extends TypeArgumentType ? unknown : T extends IncludeIdentifierType<TypeParameter[], infer Decl> ? Decl extends TypeAliasDecl<string, infer TA> ? AsDeepType<TA> : Decl extends EnumDecl<string, infer EC> ? AsDeepType<EnumType<EC>> : unknown : T extends NestedEntityMapType<string, infer TC> ? {
+    [id: string]: MemberDeclsAsDeepType<TC>;
+} : T extends ReferenceIdentifierType ? string : T extends ChildEntitiesType ? never : T extends EnumType<infer EC> ? EC extends Record<string, EnumCaseDecl> ? {
+    [Case in keyof EC]: EnumCaseTypeAsDeepType<Case & string, EC[Case]["type"]>;
 }[keyof EC] : never : never;
-export type AsType<T extends Type> = T extends ArrayType<infer I> ? AsType<I>[] : T extends ObjectType<infer P> ? {
-    [K in keyof P]: P[K] extends MemberDecl<Type, true> ? AsType<P[K]["type"]> : AsType<P[K]["type"]> | undefined;
-} : T extends BooleanType ? boolean : T extends DateType ? Date : T extends FloatType ? number : T extends IntegerType ? number : T extends StringType ? string : T extends TypeArgumentType ? unknown : T extends IncludeIdentifierType ? unknown : T extends NestedEntityMapType ? unknown : T extends ReferenceIdentifierType ? string : T extends ChildEntitiesType ? string[] : T extends EnumType<infer EC> ? EC extends Record<string, EnumCaseDecl> ? {
+export type AsType<T extends Type> = T extends ArrayType<infer I> ? AsType<I>[] : T extends ObjectType<infer P> ? MemberDeclsAsType<P> : T extends BooleanType ? boolean : T extends DateType ? Date : T extends FloatType ? number : T extends IntegerType ? number : T extends StringType ? string : T extends TypeArgumentType ? unknown : T extends IncludeIdentifierType ? unknown : T extends NestedEntityMapType<string, infer TC> ? {
+    [id: string]: MemberDeclsAsType<TC>;
+} : T extends ReferenceIdentifierType ? string : T extends ChildEntitiesType ? string[] : T extends EnumType<infer EC> ? EC extends Record<string, EnumCaseDecl> ? {
     [Case in keyof EC]: EnumCaseTypeAsType<Case & string, EC[Case]["type"]>;
 }[keyof EC] : never : never;
 export type AsNode<T> = T extends (infer I)[] ? ArrayType<AsNode<I>> : T extends Record<string, unknown> ? ObjectType<{

package/dist/src/node/schema/types/primitives/FloatType.d.ts

@@ -2,10 +2,13 @@ import type { NumberConstraints } from "../../../../shared/validation/number.ts"
 import type { GetNestedDeclarations, GetReferences, Predicate, Serializer, TypeArgumentsResolver, Validator } from "../../Node.ts";
 import { NodeKind } from "../../Node.ts";
 import type { BaseType, StructureFormatter } from "../Type.ts";
-export interface FloatType extends BaseType, NumberConstraints {
+export interface FloatConstraints extends NumberConstraints {
+    fractionDigits?: number;
+}
+export interface FloatType extends BaseType, FloatConstraints {
     kind: NodeKind["FloatType"];
 }
-export declare const FloatType: (options?: NumberConstraints) => FloatType;
+export declare const FloatType: (options?: FloatConstraints) => FloatType;
 export { FloatType as Float };
 export declare const isFloatType: Predicate<FloatType>;
 export declare const getNestedDeclarationsInFloatType: GetNestedDeclarations<FloatType>;

package/dist/src/node/schema/types/primitives/FloatType.js

@@ -1,10 +1,16 @@
 import { validateNumberConstraints } from "../../../../shared/validation/number.js";
 import { json } from "../../../utils/errorFormatting.js";
 import { NodeKind } from "../../Node.js";
-export const FloatType = (options = {}) => ({
-    ...options,
-    kind: NodeKind.FloatType,
-});
+export const FloatType = (options = {}) => {
+    if (options.fractionDigits !== undefined &&
+        (!Number.isInteger(options.fractionDigits) || options.fractionDigits < 1)) {
+        throw new TypeError("The fractionDigits option must be a positive integer");
+    }
+    return {
+        ...options,
+        kind: NodeKind.FloatType,
+    };
+};
 export { FloatType as Float };
 export const isFloatType = node => node.kind === NodeKind.FloatType;
 export const getNestedDeclarationsInFloatType = addedDecls => addedDecls;

package/dist/src/node/server/api/git.js

@@ -4,6 +4,7 @@ import { join } from "node:path";
 import { hasFileChanges, splitBranchName } from "../../../shared/utils/git.js";
 import { getInstanceContainerOverview } from "../../../shared/utils/instances.js";
 import { getGroupedInstancesFromDatabaseInMemory } from "../../utils/databaseInMemory.js";
+import { attachGitStatusToDatabaseInMemory } from "../../utils/git.js";
 import { reinit } from "../init.js";
 import { createChildInstancesForInstanceIdGetter } from "../utils/childInstances.js";
 const debug = Debug("tsondb:server:api:git");
@@ -24,6 +25,9 @@ gitApi.get("/", (req, res) => {
 });
 gitApi.get("/status", async (req, res) => {
     const status = await req.git.status();
+    req.setLocal("databaseInMemory", attachGitStatusToDatabaseInMemory(req.databaseInMemory, req.dataRoot, 
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    req.gitRoot, status));
     const getChildInstancesForInstanceId = createChildInstancesForInstanceIdGetter(req);
     const body = {
         currentBranch: status.current,

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

@@ -2,10 +2,12 @@ import express from "express";
 import { declarationsApi } from "./declarations.js";
 import { gitApi } from "./git.js";
 import { instancesApi } from "./instances.js";
+import { searchApi } from "./search.js";
 export const api = express.Router();
 api.use("/declarations", declarationsApi);
 api.use("/instances", instancesApi);
 api.use("/git", gitApi);
+api.use("/search", searchApi);
 api.get("/config", (req, res) => {
     const body = {
         localeEntityName: req.localeEntity?.name,

package/dist/src/node/server/api/search.d.ts

@@ -0,0 +1 @@
+export declare const searchApi: import("express-serve-static-core").Router;

package/dist/src/node/server/api/search.js

@@ -0,0 +1,50 @@
+import Debug from "debug";
+import express from "express";
+import { isEntityDeclWithParentReference } from "../../schema/index.js";
+import { getGroupedInstancesFromDatabaseInMemory } from "../../utils/databaseInMemory.js";
+import { getDisplayNameFromEntityInstance } from "../../utils/displayName.js";
+import { createChildInstancesForInstanceIdGetter } from "../utils/childInstances.js";
+import { getQueryParamString } from "../utils/query.js";
+const debug = Debug("tsondb:server:api:search");
+export const searchApi = express.Router();
+searchApi.get("/", (req, res) => {
+    const query = getQueryParamString(req.query, "q")?.toLowerCase() ?? "";
+    debug('search for items containing "%s"', query);
+    const getChildInstancesForInstanceId = createChildInstancesForInstanceIdGetter(req);
+    const body = {
+        query,
+        results: query.length === 0
+            ? []
+            : getGroupedInstancesFromDatabaseInMemory(req.databaseInMemory)
+                .flatMap(([entityName, instances]) => {
+                const entity = req.entitiesByName[entityName];
+                if (entity && isEntityDeclWithParentReference(entity)) {
+                    return [];
+                }
+                return instances
+                    .map((instance) => {
+                    const { name, localeId } = getDisplayNameFromEntityInstance(
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    req.entitiesByName[entityName], instance, req.getInstanceById, getChildInstancesForInstanceId, req.locales);
+                    const searchableName = name.toLowerCase();
+                    return [
+                        entityName,
+                        {
+                            id: instance.id,
+                            displayName: name,
+                            displayNameLocaleId: localeId,
+                            relevance: instance.id.startsWith(query) || searchableName.startsWith(query)
+                                ? 1
+                                : instance.id.includes(query) || searchableName.includes(query)
+                                    ? 0.5
+                                    : 0,
+                        },
+                    ];
+                })
+                    .filter(instance => instance[1].relevance > 0);
+            })
+                .toSorted((a, b) => a[1].relevance - b[1].relevance ||
+                a[1].displayName.localeCompare(b[1].displayName, a[1].displayNameLocaleId)),
+    };
+    res.json(body);
+});

package/dist/src/node/server/utils/instanceOperations.js

@@ -8,7 +8,7 @@ export const createInstance = async (locals, instance, idQueryParam) => {
     if (entity === undefined) {
         return error(new HTTPError(400, "Entity not found"));
     }
-    const databaseTransactionResult = await runDatabaseTransaction(locals.dataRoot, locals.gitRoot ? locals.git : undefined, locals.entitiesByName, locals.databaseInMemory, locals.referencesToInstances, res => saveInstanceTree(locals.entitiesByName, undefined, locals.localeEntity, instance.entityName, undefined, instance, idQueryParam, res));
+    const databaseTransactionResult = await runDatabaseTransaction(locals.dataRoot, locals.gitRoot ? locals.git : undefined, locals.entitiesByName, locals.databaseInMemory, locals.referencesToInstances, res => saveInstanceTree(locals.entitiesByName, undefined, undefined, locals.localeEntity, instance.entityName, undefined, instance, idQueryParam, res));
     if (isError(databaseTransactionResult)) {
         return databaseTransactionResult;
     }
@@ -27,7 +27,7 @@ export const updateInstance = async (locals, instance) => {
         return error(new HTTPError(400, "Entity not found"));
     }
     const oldChildInstances = getChildInstances(locals.databaseInMemory, entity, instance.id, true);
-    const databaseTransactionResult = await runDatabaseTransaction(locals.dataRoot, locals.gitRoot ? locals.git : undefined, locals.entitiesByName, locals.databaseInMemory, locals.referencesToInstances, res => saveInstanceTree(locals.entitiesByName, undefined, locals.localeEntity, instance.entityName, {
+    const databaseTransactionResult = await runDatabaseTransaction(locals.dataRoot, locals.gitRoot ? locals.git : undefined, locals.entitiesByName, locals.databaseInMemory, locals.referencesToInstances, res => saveInstanceTree(locals.entitiesByName, undefined, undefined, locals.localeEntity, instance.entityName, {
         id: instance.id,
         content: instanceContainer.content,
         childInstances: oldChildInstances,
@@ -51,7 +51,7 @@ export const deleteInstance = async (locals, entityName, instanceId) => {
         return error(new HTTPError(400, "Entity not found"));
     }
     const oldChildInstances = getChildInstances(locals.databaseInMemory, entity, instanceId, true);
-    const databaseTransactionResult = await runDatabaseTransaction(locals.dataRoot, locals.gitRoot ? locals.git : undefined, locals.entitiesByName, locals.databaseInMemory, locals.referencesToInstances, res => saveInstanceTree(locals.entitiesByName, undefined, locals.localeEntity, entityName, {
+    const databaseTransactionResult = await runDatabaseTransaction(locals.dataRoot, locals.gitRoot ? locals.git : undefined, locals.entitiesByName, locals.databaseInMemory, locals.referencesToInstances, res => saveInstanceTree(locals.entitiesByName, undefined, undefined, locals.localeEntity, entityName, {
         id: instanceId,
         content: instanceContainer.content,
         childInstances: oldChildInstances,

package/dist/src/node/server/utils/query.d.ts

@@ -0,0 +1,2 @@
+import type { Request } from "express";
+export declare const getQueryParamString: (parsedQueryString: Request["query"], key: string) => string | undefined;

package/dist/src/node/server/utils/query.js

@@ -0,0 +1,7 @@
+export const getQueryParamString = (parsedQueryString, key) => {
+    const value = parsedQueryString[key];
+    if (typeof value === "string") {
+        return value;
+    }
+    return;
+};

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

@@ -29,6 +29,6 @@ export interface GenEntityTaggedInstanceContainerWithChildInstances<ID extends s
 }
 export declare const getChildInstancesFromEntity: (databaseInMemory: DatabaseInMemory, parentEntity: EntityDecl, parentId: string, childEntity: EntityDeclWithParentReference) => InstanceContainer[];
 export declare const getChildInstances: (databaseInMemory: DatabaseInMemory, parentEntity: EntityDecl, parentId: string, recursive?: boolean) => EntityTaggedInstanceContainerWithChildInstances[];
-export declare const saveInstanceTree: (entitiesByName: Record<string, EntityDecl>, parentId: string | undefined, localeEntity: EntityDecl | undefined, entityName: string, oldInstance: EntityTaggedInstanceContainerWithChildInstances | undefined, newInstance: UnsafeEntityTaggedInstanceContainerWithChildInstances | undefined, customId: unknown, res: TransactionResult) => TransactionResult<{
+export declare const saveInstanceTree: (entitiesByName: Record<string, EntityDecl>, parentEntityName: string | undefined, parentId: string | undefined, localeEntity: EntityDecl | undefined, entityName: string, oldInstance: EntityTaggedInstanceContainerWithChildInstances | undefined, newInstance: UnsafeEntityTaggedInstanceContainerWithChildInstances | undefined, customId: unknown, res: TransactionResult) => TransactionResult<{
     instanceContainer: InstanceContainer;
 }>;

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

@@ -1,6 +1,7 @@
+import { createEnumCaseValue } from "../../shared/schema/declarations/EnumDecl.js";
 import { hasKey } from "../../shared/utils/object.js";
 import { error, isError, map, ok } from "../../shared/utils/result.js";
-import { isEntityDeclWithParentReference, reduceNodes } from "../schema/index.js";
+import { isEntityDeclWithParentReference, isEnumDecl, isIncludeIdentifierType, reduceNodes, } from "../schema/index.js";
 import { isChildEntitiesType } from "../schema/types/references/ChildEntitiesType.js";
 import { getInstancesOfEntityFromDatabaseInMemory, } from "./databaseInMemory.js";
 import { HTTPError } from "./error.js";
@@ -30,21 +31,26 @@ export const getChildInstances = (databaseInMemory, parentEntity, parentId, recu
             : [],
     })));
 };
-const prepareNewChildInstanceContent = (entity, parentId, content) => {
+const prepareNewChildInstanceContent = (entity, parentEntityName, parentId, content) => {
     if (isEntityDeclWithParentReference(entity)) {
-        if (parentId === undefined) {
+        if (parentEntityName === undefined || parentId === undefined) {
             return error(new HTTPError(400, `Cannot create instance of child entity "${entity.name}" without parent reference`));
         }
+        const parentReferenceType = entity.type.value.properties[entity.parentReferenceKey]?.type;
         return ok({
             ...content,
-            [entity.parentReferenceKey]: parentId,
+            [entity.parentReferenceKey]: parentReferenceType &&
+                isIncludeIdentifierType(parentReferenceType) &&
+                isEnumDecl(parentReferenceType.reference)
+                ? createEnumCaseValue(parentEntityName, parentId)
+                : parentId,
         });
     }
     else {
         return ok(content);
     }
 };
-export const saveInstanceTree = (entitiesByName, parentId, localeEntity, entityName, oldInstance, newInstance, customId, res) => {
+export const saveInstanceTree = (entitiesByName, parentEntityName, parentId, localeEntity, entityName, oldInstance, newInstance, customId, res) => {
     if (isError(res)) {
         return res;
     }
@@ -59,14 +65,14 @@ export const saveInstanceTree = (entitiesByName, parentId, localeEntity, entityN
         }
         // delete all child instances recursively
         const deletedRes = deleteInstance(res, entity, oldInstance.id);
-        return map(oldInstance.childInstances.reduce((resAcc, oldChildInstance) => saveInstanceTree(entitiesByName, oldInstance.id, localeEntity, oldInstance.entityName, oldChildInstance, undefined, undefined, resAcc), deletedRes), data => ({
+        return map(oldInstance.childInstances.reduce((resAcc, oldChildInstance) => saveInstanceTree(entitiesByName, oldInstance.entityName, oldInstance.id, localeEntity, oldChildInstance.entityName, oldChildInstance, undefined, undefined, resAcc), deletedRes), data => ({
             ...data,
             instanceContainer: { id: oldInstance.id, content: oldInstance.content },
         }));
     }
     else {
         const preparedContent = newInstance.id === undefined
-            ? prepareNewChildInstanceContent(entity, parentId, newInstance.content)
+            ? prepareNewChildInstanceContent(entity, parentEntityName, parentId, newInstance.content)
             : ok(newInstance.content);
         if (isError(preparedContent)) {
             return preparedContent;
@@ -85,8 +91,8 @@ export const saveInstanceTree = (entitiesByName, parentId, localeEntity, entityN
         const setResWithoutInfo = ok({ ...setRes.value, additionalInformation: undefined });
         return map(newInstance.childInstances
             .filter(newChildInstance => newChildInstance.id === undefined)
-            .reduce((resAcc, newChildInstance) => saveInstanceTree(entitiesByName, instanceId, localeEntity, newChildInstance.entityName, undefined, newChildInstance, undefined, resAcc), oldInstance
-            ? oldInstance.childInstances.reduce((resAcc, oldChildInstance) => saveInstanceTree(entitiesByName, instanceId, localeEntity, oldChildInstance.entityName, oldChildInstance, newInstance.childInstances.find(ci => ci.id === oldChildInstance.id), undefined, resAcc), setResWithoutInfo)
+            .reduce((resAcc, newChildInstance) => saveInstanceTree(entitiesByName, newInstance.entityName, instanceId, localeEntity, newChildInstance.entityName, undefined, newChildInstance, undefined, resAcc), oldInstance
+            ? oldInstance.childInstances.reduce((resAcc, oldChildInstance) => saveInstanceTree(entitiesByName, oldInstance.entityName, instanceId, localeEntity, oldChildInstance.entityName, oldChildInstance, newInstance.childInstances.find(ci => ci.id === oldChildInstance.id), undefined, resAcc), setResWithoutInfo)
             : setResWithoutInfo), data => ({
             ...data,
             instanceContainer: { id: instanceId, content: preparedContent.value },

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

@@ -4,6 +4,7 @@ export const getDisplayNameFromEntityInstance = (entity, instanceContainer, getI
     if (useCustomizer && entity.displayNameCustomizer) {
         const calculatedName = getDisplayNameFromEntityInstance(entity, instanceContainer, getInstanceById, getChildInstancesForInstanceId, locales, defaultName, false);
         return entity.displayNameCustomizer({
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment -- otherwise type instiatiation too deep
             instance: instanceContainer.content,
             instanceId: instanceContainer.id,
             instanceDisplayName: calculatedName.name,

package/dist/src/shared/api.d.ts

@@ -87,3 +87,7 @@ export interface CreateCommitRequestBody {
 export interface CreateBranchRequestBody {
     branchName: string;
 }
+export interface SearchResponseBody {
+    query: string;
+    results: [entityName: string, instane: InstanceContainerOverview][];
+}

package/dist/src/shared/schema/declarations/EntityDecl.d.ts

@@ -1,20 +1,24 @@
-import type { Leaves } from "../../../shared/utils/object.ts";
+import type { GenericEntityDisplayName } from "../../../node/schema/index.ts";
 import { NodeKind, type GetReferencesSerialized, type SerializedNode, type SerializedTypeArgumentsResolver } from "../Node.ts";
+import type { SerializedNestedEntityMapType } from "../types/NestedEntityMapType.ts";
 import { type SerializedMemberDecl, type SerializedObjectType } from "../types/ObjectType.ts";
-import type { SerializedAsType } from "../types/Type.ts";
+import type { SerializedStringType } from "../types/StringType.ts";
 import type { SerializedBaseDecl } from "./Declaration.ts";
-export type SerializedEntityDisplayName<T extends SerializedObjectType> = Leaves<SerializedAsType<T>> | {
+export type SerializedEntityDisplayName<T extends TSerializedConstraint> = SerializedPathTo<T, SerializedStringType> | {
     /**
      * @default "translations"
      */
-    pathToLocaleMap?: Leaves<SerializedAsType<T>>;
+    pathToLocaleMap?: SerializedPathTo<T, SerializedNestedEntityMapType>;
     /**
      * @default "name"
      */
     pathInLocaleMap?: string;
 } | null;
-type TConstraint = Record<string, SerializedMemberDecl>;
-export interface SerializedEntityDecl<Name extends string = string, T extends TConstraint = TConstraint, FK extends Extract<keyof T, string> | undefined = Extract<keyof T, string> | undefined> extends SerializedBaseDecl<Name, []> {
+type TSerializedConstraint = Record<string, SerializedMemberDecl>;
+type SerializedPathTo<T extends TSerializedConstraint, R> = {
+    [K in keyof T]: T[K] extends SerializedMemberDecl<infer V> ? V extends R ? K : R extends V ? string : T[K] extends SerializedObjectType<infer P> ? `${Extract<K, string>}.${SerializedPathTo<P, R>}` : never : never;
+}[Extract<keyof T, string>];
+export interface SerializedEntityDecl<Name extends string = string, T extends TSerializedConstraint = TSerializedConstraint, FK extends Extract<keyof T, string> | undefined = Extract<keyof T, string> | undefined> extends SerializedBaseDecl<Name, []> {
     kind: NodeKind["EntityDecl"];
     namePlural: string;
     type: SerializedObjectType<T>;
@@ -22,13 +26,13 @@ export interface SerializedEntityDecl<Name extends string = string, T extends TC
     /**
      * @default "name"
      */
-    displayName?: SerializedEntityDisplayName<SerializedObjectType<T>>;
+    displayName?: GenericEntityDisplayName;
     displayNameCustomizer: boolean;
     isDeprecated?: boolean;
 }
 export declare const isSerializedEntityDecl: (node: SerializedNode) => node is SerializedEntityDecl;
-export declare const isSerializedEntityDeclWithParentReference: <Name extends string, T extends TConstraint, FK extends Extract<keyof T, string> | undefined>(decl: SerializedEntityDecl<Name, T, FK>) => decl is SerializedEntityDecl<Name, T, NonNullable<FK>>;
-export declare const isSerializedEntityDeclWithoutParentReference: <Name extends string, T extends TConstraint>(decl: SerializedEntityDecl<Name, T>) => decl is SerializedEntityDecl<Name, T, undefined>;
+export declare const isSerializedEntityDeclWithParentReference: <Name extends string, T extends TSerializedConstraint, FK extends Extract<keyof T, string> | undefined>(decl: SerializedEntityDecl<Name, T, FK>) => decl is SerializedEntityDecl<Name, T, NonNullable<FK>>;
+export declare const isSerializedEntityDeclWithoutParentReference: <Name extends string, T extends TSerializedConstraint>(decl: SerializedEntityDecl<Name, T>) => decl is SerializedEntityDecl<Name, T, undefined>;
 export declare const resolveTypeArgumentsInSerializedEntityDecl: SerializedTypeArgumentsResolver<SerializedEntityDecl>;
 export declare const getReferencesForSerializedEntityDecl: GetReferencesSerialized<SerializedEntityDecl>;
 export {};

package/dist/src/shared/schema/declarations/EnumDecl.d.ts

@@ -10,3 +10,11 @@ export interface SerializedEnumDecl<Name extends string = string, T extends Reco
 export declare const isSerializedEnumDecl: (node: SerializedNode) => node is SerializedEnumDecl;
 export declare const resolveTypeArgumentsInSerializedEnumDecl: SerializedTypeArgumentsResolver<SerializedEnumDecl>;
 export declare const getReferencesForSerializedEnumDecl: GetReferencesSerialized<SerializedEnumDecl>;
+export declare const ENUM_DISCRIMINATOR_KEY = "kind";
+export type ENUM_DISCRIMINATOR_KEY = typeof ENUM_DISCRIMINATOR_KEY;
+export type EnumValue<K extends string, V> = {
+    [ENUM_DISCRIMINATOR_KEY]: K;
+} & {
+    [Key2 in K]: V;
+};
+export declare const createEnumCaseValue: <K extends string, V>(caseName: K, caseValue: V) => EnumValue<K, V>;

package/dist/src/shared/schema/declarations/EnumDecl.js

@@ -9,3 +9,8 @@ export const resolveTypeArgumentsInSerializedEnumDecl = (decls, args, decl) => {
     };
 };
 export const getReferencesForSerializedEnumDecl = (decls, decl, value) => getReferencesForSerializedEnumType(decls, decl.type, value);
+export const ENUM_DISCRIMINATOR_KEY = "kind";
+export const createEnumCaseValue = (caseName, caseValue) => ({
+    [ENUM_DISCRIMINATOR_KEY]: caseName,
+    [caseName]: caseValue,
+});

package/dist/src/shared/schema/types/FloatType.d.ts

@@ -1,11 +1,12 @@
-import type { RangeBound } from "../../validation/number.ts";
+import type { NumberConstraints } from "../../validation/number.ts";
 import type { GetReferencesSerialized, NodeKind, SerializedTypeArgumentsResolver } from "../Node.ts";
 import type { SerializedBaseType } from "./Type.ts";
-export interface SerializedFloatType extends SerializedBaseType {
+export interface FloatConstraints extends NumberConstraints {
+    fractionDigits?: number;
+}
+export declare const DEFAULT_FRACTION_DIGITS = 2;
+export interface SerializedFloatType extends SerializedBaseType, FloatConstraints {
     kind: NodeKind["FloatType"];
-    minimum?: RangeBound;
-    maximum?: RangeBound;
-    multipleOf?: number;
 }
 export declare const resolveTypeArgumentsInSerializedFloatType: SerializedTypeArgumentsResolver<SerializedFloatType>;
 export declare const getReferencesForSerializedFloatType: GetReferencesSerialized<SerializedFloatType>;

package/dist/src/shared/schema/types/FloatType.js

@@ -1,2 +1,3 @@
+export const DEFAULT_FRACTION_DIGITS = 2;
 export const resolveTypeArgumentsInSerializedFloatType = (_decls, _args, type) => type;
 export const getReferencesForSerializedFloatType = () => [];

package/dist/src/shared/utils/object.d.ts

@@ -2,7 +2,7 @@ export declare const sortObjectKeys: (obj: Record<string, unknown>, keys: string
 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]>}`}`;
+    [K in keyof T]: T[K] extends unknown[] ? never : `${Extract<K, string>}${Leaves<T[K]> extends never ? "" : `.${Leaves<T[K]>}`}`;
 }[keyof T] : never;
 export declare const onlyKeys: <T extends object, K extends keyof T>(obj: T, ...keys: K[]) => Pick<T, K>;
 export declare const hasKey: <T extends object, K extends PropertyKey>(obj: T, key: K) => obj is T & { [k in K]: unknown; };

package/dist/src/web/api/search.d.ts

@@ -0,0 +1,2 @@
+import type { SearchResponseBody } from "../../shared/api.ts";
+export declare const searchInstances: (locales: string[], query: string) => Promise<SearchResponseBody>;

package/dist/src/web/api/search.js

@@ -0,0 +1,7 @@
+import { getResource } from "../utils/api.js";
+export const searchInstances = async (locales, query) => getResource("/api/search", {
+    locales,
+    modifyUrl: url => {
+        url.searchParams.set("q", query);
+    },
+});

package/dist/src/web/components/Layout.js

@@ -6,7 +6,7 @@ import { Settings } from "./Settings.js";
 export const Layout = ({ breadcrumbs, children }) => {
     const [_1, setIsGitOpen] = useContext(GitContext);
     const [isGitAlwaysOpen, _2] = useSetting("gitSidebar");
-    return (_jsxs(_Fragment, { children: [_jsxs("header", { children: [_jsx("nav", { children: _jsx("ol", { children: breadcrumbs.map(({ url, label }) => (_jsx("li", { children: _jsx("a", { href: url, children: label }) }, url))) }) }), _jsxs("div", { class: "nav-buttons", children: [_jsx("button", { class: `git-toggle${!isGitAlwaysOpen ? " git-toggle--no-sidebar" : ""}`, onClick: () => {
+    return (_jsxs(_Fragment, { children: [_jsxs("header", { children: [_jsx("nav", { children: _jsx("ol", { children: breadcrumbs.map(({ url, label }) => (_jsx("li", { children: _jsx("a", { href: url, children: label }) }, url))) }) }), _jsxs("div", { class: "nav-buttons", children: [_jsx("a", { href: "/search", class: "btn", children: "Search" }), _jsx("button", { class: `git-toggle${!isGitAlwaysOpen ? " git-toggle--no-sidebar" : ""}`, onClick: () => {
                                     setIsGitOpen(b => !b);
                                 }, children: "File changes" }), _jsx(Settings, {})] })] }), _jsx("main", { children: children })] }));
 };

package/dist/src/web/components/git/GitStatusIndicator.js

@@ -2,5 +2,5 @@ import { jsx as _jsx } from "preact/jsx-runtime";
 import { getGitStatusForDisplay, getLabelForGitStatus, } from "../../../shared/utils/git.js";
 export const GitStatusIndicator = ({ status }) => {
     const gitStatusForDisplay = getGitStatusForDisplay(status);
-    return (_jsx("span", { class: `git-status git-status--${gitStatusForDisplay ?? ""}`, title: getLabelForGitStatus(gitStatusForDisplay), children: gitStatusForDisplay }));
+    return gitStatusForDisplay === undefined ? null : (_jsx("span", { class: `git-status git-status--${gitStatusForDisplay}`, title: getLabelForGitStatus(gitStatusForDisplay), children: gitStatusForDisplay }));
 };

package/dist/src/web/components/typeInputs/FloatTypeInput.d.ts

@@ -1,5 +1,5 @@
 import type { FunctionComponent } from "preact";
-import type { SerializedFloatType } from "../../../shared/schema/types/FloatType.ts";
+import { type SerializedFloatType } from "../../../shared/schema/types/FloatType.ts";
 import type { TypeInputProps } from "./TypeInput.tsx";
 type Props = TypeInputProps<SerializedFloatType, number>;
 export declare const FloatTypeInput: FunctionComponent<Props>;

package/dist/src/web/components/typeInputs/FloatTypeInput.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
 import { useState } from "preact/hooks";
+import { DEFAULT_FRACTION_DIGITS, } from "../../../shared/schema/types/FloatType.js";
 import { validateNumberConstraints } from "../../../shared/validation/number.js";
 import { MismatchingTypeError } from "./utils/MismatchingTypeError.js";
 import { ValidationErrors } from "./utils/ValidationErrors.js";
@@ -15,5 +16,5 @@ export const FloatTypeInput = ({ type, value, disabled, onChange }) => {
                     if (!Number.isNaN(numericValue)) {
                         onChange(numericValue);
                     }
-                }, step: 0.01, "aria-invalid": errors.length > 0, disabled: disabled }), _jsx(ValidationErrors, { disabled: disabled, errors: errors })] }));
+                }, step: 1 / Math.pow(10, type.fractionDigits ?? DEFAULT_FRACTION_DIGITS), "aria-invalid": errors.length > 0, disabled: disabled }), _jsx(ValidationErrors, { disabled: disabled, errors: errors })] }));
 };

package/dist/src/web/index.js

@@ -20,6 +20,7 @@ import { Entity } from "./routes/Entity.js";
 import { Home } from "./routes/Home.js";
 import { Instance } from "./routes/Instance.js";
 import { NotFound } from "./routes/NotFound.js";
+import { Search } from "./routes/Search.js";
 const mapEntities = (data) => data.declarations
     .map(decl => ({ ...decl, isLocaleEntity: decl.declaration.name === data.localeEntity }))
     .sort((a, b) => a.declaration.name.localeCompare(b.declaration.name));
@@ -33,7 +34,7 @@ const App = ({ config }) => {
             alert("Error reloading entities: " + String(error));
         });
     }, [location.path, reloadEntities]);
-    return (_jsx(ConfigContext.Provider, { value: config, children: _jsx(SettingsContext.Provider, { value: settingsContext, children: _jsx(GitContext.Provider, { value: [isGitOpen, setIsGitOpen], children: _jsx(LocationProvider, { children: _jsx(EntitiesContext.Provider, { value: { entities: entities ?? [], reloadEntities }, children: _jsxs(ContextProviderWrapper, { context: GitClientContext, useValue: useGitClient, children: [_jsx(LoadingOverlay, {}), _jsxs(Router, { children: [_jsx(Route, { path: "/", component: Home }), _jsx(Route, { path: "/entities/:name", component: Entity }), _jsx(Route, { path: "/entities/:name/instances/create", component: CreateInstance }), _jsx(Route, { path: "/entities/:name/instances/:id", component: Instance }), _jsx(Route, { default: true, component: NotFound })] }), _jsx(Git, {})] }) }) }) }) }) }));
+    return (_jsx(ConfigContext.Provider, { value: config, children: _jsx(SettingsContext.Provider, { value: settingsContext, children: _jsx(GitContext.Provider, { value: [isGitOpen, setIsGitOpen], children: _jsx(LocationProvider, { children: _jsx(EntitiesContext.Provider, { value: { entities: entities ?? [], reloadEntities }, children: _jsxs(ContextProviderWrapper, { context: GitClientContext, useValue: useGitClient, children: [_jsx(LoadingOverlay, {}), _jsxs(Router, { children: [_jsx(Route, { path: "/", component: Home }), _jsx(Route, { path: "/search", component: Search }), _jsx(Route, { path: "/entities/:name", component: Entity }), _jsx(Route, { path: "/entities/:name/instances/create", component: CreateInstance }), _jsx(Route, { path: "/entities/:name/instances/:id", component: Instance }), _jsx(Route, { default: true, component: NotFound })] }), _jsx(Git, {})] }) }) }) }) }) }));
 };
 const config = await getWebConfig();
 const root = document.getElementById("app");

package/dist/src/web/routes/Search.d.ts

@@ -0,0 +1,2 @@
+import type { FunctionalComponent } from "preact";
+export declare const Search: FunctionalComponent;

package/dist/src/web/routes/Search.js

@@ -0,0 +1,56 @@
+import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
+import { useCallback, useEffect, useState } from "preact/hooks";
+import { getGitStatusForDisplay } from "../../shared/utils/git.js";
+import { toTitleCase } from "../../shared/utils/string.js";
+import { deleteInstanceByEntityNameAndId } from "../api/declarations.js";
+import { searchInstances } from "../api/search.js";
+import { GitStatusIndicator } from "../components/git/GitStatusIndicator.js";
+import { Layout } from "../components/Layout.js";
+import { useSetting } from "../hooks/useSettings.js";
+import { logAndAlertError } from "../utils/debug.js";
+import { homeTitle } from "./Home.js";
+const MIN_CHARACTERS = 3;
+export const Search = () => {
+    const [locales] = useSetting("displayedLocales");
+    const [query, setQuery] = useState(() => new URLSearchParams(window.location.search).get("q") ?? "");
+    const [results, setResults] = useState();
+    const search = useCallback(() => {
+        const url = new URL(window.location.href);
+        if (url.searchParams.get("q") !== query) {
+            if (query.length === 0) {
+                url.searchParams.delete("q");
+            }
+            else {
+                url.searchParams.set("q", query);
+            }
+            window.history.pushState({}, "", url);
+        }
+        if (query.length >= MIN_CHARACTERS) {
+            searchInstances(locales, query)
+                .then(res => {
+                setResults(res.results);
+            })
+                .catch(logAndAlertError);
+        }
+    }, [locales, query]);
+    useEffect(() => {
+        document.title = "Search — TSONDB";
+        search();
+    }, [search]);
+    return (_jsxs(Layout, { breadcrumbs: [{ url: "/", label: homeTitle }], children: [_jsx("h1", { children: "Search" }), _jsx("input", { type: "search", name: "q", value: query, onInput: event => {
+                    setQuery(event.currentTarget.value);
+                } }), query.length < MIN_CHARACTERS ? (_jsx("p", { class: "help", children: "Provide at least 3 characters in the search field to start the search" })) : (results && (_jsxs("section", { class: "search-results", children: [_jsx("h2", { children: "Results" }), results.length === 0 ? (_jsx("p", { class: "empty", children: "No results" })) : (_jsx("ul", { class: "entries entries--instances", children: results.map(([entityName, instance]) => {
+                            const gitStatusForDisplay = getGitStatusForDisplay(instance.gitStatus);
+                            return (_jsxs("li", { id: `instance-${instance.id}`, class: `entries-item${gitStatusForDisplay === undefined
+                                    ? ""
+                                    : ` git-status--${gitStatusForDisplay}`}`, children: [_jsxs("h2", { class: "entries-item__title", children: [instance.displayName, _jsx("span", { "aria-hidden": true, class: "entries-item__title-entity", children: toTitleCase(entityName) })] }), _jsx("p", { "aria-hidden": true, class: "entries-item__subtitle entries-item__subtitle--id", children: instance.id }), _jsxs("div", { class: "entries-item__side", children: [_jsx(GitStatusIndicator, { status: instance.gitStatus }), _jsxs("div", { class: "btns", children: [_jsx("a", { href: `/entities/${entityName}/instances/${instance.id}`, class: "btn", children: "Edit" }), _jsx("button", { class: "destructive", onClick: () => {
+                                                            if (confirm("Are you sure you want to delete this instance?")) {
+                                                                deleteInstanceByEntityNameAndId(locales, entityName, instance.id)
+                                                                    .then(() => {
+                                                                    search();
+                                                                })
+                                                                    .catch(logAndAlertError);
+                                                            }
+                                                        }, children: "Delete" })] })] })] }, instance.id));
+                        }) }))] })))] }));
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsondb",
-  "version": "0.12.5",
+  "version": "0.12.7",
   "description": "",
   "license": "ISC",
   "author": "Lukas Obermann",

package/public/css/styles.css

@@ -589,6 +589,12 @@ select {
   }
 }
 
+.entries-item__title-entity {
+  font-weight: 400;
+  color: var(--color-foreground-secondary);
+  padding-left: 0.5em;
+}
+
 .entries-item__subtitle--id {
   font-family: var(--font-mono);
 }
@@ -1205,3 +1211,7 @@ dialog[open]:has(> .loading-overlay--open)::backdrop {
 .object-item--translation button {
   align-self: center;
 }
+
+section.search-results {
+  margin-top: 3.6rem;
+}