tsondb 0.2.0 → 0.4.0

package/lib/renderers/jsonschema/index.d.ts

@@ -1,6 +0,0 @@
-import { Output } from "../Output.js";
-import { JsonSchemaRendererOptions } from "./render.js";
-export declare const JsonSchemaOutput: (options: {
-    targetPath: string;
-    rendererOptions?: JsonSchemaRendererOptions;
-}) => Output;

package/lib/renderers/jsonschema/index.js

@@ -1,12 +0,0 @@
-import { mkdir, writeFile } from "fs/promises";
-import { dirname } from "path";
-import { resolveTypeArgumentsInDecls } from "../../schema/index.js";
-import { render } from "./render.js";
-export const JsonSchemaOutput = (options) => ({
-    run: async (schema) => {
-        await mkdir(dirname(options.targetPath), { recursive: true });
-        await writeFile(options.targetPath, render(options.rendererOptions, resolveTypeArgumentsInDecls(schema.declarations)), {
-            encoding: "utf-8",
-        });
-    },
-});

package/lib/renderers/jsonschema/render.d.ts

@@ -1,5 +0,0 @@
-import { Decl } from "../../schema/declarations/Declaration.js";
-export type JsonSchemaRendererOptions = {
-    indentation: number;
-};
-export declare const render: (options: Partial<JsonSchemaRendererOptions> | undefined, declarations: readonly Decl[]) => string;

package/lib/renderers/ts/index.d.ts

@@ -1,6 +0,0 @@
-import { Output } from "../Output.js";
-import { TypeScriptRendererOptions } from "./render.js";
-export declare const TypeScriptOutput: (options: {
-    targetPath: string;
-    rendererOptions?: TypeScriptRendererOptions;
-}) => Output;

package/lib/renderers/ts/index.js

@@ -1,11 +0,0 @@
-import { mkdir, writeFile } from "fs/promises";
-import { dirname } from "path";
-import { render } from "./render.js";
-export const TypeScriptOutput = (options) => ({
-    run: async (schema) => {
-        await mkdir(dirname(options.targetPath), { recursive: true });
-        await writeFile(options.targetPath, render(options.rendererOptions, schema.declarations), {
-            encoding: "utf-8",
-        });
-    },
-});

package/lib/renderers/ts/render.js

