@vaadin/hilla-generator-plugin-model 24.4.0-alpha1

package/.lintstagedrc.js

@@ -0,0 +1,6 @@
+import { commands, extensions } from '../../../.lintstagedrc.js';
+
+export default {
+  [`src/**/*.{${extensions}}`]: commands,
+  [`test/**/*.{${extensions}}`]: commands,
+};

package/EntityModelProcessor.d.ts

@@ -0,0 +1,35 @@
+import { type Schema } from '@vaadin/hilla-generator-core/Schema.js';
+import DependencyManager from '@vaadin/hilla-generator-utils/dependencies/DependencyManager.js';
+import { type ClassDeclaration, type Identifier, type SourceFile } from 'typescript';
+import { type Context } from './utils.js';
+export type DependencyData = Readonly<{
+    id: Identifier;
+    path: string;
+}>;
+declare const $dependencies: unique symbol;
+declare const $entity: unique symbol;
+declare const $fullyQualifiedName: unique symbol;
+declare const $model: unique symbol;
+declare const $processDeclaration: unique symbol;
+export declare abstract class EntityModelProcessor {
+    #private;
+    static process(name: string, component: Schema, context: Context): SourceFile;
+    protected readonly [$dependencies]: DependencyManager;
+    protected readonly [$entity]: DependencyData;
+    protected readonly [$fullyQualifiedName]: string;
+    protected readonly [$model]: DependencyData;
+    protected constructor(name: string, shouldImportEntityAsType: boolean);
+    process(): SourceFile;
+    protected abstract [$processDeclaration](): ClassDeclaration | undefined;
+}
+export declare class EntityClassModelProcessor extends EntityModelProcessor {
+    #private;
+    constructor(name: string, component: Schema, context: Context);
+    protected [$processDeclaration](): ClassDeclaration | undefined;
+}
+export declare class EntityEnumModelProcessor extends EntityModelProcessor {
+    constructor(name: string);
+    protected [$processDeclaration](): ClassDeclaration;
+}
+export {};
+//# sourceMappingURL=EntityModelProcessor.d.ts.map

package/EntityModelProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityModelProcessor.d.ts","sourceRoot":"","sources":["src/EntityModelProcessor.ts"],"names":[],"mappings":"AAEA,OAAO,EAWL,KAAK,MAAM,EACZ,MAAM,wCAAwC,CAAC;AAMhD,OAAO,iBAAiB,MAAM,iEAAiE,CAAC;AAEhG,OAAW,EACT,KAAK,gBAAgB,EAErB,KAAK,UAAU,EACf,KAAK,UAAU,EAEhB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAA0B,KAAK,OAAO,EAAsD,MAAM,YAAY,CAAC;AAEtH,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC;IACpC,EAAE,EAAE,UAAU,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd,CAAC,CAAC;AAEH,QAAA,MAAM,aAAa,eAAW,CAAC;AAC/B,QAAA,MAAM,OAAO,eAAW,CAAC;AACzB,QAAA,MAAM,mBAAmB,eAAW,CAAC;AACrC,QAAA,MAAM,MAAM,eAAW,CAAC;AACxB,QAAA,MAAM,mBAAmB,eAAW,CAAC;AAErC,8BAAsB,oBAAoB;;IACxC,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,UAAU;IAY7E,SAAS,CAAC,QAAQ,CAAC,CAAC,aAAa,CAAC,EAAE,iBAAiB,CAAC;IACtD,SAAS,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,EAAE,cAAc,CAAC;IAC7C,SAAS,CAAC,QAAQ,CAAC,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IACjD,SAAS,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAE,cAAc,CAAC;IAG5C,SAAS,aAAa,IAAI,EAAE,MAAM,EAAE,wBAAwB,EAAE,OAAO;IAuBrE,OAAO,IAAI,UAAU;IAarB,SAAS,CAAC,QAAQ,CAAC,CAAC,mBAAmB,CAAC,IAAI,gBAAgB,GAAG,SAAS;CACzE;AAED,qBAAa,yBAA0B,SAAQ,oBAAoB;;gBAOrD,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO;IAc7D,SAAS,CAAC,CAAC,mBAAmB,CAAC,IAAI,gBAAgB,GAAG,SAAS;CA6GhE;AAED,qBAAa,wBAAyB,SAAQ,oBAAoB;gBACpD,IAAI,EAAE,MAAM;IAIxB,SAAS,CAAC,CAAC,mBAAmB,CAAC,IAAI,gBAAgB;CA+BpD"}

package/EntityModelProcessor.js

@@ -0,0 +1,222 @@
+import { dirname } from "path/posix";
+import {
+  convertReferenceSchemaToPath,
+  convertReferenceSchemaToSpecifier,
+  decomposeSchema,
+  isComposedSchema,
+  isEmptyObject,
+  isEnumSchema,
+  isObjectSchema,
+  isReferenceSchema
+} from "@vaadin/hilla-generator-core/Schema.js";
+import {
+  convertFullyQualifiedNameToRelativePath,
+  simplifyFullyQualifiedName
+} from "@vaadin/hilla-generator-core/utils.js";
+import createSourceFile from "@vaadin/hilla-generator-utils/createSourceFile.js";
+import DependencyManager from "@vaadin/hilla-generator-utils/dependencies/DependencyManager.js";
+import PathManager from "@vaadin/hilla-generator-utils/dependencies/PathManager.js";
+import ts, {
+} from "typescript";
+import { ModelSchemaExpressionProcessor, ModelSchemaTypeProcessor } from "./ModelSchemaProcessor.js";
+import { importBuiltInFormModel, createModelBuildingCallback, createEmptyValueMaker } from "./utils.js";
+const $dependencies = Symbol();
+const $entity = Symbol();
+const $fullyQualifiedName = Symbol();
+const $model = Symbol();
+const $processDeclaration = Symbol();
+class EntityModelProcessor {
+  static process(name, component, context) {
+    context.owner.logger.debug(`Processing model for entity: ${name}`);
+    const schema = isComposedSchema(component) ? decomposeSchema(component)[0] : component;
+    return isEnumSchema(schema) ? (
+      // eslint-disable-next-line @typescript-eslint/no-use-before-define
+      new EntityEnumModelProcessor(name).process()
+    ) : (
+      // eslint-disable-next-line @typescript-eslint/no-use-before-define
+      new EntityClassModelProcessor(name, component, context).process()
+    );
+  }
+  [$dependencies];
+  [$entity];
+  [$fullyQualifiedName];
+  [$model];
+  #outputPathManager = new PathManager({ extension: "ts" });
+  constructor(name, shouldImportEntityAsType) {
+    this[$fullyQualifiedName] = name;
+    const entityName = simplifyFullyQualifiedName(name);
+    const entityPath = convertFullyQualifiedNameToRelativePath(name);
+    const modelName = `${entityName}Model`;
+    const modelPath = `${entityPath}Model`;
+    this[$dependencies] = new DependencyManager(new PathManager({ extension: ".js", relativeTo: dirname(modelPath) }));
+    const { exports, imports, paths } = this[$dependencies];
+    this[$model] = {
+      id: exports.default.set(modelName),
+      path: modelPath
+    };
+    this[$entity] = {
+      id: imports.default.add(paths.createRelativePath(entityPath), entityName, shouldImportEntityAsType),
+      path: entityPath
+    };
+  }
+  process() {
+    const declaration = this[$processDeclaration]();
+    const { exports, imports } = this[$dependencies];
+    const importStatements = imports.toCode();
+    const exportStatement = exports.toCode();
+    return createSourceFile(
+      [...importStatements, declaration, ...exportStatement].filter(Boolean),
+      this.#outputPathManager.createRelativePath(this[$model].path)
+    );
+  }
+}
+class EntityClassModelProcessor extends EntityModelProcessor {
+  #component;
+  #context;
+  #fullyQualifiedName;
+  #getPropertyModelSymbol;
+  #makeObjectEmptyValueCreator;
+  constructor(name, component, context) {
+    super(name, true);
+    this.#component = component;
+    this.#context = context;
+    this.#fullyQualifiedName = name;
+    this.#getPropertyModelSymbol = this[$dependencies].imports.named.add("@vaadin/hilla-lit-form", "_getPropertyModel");
+    this.#makeObjectEmptyValueCreator = this[$dependencies].imports.named.add(
+      "@vaadin/hilla-lit-form",
+      "makeObjectEmptyValueCreator"
+    );
+  }
+  [$processDeclaration]() {
+    const { logger } = this.#context.owner;
+    let entitySchema = this.#component;
+    let parent;
+    if (isComposedSchema(this.#component)) {
+      const decomposed = decomposeSchema(this.#component);
+      if (decomposed.length > 2) {
+        logger.debug(
+          this.#component,
+          `The schema for a class component ${this.#fullyQualifiedName} has more than two components. This plugin will ignore it.`
+        );
+        return void 0;
+      }
+      const [parentSchema, childSchema] = decomposed;
+      if (!isReferenceSchema(parentSchema)) {
+        logger.debug(parentSchema, "Only reference schema allowed for parent class");
+        return void 0;
+      }
+      entitySchema = childSchema;
+      parent = this.#processParentClass(parentSchema);
+    } else {
+      parent = importBuiltInFormModel("ObjectModel", this[$dependencies]);
+    }
+    return this.#processModelClass(entitySchema, this[$entity].id, parent);
+  }
+  #processClassElements({ properties }) {
+    if (!properties) {
+      return [];
+    }
+    return Object.entries(properties).map(([name, schema]) => {
+      const type = new ModelSchemaTypeProcessor(schema, this[$dependencies]).process();
+      const args = new ModelSchemaExpressionProcessor(schema, this[$dependencies]).process();
+      return ts.factory.createGetAccessorDeclaration(
+        void 0,
+        ts.factory.createIdentifier(name),
+        [],
+        type,
+        ts.factory.createBlock(
+          [
+            ts.factory.createReturnStatement(
+              ts.factory.createCallExpression(
+                ts.factory.createElementAccessExpression(ts.factory.createThis(), this.#getPropertyModelSymbol),
+                void 0,
+                [ts.factory.createStringLiteral(name), createModelBuildingCallback(type.typeName, args)]
+              )
+            )
+          ],
+          true
+        )
+      );
+    });
+  }
+  #processModelClass(schema, entity, parent) {
+    const { logger } = this.#context.owner;
+    if (!isObjectSchema(schema)) {
+      logger.debug(schema, `Component is not an object: ${this.#fullyQualifiedName}`);
+      return void 0;
+    }
+    if (isEmptyObject(schema)) {
+      logger.warn(`Component has no properties: ${this.#fullyQualifiedName}`);
+    }
+    const typeT = ts.factory.createIdentifier("T");
+    const modelTypeParameters = ts.factory.createTypeParameterDeclaration(
+      void 0,
+      typeT,
+      ts.factory.createTypeReferenceNode(entity),
+      ts.factory.createTypeReferenceNode(entity)
+    );
+    return ts.factory.createClassDeclaration(
+      void 0,
+      this[$model].id,
+      [modelTypeParameters],
+      [
+        ts.factory.createHeritageClause(ts.SyntaxKind.ExtendsKeyword, [
+          ts.factory.createExpressionWithTypeArguments(parent, [ts.factory.createTypeReferenceNode(typeT)])
+        ])
+      ],
+      [
+        createEmptyValueMaker(this.#makeObjectEmptyValueCreator, this[$model].id),
+        ...this.#processClassElements(schema)
+      ]
+    );
+  }
+  #processParentClass(schema) {
+    const { imports, paths } = this[$dependencies];
+    const specifier = convertReferenceSchemaToSpecifier(schema);
+    const path = convertReferenceSchemaToPath(schema);
+    const modelPath = paths.createRelativePath(`${path}Model`);
+    const modelSpecifier = `${specifier}Model`;
+    return imports.default.add(modelPath, modelSpecifier, false);
+  }
+}
+class EntityEnumModelProcessor extends EntityModelProcessor {
+  constructor(name) {
+    super(name, false);
+  }
+  [$processDeclaration]() {
+    const enumModel = importBuiltInFormModel("EnumModel", this[$dependencies]);
+    const enumPropertySymbol = this[$dependencies].imports.named.add("@vaadin/hilla-lit-form", "_enum");
+    const makeEnumEmptyValueCreator = this[$dependencies].imports.named.add(
+      "@vaadin/hilla-lit-form",
+      "makeEnumEmptyValueCreator"
+    );
+    return ts.factory.createClassDeclaration(
+      void 0,
+      this[$model].id,
+      void 0,
+      [
+        ts.factory.createHeritageClause(ts.SyntaxKind.ExtendsKeyword, [
+          ts.factory.createExpressionWithTypeArguments(enumModel, [
+            ts.factory.createTypeQueryNode(this[$entity].id, void 0)
+          ])
+        ])
+      ],
+      [
+        createEmptyValueMaker(makeEnumEmptyValueCreator, this[$model].id),
+        ts.factory.createPropertyDeclaration(
+          [ts.factory.createModifier(ts.SyntaxKind.ReadonlyKeyword)],
+          ts.factory.createComputedPropertyName(enumPropertySymbol),
+          void 0,
+          void 0,
+          this[$entity].id
+        )
+      ]
+    );
+  }
+}
+export {
+  EntityClassModelProcessor,
+  EntityEnumModelProcessor,
+  EntityModelProcessor
+};
+//# sourceMappingURL=EntityModelProcessor.js.map

