tsondb 0.5.5 → 0.5.7

package/README.md

@@ -10,6 +10,44 @@ TSON-DB can also be used to render type declarations in multiple languages or vo
 npm install tsondb
 ```
 
+## Configuration
+
+To configure `tsondb`, create a configuration file at the location from where you are going to run its commands, usually the project root. The following file names are possible and are checked in the given order:
+
+1. `tsondb.config.mts`
+2. `tsondb.config.ts`
+3. `tsondb.config.mjs`
+4. `tsondb.config.js`
+
+You need to export an object conforming to the `Config` type as the default export.
+
+```ts
+// tsondb.config.ts
+import { join } from "node:path"
+import { type Config, Schema } from "tsondb"
+import { JsonSchemaOutput } from "tsondb/renderer/jsonschema"
+import { TypeScriptOutput } from "tsondb/renderer/ts"
+
+export default {
+  schema: new Schema(
+    [
+      // add your entities here
+    ]
+  ),
+  outputs: [
+    TypeScriptOutput({
+      targetPath: join(import.meta.dirname, "gen", "ts"),
+    }),
+    JsonSchemaOutput({
+      targetPath: join(import.meta.dirname, "gen", "schema"),
+    }),
+  ],
+  dataRootPath: join(import.meta.dirname, "data"),
+} satisfies Config
+```
+
+See the following sections for details on how the different parts come together.
+
 ## Define a Schema
 
 You define a schema by declarations that consist of types.
@@ -40,6 +78,8 @@ Note that some imports may shadow global objects (like `String` and `Object` in
 
 Make sure to always pass `import.meta.url` as the first parameter to each declaration function, otherwise some functionality will not work at all or will not work as expected.
 
+To actually add `Ùser` to your schema, either list it in the array passed to the `Schema` function or reference it in an entity that is already listed.
+
 ### Available Declarations
 
 #### `Entity` or `EntityDecl`
@@ -146,26 +186,23 @@ If the database is in a Git repository, you’ll also get a simple Git GUI for m
 
 ## Generate typings
 
-To generate typings, you have to define the `outputs` option on the `ModelContainer`.
+To generate typings, you have to define the `outputs` property in the configuration file.
 
 ```ts