@@ -1,112 +0,0 @@
-import { EOL } from "node:os";
-import { addEphemeralUUIDToType, createEntityIdentifierTypeAsDecl, isEntityDecl, } from "../../schema/declarations/EntityDecl.js";
-import { TypeAliasDecl } from "../../schema/declarations/TypeAliasDecl.js";
-import { flatMapAuxiliaryDecls, NodeKind } from "../../schema/Node.js";
-import { isObjectType } from "../../schema/types/generic/ObjectType.js";
-import { isNestedEntityMapType, } from "../../schema/types/references/NestedEntityMapType.js";
-import { getParentDecl } from "../../schema/types/Type.js";
-import { discriminatorKey } from "../../shared/enum.js";
-import { toCamelCase } from "../../shared/utils/string.js";
-import { assertExhaustive } from "../../shared/utils/typeSafety.js";
-import { applyIndentation, joinSyntax, prefixLines, syntax } from "../../utils/render.js";
-const defaultOptions = {
-    indentation: 2,
-};
-const renderDocumentation = (comment, isDeprecated) => comment === undefined
-    ? ""
-    : syntax `/**
-${prefixLines(" * ", comment, true)}${isDeprecated
-        ? syntax `
- * @deprecated`
-        : ""}
- */
-`;
-const renderTypeParameters = (options, params) => params.length === 0
-    ? ""
-    : `<${params
-        .map(param => param.constraint === undefined
-        ? param.name
-        : joinSyntax(param.name, " extends ", renderType(options, param.constraint)))
-        .join(", ")}>`;
-const renderArrayType = (options, type) => `${renderType(options, type.items)}[]`;
-const wrapAsObject = (options, syntax) => joinSyntax("{", EOL, applyIndentation(1, syntax, options.indentation), EOL, "}");
-const renderObjectType = (options, type) => {
-    return wrapAsObject(options, Object.entries(type.properties)
-        .map(([name, config]) => joinSyntax(renderDocumentation(config.comment, config.isDeprecated), name, config.isRequired ? "" : "?", ": ", renderType(options, config.type)))
-        .join(Object.values(type.properties).some(prop => prop.comment !== undefined) ? EOL + EOL : EOL));
-};
-const renderBooleanType = (_options, _type) => "boolean";
-const renderDateType = (_options, _type) => "Date";
-const renderNumericType = (_options, _type) => "number";
-const renderStringType = (_options, _type) => "string";
-const renderGenericArgumentIdentifierType = (_options, type) => type.argument.name;
-const renderReferenceIdentifierType = (_options, type) => type.entity.name + "_ID";
-const renderIncludeIdentifierType = (_options, type) => type.reference.name;
-const renderNestedEntityMapType = (options, type) => wrapAsObject(options, syntax `[${toCamelCase(type.secondaryEntity.name)}Id: string]: ${type.name}`);
-const renderType = (options, type) => {
-    switch (type.kind) {
-        case NodeKind.ArrayType:
-            return renderArrayType(options, type);
-        case NodeKind.ObjectType:
-            return renderObjectType(options, type);
-        case NodeKind.BooleanType:
-            return renderBooleanType(options, type);
-        case NodeKind.DateType:
-            return renderDateType(options, type);
-        case NodeKind.FloatType:
-            return renderNumericType(options, type);
-        case NodeKind.IntegerType:
-            return renderNumericType(options, type);
-        case NodeKind.StringType:
-            return renderStringType(options, type);
-        case NodeKind.GenericArgumentIdentifierType:
-            return renderGenericArgumentIdentifierType(options, type);
-        case NodeKind.ReferenceIdentifierType:
-            return renderReferenceIdentifierType(options, type);
-        case NodeKind.IncludeIdentifierType:
-            return renderIncludeIdentifierType(options, type);
-        case NodeKind.NestedEntityMapType:
-            return renderNestedEntityMapType(options, type);
-        default:
-            return assertExhaustive(type, "Unknown type");
-    }
-};
-const renderEntityDecl = (options, decl) => joinSyntax(renderDocumentation(decl.comment, decl.isDeprecated), "export interface ", decl.name, " ", renderType(options, addEphemeralUUIDToType(decl)));
-const renderEnumDecl = (options, decl) => joinSyntax(renderDocumentation(decl.comment, decl.isDeprecated), "export type ", decl.name, renderTypeParameters(options, decl.parameters), " =", ...Object.entries(decl.values.value).map(([caseName, caseDef]) => applyIndentation(1, joinSyntax(EOL, "| {", EOL, applyIndentation(1, joinSyntax(`${discriminatorKey}: "${caseName}"`, caseDef.type === null
-    ? ""
-    : joinSyntax(EOL, caseName + ": ", renderType(options, caseDef.type))), options.indentation), EOL, "}"), options.indentation)));
-const renderTypeAliasDecl = (options, decl) => {
-    const type = decl.type.value;
-    return isObjectType(type)
-        ? joinSyntax(renderDocumentation(decl.comment, decl.isDeprecated), "export interface ", decl.name, renderTypeParameters(options, decl.parameters), " ", renderType(options, type))
-        : joinSyntax(renderDocumentation(decl.comment), "export type ", decl.name, renderTypeParameters(options, decl.parameters), " = ", renderType(options, type));
-};
-const renderDecl = (options, decl) => {
-    switch (decl.kind) {
-        case NodeKind.EntityDecl:
-            return renderEntityDecl(options, decl);
-        case NodeKind.EnumDecl:
-            return renderEnumDecl(options, decl);
-        case NodeKind.TypeAliasDecl:
-            return renderTypeAliasDecl(options, decl);
-        default:
-            return assertExhaustive(decl, "Unknown declaration");
-    }
-};
-const renderDeclarations = (options, declarations) => declarations.map(decl => renderDecl(options, decl)).join(EOL + EOL);
-export const render = (options = defaultOptions, declarations) => {
-    const finalOptions = { ...defaultOptions, ...options };
-    return renderDeclarations(finalOptions, flatMapAuxiliaryDecls(node => {
-        if (isNestedEntityMapType(node)) {
-            return TypeAliasDecl(getParentDecl(node)?.sourceUrl ?? "", {
-                name: node.name,
-                comment: node.comment,
-                type: () => node.type.value,
-            });
-        }
-        else if (isEntityDecl(node)) {
-            return createEntityIdentifierTypeAsDecl(node);
-        }
-        return undefined;
-    }, declarations));
-};