package/EntityModelProcessor.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["src/EntityModelProcessor.ts"],
+  "sourcesContent": ["/* eslint-disable symbol-description */\nimport { dirname } from 'path/posix';\nimport {\n  convertReferenceSchemaToPath,\n  convertReferenceSchemaToSpecifier,\n  decomposeSchema,\n  isComposedSchema,\n  isEmptyObject,\n  isEnumSchema,\n  isObjectSchema,\n  isReferenceSchema,\n  type ObjectSchema,\n  type ReferenceSchema,\n  type Schema,\n} from '@vaadin/hilla-generator-core/Schema.js';\nimport {\n  convertFullyQualifiedNameToRelativePath,\n  simplifyFullyQualifiedName,\n} from '@vaadin/hilla-generator-core/utils.js';\nimport createSourceFile from '@vaadin/hilla-generator-utils/createSourceFile.js';\nimport DependencyManager from '@vaadin/hilla-generator-utils/dependencies/DependencyManager.js';\nimport PathManager from '@vaadin/hilla-generator-utils/dependencies/PathManager.js';\nimport ts, {\n  type ClassDeclaration,\n  type ClassElement,\n  type Identifier,\n  type SourceFile,\n  type Statement,\n} from 'typescript';\nimport { ModelSchemaExpressionProcessor, ModelSchemaTypeProcessor } from './ModelSchemaProcessor.js';\nimport { importBuiltInFormModel, type Context, createModelBuildingCallback, createEmptyValueMaker } from './utils.js';\n\nexport type DependencyData = Readonly<{\n  id: Identifier;\n  path: string;\n}>;\n\nconst $dependencies = Symbol();\nconst $entity = Symbol();\nconst $fullyQualifiedName = Symbol();\nconst $model = Symbol();\nconst $processDeclaration = Symbol();\n\nexport abstract class EntityModelProcessor {\n  static process(name: string, component: Schema, context: Context): SourceFile {\n    context.owner.logger.debug(`Processing model for entity: ${name}`);\n\n    const schema = isComposedSchema(component) ? decomposeSchema(component)[0] : component;\n\n    return isEnumSchema(schema)\n      ? // eslint-disable-next-line @typescript-eslint/no-use-before-define\n        new EntityEnumModelProcessor(name).process() // eslint-disable-line no-use-before-define\n      : // eslint-disable-next-line @typescript-eslint/no-use-before-define\n        new EntityClassModelProcessor(name, component, context).process(); // eslint-disable-line no-use-before-define\n  }\n\n  protected readonly [$dependencies]: DependencyManager;\n  protected readonly [$entity]: DependencyData;\n  protected readonly [$fullyQualifiedName]: string;\n  protected readonly [$model]: DependencyData;\n  readonly #outputPathManager = new PathManager({ extension: 'ts' });\n\n  protected constructor(name: string, shouldImportEntityAsType: boolean) {\n    this[$fullyQualifiedName] = name;\n\n    const entityName = simplifyFullyQualifiedName(name);\n    const entityPath = convertFullyQualifiedNameToRelativePath(name);\n\n    const modelName = `${entityName}Model`;\n    const modelPath = `${entityPath}Model`;\n    this[$dependencies] = new DependencyManager(new PathManager({ extension: '.js', relativeTo: dirname(modelPath) }));\n\n    const { exports, imports, paths } = this[$dependencies];\n\n    this[$model] = {\n      id: exports.default.set(modelName),\n      path: modelPath,\n    };\n\n    this[$entity] = {\n      id: imports.default.add(paths.createRelativePath(entityPath), entityName, shouldImportEntityAsType),\n      path: entityPath,\n    };\n  }\n\n  process(): SourceFile {\n    const declaration = this[$processDeclaration]();\n\n    const { exports, imports } = this[$dependencies];\n    const importStatements = imports.toCode();\n    const exportStatement = exports.toCode();\n\n    return createSourceFile(\n      [...importStatements, declaration, ...exportStatement].filter(Boolean) as readonly Statement[],\n      this.#outputPathManager.createRelativePath(this[$model].path),\n    );\n  }\n\n  protected abstract [$processDeclaration](): ClassDeclaration | undefined;\n}\n\nexport class EntityClassModelProcessor extends EntityModelProcessor {\n  readonly #component: Schema;\n  readonly #context: Context;\n  readonly #fullyQualifiedName: string;\n  readonly #getPropertyModelSymbol: Identifier;\n  readonly #makeObjectEmptyValueCreator: Identifier;\n\n  constructor(name: string, component: Schema, context: Context) {\n    super(name, true);\n\n    this.#component = component;\n    this.#context = context;\n    this.#fullyQualifiedName = name;\n\n    this.#getPropertyModelSymbol = this[$dependencies].imports.named.add('@vaadin/hilla-lit-form', '_getPropertyModel');\n    this.#makeObjectEmptyValueCreator = this[$dependencies].imports.named.add(\n      '@vaadin/hilla-lit-form',\n      'makeObjectEmptyValueCreator',\n    );\n  }\n\n  protected [$processDeclaration](): ClassDeclaration | undefined {\n    const { logger } = this.#context.owner;\n\n    let entitySchema = this.#component;\n    let parent;\n\n    if (isComposedSchema(this.#component)) {\n      const decomposed = decomposeSchema(this.#component);\n\n      if (decomposed.length > 2) {\n        logger.debug(\n          this.#component,\n          `The schema for a class component ${this.#fullyQualifiedName} has more than two components. This plugin will ignore it.`,\n        );\n        return undefined;\n      }\n\n      const [parentSchema, childSchema] = decomposed;\n\n      if (!isReferenceSchema(parentSchema)) {\n        logger.debug(parentSchema, 'Only reference schema allowed for parent class');\n        return undefined;\n      }\n\n      entitySchema = childSchema;\n      parent = this.#processParentClass(parentSchema);\n    } else {\n      parent = importBuiltInFormModel('ObjectModel', this[$dependencies]);\n    }\n\n    return this.#processModelClass(entitySchema, this[$entity].id, parent);\n  }\n\n  #processClassElements({ properties }: ObjectSchema): readonly ClassElement[] {\n    if (!properties) {\n      return [];\n    }\n\n    return Object.entries(properties).map(([name, schema]) => {\n      const type = new ModelSchemaTypeProcessor(schema, this[$dependencies]).process();\n      const args = new ModelSchemaExpressionProcessor(schema, this[$dependencies]).process();\n\n      return ts.factory.createGetAccessorDeclaration(\n        undefined,\n        ts.factory.createIdentifier(name),\n        [],\n        type,\n        ts.factory.createBlock(\n          [\n            ts.factory.createReturnStatement(\n              ts.factory.createCallExpression(\n                ts.factory.createElementAccessExpression(ts.factory.createThis(), this.#getPropertyModelSymbol),\n                undefined,\n                [ts.factory.createStringLiteral(name), createModelBuildingCallback(type.typeName as Identifier, args)],\n              ),\n            ),\n          ],\n          true,\n        ),\n      );\n    });\n  }\n\n  #processModelClass(schema: Schema, entity: Identifier, parent: Identifier): ClassDeclaration | undefined {\n    const { logger } = this.#context.owner;\n\n    if (!isObjectSchema(schema)) {\n      logger.debug(schema, `Component is not an object: ${this.#fullyQualifiedName}`);\n      return undefined;\n    }\n\n    if (isEmptyObject(schema)) {\n      logger.warn(`Component has no properties: ${this.#fullyQualifiedName}`);\n    }\n\n    const typeT = ts.factory.createIdentifier('T');\n    const modelTypeParameters = ts.factory.createTypeParameterDeclaration(\n      undefined,\n      typeT,\n      ts.factory.createTypeReferenceNode(entity),\n      ts.factory.createTypeReferenceNode(entity),\n    );\n\n    return ts.factory.createClassDeclaration(\n      undefined,\n      this[$model].id,\n      [modelTypeParameters],\n      [\n        ts.factory.createHeritageClause(ts.SyntaxKind.ExtendsKeyword, [\n          ts.factory.createExpressionWithTypeArguments(parent, [ts.factory.createTypeReferenceNode(typeT)]),\n        ]),\n      ],\n      [\n        createEmptyValueMaker(this.#makeObjectEmptyValueCreator, this[$model].id),\n        ...this.#processClassElements(schema),\n      ],\n    );\n  }\n\n  #processParentClass(schema: ReferenceSchema): Identifier {\n    const { imports, paths } = this[$dependencies];\n\n    const specifier = convertReferenceSchemaToSpecifier(schema);\n    const path = convertReferenceSchemaToPath(schema);\n    const modelPath = paths.createRelativePath(`${path}Model`);\n    const modelSpecifier = `${specifier}Model`;\n\n    return imports.default.add(modelPath, modelSpecifier, false);\n  }\n}\n\nexport class EntityEnumModelProcessor extends EntityModelProcessor {\n  constructor(name: string) {\n    super(name, false);\n  }\n\n  protected [$processDeclaration](): ClassDeclaration {\n    const enumModel = importBuiltInFormModel('EnumModel', this[$dependencies]);\n    const enumPropertySymbol = this[$dependencies].imports.named.add('@vaadin/hilla-lit-form', '_enum');\n    const makeEnumEmptyValueCreator = this[$dependencies].imports.named.add(\n      '@vaadin/hilla-lit-form',\n      'makeEnumEmptyValueCreator',\n    );\n\n    return ts.factory.createClassDeclaration(\n      undefined,\n      this[$model].id,\n      undefined,\n      [\n        ts.factory.createHeritageClause(ts.SyntaxKind.ExtendsKeyword, [\n          ts.factory.createExpressionWithTypeArguments(enumModel, [\n            ts.factory.createTypeQueryNode(this[$entity].id, undefined),\n          ]),\n        ]),\n      ],\n      [\n        createEmptyValueMaker(makeEnumEmptyValueCreator, this[$model].id),\n        ts.factory.createPropertyDeclaration(\n          [ts.factory.createModifier(ts.SyntaxKind.ReadonlyKeyword)],\n          ts.factory.createComputedPropertyName(enumPropertySymbol),\n          undefined,\n          undefined,\n          this[$entity].id,\n        ),\n      ],\n    );\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/MetadataProcessor.d.ts

@@ -0,0 +1,13 @@
+import type { Schema } from '@vaadin/hilla-generator-core/Schema.js';
+import { type ObjectLiteralExpression } from 'typescript';
+interface Annotation {
+    name: string;
+    attributes?: Record<string, unknown>;
+}
+export type SchemaWithMetadata = Schema & {
+    'x-annotations'?: Annotation[];
+    'x-java-type'?: string;
+};
+export declare function process(schema: Schema): ObjectLiteralExpression | null;
+export {};
+//# sourceMappingURL=MetadataProcessor.d.ts.map

package/MetadataProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetadataProcessor.d.ts","sourceRoot":"","sources":["src/MetadataProcessor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wCAAwC,CAAC;AACrE,OAAW,EAAE,KAAK,uBAAuB,EAA2B,MAAM,YAAY,CAAC;AAEvF,UAAU,UAAU;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC;AAED,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG;IACxC,eAAe,CAAC,EAAE,UAAU,EAAE,CAAC;IAC/B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AA8BF,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,uBAAuB,GAAG,IAAI,CAYtE"}

package/MetadataProcessor.js

@@ -0,0 +1,38 @@
+import ts, {} from "typescript";
+function createAnnotationsProperty(schema) {
+  const annotations = schema["x-annotations"];
+  const hasAnnotations = annotations && annotations.length > 0;
+  if (!hasAnnotations) {
+    return null;
+  }
+  const annotationLiterals = annotations.map(
+    (annotation) => ts.factory.createObjectLiteralExpression([
+      ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(annotation.name))
+    ])
+  );
+  return ts.factory.createPropertyAssignment(
+    "annotations",
+    ts.factory.createArrayLiteralExpression(annotationLiterals)
+  );
+}
+function createJavaTypeProperty(schema) {
+  const javaType = schema["x-java-type"];
+  if (!javaType) {
+    return null;
+  }
+  return ts.factory.createPropertyAssignment("javaType", ts.factory.createStringLiteral(javaType));
+}
+function process(schema) {
+  const schemaWithMetadata = schema;
+  const properties = [createAnnotationsProperty(schemaWithMetadata), createJavaTypeProperty(schemaWithMetadata)].filter(
+    Boolean
+  );
+  if (properties.length === 0) {
+    return null;
+  }
+  return ts.factory.createObjectLiteralExpression(properties);
+}
+export {
+  process
+};
+//# sourceMappingURL=MetadataProcessor.js.map

