tsondb 0.3.0 → 0.4.0

package/lib/node/index.d.ts

@@ -0,0 +1,8 @@
+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>;
+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>;

package/lib/node/index.js

@@ -0,0 +1,62 @@
+import Debug from "debug";
+import { mkdir } from "fs/promises";
+import { join } from "path";
+import { parallelizeErrors } from "../shared/utils/validation.js";
+import { getEntities } from "./Schema.js";
+import { createValidators, validateEntityDecl } from "./schema/index.js";
+import { createServer } from "./server/index.js";
+import { getErrorMessageForDisplay, wrapErrorsIfAny } from "./utils/error.js";
+import { getInstancesByEntityName } from "./utils/instances.js";
+const debug = Debug("tsondb:schema");
+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 });
+    }
+};
+export const generateOutputs = async (schema, outputs) => {
+    for (const output of outputs) {
+        await output.run(schema);
+    }
+};
+const _validate = (entities, instancesByEntityName) => {
+    const errors = entities.flatMap(entity => parallelizeErrors(instancesByEntityName[entity.name]?.map(instance => wrapErrorsIfAny(`in file "${entity.name}/${instance.fileName}"`, validateEntityDecl(createValidators(instancesByEntityName), entity, instance.content))) ?? []));
+    if (errors.length === 0) {
+        debug("All entities are valid");
+    }
+    else {
+        debug("Errors:\n");
+        for (const error of errors) {
+            debug(getErrorMessageForDisplay(error) + "\n");
+        }
+        throw new Error("Validation failed");
+    }
+};
+export const validate = async (schema, dataRootPath) => {
+    const entities = getEntities(schema);
+    await prepareFolders(dataRootPath, entities);
+    const instancesByEntityName = await getInstancesByEntityName(dataRootPath, entities);
+    _validate(entities, instancesByEntityName);
+};
+export const generateAndValidate = async (schema, outputs, dataRootPath) => {
+    await generateOutputs(schema, outputs);
+    const entities = getEntities(schema);
+    await prepareFolders(dataRootPath, entities);
+    const instancesByEntityName = await getInstancesByEntityName(dataRootPath, entities);
+    _validate(entities, instancesByEntityName);
+};
+export const serve = async (schema, dataRootPath, serverOptions) => {
+    const entities = getEntities(schema);
+    await prepareFolders(dataRootPath, entities);
+    const instancesByEntityName = await getInstancesByEntityName(dataRootPath, entities);
+    await createServer(schema, dataRootPath, instancesByEntityName, serverOptions);
+};
+export const generateValidateAndServe = async (schema, outputs, dataRootPath, serverOptions) => {
+    await generateOutputs(schema, outputs);
+    const entities = getEntities(schema);
+    await prepareFolders(dataRootPath, entities);
+    const instancesByEntityName = await getInstancesByEntityName(dataRootPath, entities);
+    _validate(entities, instancesByEntityName);
+    await createServer(schema, dataRootPath, instancesByEntityName, serverOptions);
+};

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

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

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

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

package/lib/{renderers → node/renderers}/jsonschema/index.js