package/lib/schema/declarations/EnumDecl.js

@@ -1,115 +0,0 @@
-import { discriminatorKey } from "../../shared/enum.js";
-import { Lazy } from "../../utils/lazy.js";
-import { NodeKind } from "../Node.js";
-import { serializeTypeParameter, } from "../parameters/TypeParameter.js";
-import { getReferencesForType, resolveTypeArgumentsInType, serializeType, validate, } from "../types/Type.js";
-import { getNestedDeclarations, getTypeArgumentsRecord, validateDeclName, } from "./Declaration.js";
-export const GenEnumDecl = (sourceUrl, options) => {
-    validateDeclName(options.name);
-    const decl = {
-        ...options,
-        kind: NodeKind.EnumDecl,
-        sourceUrl,
-        values: Lazy.of(() => {
-            const type = options.values(...options.parameters);
-            Object.values(type).forEach(type => {
-                if (type.type) {
-                    type.type.parent = decl;
-                }
-            });
-            return type;
-        }),
-    };
-    return decl;
-};
-export { GenEnumDecl as GenEnum };
-export const EnumDecl = (sourceUrl, options) => {
-    validateDeclName(options.name);
-    const decl = {
-        ...options,
-        kind: NodeKind.EnumDecl,
-        sourceUrl,
-        parameters: [],
-        values: Lazy.of(() => {
-            const type = options.values();
-            Object.values(type).forEach(type => {
-                if (type.type) {
-                    type.type.parent = decl;
-                }
-            });
-            return type;
-        }),
-    };
-    return decl;
-};
-export { EnumDecl as Enum };
-export const isEnumDecl = (node) => node.kind === NodeKind.EnumDecl;
-export const getNestedDeclarationsInEnumDecl = (addedDecls, decl) => Object.values(decl.values.value).reduce((acc, caseMember) => caseMember.type === null ? acc : getNestedDeclarations(acc, caseMember.type), addedDecls);
-export const validateEnumDecl = (helpers, decl, args, value) => {
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
-        return [TypeError(`expected an object, but got ${JSON.stringify(value)}`)];
-    }
-    const actualKeys = Object.keys(value);
-    if (!(discriminatorKey in value) || typeof value[discriminatorKey] !== "string") {
-        return [
-            TypeError(`missing required discriminator value at key "${discriminatorKey}" of type string`),
-        ];
-    }
-    const caseName = value[discriminatorKey];
-    if (!(caseName in decl.values.value)) {
-        return [TypeError(`discriminator "${caseName}" is not a valid enum case`)];
-    }
-    const unknownKeyErrors = actualKeys.flatMap(actualKey => actualKey === discriminatorKey || actualKey in decl.values.value
-        ? []
-        : [TypeError(`key "${actualKey}" is not the discriminator key or a valid enum case`)]);
-    if (unknownKeyErrors.length > 0) {
-        return unknownKeyErrors;
-    }
-    const associatedType = decl.values.value[caseName]?.type;
-    if (associatedType != null) {
-        if (!(caseName in value)) {
-            return [TypeError(`missing required associated value for case "${caseName}"`)];
-        }
-        return validate(helpers, resolveTypeArgumentsInType(getTypeArgumentsRecord(decl, args), associatedType), value[caseName]);
-    }
-    return [];
-};
-export const resolveTypeArgumentsInEnumDecl = (decl, args) => {
-    const resolvedArgs = getTypeArgumentsRecord(decl, args);
-    return EnumDecl(decl.sourceUrl, {
-        ...decl,
-        values: () => Object.fromEntries(Object.entries(decl.values.value).map(([key, { type, ...caseMember }]) => [
-            key,
-            {
-                ...caseMember,
-                type: type === null ? null : resolveTypeArgumentsInType(resolvedArgs, type),
-            },
-        ])),
-    });
-};
-export const EnumCaseDecl = (options) => ({
-    ...options,
-    kind: NodeKind.EnumCaseDecl,
-});
-export { EnumCaseDecl as EnumCase };
-export const serializeEnumDecl = type => ({
-    ...type,
-    values: Object.fromEntries(Object.entries(type.values.value).map(([key, caseMember]) => [
-        key,
-        {
-            ...caseMember,
-            type: caseMember.type === null ? null : serializeType(caseMember.type),
-        },
-    ])),
-    parameters: type.parameters.map(param => serializeTypeParameter(param)),
-});
-export const getReferencesForEnumDecl = (decl, value) => typeof value === "object" &&
-    value !== null &&
-    !Array.isArray(value) &&
-    discriminatorKey in value &&
-    typeof value[discriminatorKey] === "string" &&
-    value[discriminatorKey] in decl.values.value &&
-    decl.values.value[value[discriminatorKey]]?.type == null &&
-    value[discriminatorKey] in value
-    ? getReferencesForType(decl.values.value[value[discriminatorKey]].type, value[value[discriminatorKey]])
-    : [];

