tsondb 0.12.3 → 0.12.6

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

@@ -0,0 +1,46 @@
+import type { SimpleGit } from "simple-git";
+import type { InstanceContainer, InstanceContent } from "../../shared/utils/instances.ts";
+import { type Result } from "../../shared/utils/result.ts";
+import type { EntityDecl } from "../schema/index.ts";
+import { type DatabaseInMemory } from "./databaseInMemory.ts";
+import { type ReferencesToInstances } from "./references.ts";
+export type TransactionStep = {
+    kind: "set";
+    entity: EntityDecl;
+    instanceId: string;
+    instance: InstanceContent;
+    oldInstance: InstanceContent | undefined;
+} | {
+    kind: "delete";
+    entity: EntityDecl;
+    instanceId: string;
+    oldInstance: InstanceContent;
+};
+export type TransactionResult<A extends object = object> = Result<{
+    entitiesByName: Record<string, EntityDecl>;
+    db: DatabaseInMemory;
+    refs: ReferencesToInstances;
+    steps: TransactionStep[];
+} & A, Error>;
+/**
+ * Run a transaction on the database in memory, applying all changes to disk if successful.
+ */
+export declare const runDatabaseTransaction: (root: string, git: SimpleGit | undefined, entitiesByName: Record<string, EntityDecl>, database: DatabaseInMemory, references: ReferencesToInstances, transactionFn: (db: TransactionResult) => TransactionResult<{
+    instanceContainer: InstanceContainer;
+}>) => Promise<Result<{
+    db: DatabaseInMemory;
+    refs: ReferencesToInstances;
+    instanceContainer: InstanceContainer;
+}, Error>>;
+/**
+ * Function to be used within a transaction to set an instance in the database.
+ *
+ * Note that the transaction result is immutable, so the returned `TransactionResult` must be used for further operations.
+ */
+export declare const setInstanceT: (res: TransactionResult, entity: EntityDecl, instance: InstanceContainer) => TransactionResult;
+/**
+ * Function to be used within a transaction to delete an instance from the database.
+ *
+ * Note that the transaction result is immutable, so the returned `TransactionResult` must be used for further operations.
+ */
+export declare const deleteInstanceT: (res: TransactionResult, entity: EntityDecl, instanceId: string) => TransactionResult;

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