package/MetadataProcessor.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["src/MetadataProcessor.ts"],
+  "sourcesContent": ["import type { Schema } from '@vaadin/hilla-generator-core/Schema.js';\nimport ts, { type ObjectLiteralExpression, type PropertyAssignment } from 'typescript';\n\ninterface Annotation {\n  name: string;\n  attributes?: Record<string, unknown>;\n}\n\nexport type SchemaWithMetadata = Schema & {\n  'x-annotations'?: Annotation[];\n  'x-java-type'?: string;\n};\n\nfunction createAnnotationsProperty(schema: SchemaWithMetadata): PropertyAssignment | null {\n  const annotations = schema['x-annotations'];\n  const hasAnnotations = annotations && annotations.length > 0;\n  if (!hasAnnotations) {\n    return null;\n  }\n\n  const annotationLiterals = annotations.map((annotation) =>\n    ts.factory.createObjectLiteralExpression([\n      ts.factory.createPropertyAssignment('name', ts.factory.createStringLiteral(annotation.name)),\n    ]),\n  );\n\n  return ts.factory.createPropertyAssignment(\n    'annotations',\n    ts.factory.createArrayLiteralExpression(annotationLiterals),\n  );\n}\n\nfunction createJavaTypeProperty(schema: SchemaWithMetadata): PropertyAssignment | null {\n  const javaType = schema['x-java-type'];\n  if (!javaType) {\n    return null;\n  }\n\n  return ts.factory.createPropertyAssignment('javaType', ts.factory.createStringLiteral(javaType));\n}\n\nexport function process(schema: Schema): ObjectLiteralExpression | null {\n  const schemaWithMetadata = schema as SchemaWithMetadata;\n\n  const properties = [createAnnotationsProperty(schemaWithMetadata), createJavaTypeProperty(schemaWithMetadata)].filter(\n    Boolean,\n  ) as PropertyAssignment[];\n\n  if (properties.length === 0) {\n    return null;\n  }\n\n  return ts.factory.createObjectLiteralExpression(properties);\n}\n"],
+  "mappings": "AACA,OAAO,YAAmE;AAY1E,SAAS,0BAA0B,QAAuD;AACxF,QAAM,cAAc,OAAO,eAAe;AAC1C,QAAM,iBAAiB,eAAe,YAAY,SAAS;AAC3D,MAAI,CAAC,gBAAgB;AACnB,WAAO;AAAA,EACT;AAEA,QAAM,qBAAqB,YAAY;AAAA,IAAI,CAAC,eAC1C,GAAG,QAAQ,8BAA8B;AAAA,MACvC,GAAG,QAAQ,yBAAyB,QAAQ,GAAG,QAAQ,oBAAoB,WAAW,IAAI,CAAC;AAAA,IAC7F,CAAC;AAAA,EACH;AAEA,SAAO,GAAG,QAAQ;AAAA,IAChB;AAAA,IACA,GAAG,QAAQ,6BAA6B,kBAAkB;AAAA,EAC5D;AACF;AAEA,SAAS,uBAAuB,QAAuD;AACrF,QAAM,WAAW,OAAO,aAAa;AACrC,MAAI,CAAC,UAAU;AACb,WAAO;AAAA,EACT;AAEA,SAAO,GAAG,QAAQ,yBAAyB,YAAY,GAAG,QAAQ,oBAAoB,QAAQ,CAAC;AACjG;AAEO,SAAS,QAAQ,QAAgD;AACtE,QAAM,qBAAqB;AAE3B,QAAM,aAAa,CAAC,0BAA0B,kBAAkB,GAAG,uBAAuB,kBAAkB,CAAC,EAAE;AAAA,IAC7G;AAAA,EACF;AAEA,MAAI,WAAW,WAAW,GAAG;AAC3B,WAAO;AAAA,EACT;AAEA,SAAO,GAAG,QAAQ,8BAA8B,UAAU;AAC5D;",
+  "names": []
+}

