tsondb 0.21.5 → 0.21.8

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.");
         }
@@ -386,6 +379,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 +428,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 +727,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,

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

@@ -1,9 +1,9 @@
 import { type KeyPath } from "../../shared/schema/utils/keyPath.ts";
-import { type Decl, type EntityDecl, type EnumDecl, type Node, type Type, type TypeAliasDecl } from "./dsl/index.ts";
+import type { Decl, EntityDecl, EnumDecl, Node, Type, TypeAliasDecl } from "./dsl/index.ts";
 import type { TypeParameter } from "./dsl/TypeParameter.ts";
 import type { ArrayType } from "./dsl/types/ArrayType.ts";
 import type { BooleanType } from "./dsl/types/BooleanType.ts";
-import { type ChildEntitiesType } from "./dsl/types/ChildEntitiesType.ts";
+import type { ChildEntitiesType } from "./dsl/types/ChildEntitiesType.ts";
 import type { DateType } from "./dsl/types/DateType.ts";
 import type { EnumCaseDecl, EnumType } from "./dsl/types/EnumType.ts";
 import type { FloatType } from "./dsl/types/FloatType.ts";
@@ -13,7 +13,7 @@ import type { NestedEntityMapType } from "./dsl/types/NestedEntityMapType.ts";
 import type { MemberDecl, ObjectType } from "./dsl/types/ObjectType.ts";
 import type { ReferenceIdentifierType } from "./dsl/types/ReferenceIdentifierType.ts";
 import type { StringType } from "./dsl/types/StringType.ts";
-import { type TranslationObjectType } from "./dsl/types/TranslationObjectType.ts";
+import type { TranslationObjectType } from "./dsl/types/TranslationObjectType.ts";
 import type { TypeArgumentType } from "./dsl/types/TypeArgumentType.ts";
 type KindToTypeMap = {
     ChildEntityDecl: ChildEntitiesType;
@@ -64,7 +64,7 @@ type MemberDeclsAsType<P extends Record<string, MemberDecl>> = {
 type MemberDeclsAsDeepType<P extends Record<string, MemberDecl>> = {
     [K in keyof P]: P[K] extends MemberDecl<Type, true> ? AsDeepType<P[K]["type"]> : AsDeepType<P[K]["type"]> | undefined;
 };
-export type AsDeepType<T extends Type> = T extends ArrayType<infer I> ? AsDeepType<I>[] : T extends ObjectType<infer P> ? MemberDeclsAsDeepType<P> : T extends BooleanType ? boolean : T extends DateType ? Date : T extends FloatType ? number : T extends IntegerType ? number : T extends StringType ? string : T extends TypeArgumentType ? unknown : T extends IncludeIdentifierType<TypeParameter[], infer Decl> ? Decl extends TypeAliasDecl<string, infer TA> ? AsDeepType<TA> : Decl extends EnumDecl<string, infer EC> ? AsDeepType<EnumType<EC>> : unknown : T extends NestedEntityMapType<string, infer TC> ? {
+export type AsDeepType<T extends Type> = T extends ArrayType<infer I> ? AsDeepType<I>[] : T extends ObjectType<infer P> ? MemberDeclsAsDeepType<P> : T extends BooleanType ? boolean : T extends DateType ? Date : T extends FloatType ? number : T extends IntegerType ? number : T extends StringType ? string : T extends TypeArgumentType ? unknown : T extends IncludeIdentifierType<TypeParameter[], infer InnerDecl> ? InnerDecl extends TypeAliasDecl<string, infer TA> ? AsDeepType<TA> : InnerDecl extends EnumDecl<string, infer EC> ? AsDeepType<EnumType<EC>> : unknown : T extends NestedEntityMapType<string, infer TC> ? {
     [id: string]: MemberDeclsAsDeepType<TC>;
 } : T extends ReferenceIdentifierType ? string : T extends ChildEntitiesType ? never : T extends EnumType<infer EC> ? EC extends Record<string, EnumCaseDecl> ? {
     [Case in keyof EC]: EnumCaseTypeAsDeepType<Case & string, EC[Case]["type"]>;

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

@@ -2,9 +2,6 @@ import { error, ok } from "@elyukai/utils/result";
 import { assertExhaustive } from "@elyukai/utils/typeSafety";
 import { NodeKind } from "../../shared/schema/Node.js";
 import { getAtKeyPath, parseKeyPath } from "../../shared/schema/utils/keyPath.js";
-import {} from "./dsl/index.js";
-import {} from "./dsl/types/ChildEntitiesType.js";
-import {} from "./dsl/types/TranslationObjectType.js";
 import { isArrayType, isDecl, isIncludeIdentifierType, isObjectType, isTypeAliasDecl, } from "./guards.js";
 export const isOfKind = (node, kind) => node.kind === kind;
 export const reduceNodes = (reducer, nodes, options = {}) => {
@@ -118,11 +115,11 @@ export function walkTypeNodeTree(callbackFn, type, parentTypes, parentDecl) {
             return assertExhaustive(type);
     }
 }
-export const findTypeAtPath = (type, path, options = {}) => getAtKeyPath(type, [], parseKeyPath(path), options.throwOnPathMismatch ?? false, type => isArrayType(type)
-    ? ok(type.items)
-    : error(previousPath => `Key path "${previousPath}" does not contain an array type.`), (type, name) => {
-    if (isObjectType(type)) {
-        const prop = type.properties[name];
+export const findTypeAtPath = (type, path, options = {}) => getAtKeyPath(type, [], parseKeyPath(path), options.throwOnPathMismatch ?? false, innerType => isArrayType(innerType)
+    ? ok(innerType.items)
+    : error(previousPath => `Key path "${previousPath}" does not contain an array type.`), (innerType, name) => {
+    if (isObjectType(innerType)) {
+        const prop = innerType.properties[name];
         if (prop) {
             return ok(prop.type);
         }
@@ -136,10 +133,10 @@ export const findTypeAtPath = (type, path, options = {}) => getAtKeyPath(type, [
 }, 
 // recursively resolves type aliases in includes as this is automatically
 // called recursively if needed
-type => isIncludeIdentifierType(type) &&
+innerType => isIncludeIdentifierType(innerType) &&
     options.followTypeAliasIncludes &&
-    isTypeAliasDecl(type.reference)
-    ? ok([type.reference.type.value, true])
+    isTypeAliasDecl(innerType.reference)
+    ? ok([innerType.reference.type.value, true])
     : error());
 /**
  * Tests whether a type is a child entity type, either directly or through an include.