tsondb 0.1.3

package/README.md

@@ -0,0 +1,3 @@
+# TSON-DB
+
+A TypeScript DSL for creating and managing JSON databases.

package/lib/ModelContainer.d.ts

@@ -0,0 +1,17 @@
+import { Output } from "./renderers/Output.js";
+import { Schema } from "./Schema.js";
+export interface ModelContainer {
+    schema: Schema;
+    outputs: Output[];
+    dataRootPath: string;
+}
+export declare const ModelContainer: (options: {
+    schema: Schema;
+    outputs: Output[];
+    dataRootPath: string;
+}) => ModelContainer;
+export declare const generateOutputs: (modelContainer: ModelContainer) => Promise<void>;
+export declare const validate: (modelContainer: ModelContainer) => Promise<void>;
+export declare const generateAndValidate: (modelContainer: ModelContainer) => Promise<void>;
+export declare const serve: (modelContainer: ModelContainer) => Promise<void>;
+export declare const generateValidateAndServe: (modelContainer: ModelContainer) => Promise<void>;

package/lib/ModelContainer.js

@@ -0,0 +1,63 @@
+import { mkdir } from "fs/promises";
+import { join } from "path";
+import { getEntities } from "./Schema.js";
+import { createValidators, validateEntityDecl } from "./schema/index.js";
+import { createServer } from "./server/index.js";
+import { parallelizeErrors } from "./shared/utils/validation.js";
+import { getErrorMessageForDisplay, wrapErrorsIfAny } from "./utils/error.js";
+import { getInstancesByEntityName } from "./utils/instances.js";
+export const ModelContainer = (options) => ({
+    ...options,
+});
+const prepareFolders = async (modelContainer, entities) => {
+    await mkdir(modelContainer.dataRootPath, { recursive: true });
+    for (const entity of entities) {
+        const entityDir = join(modelContainer.dataRootPath, entity.name);
+        await mkdir(entityDir, { recursive: true });
+    }
+};
+export const generateOutputs = async (modelContainer) => {
+    for (const output of modelContainer.outputs) {
+        await output.run(modelContainer.schema);
+    }
+};
+const _validate = async (entities, instancesByEntityName) => {
+    const errors = entities.flatMap(entity => parallelizeErrors(instancesByEntityName[entity.name].map(instance => wrapErrorsIfAny(`in file "${entity.name}/${instance.fileName}"`, validateEntityDecl(createValidators(instancesByEntityName), entity, instance.content)))));
+    if (errors.length === 0) {
+        console.log("All entities are valid");
+    }
+    else {
+        console.error("Errors:\n");
+        for (const error of errors) {
+            console.error(getErrorMessageForDisplay(error) + "\n");
+        }
+        throw new Error("Validation failed");
+    }
+};
+export const validate = async (modelContainer) => {
+    const entities = getEntities(modelContainer.schema);
+    await prepareFolders(modelContainer, entities);
+    const instancesByEntityName = await getInstancesByEntityName(modelContainer, entities);
+    return _validate(entities, instancesByEntityName);
+};
+export const generateAndValidate = async (modelContainer) => {
+    await generateOutputs(modelContainer);
+    const entities = getEntities(modelContainer.schema);
+    await prepareFolders(modelContainer, entities);
+    const instancesByEntityName = await getInstancesByEntityName(modelContainer, entities);
+    await _validate(entities, instancesByEntityName);
+};
+export const serve = async (modelContainer) => {
+    const entities = getEntities(modelContainer.schema);
+    await prepareFolders(modelContainer, entities);
+    const instancesByEntityName = await getInstancesByEntityName(modelContainer, entities);
+    createServer(modelContainer, instancesByEntityName);
+};
+export const generateValidateAndServe = async (modelContainer) => {
+    await generateOutputs(modelContainer);
+    const entities = getEntities(modelContainer.schema);
+    await prepareFolders(modelContainer, entities);
+    const instancesByEntityName = await getInstancesByEntityName(modelContainer, entities);
+    await _validate(entities, instancesByEntityName);
+    createServer(modelContainer, instancesByEntityName);
+};