package/ModelSchemaProcessor.d.ts

@@ -0,0 +1,52 @@
+import { type ArraySchema, type BooleanSchema, type IntegerSchema, type MapSchema, type NumberSchema, type ReferenceSchema, type Schema, type StringSchema } from '@vaadin/hilla-generator-core/Schema.js';
+import type DependencyManager from '@vaadin/hilla-generator-utils/dependencies/DependencyManager.js';
+import ts, { type Expression, type TypeReferenceNode } from 'typescript';
+declare const $dependencies: unique symbol;
+declare const $processArray: unique symbol;
+declare const $processRecord: unique symbol;
+declare const $processReference: unique symbol;
+declare const $processString: unique symbol;
+declare const $processNumber: unique symbol;
+declare const $processBoolean: unique symbol;
+declare const $processUnknown: unique symbol;
+declare const $originalSchema: unique symbol;
+declare const $schema: unique symbol;
+export declare abstract class ModelSchemaPartProcessor<T> {
+    protected readonly [$dependencies]: DependencyManager;
+    protected readonly [$originalSchema]: Schema;
+    protected readonly [$schema]: Schema;
+    constructor(schema: Schema, dependencies: DependencyManager);
+    process(): T;
+    protected abstract [$processArray](schema: ArraySchema): T;
+    protected abstract [$processBoolean](schema: BooleanSchema): T;
+    protected abstract [$processNumber](schema: IntegerSchema | NumberSchema): T;
+    protected abstract [$processRecord](schema: MapSchema): T;
+    protected abstract [$processReference](schema: ReferenceSchema): T;
+    protected abstract [$processString](schema: StringSchema): T;
+    protected abstract [$processUnknown](schema: Schema): T;
+}
+export declare class ModelSchemaTypeProcessor extends ModelSchemaPartProcessor<TypeReferenceNode> {
+    #private;
+    constructor(schema: Schema, dependencies: DependencyManager);
+    protected [$processArray](schema: ArraySchema): TypeReferenceNode;
+    protected [$processBoolean](schema: BooleanSchema): TypeReferenceNode;
+    protected [$processNumber](schema: IntegerSchema | NumberSchema): TypeReferenceNode;
+    protected [$processRecord](schema: MapSchema): TypeReferenceNode;
+    protected [$processReference](schema: ReferenceSchema): TypeReferenceNode;
+    protected [$processString](schema: StringSchema): TypeReferenceNode;
+    protected [$processUnknown](schema: Schema): TypeReferenceNode;
+}
+export declare class ModelSchemaExpressionProcessor extends ModelSchemaPartProcessor<readonly Expression[]> {
+    #private;
+    constructor(schema: Schema, dependencies: DependencyManager);
+    process(): readonly ts.Expression[];
+    protected [$processArray](schema: ArraySchema): readonly Expression[];
+    protected [$processBoolean](_: BooleanSchema): readonly Expression[];
+    protected [$processNumber](_: IntegerSchema | NumberSchema): readonly Expression[];
+    protected [$processRecord](_: MapSchema): readonly Expression[];
+    protected [$processReference](_: ReferenceSchema): readonly Expression[];
+    protected [$processString](_: StringSchema): readonly Expression[];
+    protected [$processUnknown](_: Schema): readonly Expression[];
+}
+export {};
+//# sourceMappingURL=ModelSchemaProcessor.d.ts.map

package/ModelSchemaProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModelSchemaProcessor.d.ts","sourceRoot":"","sources":["src/ModelSchemaProcessor.ts"],"names":[],"mappings":"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"}

package/ModelSchemaProcessor.js

@@ -0,0 +1,227 @@
+import {
+  convertReferenceSchemaToPath,
+  convertReferenceSchemaToSpecifier,
+  decomposeSchema,
+  isArraySchema,
+  isBooleanSchema,
+  isComposedSchema,
+  isIntegerSchema,
+  isMapSchema,
+  isNullableSchema,
+  isNumberSchema,
+  isReferenceSchema,
+  isStringSchema
+} from "@vaadin/hilla-generator-core/Schema.js";
+import ts, {
+} from "typescript";
+import { process } from "./MetadataProcessor.js";
+import { createModelBuildingCallback, importBuiltInFormModel } from "./utils.js";
+import { hasValidationConstraints, ValidationConstraintProcessor } from "./ValidationConstraintProcessor.js";
+const $dependencies = Symbol();
+const $processArray = Symbol();
+const $processRecord = Symbol();
+const $processReference = Symbol();
+const $processString = Symbol();
+const $processNumber = Symbol();
+const $processBoolean = Symbol();
+const $processUnknown = Symbol();
+const $originalSchema = Symbol();
+const $schema = Symbol();
+class ModelSchemaPartProcessor {
+  [$dependencies];
+  [$originalSchema];
+  [$schema];
+  constructor(schema, dependencies) {
+    this[$dependencies] = dependencies;
+    this[$originalSchema] = schema;
+    this[$schema] = isComposedSchema(schema) ? decomposeSchema(schema)[0] : schema;
+  }
+  process() {
+    const schema = this[$schema];
+    if (isReferenceSchema(schema)) {
+      return this[$processReference](schema);
+    }
+    if (isArraySchema(schema)) {
+      return this[$processArray](schema);
+    }
+    if (isMapSchema(schema)) {
+      return this[$processRecord](schema);
+    }
+    if (isStringSchema(schema)) {
+      return this[$processString](schema);
+    }
+    if (isNumberSchema(schema) || isIntegerSchema(schema)) {
+      return this[$processNumber](schema);
+    }
+    if (isBooleanSchema(schema)) {
+      return this[$processBoolean](schema);
+    }
+    return this[$processUnknown](schema);
+  }
+}
+function handleNullableInternalType(schema, typeNode) {
+  return isNullableSchema(schema) ? ts.factory.createUnionTypeNode([typeNode, ts.factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword)]) : typeNode;
+}
+class ModelSchemaInternalTypeProcessor extends ModelSchemaPartProcessor {
+  [$processArray](schema) {
+    return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("ReadonlyArray"), [
+      handleNullableInternalType(
+        schema.items,
+        new ModelSchemaInternalTypeProcessor(schema.items, this[$dependencies]).process()
+      )
+    ]);
+  }
+  [$processBoolean](_) {
+    return ts.factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword);
+  }
+  [$processNumber](_) {
+    return ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
+  }
+  [$processRecord]({ additionalProperties: props }) {
+    const valueType = typeof props === "boolean" ? ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword) : handleNullableInternalType(props, new ModelSchemaInternalTypeProcessor(props, this[$dependencies]).process());
+    return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("Record"), [
+      ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
+      valueType
+    ]);
+  }
+  [$processReference](schema) {
+    const { imports, paths } = this[$dependencies];
+    const typeName = convertReferenceSchemaToSpecifier(schema);
+    const typePath = paths.createRelativePath(convertReferenceSchemaToPath(schema));
+    return ts.factory.createTypeReferenceNode(
+      imports.default.getIdentifier(typePath) ?? imports.default.add(typePath, typeName, true)
+    );
+  }
+  [$processString](_) {
+    return ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword);
+  }
+  [$processUnknown](_) {
+    return ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
+  }
+}
+class ModelSchemaIdentifierProcessor extends ModelSchemaPartProcessor {
+  [$processArray](_) {
+    return importBuiltInFormModel("ArrayModel", this[$dependencies]);
+  }
+  [$processBoolean](_) {
+    return importBuiltInFormModel("BooleanModel", this[$dependencies]);
+  }
+  [$processNumber](_) {
+    return importBuiltInFormModel("NumberModel", this[$dependencies]);
+  }
+  [$processRecord](_) {
+    return importBuiltInFormModel("ObjectModel", this[$dependencies]);
+  }
+  [$processReference](schema) {
+    const { imports, paths } = this[$dependencies];
+    const name = `${convertReferenceSchemaToSpecifier(schema)}Model`;
+    const path = paths.createRelativePath(`${convertReferenceSchemaToPath(schema)}Model`);
+    return imports.default.getIdentifier(path) ?? imports.default.add(path, name);
+  }
+  [$processString](_) {
+    return importBuiltInFormModel("StringModel", this[$dependencies]);
+  }
+  [$processUnknown](_) {
+    return importBuiltInFormModel("ObjectModel", this[$dependencies]);
+  }
+}
+class ModelSchemaTypeProcessor extends ModelSchemaPartProcessor {
+  #id;
+  constructor(schema, dependencies) {
+    super(schema, dependencies);
+    this.#id = new ModelSchemaIdentifierProcessor(schema, dependencies);
+  }
+  [$processArray](schema) {
+    return ts.factory.createTypeReferenceNode(this.#id[$processArray](schema), [
+      new ModelSchemaTypeProcessor(schema.items, this[$dependencies]).process()
+    ]);
+  }
+  [$processBoolean](schema) {
+    return ts.factory.createTypeReferenceNode(this.#id[$processBoolean](schema));
+  }
+  [$processNumber](schema) {
+    return ts.factory.createTypeReferenceNode(this.#id[$processNumber](schema));
+  }
+  [$processRecord](schema) {
+    return ts.factory.createTypeReferenceNode(this.#id[$processRecord](schema), [
+      new ModelSchemaInternalTypeProcessor(schema, this[$dependencies]).process()
+    ]);
+  }
+  [$processReference](schema) {
+    return ts.factory.createTypeReferenceNode(this.#id[$processReference](schema));
+  }
+  [$processString](schema) {
+    return ts.factory.createTypeReferenceNode(this.#id[$processString](schema));
+  }
+  [$processUnknown](schema) {
+    return ts.factory.createTypeReferenceNode(this.#id[$processUnknown](schema));
+  }
+}
+class ModelSchemaExpressionProcessor extends ModelSchemaPartProcessor {
+  #validationConstraintProcessor;
+  constructor(schema, dependencies) {
+    super(schema, dependencies);
+    this.#validationConstraintProcessor = new ValidationConstraintProcessor(
+      (name) => importBuiltInFormModel(name, dependencies)
+    );
+  }
+  process() {
+    const originalSchema = this[$originalSchema];
+    let result = super.process();
+    const modelOptionsProperties = [
+      this.#createValidatorsProperty(originalSchema),
+      ModelSchemaExpressionProcessor.#createMetadataProperty(originalSchema)
+    ].filter(Boolean);
+    if (modelOptionsProperties.length > 0) {
+      const optionsObject = ts.factory.createObjectLiteralExpression(modelOptionsProperties);
+      result = [...result, optionsObject];
+    }
+    return [isNullableSchema(originalSchema) ? ts.factory.createTrue() : ts.factory.createFalse(), ...result];
+  }
+  [$processArray](schema) {
+    const model = new ModelSchemaIdentifierProcessor(schema.items, this[$dependencies]).process();
+    return [
+      createModelBuildingCallback(
+        model,
+        new ModelSchemaExpressionProcessor(schema.items, this[$dependencies]).process()
+      )
+    ];
+  }
+  [$processBoolean](_) {
+    return [];
+  }
+  [$processNumber](_) {
+    return [];
+  }
+  [$processRecord](_) {
+    return [];
+  }
+  [$processReference](_) {
+    return [];
+  }
+  [$processString](_) {
+    return [];
+  }
+  [$processUnknown](_) {
+    return [];
+  }
+  #createValidatorsProperty(schema) {
+    if (!hasValidationConstraints(schema)) {
+      return null;
+    }
+    const constraints = schema["x-validation-constraints"].map(
+      (constraint) => this.#validationConstraintProcessor.process(constraint)
+    );
+    return ts.factory.createPropertyAssignment("validators", ts.factory.createArrayLiteralExpression(constraints));
+  }
+  static #createMetadataProperty(schema) {
+    const metadata = process(schema);
+    return metadata ? ts.factory.createPropertyAssignment("meta", metadata) : null;
+  }
+}
+export {
+  ModelSchemaExpressionProcessor,
+  ModelSchemaPartProcessor,
+  ModelSchemaTypeProcessor
+};
+//# sourceMappingURL=ModelSchemaProcessor.js.map

