tsondb 0.2.0 → 0.4.0

package/lib/{client → web}/components/typeInputs/ReferenceIdentifierTypeInput.d.ts

@@ -1,6 +1,6 @@
-import { FunctionComponent } from "preact";
-import { SerializedReferenceIdentifierType } from "../../../schema/types/references/ReferenceIdentifierType.js";
-import { InstanceNamesByEntity } from "../../hooks/useInstanceNamesByEntity.js";
+import type { FunctionComponent } from "preact";
+import type { SerializedReferenceIdentifierType } from "../../../node/schema/types/references/ReferenceIdentifierType.js";
+import type { InstanceNamesByEntity } from "../../hooks/useInstanceNamesByEntity.js";
 type Props = {
     type: SerializedReferenceIdentifierType;
     value: string;

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

@@ -0,0 +1,11 @@
+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 }, instance.id)))] }), _jsx(ValidationErrors, { errors: !value ? [ReferenceError("no reference provided")] : [] })] }));
+};

package/lib/{client → web}/components/typeInputs/StringTypeInput.d.ts

@@ -1,5 +1,5 @@
-import { FunctionComponent } from "preact";
-import { SerializedStringType } from "../../../schema/types/primitives/StringType.js";
+import type { FunctionComponent } from "preact";
+import type { SerializedStringType } from "../../../node/schema/types/primitives/StringType.js";
 type Props = {
     type: SerializedStringType;
     value: string;

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

@@ -0,0 +1,13 @@
+import type { FunctionComponent } from "preact";
+import type { SerializedType } from "../../../node/schema/types/Type.js";
+import type { InstanceNamesByEntity } from "../../hooks/useInstanceNamesByEntity.js";
+import type { 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 {};

package/lib/{client → web}/components/typeInputs/TypeInput.js

@@ -3,8 +3,9 @@ import { assertExhaustive } from "../../../shared/utils/typeSafety.js";
 import { ArrayTypeInput } from "./ArrayTypeInput.js";
 import { BooleanTypeInput } from "./BooleanTypeInput.js";
 import { DateTypeInput } from "./DateTypeInput.js";
+import { EnumTypeInput } from "./EnumTypeInput.js";
 import { FloatTypeInput } from "./FloatTypeInput.js";
-import { GenericArgumentIdentifierTypeInput } from "./GenericTypeArgumentIdentifierTypeInput.js";
+import { TypeArgumentTypeInput } from "./GenericTypeArgumentIdentifierTypeInput.js";
 import { IncludeIdentifierTypeInput } from "./IncludeIdentifierTypeInput.js";
 import { IntegerTypeInput } from "./IntegerTypeInput.js";
 import { NestedEntityMapTypeInput } from "./NestedEntityMapTypeInput.js";
@@ -63,8 +64,8 @@ export const TypeInput = ({ type, value, instanceNamesByEntity, getDeclFromDeclN
             else {
                 return _jsx(MismatchingTypeError, { expected: "object", actual: value });
             }
-        case "GenericArgumentIdentifierType":
-            return _jsx(GenericArgumentIdentifierTypeInput, { type: type });
+        case "TypeArgumentType":
+            return _jsx(TypeArgumentTypeInput, { type: type });
         case "ReferenceIdentifierType":
             if (typeof value === "string") {
                 return (_jsx(ReferenceIdentifierTypeInput, { type: type, value: value, instanceNamesByEntity: instanceNamesByEntity, onChange: onChange }));
@@ -81,6 +82,8 @@ export const TypeInput = ({ type, value, instanceNamesByEntity, getDeclFromDeclN
             else {
                 return _jsx(MismatchingTypeError, { expected: "entity map", actual: value });
             }
+        case "EnumType":
+            return (_jsx(EnumTypeInput, { type: type, value: value, instanceNamesByEntity: instanceNamesByEntity, getDeclFromDeclName: getDeclFromDeclName, onChange: onChange }));
         default:
             return assertExhaustive(type);
     }

package/lib/{client → web}/components/typeInputs/utils/Markdown.d.ts

@@ -1,4 +1,4 @@
-import { FunctionalComponent } from "preact";
+import type { FunctionalComponent } from "preact";
 type Props = {
     string: string;
 };

package/lib/web/components/typeInputs/utils/Markdown.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx } from "preact/jsx-runtime";
+import { parseBlockMarkdown } from "../../../../shared/utils/markdown.js";
+export const Markdown = ({ string }) => {
+    const blocks = parseBlockMarkdown(string);
+    return blocks.map((block, i) => _jsx(BlockMarkdown, { node: block }, `md-block-${i.toString()}`));
+};
+const BlockMarkdown = ({ node }) => {
+    switch (node.kind) {
+        case "paragraph":
+            return (_jsx("p", { children: node.content.map((inline, ii) => (_jsx(InlineMarkdown, { node: inline }, ii))) }));
+        case "text":
+            return node.content;
+        default:
+            return null;
+    }
+};
+const InlineMarkdown = ({ node }) => {
+    switch (node.kind) {
+        case "bold":
+            return (_jsx("strong", { children: node.content.map((inline, i) => (_jsx(InlineMarkdown, { node: inline }, i))) }));
+        case "italic":
+            return (_jsx("em", { children: node.content.map((inline, i) => (_jsx(InlineMarkdown, { node: inline }, i))) }));
+        case "text":
+            return node.content;
+    }
+};

package/lib/{client → web}/components/typeInputs/utils/MismatchingTypeError.d.ts

@@ -1,4 +1,4 @@
-import { FunctionComponent } from "preact";
+import type { FunctionComponent } from "preact";
 type Props = {
     expected: string;
     actual: unknown;

package/lib/{client → web}/components/typeInputs/utils/ValidationErrors.d.ts

@@ -1,4 +1,4 @@
-import { FunctionComponent } from "preact";
+import type { FunctionComponent } from "preact";
 type Props = {
     errors: Error[];
 };

package/lib/web/hooks/useAPIResource.d.ts

@@ -0,0 +1 @@
+export declare const useAPIResource: <T, A extends unknown[]>(apiFn: (...args: A) => Promise<T>, ...args: A) => [T | undefined, () => Promise<void>];

package/lib/web/hooks/useAPIResource.js

@@ -0,0 +1,2 @@
+import { useMappedAPIResource } from "./useMappedAPIResource.js";
+export const useAPIResource = (apiFn, ...args) => useMappedAPIResource(apiFn, data => data, ...args);

package/lib/{client → web}/hooks/useEntityFromRoute.d.ts

@@ -1,4 +1,4 @@
-import { SerializedEntityDecl } from "../../schema/declarations/EntityDecl.js";
+import type { SerializedEntityDecl } from "../../node/schema/declarations/EntityDecl.js";
 export declare const useEntityFromRoute: () => {
     entity: SerializedEntityDecl;
     isLocaleEntity: boolean;

package/lib/{client → web}/hooks/useEntityFromRoute.js

@@ -10,7 +10,7 @@ export const useEntityFromRoute = () => {
                 .then(data => {
                 setEntityData(data);
             })
-                .catch(error => {
+                .catch((error) => {
                 console.error("Error fetching data:", error);
             });
         }

package/lib/{client → web}/hooks/useInstanceNamesByEntity.d.ts

@@ -1,3 +1,3 @@
-import { GetAllInstancesResponseBody } from "../../shared/api.js";
+import type { GetAllInstancesResponseBody } from "../../shared/api.js";
 export type InstanceNamesByEntity = GetAllInstancesResponseBody["instances"];
 export declare const useInstanceNamesByEntity: (locales?: string[]) => [InstanceNamesByEntity, () => void];

package/lib/{client → web}/hooks/useInstanceNamesByEntity.js

@@ -1,18 +1,20 @@
-import { useEffect, useState } from "preact/hooks";
+import { useCallback, useEffect, useState } from "preact/hooks";
 import { getAllInstances } from "../api.js";
 export const useInstanceNamesByEntity = (locales = []) => {
     const [instanceNamesByEntity, setInstanceNamesByEntity] = useState({});
-    const updateInstanceNamesByEntity = () => {
+    const updateInstanceNamesByEntity = useCallback(() => {
         getAllInstances(locales)
             .then(data => {
             setInstanceNamesByEntity(data.instances);
         })
-            .catch(error => {
-            console.error("Error fetching data:", error);
+            .catch((error) => {
+            if (error instanceof Error) {
+                console.error("Error fetching data:", error.toString());
+            }
         });
-    };
+    }, [locales]);
     useEffect(() => {
         updateInstanceNamesByEntity();
-    }, []);
+    }, [updateInstanceNamesByEntity]);
     return [instanceNamesByEntity, updateInstanceNamesByEntity];
 };

package/lib/web/hooks/useMappedAPIResource.d.ts

@@ -0,0 +1 @@
+export declare const useMappedAPIResource: <T, A extends unknown[], U>(apiFn: (...args: A) => Promise<T>, mapFn: (data: T) => U, ...args: A) => [U | undefined, () => Promise<void>];

package/lib/web/hooks/useMappedAPIResource.js

@@ -0,0 +1,17 @@
+import { useCallback, useEffect, useState } from "preact/hooks";
+export const useMappedAPIResource = (apiFn, mapFn, ...args) => {
+    const [data, setData] = useState();
+    const fetchData = useCallback(() => apiFn(...args).then(result => {
+        setData(mapFn(result));
+    }), [apiFn, args, mapFn]);
+    useEffect(() => {
+        fetchData().catch((err) => {
+            console.log(err);
+        });
+    }, [fetchData]);
+    const reload = useCallback(() => {
+        setData(undefined);
+        return fetchData();
+    }, [fetchData]);
+    return [data, reload];
+};

package/lib/{client → web}/hooks/useSecondaryDeclarations.d.ts

@@ -1,3 +1,3 @@
-import { SerializedSecondaryDecl } from "../../schema/declarations/Declaration.js";
+import type { SerializedSecondaryDecl } from "../../node/schema/declarations/Declaration.js";
 export type GetDeclFromDeclName = (name: string) => SerializedSecondaryDecl | undefined;
 export declare const useGetDeclFromDeclName: () => GetDeclFromDeclName;

package/lib/{client → web}/hooks/useSecondaryDeclarations.js

@@ -9,8 +9,10 @@ export const useGetDeclFromDeclName = () => {
                 .map(decl => decl.declaration)
                 .filter((decl) => decl.kind === "EnumDecl" || decl.kind === "TypeAliasDecl"));
         })
-            .catch(error => {
-            console.error("Error fetching data:", error);
+            .catch((error) => {
+            if (error instanceof Error) {
+                console.error("Error fetching data:", error.toString());
+            }
         });
     }, []);
     const getDeclFromDeclName = useCallback((name) => secondaryDeclarations.find(decl => decl.name === name), [secondaryDeclarations]);

package/lib/{client → web}/routes/CreateInstance.d.ts

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

package/lib/{client → web}/routes/CreateInstance.js

@@ -48,8 +48,10 @@ export const CreateInstance = () => {
                     route(`/entities/${entity.name}?created=${encodeURIComponent(createdInstance.instance.id)}`);
                 }
             })
-                .catch(error => {
-                alert(`Error updating instance:\n\n${error}`);
+                .catch((error) => {
+                if (error instanceof Error) {
+                    alert(`Error creating instance:\n\n${error.toString()}`);
+                }
             });
         }
     };

package/lib/web/routes/Entity.d.ts

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

package/lib/web/routes/Entity.js

@@ -0,0 +1,43 @@
+import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
+import { useRoute } from "preact-iso";
+import { useEffect } from "preact/hooks";
+import { getDisplayNameFromEntityInstance } from "../../shared/utils/displayName.js";
+import { getGitStatusForDisplay, getLabelForGitStatus } from "../../shared/utils/git.js";
+import { deleteInstanceByEntityNameAndId, getEntityByName, getInstancesByEntityName, } from "../api.js";
+import { Layout } from "../components/Layout.js";
+import { useAPIResource } from "../hooks/useAPIResource.js";
+import { useMappedAPIResource } from "../hooks/useMappedAPIResource.js";
+import { NotFound } from "./NotFound.js";
+export const Entity = () => {
+    const { params: { name }, query: { created }, } = useRoute();
+    const [entity] = useAPIResource(getEntityByName, name ?? "");
+    const [instances, reloadInstances] = useMappedAPIResource(getInstancesByEntityName, data => data.instances, name ?? "");
+    useEffect(() => {
+        if (created) {
+            const instanceElement = document.getElementById(`instance-${created}`);
+            if (instanceElement) {
+                instanceElement.scrollIntoView({ behavior: "smooth", block: "center" });
+            }
+        }
+    }, [created]);
+    if (!name) {
+        return _jsx(NotFound, {});
+    }
+    if (!entity || !instances) {
+        return (_jsxs("div", { children: [_jsx("h1", { children: name }), _jsx("p", { className: "loading", children: "Loading \u2026" })] }));
+    }
+    return (_jsxs(Layout, { breadcrumbs: [{ url: "/", label: "Home" }], children: [_jsxs("div", { class: "header-with-btns", children: [_jsx("h1", { children: name }), _jsx("a", { class: "btn btn--primary", href: `/entities/${entity.declaration.name}/instances/create`, children: "Add" })] }), entity.declaration.comment && _jsx("p", { className: "description", children: entity.declaration.comment }), _jsxs("p", { children: [instances.length, " instance", instances.length === 1 ? "" : "s"] }), _jsx("ul", { class: "instances", children: instances.map(instance => {
+                    const gitStatusForDisplay = getGitStatusForDisplay(instance.gitStatus);
+                    return (_jsxs("li", { id: `instance-${instance.id}`, class: `instance-item ${created === instance.id ? "instance-item--created" : ""} ${gitStatusForDisplay === undefined ? "" : `git-status--${gitStatusForDisplay}`}`, children: [_jsx("h2", { children: getDisplayNameFromEntityInstance(entity.declaration, instance.content, instance.id) }), _jsx("p", { "aria-hidden": true, class: "id", children: instance.id }), gitStatusForDisplay !== undefined && (_jsx("p", { class: `git-status git-status--${gitStatusForDisplay}`, title: getLabelForGitStatus(gitStatusForDisplay), children: gitStatusForDisplay })), _jsxs("div", { className: "btns", children: [_jsx("a", { href: `/entities/${entity.declaration.name}/instances/${instance.id}`, class: "btn", children: "Edit" }), _jsx("button", { class: "destructive", onClick: () => {
+                                            if (confirm("Are you sure you want to delete this instance?")) {
+                                                deleteInstanceByEntityNameAndId(entity.declaration.name, instance.id)
+                                                    .then(() => reloadInstances())
+                                                    .catch((error) => {
+                                                    if (error instanceof Error) {
+                                                        alert("Error deleting instance:\n\n" + error.toString());
+                                                    }
+                                                });
+                                            }
+                                        }, children: "Delete" })] })] }, instance.id));
+                }) })] }));
+};

package/lib/web/routes/Home.d.ts

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

package/lib/web/routes/Home.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
+import { toTitleCase } from "../../shared/utils/string.js";
+import { getAllEntities } from "../api.js";
+import { Layout } from "../components/Layout.js";
+import { useMappedAPIResource } from "../hooks/useMappedAPIResource.js";
+export const Home = () => {
+    const [entities] = useMappedAPIResource(getAllEntities, data => data.declarations.sort((a, b) => a.declaration.name.localeCompare(b.declaration.name)));
+    return (_jsxs(Layout, { breadcrumbs: [{ url: "/", label: "Home" }], children: [_jsx("h1", { children: "Entities" }), _jsx("ul", { class: "entities", children: (entities ?? []).map(entity => (_jsxs("li", { class: "entity-item", children: [_jsxs("div", { className: "title", children: [_jsx("h2", { children: toTitleCase(entity.declaration.name) }), entity.declaration.comment && _jsx("p", { children: entity.declaration.comment })] }), _jsxs("p", { class: "meta", children: [entity.instanceCount, " instance", entity.instanceCount === 1 ? "" : "s"] }), _jsx("div", { className: "btns", children: _jsx("a", { href: `/entities/${entity.declaration.name}`, class: "btn", children: "View" }) })] }, entity.declaration.name))) })] }));
+};

package/lib/{client → web}/routes/Instance.d.ts

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

package/lib/{client → web}/routes/Instance.js

@@ -26,22 +26,23 @@ export const Instance = () => {
                 setInstance(instanceData.instance);
                 setOriginalInstance(instanceData.instance);
             })
-                .catch(error => {
+                .catch((error) => {
                 console.error("Error fetching entities:", error);
             });
         }
-    }, []);
+    }, [id, name]);
     const handleSubmit = (event) => {
         event.preventDefault();
         if (name && id && instance) {
             updateInstanceByEntityNameAndId(name, id, instance.content)
                 .then(updatedInstance => {
-                0;
                 setInstance(updatedInstance.instance);
                 setOriginalInstance(updatedInstance.instance);
             })
-                .catch(error => {
-                alert(`Error updating instance:\n\n${error}`);
+                .catch((error) => {
+                if (error instanceof Error) {
+                    alert(`Error updating instance:\n\n${error}`);
+                }
             });
         }
     };
@@ -65,9 +66,14 @@ export const Instance = () => {
                                     .then(() => {
                                     route(`/entities/${name}`);
                                 })
-                                    .catch(error => {
-                                    alert("Error deleting instance:\n\n" + error);
+                                    .catch((error) => {
+                                    if (error instanceof Error) {
+                                        alert("Error deleting instance:\n\n" + error.toString());
+                                    }
                                 });
                             }
-                        }, children: "Delete" })] }), _jsxs("form", { onSubmit: handleSubmit, children: [_jsx(TypeInput, { type: entityFromRoute.entity.type, value: instance.content, instanceNamesByEntity: instanceNamesByEntity, getDeclFromDeclName: getDeclFromDeclName, onChange: value => setInstance(container => ({ ...container, content: value })) }), _jsx("button", { type: "submit", disabled: !hasChanges, class: "primary", children: "Save" })] })] }));
+                        }, children: "Delete" })] }), _jsxs("form", { onSubmit: handleSubmit, children: [_jsx(TypeInput, { type: entityFromRoute.entity.type, value: instance.content, instanceNamesByEntity: instanceNamesByEntity, getDeclFromDeclName: getDeclFromDeclName, onChange: value => {
+                            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                            setInstance(container => ({ ...container, content: value }));
+                        } }), _jsx("button", { type: "submit", disabled: !hasChanges, class: "primary", children: "Save" })] })] }));
 };