package/lib/Schema.d.ts

@@ -0,0 +1,8 @@
+import { Decl } from "./schema/declarations/Declaration.js";
+import { EntityDecl } from "./schema/declarations/EntityDecl.js";
+export interface Schema {
+    declarations: readonly Decl[];
+    localeEntity?: EntityDecl;
+}
+export declare const Schema: (declarations: Decl[], localeEntity?: EntityDecl) => Schema;
+export declare const getEntities: (schema: Schema) => EntityDecl[];

package/lib/Schema.js

@@ -0,0 +1,72 @@
+import { getNestedDeclarations, getParameterNames, } from "./schema/declarations/Declaration.js";
+import { isEntityDecl } from "./schema/declarations/EntityDecl.js";
+import { isStringType } from "./schema/types/primitives/StringType.js";
+import { isNestedEntityMapType } from "./schema/types/references/NestedEntityMapType.js";
+import { findTypeAtPath } from "./schema/types/Type.js";
+const checkDuplicateIdentifier = (existingDecls, decl) => {
+    if (existingDecls
+        .values()
+        .some(otherDecl => otherDecl !== decl && otherDecl.name.toLowerCase() === decl.name.toLowerCase())) {
+        throw new Error(`Duplicate declaration name: "${decl.name}". Make sure declaration names are globally unique.`);
+    }
+};
+const checkParameterNamesShadowing = (decls) => {
+    for (const decl of decls) {
+        for (const param of getParameterNames(decl)) {
+            if (decls.values().some(decl => decl.name === param)) {
+                throw new Error(`Parameter name "${param}" shadows declaration name.`);
+            }
+        }
+    }
+};
+const checkEntityDisplayNamePaths = (decls, localeEntity) => {
+    for (const decl of decls) {
+        if (isEntityDecl(decl)) {
+            const displayName = decl.displayName ?? "name";
+            if (typeof displayName === "object") {
+                const pathToLocaleMap = displayName.pathToLocaleMap ?? "translations";
+                const pathInLocaleMap = displayName.pathInLocaleMap ?? "name";
+                if (localeEntity === undefined) {
+                    throw new Error(`Display name path "${pathToLocaleMap}" for entity "${decl.name}" requires a defined locale entity.`);
+                }
+                const localeMapAtPath = findTypeAtPath(decl.type.value, pathToLocaleMap.split("."));
+                if (!localeMapAtPath ||
+                    !isNestedEntityMapType(localeMapAtPath) ||
+                    localeMapAtPath.secondaryEntity.name !== localeEntity.name) {
+                    throw new Error(`Display name path "${pathToLocaleMap}" for entity "${decl.name}" does not lead to a nested entity map for the defined locale entity.`);
+                }
+                const typeAtLocaleMapPath = findTypeAtPath(localeMapAtPath.type.value, pathInLocaleMap.split("."));
+                if (!typeAtLocaleMapPath || !isStringType(typeAtLocaleMapPath)) {
+                    throw new Error(`Display name path "${pathInLocaleMap}" for entity "${decl.name}" does not lead to a value of type string in nested locale map.`);
+                }
+            }
+            else {
+                const path = displayName.split(".");
+                const typeAtPath = findTypeAtPath(decl.type.value, path);
+                if (!typeAtPath || !isStringType(typeAtPath)) {
+                    throw new Error(`Display name path "${displayName}" for entity "${decl.name}" does not lead to a value of type string.`);
+                }
+            }
+        }
+    }
+};
+const addDeclarations = (existingDecls, declsToAdd, nested) => declsToAdd.reduce((accDecls, decl) => {
+    if (!accDecls.includes(decl)) {
+        checkDuplicateIdentifier(accDecls, decl);
+        const nestedDecls = nested
+            ? getNestedDeclarations(declToAdd => accDecls.includes(declToAdd), decl)
+            : [];
+        return addDeclarations([...accDecls, decl], nestedDecls, false);
+    }
+    return accDecls;
+}, existingDecls);
+export const Schema = (declarations, localeEntity) => {
+    const allDecls = addDeclarations([], localeEntity ? declarations.concat(localeEntity) : declarations, true);
+    checkParameterNamesShadowing(allDecls);
+    checkEntityDisplayNamePaths(allDecls, localeEntity);
+    return {
+        declarations: allDecls,
+        localeEntity,
+    };
+};
+export const getEntities = (schema) => schema.declarations.filter(isEntityDecl);