package/ModelSchemaProcessor.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["src/ModelSchemaProcessor.ts"],
+  "sourcesContent": ["import {\n  type ArraySchema,\n  type BooleanSchema,\n  convertReferenceSchemaToPath,\n  convertReferenceSchemaToSpecifier,\n  decomposeSchema,\n  type IntegerSchema,\n  isArraySchema,\n  isBooleanSchema,\n  isComposedSchema,\n  isIntegerSchema,\n  isMapSchema,\n  isNullableSchema,\n  isNumberSchema,\n  isReferenceSchema,\n  isStringSchema,\n  type MapSchema,\n  type NumberSchema,\n  type ReferenceSchema,\n  type Schema,\n  type StringSchema,\n} from '@vaadin/hilla-generator-core/Schema.js';\nimport type DependencyManager from '@vaadin/hilla-generator-utils/dependencies/DependencyManager.js';\nimport ts, {\n  type Expression,\n  type Identifier,\n  type PropertyAssignment,\n  type TypeNode,\n  type TypeReferenceNode,\n} from 'typescript';\nimport { process } from './MetadataProcessor.js';\nimport { createModelBuildingCallback, importBuiltInFormModel } from './utils.js';\nimport { hasValidationConstraints, ValidationConstraintProcessor } from './ValidationConstraintProcessor.js';\n\nconst $dependencies = Symbol();\nconst $processArray = Symbol();\nconst $processRecord = Symbol();\nconst $processReference = Symbol();\nconst $processString = Symbol();\nconst $processNumber = Symbol();\nconst $processBoolean = Symbol();\nconst $processUnknown = Symbol();\nconst $originalSchema = Symbol();\nconst $schema = Symbol();\n\nexport abstract class ModelSchemaPartProcessor<T> {\n  protected readonly [$dependencies]: DependencyManager;\n  protected readonly [$originalSchema]: Schema;\n  protected readonly [$schema]: Schema;\n\n  constructor(schema: Schema, dependencies: DependencyManager) {\n    this[$dependencies] = dependencies;\n    this[$originalSchema] = schema;\n    this[$schema] = isComposedSchema(schema) ? decomposeSchema(schema)[0] : schema;\n  }\n\n  process(): T {\n    const schema = this[$schema];\n\n    if (isReferenceSchema(schema)) {\n      return this[$processReference](schema);\n    }\n\n    if (isArraySchema(schema)) {\n      return this[$processArray](schema);\n    }\n\n    if (isMapSchema(schema)) {\n      return this[$processRecord](schema);\n    }\n\n    if (isStringSchema(schema)) {\n      return this[$processString](schema);\n    }\n\n    if (isNumberSchema(schema) || isIntegerSchema(schema)) {\n      return this[$processNumber](schema);\n    }\n\n    if (isBooleanSchema(schema)) {\n      return this[$processBoolean](schema);\n    }\n\n    return this[$processUnknown](schema);\n  }\n\n  protected abstract [$processArray](schema: ArraySchema): T;\n  protected abstract [$processBoolean](schema: BooleanSchema): T;\n  protected abstract [$processNumber](schema: IntegerSchema | NumberSchema): T;\n  protected abstract [$processRecord](schema: MapSchema): T;\n  protected abstract [$processReference](schema: ReferenceSchema): T;\n  protected abstract [$processString](schema: StringSchema): T;\n  protected abstract [$processUnknown](schema: Schema): T;\n}\n\nfunction handleNullableInternalType(schema: Schema, typeNode: TypeNode): TypeNode {\n  return isNullableSchema(schema)\n    ? ts.factory.createUnionTypeNode([typeNode, ts.factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword)])\n    : typeNode;\n}\n\nclass ModelSchemaInternalTypeProcessor extends ModelSchemaPartProcessor<TypeNode> {\n  protected override [$processArray](schema: ArraySchema): TypeNode {\n    return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('ReadonlyArray'), [\n      handleNullableInternalType(\n        schema.items,\n        new ModelSchemaInternalTypeProcessor(schema.items, this[$dependencies]).process(),\n      ),\n    ]);\n  }\n\n  protected override [$processBoolean](_: BooleanSchema): TypeNode {\n    return ts.factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword);\n  }\n\n  protected override [$processNumber](_: IntegerSchema | NumberSchema): TypeNode {\n    return ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);\n  }\n\n  protected override [$processRecord]({ additionalProperties: props }: MapSchema): TypeNode {\n    const valueType =\n      typeof props === 'boolean'\n        ? ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)\n        : handleNullableInternalType(props, new ModelSchemaInternalTypeProcessor(props, this[$dependencies]).process());\n\n    return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Record'), [\n      ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),\n      valueType,\n    ]);\n  }\n\n  protected override [$processReference](schema: ReferenceSchema): TypeNode {\n    const { imports, paths } = this[$dependencies];\n    const typeName = convertReferenceSchemaToSpecifier(schema);\n    const typePath = paths.createRelativePath(convertReferenceSchemaToPath(schema));\n    return ts.factory.createTypeReferenceNode(\n      imports.default.getIdentifier(typePath) ?? imports.default.add(typePath, typeName, true),\n    );\n  }\n\n  protected override [$processString](_: StringSchema): TypeNode {\n    return ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword);\n  }\n\n  protected override [$processUnknown](_: Schema): TypeNode {\n    return ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);\n  }\n}\n\nclass ModelSchemaIdentifierProcessor extends ModelSchemaPartProcessor<Identifier> {\n  override [$processArray](_: ArraySchema): Identifier {\n    return importBuiltInFormModel('ArrayModel', this[$dependencies]);\n  }\n\n  override [$processBoolean](_: BooleanSchema): Identifier {\n    return importBuiltInFormModel('BooleanModel', this[$dependencies]);\n  }\n\n  override [$processNumber](_: IntegerSchema | NumberSchema): Identifier {\n    return importBuiltInFormModel('NumberModel', this[$dependencies]);\n  }\n\n  override [$processRecord](_: MapSchema): Identifier {\n    return importBuiltInFormModel('ObjectModel', this[$dependencies]);\n  }\n\n  override [$processReference](schema: ReferenceSchema): Identifier {\n    const { imports, paths } = this[$dependencies];\n\n    const name = `${convertReferenceSchemaToSpecifier(schema)}Model`;\n    const path = paths.createRelativePath(`${convertReferenceSchemaToPath(schema)}Model`);\n\n    return imports.default.getIdentifier(path) ?? imports.default.add(path, name);\n  }\n\n  override [$processString](_: StringSchema): Identifier {\n    return importBuiltInFormModel('StringModel', this[$dependencies]);\n  }\n\n  override [$processUnknown](_: Schema): Identifier {\n    return importBuiltInFormModel('ObjectModel', this[$dependencies]);\n  }\n}\n\nexport class ModelSchemaTypeProcessor extends ModelSchemaPartProcessor<TypeReferenceNode> {\n  readonly #id: ModelSchemaIdentifierProcessor;\n\n  constructor(schema: Schema, dependencies: DependencyManager) {\n    super(schema, dependencies);\n    this.#id = new ModelSchemaIdentifierProcessor(schema, dependencies);\n  }\n\n  protected override [$processArray](schema: ArraySchema): TypeReferenceNode {\n    return ts.factory.createTypeReferenceNode(this.#id[$processArray](schema), [\n      new ModelSchemaTypeProcessor(schema.items, this[$dependencies]).process(),\n    ]);\n  }\n\n  protected override [$processBoolean](schema: BooleanSchema): TypeReferenceNode {\n    return ts.factory.createTypeReferenceNode(this.#id[$processBoolean](schema));\n  }\n\n  protected override [$processNumber](schema: IntegerSchema | NumberSchema): TypeReferenceNode {\n    return ts.factory.createTypeReferenceNode(this.#id[$processNumber](schema));\n  }\n\n  protected override [$processRecord](schema: MapSchema): TypeReferenceNode {\n    return ts.factory.createTypeReferenceNode(this.#id[$processRecord](schema), [\n      new ModelSchemaInternalTypeProcessor(schema, this[$dependencies]).process(),\n    ]);\n  }\n\n  protected override [$processReference](schema: ReferenceSchema): TypeReferenceNode {\n    return ts.factory.createTypeReferenceNode(this.#id[$processReference](schema));\n  }\n\n  protected override [$processString](schema: StringSchema): TypeReferenceNode {\n    return ts.factory.createTypeReferenceNode(this.#id[$processString](schema));\n  }\n\n  protected override [$processUnknown](schema: Schema): TypeReferenceNode {\n    return ts.factory.createTypeReferenceNode(this.#id[$processUnknown](schema));\n  }\n}\n\nexport class ModelSchemaExpressionProcessor extends ModelSchemaPartProcessor<readonly Expression[]> {\n  readonly #validationConstraintProcessor: ValidationConstraintProcessor;\n\n  constructor(schema: Schema, dependencies: DependencyManager) {\n    super(schema, dependencies);\n    this.#validationConstraintProcessor = new ValidationConstraintProcessor((name) =>\n      importBuiltInFormModel(name, dependencies),\n    );\n  }\n\n  override process(): readonly ts.Expression[] {\n    const originalSchema = this[$originalSchema];\n\n    let result = super.process();\n\n    const modelOptionsProperties = [\n      this.#createValidatorsProperty(originalSchema),\n      ModelSchemaExpressionProcessor.#createMetadataProperty(originalSchema),\n    ].filter(Boolean) as PropertyAssignment[];\n\n    if (modelOptionsProperties.length > 0) {\n      const optionsObject = ts.factory.createObjectLiteralExpression(modelOptionsProperties);\n\n      result = [...result, optionsObject];\n    }\n\n    return [isNullableSchema(originalSchema) ? ts.factory.createTrue() : ts.factory.createFalse(), ...result];\n  }\n\n  protected override [$processArray](schema: ArraySchema): readonly Expression[] {\n    const model = new ModelSchemaIdentifierProcessor(schema.items, this[$dependencies]).process();\n\n    return [\n      createModelBuildingCallback(\n        model,\n        new ModelSchemaExpressionProcessor(schema.items, this[$dependencies]).process(),\n      ),\n    ];\n  }\n\n  protected override [$processBoolean](_: BooleanSchema): readonly Expression[] {\n    return [];\n  }\n\n  protected override [$processNumber](_: IntegerSchema | NumberSchema): readonly Expression[] {\n    return [];\n  }\n\n  protected override [$processRecord](_: MapSchema): readonly Expression[] {\n    return [];\n  }\n\n  protected override [$processReference](_: ReferenceSchema): readonly Expression[] {\n    return [];\n  }\n\n  protected override [$processString](_: StringSchema): readonly Expression[] {\n    return [];\n  }\n\n  protected override [$processUnknown](_: Schema): readonly Expression[] {\n    return [];\n  }\n\n  #createValidatorsProperty(schema: Schema): PropertyAssignment | null {\n    if (!hasValidationConstraints(schema)) {\n      return null;\n    }\n\n    const constraints = schema['x-validation-constraints'].map((constraint) =>\n      this.#validationConstraintProcessor.process(constraint),\n    );\n    return ts.factory.createPropertyAssignment('validators', ts.factory.createArrayLiteralExpression(constraints));\n  }\n\n  static #createMetadataProperty(schema: Schema): PropertyAssignment | null {\n    const metadata = process(schema);\n    return metadata ? ts.factory.createPropertyAssignment('meta', metadata) : null;\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/README.md

@@ -0,0 +1 @@
+# Hilla TypeScript Generator Backbone Plugin

package/ValidationConstraintProcessor.d.ts

@@ -0,0 +1,17 @@
+import { type NonComposedRegularSchema, type Schema } from '@vaadin/hilla-generator-core/Schema.js';
+import { type Identifier, type NewExpression } from 'typescript';
+export type ValidationConstrainedSchema = NonComposedRegularSchema & Readonly<{
+    'x-validation-constraints': readonly ValidationConstraint[];
+}>;
+export declare function hasValidationConstraints(schema: Schema): schema is ValidationConstrainedSchema;
+export interface ValidationConstraint {
+    simpleName: string;
+    attributes?: Record<string, unknown>;
+}
+export type ValidationConstraintImporter = (name: string) => Identifier;
+export declare class ValidationConstraintProcessor {
+    #private;
+    constructor(importer: ValidationConstraintImporter);
+    process(constraint: ValidationConstraint): NewExpression;
+}
+//# sourceMappingURL=ValidationConstraintProcessor.d.ts.map

package/ValidationConstraintProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValidationConstraintProcessor.d.ts","sourceRoot":"","sources":["src/ValidationConstraintProcessor.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,wBAAwB,EAC7B,KAAK,MAAM,EACZ,MAAM,wCAAwC,CAAC;AAEhD,OAAW,EAET,KAAK,UAAU,EACf,KAAK,aAAa,EAGnB,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,2BAA2B,GAAG,wBAAwB,GAChE,QAAQ,CAAC;IAAE,0BAA0B,EAAE,SAAS,oBAAoB,EAAE,CAAA;CAAE,CAAC,CAAC;AAE5E,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,IAAI,2BAA2B,CAM9F;AAED,MAAM,WAAW,oBAAoB;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC;AAED,MAAM,MAAM,4BAA4B,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,UAAU,CAAC;AAQxE,qBAAa,6BAA6B;;gBAG5B,QAAQ,EAAE,4BAA4B;IAIlD,OAAO,CAAC,UAAU,EAAE,oBAAoB,GAAG,aAAa;CAoBzD"}

package/ValidationConstraintProcessor.js

@@ -0,0 +1,40 @@
+import {
+  isNonComposedRegularSchema
+} from "@vaadin/hilla-generator-core/Schema.js";
+import { template, transform } from "@vaadin/hilla-generator-utils/ast.js";
+import ts, {
+} from "typescript";
+function hasValidationConstraints(schema) {
+  return isNonComposedRegularSchema(schema) && "x-validation-constraints" in schema && schema["x-validation-constraints"].length > 0;
+}
+function selector([statement]) {
+  return statement.declarationList.declarations[0].initializer;
+}
+const variableStatementVar = "const a";
+class ValidationConstraintProcessor {
+  #importer;
+  constructor(importer) {
+    this.#importer = importer;
+  }
+  process(constraint) {
+    return ts.factory.createNewExpression(
+      this.#importer(constraint.simpleName),
+      void 0,
+      constraint.attributes ? [ValidationConstraintProcessor.#processAttributes(constraint.attributes)] : []
+    );
+  }
+  static #processAttributes(attributes) {
+    const names = Object.keys(attributes);
+    const tpl = JSON.stringify(names.includes("value") && names.length === 1 ? attributes.value : attributes);
+    return template(`${variableStatementVar}=${tpl}`, selector, [
+      transform(
+        (node) => ts.isPropertyAssignment(node) && ts.isStringLiteral(node.name) ? ts.factory.createPropertyAssignment(node.name.text, node.initializer) : node
+      )
+    ]);
+  }
+}
+export {
+  ValidationConstraintProcessor,
+  hasValidationConstraints
+};
+//# sourceMappingURL=ValidationConstraintProcessor.js.map

package/ValidationConstraintProcessor.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["src/ValidationConstraintProcessor.ts"],
+  "sourcesContent": ["import {\n  isNonComposedRegularSchema,\n  type NonComposedRegularSchema,\n  type Schema,\n} from '@vaadin/hilla-generator-core/Schema.js';\nimport { template, transform } from '@vaadin/hilla-generator-utils/ast.js';\nimport ts, {\n  type Expression,\n  type Identifier,\n  type NewExpression,\n  type Statement,\n  type VariableStatement,\n} from 'typescript';\n\nexport type ValidationConstrainedSchema = NonComposedRegularSchema &\n  Readonly<{ 'x-validation-constraints': readonly ValidationConstraint[] }>;\n\nexport function hasValidationConstraints(schema: Schema): schema is ValidationConstrainedSchema {\n  return (\n    isNonComposedRegularSchema(schema) &&\n    'x-validation-constraints' in schema &&\n    (schema as ValidationConstrainedSchema)['x-validation-constraints'].length > 0\n  );\n}\n\nexport interface ValidationConstraint {\n  simpleName: string;\n  attributes?: Record<string, unknown>;\n}\n\nexport type ValidationConstraintImporter = (name: string) => Identifier;\n\nfunction selector<T extends Expression>([statement]: readonly Statement[]): T {\n  return (statement as VariableStatement).declarationList.declarations[0].initializer as T;\n}\n\nconst variableStatementVar = 'const a';\n\nexport class ValidationConstraintProcessor {\n  readonly #importer: ValidationConstraintImporter;\n\n  constructor(importer: ValidationConstraintImporter) {\n    this.#importer = importer;\n  }\n\n  process(constraint: ValidationConstraint): NewExpression {\n    return ts.factory.createNewExpression(\n      this.#importer(constraint.simpleName),\n      undefined,\n      constraint.attributes ? [ValidationConstraintProcessor.#processAttributes(constraint.attributes)] : [],\n    );\n  }\n\n  static #processAttributes(attributes: Record<string, unknown>): Expression {\n    const names = Object.keys(attributes);\n    const tpl = JSON.stringify(names.includes('value') && names.length === 1 ? attributes.value : attributes);\n\n    return template(`${variableStatementVar}=${tpl}`, selector, [\n      transform((node) =>\n        ts.isPropertyAssignment(node) && ts.isStringLiteral(node.name)\n          ? ts.factory.createPropertyAssignment(node.name.text, node.initializer)\n          : node,\n      ),\n    ]);\n  }\n}\n"],
+  "mappings": "AAAA;AAAA,EACE;AAAA,OAGK;AACP,SAAS,UAAU,iBAAiB;AACpC,OAAO;AAAA,OAMA;AAKA,SAAS,yBAAyB,QAAuD;AAC9F,SACE,2BAA2B,MAAM,KACjC,8BAA8B,UAC7B,OAAuC,0BAA0B,EAAE,SAAS;AAEjF;AASA,SAAS,SAA+B,CAAC,SAAS,GAA4B;AAC5E,SAAQ,UAAgC,gBAAgB,aAAa,CAAC,EAAE;AAC1E;AAEA,MAAM,uBAAuB;AAEtB,MAAM,8BAA8B;AAAA,EAChC;AAAA,EAET,YAAY,UAAwC;AAClD,SAAK,YAAY;AAAA,EACnB;AAAA,EAEA,QAAQ,YAAiD;AACvD,WAAO,GAAG,QAAQ;AAAA,MAChB,KAAK,UAAU,WAAW,UAAU;AAAA,MACpC;AAAA,MACA,WAAW,aAAa,CAAC,8BAA8B,mBAAmB,WAAW,UAAU,CAAC,IAAI,CAAC;AAAA,IACvG;AAAA,EACF;AAAA,EAEA,OAAO,mBAAmB,YAAiD;AACzE,UAAM,QAAQ,OAAO,KAAK,UAAU;AACpC,UAAM,MAAM,KAAK,UAAU,MAAM,SAAS,OAAO,KAAK,MAAM,WAAW,IAAI,WAAW,QAAQ,UAAU;AAExG,WAAO,SAAS,GAAG,oBAAoB,IAAI,GAAG,IAAI,UAAU;AAAA,MAC1D;AAAA,QAAU,CAAC,SACT,GAAG,qBAAqB,IAAI,KAAK,GAAG,gBAAgB,KAAK,IAAI,IACzD,GAAG,QAAQ,yBAAyB,KAAK,KAAK,MAAM,KAAK,WAAW,IACpE;AAAA,MACN;AAAA,IACF,CAAC;AAAA,EACH;AACF;",
+  "names": []
+}