package/lib/schema/types/Type.d.ts

@@ -1,42 +0,0 @@
-import { Decl } from "../declarations/Declaration.js";
-import { BaseNode, GetReferences, Serializer } from "../Node.js";
-import { Validator } from "../validation/type.js";
-import { ArrayType, SerializedArrayType } from "./generic/ArrayType.js";
-import { MemberDecl, ObjectType, SerializedMemberDecl, SerializedObjectType } from "./generic/ObjectType.js";
-import { BooleanType, SerializedBooleanType } from "./primitives/BooleanType.js";
-import { DateType, SerializedDateType } from "./primitives/DateType.js";
-import { FloatType, SerializedFloatType } from "./primitives/FloatType.js";
-import { IntegerType, SerializedIntegerType } from "./primitives/IntegerType.js";
-import { PrimitiveType, SerializedPrimitiveType } from "./primitives/PrimitiveType.js";
-import { SerializedStringType, StringType } from "./primitives/StringType.js";
-import { GenericArgumentIdentifierType, SerializedGenericArgumentIdentifierType } from "./references/GenericArgumentIdentifierType.js";
-import { IncludeIdentifierType, SerializedIncludeIdentifierType } from "./references/IncludeIdentifierType.js";
-import { NestedEntityMapType, SerializedNestedEntityMapType } from "./references/NestedEntityMapType.js";
-import { ReferenceIdentifierType, SerializedReferenceIdentifierType } from "./references/ReferenceIdentifierType.js";
-export interface BaseType extends BaseNode {
-    /**
-     * The parent node of this type will be set when the type is used in a declaration or nested in another type.
-     */
-    parent?: Type | Decl;
-}
-export interface SerializedBaseType extends BaseNode {
-}
-export type Type = PrimitiveType | ArrayType | ObjectType | GenericArgumentIdentifierType | ReferenceIdentifierType | IncludeIdentifierType | NestedEntityMapType;
-export type SerializedType = SerializedPrimitiveType | SerializedArrayType | SerializedObjectType | SerializedGenericArgumentIdentifierType | SerializedReferenceIdentifierType | SerializedIncludeIdentifierType | SerializedNestedEntityMapType;
-export declare const validate: Validator<Type>;
-export declare const resolveTypeArgumentsInType: <Args extends Record<string, Type>>(args: Args, type: Type) => Type;
-export declare function walkTypeNodeTree(callbackFn: (type: Type) => void, type: Type): void;
-export type AsType<T extends Type> = T extends ArrayType<infer I> ? AsType<I>[] : T extends ObjectType<infer P> ? {
-    [K in keyof P]: P[K] extends MemberDecl<Type, true> ? AsType<P[K]["type"]> : AsType<P[K]["type"]> | undefined;
-} : T extends BooleanType ? boolean : T extends DateType ? Date : T extends FloatType ? number : T extends IntegerType ? number : T extends StringType ? string : T extends GenericArgumentIdentifierType ? unknown : T extends IncludeIdentifierType ? unknown : T extends NestedEntityMapType ? unknown : T extends ReferenceIdentifierType ? unknown : never;
-export type SerializedAsType<T extends SerializedType> = T extends SerializedArrayType<infer I> ? SerializedAsType<I>[] : T extends SerializedObjectType<infer P> ? {
-    [K in keyof P]: P[K] extends SerializedMemberDecl<SerializedType, true> ? SerializedAsType<P[K]["type"]> : SerializedAsType<P[K]["type"]> | undefined;
-} : T extends SerializedBooleanType ? boolean : T extends SerializedDateType ? Date : T extends SerializedFloatType ? number : T extends SerializedIntegerType ? number : T extends SerializedStringType ? string : T extends SerializedGenericArgumentIdentifierType ? unknown : T extends SerializedIncludeIdentifierType ? unknown : T extends SerializedNestedEntityMapType ? unknown : T extends SerializedReferenceIdentifierType ? unknown : never;
-export type AsNode<T> = T extends (infer I)[] ? ArrayType<AsNode<I>> : T extends Record<string, any> ? ObjectType<{
-    [K in keyof T]: T[K] extends MemberDecl<Type, boolean> ? T[K] : T extends null | undefined ? MemberDecl<AsNode<NonNullable<T[K]>>, false> : MemberDecl<AsNode<T[K]>, true>;
-}> : T extends string ? StringType : T extends number ? FloatType : T extends boolean ? BooleanType : never;
-export declare const getParentDecl: (type: Type) => Decl | undefined;
-export declare const findTypeAtPath: (type: Type, path: string[]) => Type | undefined;
-export declare const serializeType: Serializer<Type, SerializedType>;
-export declare const removeParentKey: <T extends BaseType>(type: T) => Omit<T, "parent">;
-export declare const getReferencesForType: GetReferences<Type>;