package/lib/client/api.d.ts

@@ -0,0 +1,11 @@
+import { SerializedEntityDecl } from "../schema/declarations/EntityDecl.js";
+import { CreateInstanceOfEntityResponseBody, DeleteInstanceOfEntityResponseBody, GetAllDeclarationsResponseBody, GetAllInstancesOfEntityResponseBody, GetAllInstancesResponseBody, GetDeclarationResponseBody, GetInstanceOfEntityResponseBody, 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>;

package/lib/client/api.js

@@ -0,0 +1,83 @@
+export const getAllDeclarations = async (kind) => {
+    const url = new URL("/api/declarations", window.location.origin);
+    if (kind) {
+        url.searchParams.append("kind", kind);
+    }
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return response.json();
+};
+export const getAllEntities = () => getAllDeclarations("Entity");
+export const getEntityByName = async (name) => {
+    const response = await fetch(`/api/declarations/${name}`);
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return response.json();
+};
+export const getInstancesByEntityName = async (name) => {
+    const response = await fetch(`/api/declarations/${name}/instances`);
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return response.json();
+};
+export const createInstanceByEntityNameAndId = async (name, content, id) => {
+    const url = new URL(`/api/declarations/${name}/instances`, window.location.origin);
+    if (id) {
+        url.searchParams.append("id", id);
+    }
+    const response = await fetch(url, {
+        method: "POST",
+        body: JSON.stringify(content),
+        headers: {
+            "Content-Type": "application/json",
+        },
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return response.json();
+};
+export const getInstanceByEntityNameAndId = async (name, id) => {
+    const response = await fetch(`/api/declarations/${name}/instances/${id}`);
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return response.json();
+};
+export const updateInstanceByEntityNameAndId = async (name, id, content) => {
+    const response = await fetch(`/api/declarations/${name}/instances/${id}`, {
+        method: "PUT",
+        body: JSON.stringify(content),
+        headers: {
+            "Content-Type": "application/json",
+        },
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return response.json();
+};
+export const deleteInstanceByEntityNameAndId = async (name, id) => {
+    const response = await fetch(`/api/declarations/${name}/instances/${id}`, {
+        method: "DELETE",
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return response.json();
+};
+export const getAllInstances = async (locales) => {
+    const url = new URL("/api/instances", window.location.origin);
+    for (const locale of locales) {
+        url.searchParams.append("locales", locale);
+    }
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return response.json();
+};

package/lib/client/components/Layout.d.ts

@@ -0,0 +1,10 @@
+import { ComponentChildren, FunctionComponent } from "preact";
+type Props = {
+    breadcrumbs: {
+        url: string;
+        label: string;
+    }[];
+    children: ComponentChildren;
+};
+export declare const Layout: FunctionComponent<Props>;
+export {};

package/lib/client/components/Layout.js

@@ -0,0 +1,4 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "preact/jsx-runtime";
+export const Layout = ({ breadcrumbs, children }) => {
+    return (_jsxs(_Fragment, { children: [_jsx("header", { children: _jsx("nav", { children: _jsx("ol", { children: breadcrumbs.map(({ url, label }) => (_jsx("li", { children: _jsx("a", { href: url, children: label }) }))) }) }) }), _jsx("main", { children: children })] }));
+};

package/lib/client/components/Select.d.ts

@@ -0,0 +1,3 @@
+import { FunctionalComponent } from "preact";
+import { SelectHTMLAttributes } from "preact/compat";
+export declare const Select: FunctionalComponent<SelectHTMLAttributes>;

package/lib/client/components/Select.js

@@ -0,0 +1,2 @@
+import { jsx as _jsx } from "preact/jsx-runtime";
+export const Select = props => (_jsx("div", { class: "select-wrapper", children: _jsx("select", { ...props, class: `${props.class ?? ""} ${props.className ?? ""} ${!props.value ? "no-selection" : ""}` }) }));

package/lib/client/components/typeInputs/ArrayTypeInput.d.ts

@@ -0,0 +1,13 @@
+import { FunctionComponent } from "preact";
+import { SerializedArrayType } from "../../../schema/types/generic/ArrayType.js";
+import { InstanceNamesByEntity } from "../../hooks/useInstanceNamesByEntity.js";
+import { GetDeclFromDeclName } from "../../hooks/useSecondaryDeclarations.js";
+type Props = {
+    type: SerializedArrayType;
+    value: unknown[];
+    instanceNamesByEntity: InstanceNamesByEntity;
+    getDeclFromDeclName: GetDeclFromDeclName;
+    onChange: (value: unknown[]) => void;
+};
+export declare const ArrayTypeInput: FunctionComponent<Props>;
+export {};

package/lib/client/components/typeInputs/ArrayTypeInput.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
+import { validateArrayConstraints } from "../../../shared/validation/array.js";
+import { createTypeSkeleton } from "../../utils/typeSkeleton.js";
+import { TypeInput } from "./TypeInput.js";
+import { ValidationErrors } from "./utils/ValidationErrors.js";
+export const ArrayTypeInput = ({ type, value, instanceNamesByEntity, getDeclFromDeclName, onChange, }) => {
+    const errors = validateArrayConstraints(type, value);
+    const isTuple = typeof type.minItems === "number" && type.minItems === type.maxItems;
+    return (_jsxs("div", { class: "field field--container field--array", children: [value.length > 0 && (_jsx("ol", { children: value.map((item, i) => (_jsxs("li", { class: "container-item array-item", children: [_jsx(TypeInput, { type: type.items, value: item, instanceNamesByEntity: instanceNamesByEntity, getDeclFromDeclName: getDeclFromDeclName, onChange: newItem => onChange([...value.slice(0, i), newItem, ...value.slice(i + 1)]) }), isTuple ? null : (_jsx("button", { class: "destructive", onClick: () => onChange([...value, createTypeSkeleton(getDeclFromDeclName, type.items)]), disabled: type.minItems !== undefined && value.length <= type.minItems, children: "Delete Item" }))] }, i))) })), isTuple ? null : (_jsx("div", { class: "add-item-container", children: _jsx("button", { onClick: () => onChange([...value, createTypeSkeleton(getDeclFromDeclName, type.items)]), disabled: type.maxItems !== undefined && value.length >= type.maxItems, children: "Add Item" }) })), _jsx(ValidationErrors, { errors: errors })] }));
+};

package/lib/client/components/typeInputs/BooleanTypeInput.d.ts

@@ -0,0 +1,9 @@
+import { FunctionComponent } from "preact";
+import { SerializedBooleanType } from "../../../schema/types/primitives/BooleanType.js";
+type Props = {
+    type: SerializedBooleanType;
+    value: boolean;
+    onChange: (value: boolean) => void;
+};
+export declare const BooleanTypeInput: FunctionComponent<Props>;
+export {};

package/lib/client/components/typeInputs/BooleanTypeInput.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "preact/jsx-runtime";
+export const BooleanTypeInput = ({ value, onChange }) => {
+    return (_jsx("div", { class: "field", children: _jsx("input", { type: "checkbox", checked: value, onInput: event => {
+                onChange(event.currentTarget.checked);
+            } }) }));
+};

package/lib/client/components/typeInputs/DateTypeInput.d.ts

@@ -0,0 +1,9 @@
+import { FunctionComponent } from "preact";
+import { SerializedDateType } from "../../../schema/types/primitives/DateType.js";
+type Props = {
+    type: SerializedDateType;
+    value: string;
+    onChange: (value: string) => void;
+};
+export declare const DateTypeInput: FunctionComponent<Props>;
+export {};

package/lib/client/components/typeInputs/DateTypeInput.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
+import { validateDateConstraints } from "../../../shared/validation/date.js";
+import { ValidationErrors } from "./utils/ValidationErrors.js";
+export const DateTypeInput = ({ type, value, onChange }) => {
+    const errors = validateDateConstraints(type, value);
+    return (_jsxs("div", { class: "field", children: [_jsx("input", { type: "date", value: value, onInput: event => {
+                    onChange(event.currentTarget.value);
+                } }), _jsx(ValidationErrors, { errors: errors })] }));
+};

package/lib/client/components/typeInputs/FloatTypeInput.d.ts

@@ -0,0 +1,9 @@
+import { FunctionComponent } from "preact";
+import { SerializedFloatType } from "../../../schema/types/primitives/FloatType.js";
+type Props = {
+    type: SerializedFloatType;
+    value: number;
+    onChange: (value: number) => void;
+};
+export declare const FloatTypeInput: FunctionComponent<Props>;
+export {};

package/lib/client/components/typeInputs/FloatTypeInput.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
+import { useState } from "preact/hooks";
+import { validateNumberConstraints } from "../../../shared/validation/number.js";
+import { ValidationErrors } from "./utils/ValidationErrors.js";
+export const FloatTypeInput = ({ type, value, onChange }) => {
+    const [stringValue, setStringValue] = useState(value.toString());
+    const errors = validateNumberConstraints(type, value);
+    return (_jsxs("div", { class: "field", children: [_jsx("input", { type: "number", value: stringValue, onInput: event => {
+                    setStringValue(event.currentTarget.value);
+                    const numericValue = Number.parseFloat(event.currentTarget.value);
+                    if (!Number.isNaN(numericValue)) {
+                        onChange(numericValue);
+                    }
+                }, step: 0.01, "aria-invalid": errors.length > 0 }), _jsx(ValidationErrors, { errors: errors })] }));
+};

package/lib/client/components/typeInputs/GenericTypeArgumentIdentifierTypeInput.d.ts

@@ -0,0 +1,7 @@
+import { FunctionComponent } from "preact";
+import { SerializedGenericArgumentIdentifierType } from "../../../schema/types/references/GenericArgumentIdentifierType.js";
+type Props = {
+    type: SerializedGenericArgumentIdentifierType;
+};
+export declare const GenericArgumentIdentifierTypeInput: FunctionComponent<Props>;
+export {};

package/lib/client/components/typeInputs/GenericTypeArgumentIdentifierTypeInput.js

@@ -0,0 +1,4 @@
+import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
+export const GenericArgumentIdentifierTypeInput = ({ type }) => {
+    return (_jsxs("div", { role: "alert", children: ["Unresolved type argument ", _jsx("code", { children: type.argument.name })] }));
+};

package/lib/client/components/typeInputs/IncludeIdentifierTypeInput.d.ts

@@ -0,0 +1,13 @@
+import { FunctionComponent } from "preact";
+import { SerializedIncludeIdentifierType } from "../../../schema/index.js";
+import { InstanceNamesByEntity } from "../../hooks/useInstanceNamesByEntity.js";
+import { GetDeclFromDeclName } from "../../hooks/useSecondaryDeclarations.js";
+type Props = {
+    type: SerializedIncludeIdentifierType;
+    value: unknown;
+    instanceNamesByEntity: InstanceNamesByEntity;
+    getDeclFromDeclName: GetDeclFromDeclName;
+    onChange: (value: unknown) => void;
+};
+export declare const IncludeIdentifierTypeInput: FunctionComponent<Props>;
+export {};

package/lib/client/components/typeInputs/IncludeIdentifierTypeInput.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
+import { assertExhaustive } from "../../../shared/utils/typeSafety.js";
+import { TypeInput } from "./TypeInput.js";
+import { EnumDeclField } from "./utils/EnumDeclField.js";
+export const IncludeIdentifierTypeInput = ({ type, value, instanceNamesByEntity, getDeclFromDeclName, onChange, }) => {
+    const decl = getDeclFromDeclName(type.reference);
+    if (decl === undefined) {
+        return (_jsxs("div", { role: "alert", children: ["Unresolved declaration identifier ", _jsx("code", { children: type.reference })] }));
+    }
+    switch (decl.kind) {
+        case "EnumDecl":
+            return (_jsx(EnumDeclField, { decl: decl, value: value, instanceNamesByEntity: instanceNamesByEntity, getDeclFromDeclName: getDeclFromDeclName, onChange: onChange }));
+        case "TypeAliasDecl":
+            return (_jsx(TypeInput, { type: decl.type, value: value, instanceNamesByEntity: instanceNamesByEntity, getDeclFromDeclName: getDeclFromDeclName, onChange: onChange }));
+        default:
+            return assertExhaustive(decl);
+    }
+};

package/lib/client/components/typeInputs/IntegerTypeInput.d.ts

@@ -0,0 +1,9 @@
+import { FunctionComponent } from "preact";
+import { SerializedIntegerType } from "../../../schema/types/primitives/IntegerType.js";
+type Props = {
+    type: SerializedIntegerType;
+    value: number;
+    onChange: (value: number) => void;
+};
+export declare const IntegerTypeInput: FunctionComponent<Props>;
+export {};

package/lib/client/components/typeInputs/IntegerTypeInput.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
+import { useState } from "preact/hooks";
+import { validateNumberConstraints } from "../../../shared/validation/number.js";
+import { ValidationErrors } from "./utils/ValidationErrors.js";
+export const IntegerTypeInput = ({ type, value, onChange }) => {
+    const [stringValue, setStringValue] = useState(value.toString());
+    const errors = validateNumberConstraints(type, value);
+    return (_jsxs("div", { class: "field", children: [_jsx("input", { type: "number", value: stringValue, onInput: event => {
+                    setStringValue(event.currentTarget.value);
+                    const numericValue = Number.parseInt(event.currentTarget.value, 10);
+                    if (!Number.isNaN(numericValue)) {
+                        onChange(numericValue);
+                    }
+                }, step: 0.01, "aria-invalid": errors.length > 0 }), _jsx(ValidationErrors, { errors: errors })] }));
+};

package/lib/client/components/typeInputs/NestedEntityMapTypeInput.d.ts

@@ -0,0 +1,13 @@
+import { FunctionComponent } from "preact";
+import { SerializedNestedEntityMapType } from "../../../schema/types/references/NestedEntityMapType.js";
+import { InstanceNamesByEntity } from "../../hooks/useInstanceNamesByEntity.js";
+import { GetDeclFromDeclName } from "../../hooks/useSecondaryDeclarations.js";
+type Props = {
+    type: SerializedNestedEntityMapType;
+    value: Record<string, unknown>;
+    instanceNamesByEntity: InstanceNamesByEntity;
+    getDeclFromDeclName: GetDeclFromDeclName;
+    onChange: (value: Record<string, unknown>) => void;
+};
+export declare const NestedEntityMapTypeInput: FunctionComponent<Props>;
+export {};

package/lib/client/components/typeInputs/NestedEntityMapTypeInput.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
+import { useState } from "preact/hooks";
+import { sortObjectKeysAlphabetically } from "../../../shared/utils/object.js";
+import { createTypeSkeleton } from "../../utils/typeSkeleton.js";
+import { Select } from "../Select.js";
+import { TypeInput } from "./TypeInput.js";
+export const NestedEntityMapTypeInput = ({ type, value, instanceNamesByEntity, getDeclFromDeclName, onChange, }) => {
+    const [newKey, setNewKey] = useState("");
+    const existingKeys = Object.keys(value);
+    const secondaryInstances = (instanceNamesByEntity[type.secondaryEntity] ?? [])
+        .slice()
+        .filter(instance => !existingKeys.includes(instance.id))
+        .sort((a, b) => a.name.localeCompare(b.name));
+    return (_jsxs("div", { class: "field field--container field--nestedentitymap", children: [existingKeys.length > 0 && (_jsx("ul", { children: Object.entries(value).map(([key, item]) => (_jsxs("li", { class: "container-item dict-item", children: [_jsxs("div", { className: "container-item-header", children: [_jsx("div", { className: "container-item-title", children: _jsxs("span", { children: [_jsx("strong", { children: instanceNamesByEntity[type.secondaryEntity].find(instance => instance.id === key)?.name ?? key }), " ", _jsx("span", { className: "id", children: key })] }) }), _jsx("div", { className: "btns", children: _jsx("button", { class: "destructive", onClick: () => {
+                                            const newObj = { ...value };
+                                            delete newObj[key];
+                                            onChange(newObj);
+                                        }, children: "Delete Key" }) })] }), _jsx(TypeInput, { type: type.type, value: item, instanceNamesByEntity: instanceNamesByEntity, getDeclFromDeclName: getDeclFromDeclName, onChange: newItem => onChange(sortObjectKeysAlphabetically({ ...value, [key]: newItem })) })] }, key))) })), _jsxs("div", { class: "add-item-container", children: [_jsxs(Select, { value: newKey, onInput: event => setNewKey(event.currentTarget.value), disabled: secondaryInstances.length === 0, children: [secondaryInstances.length === 0 ? (_jsx("option", { value: "", disabled: true, children: "No instances available" })) : (_jsx("option", { value: "", disabled: true, children: "No selected instance" })), secondaryInstances.map(instance => (_jsx("option", { value: instance.id, children: instance.name })))] }), _jsx("button", { onClick: () => {
+                            onChange(sortObjectKeysAlphabetically({
+                                ...value,
+                                [newKey]: createTypeSkeleton(getDeclFromDeclName, type.type),
+                            }));
+                            setNewKey("");
+                        }, disabled: newKey === "", children: "Add Key" })] })] }));
+};

package/lib/client/components/typeInputs/ObjectTypeInput.d.ts

@@ -0,0 +1,13 @@
+import { FunctionComponent } from "preact";
+import { SerializedObjectType } from "../../../schema/types/generic/ObjectType.js";
+import { InstanceNamesByEntity } from "../../hooks/useInstanceNamesByEntity.js";
+import { GetDeclFromDeclName } from "../../hooks/useSecondaryDeclarations.js";
+type Props = {
+    type: SerializedObjectType;
+    value: Record<string, unknown>;
+    instanceNamesByEntity: InstanceNamesByEntity;
+    getDeclFromDeclName: GetDeclFromDeclName;
+    onChange: (value: Record<string, unknown>) => void;
+};
+export declare const ObjectTypeInput: FunctionComponent<Props>;
+export {};

package/lib/client/components/typeInputs/ObjectTypeInput.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
+import { sortObjectKeys } from "../../../shared/utils/object.js";
+import { toTitleCase } from "../../../shared/utils/string.js";
+import { validateObjectConstraints } from "../../../shared/validation/object.js";
+import { createTypeSkeleton } from "../../utils/typeSkeleton.js";
+import { TypeInput } from "./TypeInput.js";
+import { ValidationErrors } from "./utils/ValidationErrors.js";
+export const ObjectTypeInput = ({ type, value, instanceNamesByEntity, getDeclFromDeclName, onChange, }) => {
+    const errors = validateObjectConstraints(type, Object.keys(type.properties), value);
+    return (_jsxs("div", { class: "field field--container field--object", children: [_jsx("ul", { children: Object.entries(type.properties).map(([key, memberDecl]) => (_jsxs("li", { class: "container-item object-item", children: [_jsxs("div", { className: "container-item-header", children: [_jsxs("div", { className: "container-item-title", children: [_jsx("strong", { children: toTitleCase(key) }), memberDecl.comment === undefined ? null : (_jsx("p", { class: "comment", children: memberDecl.comment }))] }), memberDecl.isRequired ? null : value[key] === undefined ? (_jsx("button", { onClick: () => {
+                                        onChange(sortObjectKeys({
+                                            ...value,
+                                            [key]: createTypeSkeleton(getDeclFromDeclName, memberDecl.type),
+                                        }, Object.keys(type.properties)));
+                                    }, children: "Add Property" })) : (_jsx("button", { class: "destructive", onClick: () => {
+                                        const newObj = { ...value };
+                                        delete newObj[key];
+                                        onChange(newObj);
+                                    }, children: "Remove Property" }))] }), memberDecl.isRequired || value[key] !== undefined ? (_jsx(TypeInput, { type: memberDecl.type, value: value[key], instanceNamesByEntity: instanceNamesByEntity, getDeclFromDeclName: getDeclFromDeclName, onChange: newItem => onChange(sortObjectKeys({ ...value, [key]: newItem }, Object.keys(type.properties))) })) : null] }, key))) }), _jsx(ValidationErrors, { errors: errors })] }));
+};

package/lib/client/components/typeInputs/ReferenceIdentifierTypeInput.d.ts

@@ -0,0 +1,11 @@
+import { FunctionComponent } from "preact";
+import { SerializedReferenceIdentifierType } from "../../../schema/types/references/ReferenceIdentifierType.js";
+import { InstanceNamesByEntity } from "../../hooks/useInstanceNamesByEntity.js";
+type Props = {
+    type: SerializedReferenceIdentifierType;
+    value: string;
+    instanceNamesByEntity: InstanceNamesByEntity;
+    onChange: (value: string) => void;
+};
+export declare const ReferenceIdentifierTypeInput: FunctionComponent<Props>;
+export {};

package/lib/client/components/typeInputs/ReferenceIdentifierTypeInput.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
+import { Select } from "../Select.js";
+import { ValidationErrors } from "./utils/ValidationErrors.js";
+export const ReferenceIdentifierTypeInput = ({ type, value, instanceNamesByEntity, onChange, }) => {
+    const instances = (instanceNamesByEntity[type.entity] ?? [])
+        .slice()
+        .sort((a, b) => a.name.localeCompare(b.name));
+    return (_jsxs("div", { class: "field", children: [_jsxs(Select, { value: value, onInput: event => onChange(event.currentTarget.value), disabled: instances.length === 0, "aria-invalid": !value, children: [instances.length === 0 ? (_jsx("option", { value: "", disabled: true, children: "No instances available" })) : (_jsx("option", { value: "", disabled: true, children: "No selected instance" })), instances.map(instance => (_jsx("option", { value: instance.id, children: instance.name })))] }), _jsx(ValidationErrors, { errors: !value ? [ReferenceError("no reference provided")] : [] })] }));
+};

package/lib/client/components/typeInputs/StringTypeInput.d.ts

@@ -0,0 +1,9 @@
+import { FunctionComponent } from "preact";
+import { SerializedStringType } from "../../../schema/types/primitives/StringType.js";
+type Props = {
+    type: SerializedStringType;
+    value: string;
+    onChange: (value: string) => void;
+};
+export declare const StringTypeInput: FunctionComponent<Props>;
+export {};

package/lib/client/components/typeInputs/StringTypeInput.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
+import { validateStringConstraints } from "../../../shared/validation/string.js";
+import { ValidationErrors } from "./utils/ValidationErrors.js";
+export const StringTypeInput = ({ type, value, onChange }) => {
+    const { minLength, maxLength, pattern } = type;
+    const errors = validateStringConstraints(type, value);
+    return (_jsxs("div", { class: "field", children: [_jsx("input", { type: "text", value: value, minLength: minLength, maxLength: maxLength, pattern: pattern, onInput: event => {
+                    onChange(event.currentTarget.value);
+                }, "aria-invalid": errors.length > 0 }), _jsx(ValidationErrors, { errors: errors })] }));
+};

package/lib/client/components/typeInputs/TypeInput.d.ts

@@ -0,0 +1,13 @@
+import { FunctionComponent } from "preact";
+import { SerializedType } from "../../../schema/types/Type.js";
+import { InstanceNamesByEntity } from "../../hooks/useInstanceNamesByEntity.js";
+import { GetDeclFromDeclName } from "../../hooks/useSecondaryDeclarations.js";
+type Props = {
+    type: SerializedType;
+    value: unknown;
+    instanceNamesByEntity: InstanceNamesByEntity;
+    getDeclFromDeclName: GetDeclFromDeclName;
+    onChange: (value: unknown) => void;
+};
+export declare const TypeInput: FunctionComponent<Props>;
+export {};