@@ -1,8 +1,8 @@
 import { mkdir, rm, writeFile } from "node:fs/promises";
 import { basename, dirname, extname, join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
+import { commonPrefix } from "../../../shared/utils/string.js";
 import { groupDeclarationsBySourceUrl, resolveTypeArgumentsInDecls } from "../../schema/index.js";
-import { commonPrefix } from "../../shared/utils/string.js";
 import { render } from "./render.js";
 const extension = ".schema.json";
 export const JsonSchemaOutput = (options) => ({
@@ -19,7 +19,7 @@ export const JsonSchemaOutput = (options) => ({
                     const newDir = join(options.targetPath, relativePath);
                     const newPath = join(newDir, basename(sourcePath, extname(sourcePath)) + extension);
                     await mkdir(newDir, { recursive: true });
-                    await writeFile(newPath, render(options.rendererOptions, decls), {
+                    await writeFile(newPath, render(options.rendererOptions, decls ?? []), {
                         encoding: "utf-8",
                     });
                 }

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

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

package/lib/{renderers → node/renderers}/jsonschema/render.js

@@ -1,11 +1,11 @@
 import { dirname, relative } from "node:path";
+import { discriminatorKey } from "../../../shared/enum.js";
+import { assertExhaustive } from "../../../shared/utils/typeSafety.js";
 import { addEphemeralUUIDToType, createEntityIdentifierTypeAsDecl, isEntityDecl, } from "../../schema/declarations/EntityDecl.js";
 import { TypeAliasDecl } from "../../schema/declarations/TypeAliasDecl.js";
 import { flatMapAuxiliaryDecls, NodeKind } from "../../schema/Node.js";
-import { isNestedEntityMapType, } from "../../schema/types/references/NestedEntityMapType.js";
+import { isNestedEntityMapType } from "../../schema/types/references/NestedEntityMapType.js";
 import { getParentDecl } from "../../schema/types/Type.js";
-import { discriminatorKey } from "../../shared/enum.js";
-import { assertExhaustive } from "../../shared/utils/typeSafety.js";
 import { ensureSpecialDirStart } from "../../utils/path.js";
 const defaultIndentation = 2;
 const defaultOptions = {
@@ -67,8 +67,8 @@ const renderStringType = (_options, type) => ({
     maxLength: type.maxLength,
     pattern: type.pattern?.source,
 });
-const renderGenericArgumentIdentifierType = (_options, _type) => {
-    throw new TypeError("GenericArgumentIdentifierType is not supported in JSON Schema.");
+const renderTypeArgumentType = (_options, _type) => {
+    throw new TypeError("TypeArgumentType is not supported in JSON Schema.");
 };
 const renderReferenceIdentifierType = (_options, type) => ({
     $ref: `#/$defs/${type.entity.name}_ID`,
@@ -98,7 +98,7 @@ const renderEnumType = (options, type) => ({
             },
             ...(caseDef.type === null ? {} : { [caseName]: renderType(options, caseDef.type) }),
         },
-        required: [discriminatorKey, ...(caseDef === null ? [] : [caseName])],
+        required: [discriminatorKey, ...(caseDef.type === null ? [] : [caseName])],
     })),
 });
 const renderType = (options, type) => {
@@ -117,8 +117,8 @@ const renderType = (options, type) => {
             return renderIntegerType(options, type);
         case NodeKind.StringType:
             return renderStringType(options, type);
-        case NodeKind.GenericArgumentIdentifierType:
-            return renderGenericArgumentIdentifierType(options, type);
+        case NodeKind.TypeArgumentType:
+            return renderTypeArgumentType(options, type);
         case NodeKind.ReferenceIdentifierType:
             return renderReferenceIdentifierType(options, type);
         case NodeKind.IncludeIdentifierType:
@@ -179,5 +179,5 @@ export const render = (options = defaultOptions, declarations) => {
         ? undefined
         : finalOptions.format === "tabs"
             ? "\t"
-            : finalOptions.format.indentation ?? defaultIndentation);
+            : (finalOptions.format.indentation ?? defaultIndentation));
 };

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

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

package/lib/{renderers → node/renderers}/ts/index.js

@@ -2,8 +2,8 @@ import Debug from "debug";
 import { mkdir, rm, writeFile } from "node:fs/promises";
 import { basename, dirname, extname, join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
+import { commonPrefix } from "../../../shared/utils/string.js";
 import { groupDeclarationsBySourceUrl } from "../../schema/declarations/Declaration.js";
-import { commonPrefix } from "../../shared/utils/string.js";
 import { render } from "./render.js";
 const debug = Debug("tsondb:renderer:ts");
 const extension = ".d.ts";
@@ -23,7 +23,7 @@ export const TypeScriptOutput = (options) => ({
                     const newDir = join(options.targetPath, relativePath);
                     const newPath = join(newDir, basename(sourcePath, extname(sourcePath)) + extension);
                     await mkdir(newDir, { recursive: true });
-                    await writeFile(newPath, render(options.rendererOptions, decls), {
+                    await writeFile(newPath, render(options.rendererOptions, decls ?? []), {
                         encoding: "utf-8",
                     });
                 }

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

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

package/lib/{renderers → node/renderers}/ts/render.js

@@ -1,14 +1,14 @@
 import { EOL } from "node:os";
 import { dirname, relative } from "node:path";
+import { discriminatorKey } from "../../../shared/enum.js";
+import { toCamelCase } from "../../../shared/utils/string.js";
+import { assertExhaustive } from "../../../shared/utils/typeSafety.js";
 import { addEphemeralUUIDToType, createEntityIdentifierTypeAsDecl, isEntityDecl, } from "../../schema/declarations/EntityDecl.js";
 import { TypeAliasDecl } from "../../schema/declarations/TypeAliasDecl.js";
 import { flatMapAuxiliaryDecls, NodeKind } from "../../schema/Node.js";
 import { isObjectType } from "../../schema/types/generic/ObjectType.js";
-import { isNestedEntityMapType, } from "../../schema/types/references/NestedEntityMapType.js";
+import { isNestedEntityMapType } from "../../schema/types/references/NestedEntityMapType.js";
 import { getParentDecl } from "../../schema/types/Type.js";
-import { discriminatorKey } from "../../shared/enum.js";
-import { toCamelCase } from "../../shared/utils/string.js";
-import { assertExhaustive } from "../../shared/utils/typeSafety.js";
 import { ensureSpecialDirStart } from "../../utils/path.js";
 import { combineSyntaxes, indent, prefixLines, syntax } from "../../utils/render.js";
 const defaultOptions = {
@@ -39,7 +39,7 @@ const renderBooleanType = (_options, _type) => syntax `boolean`;
 const renderDateType = (_options, _type) => syntax `Date`;
 const renderNumericType = (_options, _type) => syntax `number`;
 const renderStringType = (_options, _type) => syntax `string`;
-const renderGenericArgumentIdentifierType = (_options, type) => syntax `${type.argument.name}`;
+const renderTypeArgumentType = (_options, type) => syntax `${type.argument.name}`;
 const renderReferenceIdentifierType = (_options, type) => [
     { [type.entity.sourceUrl]: [type.entity.name + "_ID"] },
     type.entity.name + "_ID",
@@ -70,8 +70,8 @@ const renderType = (options, type) => {
             return renderNumericType(options, type);
         case NodeKind.StringType:
             return renderStringType(options, type);
-        case NodeKind.GenericArgumentIdentifierType:
-            return renderGenericArgumentIdentifierType(options, type);
+        case NodeKind.TypeArgumentType:
+            return renderTypeArgumentType(options, type);
         case NodeKind.ReferenceIdentifierType:
             return renderReferenceIdentifierType(options, type);
         case NodeKind.IncludeIdentifierType:
@@ -130,6 +130,7 @@ export const render = (options = defaultOptions, declarations) => {
         return undefined;
     }, declarations));
     return finalOptions.preserveFiles
-        ? renderImports(declarations[0].sourceUrl, imports) + content
+        ? (declarations[0] === undefined ? "" : renderImports(declarations[0].sourceUrl, imports)) +
+            content
         : content;
 };

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

@@ -1,6 +1,6 @@
-import { InstancesByEntityName } from "../shared/utils/instances.js";
-import { Decl } from "./declarations/Declaration.js";
-import { Type } from "./types/Type.js";
+import type { InstancesByEntityName } from "../../shared/utils/instances.js";
+import type { Decl } from "./declarations/Declaration.js";
+import type { Type } from "./types/Type.js";
 export interface NodeKind {
     EntityDecl: "EntityDecl";
     EnumDecl: "EnumDecl";
@@ -14,7 +14,7 @@ export interface NodeKind {
     IntegerType: "IntegerType";
     StringType: "StringType";
     DateType: "DateType";
-    GenericArgumentIdentifierType: "GenericArgumentIdentifierType";
+    TypeArgumentType: "TypeArgumentType";
     GenericParameter: "GenericParameter";
     ReferenceIdentifierType: "ReferenceIdentifierType";
     IncludeIdentifierType: "IncludeIdentifierType";

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

@@ -1,5 +1,5 @@
-import { assertExhaustive } from "../shared/utils/typeSafety.js";
-import { enumOfObject } from "../utils/enum.js";
+import { enumOfObject } from "../../shared/utils/enum.js";
+import { assertExhaustive } from "../../shared/utils/typeSafety.js";
 export const NodeKind = enumOfObject({
     EntityDecl: null,
     EnumDecl: null,
@@ -13,7 +13,7 @@ export const NodeKind = enumOfObject({
     IntegerType: null,
     StringType: null,
     DateType: null,
-    GenericArgumentIdentifierType: null,
+    TypeArgumentType: null,
     GenericParameter: null,
     ReferenceIdentifierType: null,
     IncludeIdentifierType: null,
@@ -48,7 +48,7 @@ export const flatMapAuxiliaryDecls = (callbackFn, declarations) => {
             case NodeKind.FloatType:
             case NodeKind.IntegerType:
             case NodeKind.StringType:
-            case NodeKind.GenericArgumentIdentifierType:
+            case NodeKind.TypeArgumentType:
             case NodeKind.ReferenceIdentifierType:
             case NodeKind.IncludeIdentifierType:
             case NodeKind.NestedEntityMapType:
@@ -74,7 +74,7 @@ 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" &&
+    checkReferentialIntegrity: ({ name, value }) => instancesByEntityName[name]?.some(instance => typeof instance.content === "object" &&
         instance.content !== null &&
         !Array.isArray(instance.content) &&
         instance.id === value)

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

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

package/lib/{schema/parameters → node/schema}/TypeParameter.js

@@ -1,5 +1,5 @@
-import { NodeKind } from "../Node.js";
-import { removeParentKey, serializeType, } from "../types/Type.js";
+import { NodeKind } from "./Node.js";
+import { removeParentKey, serializeType } from "./types/Type.js";
 export const Param = (name, constraint) => ({
     kind: NodeKind.GenericParameter,
     name,

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

@@ -1,12 +1,11 @@
-import { BaseNode, GetReferences, Node, Serializer } from "../Node.js";
-import { SerializedTypeParameter, TypeParameter } from "../parameters/TypeParameter.js";
-import { EnumCaseDecl, SerializedEnumCaseDecl } from "../types/generic/EnumType.js";
-import { ObjectType, SerializedObjectType } from "../types/generic/ObjectType.js";
-import { SerializedType, Type } from "../types/Type.js";
-import { ValidatorHelpers } from "../validation/type.js";
-import { EntityDecl, SerializedEntityDecl } from "./EntityDecl.js";
-import { EnumDecl, SerializedEnumDecl } from "./EnumDecl.js";
-import { SerializedTypeAliasDecl, TypeAliasDecl } from "./TypeAliasDecl.js";
+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 } 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";
 export type TypeArguments<Params extends TypeParameter[]> = {
     [K in keyof Params]: Params[K] extends TypeParameter<string, infer T> ? T : Type;
 };
@@ -17,8 +16,8 @@ export declare const getParameterNames: (decl: Decl) => string[];
 export declare const getTypeArgumentsRecord: <Params extends TypeParameter[]>(decl: DeclP<Params>, args: TypeArguments<Params>) => Record<string, Type>;
 export type Decl = EntityDecl | EnumDecl | TypeAliasDecl;
 export type SerializedDecl = SerializedEntityDecl | SerializedEnumDecl | SerializedTypeAliasDecl;
-export type DeclP<Params extends TypeParameter[] = TypeParameter[]> = EntityDecl<string, ObjectType> | EnumDecl<string, Record<string, EnumCaseDecl>, Params> | TypeAliasDecl<string, Type, Params>;
-export type SerializedDeclP<Params extends SerializedTypeParameter[] = SerializedTypeParameter[]> = SerializedEntityDecl<string, SerializedObjectType> | SerializedEnumDecl<string, Record<string, SerializedEnumCaseDecl>, Params> | SerializedTypeAliasDecl<string, SerializedType, Params>;
+export type DeclP<Params extends TypeParameter[] = TypeParameter[]> = EntityDecl | EnumDecl<string, Record<string, EnumCaseDecl>, Params> | TypeAliasDecl<string, Type, Params>;
+export type SerializedDeclP<Params extends SerializedTypeParameter[] = SerializedTypeParameter[]> = SerializedEntityDecl | SerializedEnumDecl<string, Record<string, SerializedEnumCaseDecl>, Params> | SerializedTypeAliasDecl<string, SerializedType, Params>;
 export type SecondaryDecl = EnumDecl | TypeAliasDecl;
 export type SerializedSecondaryDecl = SerializedEnumDecl | SerializedTypeAliasDecl;
 export declare const getNestedDeclarations: GetNestedDeclarations;

package/lib/{schema → node/schema}/declarations/Declaration.js

@@ -1,8 +1,8 @@
-import { assertExhaustive } from "../../shared/utils/typeSafety.js";
+import { assertExhaustive } from "../../../shared/utils/typeSafety.js";
 import { NodeKind } from "../Node.js";
 import { getNestedDeclarationsInArrayType } from "../types/generic/ArrayType.js";
-import { getNestedDeclarationsInEnumType, } from "../types/generic/EnumType.js";
-import { getNestedDeclarationsInObjectType, } from "../types/generic/ObjectType.js";
+import { getNestedDeclarationsInEnumType } from "../types/generic/EnumType.js";
+import { getNestedDeclarationsInObjectType } from "../types/generic/ObjectType.js";
 import { getNestedDeclarationsInIncludeIdentifierType } from "../types/references/IncludeIdentifierType.js";
 import { getNestedDeclarationsInNestedEntityMapType } from "../types/references/NestedEntityMapType.js";
 import { getNestedDeclarationsInReferenceIdentifierType } from "../types/references/ReferenceIdentifierType.js";
@@ -10,7 +10,9 @@ import { getNestedDeclarationsInEntityDecl, getReferencesForEntityDecl, isEntity
 import { getNestedDeclarationsInEnumDecl, getReferencesForEnumDecl, isEnumDecl, resolveTypeArgumentsInEnumDecl, serializeEnumDecl, validateEnumDecl, } from "./EnumDecl.js";
 import { getNestedDeclarationsInTypeAliasDecl, getReferencesForTypeAliasDecl, isTypeAliasDecl, resolveTypeArgumentsInTypeAliasDecl, serializeTypeAliasDecl, validateTypeAliasDecl, } from "./TypeAliasDecl.js";
 export const getParameterNames = (decl) => decl.parameters.map(param => param.name);
-export const getTypeArgumentsRecord = (decl, args) => Object.fromEntries(args.map((arg, i) => [decl.parameters[i].name, arg]));
+export const getTypeArgumentsRecord = (decl, args) => Object.fromEntries(
+// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+args.slice(0, decl.parameters.length).map((arg, i) => [decl.parameters[i].name, arg]));
 export const getNestedDeclarations = (addedDecls, node) => {
     switch (node.kind) {
         case NodeKind.EntityDecl:
@@ -28,7 +30,7 @@ export const getNestedDeclarations = (addedDecls, node) => {
         case NodeKind.FloatType:
         case NodeKind.IntegerType:
         case NodeKind.StringType:
-        case NodeKind.GenericArgumentIdentifierType:
+        case NodeKind.TypeArgumentType:
             return addedDecls;
         case NodeKind.ReferenceIdentifierType:
             return getNestedDeclarationsInReferenceIdentifierType(addedDecls, node);

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

@@ -1,11 +1,12 @@
-import { Lazy } from "../../utils/lazy.js";
-import { Leaves } from "../../utils/object.js";
-import { GetReferences, Node, NodeKind, Serializer } from "../Node.js";
-import { MemberDecl, ObjectType, SerializedObjectType } from "../types/generic/ObjectType.js";
+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 { AsType, SerializedAsType, Type } from "../types/Type.js";
-import { ValidatorHelpers } from "../validation/type.js";
-import { BaseDecl, GetNestedDeclarations, SerializedBaseDecl } from "./Declaration.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";
 export interface EntityDecl<Name extends string = string, T extends ObjectType = ObjectType> extends BaseDecl<Name, []> {
     kind: NodeKind["EntityDecl"];
@@ -70,10 +71,10 @@ export declare const isEntityDecl: (node: Node) => node is EntityDecl;
 export declare const getNestedDeclarationsInEntityDecl: GetNestedDeclarations<EntityDecl>;
 export declare const validateEntityDecl: (helpers: ValidatorHelpers, decl: EntityDecl, value: unknown) => Error[];
 export declare const resolveTypeArgumentsInEntityDecl: (decl: EntityDecl) => EntityDecl;
-export declare const addEphemeralUUIDToType: <T extends Record<string, MemberDecl<Type, boolean>>>(decl: EntityDecl<string, ObjectType<T>>) => ObjectType<Omit<T, "id"> & {
+export declare const addEphemeralUUIDToType: <T extends Record<string, MemberDecl>>(decl: EntityDecl<string, ObjectType<T>>) => ObjectType<Omit<T, "id"> & {
     id: MemberDecl<StringType, true>;
 }>;
 export declare const createEntityIdentifierType: () => StringType;
-export declare const createEntityIdentifierTypeAsDecl: <Name extends string>(decl: EntityDecl<Name, ObjectType>) => TypeAliasDecl<`${Name}_ID`, StringType, []>;
+export declare const createEntityIdentifierTypeAsDecl: <Name extends string>(decl: EntityDecl<Name>) => TypeAliasDecl<`${Name}_ID`, StringType, []>;
 export declare const serializeEntityDecl: Serializer<EntityDecl, SerializedEntityDecl>;
 export declare const getReferencesForEntityDecl: GetReferences<EntityDecl>;

package/lib/{schema → node/schema}/declarations/EntityDecl.js

@@ -1,9 +1,9 @@
-import { Lazy } from "../../utils/lazy.js";
+import { Lazy } from "../../../shared/utils/lazy.js";
 import { NodeKind } from "../Node.js";
 import { getNestedDeclarationsInObjectType, getReferencesForObjectType, Required, resolveTypeArgumentsInObjectType, serializeObjectType, } from "../types/generic/ObjectType.js";
 import { StringType } from "../types/primitives/StringType.js";
 import { validate } from "../types/Type.js";
-import { validateDeclName, } from "./Declaration.js";
+import { validateDeclName } from "./Declaration.js";
 import { TypeAliasDecl } from "./TypeAliasDecl.js";
 export const EntityDecl = (sourceUrl, options) => {
     validateDeclName(options.name);

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

@@ -1,10 +1,12 @@
-import { Lazy } from "../../utils/lazy.js";
-import { GetReferences, Node, NodeKind, Serializer } from "../Node.js";
-import { SerializedTypeParameter, TypeParameter } from "../parameters/TypeParameter.js";
-import { EnumCaseDecl, EnumType, SerializedEnumCaseDecl, SerializedEnumType } from "../types/generic/EnumType.js";
-import { Type } from "../types/Type.js";
-import { ValidatorHelpers } from "../validation/type.js";
-import { BaseDecl, GetNestedDeclarations, SerializedBaseDecl, TypeArguments } from "./Declaration.js";
+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";
 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/{schema → node/schema}/declarations/EnumDecl.js

@@ -1,8 +1,8 @@
-import { Lazy } from "../../utils/lazy.js";
+import { Lazy } from "../../../shared/utils/lazy.js";
 import { NodeKind } from "../Node.js";
-import { serializeTypeParameter, } from "../parameters/TypeParameter.js";
+import { serializeTypeParameter } from "../TypeParameter.js";
 import { EnumType, getNestedDeclarationsInEnumType, getReferencesForEnumType, resolveTypeArgumentsInEnumType, serializeEnumType, validateEnumType, } from "../types/generic/EnumType.js";
-import { getTypeArgumentsRecord, validateDeclName, } from "./Declaration.js";
+import { getTypeArgumentsRecord, validateDeclName } from "./Declaration.js";
 export const GenEnumDecl = (sourceUrl, options) => {
     validateDeclName(options.name);
     const decl = {

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

@@ -1,9 +1,10 @@
-import { Lazy } from "../../utils/lazy.js";
-import { GetReferences, Node, NodeKind, Serializer } from "../Node.js";
-import { SerializedTypeParameter, TypeParameter } from "../parameters/TypeParameter.js";
-import { SerializedType, Type } from "../types/Type.js";
-import { ValidatorHelpers } from "../validation/type.js";
-import { BaseDecl, GetNestedDeclarations, SerializedBaseDecl, TypeArguments } from "./Declaration.js";
+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";
 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>;
@@ -29,7 +30,7 @@ export declare const TypeAliasDecl: <Name extends string, T extends Type>(source
     type: () => T;
 }) => TypeAliasDecl<Name, T, []>;
 export { TypeAliasDecl as TypeAlias };
-export declare const isTypeAliasDecl: (node: Node) => node is TypeAliasDecl<string, Type, TypeParameter[]>;
+export declare const isTypeAliasDecl: (node: Node) => node is TypeAliasDecl;
 export declare const getNestedDeclarationsInTypeAliasDecl: GetNestedDeclarations<TypeAliasDecl>;
 export declare const validateTypeAliasDecl: <Params extends TypeParameter[]>(helpers: ValidatorHelpers, decl: TypeAliasDecl<string, Type, Params>, args: TypeArguments<Params>, value: unknown) => Error[];
 export declare const resolveTypeArgumentsInTypeAliasDecl: <Params extends TypeParameter[]>(decl: TypeAliasDecl<string, Type, Params>, args: TypeArguments<Params>) => TypeAliasDecl<string, Type, []>;

package/lib/{schema → node/schema}/declarations/TypeAliasDecl.js

@@ -1,8 +1,8 @@
-import { Lazy } from "../../utils/lazy.js";
+import { Lazy } from "../../../shared/utils/lazy.js";
 import { NodeKind } from "../Node.js";
-import { serializeTypeParameter, } from "../parameters/TypeParameter.js";
+import { serializeTypeParameter } from "../TypeParameter.js";
 import { getReferencesForType, resolveTypeArgumentsInType, serializeType, validate, } from "../types/Type.js";
-import { getNestedDeclarations, getTypeArgumentsRecord, validateDeclName, } from "./Declaration.js";
+import { getNestedDeclarations, getTypeArgumentsRecord, validateDeclName } from "./Declaration.js";
 export const GenTypeAliasDecl = (sourceUrl, options) => {
     validateDeclName(options.name);
     const decl = {

package/lib/{schema → node/schema}/index.d.ts

@@ -3,19 +3,19 @@ export * from "./declarations/EntityDecl.js";
 export * from "./declarations/EnumDecl.js";
 export * from "./declarations/TypeAliasDecl.js";
 export * from "./Node.js";
-export * from "./parameters/TypeParameter.js";
+export * from "./TypeParameter.js";
 export * from "./types/generic/ArrayType.js";
-export { EnumCase } from "./types/generic/EnumType.js";
+export * from "./types/generic/EnumType.js";
 export * from "./types/generic/ObjectType.js";
 export * from "./types/primitives/BooleanType.js";
 export * from "./types/primitives/DateType.js";
 export * from "./types/primitives/FloatType.js";
 export * from "./types/primitives/IntegerType.js";
 export * from "./types/primitives/NumericType.js";
-export * from "./types/primitives/PrimitiveType.js";
+export type * from "./types/primitives/PrimitiveType.js";
 export * from "./types/primitives/StringType.js";
-export * from "./types/references/GenericArgumentIdentifierType.js";
 export * from "./types/references/IncludeIdentifierType.js";
 export * from "./types/references/NestedEntityMapType.js";
 export * from "./types/references/ReferenceIdentifierType.js";
+export * from "./types/references/TypeArgumentType.js";
 export * from "./types/Type.js";

package/lib/{schema → node/schema}/index.js

@@ -3,19 +3,18 @@ export * from "./declarations/EntityDecl.js";
 export * from "./declarations/EnumDecl.js";
 export * from "./declarations/TypeAliasDecl.js";
 export * from "./Node.js";
-export * from "./parameters/TypeParameter.js";
+export * from "./TypeParameter.js";
 export * from "./types/generic/ArrayType.js";
-export { EnumCase } from "./types/generic/EnumType.js";
+export * from "./types/generic/EnumType.js";
 export * from "./types/generic/ObjectType.js";
 export * from "./types/primitives/BooleanType.js";
 export * from "./types/primitives/DateType.js";
 export * from "./types/primitives/FloatType.js";
 export * from "./types/primitives/IntegerType.js";
 export * from "./types/primitives/NumericType.js";
-export * from "./types/primitives/PrimitiveType.js";
 export * from "./types/primitives/StringType.js";
-export * from "./types/references/GenericArgumentIdentifierType.js";
 export * from "./types/references/IncludeIdentifierType.js";
 export * from "./types/references/NestedEntityMapType.js";
 export * from "./types/references/ReferenceIdentifierType.js";
+export * from "./types/references/TypeArgumentType.js";
 export * from "./types/Type.js";