package/index.d.ts

@@ -0,0 +1,13 @@
+import Plugin from '@vaadin/hilla-generator-core/Plugin.js';
+import type SharedStorage from '@vaadin/hilla-generator-core/SharedStorage.js';
+export declare enum ModelPluginSourceType {
+    Model = "model"
+}
+export default class ModelPlugin extends Plugin {
+    #private;
+    static readonly MODEL_PLUGIN_FILE_TAGS = "MODEL_PLUGIN_FILE_TAGS";
+    ['constructor']: typeof ModelPlugin;
+    get path(): string;
+    execute(storage: SharedStorage): Promise<void>;
+}
+//# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["src/index.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,wCAAwC,CAAC;AAC5D,OAAO,KAAK,aAAa,MAAM,+CAA+C,CAAC;AAO/E,oBAAY,qBAAqB;IAC/B,KAAK,UAAU;CAChB;AAED,MAAM,CAAC,OAAO,OAAO,WAAY,SAAQ,MAAM;;IAC7C,MAAM,CAAC,QAAQ,CAAC,sBAAsB,4BAA4B;IAC1D,CAAC,aAAa,CAAC,EAAE,OAAO,WAAW,CAAC;IAG5C,IAAa,IAAI,IAAI,MAAM,CAE1B;IAGc,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;CAoB9D"}