@@ -0,0 +1,105 @@
+import { isError, map, ok } from "../../shared/utils/result.js";
+import { deleteInstanceInDatabaseInMemory, setInstanceInDatabaseInMemory, } from "./databaseInMemory.js";
+import { applyStepsToDisk } from "./databaseOnDisk.js";
+import { attachGitStatusToDatabaseInMemory } from "./git.js";
+import { updateReferencesToInstances } from "./references.js";
+/**
+ * Run a transaction on the database in memory, applying all changes to disk if successful.
+ */
+export const runDatabaseTransaction = async (root, git, entitiesByName, database, references, transactionFn) => {
+    const result = transactionFn(ok({
+        db: database,
+        entitiesByName,
+        refs: references,
+        steps: [],
+    }));
+    if (isError(result)) {
+        return result;
+    }
+    const { db: newDb, refs: newRefs, steps, instanceContainer } = result.value;
+    const diskResult = await applyStepsToDisk(root, steps);
+    if (isError(diskResult)) {
+        return diskResult;
+    }
+    if (git !== undefined) {
+        const status = await git.status();
+        const repoRoot = await git.revparse(["--show-toplevel"]);
+        const newDbWithUpdatedGit = attachGitStatusToDatabaseInMemory(newDb, root, repoRoot, status);
+        return ok({ db: newDbWithUpdatedGit, refs: newRefs, instanceContainer });
+    }
+    return ok({ db: newDb, refs: newRefs, instanceContainer });
+};
+/**
+ * Function to be used within a transaction to set an instance in the database.
+ *
+ * Note that the transaction result is immutable, so the returned `TransactionResult` must be used for further operations.
+ */
+export const setInstanceT = (res, entity, instance) => map(res, ({ db, steps, refs, entitiesByName }) => {
+    const [updatedDb, oldInstance] = setInstanceInDatabaseInMemory(db, entity.name, instance);
+    const updatedRefs = updateReferencesToInstances(entitiesByName, refs, entity.name, instance.id, oldInstance, instance.content);
+    const step = {
+        kind: "set",
+        entity,
+        instanceId: instance.id,
+        instance: instance.content,
+        oldInstance,
+    };
+    return {
+        db: updatedDb,
+        steps: [...steps, step],
+        refs: updatedRefs,
+        entitiesByName,
+        additionalInformation: undefined,
+    };
+});
+// /**
+//  * Function to set an instance in the database directly.
+//  *
+//  * This is the same as running a singular set transaction.
+//  */
+// export const setInstance = (
+//   root: string,
+//   db: DatabaseInMemory,
+//   entity: EntityDecl,
+//   instance: InstanceContainer,
+// ): Promise<Result<DatabaseInMemory, Error>> =>
+//   runTransaction(root, db, res => setInstanceT(res, entity, instance))
+/**
+ * Function to be used within a transaction to delete an instance from the database.
+ *
+ * Note that the transaction result is immutable, so the returned `TransactionResult` must be used for further operations.
+ */
+export const deleteInstanceT = (res, entity, instanceId) => map(res, tres => {
+    const { db, steps, refs, entitiesByName } = tres;
+    const [updatedDb, oldInstance] = deleteInstanceInDatabaseInMemory(db, entity.name, instanceId);
+    if (oldInstance === undefined) {
+        // instance did not exist, no-op
+        return tres;
+    }
+    const updatedRefs = updateReferencesToInstances(entitiesByName, refs, entity.name, instanceId, oldInstance, undefined);
+    const step = {
+        kind: "delete",
+        entity,
+        instanceId,
+        oldInstance,
+    };
+    return {
+        db: updatedDb,
+        steps: [...steps, step],
+        refs: updatedRefs,
+        entitiesByName,
+        additionalInformation: undefined,
+    };
+});
+// /**
+//  * Function to delete an instance from the database directly.
+//  *
+//  * This is the same as running a singular deletion transaction.
+//  */
+// export const deleteInstance = (
+//   root: string,
+//   db: DatabaseInMemory,
+//   entityName: string,
+//   instanceId: string,
+// ): Promise<Result<DatabaseInMemory, Error>> =>
+//   runTransaction(root, db, res => deleteInstanceT(res, entityName, instanceId))

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

@@ -1,11 +1,11 @@
 import type { GetInstanceById } from "../../node/server/index.ts";
 import { type DisplayNameResult } from "../../shared/utils/displayName.ts";