package/lib/schema/types/primitives/PrimitiveType.d.ts

@@ -1,6 +0,0 @@
-import { BooleanType, SerializedBooleanType } from "./BooleanType.js";
-import { DateType, SerializedDateType } from "./DateType.js";
-import { NumericType, SerializedNumericType } from "./NumericType.js";
-import { SerializedStringType, StringType } from "./StringType.js";
-export type PrimitiveType = BooleanType | DateType | NumericType | StringType;
-export type SerializedPrimitiveType = SerializedBooleanType | SerializedDateType | SerializedNumericType | SerializedStringType;

package/lib/schema/types/references/GenericArgumentIdentifierType.d.ts

@@ -1,21 +0,0 @@
-import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
-import { SerializedTypeParameter, TypeParameter } from "../../parameters/TypeParameter.js";
-import { Validator } from "../../validation/type.js";
-import { BaseType, SerializedBaseType, Type } from "../Type.js";
-type TConstraint = TypeParameter;
-export interface GenericArgumentIdentifierType<T extends TConstraint = TConstraint> extends BaseType {
-    kind: NodeKind["GenericArgumentIdentifierType"];
-    argument: T;
-}
-type TSerializedConstraint = SerializedTypeParameter;
-export interface SerializedGenericArgumentIdentifierType<T extends TSerializedConstraint = TSerializedConstraint> extends SerializedBaseType {
-    kind: NodeKind["GenericArgumentIdentifierType"];
-    argument: T;
-}
-export declare const GenericArgumentIdentifierType: <T extends TConstraint>(argument: T) => GenericArgumentIdentifierType<T>;
-export { GenericArgumentIdentifierType as GenericArgumentIdentifier };
-export declare const isGenericArgumentIdentifierType: (node: Node) => node is GenericArgumentIdentifierType;
-export declare const validateGenericArgumentIdentifierType: Validator<GenericArgumentIdentifierType>;
-export declare const resolveTypeArgumentsInGenericArgumentIdentifierType: <T extends TConstraint, Args extends Record<string, Type>>(args: Args, type: GenericArgumentIdentifierType<T>) => Args[T["name"]];
-export declare const serializeGenericArgumentIdentifierType: Serializer<GenericArgumentIdentifierType, SerializedGenericArgumentIdentifierType>;
-export declare const getReferencesForGenericArgumentIdentifierType: GetReferences<GenericArgumentIdentifierType>;