package/lib/{client → web}/routes/NotFound.d.ts

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

package/lib/web/utils/typeSkeleton.d.ts

@@ -0,0 +1,3 @@
+import type { SerializedType } from "../../node/schema/types/Type.js";
+import type { GetDeclFromDeclName } from "../hooks/useSecondaryDeclarations.js";
+export declare const createTypeSkeleton: (getDeclFromDeclName: GetDeclFromDeclName, type: SerializedType) => unknown;

package/lib/{client → web}/utils/typeSkeleton.js

@@ -17,7 +17,7 @@ export const createTypeSkeleton = (getDeclFromDeclName, type) => {
             return Object.fromEntries(Object.entries(type.properties).flatMap(([key, memberDecl]) => memberDecl.isRequired
                 ? [[key, createTypeSkeleton(getDeclFromDeclName, memberDecl.type)]]
                 : []));
-        case "GenericArgumentIdentifierType":
+        case "TypeArgumentType":
             return undefined;
         case "ReferenceIdentifierType":
             return "";
@@ -26,25 +26,22 @@ export const createTypeSkeleton = (getDeclFromDeclName, type) => {
             if (referencedDecl === undefined) {
                 return undefined;
             }
-            switch (referencedDecl.kind) {
-                case "TypeAliasDecl":
-                    return createTypeSkeleton(getDeclFromDeclName, referencedDecl.type);
-                case "EnumDecl": {
-                    const firstCase = Object.entries(referencedDecl.values)[0];
-                    if (firstCase[1].type === null) {
-                        return { kind: firstCase[0] };
-                    }
-                    return {
-                        kind: firstCase[0],
-                        [firstCase[0]]: createTypeSkeleton(getDeclFromDeclName, firstCase[1].type),
-                    };
-                }
-                default:
-                    return assertExhaustive(referencedDecl);
-            }
+            return createTypeSkeleton(getDeclFromDeclName, referencedDecl.type);
         }
         case "NestedEntityMapType":
             return {};
+        case "EnumType": {
+            const firstCase = Object.entries(type.values)[0];
+            if (firstCase === undefined) {
+                return {};
+            }
+            return {
+                kind: firstCase[0],
+                ...(firstCase[1].type === null
+                    ? {}
+                    : { [firstCase[0]]: createTypeSkeleton(getDeclFromDeclName, firstCase[1].type) }),
+            };
+        }
         default:
             return assertExhaustive(type);
     }