package/index.js

@@ -0,0 +1,35 @@
+import Plugin from "@vaadin/hilla-generator-core/Plugin.js";
+import { EntityModelProcessor } from "./EntityModelProcessor.js";
+var ModelPluginSourceType = /* @__PURE__ */ ((ModelPluginSourceType2) => {
+  ModelPluginSourceType2["Model"] = "model";
+  return ModelPluginSourceType2;
+})(ModelPluginSourceType || {});
+class ModelPlugin extends Plugin {
+  static MODEL_PLUGIN_FILE_TAGS = "MODEL_PLUGIN_FILE_TAGS";
+  #tags = /* @__PURE__ */ new WeakMap();
+  get path() {
+    return import.meta.url;
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async execute(storage) {
+    const files = this.#processEntities(storage.api.components?.schemas);
+    files.forEach((file) => this.#tags.set(file, "model" /* Model */));
+    storage.sources.push(...files);
+    storage.pluginStorage.set(this.constructor.MODEL_PLUGIN_FILE_TAGS, this.#tags);
+  }
+  #processEntities(schemas) {
+    this.logger.debug("Processing entities");
+    if (!schemas) {
+      return [];
+    }
+    const ctx = {
+      owner: this
+    };
+    return Object.entries(schemas).map(([name, component]) => EntityModelProcessor.process(name, component, ctx));
+  }
+}
+export {
+  ModelPluginSourceType,
+  ModelPlugin as default
+};
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["src/index.ts"],
+  "sourcesContent": ["import Plugin from '@vaadin/hilla-generator-core/Plugin.js';\nimport type SharedStorage from '@vaadin/hilla-generator-core/SharedStorage.js';\nimport type { OpenAPIV3 } from 'openapi-types';\nimport type { ReadonlyDeep } from 'type-fest';\nimport type { SourceFile } from 'typescript';\nimport { EntityModelProcessor } from './EntityModelProcessor.js';\nimport type { Context } from './utils.js';\n\nexport enum ModelPluginSourceType {\n  Model = 'model',\n}\n\nexport default class ModelPlugin extends Plugin {\n  static readonly MODEL_PLUGIN_FILE_TAGS = 'MODEL_PLUGIN_FILE_TAGS';\n  declare ['constructor']: typeof ModelPlugin;\n  readonly #tags = new WeakMap<SourceFile, ModelPluginSourceType>();\n\n  override get path(): string {\n    return import.meta.url;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/require-await\n  override async execute(storage: SharedStorage): Promise<void> {\n    const files = this.#processEntities(storage.api.components?.schemas);\n    files.forEach((file) => this.#tags.set(file, ModelPluginSourceType.Model));\n    storage.sources.push(...files);\n    storage.pluginStorage.set(this.constructor.MODEL_PLUGIN_FILE_TAGS, this.#tags);\n  }\n\n  #processEntities(schemas: ReadonlyDeep<OpenAPIV3.ComponentsObject>['schemas'] | undefined): readonly SourceFile[] {\n    this.logger.debug('Processing entities');\n\n    if (!schemas) {\n      return [];\n    }\n\n    const ctx: Context = {\n      owner: this,\n    };\n\n    return Object.entries(schemas).map(([name, component]) => EntityModelProcessor.process(name, component, ctx));\n  }\n}\n"],
+  "mappings": "AAAA,OAAO,YAAY;AAKnB,SAAS,4BAA4B;AAG9B,IAAK,wBAAL,kBAAKA,2BAAL;AACL,EAAAA,uBAAA,WAAQ;AADE,SAAAA;AAAA,GAAA;AAIZ,MAAO,oBAAkC,OAAO;AAAA,EAC9C,OAAgB,yBAAyB;AAAA,EAEhC,QAAQ,oBAAI,QAA2C;AAAA,EAEhE,IAAa,OAAe;AAC1B,WAAO,YAAY;AAAA,EACrB;AAAA;AAAA,EAGA,MAAe,QAAQ,SAAuC;AAC5D,UAAM,QAAQ,KAAK,iBAAiB,QAAQ,IAAI,YAAY,OAAO;AACnE,UAAM,QAAQ,CAAC,SAAS,KAAK,MAAM,IAAI,MAAM,mBAA2B,CAAC;AACzE,YAAQ,QAAQ,KAAK,GAAG,KAAK;AAC7B,YAAQ,cAAc,IAAI,KAAK,YAAY,wBAAwB,KAAK,KAAK;AAAA,EAC/E;AAAA,EAEA,iBAAiB,SAAiG;AAChH,SAAK,OAAO,MAAM,qBAAqB;AAEvC,QAAI,CAAC,SAAS;AACZ,aAAO,CAAC;AAAA,IACV;AAEA,UAAM,MAAe;AAAA,MACnB,OAAO;AAAA,IACT;AAEA,WAAO,OAAO,QAAQ,OAAO,EAAE,IAAI,CAAC,CAAC,MAAM,SAAS,MAAM,qBAAqB,QAAQ,MAAM,WAAW,GAAG,CAAC;AAAA,EAC9G;AACF;",
+  "names": ["ModelPluginSourceType"]
+}

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "@vaadin/hilla-generator-plugin-model",
+  "version": "24.4.0-alpha1",
+  "description": "A Hilla TypeScript Generator plugin to generate form models",
+  "main": "index.js",
+  "type": "module",
+  "engines": {
+    "node": ">= 16.13"
+  },
+  "scripts": {
+    "clean:build": "git clean -fx . -e .vite -e node_modules",
+    "build": "concurrently npm:build:*",
+    "build:esbuild": "tsx ../../../scripts/build.ts",
+    "build:dts": "tsc --isolatedModules -p tsconfig.build.json",
+    "build:copy": "cd src && copyfiles **/*.d.ts ..",
+    "lint": "eslint src test",
+    "lint:fix": "eslint src test --fix",
+    "test": "mocha test/**/*.spec.ts --config ../../../.mocharc.cjs",
+    "test:update": "npm run test -- --update",
+    "test:coverage": "c8 -c ../../../.c8rc.json npm test",
+    "typecheck": "tsc --noEmit"
+  },
+  "exports": {
+    ".": {
+      "default": "./index.js"
+    },
+    "./index.js": {
+      "default": "./index.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vaadin/hilla.git",
+    "directory": "packages/ts/generator-plugin-model"
+  },
+  "keywords": [
+    "hilla",
+    "typescript",
+    "generator"
+  ],
+  "author": "Vaadin Ltd.",
+  "license": "Apache 2.0",
+  "bugs": {
+    "url": "https://github.com/vaadin/hilla/issues"
+  },
+  "homepage": "https://hilla.dev",
+  "files": [
+    "*.{d.ts.map,d.ts,js.map,js}"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@vaadin/hilla-lit-form": "24.4.0-alpha1",
+    "@vaadin/hilla-generator-core": "24.4.0-alpha1",
+    "@vaadin/hilla-generator-plugin-backbone": "24.4.0-alpha1"
+  },
+  "dependencies": {
+    "@vaadin/hilla-generator-utils": "24.4.0-alpha1",
+    "fast-deep-equal": "^3.1.3",
+    "openapi-types": "^12.1.3",
+    "typescript": "5.3.2"
+  },
+  "devDependencies": {
+    "@vaadin/hilla-generator-core": "24.4.0-alpha1",
+    "@vaadin/hilla-generator-plugin-client": "24.4.0-alpha1",
+    "@types/chai": "^4.3.6",
+    "@types/mocha": "^10.0.2",
+    "@types/node": "^20.7.1",
+    "@types/sinon": "^10.0.17",
+    "@types/sinon-chai": "^3.2.10",
+    "c8": "^8.0.1",
+    "chai": "^4.3.10",
+    "concurrently": "^8.2.1",
+    "copyfiles": "^2.4.1",
+    "mocha": "^10.2.0",
+    "pino": "^8.15.1",
+    "rimraf": "^5.0.5",
+    "sinon": "^16.0.0",
+    "sinon-chai": "^3.7.0",
+    "type-fest": "^4.3.2"
+  }
+}

package/utils.d.ts

@@ -0,0 +1,11 @@
+import type Plugin from '@vaadin/hilla-generator-core/Plugin.js';
+import type DependencyManager from '@vaadin/hilla-generator-utils/dependencies/DependencyManager.js';
+import { type ArrowFunction, type Expression, type Identifier, type PropertyDeclaration } from 'typescript';
+export type Context = Readonly<{
+    owner: Plugin;
+}>;
+export declare const defaultMediaType = "application/json";
+export declare function importBuiltInFormModel(specifier: string, { imports, paths }: DependencyManager): Identifier;
+export declare function createModelBuildingCallback(name: Identifier, args: readonly Expression[]): ArrowFunction;
+export declare function createEmptyValueMaker(maker: Identifier, model: Identifier): PropertyDeclaration;
+//# sourceMappingURL=utils.d.ts.map

package/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,wCAAwC,CAAC;AACjE,OAAO,KAAK,iBAAiB,MAAM,iEAAiE,CAAC;AACrG,OAAW,EAAE,KAAK,aAAa,EAAE,KAAK,UAAU,EAAE,KAAK,UAAU,EAAE,KAAK,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEhH,MAAM,MAAM,OAAO,GAAG,QAAQ,CAAC;IAC7B,KAAK,EAAE,MAAM,CAAC;CACf,CAAC,CAAC;AAEH,eAAO,MAAM,gBAAgB,qBAAqB,CAAC;AAEnD,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,iBAAiB,GAAG,UAAU,CAG3G;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,UAAU,EAAE,GAAG,aAAa,CAWxG;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,GAAG,mBAAmB,CAQ/F"}

package/utils.js

@@ -0,0 +1,33 @@
+import ts, {} from "typescript";
+const defaultMediaType = "application/json";
+function importBuiltInFormModel(specifier, { imports, paths }) {
+  const modelPath = paths.createBareModulePath("@vaadin/hilla-lit-form", false);
+  return imports.named.getIdentifier(modelPath, specifier) ?? imports.named.add(modelPath, specifier);
+}
+function createModelBuildingCallback(name, args) {
+  const defaults = [ts.factory.createIdentifier("parent"), ts.factory.createIdentifier("key")];
+  return ts.factory.createArrowFunction(
+    void 0,
+    void 0,
+    defaults.map((arg) => ts.factory.createParameterDeclaration(void 0, void 0, arg)),
+    void 0,
+    ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
+    ts.factory.createNewExpression(name, void 0, [...defaults, ...args])
+  );
+}
+function createEmptyValueMaker(maker, model) {
+  return ts.factory.createPropertyDeclaration(
+    [ts.factory.createModifier(ts.SyntaxKind.StaticKeyword), ts.factory.createModifier(ts.SyntaxKind.OverrideKeyword)],
+    "createEmptyValue",
+    void 0,
+    void 0,
+    ts.factory.createCallExpression(maker, void 0, [model])
+  );
+}
+export {
+  createEmptyValueMaker,
+  createModelBuildingCallback,
+  defaultMediaType,
+  importBuiltInFormModel
+};
+//# sourceMappingURL=utils.js.map

package/utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["src/utils.ts"],
+  "sourcesContent": ["import type Plugin from '@vaadin/hilla-generator-core/Plugin.js';\nimport type DependencyManager from '@vaadin/hilla-generator-utils/dependencies/DependencyManager.js';\nimport ts, { type ArrowFunction, type Expression, type Identifier, type PropertyDeclaration } from 'typescript';\n\nexport type Context = Readonly<{\n  owner: Plugin;\n}>;\n\nexport const defaultMediaType = 'application/json';\n\nexport function importBuiltInFormModel(specifier: string, { imports, paths }: DependencyManager): Identifier {\n  const modelPath = paths.createBareModulePath('@vaadin/hilla-lit-form', false);\n  return imports.named.getIdentifier(modelPath, specifier) ?? imports.named.add(modelPath, specifier);\n}\n\nexport function createModelBuildingCallback(name: Identifier, args: readonly Expression[]): ArrowFunction {\n  const defaults = [ts.factory.createIdentifier('parent'), ts.factory.createIdentifier('key')];\n\n  return ts.factory.createArrowFunction(\n    undefined,\n    undefined,\n    defaults.map((arg) => ts.factory.createParameterDeclaration(undefined, undefined, arg)),\n    undefined,\n    ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),\n    ts.factory.createNewExpression(name, undefined, [...defaults, ...args]),\n  );\n}\n\nexport function createEmptyValueMaker(maker: Identifier, model: Identifier): PropertyDeclaration {\n  return ts.factory.createPropertyDeclaration(\n    [ts.factory.createModifier(ts.SyntaxKind.StaticKeyword), ts.factory.createModifier(ts.SyntaxKind.OverrideKeyword)],\n    'createEmptyValue',\n    undefined,\n    undefined,\n    ts.factory.createCallExpression(maker, undefined, [model]),\n  );\n}\n"],
+  "mappings": "AAEA,OAAO,YAA4F;AAM5F,MAAM,mBAAmB;AAEzB,SAAS,uBAAuB,WAAmB,EAAE,SAAS,MAAM,GAAkC;AAC3G,QAAM,YAAY,MAAM,qBAAqB,0BAA0B,KAAK;AAC5E,SAAO,QAAQ,MAAM,cAAc,WAAW,SAAS,KAAK,QAAQ,MAAM,IAAI,WAAW,SAAS;AACpG;AAEO,SAAS,4BAA4B,MAAkB,MAA4C;AACxG,QAAM,WAAW,CAAC,GAAG,QAAQ,iBAAiB,QAAQ,GAAG,GAAG,QAAQ,iBAAiB,KAAK,CAAC;AAE3F,SAAO,GAAG,QAAQ;AAAA,IAChB;AAAA,IACA;AAAA,IACA,SAAS,IAAI,CAAC,QAAQ,GAAG,QAAQ,2BAA2B,QAAW,QAAW,GAAG,CAAC;AAAA,IACtF;AAAA,IACA,GAAG,QAAQ,YAAY,GAAG,WAAW,sBAAsB;AAAA,IAC3D,GAAG,QAAQ,oBAAoB,MAAM,QAAW,CAAC,GAAG,UAAU,GAAG,IAAI,CAAC;AAAA,EACxE;AACF;AAEO,SAAS,sBAAsB,OAAmB,OAAwC;AAC/F,SAAO,GAAG,QAAQ;AAAA,IAChB,CAAC,GAAG,QAAQ,eAAe,GAAG,WAAW,aAAa,GAAG,GAAG,QAAQ,eAAe,GAAG,WAAW,eAAe,CAAC;AAAA,IACjH;AAAA,IACA;AAAA,IACA;AAAA,IACA,GAAG,QAAQ,qBAAqB,OAAO,QAAW,CAAC,KAAK,CAAC;AAAA,EAC3D;AACF;",
+  "names": []
+}