package/lib/schema/types/references/GenericArgumentIdentifierType.js

@@ -1,18 +0,0 @@
-import { NodeKind } from "../../Node.js";
-import { serializeTypeParameter, } from "../../parameters/TypeParameter.js";
-import { removeParentKey } from "../Type.js";
-export const GenericArgumentIdentifierType = (argument) => ({
-    kind: NodeKind.GenericArgumentIdentifierType,
-    argument,
-});
-export { GenericArgumentIdentifierType as GenericArgumentIdentifier };
-export const isGenericArgumentIdentifierType = (node) => node.kind === NodeKind.GenericArgumentIdentifierType;
-export const validateGenericArgumentIdentifierType = (_helpers, type, _value) => {
-    throw new TypeError(`generic argument "${type.argument.name}" has not been replaced with a concrete type`);
-};
-export const resolveTypeArgumentsInGenericArgumentIdentifierType = (args, type) => args[type.argument.name];
-export const serializeGenericArgumentIdentifierType = type => ({
-    ...removeParentKey(type),
-    argument: serializeTypeParameter(type.argument),
-});
-export const getReferencesForGenericArgumentIdentifierType = (_type, _value) => [];

package/lib/schema/validation/type.d.ts

@@ -1,4 +0,0 @@
-import { Validators } from "../Node.js";
-import { Type } from "../types/Type.js";
-export type ValidatorHelpers = Validators;
-export type Validator<T extends Type, Args extends any[] = []> = (helpers: ValidatorHelpers, type: T, value: unknown, ...args: Args) => Error[];

package/lib/server/index.d.ts

@@ -1,8 +0,0 @@
-import { ModelContainer } from "../ModelContainer.js";
-import { InstancesByEntityName } from "../shared/utils/instances.js";
-type ServerOptions = {
-    name: string;
-    port: number;
-};
-export declare const createServer: (modelContainer: ModelContainer, instancesByEntityName: InstancesByEntityName, options?: Partial<ServerOptions>) => void;
-export {};

package/lib/server/index.js

