tsondb 0.21.5 → 0.21.10

package/dist/src/node/bin/tsondb.js

@@ -8,6 +8,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     return path;
 };
 import { omitUndefinedKeys } from "@elyukai/utils/object";
+import { assertExhaustive } from "@elyukai/utils/typeSafety";
 import Debug from "debug";
 import { access, constants } from "node:fs/promises";
 import { join } from "node:path";
@@ -87,12 +88,14 @@ const config = await (async () => {
     for (const configName of possibleConfigNames) {
         const fullPath = join(cwd(), configName);
         try {
+            // oxlint-disable-next-line no-await-in-loop
             await access(fullPath, constants.R_OK);
         }
         catch {
             debug(`could not use config file ${fullPath}, not found`);
             continue;
         }
+        // oxlint-disable-next-line no-await-in-loop
         const foundConfigModule = (await import(__rewriteRelativeImportExtension(pathToFileURL(fullPath).toString())));
         if ("default" in foundConfigModule) {
             debug(`config file ${fullPath} found with config`);
@@ -110,18 +113,19 @@ if (config === undefined) {
 if (passedArguments.command === undefined) {
     throw new Error("No command has been specified. Possible commands are: generate, serve, validate.");
 }
-const createDB = (config, validationOptions, skipReferenceCache) => TSONDB.create({
-    ...config,
+const createDB = (dataConfig, validationOptions, skipReferenceCache) => TSONDB.create({
+    ...dataConfig,
     validationOptions,
 }, skipReferenceCache);
-if (passedArguments.command.name === "generate") {
+const commandName = passedArguments.command.name;
+if (commandName === "generate") {
     debug(`running command: generate`);
     validateConfigForGeneration(config);
     await TSONDB.generateOutputs(config);
 }
 else {
     validateConfigForData(config);
-    switch (passedArguments.command.name) {
+    switch (commandName) {
         case "serve": {
             debug(`running command: serve`);
             validateConfigForServer(config);
@@ -200,5 +204,7 @@ else {
             }
             break;
         }
+        default:
+            assertExhaustive(commandName);
     }
 }

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

@@ -2,9 +2,8 @@ import type { InstanceContainer, InstanceContainerOverview, InstanceContent, Sin
 import type { FormatterOptions } from "./config.ts";
 import { Git } from "./git.js";
 import type { Output } from "./output.ts";
-import { type EntityDecl } from "./schema/dsl/index.ts";
-import type { AnyChildEntityMap, AnyEntityMap, AnyEnumMap, AnySingletonEntityMap, AnyTypeAliasMap } from "./schema/generatedTypeHelpers.ts";
-import { type IdArgsVariant } from "./schema/generatedTypeHelpers.ts";
+import type { EntityDecl } from "./schema/dsl/index.ts";
+import type { AnyChildEntityMap, AnyEntityMap, AnyEnumMap, AnySingletonEntityMap, AnyTypeAliasMap, IdArgsVariant } from "./schema/generatedTypeHelpers.ts";
 import type { Schema } from "./schema/index.ts";
 import { Transaction } from "./transaction.ts";
 export interface DefaultTSONDBTypes {
@@ -104,6 +103,7 @@ export interface TranslationValidationOptions {
      */
     matchParametersInKeys?: boolean;
 }
+export type HookTrigger = "transaction:before" | "transaction:after";
 /**
  * The main class for managing a typed JSON database.
  */
@@ -318,8 +318,17 @@ export declare class TSONDB<T extends DefaultTSONDBTypes = DefaultTSONDBTypes> {
      * @param path The file path where the compressed database will be saved.
      */
     compressToSingleFile(path: string): Promise<void>;
+    /**
+     * Registers a new hook for the specified trigger. The callback will be invoked whenever the trigger is activated.
+     */
+    registerHook(trigger: HookTrigger, callback: (db: TSONDB<T>) => void): void;
+    /**
+     * Unregisters a hook for the specified trigger.
+     */
+    unregisterHook(trigger: HookTrigger, callback: (db: TSONDB<T>) => void): void;
 }
 export type TSONDBWithGit<T extends DefaultTSONDBTypes = DefaultTSONDBTypes> = TSONDB<T> & {
     git: Git<T>;
 };
 export type { Config } from "./config.ts";
+export { createServer } from "./server/index.ts";

package/dist/src/node/index.js

@@ -15,8 +15,6 @@ import { countError, countErrors, getErrorMessageForDisplay, HTTPError, wrapErro
 import { parallelizeErrors } from "../shared/utils/validation.js";
 import { Git } from "./git.js";
 import { getDisplayName, getDisplayNameWithId } from "./schema/detached.js";
-import {} from "./schema/dsl/index.js";
-import {} from "./schema/generatedTypeHelpers.js";
 import { isEntityDecl, isEntityDeclWithParentReference } from "./schema/guards.js";
 import { serializeNode } from "./schema/treeOperations/serialization.js";
 import { createEntityNameValidator, createReferenceValidator, validateDeclReferentialIntegrity, validateDeclStructuralIntegrity, } from "./schema/treeOperations/validation.js";
@@ -32,15 +30,10 @@ import { checkUniqueConstraintsForAllEntities } from "./utils/unique.js";
 const debug = Debug("tsondb:class");
 const prepareFolders = async (dataRootPath, entities) => {
     await mkdir(dataRootPath, { recursive: true });
-    for (const entity of entities) {
-        const entityDir = join(dataRootPath, entity.name);
-        await mkdir(entityDir, { recursive: true });
-    }
+    await Promise.all(entities.map(entity => mkdir(join(dataRootPath, entity.name), { recursive: true })));
 };
 const generateOutputs = async (schema, outputs) => {
-    for (const output of outputs) {
-        await output.run(schema);
-    }
+    await Promise.all(outputs.map(output => output.run(schema)));
 };
 const getGit = async (dataRootPath) => {
     const git = simpleGit({ baseDir: dataRootPath });
@@ -59,7 +52,7 @@ const getGit = async (dataRootPath) => {
     }
 };
 const checkLocales = (schema, data, locales) => {
-    const localeEntity = schema.localeEntity;
+    const { localeEntity } = schema;
     if (localeEntity &&
         !locales.every(locale => data.hasInstanceOfEntityById(localeEntity.name, locale))) {
         throw new Error("All provided locales must exist in the database.");
@@ -71,7 +64,7 @@ const initData = async (dataRootPath, schema, locales, git, gitStatus, skipRefer
     debug("done");
     checkLocales(schema, data, locales);
     const serializedDeclarationsByName = Object.fromEntries(schema.resolvedDeclarations.map(decl => [decl.name, serializeNode(decl)]));
-    let referencesToInstances;
+    let referencesToInstances = {};
     if (!skipReferenceCache) {
         debug("creating references cache ...");
         referencesToInstances = await getReferencesToInstances(data, serializedDeclarationsByName);
@@ -79,7 +72,6 @@ const initData = async (dataRootPath, schema, locales, git, gitStatus, skipRefer
     }
     else {
         debug("skipping references cache creation");
-        referencesToInstances = {};
     }
     if (git) {
         const status = gitStatus ?? (await git.client.status());
@@ -102,6 +94,7 @@ export class TSONDB {
     #formatterOptions;
     #gitWrapper;
     #locked = false;
+    #hooks = {};
     constructor(options) {
         this.#dataRootPath = options.dataRootPath;
         this.#data = options.data;
@@ -124,7 +117,7 @@ export class TSONDB {
      * @param skipReferenceCache If set to `true`, the reference cache will not be created during initialization. This can speed up the initialization process, but referential integrity checks will not work correctly until the cache is created. This should only be set to `true` if you plan to call `sync()` immediately after initialization.
      */
     static async create(options, skipReferenceCache = false) {
-        const entities = options.schema.entities;
+        const { entities } = options.schema;
         debug("using data root path: %s", options.dataRootPath);
         await prepareFolders(options.dataRootPath, entities);
         debug("prepared folders");
@@ -135,7 +128,7 @@ export class TSONDB {
         else {
             debug("no git repository found");
         }
-        const localeEntity = options.schema.localeEntity;
+        const { localeEntity } = options.schema;
         if (!localeEntity && options.locales) {
             throw new Error("Schema does not contain a locale entity, locales cannot be provided.");
         }
@@ -193,6 +186,11 @@ export class TSONDB {
             useStyling: true,
         };
         const errors = [];
+        const summary = [];
+        const debugAndAddToSummary = (message) => {
+            debug(message);
+            summary.push(message);
+        };
         if (!skipStructuralValidation) {
             debug("Checking structural integrity ...");
             const structureErrors = onlyEntities
@@ -216,7 +214,7 @@ export class TSONDB {
                 .toSorted((a, b) => a.message.localeCompare(b.message));
             if (structureErrors.length > 0) {
                 const errorCount = countErrors(structureErrors);
-                debug(`${errorCount.toString()} structural integrity violation${errorCount === 1 ? "" : "s"} found`);
+                debugAndAddToSummary(`${errorCount.toString()} structural integrity violation${errorCount === 1 ? "" : "s"} found`);
                 errors.push(...structureErrors);
             }
             else {
@@ -250,7 +248,7 @@ export class TSONDB {
                         .toSorted((a, b) => a.message.localeCompare(b.message));
                     if (referenceErrors.length > 0) {
                         const errorCount = countErrors(referenceErrors);
-                        debug(`${errorCount.toString()} referential integrity violation${errorCount === 1 ? "" : "s"} found`);
+                        debugAndAddToSummary(`${errorCount.toString()} referential integrity violation${errorCount === 1 ? "" : "s"} found`);
                         errors.push(...referenceErrors);
                     }
                     else {
@@ -266,7 +264,7 @@ export class TSONDB {
             const uniqueConstraintResult = checkUniqueConstraintsForAllEntities(data, (changedEntities ?? onlyEntities).filter(e => isEntityDecl(e)), instanceOverviewsByEntityName);
             if (isError(uniqueConstraintResult)) {
                 const errorCount = countError(uniqueConstraintResult.error);
-                debug(`${errorCount.toString()} unique constraint violation${errorCount === 1 ? "" : "s"} found`);
+                debugAndAddToSummary(`${errorCount.toString()} unique constraint violation${errorCount === 1 ? "" : "s"} found`);
                 errors.push(uniqueConstraintResult.error);
             }
             else {
@@ -276,7 +274,7 @@ export class TSONDB {
             const customConstraintResult = checkCustomConstraintsForAllEntities((...args) => getDisplayName(getEntity, this.#locales, data, ...args), (...args) => getDisplayNameWithId(getEntity, this.#locales, data, ...args), (...args) => getInstanceOverview(data.getInstanceContainerOfEntityById.bind(data), data.getAllChildInstanceContainersForParent.bind(data, getEntity), getEntity, this.#locales, args), getEntity, data, entities);
             if (isError(customConstraintResult)) {
                 const errorCount = countError(customConstraintResult.error);
-                debug(`${errorCount.toString()} custom constraint violation${errorCount === 1 ? "" : "s"} found`);
+                debugAndAddToSummary(`${errorCount.toString()} custom constraint violation${errorCount === 1 ? "" : "s"} found`);
                 errors.push(customConstraintResult.error);
             }
             else {
@@ -284,7 +282,7 @@ export class TSONDB {
             }
         }
         else {
-            debug("Skipping further checks due to previous structural integrity errors");
+            debugAndAddToSummary("Skipping further checks due to previous structural integrity errors");
         }
         if (logToConsole) {
             console.log(`${data.totalSize.toString()} instance${data.totalSize === 1 ? "" : "s"} checked`);
@@ -293,7 +291,14 @@ export class TSONDB {
             }
             else {
                 const errorCount = countErrors(errors);
-                console.error(styleText("red", `${errorCount.toString()} validation error${errorCount === 1 ? "" : "s"} found\n\n${errors.map(err => getErrorMessageForDisplay(err)).join("\n\n")}`, { stream: stderr }));
+                console.error(styleText("red", `${errors.map(err => getErrorMessageForDisplay(err)).join("\n\n")}\n`, {
+                    stream: stderr,
+                }));
+                console.error(styleText(["red", "bold"], "Summary", { stream: stderr }));
+                console.error(styleText("red", [
+                    `${errorCount.toString()} validation error${errorCount === 1 ? "" : "s"} found`,
+                    ...summary,
+                ].join("\n"), { stream: stderr }));
             }
         }
         return errors;
@@ -386,6 +391,7 @@ export class TSONDB {
             throw new HTTPError(503, "Another transaction is currently running. Transactions cannot be run concurrently.");
         }
         debug("Starting transaction, locking database ...");
+        this.#hooks["transaction:before"]?.forEach(hook => hook(this));
         this.#locked = true;
         try {
             const getEntity = this.#schema.getEntity.bind(this.#schema);
@@ -434,6 +440,7 @@ export class TSONDB {
             this.#referencesToInstances = newRefs;
             this.#locked = false;
             debug("Transaction successful, released lock");
+            this.#hooks["transaction:after"]?.forEach(hook => hook(this));
             return res;
         }
         catch (error) {
@@ -732,4 +739,24 @@ export class TSONDB {
     async compressToSingleFile(path) {
         await writeFile(path, JSON.stringify(this.#data), "utf-8");
     }
+    /**
+     * Registers a new hook for the specified trigger. The callback will be invoked whenever the trigger is activated.
+     */
+    registerHook(trigger, callback) {
+        ;
+        (this.#hooks[trigger] ??= []).push(callback);
+    }
+    /**
+     * Unregisters a hook for the specified trigger.
+     */
+    unregisterHook(trigger, callback) {
+        const callbacks = this.#hooks[trigger];
+        if (callbacks) {
+            const index = callbacks.indexOf(callback);
+            if (index !== -1) {
+                callbacks.splice(index, 1);
+            }
+        }
+    }
 }
+export { createServer } from "./server/index.js";

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

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

package/dist/src/node/renderers/jsonschema/index.js

@@ -17,7 +17,7 @@ export const JsonSchemaOutput = (options) => ({
             const sourceRootPath = fileURLToPath(commonPrefix(...Object.keys(declarationsBySourceUrl)));
             debug("common source root path: %s", sourceRootPath);
             if (sourceRootPath) {
-                for (const [sourceUrl, decls] of Object.entries(declarationsBySourceUrl)) {
+                await Promise.all(Object.entries(declarationsBySourceUrl).map(async ([sourceUrl, decls]) => {
                     const sourcePath = fileURLToPath(sourceUrl);
                     const relativePath = dirname(relative(sourceRootPath, sourcePath));
                     const newDir = join(options.targetPath, relativePath);
@@ -26,7 +26,7 @@ export const JsonSchemaOutput = (options) => ({
                     await writeFile(newPath, render(options.rendererOptions, decls ?? []), {
                         encoding: "utf-8",
                     });
-                }
+                }));
                 debug("emitted declaration files to %s", options.targetPath);
             }
         }

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

@@ -5,8 +5,8 @@ import { NodeKind } from "../../../shared/schema/Node.js";
 import { asDecl } from "../../schema/dsl/declarations/Decl.js";
 import { addEphemeralUUIDToType, createEntityIdentifierTypeAsDecl, isEntityDecl, } from "../../schema/dsl/declarations/EntityDecl.js";
 import { TypeAliasDecl } from "../../schema/dsl/declarations/TypeAliasDecl.js";
-import { isNestedEntityMapType } from "../../schema/dsl/types/NestedEntityMapType.js";
-import { getTypeOfKey } from "../../schema/dsl/types/TranslationObjectType.js";
+import { isNestedEntityMapType, } from "../../schema/dsl/types/NestedEntityMapType.js";
+import { getTypeOfKey, } from "../../schema/dsl/types/TranslationObjectType.js";
 import { flatMapAuxiliaryDecls, isFinalChildEntitiesType } from "../../schema/helpers.js";
 import { ensureSpecialDirStart } from "../../utils/path.js";
 const defaultIndentation = 2;
@@ -24,7 +24,7 @@ const renderArrayType = (options, type) => ({
 const renderObjectType = (options, type) => ({
     type: "object",
     properties: Object.fromEntries(Object.entries(type.properties)
-        .filter(([_, config]) => !isFinalChildEntitiesType(config.type))
+        .filter(([_key, config]) => !isFinalChildEntitiesType(config.type))
         .map(([name, config]) => [
         name,
         {
@@ -192,9 +192,7 @@ export const render = (options = defaultOptions, declarations) => {
         $defs: renderDeclarations(finalOptions, flatMapAuxiliaryDecls((parentNodes, node, existingDecls) => {
             if (isNestedEntityMapType(node)) {
                 if (existingDecls.some(decl => decl.name === node.name)) {
-                    // this may happen when a nested entity map is defined in a generic declaration and the generic declaration is used multiple times
-                    // TODO: circumvent by defining the nested entity declaration outside the generic declaration
-                    return undefined;
+                    throw new Error("A nested entity map type with the same name has already been defined in this schema. Make sure the nested entity map type is defined only once in the schema. If the nested entity map type is defined in a generic declaration, consider defining it outside the generic declaration to avoid this issue.");
                 }
                 return TypeAliasDecl(asDecl(parentNodes[0])?.sourceUrl ?? "", {
                     name: node.name,

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

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

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

@@ -18,7 +18,7 @@ export const TypeScriptOutput = (options) => ({
             const sourceRootPath = fileURLToPath(commonPrefix(...Object.keys(declarationsBySourceUrl)));
             debug("common source root path: %s", sourceRootPath);
             if (sourceRootPath) {
-                for (const [sourceUrl, decls] of Object.entries(declarationsBySourceUrl)) {
+                await Promise.all(Object.entries(declarationsBySourceUrl).map(async ([sourceUrl, decls]) => {
                     const sourcePath = fileURLToPath(sourceUrl);
                     const relativePath = dirname(relative(sourceRootPath, sourcePath));
                     const newDir = join(options.targetPath, relativePath);
@@ -27,7 +27,7 @@ export const TypeScriptOutput = (options) => ({
                     await writeFile(newPath, pragma + render(options.rendererOptions, decls ?? []), {
                         encoding: "utf-8",
                     });
-                }
+                }));
                 debug("emitted declaration files to %s", options.targetPath);
             }
         }

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

@@ -12,9 +12,9 @@ import { addEphemeralUUIDToType, createEntityIdentifierTypeAsDecl, isEntityDecl,
 import { isEnumDecl } from "../../schema/dsl/declarations/EnumDecl.js";
 import { isSingletonEntityDecl, } from "../../schema/dsl/declarations/SingletonEntityDecl.js";
 import { isTypeAliasDecl, TypeAliasDecl } from "../../schema/dsl/declarations/TypeAliasDecl.js";
-import { isNestedEntityMapType } from "../../schema/dsl/types/NestedEntityMapType.js";
-import { isObjectType } from "../../schema/dsl/types/ObjectType.js";
-import { getTypeOfKey } from "../../schema/dsl/types/TranslationObjectType.js";
+import { isNestedEntityMapType, } from "../../schema/dsl/types/NestedEntityMapType.js";
+import { isObjectType, } from "../../schema/dsl/types/ObjectType.js";
+import { getTypeOfKey, } from "../../schema/dsl/types/TranslationObjectType.js";
 import { flatMapAuxiliaryDecls, isFinalChildEntitiesType } from "../../schema/helpers.js";
 import { ensureSpecialDirStart } from "../../utils/path.js";
 const defaultOptions = {
@@ -52,11 +52,9 @@ const renderArrayType = (options, type) => type.minItems !== undefined && type.m
     ])
     : syntax `${renderType(options, type.items)}[]`;
 const wrapAsObject = (options, str) => syntax `{${EOL}${indent(options.indentation, 1, str)}${EOL}}`;
-const renderObjectType = (options, type) => {
-    return wrapAsObject(options, combineSyntaxes(Object.entries(type.properties)
-        .filter(([_, config]) => !isFinalChildEntitiesType(config.type))
-        .map(([name, config]) => syntax `${renderDocumentation(config.comment, config.isDeprecated)}${name}${config.isRequired ? "" : "?"}: ${renderType(options, config.type)}`), Object.values(type.properties).some(prop => prop.comment !== undefined) ? EOL + EOL : EOL));
-};
+const renderObjectType = (options, type) => wrapAsObject(options, combineSyntaxes(Object.entries(type.properties)
+    .filter(([_key, config]) => !isFinalChildEntitiesType(config.type))
+    .map(([name, config]) => syntax `${renderDocumentation(config.comment, config.isDeprecated)}${name}${config.isRequired ? "" : "?"}: ${renderType(options, config.type)}`), Object.values(type.properties).some(prop => prop.comment !== undefined) ? EOL + EOL : EOL));
 const renderBooleanType = (_options, _type) => syntax `boolean`;
 const renderDateType = (options, _type) => options.dateType === "Date" ? syntax `Date` : syntax `string`;
 const renderFloatType = (_options, _type) => syntax `number`;
@@ -64,8 +62,8 @@ const renderIntegerType = (_options, _type) => syntax `number`;
 const renderStringType = (_options, _type) => syntax `string`;
 const renderTypeArgumentType = (_options, type) => syntax `${type.argument.name}`;
 const renderReferenceIdentifierType = (_options, type) => [
-    { [type.entity.sourceUrl]: [type.entity.name + "_ID"] },
-    type.entity.name + "_ID",
+    { [type.entity.sourceUrl]: [`${type.entity.name}_ID`] },
+    `${type.entity.name}_ID`,
 ];
 const renderIncludeIdentifierType = (options, type) => combineSyntaxes([
     [{ [type.reference.sourceUrl]: [type.reference.name] }, type.reference.name],
@@ -111,9 +109,7 @@ const renderTranslationParameterBrand = (options, params) => {
     }
     return syntax ` & { __params: { ${entries.map(([name, type]) => `"${name}": ${type}`).join("; ")} } }`;
 };
-const renderTranslationObjectType = (options, type) => {
-    return wrapAsObject(options, combineSyntaxes(Object.entries(type.properties).map(([name, config]) => syntax `"${name.replace('"', '\\"')}"${type.allKeysAreRequired ? "" : "?"}: ${renderType(options, getTypeOfKey(config, type))}${renderTranslationParameterBrand(options, mapParameterTypeNames(extractParameterTypeNamesFromMessage(name), typeName => mapTypeNameToType(options, typeName)))}`), EOL));
-};
+const renderTranslationObjectType = (options, type) => wrapAsObject(options, combineSyntaxes(Object.entries(type.properties).map(([name, config]) => syntax `"${name.replace('"', '\\"')}"${type.allKeysAreRequired ? "" : "?"}: ${renderType(options, getTypeOfKey(config, type))}${renderTranslationParameterBrand(options, mapParameterTypeNames(extractParameterTypeNamesFromMessage(name), typeName => mapTypeNameToType(options, typeName)))}`), EOL));
 const renderType = (options, type) => {
     switch (type.kind) {
         case NodeKind.ArrayType:
@@ -192,7 +188,7 @@ const renderMapHelperType = (options, declarations, key, defaultName, filterFn,
             .filter(filterFn)
             .sort((a, b) => a.name.localeCompare(b.name))
             .map(renderKeyFn ??
-            (decl => `${decl.name}: ${decl.name}${decl.parameters.length > 0 ? "<" + decl.parameters.map(param => (param.constraint ? renderType(options, param.constraint)[1] : "unknown")).join(", ") + ">" : ""}`))
+            (decl => `${decl.name}: ${decl.name}${decl.parameters.length > 0 ? `<${decl.parameters.map(param => (param.constraint ? renderType(options, param.constraint)[1] : "unknown")).join(", ")}>` : ""}`))
             .join(EOL))}${EOL}}${EOL + EOL}`
         : "";
 };
@@ -205,13 +201,7 @@ const renderStringableTranslationParameterType = (options) => options.inferTrans
     (options.inferTranslationParameters.defaultTranslationParameterType === undefined ||
         options.inferTranslationParameters.defaultTranslationParameterType ===
             "StringableTranslationParameter")
-    ? "export type StringableTranslationParameter = {" +
-        EOL +
-        prefixLines(getIndentation(options.indentation, 1), "toString(): string") +
-        EOL +
-        "}" +
-        EOL +
-        EOL
+    ? `export type StringableTranslationParameter = {${EOL}${prefixLines(getIndentation(options.indentation, 1), "toString(): string")}${EOL}}${EOL}${EOL}`
     : "";
 // const renderGetterConstruct = (
 //   config: GetterOptions | undefined,

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

@@ -1,7 +1,7 @@
 /**
  * Standalone functions for database operations without needing a full TSONDB instance.
  */
-import { type DatabaseInMemory } from "../utils/databaseInMemory.ts";
+import type { DatabaseInMemory } from "../utils/databaseInMemory.ts";
 import { type AnyEntityMap, type GetEntityByName, type IdArgsVariant } from "./generatedTypeHelpers.ts";
 export declare const getDisplayName: <EM extends AnyEntityMap>(getEntity: GetEntityByName<EM>, locales: string[], data: DatabaseInMemory<EM>, ...args: IdArgsVariant<EM>) => string | undefined;
 export declare const getDisplayNameWithId: <EM extends AnyEntityMap>(getEntity: GetEntityByName<EM>, locales: string[], data: DatabaseInMemory<EM>, ...args: IdArgsVariant<EM>) => string;

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

@@ -1,7 +1,6 @@
 /**
  * Standalone functions for database operations without needing a full TSONDB instance.
  */
-import {} from "../utils/databaseInMemory.js";
 import { getDisplayNameFromEntityInstance } from "../utils/displayName.js";
 import { normalizedIdArgs, } from "./generatedTypeHelpers.js";
 export const getDisplayName = (getEntity, locales, data, ...args) => {

package/dist/src/node/schema/dsl/declarations/Decl.d.ts

@@ -3,10 +3,10 @@ import type { Node } from "../index.ts";
 import type { TypeParameter } from "../TypeParameter.ts";
 import type { EnumCaseDecl } from "../types/EnumType.ts";
 import type { Type } from "../types/Type.ts";
-import type { EntityDecl } from "./EntityDecl.ts";
-import type { EnumDecl } from "./EnumDecl.ts";
+import { type EntityDecl } from "./EntityDecl.ts";
+import { type EnumDecl } from "./EnumDecl.ts";
 import { type SingletonEntityDecl } from "./SingletonEntityDecl.ts";
-import type { TypeAliasDecl } from "./TypeAliasDecl.ts";
+import { type TypeAliasDecl } from "./TypeAliasDecl.ts";
 export type TypeArguments<Params extends TypeParameter[]> = {
     [K in keyof Params]: Params[K] extends TypeParameter<string, infer T> ? T : Type;
 };

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

@@ -10,7 +10,7 @@ export const getTypeArgumentsRecord = (decl, args) => Object.fromEntries(
 args.slice(0, decl.parameters.length).map((arg, i) => [decl.parameters[i].name, arg]));
 export const isDecl = (node) => isEntityDecl(node) || isSingletonEntityDecl(node) || isEnumDecl(node) || isTypeAliasDecl(node);
 export const asDecl = (node) => node && isDecl(node) ? node : undefined;
-const declNamePattern = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+const declNamePattern = /^[a-zA-Z_][a-zA-Z0-9_]*$/u;
 export const validateDeclName = (name) => {
     if (!declNamePattern.test(name)) {
         throw new Error(`Invalid declaration name "${name}". Declaration names must match the pattern ${declNamePattern.toString()}.`);

package/dist/src/node/schema/dsl/declarations/EntityDecl.d.ts

@@ -7,9 +7,9 @@ import type { CustomConstraint, TypedCustomConstraint } from "../../../utils/cus
 import type { DisplayNameCustomizer, TypedDisplayNameCustomizer } from "../../../utils/displayName.ts";
 import type { Node } from "../index.ts";
 import type { NestedEntityMapType } from "../types/NestedEntityMapType.ts";
-import type { MemberDecl, ObjectType } from "../types/ObjectType.ts";
+import { type MemberDecl, type ObjectType } from "../types/ObjectType.ts";
 import { StringType } from "../types/StringType.ts";
-import type { BaseDecl } from "./Decl.ts";
+import { type BaseDecl } from "./Decl.ts";
 import { TypeAliasDecl } from "./TypeAliasDecl.ts";
 export type EntityDisplayName<T extends TConstraint> = PathTo<T, StringType> | {
     /**

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

@@ -41,6 +41,6 @@ export const addEphemeralUUIDToType = (decl) => ({
 export const createEntityIdentifierType = () => StringType();
 export const createEntityIdentifierTypeAsDecl = (decl) => TypeAliasDecl(decl.sourceUrl, {
     comment: createEntityIdentifierComment(),
-    name: (decl.name + "_ID"),
+    name: `${decl.name}_ID`,
     type: createEntityIdentifierType,
 });

package/dist/src/node/schema/dsl/declarations/EnumDecl.d.ts

@@ -4,9 +4,8 @@ import { NodeKind } from "../../../../shared/schema/Node.ts";
 import type { NestedCustomConstraint, TypedNestedCustomConstraint } from "../../../utils/customConstraints.ts";
 import type { Node } from "../index.ts";
 import type { TypeParameter } from "../TypeParameter.ts";
-import type { EnumCaseDecl } from "../types/EnumType.ts";
-import { EnumType } from "../types/EnumType.ts";
-import type { BaseDecl } from "./Decl.ts";
+import { type EnumCaseDecl, EnumType } from "../types/EnumType.ts";
+import { type BaseDecl } from "./Decl.ts";
 type TConstraint = Record<string, EnumCaseDecl>;
 export interface EnumDecl<Name extends string = string, T extends TConstraint = TConstraint, Params extends TypeParameter[] = TypeParameter[]> extends BaseDecl<Name, Params> {
     kind: NodeKind["EnumDecl"];

package/dist/src/node/schema/dsl/declarations/SingletonEntityDecl.d.ts

@@ -4,7 +4,7 @@ import type { SortOrder } from "../../../../shared/schema/utils/sortOrder.ts";
 import type { CustomConstraint, TypedCustomConstraint } from "../../../utils/customConstraints.ts";
 import type { Node } from "../index.ts";
 import type { MemberDecl, ObjectType } from "../types/ObjectType.ts";
-import type { BaseDecl } from "./Decl.ts";
+import { type BaseDecl } from "./Decl.ts";
 type TConstraint = Record<string, MemberDecl>;
 export interface SingletonEntityDecl<Name extends string = string, T extends TConstraint = TConstraint> extends BaseDecl<Name, []> {
     kind: NodeKind["SingletonEntityDecl"];

package/dist/src/node/schema/dsl/declarations/TypeAliasDecl.d.ts

@@ -4,7 +4,7 @@ import type { NestedCustomConstraint, TypedNestedCustomConstraint } from "../../
 import type { Node } from "../index.ts";
 import type { TypeParameter } from "../TypeParameter.ts";
 import type { Type } from "../types/Type.ts";
-import type { BaseDecl } from "./Decl.ts";
+import { type BaseDecl } from "./Decl.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/dsl/index.d.ts

@@ -1,5 +1,5 @@
-import type { TypeParameter } from "./TypeParameter.ts";
 import type { Decl } from "./declarations/Decl.ts";
+import type { TypeParameter } from "./TypeParameter.ts";
 import type { Type } from "./types/Type.ts";
 export { Param, TypeParameter } from "./TypeParameter.ts";
 export { type Decl, type DeclP, type IncludableDeclP, type SecondaryDecl, } from "./declarations/Decl.ts";

package/dist/src/node/schema/dsl/types/ChildEntitiesType.d.ts

@@ -1,5 +1,5 @@
 import { NodeKind } from "../../../../shared/schema/Node.ts";
-import { type EntityDecl } from "../declarations/EntityDecl.ts";
+import type { EntityDecl } from "../declarations/EntityDecl.ts";
 import type { Node } from "../index.ts";
 import type { MemberDecl } from "./ObjectType.ts";
 import type { BaseType } from "./Type.ts";

package/dist/src/node/schema/dsl/types/ChildEntitiesType.js

@@ -1,5 +1,4 @@
 import { NodeKind } from "../../../../shared/schema/Node.js";
-import {} from "../declarations/EntityDecl.js";
 export const ChildEntitiesType = (entity) => ({
     kind: NodeKind.ChildEntitiesType,
     entity,

package/dist/src/node/schema/dsl/types/IncludeIdentifierType.d.ts

@@ -1,7 +1,7 @@
 import { NodeKind } from "../../../../shared/schema/Node.ts";
 import type { IncludableDeclP, TypeArguments } from "../declarations/Decl.ts";
 import type { EnumDecl } from "../declarations/EnumDecl.ts";
-import { type TypeAliasDecl } from "../declarations/TypeAliasDecl.ts";
+import type { TypeAliasDecl } from "../declarations/TypeAliasDecl.ts";
 import type { Node } from "../index.ts";
 import type { TypeParameter } from "../TypeParameter.ts";
 import type { EnumCaseDecl } from "./EnumType.ts";

package/dist/src/node/schema/dsl/types/IncludeIdentifierType.js

@@ -1,5 +1,4 @@
 import { NodeKind } from "../../../../shared/schema/Node.js";
-import {} from "../declarations/TypeAliasDecl.js";
 export const GenIncludeIdentifierType = (reference, args) => ({
     kind: NodeKind.IncludeIdentifierType,
     reference,

package/dist/src/node/schema/dsl/types/NestedEntityMapType.d.ts

@@ -4,7 +4,7 @@ import type { EntityDecl } from "../declarations/EntityDecl.ts";
 import type { TypeAliasDecl } from "../declarations/TypeAliasDecl.ts";
 import type { Node } from "../index.ts";
 import type { TypeParameter } from "../TypeParameter.ts";
-import { type IncludeIdentifier } from "./IncludeIdentifierType.ts";
+import type { IncludeIdentifier } from "./IncludeIdentifierType.ts";
 import type { MemberDecl, ObjectType } from "./ObjectType.ts";
 import type { BaseType } from "./Type.ts";
 type TConstraint = Record<string, MemberDecl>;

package/dist/src/node/schema/dsl/types/NestedEntityMapType.js

@@ -1,6 +1,5 @@
 import { Lazy } from "@elyukai/utils/lazy";
 import { NodeKind } from "../../../../shared/schema/Node.js";
-import {} from "./IncludeIdentifierType.js";
 export const NestedEntityMapType = (options) => {
     const nestedEntityMapType = {
         ...options,

package/dist/src/node/schema/dsl/types/ObjectType.js

@@ -1,6 +1,6 @@
 import { NodeKind } from "../../../../shared/schema/Node.js";
 import { validateOption } from "../../validation/options.js";
-const keyPattern = /^[a-zA-Z0-9][a-zA-Z0-9_]*$/;
+const keyPattern = /^[a-zA-Z0-9][a-zA-Z0-9_]*$/u;
 export const ObjectType = (properties, options = {}) => {
     const type = {
         ...options,