-ModelContainer({
+export default {
   // ...
   outputs: [
     TypeScriptOutput({
-      targetPath: join(import.meta.dirname, "..", "gen", "types.d.ts"),
-      rendererOptions: {
-        preserveFiles: false,
-      },
+      targetPath: join(import.meta.dirname, "gen", "types.d.ts"),
     }),
     JsonSchemaOutput({
-      targetPath: join(import.meta.dirname, "..", "gen", "types.schema.json"),
+      targetPath: join(import.meta.dirname, "gen", "schema"),
       rendererOptions: {
         preserveFiles: true,
       },
     }),
   ],
-})
+} satisfies Config
 ```
 
 You specify a target path where to save each generated content, and you can optionally provide custom settings to the respective renderers.

package/{lib → dist/src}/bin/tsondb.js

@@ -19,6 +19,18 @@ const passedArguments = parseArguments({
     commands: {
         validate: {
             name: "validate",
+            options: {
+                checkReferentialIntegrity: {
+                    name: "check-referential-integrity",
+                    type: Boolean,
+                },
+                entities: {
+                    name: "entities",
+                    alias: "e",
+                    multiple: true,
+                    type: String,
+                },
+            },
         },
         generate: {
             name: "generate",
@@ -33,10 +45,10 @@ const passedArguments = parseArguments({
 });
 // import the config
 const possibleConfigNames = [
-    "tsondb.config.ts",
     "tsondb.config.mts",
-    "tsondb.config.js",
+    "tsondb.config.ts",
     "tsondb.config.mjs",
+    "tsondb.config.js",
 ];
 const config = await (async () => {
     for (const configName of possibleConfigNames) {
@@ -76,7 +88,10 @@ switch (passedArguments.command.name) {
         break;
     case "validate":
         debug(`running command: validate`);
-        await validate(config.schema, config.dataRootPath);
+        await validate(config.schema, config.dataRootPath, {
+            checkReferentialIntegrity: passedArguments.command.options?.checkReferentialIntegrity,
+            checkOnlyEntities: passedArguments.command.options?.entities,
+        });
         break;
     case "format":
         debug(`running command: format`);

package/{lib → dist/src}/node/Schema.d.ts

@@ -1,5 +1,5 @@
-import type { Decl } from "./schema/declarations/Declaration.js";
-import type { EntityDecl } from "./schema/declarations/EntityDecl.js";
+import type { Decl } from "./schema/declarations/Declaration.ts";
+import type { EntityDecl } from "./schema/declarations/EntityDecl.ts";
 export interface Schema {
     declarations: readonly Decl[];
     localeEntity?: EntityDecl;

package/{lib → dist/src}/node/index.d.ts

@@ -2,8 +2,13 @@ import type { Output } from "./renderers/Output.ts";
 import type { Schema } from "./Schema.ts";
 import type { ServerOptions } from "./server/index.ts";
 export declare const generateOutputs: (schema: Schema, outputs: Output[]) => Promise<void>;
-export declare const validate: (schema: Schema, dataRootPath: string) => Promise<void>;
-export declare const generateAndValidate: (schema: Schema, outputs: Output[], dataRootPath: string) => Promise<void>;
+type ValidationOptions = {
+    checkReferentialIntegrity: boolean;
+    checkOnlyEntities: string[];
+};
+export declare const validate: (schema: Schema, dataRootPath: string, options?: Partial<ValidationOptions>) => Promise<void>;
+export declare const generateAndValidate: (schema: Schema, outputs: Output[], dataRootPath: string, validationOptions?: Partial<ValidationOptions>) => Promise<void>;
 export declare const serve: (schema: Schema, dataRootPath: string, serverOptions?: Partial<ServerOptions>) => Promise<void>;
-export declare const generateValidateAndServe: (schema: Schema, outputs: Output[], dataRootPath: string, serverOptions?: Partial<ServerOptions>) => Promise<void>;
+export declare const generateValidateAndServe: (schema: Schema, outputs: Output[], dataRootPath: string, serverOptions?: Partial<ServerOptions>, validationOptions?: Partial<ValidationOptions>) => Promise<void>;
 export declare const format: (schema: Schema, dataRootPath: string) => Promise<void>;
+export {};

package/{lib → dist/src}/node/index.js

@@ -1,6 +1,7 @@
 import Debug from "debug";
 import { mkdir, writeFile } from "fs/promises";
-import { join } from "path";
+import { join, sep } from "path";
+import { styleText } from "util";
 import { parallelizeErrors } from "../shared/utils/validation.js";
 import { getEntities } from "./Schema.js";
 import { createValidators, validateEntityDecl } from "./schema/index.js";
@@ -20,33 +21,33 @@ export const generateOutputs = async (schema, outputs) => {
         await output.run(schema);
     }
 };
-const _validate = (dataRootPath, entities, instancesByEntityName) => {
-    const errors = entities
-        .flatMap(entity => parallelizeErrors(instancesByEntityName[entity.name]?.map(instance => wrapErrorsIfAny(`in file "${join(dataRootPath, entity.name, instance.fileName)}"`, validateEntityDecl(createValidators(instancesByEntityName), entity, instance.content))) ?? []))
+const _validate = (dataRootPath, entities, instancesByEntityName, options = {}) => {
+    const { checkReferentialIntegrity = false, checkOnlyEntities = [] } = options;
+    const errors = (checkOnlyEntities.length > 0
+        ? entities.filter(entity => checkOnlyEntities.includes(entity.name))
+        : entities)
+        .flatMap(entity => parallelizeErrors(instancesByEntityName[entity.name]?.map(instance => wrapErrorsIfAny(`in file ${styleText("white", `"${dataRootPath}${sep}${styleText("bold", join(entity.name, instance.fileName))}"`)}`, validateEntityDecl(createValidators(instancesByEntityName, checkReferentialIntegrity), entity, instance.content))) ?? []))
         .toSorted((a, b) => a.message.localeCompare(b.message));
     if (errors.length === 0) {
         debug("All entities are valid");
     }
     else {
-        debug("Errors:\n");
-        for (const error of errors) {
-            debug(getErrorMessageForDisplay(error) + "\n");
-        }
+        console.error(styleText("red", "\n" + errors.map(err => getErrorMessageForDisplay(err)).join("\n\n")));
         throw new Error(`Validation failed with ${countErrors(errors).toString()} errors`);
     }
 };
-export const validate = async (schema, dataRootPath) => {
+export const validate = async (schema, dataRootPath, options) => {
     const entities = getEntities(schema);
     await prepareFolders(dataRootPath, entities);
     const instancesByEntityName = await getInstancesByEntityName(dataRootPath, entities);
-    _validate(dataRootPath, entities, instancesByEntityName);
+    _validate(dataRootPath, entities, instancesByEntityName, options);
 };
-export const generateAndValidate = async (schema, outputs, dataRootPath) => {
+export const generateAndValidate = async (schema, outputs, dataRootPath, validationOptions) => {
     await generateOutputs(schema, outputs);
     const entities = getEntities(schema);
     await prepareFolders(dataRootPath, entities);
     const instancesByEntityName = await getInstancesByEntityName(dataRootPath, entities);
-    _validate(dataRootPath, entities, instancesByEntityName);
+    _validate(dataRootPath, entities, instancesByEntityName, validationOptions);
 };
 export const serve = async (schema, dataRootPath, serverOptions) => {
     const entities = getEntities(schema);
@@ -54,12 +55,12 @@ export const serve = async (schema, dataRootPath, serverOptions) => {
     const instancesByEntityName = await getInstancesByEntityName(dataRootPath, entities);
     await createServer(schema, dataRootPath, instancesByEntityName, serverOptions);
 };
-export const generateValidateAndServe = async (schema, outputs, dataRootPath, serverOptions) => {
+export const generateValidateAndServe = async (schema, outputs, dataRootPath, serverOptions, validationOptions) => {
     await generateOutputs(schema, outputs);
     const entities = getEntities(schema);
     await prepareFolders(dataRootPath, entities);
     const instancesByEntityName = await getInstancesByEntityName(dataRootPath, entities);
-    _validate(dataRootPath, entities, instancesByEntityName);
+    _validate(dataRootPath, entities, instancesByEntityName, validationOptions);
     await createServer(schema, dataRootPath, instancesByEntityName, serverOptions);
 };
 export const format = async (schema, dataRootPath) => {

package/{lib → dist/src}/node/renderers/Output.d.ts

@@ -1,4 +1,4 @@
-import type { Schema } from "../Schema.js";
+import type { Schema } from "../Schema.ts";
 export interface Output {
     run: (schema: Schema) => Promise<void>;
 }

package/{lib → dist/src}/node/renderers/jsonschema/index.d.ts

@@ -1,5 +1,5 @@
-import type { Output } from "../Output.js";
-import type { JsonSchemaRendererOptions } from "./render.js";
+import type { Output } from "../Output.ts";
+import type { JsonSchemaRendererOptions } from "./render.ts";
 export declare const JsonSchemaOutput: (options: {
     targetPath: string;
     rendererOptions?: Partial<JsonSchemaRendererOptions>;

package/{lib → dist/src}/node/renderers/jsonschema/render.d.ts

@@ -1,4 +1,4 @@
-import type { Decl } from "../../schema/declarations/Declaration.js";
+import type { Decl } from "../../schema/declarations/Declaration.ts";
 export type JsonSchemaRendererOptions = {
     format: "minified" | "tabs" | {
         kind: "spaces";

package/{lib → dist/src}/node/renderers/ts/index.d.ts

@@ -1,5 +1,5 @@
-import type { Output } from "../Output.js";
-import type { TypeScriptRendererOptions } from "./render.js";
+import type { Output } from "../Output.ts";
+import type { TypeScriptRendererOptions } from "./render.ts";
 export declare const TypeScriptOutput: (options: {
     targetPath: string;
     rendererOptions?: Partial<TypeScriptRendererOptions>;

package/{lib → dist/src}/node/renderers/ts/render.d.ts

@@ -1,4 +1,4 @@
-import type { Decl } from "../../schema/declarations/Declaration.js";
+import type { Decl } from "../../schema/declarations/Declaration.ts";
 export type TypeScriptRendererOptions = {
     indentation: number;
     objectTypeKeyword: "interface" | "type";

package/{lib → dist/src}/node/schema/Node.d.ts

@@ -1,6 +1,6 @@
-import type { InstancesByEntityName } from "../../shared/utils/instances.js";
-import type { Decl } from "./declarations/Declaration.js";
-import type { Type } from "./types/Type.js";
+import type { InstancesByEntityName } from "../../shared/utils/instances.ts";
+import type { Decl } from "./declarations/Declaration.ts";
+import type { Type } from "./types/Type.ts";
 export interface NodeKind {
     EntityDecl: "EntityDecl";
     EnumDecl: "EnumDecl";
@@ -34,6 +34,6 @@ export type IdentifierToCheck = {
 export interface Validators {
     checkReferentialIntegrity: (identifier: IdentifierToCheck) => Error[];
 }
-export declare const createValidators: (instancesByEntityName: InstancesByEntityName) => Validators;
+export declare const createValidators: (instancesByEntityName: InstancesByEntityName, checkReferentialIntegrity?: boolean) => Validators;
 export type Serializer<T, U> = (node: T) => U;
 export type GetReferences<T extends Node> = (node: T, value: unknown) => string[];

package/{lib → dist/src}/node/schema/Node.js

@@ -1,5 +1,6 @@
 import { enumOfObject } from "../../shared/utils/enum.js";
 import { assertExhaustive } from "../../shared/utils/typeSafety.js";
+import { entity, json } from "../utils/errorFormatting.js";
 export const NodeKind = enumOfObject({
     EntityDecl: null,
     EnumDecl: null,
@@ -74,13 +75,15 @@ export const flatMapAuxiliaryDecls = (callbackFn, declarations) => {
     };
     return declarations.reduce((decls, node) => mapNodeTree(reducer, node, [...decls, node]), []);
 };
-export const createValidators = (instancesByEntityName) => ({
-    checkReferentialIntegrity: ({ name, value }) => instancesByEntityName[name]?.some(instance => typeof instance.content === "object" &&
-        instance.content !== null &&
-        !Array.isArray(instance.content) &&
-        instance.id === value)
-        ? []
-        : [
-            ReferenceError(`Invalid reference to instance of entity "${name}" with identifier ${JSON.stringify(value)}`),
-        ],
+export const createValidators = (instancesByEntityName, checkReferentialIntegrity = true) => ({
+    checkReferentialIntegrity: checkReferentialIntegrity
+        ? ({ name, value }) => instancesByEntityName[name]?.some(instance => typeof instance.content === "object" &&
+            instance.content !== null &&
+            !Array.isArray(instance.content) &&
+            instance.id === value)
+            ? []
+            : [
+                ReferenceError(`Invalid reference to instance of entity ${entity(`"${name}"`)} with identifier ${json(value)}`),
+            ]
+        : () => [],
 });

package/{lib → dist/src}/node/schema/TypeParameter.d.ts

@@ -1,6 +1,6 @@
-import type { Serializer } from "./Node.js";
-import { NodeKind } from "./Node.js";
-import type { SerializedBaseType, SerializedType, Type } from "./types/Type.js";
+import type { Serializer } from "./Node.ts";
+import { NodeKind } from "./Node.ts";
+import type { SerializedBaseType, SerializedType, Type } from "./types/Type.ts";
 export interface TypeParameter<N extends string = string, T extends Type = Type> {
     kind: NodeKind["GenericParameter"];
     name: N;

package/{lib → dist/src}/node/schema/declarations/Declaration.d.ts

@@ -1,11 +1,11 @@
-import type { BaseNode, GetReferences, Node, Serializer } from "../Node.js";
-import type { SerializedTypeParameter, TypeParameter } from "../TypeParameter.js";
-import type { EnumCaseDecl, SerializedEnumCaseDecl } from "../types/generic/EnumType.js";
-import { type SerializedType, type Type } from "../types/Type.js";
-import type { ValidatorHelpers } from "../validation/type.js";
-import type { EntityDecl, SerializedEntityDecl } from "./EntityDecl.js";
-import type { EnumDecl, SerializedEnumDecl } from "./EnumDecl.js";
-import type { SerializedTypeAliasDecl, TypeAliasDecl } from "./TypeAliasDecl.js";
+import type { BaseNode, GetReferences, Node, Serializer } from "../Node.ts";
+import type { SerializedTypeParameter, TypeParameter } from "../TypeParameter.ts";
+import type { EnumCaseDecl, SerializedEnumCaseDecl } from "../types/generic/EnumType.ts";
+import { type SerializedType, type Type } from "../types/Type.ts";
+import type { ValidatorHelpers } from "../validation/type.ts";
+import type { EntityDecl, SerializedEntityDecl } from "./EntityDecl.ts";
+import type { EnumDecl, SerializedEnumDecl } from "./EnumDecl.ts";
+import type { SerializedTypeAliasDecl, TypeAliasDecl } from "./TypeAliasDecl.ts";
 export type TypeArguments<Params extends TypeParameter[]> = {
     [K in keyof Params]: Params[K] extends TypeParameter<string, infer T> ? T : Type;
 };

package/{lib → dist/src}/node/schema/declarations/EntityDecl.d.ts

@@ -1,13 +1,13 @@
-import { Lazy } from "../../../shared/utils/lazy.js";
-import type { Leaves } from "../../../shared/utils/object.js";
-import type { GetReferences, Node, Serializer } from "../Node.js";
-import { NodeKind } from "../Node.js";
-import type { MemberDecl, ObjectType, SerializedObjectType } from "../types/generic/ObjectType.js";
-import { StringType } from "../types/primitives/StringType.js";
-import type { AsType, SerializedAsType } from "../types/Type.js";
-import type { ValidatorHelpers } from "../validation/type.js";
-import type { BaseDecl, GetNestedDeclarations, SerializedBaseDecl } from "./Declaration.js";
-import { TypeAliasDecl } from "./TypeAliasDecl.js";
+import { Lazy } from "../../../shared/utils/lazy.ts";
+import type { Leaves } from "../../../shared/utils/object.ts";
+import type { GetReferences, Node, Serializer } from "../Node.ts";
+import { NodeKind } from "../Node.ts";
+import type { MemberDecl, ObjectType, SerializedObjectType } from "../types/generic/ObjectType.ts";
+import { StringType } from "../types/primitives/StringType.ts";
+import type { AsType, SerializedAsType } from "../types/Type.ts";
+import type { ValidatorHelpers } from "../validation/type.ts";
+import type { BaseDecl, GetNestedDeclarations, SerializedBaseDecl } from "./Declaration.ts";
+import { TypeAliasDecl } from "./TypeAliasDecl.ts";
 export interface EntityDecl<Name extends string = string, T extends ObjectType = ObjectType> extends BaseDecl<Name, []> {
     kind: NodeKind["EntityDecl"];
     namePlural: string;

package/{lib → dist/src}/node/schema/declarations/EnumDecl.d.ts

@@ -1,12 +1,12 @@
-import { Lazy } from "../../../shared/utils/lazy.js";
-import type { GetReferences, Node, Serializer } from "../Node.js";
-import { NodeKind } from "../Node.js";
-import type { SerializedTypeParameter, TypeParameter } from "../TypeParameter.js";
-import type { EnumCaseDecl, SerializedEnumCaseDecl, SerializedEnumType } from "../types/generic/EnumType.js";
-import { EnumType } from "../types/generic/EnumType.js";
-import { type Type } from "../types/Type.js";
-import type { ValidatorHelpers } from "../validation/type.js";
-import type { BaseDecl, GetNestedDeclarations, SerializedBaseDecl, TypeArguments } from "./Declaration.js";
+import { Lazy } from "../../../shared/utils/lazy.ts";
+import type { GetReferences, Node, Serializer } from "../Node.ts";
+import { NodeKind } from "../Node.ts";
+import type { SerializedTypeParameter, TypeParameter } from "../TypeParameter.ts";
+import type { EnumCaseDecl, SerializedEnumCaseDecl, SerializedEnumType } from "../types/generic/EnumType.ts";
+import { EnumType } from "../types/generic/EnumType.ts";
+import { type Type } from "../types/Type.ts";
+import type { ValidatorHelpers } from "../validation/type.ts";
+import type { BaseDecl, GetNestedDeclarations, SerializedBaseDecl, TypeArguments } from "./Declaration.ts";
 export interface EnumDecl<Name extends string = string, T extends Record<string, EnumCaseDecl> = Record<string, EnumCaseDecl>, Params extends TypeParameter[] = TypeParameter[]> extends BaseDecl<Name, Params> {
     kind: NodeKind["EnumDecl"];
     type: Lazy<EnumType<T>>;

package/{lib → dist/src}/node/schema/declarations/TypeAliasDecl.d.ts

@@ -1,10 +1,10 @@
-import { Lazy } from "../../../shared/utils/lazy.js";
-import type { GetReferences, Node, Serializer } from "../Node.js";
-import { NodeKind } from "../Node.js";
-import type { SerializedTypeParameter, TypeParameter } from "../TypeParameter.js";
-import type { SerializedType, Type } from "../types/Type.js";
-import type { ValidatorHelpers } from "../validation/type.js";
-import type { BaseDecl, GetNestedDeclarations, SerializedBaseDecl, TypeArguments } from "./Declaration.js";
+import { Lazy } from "../../../shared/utils/lazy.ts";
+import type { GetReferences, Node, Serializer } from "../Node.ts";
+import { NodeKind } from "../Node.ts";
+import type { SerializedTypeParameter, TypeParameter } from "../TypeParameter.ts";
+import type { SerializedType, Type } from "../types/Type.ts";
+import type { ValidatorHelpers } from "../validation/type.ts";
+import type { BaseDecl, GetNestedDeclarations, SerializedBaseDecl, TypeArguments } from "./Declaration.ts";
 export interface TypeAliasDecl<Name extends string = string, T extends Type = Type, Params extends TypeParameter[] = TypeParameter[]> extends BaseDecl<Name, Params> {
     kind: NodeKind["TypeAliasDecl"];
     type: Lazy<T>;

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

@@ -0,0 +1,21 @@
+export * from "./declarations/Declaration.ts";
+export * from "./declarations/EntityDecl.ts";
+export * from "./declarations/EnumDecl.ts";
+export * from "./declarations/TypeAliasDecl.ts";
+export * from "./Node.ts";
+export * from "./TypeParameter.ts";
+export * from "./types/generic/ArrayType.ts";
+export * from "./types/generic/EnumType.ts";
+export * from "./types/generic/ObjectType.ts";
+export * from "./types/primitives/BooleanType.ts";
+export * from "./types/primitives/DateType.ts";
+export * from "./types/primitives/FloatType.ts";
+export * from "./types/primitives/IntegerType.ts";
+export * from "./types/primitives/NumericType.ts";
+export type * from "./types/primitives/PrimitiveType.ts";
+export * from "./types/primitives/StringType.ts";
+export * from "./types/references/IncludeIdentifierType.ts";
+export * from "./types/references/NestedEntityMapType.ts";
+export * from "./types/references/ReferenceIdentifierType.ts";
+export * from "./types/references/TypeArgumentType.ts";
+export * from "./types/Type.ts";

package/{lib → dist/src}/node/schema/types/Type.d.ts

@@ -1,19 +1,19 @@
-import type { Decl } from "../declarations/Declaration.js";
-import type { BaseNode, GetReferences, Serializer } from "../Node.js";
-import type { Validator } from "../validation/type.js";
-import type { ArrayType, SerializedArrayType } from "./generic/ArrayType.js";
-import type { EnumType, SerializedEnumType } from "./generic/EnumType.js";
-import type { MemberDecl, ObjectType, SerializedMemberDecl, SerializedObjectType } from "./generic/ObjectType.js";
-import type { BooleanType, SerializedBooleanType } from "./primitives/BooleanType.js";
-import type { DateType, SerializedDateType } from "./primitives/DateType.js";
-import type { FloatType, SerializedFloatType } from "./primitives/FloatType.js";
-import type { IntegerType, SerializedIntegerType } from "./primitives/IntegerType.js";
-import type { PrimitiveType, SerializedPrimitiveType } from "./primitives/PrimitiveType.js";
-import type { SerializedStringType, StringType } from "./primitives/StringType.js";
-import type { IncludeIdentifierType, SerializedIncludeIdentifierType } from "./references/IncludeIdentifierType.js";
-import type { NestedEntityMapType, SerializedNestedEntityMapType } from "./references/NestedEntityMapType.js";
-import type { ReferenceIdentifierType, SerializedReferenceIdentifierType } from "./references/ReferenceIdentifierType.js";
-import type { SerializedTypeArgumentType, TypeArgumentType } from "./references/TypeArgumentType.js";
+import type { Decl } from "../declarations/Declaration.ts";
+import type { BaseNode, GetReferences, Serializer } from "../Node.ts";
+import type { Validator } from "../validation/type.ts";
+import type { ArrayType, SerializedArrayType } from "./generic/ArrayType.ts";
+import type { EnumType, SerializedEnumType } from "./generic/EnumType.ts";
+import type { MemberDecl, ObjectType, SerializedMemberDecl, SerializedObjectType } from "./generic/ObjectType.ts";
+import type { BooleanType, SerializedBooleanType } from "./primitives/BooleanType.ts";
+import type { DateType, SerializedDateType } from "./primitives/DateType.ts";
+import type { FloatType, SerializedFloatType } from "./primitives/FloatType.ts";
+import type { IntegerType, SerializedIntegerType } from "./primitives/IntegerType.ts";
+import type { PrimitiveType, SerializedPrimitiveType } from "./primitives/PrimitiveType.ts";
+import type { SerializedStringType, StringType } from "./primitives/StringType.ts";
+import type { IncludeIdentifierType, SerializedIncludeIdentifierType } from "./references/IncludeIdentifierType.ts";
+import type { NestedEntityMapType, SerializedNestedEntityMapType } from "./references/NestedEntityMapType.ts";
+import type { ReferenceIdentifierType, SerializedReferenceIdentifierType } from "./references/ReferenceIdentifierType.ts";
+import type { SerializedTypeArgumentType, TypeArgumentType } from "./references/TypeArgumentType.ts";
 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.

package/{lib → dist/src}/node/schema/types/generic/ArrayType.d.ts

@@ -1,8 +1,8 @@
-import type { GetNestedDeclarations } from "../../declarations/Declaration.js";
-import type { GetReferences, Node, Serializer } from "../../Node.js";
-import { NodeKind } from "../../Node.js";
-import type { Validator } from "../../validation/type.js";
-import type { BaseType, SerializedBaseType, SerializedType, StructureFormatter, Type } from "../Type.js";
+import type { GetNestedDeclarations } from "../../declarations/Declaration.ts";
+import type { GetReferences, Node, Serializer } from "../../Node.ts";
+import { NodeKind } from "../../Node.ts";
+import type { Validator } from "../../validation/type.ts";
+import type { BaseType, SerializedBaseType, SerializedType, StructureFormatter, Type } from "../Type.ts";
 export interface ArrayType<T extends Type = Type> extends BaseType {
     kind: NodeKind["ArrayType"];
     minItems?: number;

package/{lib → dist/src}/node/schema/types/generic/ArrayType.js

@@ -1,6 +1,7 @@
 import { parallelizeErrors } from "../../../../shared/utils/validation.js";
 import { validateArrayConstraints } from "../../../../shared/validation/array.js";
 import { wrapErrorsIfAny } from "../../../utils/error.js";
+import { json, key } from "../../../utils/errorFormatting.js";
 import { getNestedDeclarations } from "../../declarations/Declaration.js";
 import { NodeKind } from "../../Node.js";
 import { validateOption } from "../../validation/options.js";
@@ -21,11 +22,11 @@ export const isArrayType = (node) => node.kind === NodeKind.ArrayType;
 export const getNestedDeclarationsInArrayType = (addedDecls, type) => getNestedDeclarations(addedDecls, type.items);
 export const validateArrayType = (helpers, type, value) => {
     if (!Array.isArray(value)) {
-        return [TypeError(`expected an array, but got ${JSON.stringify(value)}`)];
+        return [TypeError(`expected an array, but got ${json(value)}`)];
     }
     return parallelizeErrors([
         ...validateArrayConstraints(type, value),
-        ...value.map((item, index) => wrapErrorsIfAny(`at index ${index.toString()}`, validate(helpers, type.items, item))),
+        ...value.map((item, index) => wrapErrorsIfAny(`at index ${key(index.toString())}`, validate(helpers, type.items, item))),
     ]);
 };
 export const resolveTypeArgumentsInArrayType = (args, type) => ArrayType(resolveTypeArgumentsInType(args, type.items), {

package/{lib → dist/src}/node/schema/types/generic/EnumType.d.ts

@@ -1,8 +1,8 @@
-import type { GetNestedDeclarations } from "../../declarations/Declaration.js";
-import type { GetReferences, Node, Serializer } from "../../Node.js";
-import { NodeKind } from "../../Node.js";
-import type { Validator } from "../../validation/type.js";
-import type { BaseType, SerializedBaseType, SerializedType, StructureFormatter, Type } from "../Type.js";
+import type { GetNestedDeclarations } from "../../declarations/Declaration.ts";
+import type { GetReferences, Node, Serializer } from "../../Node.ts";
+import { NodeKind } from "../../Node.ts";
+import type { Validator } from "../../validation/type.ts";
+import type { BaseType, SerializedBaseType, SerializedType, StructureFormatter, Type } from "../Type.ts";
 export interface EnumType<T extends Record<string, EnumCaseDecl> = Record<string, EnumCaseDecl>> extends BaseType {
     kind: NodeKind["EnumType"];
     values: T;

package/{lib → dist/src}/node/schema/types/generic/EnumType.js

@@ -1,4 +1,5 @@
 import { discriminatorKey } from "../../../../shared/enum.js";
+import { json, key } from "../../../utils/errorFormatting.js";
 import { getNestedDeclarations } from "../../declarations/Declaration.js";
 import { NodeKind } from "../../Node.js";
 import { formatValue, getReferencesForType, removeParentKey, resolveTypeArgumentsInType, serializeType, validate, } from "../Type.js";
@@ -17,24 +18,24 @@ export const isEnumType = (node) => node.kind === NodeKind.EnumType;
 export const getNestedDeclarationsInEnumType = (addedDecls, type) => Object.values(type.values).reduce((acc, caseMember) => caseMember.type === null ? acc : getNestedDeclarations(acc, caseMember.type), addedDecls);
 export const validateEnumType = (helpers, type, value) => {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
-        return [TypeError(`expected an object, but got ${JSON.stringify(value)}`)];
+        return [TypeError(`expected an object, but got ${json(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`),
+            TypeError(`missing required discriminator value at key ${key(`"${discriminatorKey}"`)} of type string`),
         ];
     }
     const caseName = value[discriminatorKey];
     if (!(caseName in type.values)) {
         return [
-            TypeError(`discriminator "${caseName}" is not a valid enum case, possible cases are: ${Object.keys(type.values).join(", ")}`),
+            TypeError(`discriminator ${key(`"${caseName}"`)} is not a valid enum case, possible cases are: ${Object.keys(type.values).join(", ")}`),
         ];
     }
     const unknownKeyErrors = actualKeys.flatMap(actualKey => actualKey === discriminatorKey || actualKey in type.values
         ? []
         : [
-            TypeError(`key "${actualKey}" is not the discriminator key "${caseName}" or a valid enum case, possible cases are: ${Object.keys(type.values).join(", ")}`),
+            TypeError(`key ${key(`"${actualKey}"`)} is not the discriminator key ${key(`"${caseName}"`)} or a valid enum case, possible cases are: ${Object.keys(type.values).join(", ")}`),
         ]);
     if (unknownKeyErrors.length > 0) {
         return unknownKeyErrors;
@@ -42,7 +43,7 @@ export const validateEnumType = (helpers, type, value) => {
     const associatedType = type.values[caseName]?.type;
     if (associatedType != null) {
         if (!(caseName in value)) {
-            return [TypeError(`missing required associated value for case "${caseName}"`)];
+            return [TypeError(`missing required associated value for case ${key(`"${caseName}"`)}`)];
         }
         return validate(helpers, associatedType, value[caseName]);
     }

package/{lib → dist/src}/node/schema/types/generic/ObjectType.d.ts

@@ -1,9 +1,9 @@
-import type { ObjectConstraints } from "../../../../shared/validation/object.js";
-import type { GetNestedDeclarations } from "../../declarations/Declaration.js";
-import type { GetReferences, Node, Serializer } from "../../Node.js";
-import { NodeKind } from "../../Node.js";
-import type { Validator } from "../../validation/type.js";
-import type { BaseType, SerializedBaseType, SerializedType, StructureFormatter, Type } from "../Type.js";
+import type { ObjectConstraints } from "../../../../shared/validation/object.ts";
+import type { GetNestedDeclarations } from "../../declarations/Declaration.ts";
+import type { GetReferences, Node, Serializer } from "../../Node.ts";
+import { NodeKind } from "../../Node.ts";
+import type { Validator } from "../../validation/type.ts";
+import type { BaseType, SerializedBaseType, SerializedType, StructureFormatter, Type } from "../Type.ts";
 type TConstraint = Record<string, MemberDecl>;
 export interface ObjectType<T extends TConstraint = TConstraint> extends BaseType, ObjectConstraints {
     kind: NodeKind["ObjectType"];