tsondb 0.21.2 → 0.21.4

package/dist/src/node/git.js

@@ -1,7 +1,7 @@
 import Debug from "debug";
 import { join } from "path";
+import { HTTPError } from "../shared/utils/error.js";
 import { getAllInstanceOverviewsByEntityName } from "./utils/displayName.js";
-import { HTTPError } from "./utils/error.js";
 import { getFileNameForId } from "./utils/files.js";
 import { attachGitStatusToDatabaseInMemory } from "./utils/git.js";
 const debug = Debug("tsondb:git");

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

@@ -1,4 +1,4 @@
-import type { InstanceContainer, InstanceContainerOverview, SingletonInstanceContainer } from "../shared/utils/instances.ts";
+import type { InstanceContainer, InstanceContainerOverview, InstanceContent, SingletonInstanceContainer } from "../shared/utils/instances.ts";
 import type { FormatterOptions } from "./config.ts";
 import { Git } from "./git.js";
 import type { Output } from "./output.ts";
@@ -14,7 +14,7 @@ export interface DefaultTSONDBTypes {
     enumMap: AnyEnumMap;
     typeAliasMap: AnyTypeAliasMap;
 }
-export type Entity<T extends DefaultTSONDBTypes, E extends EntityName<T>> = T["entityMap"][E];
+export type Entity<T extends DefaultTSONDBTypes, E extends EntityName<T> = EntityName<T>> = T["entityMap"][E];
 export type EntityName<T extends DefaultTSONDBTypes> = Extract<keyof T["entityMap"], string>;
 export type SingletonEntity<T extends DefaultTSONDBTypes, E extends SingletonEntityName<T>> = T["singletonEntityMap"][E];
 export type SingletonEntityName<T extends DefaultTSONDBTypes> = Extract<keyof T["singletonEntityMap"], string>;