-import type { InstanceContainer } from "../../shared/utils/instances.ts";
+import type { InstanceContainer, InstanceContent } from "../../shared/utils/instances.ts";
 import { type EntityDecl } from "../schema/declarations/EntityDecl.ts";
 import type { AsDeepType, Type } from "../schema/types/Type.ts";
 export type GetChildInstancesForInstanceId = (parentEntityName: string, parentId: string, childEntityName: string) => {
     id: string;
-    content: unknown;
+    content: InstanceContent;
 }[];
 export type DisplayNameCustomizer<T extends Type> = (params: {
     instance: AsDeepType<T>;
@@ -13,7 +13,7 @@ export type DisplayNameCustomizer<T extends Type> = (params: {
     instanceDisplayName: string;
     instanceDisplayNameLocaleId: string | undefined;
     locales: string[];
-    getInstanceById: (id: string) => unknown;
+    getInstanceById: (id: string) => InstanceContent | undefined;
     getDisplayNameForInstanceId: (id: string) => DisplayNameResult | undefined;
     getChildInstancesForInstanceId: GetChildInstancesForInstanceId;
 }) => DisplayNameResult;

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

@@ -2,3 +2,7 @@ export declare const getErrorMessageForDisplay: (error: Error) => 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/node/utils/error.js

@@ -25,3 +25,11 @@ export const wrapErrorsIfAny = (message, errors) => {
     }
     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/utils/files.d.ts

@@ -1,5 +1,7 @@
-import type { EntityDecl } from "../schema/index.ts";
+import type { InstanceContent } from "../../shared/utils/instances.ts";
+import { type EntityDecl } from "../schema/index.ts";
 export declare const getFileNameForId: (id: string) => string;
 export declare const getPathToInstance: (dataRoot: string, entityName: string, id: string) => string;
-export declare const writeInstance: (dataRoot: string, entity: EntityDecl, id: string, instance: unknown) => Promise<void>;
+export declare const writeInstance: (dataRoot: string, entity: EntityDecl, id: string, instance: InstanceContent) => Promise<void>;
 export declare const deleteInstance: (dataRoot: string, entityName: string, id: string) => Promise<void>;
+export declare const formatInstance: (entity: EntityDecl, instanceContent: InstanceContent) => string;

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

@@ -1,9 +1,10 @@
 import { rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { formatInstance } from "./instances.js";
+import { formatValue } from "../schema/index.js";
 export const getFileNameForId = (id) => `${id}.json`;
 export const getPathToInstance = (dataRoot, entityName, id) => join(dataRoot, entityName, getFileNameForId(id));
 export const writeInstance = (dataRoot, entity, id, instance) => writeFile(getPathToInstance(dataRoot, entity.name, id), formatInstance(entity, instance), {
     encoding: "utf-8",
 });
 export const deleteInstance = (dataRoot, entityName, id) => rm(getPathToInstance(dataRoot, entityName, id));
+export const formatInstance = (entity, instanceContent) => JSON.stringify(formatValue(entity.type.value, instanceContent), undefined, 2) + "\n";

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

@@ -1,3 +1,5 @@
 import type { StatusResult } from "simple-git";
 import type { GitFileStatus } from "../../shared/utils/git.ts";
-export declare const getGitFileStatusFromStatusResult: (statusResult: StatusResult, repoRoot: string, dataRoot: string, entityName: string, fileName: string) => GitFileStatus | undefined;
+import type { DatabaseInMemory } from "./databaseInMemory.ts";
+export declare const getGitFileStatusFromStatusResult: (gitStatus: StatusResult, gitRoot: string, dataRoot: string, entityName: string, fileName: string) => GitFileStatus | undefined;
+export declare const attachGitStatusToDatabaseInMemory: (databaseInMemory: DatabaseInMemory, dataRoot: string, gitRoot: string, gitStatus: StatusResult) => DatabaseInMemory;

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

@@ -1,7 +1,9 @@
 import { join } from "path";
-export const getGitFileStatusFromStatusResult = (statusResult, repoRoot, dataRoot, entityName, fileName) => {
+import { mapD } from "../../shared/utils/dictionary.js";
+import { getFileNameForId } from "./files.js";
+export const getGitFileStatusFromStatusResult = (gitStatus, gitRoot, dataRoot, entityName, fileName) => {
     const filePath = join(dataRoot, entityName, fileName);
-    const gitFile = statusResult.files.find(file => join(repoRoot, file.path) === filePath);
+    const gitFile = gitStatus.files.find(file => join(gitRoot, file.path) === filePath);
     if (gitFile === undefined) {
         return;
     }
@@ -10,3 +12,7 @@ export const getGitFileStatusFromStatusResult = (statusResult, repoRoot, dataRoo
         workingDir: gitFile.working_dir,
     };
 };
+export const attachGitStatusToDatabaseInMemory = (databaseInMemory, dataRoot, gitRoot, gitStatus) => mapD(databaseInMemory, (instances, entityName) => mapD(instances, instanceContainer => ({
+    ...instanceContainer,
+    gitStatus: getGitFileStatusFromStatusResult(gitStatus, gitRoot, dataRoot, entityName, getFileNameForId(instanceContainer.id)),
+})));

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

@@ -0,0 +1,9 @@
+import type { InstanceContent } from "../../shared/utils/instances.ts";
+import type { EntityDecl } from "../schema/declarations/EntityDecl.ts";
+import { type TransactionResult } from "./databaseTransactions.ts";
+export declare const createNewId: () => `${string}-${string}-${string}-${string}-${string}`;
+export declare const createInstance: (res: TransactionResult, localeEntity: EntityDecl | undefined, entity: EntityDecl, instanceContent: InstanceContent, customId: unknown) => TransactionResult<{
+    instanceId: string;
+}>;
+export declare const updateInstance: (res: TransactionResult, entity: EntityDecl, instanceId: string, instanceContent: InstanceContent) => TransactionResult;
+export declare const deleteInstance: (res: TransactionResult, entity: EntityDecl, instanceId: string) => TransactionResult;

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

@@ -0,0 +1,40 @@
+import { randomUUID } from "node:crypto";
+import { error, map, ok, then } from "../../shared/utils/result.js";
+import { createValidators, validateEntityDecl } from "../schema/index.js";
+import { getInstanceOfEntityFromDatabaseInMemory, } from "./databaseInMemory.js";
+import { deleteInstanceT, setInstanceT } from "./databaseTransactions.js";
+import { getErrorMessageForDisplay, HTTPError } from "./error.js";
+import { isReferencedByOtherInstances } from "./references.js";
+export const createNewId = () => randomUUID();
+const checkCreateInstancePossible = (localeEntity, databaseInMemory, entity, instanceContent, customId) => {
+    const newInstanceId = entity === localeEntity ? customId : createNewId();
+    if (typeof newInstanceId !== "string") {
+        return error(new HTTPError(400, `New identifier "${String(newInstanceId)}" is not a string`));
+    }
+    if (localeEntity === entity &&
+        getInstanceOfEntityFromDatabaseInMemory(databaseInMemory, entity.name, newInstanceId) !==
+            undefined) {
+        return error(new HTTPError(400, `Duplicate id "${newInstanceId}" for locale entity`));
+    }
+    return map(checkUpdateInstancePossible(databaseInMemory, entity, instanceContent), () => newInstanceId);
+};
+export const createInstance = (res, localeEntity, entity, instanceContent, customId) => then(res, data => then(checkCreateInstancePossible(localeEntity, data.db, entity, instanceContent, customId), newInstanceId => map(setInstanceT(ok(data), entity, { id: newInstanceId, content: instanceContent }), data => ({ ...data, instanceId: newInstanceId }))));
+const checkUpdateInstancePossible = (databaseInMemory, entity, instanceContent) => {
+    const validationErrors = validateEntityDecl(createValidators(databaseInMemory, false), [], entity, instanceContent);
+    if (validationErrors.length > 0) {
+        return error(new HTTPError(400, validationErrors.map(getErrorMessageForDisplay).join("\n\n")));
+    }
+    else {
+        return ok();
+    }
+};
+export const updateInstance = (res, entity, instanceId, instanceContent) => then(res, data => then(checkUpdateInstancePossible(data.db, entity, instanceContent), () => setInstanceT(ok(data), entity, { id: instanceId, content: instanceContent })));
+const checkDeleteInstancePossible = (referencesToInstances, instanceId) => {
+    if (isReferencedByOtherInstances(referencesToInstances, instanceId)) {
+        return error(new HTTPError(400, "Cannot delete instance that is referenced by other instances"));
+    }
+    else {
+        return ok();
+    }
+};
+export const deleteInstance = (res, entity, instanceId) => then(res, data => then(checkDeleteInstancePossible(data.refs, instanceId), () => deleteInstanceT(ok(data), entity, instanceId)));

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

@@ -1,6 +1,7 @@
 import type { SerializedDecl } from "../../shared/schema/declarations/Declaration.ts";
-import type { InstanceContainer } from "../../shared/utils/instances.ts";
+import type { InstanceContent } from "../../shared/utils/instances.ts";
 import type { EntityDecl } from "../schema/declarations/EntityDecl.ts";
+import { type DatabaseInMemory } from "./databaseInMemory.ts";
 /**
  * A mapping from instance IDs to the list of instance IDs that reference them.
  */
@@ -8,5 +9,5 @@ export type ReferencesToInstances = {
     [instanceId: string]: string[];
 };
 export declare const isReferencedByOtherInstances: (referencesToInstances: ReferencesToInstances, instanceId: string, otherInstancesToDelete?: string[]) => boolean;
-export declare const getReferencesToInstances: (instancesByEntityName: Record<string, InstanceContainer[]>, serializedDeclarationsByName: Record<string, SerializedDecl>) => Promise<ReferencesToInstances>;
-export declare const updateReferencesToInstances: (entitiesByName: Record<string, EntityDecl>, referencesToInstances: ReferencesToInstances, entityName: string, instanceId: string, oldInstance: unknown, newInstance: unknown) => ReferencesToInstances;
+export declare const getReferencesToInstances: (databaseInMemory: DatabaseInMemory, serializedDeclarationsByName: Record<string, SerializedDecl>) => Promise<ReferencesToInstances>;
+export declare const updateReferencesToInstances: (entitiesByName: Record<string, EntityDecl>, referencesToInstances: ReferencesToInstances, entityName: string, instanceId: string, oldInstance: InstanceContent | undefined, newInstance: InstanceContent | undefined) => ReferencesToInstances;

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

@@ -3,6 +3,7 @@ import { resolve } from "node:path";
 import { difference, removeAt } from "../../shared/utils/array.js";
 import { isOk } from "../../shared/utils/result.js";
 import { getReferencesForEntityDecl } from "../schema/declarations/EntityDecl.js";
+import { getGroupedInstancesFromDatabaseInMemory, } from "./databaseInMemory.js";
 import { WorkerPool } from "./workers.js";
 const debug = Debug("tsondb:utils:references");
 export const isReferencedByOtherInstances = (referencesToInstances, instanceId, otherInstancesToDelete) => {
@@ -34,11 +35,11 @@ const removeReference = (acc, reference, instanceId) => {
     return acc;
 };
 const removeReferences = (acc, references, instanceId) => references.reduce((acc1, reference) => removeReference(acc1, reference, instanceId), acc);
-export const getReferencesToInstances = async (instancesByEntityName, serializedDeclarationsByName) => {
+export const getReferencesToInstances = async (databaseInMemory, serializedDeclarationsByName) => {
     debug("creating reference worker pool ...");
     const pool = new WorkerPool(6, resolve(import.meta.dirname, "./referencesWorker.js"), serializedDeclarationsByName);
     debug("collecting references ...");
-    const separateResults = await Promise.all(Object.entries(instancesByEntityName).map(([entityName, instances]) => new Promise((resolve, reject) => {
+    const separateResults = await Promise.all(getGroupedInstancesFromDatabaseInMemory(databaseInMemory).map(([entityName, instances]) => new Promise((resolve, reject) => {
         pool.runTask({ entityName, instances }, result => {
             if (isOk(result)) {
                 debug("collected references for entity %s in %d instances", entityName, instances.length);

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

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

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

@@ -14,7 +14,7 @@ export type SerializedEntityDisplayName<T extends SerializedObjectType> = Leaves
     pathInLocaleMap?: string;
 } | null;
 type TConstraint = Record<string, SerializedMemberDecl>;
-export interface SerializedEntityDecl<Name extends string = string, T extends TConstraint = TConstraint, FK extends (keyof T & string) | undefined = (keyof T & string) | undefined> extends SerializedBaseDecl<Name, []> {
+export interface SerializedEntityDecl<Name extends string = string, T extends TConstraint = TConstraint, FK extends Extract<keyof T, string> | undefined = Extract<keyof T, string> | undefined> extends SerializedBaseDecl<Name, []> {
     kind: NodeKind["EntityDecl"];
     namePlural: string;
     type: SerializedObjectType<T>;
@@ -27,7 +27,7 @@ export interface SerializedEntityDecl<Name extends string = string, T extends TC
     isDeprecated?: boolean;
 }
 export declare const isSerializedEntityDecl: (node: SerializedNode) => node is SerializedEntityDecl;
-export declare const isSerializedEntityDeclWithParentReference: <Name extends string, T extends TConstraint, FK extends (keyof T & string) | undefined>(decl: SerializedEntityDecl<Name, T, FK>) => decl is SerializedEntityDecl<Name, T, NonNullable<FK>>;
+export declare const isSerializedEntityDeclWithParentReference: <Name extends string, T extends TConstraint, FK extends Extract<keyof T, string> | undefined>(decl: SerializedEntityDecl<Name, T, FK>) => decl is SerializedEntityDecl<Name, T, NonNullable<FK>>;
 export declare const isSerializedEntityDeclWithoutParentReference: <Name extends string, T extends TConstraint>(decl: SerializedEntityDecl<Name, T>) => decl is SerializedEntityDecl<Name, T, undefined>;
 export declare const resolveTypeArgumentsInSerializedEntityDecl: SerializedTypeArgumentsResolver<SerializedEntityDecl>;
 export declare const getReferencesForSerializedEntityDecl: GetReferencesSerialized<SerializedEntityDecl>;

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,17 @@
+export type Dictionary<T> = readonly [Readonly<Record<string, T>>, readonly string[]];
+export declare const emptyD: Dictionary<never>;
+export declare const getD: <T>(dict: Dictionary<T>, key: string) => T | undefined;
+export declare const getMapD: <T, U>(dict: Dictionary<T>, key: string, mapFn: (value: T) => U) => U | undefined;
+export declare const hasD: <T>(dict: Dictionary<T>, key: string) => boolean;
+export declare const setD: <T>(dict: Dictionary<T>, key: string, value: T) => Dictionary<T>;
+export declare const removeD: <T>(dict: Dictionary<T>, key: string) => Dictionary<T>;
+export declare const sizeD: (dict: Dictionary<unknown>) => number;
+export declare const toEntriesD: <T>(dict: Dictionary<T>) => [string, T][];
+export declare const fromEntriesD: <T>(entries: [string, T][]) => Dictionary<T>;
+export declare const toValuesD: <T>(dict: Dictionary<T>) => T[];
+export declare const forEachD: <T>(dict: Dictionary<T>, fn: (value: T, key: string) => void) => void;
+export declare const forEachAsyncD: <T>(dict: Dictionary<T>, fn: (value: T, key: string) => Promise<void>) => Promise<void>;
+export declare const modifyD: <T>(dict: Dictionary<T>, key: string, modifyFn: (currentValue: T | undefined) => T | undefined) => Dictionary<T>;
+export declare const findD: <T>(dict: Dictionary<T>, predicate: (value: T, key: string) => boolean) => T | undefined;
+export declare const mapFirstD: <T, U>(dict: Dictionary<T>, mapFn: (value: T, key: string) => U | undefined) => U | undefined;
+export declare const mapD: <T, U>(dict: Dictionary<T>, mapFn: (value: T, key: string) => U) => Dictionary<U>;

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

@@ -0,0 +1,76 @@
+export const emptyD = [{}, []];
+export const getD = (dict, key) => dict[0][key];
+export const getMapD = (dict, key, mapFn) => {
+    const value = getD(dict, key);
+    return value === undefined ? undefined : mapFn(value);
+};
+export const hasD = (dict, key) => Object.prototype.hasOwnProperty.call(dict[0], key);
+export const setD = (dict, key, value) => {
+    if (hasD(dict, key)) {
+        return [{ ...dict[0], [key]: value }, dict[1]];
+    }
+    else {
+        return [{ ...dict[0], [key]: value }, [...dict[1], key]];
+    }
+};
+export const removeD = (dict, key) => {
+    if (hasD(dict, key)) {
+        const { [key]: _, ...newRecord } = dict[0];
+        return [newRecord, dict[1].filter(k => k !== key)];
+    }
+    else {
+        return dict;
+    }
+};
+export const sizeD = (dict) => dict[1].length;
+export const toEntriesD = (dict) => Object.entries(dict[0]);
+export const fromEntriesD = (entries) => {
+    const record = Object.fromEntries(entries);
+    const keys = Object.keys(record);
+    return [record, keys];
+};
+export const toValuesD = (dict) => Object.values(dict[0]);
+export const forEachD = (dict, fn) => {
+    for (const [key, value] of Object.entries(dict[0])) {
+        fn(value, key);
+    }
+};
+export const forEachAsyncD = async (dict, fn) => {
+    for (const [key, value] of Object.entries(dict[0])) {
+        await fn(value, key);
+    }
+};
+export const modifyD = (dict, key, modifyFn) => {
+    const currentValue = getD(dict, key);
+    const newValue = modifyFn(currentValue);
+    if (newValue === undefined) {
+        return removeD(dict, key);
+    }
+    else {
+        return setD(dict, key, newValue);
+    }
+};
+export const findD = (dict, predicate) => {
+    for (const [key, value] of Object.entries(dict[0])) {
+        if (predicate(value, key)) {
+            return value;
+        }
+    }
+    return undefined;
+};
+export const mapFirstD = (dict, mapFn) => {
+    for (const [key, value] of Object.entries(dict[0])) {
+        const mapped = mapFn(value, key);
+        if (mapped !== undefined) {
+            return mapped;
+        }
+    }
+    return undefined;
+};
+export const mapD = (dict, mapFn) => {
+    const newRecord = {};
+    for (const [key, value] of Object.entries(dict[0])) {
+        newRecord[key] = mapFn(value, key);
+    }
+    return [newRecord, dict[1]];
+};

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

@@ -2,9 +2,10 @@ import type { EntityDecl } from "../../node/schema/index.ts";
 import type { GetInstanceById } from "../../node/server/index.ts";
 import { type GetChildInstancesForInstanceId } from "../../node/utils/displayName.ts";
 import type { GitFileStatus } from "./git.ts";
+export type InstanceContent = object;
 export interface InstanceContainer {
     id: string;
-    content: unknown;
+    content: InstanceContent;
     gitStatus?: GitFileStatus;
 }
 export interface InstanceContainerOverview {
@@ -14,4 +15,3 @@ export interface InstanceContainerOverview {
     displayNameLocaleId?: string;
 }
 export declare const getInstanceContainerOverview: (entity: EntityDecl, instanceContainer: InstanceContainer, getInstanceById: GetInstanceById, getChildInstancesForInstanceId: GetChildInstancesForInstanceId, locales: string[]) => InstanceContainerOverview;
-export type InstancesByEntityName = Record<string, InstanceContainer[]>;

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

@@ -43,6 +43,10 @@ export declare const reduce: <T, E, R>(result: Result<T, E>, fok: (value: T) =>
  * Maps the value of a result to a new value.
  */
 export declare const map: <T, U, E>(result: Result<T, E>, f: (value: T) => U) => Result<U, E>;
+/**
+ * Chains a result to a new result.
+ */
+export declare const then: <T, U, E>(result: Result<T, E>, f: (value: T) => Result<U, E>) => Result<U, E>;
 /**
  * Maps an error to a new error.
  */

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

@@ -25,6 +25,10 @@ export const reduce = (result, fok, ferror) => (isOk(result) ? fok(result.value)
  * Maps the value of a result to a new value.
  */
 export const map = (result, f) => isOk(result) ? ok(f(result.value)) : result;
+/**
+ * Chains a result to a new result.
+ */
+export const then = (result, f) => isOk(result) ? f(result.value) : result;
 /**
  * Maps an error to a new error.
  */

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

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

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

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

package/dist/src/web/components/InstanceRouteSkeleton.d.ts

@@ -4,25 +4,26 @@ import type { SetStateAction } from "preact/compat";
 import { type Dispatch } from "preact/hooks";
 import type { UnsafeEntityTaggedInstanceContainerWithChildInstances } from "../../node/utils/childInstances.ts";
 import type { SerializedEntityDecl } from "../../shared/schema/declarations/EntityDecl.ts";
+import type { InstanceContent } from "../../shared/utils/instances.ts";
 import { type GetDeclFromDeclName } from "../hooks/useSecondaryDeclarations.ts";
 export type InstanceRouteSkeletonInitializer = (values: {
     locales: string[];
     entity: SerializedEntityDecl;
     instanceId: string | undefined;
-    setInstanceContent: Dispatch<SetStateAction<unknown>>;
+    setInstanceContent: Dispatch<SetStateAction<InstanceContent>>;
     getDeclFromDeclName: GetDeclFromDeclName;
 }) => Promise<void>;
 export type InstanceRouteSkeletonSubmitHandler<A extends string = string> = (values: {
     locales: string[];
     entity: SerializedEntityDecl;
     instanceId: string | undefined;
-    instanceContent: unknown;
+    instanceContent: InstanceContent;
     action: A;
     customId: string;
     isLocaleEntity: boolean | undefined;
     childInstances: UnsafeEntityTaggedInstanceContainerWithChildInstances[];
     route: LocationHook["route"];
-    setInstanceContent: Dispatch<SetStateAction<unknown>>;
+    setInstanceContent: Dispatch<SetStateAction<InstanceContent>>;
     setCustomId: Dispatch<SetStateAction<string>>;
     getDeclFromDeclName: GetDeclFromDeclName;
     updateLocalGitState?: () => Promise<void>;
@@ -31,13 +32,13 @@ export type InstanceRouteSkeletonOnSubmitHandler = (values: {
     locales: string[];
     entity: SerializedEntityDecl;
     instanceId: string | undefined;
-    instanceContent: unknown;
+    instanceContent: InstanceContent;
     buttonName: string | undefined;
     customId: string;
     isLocaleEntity: boolean | undefined;
     childInstances: UnsafeEntityTaggedInstanceContainerWithChildInstances[];
     route: LocationHook["route"];
-    setInstanceContent: Dispatch<SetStateAction<unknown>>;
+    setInstanceContent: Dispatch<SetStateAction<InstanceContent>>;
     setCustomId: Dispatch<SetStateAction<string>>;
     getDeclFromDeclName: GetDeclFromDeclName;
     updateLocalGitState?: () => Promise<void>;
@@ -46,12 +47,12 @@ export type InstanceRouteSkeletonOnSaveHandler = (values: {
     locales: string[];
     entity: SerializedEntityDecl;
     instanceId: string | undefined;
-    instanceContent: unknown;
+    instanceContent: InstanceContent;
     customId: string;
     isLocaleEntity: boolean | undefined;
     childInstances: UnsafeEntityTaggedInstanceContainerWithChildInstances[];
     route: LocationHook["route"];
-    setInstanceContent: Dispatch<SetStateAction<unknown>>;
+    setInstanceContent: Dispatch<SetStateAction<InstanceContent>>;
     setCustomId: Dispatch<SetStateAction<string>>;
     getDeclFromDeclName: GetDeclFromDeclName;
     updateLocalGitState?: () => Promise<void>;
@@ -60,7 +61,7 @@ export type InstanceRouteSkeletonTitleBuilder = (values: {
     locales: string[];
     entity: SerializedEntityDecl;
     instanceId: string | undefined;
-    instanceContent: unknown;
+    instanceContent: InstanceContent | undefined;
 }) => string | undefined;
 type Props = {
     mode: "create" | "edit";