tsondb 0.20.3 → 0.20.5

package/dist/src/node/schema/dsl/declarations/EntityDecl.js

@@ -9,7 +9,6 @@ export const EntityDecl = (sourceUrl, options) => {
     return {
         ...options,
         instanceDisplayNameCustomizer: options.instanceDisplayNameCustomizer, // ignore contravariance of registered entity type
-        customConstraints: options.customConstraints, // ignore contravariance of registered entity type
         kind: NodeKind.EntityDecl,
         sourceUrl,
         parameters: [],

package/dist/src/node/schema/generatedTypeHelpers.d.ts

@@ -55,16 +55,16 @@ export type RegisteredEnumOrTypeAlias<Name extends string, T = Register> = Regis
  */
 export declare const Case: {
     <T extends string>(type: T): Case<T>;
-    <T extends string, V extends NonNullable<unknown> | null>(type: T, value: V): Case<T, V>;
+    <T extends string, V extends AnyNonNullish | null>(type: T, value: V): Case<T, V>;
 };
 /**
  * Type representing an enum case object.
  */
 export type Case<K extends string, T = undefined> = {
-    [P in K]: T extends NonNullable<unknown> | null ? {
+    [P in K]: T extends AnyNonNullish | null ? {
         [Key in ENUM_DISCRIMINATOR_KEY]: P;
     } & {
-        [Key in P]: Extract<T, NonNullable<unknown> | null>;
+        [Key in P]: Extract<T, AnyNonNullish | null>;
     } : {
         [Key in ENUM_DISCRIMINATOR_KEY]: P;
     };

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

@@ -1,2 +1,2 @@
 import type { TransactionStep } from "../transaction.ts";
-export declare const applyStepsToDisk: (root: string, steps: TransactionStep[]) => Promise<import("@elyukai/utils/result").Ok<void> | import("@elyukai/utils/result").Error<Error>>;
+export declare const applyStepsToDisk: (root: string, steps: TransactionStep[]) => Promise<import("@elyukai/utils/result").Error<Error> | import("@elyukai/utils/result").Ok<void>>;

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

@@ -43,7 +43,7 @@ export const sendErrorResponse = (res, error) => {
         res.status(error.code).send(error.message);
     }
     else if (error instanceof Error) {
-        res.status(500).send(error.message);
+        res.status(500).send(getErrorMessageForDisplay(error));
     }
     else {
         res.status(500).send(String(error));

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

@@ -2,7 +2,7 @@ import { anySameIndices } from "@elyukai/utils/array/filters";
 import { flatCombine } from "@elyukai/utils/array/transformations";
 import { deepEqual } from "@elyukai/utils/equality";
 import { error, isError, mapError, ok } from "@elyukai/utils/result";
-import { getValueAtKeyPath, renderKeyPath } from "../../shared/schema/utils/keyPath.js";
+import { getValueAtKeyPath, getValueAtKeyPathIfDefined, renderKeyPath, } from "../../shared/schema/utils/keyPath.js";
 import {} from "./databaseInMemory.js";
 export class UniqueConstraintError extends Error {
     parts;
@@ -42,7 +42,7 @@ export const checkUniqueConstraintsForEntity = (entity, instances, instanceOverv
         const index = instances.flatMap(({ id, content }) => flatCombine(normalizedConstraint.map(elem => {
             if ("keyPath" in elem) {
                 return [
-                    getValueAtKeyPath(content, elem.keyPath) ??
+                    getValueAtKeyPathIfDefined(content, elem.keyPath) ??
                         (elem.keyPathFallback
                             ? getValueAtKeyPath(content, elem.keyPathFallback)
                             : undefined),
@@ -51,7 +51,7 @@ export const checkUniqueConstraintsForEntity = (entity, instances, instanceOverv
             else {
                 return Object.entries(getValueAtKeyPath(content, elem.entityMapKeyPath)).map(([nestedId, nestedContent]) => [
                     nestedId,
-                    getValueAtKeyPath(nestedContent, elem.keyPathInEntityMap) ??
+                    getValueAtKeyPathIfDefined(nestedContent, elem.keyPathInEntityMap) ??
                         (elem.keyPathInEntityMapFallback
                             ? getValueAtKeyPath(nestedContent, elem.keyPathInEntityMapFallback)
                             : undefined),

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

@@ -14,3 +14,4 @@ export declare const renderKeyPath: (keyPath: KeyPath) => string;
 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;

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

@@ -1,6 +1,6 @@
 import { isNotEmpty } from "@elyukai/utils/array/nonEmpty";
 import { error, isOk, ok, reduce } from "@elyukai/utils/result";
-import { assertExhaustive } from "@elyukai/utils/typeSafety";
+import { assertExhaustive, trySafe } from "@elyukai/utils/typeSafety";
 const intPattern = /^(?:0|[1-9][0-9])*$/;
 export const parseKeyPath = (keyPath) => normalizeKeyPath(keyPath).map(part => {
     if (intPattern.test(part)) {
@@ -63,3 +63,4 @@ export const getValueAtKeyPath = (value, keyPath, throwOnPathMismatch = false) =
         ? ok(value[name])
         : 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));