@@ -191,6 +191,22 @@ export declare class TSONDB<T extends DefaultTSONDBTypes = DefaultTSONDBTypes> {
      * @throws {Error} when the instance could not be deleted
      */
     deleteSingletonInstance<E extends SingletonEntityName<T>>(entityName: E): Promise<SingletonEntity<T, E>>;
+    /**
+     * Reorders all instances of an entity in the database.
+     *
+     * The entity must have a custom sort order via an integer field defined.
+     *
+     * @throws {Error}
+     */
+    reorderAllInstancesOfEntity(entityName: EntityName<T> | EntityDecl<EntityName<T>>, newOrder: string[]): Promise<void>;
+    /**
+     * Reorders an instance of an entity in the database.
+     *
+     * The entity must have a custom sort order via an integer field defined.
+     *
+     * @throws {Error}
+     */
+    reorderInstanceOfEntity(entityName: EntityName<T> | EntityDecl<EntityName<T>>, instanceId: string, newIndex: number): Promise<[id: string, oldContent: InstanceContent, newContent: InstanceContent][]>;
     /**
      * Retrieves an instance of the specified entity by its identifier.
      */

package/dist/src/node/index.js

@@ -11,6 +11,7 @@ import { stderr } from "node:process";
 import { styleText } from "node:util";
 import { simpleGit } from "simple-git";
 import { NodeKind } from "../shared/schema/Node.js";
+import { countError, countErrors, getErrorMessageForDisplay, HTTPError, wrapErrorsIfAny, } from "../shared/utils/error.js";
 import { parallelizeErrors } from "../shared/utils/validation.js";
 import { Git } from "./git.js";
 import { getDisplayName, getDisplayNameWithId } from "./schema/detached.js";
@@ -24,7 +25,6 @@ import { checkCustomConstraintsForAllEntities } from "./utils/customConstraints.
 import { DatabaseInMemory } from "./utils/databaseInMemory.js";
 import { applyStepsToDisk } from "./utils/databaseOnDisk.js";
 import { getAllInstanceOverviewsByEntityName, getDisplayNameFromEntityInstance, getInstanceOverview, getInstanceOverviewsByEntityName, } from "./utils/displayName.js";
-import { countError, countErrors, getErrorMessageForDisplay, HTTPError, wrapErrorsIfAny, } from "./utils/error.js";
 import { formatInstance, getFileNameForId, getSingletonFileName, readInstance, readSingletonInstance, writeInstance, writeSingletonInstance, } from "./utils/files.js";
 import { attachGitStatusToDatabaseInMemory } from "./utils/git.js";
 import { getReferencesToInstances, isReferencedByOtherInstances, } from "./utils/references.js";
@@ -509,6 +509,33 @@ export class TSONDB {
         txn.deleteSingletonInstance(this.#schema.getSingletonEntity(entityName)));
         return res.content;
     }
+    /**
+     * Reorders all instances of an entity in the database.
+     *
+     * The entity must have a custom sort order via an integer field defined.
+     *
+     * @throws {Error}
+     */
+    async reorderAllInstancesOfEntity(entityName, newOrder) {
+        return this.runTransaction(txn => [
+            txn.reorderAllInstancesOfEntity(
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            typeof entityName === "string" ? this.#schema.getEntity(entityName) : entityName, newOrder),
+            undefined,
+        ]);
+    }
+    /**
+     * Reorders an instance of an entity in the database.
+     *
+     * The entity must have a custom sort order via an integer field defined.
+     *
+     * @throws {Error}
+     */
+    async reorderInstanceOfEntity(entityName, instanceId, newIndex) {
+        return this.runTransaction(txn => txn.reorderInstanceOfEntity(
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        typeof entityName === "string" ? this.#schema.getEntity(entityName) : entityName, instanceId, newIndex));
+    }
     /**
      * Retrieves an instance of the specified entity by its identifier.
      */

package/dist/src/node/renderers/ts/render.js

@@ -5,6 +5,7 @@ import { EOL } from "node:os";
 import { dirname, relative } from "node:path";
 import { ENUM_DISCRIMINATOR_KEY } from "../../../shared/schema/declarations/EnumDecl.js";
 import { NodeKind } from "../../../shared/schema/Node.js";
+import { combineSyntaxes, emptyRenderResult, getIndentation, indent, prefixLines, syntax, } from "../../../shared/utils/render.js";
 import { extractParameterTypeNamesFromMessage, mapParameterTypeNames, } from "../../../shared/utils/translation.js";
 import { asDecl } from "../../schema/dsl/declarations/Decl.js";
 import { addEphemeralUUIDToType, createEntityIdentifierTypeAsDecl, isEntityDecl, isEntityDeclWithParentReference, } from "../../schema/dsl/declarations/EntityDecl.js";
@@ -16,7 +17,6 @@ import { isObjectType } from "../../schema/dsl/types/ObjectType.js";
 import { getTypeOfKey } from "../../schema/dsl/types/TranslationObjectType.js";
 import { flatMapAuxiliaryDecls, isFinalChildEntitiesType } from "../../schema/helpers.js";
 import { ensureSpecialDirStart } from "../../utils/path.js";
-import { combineSyntaxes, emptyRenderResult, getIndentation, indent, prefixLines, syntax, } from "../../utils/render.js";
 const defaultOptions = {
     indentation: 2,
     objectTypeKeyword: "interface",

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

@@ -440,6 +440,13 @@ const checkSortOrders = (declarations) => {
                 if (!isValidSortOrderType(type)) {
                     throw TypeError(`type at key path "${renderKeyPath(sortOrder.keyPath)}" is not a valid sort order type (string, integer, or float) in entity "${decl.name}"`);
                 }
+                if (sortOrder.isIndex &&
+                    (!isIntegerType(type) ||
+                        type.maximum !== undefined ||
+                        (typeof type.minimum === "object" && type.minimum.isExclusive) ||
+                        type.multipleOf !== undefined)) {
+                    throw TypeError(`type at key path ${renderKeyPath(sortOrder.keyPath)} is not a valid index sort order type (integer, optional inclusive minimum, no other constraints) in entity "${decl.name}"`);
+                }
             }
             else {
                 // const entityMapType = getType(decl.type.value, sortOrder.entityMapKeyPath)

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

@@ -4,6 +4,7 @@ import { assertExhaustive } from "@elyukai/utils/typeSafety";
 import { MessageError, parseMessage, validate } from "messageformat";
 import { ENUM_DISCRIMINATOR_KEY } from "../../../shared/schema/declarations/EnumDecl.js";
 import { NodeKind } from "../../../shared/schema/Node.js";
+import { wrapErrorsIfAny } from "../../../shared/utils/error.js";
 import { extendsParameterTypes, extractParameterTypeNamesFromMessage, } from "../../../shared/utils/translation.js";
 import { parallelizeErrors } from "../../../shared/utils/validation.js";
 import { validateArrayConstraints } from "../../../shared/validation/array.js";
@@ -12,7 +13,6 @@ import { validateNumberConstraints } from "../../../shared/validation/number.js"
 import { validateObjectConstraints, validateObjectRangeConstraints, validateUnknownKeys, } from "../../../shared/validation/object.js";
 import { validateStringConstraints } from "../../../shared/validation/string.js";
 import {} from "../../utils/databaseInMemory.js";
-import { wrapErrorsIfAny } from "../../utils/error.js";
 import { entity, json, key } from "../../utils/errorFormatting.js";
 import { getTypeArgumentsRecord } from "../dsl/declarations/Decl.js";
 import { createEntityIdentifierType } from "../dsl/declarations/EntityDecl.js";

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

@@ -148,6 +148,50 @@ declarationsApi.post("/:name/instances", async (req, res) => {
         sendErrorResponse(res, err);
     }
 });
+declarationsApi.put("/:name/instances/reorder", async (req, res) => {
+    const decl = req.db.schema.getResolvedDeclaration(req.params.name);
+    if (decl === undefined) {
+        res.status(404).send(`Declaration "${req.params.name}" not found`);
+        return;
+    }
+    if (!isEntityDecl(decl)) {
+        res.status(400).send(`Declaration "${decl.name}" is not an entity`);
+        return;
+    }
+    try {
+        const requestBody = req.body;
+        await req.db.reorderAllInstancesOfEntity(decl, requestBody.order);
+        const body = {
+            instances: req.db.getAllInstanceOverviewsOfEntity(decl.name),
+        };
+        res.json(body);
+    }
+    catch (err) {
+        sendErrorResponse(res, err);
+    }
+});
+declarationsApi.put("/:name/instances/reorder/:id", async (req, res) => {
+    const decl = req.db.schema.getResolvedDeclaration(req.params.name);
+    if (decl === undefined) {
+        res.status(404).send(`Declaration "${req.params.name}" not found`);
+        return;
+    }
+    if (!isEntityDecl(decl)) {
+        res.status(400).send(`Declaration "${decl.name}" is not an entity`);
+        return;
+    }
+    try {
+        const requestBody = req.body;
+        await req.db.reorderInstanceOfEntity(decl, req.params.id, requestBody.targetIndex);
+        const body = {
+            instances: req.db.getAllInstanceOverviewsOfEntity(decl.name),
+        };
+        res.json(body);
+    }
+    catch (err) {
+        sendErrorResponse(res, err);
+    }
+});
 declarationsApi.get("/:name/instances/:id", (req, res) => {
     const decl = req.db.schema.getResolvedDeclaration(req.params.name);
     if (decl === undefined) {

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

@@ -1,5 +1,5 @@
+import { HTTPError } from "../../../shared/utils/error.js";
 import { getChildInstances, saveInstanceTree } from "../../utils/childInstances.js";
-import { HTTPError } from "../../utils/error.js";
 export const createInstance = async (db, instance, idQueryParam) => {
     const getEntity = db.schema.getEntity.bind(db.schema);
     const entity = getEntity(instance.entityName);

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

@@ -52,6 +52,11 @@ export declare class Transaction<EM extends AnyEntityMap = RegisteredEntityMap,
     createSingletonInstance(entity: SingletonEntityDecl<Extract<keyof SEM, string>>, instanceContent: InstanceContent): [Transaction<EM, SEM>, SingletonInstanceContainer];
     updateSingletonInstance(entity: SingletonEntityDecl<Extract<keyof SEM, string>>, instanceContent: InstanceContent): [Transaction<EM, SEM>, SingletonInstanceContainer];
     deleteSingletonInstance(entity: SingletonEntityDecl<Extract<keyof SEM, string>>): [Transaction<EM, SEM>, SingletonInstanceContainer];
+    reorderAllInstancesOfEntity(entity: EntityDecl<Extract<keyof EM, string>>, newOrder: string[]): Transaction<EM, SEM>;
+    reorderInstanceOfEntity(entity: EntityDecl<Extract<keyof EM, string>>, instanceId: string, newIndex: number): [
+        Transaction<EM, SEM>,
+        changedInstances: [id: string, oldContent: InstanceContent, newContent: InstanceContent][]
+    ];
     /**
      * @package
      */

package/dist/src/node/transaction.js

@@ -1,8 +1,11 @@
+import { isEmpty } from "@elyukai/utils/array/nonEmpty";
 import { randomUUID } from "node:crypto";
+import { getSortOrderKeyPathForReorder } from "../shared/schema/utils/sortOrder.js";
+import { getErrorMessageForDisplay, HTTPError } from "../shared/utils/error.js";
 import {} from "./schema/dsl/index.js";
 import {} from "./utils/databaseInMemory.js";
-import { getErrorMessageForDisplay, HTTPError } from "./utils/error.js";
 import { isReferencedByOtherInstances, updateReferencesToInstances, } from "./utils/references.js";
+import { getSortOrderStartIndex } from "./utils/sortOrder.js";
 export const createNewId = () => randomUUID();
 /**
  * @throws {HTTPError}
@@ -208,6 +211,51 @@ export class Transaction {
             { content: oldInstance },
         ];
     }
+    reorderAllInstancesOfEntity(entity, newOrder) {
+        const { data, steps } = this.#values;
+        const positionKeyPath = getSortOrderKeyPathForReorder(entity);
+        const startIndex = getSortOrderStartIndex(entity);
+        const newData = data.reorderAllInstancesOfEntity(entity.name, positionKeyPath, newOrder, startIndex);
+        const newSteps = newData
+            .getAllInstanceContainersOfEntity(entity.name)
+            .map(instance => ({
+            kind: "update",
+            entity,
+            instanceId: instance.id,
+            instanceContent: instance.content,
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            oldInstance: data.getInstanceContainerOfEntityById(entity.name, instance.id).content,
+        }));
+        return new Transaction({
+            ...this.#values,
+            data: newData,
+            steps: [...steps, ...newSteps],
+        });
+    }
+    reorderInstanceOfEntity(entity, instanceId, newIndex) {
+        const { data, steps } = this.#values;
+        const startIndex = getSortOrderStartIndex(entity);
+        const positionKeyPath = getSortOrderKeyPathForReorder(entity);
+        const [newData, changedInstances] = data.reorderInstanceOfEntity(entity.name, positionKeyPath, instanceId, newIndex, startIndex);
+        if (isEmpty(changedInstances)) {
+            return [this, changedInstances];
+        }
+        const newSteps = changedInstances.map(([id, oldContent, newContent]) => ({
+            kind: "update",
+            entity,
+            instanceId: id,
+            instanceContent: newContent,
+            oldInstance: oldContent,
+        }));
+        return [
+            new Transaction({
+                ...this.#values,
+                data: newData,
+                steps: [...steps, ...newSteps],
+            }),
+            changedInstances,
+        ];
+    }
     /**
      * @package
      */

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

@@ -2,13 +2,13 @@ import { hasKey } from "@elyukai/utils/object";
 import { error, isError, ok } from "@elyukai/utils/result";
 import { createEnumCaseValue, ENUM_DISCRIMINATOR_KEY, } from "../../shared/schema/declarations/EnumDecl.js";
 import { NodeKind } from "../../shared/schema/Node.js";
+import { HTTPError } from "../../shared/utils/error.js";
 import {} from "../schema/dsl/index.js";
 import { isChildEntitiesType } from "../schema/dsl/types/ChildEntitiesType.js";
 import { Case } from "../schema/generatedTypeHelpers.js";
 import { isEntityDeclWithParentReference, isEnumDecl, isIncludeIdentifierType, isReferenceIdentifierType, } from "../schema/guards.js";
 import { reduceNodes } from "../schema/helpers.js";
 import {} from "./databaseInMemory.js";
-import { HTTPError } from "./error.js";
 const isParentReferenceReferencingParent = (value, parentEntityName, parentId) => {
     if (typeof value === "object" && value !== null && hasKey(value, ENUM_DISCRIMINATOR_KEY)) {
         return (value[ENUM_DISCRIMINATOR_KEY] === parentEntityName &&

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

@@ -1,4 +1,5 @@
 import { Dictionary } from "@elyukai/utils/dictionary";
+import { type KeyPath } from "../../shared/schema/utils/keyPath.ts";
 import type { InstanceContainer, InstanceContent, SingletonInstanceContainer } from "../../shared/utils/instances.ts";
 import type { EntityDecl, SingletonEntityDecl } from "../schema/dsl/index.ts";
 import { type AnyChildEntityMap, type AnyEntityMap, type AnySingletonEntityMap, type GetEntityByName, type IdArgsVariant, type RegisteredEntityMap, type RegisteredSingletonEntityMap } from "../schema/generatedTypeHelpers.ts";
@@ -21,6 +22,8 @@ export declare class DatabaseInMemory<EM extends AnyEntityMap = RegisteredEntity
     hasInstanceOfSingletonEntity(entityName: Extract<keyof SEM, string>): boolean;
     forEachInstance(fn: (entityName: Extract<keyof EM, string>, instance: InstanceContainer) => Promise<void>, async: true): Promise<void>;
     forEachInstance(fn: (entityName: Extract<keyof EM, string>, instance: InstanceContainer) => void, async?: false): void;
+    forEachInstanceOfEntity(entityName: Extract<keyof EM, string>, fn: (instance: InstanceContainer) => Promise<void>, async: true): Promise<void>;
+    forEachInstanceOfEntity(entityName: Extract<keyof EM, string>, fn: (instance: InstanceContainer) => void, async?: false): void;
     forEachSingletonInstance(fn: (entityName: Extract<keyof SEM, string>, instance: SingletonInstanceContainer) => Promise<void>, async: true): Promise<void>;
     forEachSingletonInstance(fn: (entityName: Extract<keyof SEM, string>, instance: SingletonInstanceContainer) => void, async?: false): void;
     countInstancesOfEntity(entityName: Extract<keyof EM, string>): number;
@@ -34,4 +37,9 @@ export declare class DatabaseInMemory<EM extends AnyEntityMap = RegisteredEntity
     map(fn: (instances: Dictionary<InstanceContainer>, entityName: Extract<keyof EM, string>) => Dictionary<InstanceContainer>): DatabaseInMemory<EM, SEM>;
     mapSingletons(fn: (instance: SingletonInstanceContainer, entityName: Extract<keyof SEM, string>) => SingletonInstanceContainer): DatabaseInMemory<EM, SEM>;
     getEntityNameOfInstanceId(id: string): Extract<keyof EM, string> | undefined;
+    reorderAllInstancesOfEntity(entityName: Extract<keyof EM, string>, keyPath: KeyPath, newOrder: string[], startIndex?: number): DatabaseInMemory<EM, SEM>;
+    reorderInstanceOfEntity(entityName: Extract<keyof EM, string>, keyPath: KeyPath, instanceId: string, newIndex: number, startIndex?: number): [
+        DatabaseInMemory<EM, SEM>,
+        changedInstances: [id: string, oldContent: InstanceContent, newContent: InstanceContent][]
+    ];
 }

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

@@ -1,12 +1,17 @@
+import { reorder } from "@elyukai/utils/array/modify";
 import { mapAsync } from "@elyukai/utils/async";
 import { Dictionary } from "@elyukai/utils/dictionary";
 import { deepEqual } from "@elyukai/utils/equality";
+import { on } from "@elyukai/utils/function";
 import { Lazy } from "@elyukai/utils/lazy";
+import { compareNumber } from "@elyukai/utils/ordering";
 import child_process from "node:child_process";
 import { readdir, readFile, stat } from "node:fs/promises";
 import { basename, extname, join } from "node:path";
 import { platform } from "node:process";
 import { promisify } from "node:util";
+import { getValueAtKeyPathIfDefined, setValueAtKeyPath, } from "../../shared/schema/utils/keyPath.js";
+import { HTTPError } from "../../shared/utils/error.js";
 import { normalizedIdArgs, } from "../schema/generatedTypeHelpers.js";
 import { getPathToSingletonInstance, readSingletonInstance } from "./files.js";
 const exec = promisify(child_process.exec);
@@ -102,6 +107,15 @@ export class DatabaseInMemory {
             });
         }
     }
+    forEachInstanceOfEntity(entityName, ...args) {
+        const [fn, async] = args;
+        if (async) {
+            return this.#data.get(entityName)?.forEach(fn, true);
+        }
+        else {
+            this.#data.get(entityName)?.forEach(fn);
+        }
+    }
     forEachSingletonInstance(...args) {
         const [fn, async] = args;
         if (async) {
@@ -178,4 +192,49 @@ export class DatabaseInMemory {
     getEntityNameOfInstanceId(id) {
         return this.#data.findKey(instances => instances.has(id));
     }
+    reorderAllInstancesOfEntity(entityName, keyPath, newOrder, startIndex = 0) {
+        const instancesWithPositions = this.getAllInstanceContainersOfEntity(entityName).map(instance => [instance.id, getValueAtKeyPathIfDefined(instance.content, keyPath)]);
+        if (newOrder.length !== instancesWithPositions.length) {
+            throw new HTTPError(400, `New order of instances (${newOrder.length.toFixed()} elements) does not match the amount of instances in entity "${entityName}" (${instancesWithPositions.length.toFixed()} instances)`);
+        }
+        if (instancesWithPositions.some(([id]) => !newOrder.includes(id))) {
+            throw new HTTPError(400, `Identifiers in the new order do not match existing instance identifiers for entity "${entityName}"`);
+        }
+        return new DatabaseInMemory(instancesWithPositions.reduce((db, [id]) => db.modify(entityName, instances => instances?.modify(id, instanceContainer => instanceContainer === undefined
+            ? undefined
+            : {
+                ...instanceContainer,
+                content: setValueAtKeyPath(instanceContainer.content, keyPath, newOrder.indexOf(id) + startIndex),
+            })), this.#data), this.#singletonData);
+    }
+    reorderInstanceOfEntity(entityName, keyPath, instanceId, newIndex, startIndex = 0) {
+        const instancesWithPositions = this.getAllInstanceContainersOfEntity(entityName).map(instance => [instance.id, getValueAtKeyPathIfDefined(instance.content, keyPath)]);
+        const normalizedInstancesWithPositions = instancesWithPositions.toSorted(on(([_, position]) => position, compareNumber));
+        const currentIndex = normalizedInstancesWithPositions.findIndex(([id]) => id === instanceId);
+        if (currentIndex === -1) {
+            throw new HTTPError(400, `Instance with ID "${instanceId}" does not exist in entity "${entityName}"`);
+        }
+        const newSafeIndex = Math.max(0, Math.min(newIndex, normalizedInstancesWithPositions.length - 1));
+        if (currentIndex === newSafeIndex) {
+            return [this, []];
+        }
+        const reorderedInstances = reorder(normalizedInstancesWithPositions, currentIndex, newSafeIndex);
+        const changedInstances = [];
+        return [
+            new DatabaseInMemory(reorderedInstances.reduce((db, [id], index) => db.modify(entityName, instances => instances?.modify(id, instanceContainer => {
+                if (instanceContainer === undefined) {
+                    return undefined;
+                }
+                const oldContent = instanceContainer.content;
+                const currentPosition = getValueAtKeyPathIfDefined(oldContent, keyPath);
+                if (currentPosition === index + startIndex) {
+                    return instanceContainer;
+                }
+                const newContent = setValueAtKeyPath(oldContent, keyPath, index + startIndex);
+                changedInstances.push([id, oldContent, newContent]);
+                return { ...instanceContainer, content: newContent };
+            })), this.#data), this.#singletonData),
+            changedInstances,
+        ];
+    }
 }

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

@@ -1,10 +1,2 @@
 import type { Response } from "express";
-export declare const getErrorMessageForDisplay: (error: Error, indentation?: number) => string;
-export declare const countError: (error: Error) => number;
-export declare const countErrors: (errors: Error[]) => number;
-export declare const wrapErrorsIfAny: (message: string, errors: Error[]) => AggregateError | undefined;
-export declare class HTTPError extends Error {
-    code: number;
-    constructor(code: number, message: string);
-}
 export declare const sendErrorResponse: (res: Response, error: unknown) => void;

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

@@ -1,42 +1,4 @@
-import { applyIndentation } from "./render.js";
-import { UniqueConstraintError } from "./unique.js";
-export const getErrorMessageForDisplay = (error, indentation = 2) => {
-    if (error instanceof AggregateError) {
-        return `${error.message}\n${applyIndentation(1, error.errors
-            .filter(subError => subError instanceof Error)
-            .map(subError => getErrorMessageForDisplay(subError, indentation))
-            .join("\n"), indentation)}`;
-    }
-    else if (error.cause instanceof Error) {
-        return `${error.message}\n${applyIndentation(1, getErrorMessageForDisplay(error.cause, indentation), indentation)}`;
-    }
-    else if (error instanceof UniqueConstraintError) {
-        return `${error.message}\n${applyIndentation(1, error.parts.join("\n"), indentation)}`;
-    }
-    else {
-        return error.message;
-    }
-};
-export const countError = (error) => error instanceof AggregateError
-    ? countErrors(error.errors.filter(subError => subError instanceof Error))
-    : error.cause instanceof Error
-        ? countError(error.cause)
-        : 1;
-export const countErrors = (errors) => errors.reduce((count, error) => count + countError(error), 0);
-export const wrapErrorsIfAny = (message, errors) => {
-    if (errors.length === 0) {
-        return undefined;
-    }
-    return new AggregateError(errors, message);
-};
-export class HTTPError extends Error {
-    code;
-    constructor(code, message) {
-        super(message);
-        this.code = code;
-        this.name = "HTTPError";
-    }
-}
+import { getErrorMessageForDisplay, HTTPError } from "../../shared/utils/error.js";
 export const sendErrorResponse = (res, error) => {
     res.set("Content-Type", "text/plain");
     if (error instanceof HTTPError) {

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

@@ -0,0 +1,13 @@
+import type { Lazy } from "@elyukai/utils/lazy";
+import { type SortOrder } from "../../shared/schema/utils/sortOrder.ts";
+import type { IntegerType, Type } from "../schema/dsl/index.ts";
+export declare const getSortOrderType: (decl: {
+    name: string;
+    type: Lazy<Type>;
+    sortOrder?: SortOrder;
+}) => IntegerType;
+export declare const getSortOrderStartIndex: (decl: {
+    name: string;
+    type: Lazy<Type>;
+    sortOrder?: SortOrder;
+}) => number;

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

@@ -0,0 +1,12 @@
+import { getSortOrderKeyPathForReorder, } from "../../shared/schema/utils/sortOrder.js";
+import { findTypeAtPath } from "../schema/helpers.js";
+export const getSortOrderType = (decl) => {
+    const keyPath = getSortOrderKeyPathForReorder(decl);
+    return findTypeAtPath(decl.type.value, keyPath, { throwOnPathMismatch: true });
+};
+export const getSortOrderStartIndex = (decl) => {
+    const sortOrderType = getSortOrderType(decl);
+    return typeof sortOrderType.minimum === "number"
+        ? sortOrderType.minimum
+        : (sortOrderType.minimum?.value ?? 0);
+};

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

@@ -2,10 +2,6 @@ import { type Result } from "@elyukai/utils/result";
 import type { InstanceContainer, InstanceContainerOverview } from "../../shared/utils/instances.ts";
 import type { EntityDecl } from "../schema/dsl/index.ts";
 import { type DatabaseInMemory } from "./databaseInMemory.ts";
-export declare class UniqueConstraintError extends Error {
-    readonly parts: string[];
-    constructor(message: string, parts: string[]);
-}
 /**
  * Checks all unique constraints for the provided entity and its instances.
  *

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

@@ -3,14 +3,8 @@ import { flatCombine } from "@elyukai/utils/array/transformations";
 import { deepEqual } from "@elyukai/utils/equality";
 import { error, isError, mapError, ok } from "@elyukai/utils/result";
 import { getValueAtKeyPath, getValueAtKeyPathIfDefined, renderKeyPath, } from "../../shared/schema/utils/keyPath.js";
+import { UniqueConstraintError } from "../../shared/utils/unique.js";
 import {} from "./databaseInMemory.js";
-export class UniqueConstraintError extends Error {
-    parts;
-    constructor(message, parts) {
-        super(message);
-        this.parts = parts;
-    }
-}
 const printUniqueConstraint = (constraint, values) => (Array.isArray(constraint) ? constraint : [constraint])
     .map((elem, i) => "keyPath" in elem
     ? renderKeyPath(elem.keyPath) +

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

@@ -58,6 +58,24 @@ export interface CreateInstanceOfEntityResponseBody {
     instance: InstanceContainer;
     isLocaleEntity: boolean;
 }
+export interface ReorderAllInstancesOfEntityRequestBody {
+    /**
+     * All identifiers in the requested order.
+     */
+    order: string[];
+}
+export interface ReorderAllInstancesOfEntityResponseBody {
+    instances: InstanceContainerOverview[];
+}
+export interface ReorderInstanceOfEntityRequestBody {
+    /**
+     * The 0-based index of the instance in the new order.
+     */
+    targetIndex: number;
+}
+export interface ReorderInstanceOfEntityResponseBody {
+    instances: InstanceContainerOverview[];
+}
 export interface GetInstanceOfEntityResponseBody {
     instance: InstanceContainer;
     isLocaleEntity: boolean;

package/dist/src/shared/schema/utils/keyPath.d.ts

@@ -15,3 +15,4 @@ export declare const renderParsedKeyPath: (keyPath: ParsedKeyPath) => string;
 export declare const getAtKeyPath: <T>(value: T, previousPath: ParsedKeyPath, remainingKeyPath: ParsedKeyPath, throwOnPathMismatch: boolean, fArray: (value: T, index: number) => Result<T, (previousPath: string) => string>, fObject: (value: T, key: string) => Result<T, (previousPath: string) => string>, ...fs: ((value: T, key: KeyPathElement) => Result<[T, skipKey?: boolean], void>)[]) => T;
 export declare const getValueAtKeyPath: (value: unknown, keyPath: KeyPath, throwOnPathMismatch?: boolean) => unknown;
 export declare const getValueAtKeyPathIfDefined: (value: unknown, keyPath: KeyPath) => unknown;
+export declare const setValueAtKeyPath: (value: unknown, keyPath: KeyPath, newValue: unknown) => unknown;

package/dist/src/shared/schema/utils/keyPath.js

@@ -64,3 +64,33 @@ export const getValueAtKeyPath = (value, keyPath, throwOnPathMismatch = false) =
         : error(previousPath => `Object at key path "${previousPath}" does not contain the key ${name}.`)
     : error(previousPath => `Key path "${previousPath}" does not contain an object.`));
 export const getValueAtKeyPathIfDefined = (value, keyPath) => trySafe(() => getValueAtKeyPath(value, keyPath, true));
+const _setValueAtKeyPath = (value, keyPath, newValue) => {
+    if (isNotEmpty(keyPath)) {
+        const [key, ...remainingPath] = keyPath;
+        switch (key.kind) {
+            case "index":
+                if (!Array.isArray(value)) {
+                    throw new TypeError(`Key path "${renderParsedKeyPath(keyPath)}" does not contain an array.`);
+                }
+                return [
+                    ...value.slice(0, key.index),
+                    _setValueAtKeyPath(value[key.index], remainingPath, newValue),
+                    ...value.slice(key.index + 1),
+                ];
+            case "property":
+                if (typeof value !== "object" || value === null) {
+                    throw new TypeError(`Key path "${renderParsedKeyPath(keyPath)}" does not contain an object.`);
+                }
+                return {
+                    ...value,
+                    [key.name]: _setValueAtKeyPath(value[key.name], remainingPath, newValue),
+                };
+            default:
+                return assertExhaustive(key);
+        }
+    }
+    else {
+        return newValue;
+    }
+};
+export const setValueAtKeyPath = (value, keyPath, newValue) => _setValueAtKeyPath(value, parseKeyPath(keyPath), newValue);

package/dist/src/shared/schema/utils/sortOrder.d.ts

@@ -6,6 +6,7 @@ import { type KeyPath } from "./keyPath.ts";
  */
 export type SortOrder = "displayName" | {
     keyPath: KeyPath;
+    isIndex?: boolean;
 };
 /**
  * An instance with all values needed for sorting.
@@ -15,3 +16,11 @@ export type SortableInstance = [InstanceContainer, InstanceContainerOverview];
  * Sorts instances according to the sort order defined for the entity.
  */
 export declare const sortBySortOrder: <T extends SortableInstance>(instances: T[], sortOrder: SortOrder | undefined) => T[];
+export declare const getSortOrderKeyPathForReorder: (decl: {
+    name: string;
+    sortOrder?: SortOrder;
+}) => KeyPath;
+export declare const isReorderableSortOrder: (sortOrder: SortOrder | undefined) => sortOrder is {
+    keyPath: KeyPath;
+    isIndex: true;
+};

package/dist/src/shared/schema/utils/sortOrder.js

@@ -1,15 +1,10 @@
+import { HTTPError } from "../../utils/error.js";
 import { getValueAtKeyPath } from "./keyPath.js";
-// | { entityMapKeyPath: KeyPath; keyPathInEntityMap: KeyPath }
 const getSortOrderValue = (instanceContent, sortOrder) => {
     if ("keyPath" in sortOrder) {
         return getValueAtKeyPath(instanceContent, sortOrder.keyPath);
     }
     else {
-        // const entityMap = instance.getValueAtKeyPath(sortOrder.entityMapKeyPath)
-        // if (entityMap && typeof entityMap === "object") {
-        //   const nestedInstance = InstanceContent.fromUnknown(entityMap)
-        //   return nestedInstance.getValueAtKeyPath(sortOrder.keyPathInEntityMap)
-        // }
         return;
     }
 };
@@ -36,3 +31,13 @@ export const sortBySortOrder = (instances, sortOrder) => {
             .map(({ instance }) => instance);
     }
 };
+export const getSortOrderKeyPathForReorder = (decl) => {
+    const { sortOrder } = decl;
+    if (isReorderableSortOrder(sortOrder)) {
+        return sortOrder.keyPath;
+    }
+    else {
+        throw new HTTPError(400, `Declaration "${decl.name}" does not have the sort order defined correctly. Please check the validity of the whole schema as any incorrect configuration should have been caught during schema intialization.`);
+    }
+};
+export const isReorderableSortOrder = (sortOrder) => typeof sortOrder === "object" && sortOrder.isIndex === true;

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

@@ -0,0 +1,8 @@
+export declare const getErrorMessageForDisplay: (error: Error, indentation?: number) => string;
+export declare const countError: (error: Error) => number;
+export declare const countErrors: (errors: Error[]) => number;
+export declare const wrapErrorsIfAny: (message: string, errors: Error[]) => AggregateError | undefined;
+export declare class HTTPError extends Error {
+    code: number;
+    constructor(code: number, message: string);
+}

package/dist/src/shared/utils/error.js

@@ -0,0 +1,39 @@
+import { applyIndentation } from "../../shared/utils/render.js";
+import { UniqueConstraintError } from "./unique.js";
+export const getErrorMessageForDisplay = (error, indentation = 2) => {
+    if (error instanceof AggregateError) {
+        return `${error.message}\n${applyIndentation(1, error.errors
+            .filter(subError => subError instanceof Error)
+            .map(subError => getErrorMessageForDisplay(subError, indentation))
+            .join("\n"), indentation)}`;
+    }
+    else if (error.cause instanceof Error) {
+        return `${error.message}\n${applyIndentation(1, getErrorMessageForDisplay(error.cause, indentation), indentation)}`;
+    }
+    else if (error instanceof UniqueConstraintError) {
+        return `${error.message}\n${applyIndentation(1, error.parts.join("\n"), indentation)}`;
+    }
+    else {
+        return error.message;
+    }
+};
+export const countError = (error) => error instanceof AggregateError
+    ? countErrors(error.errors.filter(subError => subError instanceof Error))
+    : error.cause instanceof Error
+        ? countError(error.cause)
+        : 1;
+export const countErrors = (errors) => errors.reduce((count, error) => count + countError(error), 0);
+export const wrapErrorsIfAny = (message, errors) => {
+    if (errors.length === 0) {
+        return undefined;
+    }
+    return new AggregateError(errors, message);
+};
+export class HTTPError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "HTTPError";
+    }
+}

package/dist/src/{node → shared}/utils/render.js

@@ -1,5 +1,5 @@
 import { mergeObjects } from "@elyukai/utils/object";
-import { EOL } from "node:os";
+const EOL = await import("node:os").then(module => module.EOL).catch(() => "\n");
 export const prefixLines = (prefix, text, includeEmptyLines = false) => text
     .split(EOL)
     .map(line => (includeEmptyLines || line.length > 0 ? prefix + line : line))

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

@@ -0,0 +1,4 @@
+export declare class UniqueConstraintError extends Error {
+    readonly parts: string[];
+    constructor(message: string, parts: string[]);
+}

package/dist/src/shared/utils/unique.js

@@ -0,0 +1,7 @@
+export class UniqueConstraintError extends Error {
+    parts;
+    constructor(message, parts) {
+        super(message);
+        this.parts = parts;
+    }
+}

package/dist/src/web/web.js

@@ -728,7 +728,7 @@ const request = async (method, url, options)=>{
 };
 const api_getResource = async (url, options)=>request("GET", url, options);
 const postResource = async (url, options)=>request("POST", url, options);
-const putResource = async (url, options)=>request("PUT", url, options);
+const api_putResource = async (url, options)=>request("PUT", url, options);
 const deleteResource = async (url, options)=>request("DELETE", url, options);
 const getAllDeclarations = async (locales, kind)=>api_getResource("/api/declarations", {
         locales,
@@ -741,6 +741,15 @@ const getAllSingletonEntities = (locales)=>getAllDeclarations(locales, "Singleto
 const getInstancesByEntityName = async (locales, name)=>api_getResource(`/api/declarations/${name}/instances`, {
         locales
     });
+const reorderAllInstancesInEntity = async (locales, name, newOrder)=>{
+    const body = {
+        order: newOrder
+    };
+    return api_putResource(`/api/declarations/${name}/instances/reorder`, {
+        locales,
+        body
+    });
+};
 const getLocaleInstances = (locales, localeEntityName)=>localeEntityName ? getInstancesByEntityName(locales, localeEntityName) : Promise.resolve({
         instances: [],
         isLocaleEntity: true
@@ -764,7 +773,7 @@ const updateInstanceByEntityNameAndId = async (locales, name, id, content)=>{
     const body = {
         instance: content
     };
-    return putResource(`/api/declarations/${name}/instances/${id}`, {
+    return api_putResource(`/api/declarations/${name}/instances/${id}`, {
         locales,
         body
     });
@@ -791,7 +800,7 @@ const updateSingletonInstanceByEntityName = async (locales, name, content)=>{
     const body = {
         instance: content
     };
-    return putResource(`/api/declarations/${name}/instance`, {
+    return api_putResource(`/api/declarations/${name}/instance`, {
         locales,
         body
     });
@@ -2404,6 +2413,13 @@ const useMappedAPIResource = (apiFn, mapFn, ...args)=>{
         mapFn,
         ...args
     ]);
+    const setNewData = hooks_module_q((result)=>{
+        setData(mapFn(result));
+    }, [
+        apiFn,
+        mapFn,
+        ...args
+    ]);
     hooks_module_h(()=>{
         fetchData().catch(logAndAlertError);
     }, [
@@ -2414,7 +2430,8 @@ const useMappedAPIResource = (apiFn, mapFn, ...args)=>{
     ]);
     return [
         data,
-        reload
+        reload,
+        setNewData
     ];
 };
 const letterOrDigit = /[a-zA-Z0-9]/;
@@ -5262,7 +5279,7 @@ const IntegerTypeInput = ({ type, value, disabled, onChange })=>{
                     const numericValue = Number.parseInt(event.currentTarget.value, 10);
                     if (!Number.isNaN(numericValue)) onChange(numericValue);
                 },
-                step: 0.01,
+                step: 1,
                 "aria-invalid": errors.length > 0,
                 disabled: disabled
             }),
@@ -6633,6 +6650,8 @@ const CreateSingletonInstance = ()=>/*#__PURE__*/ jsxRuntime_module_u(SingletonI
         onSubmit: CreateSingletonInstance_onSubmit,
         onSave: CreateSingletonInstance_onSave
     });
+await import("node:os").then((module)=>module.EOL).catch(()=>"\n");
+const isReorderableSortOrder = (sortOrder)=>"object" == typeof sortOrder && true === sortOrder.isIndex;
 const Entity_localeMapper = (result)=>result.instances;
 const mapInstances = (data)=>data.instances;
 const Entity = ()=>{
@@ -6644,8 +6663,34 @@ const Entity = ()=>{
     const gitClient = hooks_module_x(GitClientContext);
     const { reloadEntities } = hooks_module_x(EntitiesContext);
     const { declaration: entity, isLocaleEntity } = entityFromRoute ?? {};
-    const [instances, reloadInstances] = useMappedAPIResource(getInstancesByEntityName, mapInstances, locales, entity?.name ?? name ?? "");
+    const [instances, reloadInstances, setInstances] = useMappedAPIResource(getInstancesByEntityName, mapInstances, locales, entity?.name ?? name ?? "");
     const [localeInstances, reloadLocaleInstances] = useMappedAPIResource(getLocaleInstances, Entity_localeMapper, locales, config.localeEntityName);
+    const [inEditMode, setInEditMode] = hooks_module_d(false);
+    const [inApplyingNewOrder, setInApplyingNewOrder] = hooks_module_d(false);
+    const [orderedInstances, setOrderedInstances] = hooks_module_d([]);
+    hooks_module_h(()=>{
+        setOrderedInstances(instances ?? []);
+    }, [
+        instances
+    ]);
+    const toggleEditMode = hooks_module_q(()=>{
+        if (entity && !inApplyingNewOrder) if (inEditMode) {
+            setInApplyingNewOrder(true);
+            reorderAllInstancesInEntity(locales, entity.name, orderedInstances.map((i)=>i.id)).then((res)=>{
+                setInstances(res);
+                setInEditMode(false);
+            }, logAndAlertError).finally(()=>{
+                setInApplyingNewOrder(false);
+            });
+        } else setInEditMode(true);
+    }, [
+        entity,
+        inApplyingNewOrder,
+        inEditMode,
+        locales,
+        orderedInstances,
+        setInstances
+    ]);
     const { latestCommit } = hooks_module_x(GitClientContext) ?? {};
     hooks_module_h(()=>{
         reloadInstances().then(()=>reloadLocaleInstances()).catch(logAndAlertError);
@@ -6714,7 +6759,7 @@ const Entity = ()=>{
             name: "undefined" === key ? "No matching locale" : localeInstances?.find((instance)=>instance.id === key)?.displayName ?? key,
             instances: instancesByLocale[key] ?? []
         })).filter((group)=>group.instances.length > 0);
-    const instanceMapper = (instance)=>{
+    const instanceMapper = (instance, index, instancesArr)=>{
         const gitStatusForDisplay = getGitStatusForDisplay(instance.gitStatus);
         return /*#__PURE__*/ jsxRuntime_module_u("li", {
             id: `instance-${instance.id}`,
@@ -6729,7 +6774,28 @@ const Entity = ()=>{
                     class: "entries-item__subtitle entries-item__subtitle--id",
                     children: instance.id
                 }),
-                /*#__PURE__*/ jsxRuntime_module_u("div", {
+                inEditMode ? /*#__PURE__*/ jsxRuntime_module_u("div", {
+                    class: "entries-item__side",
+                    children: /*#__PURE__*/ jsxRuntime_module_u("div", {
+                        class: "btns",
+                        children: [
+                            /*#__PURE__*/ jsxRuntime_module_u("button", {
+                                disabled: index <= 0,
+                                onClick: ()=>{
+                                    setOrderedInstances((ins)=>reorder(ins, index, index - 1));
+                                },
+                                children: "Move up"
+                            }),
+                            /*#__PURE__*/ jsxRuntime_module_u("button", {
+                                disabled: index >= instancesArr.length - 1,
+                                onClick: ()=>{
+                                    setOrderedInstances((ins)=>reorder(ins, index, index + 1));
+                                },
+                                children: "Move down"
+                            })
+                        ]
+                    })
+                }) : /*#__PURE__*/ jsxRuntime_module_u("div", {
                     class: "entries-item__side",
                     children: [
                         /*#__PURE__*/ jsxRuntime_module_u(GitStatusIndicator, {
@@ -6773,10 +6839,19 @@ const Entity = ()=>{
                     /*#__PURE__*/ jsxRuntime_module_u("h1", {
                         children: toTitleCase(entity.namePlural)
                     }),
-                    /*#__PURE__*/ jsxRuntime_module_u("a", {
-                        class: "btn btn--primary",
-                        href: `/entities/${entity.name}/instances/create`,
-                        children: "Add"
+                    /*#__PURE__*/ jsxRuntime_module_u("div", {
+                        className: "btns",
+                        children: [
+                            isReorderableSortOrder(entity.sortOrder) ? /*#__PURE__*/ jsxRuntime_module_u("button", {
+                                onClick: toggleEditMode,
+                                children: inEditMode ? "Apply new order" : "Reorder"
+                            }) : null,
+                            /*#__PURE__*/ jsxRuntime_module_u("a", {
+                                class: "btn btn--primary",
+                                href: `/entities/${entity.name}/instances/create`,
+                                children: "Add"
+                            })
+                        ]
                     })
                 ]
             }),
@@ -6814,13 +6889,17 @@ const Entity = ()=>{
                                 value: searchText,
                                 onInput: (event)=>{
                                     setSearchText(event.currentTarget.value);
-                                }
+                                },
+                                disabled: inEditMode
                             })
                         ]
                     })
                 ]
             }),
-            isLocaleEntity || 1 === groupedInstances.length && groupedInstances[0]?.id !== "undefined" && locales[0] === groupedInstances[0]?.id ? /*#__PURE__*/ jsxRuntime_module_u("ul", {
+            inEditMode ? /*#__PURE__*/ jsxRuntime_module_u("ul", {
+                class: "entries entries--instances",
+                children: orderedInstances.map(instanceMapper)
+            }) : isLocaleEntity || 1 === groupedInstances.length && groupedInstances[0]?.id !== "undefined" && locales[0] === groupedInstances[0]?.id ? /*#__PURE__*/ jsxRuntime_module_u("ul", {
                 class: "entries entries--instances",
                 children: filteredInstances.map(instanceMapper)
             }) : /*#__PURE__*/ jsxRuntime_module_u("ul", {

package/package.json

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

package/public/css/styles.css

@@ -487,8 +487,9 @@ select {
   align-items: start;
 }
 
-.header-with-btns button,
-.header-with-btns .btn {
+.header-with-btns > .btns,
+.header-with-btns > button,
+.header-with-btns > .btn {
   margin-top: 2.3rem;
 }