package/package.json

@@ -1,45 +1,65 @@
 {
   "name": "tsondb",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "",
   "license": "ISC",
   "author": "Lukas Obermann",
   "type": "module",
   "files": [
-    "lib",
+    "lib/**/*.d.ts",
+    "lib/**/*.js",
     "public"
   ],
+  "bin": {
+    "tsondb": "lib/bin/tsondb.js"
+  },
   "main": "lib/index.js",
   "exports": {
     ".": "./lib/index.js",
-    "./renderer/jsonschema": "./lib/renderers/jsonschema/index.js",
-    "./renderer/ts": "./lib/renderers/ts/index.js",
-    "./modelcontainer": "./lib/ModelContainer.js",
-    "./schema": "./lib/Schema.js",
-    "./schema/def": "./lib/schema/index.js"
+    "./renderer/jsonschema": "./lib/node/renderers/jsonschema/index.js",
+    "./renderer/ts": "./lib/node/renderers/ts/index.js",
+    "./schema": "./lib/node/Schema.js",
+    "./schema/def": "./lib/node/schema/index.js"
   },
   "scripts": {
     "build": "tsc -b",
     "watch": "tsc -b -w",
-    "test": "glob -c \"node --import tsx --test\" \"./test/**/*.ts\"",
+    "test": "node --import tsx --test",
+    "lint": "eslint",
+    "check-format": "prettier \"{src,test}/**/*.{ts,tsx}\" --check",
+    "format": "prettier \"{src,test}/**/*.{ts,tsx}\" --write",
     "release": "commit-and-tag-version"
   },
   "devDependencies": {
-    "@types/express": "^5.0.1",
-    "@types/node": "^22.13.14",
+    "@eslint/js": "^9.30.1",
+    "@types/debug": "^4.1.12",
+    "@types/express": "^5.0.3",
+    "@types/node": "^24.0.12",
     "commit-and-tag-version": "^12.5.1",
-    "glob": "^11.0.1",
-    "tsx": "^4.19.3",
-    "typescript": "^5.8.2"
+    "eslint": "^9.30.1",
+    "eslint-plugin-react": "^7.37.5",
+    "eslint-plugin-react-hooks": "^5.2.0",
+    "globals": "^16.3.0",
+    "prettier": "^3.6.2",
+    "tsx": "^4.20.3",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.36.0"
   },
   "dependencies": {
+    "debug": "^4.4.1",
     "express": "^5.1.0",
-    "preact": "^10.26.5",
-    "preact-iso": "^2.9.1",
+    "preact": "^10.26.9",
+    "preact-iso": "^2.9.2",
+    "simple-cli-args": "^0.1.0",
+    "simple-git": "^3.28.0",
+    "supports-color": "^10.0.0",
     "uuid": "^11.1.0"
   },
   "repository": "github:elyukai/tsondb",
   "bugs": {
     "url": "https://github.com/elyukai/tsondb/issues"
+  },
+  "engines": {
+    "node": ">=23.6.0"
   }
 }