@@ -1,207 +0,0 @@
-import express from "express";
-import { join } from "node:path";
-import { serializeDecl } from "../schema/declarations/Declaration.js";
-import { isEntityDecl, serializeEntityDecl } from "../schema/declarations/EntityDecl.js";
-import { isEnumDecl } from "../schema/declarations/EnumDecl.js";
-import { isTypeAliasDecl } from "../schema/declarations/TypeAliasDecl.js";
-import { getDisplayNameFromEntityInstance } from "../shared/utils/displayName.js";
-import { isOk } from "../utils/result.js";
-import { createInstance, deleteInstance, updateInstance } from "./instanceOperations.js";
-const defaultOptions = {
-    name: "tsondb server",
-    port: 3000,
-};
-export const createServer = (modelContainer, instancesByEntityName, options) => {
-    const { name, port } = { ...defaultOptions, ...options };
-    const app = express();
-    app.use(express.static(join(import.meta.dirname, "../../public")));
-    app.use("/js/node_modules", express.static(join(import.meta.dirname, "../../node_modules")));
-    app.use("/js/client", express.static(join(import.meta.dirname, "../../lib/client")));
-    app.use("/js/shared", express.static(join(import.meta.dirname, "../../lib/shared")));
-    app.use(express.json());
-    const declarations = modelContainer.schema.declarations;
-    const entities = declarations.filter(isEntityDecl);
-    const entitiesByName = Object.fromEntries(entities.map(entity => [entity.name, entity]));
-    const instancesByEntityNameInMemory = { ...instancesByEntityName };
-    app.get("/api/declarations", (req, res) => {
-        let filteredEntities;
-        switch (req.query["kind"]) {
-            case "Entity":
-                filteredEntities = entities.filter(isEntityDecl);
-                break;
-            case "TypeAlias":
-                filteredEntities = entities.filter(isTypeAliasDecl);
-                break;
-            case "Enum":
-                filteredEntities = entities.filter(isEnumDecl);
-                break;
-            default:
-                filteredEntities = declarations;
-        }
-        const body = {
-            declarations: filteredEntities.map(decl => ({
-                declaration: serializeDecl(decl),
-                instanceCount: instancesByEntityNameInMemory[decl.name]?.length ?? 0,
-            })),
-            localeEntity: modelContainer.schema.localeEntity?.name,
-        };
-        res.json(body);
-    });
-    app.get("/api/declarations/:name", (req, res) => {
-        const decl = declarations.find(decl => decl.name === req.params.name);
-        if (decl === undefined) {
-            res.status(404).send(`Declaration "${req.params.name}" not found`);
-            return;
-        }
-        const body = {
-            declaration: serializeDecl(decl),
-            instanceCount: instancesByEntityNameInMemory[decl.name]?.length ?? 0,
-            isLocaleEntity: decl === modelContainer.schema.localeEntity,
-        };
-        res.json(body);
-    });
-    app.get("/api/declarations/:name/instances", (req, res) => {
-        const decl = declarations.find(decl => decl.name === 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;
-        }
-        const body = {
-            instances: instancesByEntityNameInMemory[req.params.name] ?? [],
-            isLocaleEntity: decl === modelContainer.schema.localeEntity,
-        };
-        res.json(body);
-    });
-    app.post("/api/declarations/:name/instances", async (req, res) => {
-        const decl = declarations.find(decl => decl.name === 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;
-        }
-        const result = await createInstance(modelContainer, entitiesByName, instancesByEntityNameInMemory, decl.name, req.body, req.query["id"]);
-        if (isOk(result)) {
-            const body = {
-                instance: result.value,
-                isLocaleEntity: decl === modelContainer.schema.localeEntity,
-            };
-            res.json(body);
-        }
-        else {
-            res.status(result.error[0]).send(result.error[1]);
-        }
-    });
-    app.get("/api/declarations/:name/instances/:id", (req, res) => {
-        const decl = declarations.find(decl => decl.name === 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;
-        }
-        const instance = instancesByEntityNameInMemory[decl.name]?.find(instance => instance.id === req.params.id);
-        if (instance === undefined) {
-            res.status(404).send(`Instance "${req.params.id}" not found`);
-            return;
-        }
-        const body = {
-            instance: instance,
-            isLocaleEntity: decl === modelContainer.schema.localeEntity,
-        };
-        res.json(body);
-    });
-    app.put("/api/declarations/:name/instances/:id", async (req, res) => {
-        const decl = declarations.find(decl => decl.name === 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;
-        }
-        const result = await updateInstance(modelContainer, entitiesByName, instancesByEntityNameInMemory, decl.name, req.params.id, req.body);
-        if (isOk(result)) {
-            const body = {
-                instance: result.value,
-                isLocaleEntity: decl === modelContainer.schema.localeEntity,
-            };
-            res.json(body);
-        }
-        else {
-            res.status(result.error[0]).send(result.error[1]);
-        }
-    });
-    app.delete("/api/declarations/:name/instances/:id", async (req, res) => {
-        const decl = declarations.find(decl => decl.name === 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;
-        }
-        const result = await deleteInstance(modelContainer, instancesByEntityNameInMemory, decl.name, req.params.id);
-        if (isOk(result)) {
-            const body = {
-                instance: result.value,
-                isLocaleEntity: decl === modelContainer.schema.localeEntity,
-            };
-            res.json(body);
-        }
-        else {
-            res.status(result.error[0]).send(result.error[1]);
-        }
-    });
-    app.get("/api/instances", (req, res) => {
-        const locales = (Array.isArray(req.query["locales"]) ? req.query["locales"] : [req.query["locales"]]).filter(locale => typeof locale === "string");
-        const body = {
-            instances: Object.fromEntries(Object.entries(instancesByEntityNameInMemory).map(([entityName, instances]) => [
-                entityName,
-                instances.map(instance => ({
-                    id: instance.id,
-                    name: getDisplayNameFromEntityInstance(serializeEntityDecl(entitiesByName[entityName]), instance.content, instance.id, locales),
-                })),
-            ])),
-        };
-        res.json(body);
-    });
-    app.get(/^\/.*/, (_req, res) => {
-        res.send(`<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>TSONDB</title>
-  <link rel="stylesheet" href="/css/styles.css">
-</head>
-<body>
-  <div id="app"></div>
-  <script type="importmap">
-    {
-      "imports": {
-        "preact": "/js/node_modules/preact/dist/preact.module.js",
-        "preact/hooks": "/js/node_modules/preact/hooks/dist/hooks.module.js",
-        "preact/jsx-runtime": "/js/node_modules/preact/jsx-runtime/dist/jsxRuntime.module.js",
-        "preact-iso": "/js/node_modules/preact-iso/src/index.js"
-      }
-    }
-  </script>
-  <script type="module" src="/js/client/index.js"></script>
-</body>
-</html>`);
-    });
-    app.listen(port, () => {
-        console.log(`${name} listening on http://localhost:${port}`);
-    });
-};

package/lib/server/instanceOperations.d.ts

@@ -1,7 +0,0 @@
-import { ModelContainer } from "../ModelContainer.js";
-import { EntityDecl } from "../schema/declarations/EntityDecl.js";
-import { InstanceContainer, InstancesByEntityName } from "../shared/utils/instances.js";
-import { Result } from "../utils/result.js";
-export declare const createInstance: (modelContainer: ModelContainer, entitiesByName: Record<string, EntityDecl>, instancesByEntityName: InstancesByEntityName, entityName: string, instance: unknown, idQueryParam: unknown) => Promise<Result<InstanceContainer, [code: number, message: string]>>;
-export declare const updateInstance: (modelContainer: ModelContainer, entitiesByName: Record<string, EntityDecl>, instancesByEntityName: InstancesByEntityName, entityName: string, id: string, instance: unknown) => Promise<Result<InstanceContainer, [code: number, message: string]>>;
-export declare const deleteInstance: (modelContainer: ModelContainer, instancesByEntityName: InstancesByEntityName, entityName: string, id: string) => Promise<Result<InstanceContainer, [code: number, message: string]>>;