@vaadin/hilla-generator-plugin-backbone 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/EndpointMethodOperationProcessor.d.ts

@@ -0,0 +1,13 @@
+import type Plugin from '@vaadin/hilla-generator-core/Plugin.js';
+import type DependencyManager from '@vaadin/hilla-generator-utils/dependencies/DependencyManager.js';
+import { OpenAPIV3 } from 'openapi-types';
+import type { ReadonlyDeep } from 'type-fest';
+import { type Statement } from 'typescript';
+export type EndpointMethodOperation = ReadonlyDeep<OpenAPIV3.OperationObject>;
+export declare const INIT_TYPE_NAME = "EndpointRequestInit";
+export declare const HILLA_FRONTEND_NAME = "@vaadin/hilla-core";
+export default abstract class EndpointMethodOperationProcessor {
+    static createProcessor(httpMethod: OpenAPIV3.HttpMethods, endpointName: string, endpointMethodName: string, operation: EndpointMethodOperation, dependencies: DependencyManager, owner: Plugin): EndpointMethodOperationProcessor | undefined;
+    abstract process(outputDir?: string): Promise<Statement | undefined>;
+}
+//# sourceMappingURL=EndpointMethodOperationProcessor.d.ts.map

package/EndpointMethodOperationProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EndpointMethodOperationProcessor.d.ts","sourceRoot":"","sources":["src/EndpointMethodOperationProcessor.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,wCAAwC,CAAC;AAEjE,OAAO,KAAK,iBAAiB,MAAM,iEAAiE,CAAC;AAErG,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAW,EAAmB,KAAK,SAAS,EAAiB,MAAM,YAAY,CAAC;AAIhF,MAAM,MAAM,uBAAuB,GAAG,YAAY,CAAC,SAAS,CAAC,eAAe,CAAC,CAAC;AAE9E,eAAO,MAAM,cAAc,wBAAwB,CAAC;AACpD,eAAO,MAAM,mBAAmB,uBAAuB,CAAC;AAExD,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,gCAAgC;IAC5D,MAAM,CAAC,eAAe,CACpB,UAAU,EAAE,SAAS,CAAC,WAAW,EACjC,YAAY,EAAE,MAAM,EACpB,kBAAkB,EAAE,MAAM,EAC1B,SAAS,EAAE,uBAAuB,EAClC,YAAY,EAAE,iBAAiB,EAC/B,KAAK,EAAE,MAAM,GACZ,gCAAgC,GAAG,SAAS;IAiB/C,QAAQ,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;CACrE"}

package/EndpointMethodOperationProcessor.js

@@ -0,0 +1,94 @@
+import ClientPlugin from "@vaadin/hilla-generator-plugin-client";
+import equal from "fast-deep-equal";
+import { OpenAPIV3 } from "openapi-types";
+import ts, {} from "typescript";
+import EndpointMethodRequestBodyProcessor from "./EndpointMethodRequestBodyProcessor.js";
+import EndpointMethodResponseProcessor from "./EndpointMethodResponseProcessor.js";
+const INIT_TYPE_NAME = "EndpointRequestInit";
+const HILLA_FRONTEND_NAME = "@vaadin/hilla-core";
+class EndpointMethodOperationProcessor {
+  static createProcessor(httpMethod, endpointName, endpointMethodName, operation, dependencies, owner) {
+    switch (httpMethod) {
+      case OpenAPIV3.HttpMethods.POST:
+        return new EndpointMethodOperationPOSTProcessor(
+          endpointName,
+          endpointMethodName,
+          operation,
+          dependencies,
+          owner
+        );
+      default:
+        owner.logger.warn(`Processing ${httpMethod.toUpperCase()} currently is not supported`);
+        return void 0;
+    }
+  }
+}
+class EndpointMethodOperationPOSTProcessor extends EndpointMethodOperationProcessor {
+  #dependencies;
+  #endpointMethodName;
+  #endpointName;
+  #operation;
+  #owner;
+  constructor(endpointName, endpointMethodName, operation, dependencies, owner) {
+    super();
+    this.#owner = owner;
+    this.#dependencies = dependencies;
+    this.#endpointName = endpointName;
+    this.#endpointMethodName = endpointMethodName;
+    this.#operation = operation;
+  }
+  async process(outputDir) {
+    const { exports, imports, paths } = this.#dependencies;
+    this.#owner.logger.debug(`${this.#endpointName}.${this.#endpointMethodName} - processing POST method`);
+    const initTypeIdentifier = imports.named.getIdentifier(
+      paths.createBareModulePath(HILLA_FRONTEND_NAME),
+      INIT_TYPE_NAME
+    );
+    const { initParam, packedParameters, parameters } = new EndpointMethodRequestBodyProcessor(
+      this.#operation.requestBody,
+      this.#dependencies,
+      this.#owner,
+      initTypeIdentifier
+    ).process();
+    const methodIdentifier = exports.named.add(this.#endpointMethodName);
+    const clientLibIdentifier = imports.default.getIdentifier(
+      paths.createRelativePath(await ClientPlugin.getClientFileName(outputDir))
+    );
+    const callExpression = ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(clientLibIdentifier, ts.factory.createIdentifier("call")),
+      void 0,
+      [
+        ts.factory.createStringLiteral(this.#endpointName),
+        ts.factory.createStringLiteral(this.#endpointMethodName),
+        packedParameters,
+        initParam
+      ].filter(Boolean)
+    );
+    const responseType = this.#prepareResponseType();
+    return ts.factory.createFunctionDeclaration(
+      [ts.factory.createToken(ts.SyntaxKind.AsyncKeyword)],
+      void 0,
+      methodIdentifier,
+      void 0,
+      parameters,
+      ts.factory.createTypeReferenceNode("Promise", [responseType]),
+      ts.factory.createBlock([ts.factory.createReturnStatement(callExpression)])
+    );
+  }
+  #prepareResponseType() {
+    this.#owner.logger.debug(`${this.#endpointName}.${this.#endpointMethodName} POST - processing response type`);
+    const responseTypes = Object.entries(this.#operation.responses).flatMap(
+      ([code, response]) => new EndpointMethodResponseProcessor(code, response, this.#dependencies, this.#owner).process()
+    ).filter((value, index, arr) => arr.findIndex((v) => equal(v, value)) === index);
+    if (responseTypes.length === 0) {
+      return ts.factory.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword);
+    }
+    return ts.factory.createUnionTypeNode(responseTypes);
+  }
+}
+export {
+  HILLA_FRONTEND_NAME,
+  INIT_TYPE_NAME,
+  EndpointMethodOperationProcessor as default
+};
+//# sourceMappingURL=EndpointMethodOperationProcessor.js.map

package/EndpointMethodOperationProcessor.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["src/EndpointMethodOperationProcessor.ts"],
+  "sourcesContent": ["/* eslint-disable max-params */\nimport type Plugin from '@vaadin/hilla-generator-core/Plugin.js';\nimport ClientPlugin from '@vaadin/hilla-generator-plugin-client';\nimport type DependencyManager from '@vaadin/hilla-generator-utils/dependencies/DependencyManager.js';\nimport equal from 'fast-deep-equal';\nimport { OpenAPIV3 } from 'openapi-types';\nimport type { ReadonlyDeep } from 'type-fest';\nimport ts, { type Expression, type Statement, type TypeNode } from 'typescript';\nimport EndpointMethodRequestBodyProcessor from './EndpointMethodRequestBodyProcessor.js';\nimport EndpointMethodResponseProcessor from './EndpointMethodResponseProcessor.js';\n\nexport type EndpointMethodOperation = ReadonlyDeep<OpenAPIV3.OperationObject>;\n\nexport const INIT_TYPE_NAME = 'EndpointRequestInit';\nexport const HILLA_FRONTEND_NAME = '@vaadin/hilla-core';\n\nexport default abstract class EndpointMethodOperationProcessor {\n  static createProcessor(\n    httpMethod: OpenAPIV3.HttpMethods,\n    endpointName: string,\n    endpointMethodName: string,\n    operation: EndpointMethodOperation,\n    dependencies: DependencyManager,\n    owner: Plugin,\n  ): EndpointMethodOperationProcessor | undefined {\n    switch (httpMethod) {\n      case OpenAPIV3.HttpMethods.POST:\n        // eslint-disable-next-line @typescript-eslint/no-use-before-define\n        return new EndpointMethodOperationPOSTProcessor(\n          endpointName,\n          endpointMethodName,\n          operation,\n          dependencies,\n          owner,\n        );\n      default:\n        owner.logger.warn(`Processing ${httpMethod.toUpperCase()} currently is not supported`);\n        return undefined;\n    }\n  }\n\n  abstract process(outputDir?: string): Promise<Statement | undefined>;\n}\n\nclass EndpointMethodOperationPOSTProcessor extends EndpointMethodOperationProcessor {\n  readonly #dependencies: DependencyManager;\n  readonly #endpointMethodName: string;\n  readonly #endpointName: string;\n  readonly #operation: EndpointMethodOperation;\n  readonly #owner: Plugin;\n\n  constructor(\n    endpointName: string,\n    endpointMethodName: string,\n    operation: EndpointMethodOperation,\n    dependencies: DependencyManager,\n    owner: Plugin,\n  ) {\n    super();\n    this.#owner = owner;\n    this.#dependencies = dependencies;\n    this.#endpointName = endpointName;\n    this.#endpointMethodName = endpointMethodName;\n    this.#operation = operation;\n  }\n\n  async process(outputDir?: string): Promise<Statement | undefined> {\n    const { exports, imports, paths } = this.#dependencies;\n    this.#owner.logger.debug(`${this.#endpointName}.${this.#endpointMethodName} - processing POST method`);\n    const initTypeIdentifier = imports.named.getIdentifier(\n      paths.createBareModulePath(HILLA_FRONTEND_NAME),\n      INIT_TYPE_NAME,\n    )!;\n\n    const { initParam, packedParameters, parameters } = new EndpointMethodRequestBodyProcessor(\n      this.#operation.requestBody,\n      this.#dependencies,\n      this.#owner,\n      initTypeIdentifier,\n    ).process();\n\n    const methodIdentifier = exports.named.add(this.#endpointMethodName);\n    const clientLibIdentifier = imports.default.getIdentifier(\n      paths.createRelativePath(await ClientPlugin.getClientFileName(outputDir)),\n    )!;\n\n    const callExpression = ts.factory.createCallExpression(\n      ts.factory.createPropertyAccessExpression(clientLibIdentifier, ts.factory.createIdentifier('call')),\n      undefined,\n      [\n        ts.factory.createStringLiteral(this.#endpointName),\n        ts.factory.createStringLiteral(this.#endpointMethodName),\n        packedParameters,\n        initParam,\n      ].filter(Boolean) as readonly Expression[],\n    );\n\n    const responseType = this.#prepareResponseType();\n\n    return ts.factory.createFunctionDeclaration(\n      [ts.factory.createToken(ts.SyntaxKind.AsyncKeyword)],\n      undefined,\n      methodIdentifier,\n      undefined,\n      parameters,\n      ts.factory.createTypeReferenceNode('Promise', [responseType]),\n      ts.factory.createBlock([ts.factory.createReturnStatement(callExpression)]),\n    );\n  }\n\n  #prepareResponseType(): TypeNode {\n    this.#owner.logger.debug(`${this.#endpointName}.${this.#endpointMethodName} POST - processing response type`);\n\n    const responseTypes = Object.entries(this.#operation.responses)\n      .flatMap(([code, response]) =>\n        new EndpointMethodResponseProcessor(code, response, this.#dependencies, this.#owner).process(),\n      )\n      .filter((value, index, arr) => arr.findIndex((v) => equal(v, value)) === index);\n\n    if (responseTypes.length === 0) {\n      return ts.factory.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword);\n    }\n\n    return ts.factory.createUnionTypeNode(responseTypes);\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/EndpointMethodRequestBodyProcessor.d.ts

@@ -0,0 +1,17 @@
+import type Plugin from '@vaadin/hilla-generator-core/Plugin.js';
+import type DependencyManager from '@vaadin/hilla-generator-utils/dependencies/DependencyManager.js';
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ReadonlyDeep } from 'type-fest';
+import ts, { type ObjectLiteralExpression, type ParameterDeclaration } from 'typescript';
+export type EndpointMethodRequestBody = ReadonlyDeep<OpenAPIV3.RequestBodyObject>;
+export type EndpointMethodRequestBodyProcessingResult = Readonly<{
+    parameters: readonly ParameterDeclaration[];
+    packedParameters?: ObjectLiteralExpression;
+    initParam: ts.Identifier;
+}>;
+export default class EndpointMethodRequestBodyProcessor {
+    #private;
+    constructor(requestBody: ReadonlyDeep<OpenAPIV3.ReferenceObject | OpenAPIV3.RequestBodyObject> | undefined, dependencies: DependencyManager, owner: Plugin, initTypeIdentifier: ts.Identifier);
+    process(): EndpointMethodRequestBodyProcessingResult;
+}
+//# sourceMappingURL=EndpointMethodRequestBodyProcessor.d.ts.map

package/EndpointMethodRequestBodyProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EndpointMethodRequestBodyProcessor.d.ts","sourceRoot":"","sources":["src/EndpointMethodRequestBodyProcessor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,wCAAwC,CAAC;AAOjE,OAAO,KAAK,iBAAiB,MAAM,iEAAiE,CAAC;AACrG,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,EAAE,EAAE,EAAE,KAAK,uBAAuB,EAAE,KAAK,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAIzF,MAAM,MAAM,yBAAyB,GAAG,YAAY,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC;AAElF,MAAM,MAAM,yCAAyC,GAAG,QAAQ,CAAC;IAC/D,UAAU,EAAE,SAAS,oBAAoB,EAAE,CAAC;IAC5C,gBAAgB,CAAC,EAAE,uBAAuB,CAAC;IAC3C,SAAS,EAAE,EAAE,CAAC,UAAU,CAAC;CAC1B,CAAC,CAAC;AAEH,MAAM,CAAC,OAAO,OAAO,kCAAkC;;gBASnD,WAAW,EAAE,YAAY,CAAC,SAAS,CAAC,eAAe,GAAG,SAAS,CAAC,iBAAiB,CAAC,GAAG,SAAS,EAC9F,YAAY,EAAE,iBAAiB,EAC/B,KAAK,EAAE,MAAM,EACb,kBAAkB,EAAE,EAAE,CAAC,UAAU;IAQnC,OAAO,IAAI,yCAAyC;CAuErD"}

package/EndpointMethodRequestBodyProcessor.js

@@ -0,0 +1,84 @@
+import {
+  isEmptyObject,
+  isObjectSchema
+} from "@vaadin/hilla-generator-core/Schema.js";
+import ts, {} from "typescript";
+import TypeSchemaProcessor from "./TypeSchemaProcessor.js";
+import { defaultMediaType } from "./utils.js";
+class EndpointMethodRequestBodyProcessor {
+  static #defaultInitParamName = "init";
+  #dependencies;
+  #owner;
+  #requestBody;
+  #initTypeIdentifier;
+  constructor(requestBody, dependencies, owner, initTypeIdentifier) {
+    this.#owner = owner;
+    this.#dependencies = dependencies;
+    this.#requestBody = requestBody ? owner.resolver.resolve(requestBody) : void 0;
+    this.#initTypeIdentifier = initTypeIdentifier;
+  }
+  process() {
+    if (!this.#requestBody) {
+      return {
+        initParam: ts.factory.createIdentifier(EndpointMethodRequestBodyProcessor.#defaultInitParamName),
+        packedParameters: ts.factory.createObjectLiteralExpression(),
+        parameters: [
+          ts.factory.createParameterDeclaration(
+            void 0,
+            void 0,
+            EndpointMethodRequestBodyProcessor.#defaultInitParamName,
+            ts.factory.createToken(ts.SyntaxKind.QuestionToken),
+            ts.factory.createTypeReferenceNode(this.#initTypeIdentifier)
+          )
+        ]
+      };
+    }
+    const parameterData = this.#extractParameterData(this.#requestBody.content[defaultMediaType].schema);
+    const parameterNames = parameterData.map(([name]) => name);
+    let initParamName = EndpointMethodRequestBodyProcessor.#defaultInitParamName;
+    while (parameterNames.includes(initParamName)) {
+      initParamName = `_${initParamName}`;
+    }
+    return {
+      initParam: ts.factory.createIdentifier(initParamName),
+      packedParameters: ts.factory.createObjectLiteralExpression(
+        parameterData.map(([name]) => ts.factory.createShorthandPropertyAssignment(name))
+      ),
+      parameters: [
+        ...parameterData.map(([name, schema]) => {
+          const nodes = new TypeSchemaProcessor(schema, this.#dependencies).process();
+          return ts.factory.createParameterDeclaration(
+            void 0,
+            void 0,
+            name,
+            void 0,
+            ts.factory.createUnionTypeNode(nodes)
+          );
+        }),
+        ts.factory.createParameterDeclaration(
+          void 0,
+          void 0,
+          initParamName,
+          ts.factory.createToken(ts.SyntaxKind.QuestionToken),
+          ts.factory.createTypeReferenceNode(this.#initTypeIdentifier)
+        )
+      ]
+    };
+  }
+  #extractParameterData(basicSchema) {
+    if (!basicSchema) {
+      return [];
+    }
+    const { logger, resolver } = this.#owner;
+    const resolvedSchema = resolver.resolve(basicSchema);
+    if (isObjectSchema(resolvedSchema) && !isEmptyObject(resolvedSchema)) {
+      return Object.entries(resolvedSchema.properties);
+    }
+    logger.warn("A schema provided for endpoint method's 'requestBody' is not supported");
+    return [];
+  }
+}
+export {
+  EndpointMethodRequestBodyProcessor as default
+};
+//# sourceMappingURL=EndpointMethodRequestBodyProcessor.js.map

package/EndpointMethodRequestBodyProcessor.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["src/EndpointMethodRequestBodyProcessor.ts"],
+  "sourcesContent": ["import type Plugin from '@vaadin/hilla-generator-core/Plugin.js';\nimport {\n  isEmptyObject,\n  isObjectSchema,\n  type NonEmptyObjectSchema,\n  type Schema,\n} from '@vaadin/hilla-generator-core/Schema.js';\nimport type DependencyManager from '@vaadin/hilla-generator-utils/dependencies/DependencyManager.js';\nimport type { OpenAPIV3 } from 'openapi-types';\nimport type { ReadonlyDeep } from 'type-fest';\nimport ts, { type ObjectLiteralExpression, type ParameterDeclaration } from 'typescript';\nimport TypeSchemaProcessor from './TypeSchemaProcessor.js';\nimport { defaultMediaType } from './utils.js';\n\nexport type EndpointMethodRequestBody = ReadonlyDeep<OpenAPIV3.RequestBodyObject>;\n\nexport type EndpointMethodRequestBodyProcessingResult = Readonly<{\n  parameters: readonly ParameterDeclaration[];\n  packedParameters?: ObjectLiteralExpression;\n  initParam: ts.Identifier;\n}>;\n\nexport default class EndpointMethodRequestBodyProcessor {\n  static readonly #defaultInitParamName = 'init';\n\n  readonly #dependencies: DependencyManager;\n  readonly #owner: Plugin;\n  readonly #requestBody?: EndpointMethodRequestBody;\n  readonly #initTypeIdentifier: ts.Identifier;\n\n  constructor(\n    requestBody: ReadonlyDeep<OpenAPIV3.ReferenceObject | OpenAPIV3.RequestBodyObject> | undefined,\n    dependencies: DependencyManager,\n    owner: Plugin,\n    initTypeIdentifier: ts.Identifier,\n  ) {\n    this.#owner = owner;\n    this.#dependencies = dependencies;\n    this.#requestBody = requestBody ? owner.resolver.resolve(requestBody) : undefined;\n    this.#initTypeIdentifier = initTypeIdentifier;\n  }\n\n  process(): EndpointMethodRequestBodyProcessingResult {\n    if (!this.#requestBody) {\n      return {\n        initParam: ts.factory.createIdentifier(EndpointMethodRequestBodyProcessor.#defaultInitParamName),\n        packedParameters: ts.factory.createObjectLiteralExpression(),\n        parameters: [\n          ts.factory.createParameterDeclaration(\n            undefined,\n            undefined,\n            EndpointMethodRequestBodyProcessor.#defaultInitParamName,\n            ts.factory.createToken(ts.SyntaxKind.QuestionToken),\n            ts.factory.createTypeReferenceNode(this.#initTypeIdentifier),\n          ),\n        ],\n      };\n    }\n\n    const parameterData = this.#extractParameterData(this.#requestBody.content[defaultMediaType].schema);\n    const parameterNames = parameterData.map(([name]) => name);\n    let initParamName = EndpointMethodRequestBodyProcessor.#defaultInitParamName;\n\n    while (parameterNames.includes(initParamName)) {\n      initParamName = `_${initParamName}`;\n    }\n\n    return {\n      initParam: ts.factory.createIdentifier(initParamName),\n      packedParameters: ts.factory.createObjectLiteralExpression(\n        parameterData.map(([name]) => ts.factory.createShorthandPropertyAssignment(name)),\n      ),\n      parameters: [\n        ...parameterData.map(([name, schema]) => {\n          const nodes = new TypeSchemaProcessor(schema, this.#dependencies).process();\n\n          return ts.factory.createParameterDeclaration(\n            undefined,\n            undefined,\n            name,\n            undefined,\n            ts.factory.createUnionTypeNode(nodes),\n          );\n        }),\n        ts.factory.createParameterDeclaration(\n          undefined,\n          undefined,\n          initParamName,\n          ts.factory.createToken(ts.SyntaxKind.QuestionToken),\n          ts.factory.createTypeReferenceNode(this.#initTypeIdentifier),\n        ),\n      ],\n    };\n  }\n\n  #extractParameterData(\n    basicSchema?: ReadonlyDeep<OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject>,\n  ): Array<readonly [string, Schema]> {\n    if (!basicSchema) {\n      return [];\n    }\n\n    const { logger, resolver } = this.#owner;\n\n    const resolvedSchema = resolver.resolve(basicSchema);\n\n    if (isObjectSchema(resolvedSchema) && !isEmptyObject(resolvedSchema)) {\n      return Object.entries((resolvedSchema as NonEmptyObjectSchema).properties);\n    }\n\n    logger.warn(\"A schema provided for endpoint method's 'requestBody' is not supported\");\n    return [];\n  }\n}\n"],
+  "mappings": "AACA;AAAA,EACE;AAAA,EACA;AAAA,OAGK;AAIP,OAAO,YAAqE;AAC5E,OAAO,yBAAyB;AAChC,SAAS,wBAAwB;AAUjC,MAAO,mCAAiD;AAAA,EACtD,OAAgB,wBAAwB;AAAA,EAE/B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAET,YACE,aACA,cACA,OACA,oBACA;AACA,SAAK,SAAS;AACd,SAAK,gBAAgB;AACrB,SAAK,eAAe,cAAc,MAAM,SAAS,QAAQ,WAAW,IAAI;AACxE,SAAK,sBAAsB;AAAA,EAC7B;AAAA,EAEA,UAAqD;AACnD,QAAI,CAAC,KAAK,cAAc;AACtB,aAAO;AAAA,QACL,WAAW,GAAG,QAAQ,iBAAiB,mCAAmC,qBAAqB;AAAA,QAC/F,kBAAkB,GAAG,QAAQ,8BAA8B;AAAA,QAC3D,YAAY;AAAA,UACV,GAAG,QAAQ;AAAA,YACT;AAAA,YACA;AAAA,YACA,mCAAmC;AAAA,YACnC,GAAG,QAAQ,YAAY,GAAG,WAAW,aAAa;AAAA,YAClD,GAAG,QAAQ,wBAAwB,KAAK,mBAAmB;AAAA,UAC7D;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAEA,UAAM,gBAAgB,KAAK,sBAAsB,KAAK,aAAa,QAAQ,gBAAgB,EAAE,MAAM;AACnG,UAAM,iBAAiB,cAAc,IAAI,CAAC,CAAC,IAAI,MAAM,IAAI;AACzD,QAAI,gBAAgB,mCAAmC;AAEvD,WAAO,eAAe,SAAS,aAAa,GAAG;AAC7C,sBAAgB,IAAI,aAAa;AAAA,IACnC;AAEA,WAAO;AAAA,MACL,WAAW,GAAG,QAAQ,iBAAiB,aAAa;AAAA,MACpD,kBAAkB,GAAG,QAAQ;AAAA,QAC3B,cAAc,IAAI,CAAC,CAAC,IAAI,MAAM,GAAG,QAAQ,kCAAkC,IAAI,CAAC;AAAA,MAClF;AAAA,MACA,YAAY;AAAA,QACV,GAAG,cAAc,IAAI,CAAC,CAAC,MAAM,MAAM,MAAM;AACvC,gBAAM,QAAQ,IAAI,oBAAoB,QAAQ,KAAK,aAAa,EAAE,QAAQ;AAE1E,iBAAO,GAAG,QAAQ;AAAA,YAChB;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,YACA,GAAG,QAAQ,oBAAoB,KAAK;AAAA,UACtC;AAAA,QACF,CAAC;AAAA,QACD,GAAG,QAAQ;AAAA,UACT;AAAA,UACA;AAAA,UACA;AAAA,UACA,GAAG,QAAQ,YAAY,GAAG,WAAW,aAAa;AAAA,UAClD,GAAG,QAAQ,wBAAwB,KAAK,mBAAmB;AAAA,QAC7D;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAAA,EAEA,sBACE,aACkC;AAClC,QAAI,CAAC,aAAa;AAChB,aAAO,CAAC;AAAA,IACV;AAEA,UAAM,EAAE,QAAQ,SAAS,IAAI,KAAK;AAElC,UAAM,iBAAiB,SAAS,QAAQ,WAAW;AAEnD,QAAI,eAAe,cAAc,KAAK,CAAC,cAAc,cAAc,GAAG;AACpE,aAAO,OAAO,QAAS,eAAwC,UAAU;AAAA,IAC3E;AAEA,WAAO,KAAK,wEAAwE;AACpF,WAAO,CAAC;AAAA,EACV;AACF;",
+  "names": []
+}

package/EndpointMethodResponseProcessor.d.ts

@@ -0,0 +1,13 @@
+import type Plugin from '@vaadin/hilla-generator-core/Plugin.js';
+import type DependencyManager from '@vaadin/hilla-generator-utils/dependencies/DependencyManager.js';
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ReadonlyDeep } from 'type-fest';
+import type { TypeNode } from 'typescript';
+export type EndpointMethodResponses = ReadonlyDeep<OpenAPIV3.ResponsesObject>;
+export type EndpointMethodResponse = ReadonlyDeep<OpenAPIV3.ResponseObject>;
+export default class EndpointMethodResponseProcessor {
+    #private;
+    constructor(code: string, response: EndpointMethodResponses[string], dependencyManager: DependencyManager, owner: Plugin);
+    process(): readonly TypeNode[];
+}
+//# sourceMappingURL=EndpointMethodResponseProcessor.d.ts.map

package/EndpointMethodResponseProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EndpointMethodResponseProcessor.d.ts","sourceRoot":"","sources":["src/EndpointMethodResponseProcessor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,wCAAwC,CAAC;AACjE,OAAO,KAAK,iBAAiB,MAAM,iEAAiE,CAAC;AACrG,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAI3C,MAAM,MAAM,uBAAuB,GAAG,YAAY,CAAC,SAAS,CAAC,eAAe,CAAC,CAAC;AAC9E,MAAM,MAAM,sBAAsB,GAAG,YAAY,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC;AAE5E,MAAM,CAAC,OAAO,OAAO,+BAA+B;;gBAOhD,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,uBAAuB,CAAC,MAAM,CAAC,EACzC,iBAAiB,EAAE,iBAAiB,EACpC,KAAK,EAAE,MAAM;IAQf,OAAO,IAAI,SAAS,QAAQ,EAAE;CAe/B"}

package/EndpointMethodResponseProcessor.js

@@ -0,0 +1,31 @@
+import TypeSchemaProcessor from "./TypeSchemaProcessor.js";
+import { defaultMediaType } from "./utils.js";
+class EndpointMethodResponseProcessor {
+  #code;
+  #dependencies;
+  #owner;
+  #response;
+  constructor(code, response, dependencyManager, owner) {
+    this.#code = code;
+    this.#owner = owner;
+    this.#dependencies = dependencyManager;
+    this.#response = owner.resolver.resolve(response);
+  }
+  process() {
+    switch (this.#code) {
+      case "200":
+        return this.#processOk();
+      default:
+        this.#owner.logger.warn(`Response code '${this.#code} is not supported'`);
+        return [];
+    }
+  }
+  #processOk() {
+    const rawSchema = this.#response.content?.[defaultMediaType]?.schema;
+    return rawSchema ? new TypeSchemaProcessor(rawSchema, this.#dependencies).process() : [];
+  }
+}
+export {
+  EndpointMethodResponseProcessor as default
+};
+//# sourceMappingURL=EndpointMethodResponseProcessor.js.map

package/EndpointMethodResponseProcessor.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["src/EndpointMethodResponseProcessor.ts"],
+  "sourcesContent": ["import type Plugin from '@vaadin/hilla-generator-core/Plugin.js';\nimport type DependencyManager from '@vaadin/hilla-generator-utils/dependencies/DependencyManager.js';\nimport type { OpenAPIV3 } from 'openapi-types';\nimport type { ReadonlyDeep } from 'type-fest';\nimport type { TypeNode } from 'typescript';\nimport TypeSchemaProcessor from './TypeSchemaProcessor.js';\nimport { defaultMediaType } from './utils.js';\n\nexport type EndpointMethodResponses = ReadonlyDeep<OpenAPIV3.ResponsesObject>;\nexport type EndpointMethodResponse = ReadonlyDeep<OpenAPIV3.ResponseObject>;\n\nexport default class EndpointMethodResponseProcessor {\n  readonly #code: string;\n  readonly #dependencies: DependencyManager;\n  readonly #owner: Plugin;\n  readonly #response: EndpointMethodResponse;\n\n  constructor(\n    code: string,\n    response: EndpointMethodResponses[string],\n    dependencyManager: DependencyManager,\n    owner: Plugin,\n  ) {\n    this.#code = code;\n    this.#owner = owner;\n    this.#dependencies = dependencyManager;\n    this.#response = owner.resolver.resolve(response);\n  }\n\n  process(): readonly TypeNode[] {\n    switch (this.#code) {\n      case '200':\n        return this.#processOk();\n      default:\n        this.#owner.logger.warn(`Response code '${this.#code} is not supported'`);\n        return [];\n    }\n  }\n\n  #processOk(): readonly TypeNode[] {\n    const rawSchema = this.#response.content?.[defaultMediaType]?.schema;\n\n    return rawSchema ? new TypeSchemaProcessor(rawSchema, this.#dependencies).process() : [];\n  }\n}\n"],
+  "mappings": "AAKA,OAAO,yBAAyB;AAChC,SAAS,wBAAwB;AAKjC,MAAO,gCAA8C;AAAA,EAC1C;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAET,YACE,MACA,UACA,mBACA,OACA;AACA,SAAK,QAAQ;AACb,SAAK,SAAS;AACd,SAAK,gBAAgB;AACrB,SAAK,YAAY,MAAM,SAAS,QAAQ,QAAQ;AAAA,EAClD;AAAA,EAEA,UAA+B;AAC7B,YAAQ,KAAK,OAAO;AAAA,MAClB,KAAK;AACH,eAAO,KAAK,WAAW;AAAA,MACzB;AACE,aAAK,OAAO,OAAO,KAAK,kBAAkB,KAAK,KAAK,oBAAoB;AACxE,eAAO,CAAC;AAAA,IACZ;AAAA,EACF;AAAA,EAEA,aAAkC;AAChC,UAAM,YAAY,KAAK,UAAU,UAAU,gBAAgB,GAAG;AAE9D,WAAO,YAAY,IAAI,oBAAoB,WAAW,KAAK,aAAa,EAAE,QAAQ,IAAI,CAAC;AAAA,EACzF;AACF;",
+  "names": []
+}

package/EndpointProcessor.d.ts

@@ -0,0 +1,11 @@
+import type Plugin from '@vaadin/hilla-generator-core/Plugin.js';
+import { OpenAPIV3 } from 'openapi-types';
+import type { ReadonlyDeep } from 'type-fest';
+import type { SourceFile } from 'typescript';
+export default class EndpointProcessor {
+    #private;
+    static create(name: string, owner: Plugin, methods: Map<string, ReadonlyDeep<OpenAPIV3.PathItemObject>>, outputDir?: string): Promise<EndpointProcessor>;
+    private constructor();
+    process(): Promise<SourceFile>;
+}
+//# sourceMappingURL=EndpointProcessor.d.ts.map

package/EndpointProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EndpointProcessor.d.ts","sourceRoot":"","sources":["src/EndpointProcessor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,wCAAwC,CAAC;AAKjE,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAa,MAAM,YAAY,CAAC;AAMxD,MAAM,CAAC,OAAO,OAAO,iBAAiB;;WACvB,MAAM,CACjB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC,EAC5D,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,iBAAiB,CAAC;IAoB7B,OAAO;IAYD,OAAO,IAAI,OAAO,CAAC,UAAU,CAAC;CAuCrC"}

package/EndpointProcessor.js

@@ -0,0 +1,63 @@
+import ClientPlugin from "@vaadin/hilla-generator-plugin-client";
+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 { OpenAPIV3 } from "openapi-types";
+import EndpointMethodOperationProcessor, {
+  HILLA_FRONTEND_NAME,
+  INIT_TYPE_NAME
+} from "./EndpointMethodOperationProcessor.js";
+class EndpointProcessor {
+  static async create(name, owner, methods, outputDir) {
+    const endpoint = new EndpointProcessor(name, owner, methods, outputDir);
+    endpoint.#dependencies.imports.default.add(
+      endpoint.#dependencies.paths.createRelativePath(await ClientPlugin.getClientFileName(outputDir)),
+      "client"
+    );
+    endpoint.#dependencies.imports.named.add(
+      endpoint.#dependencies.paths.createBareModulePath(HILLA_FRONTEND_NAME),
+      INIT_TYPE_NAME
+    );
+    return endpoint;
+  }
+  #createdFilePaths = new PathManager({ extension: "ts" });
+  #dependencies = new DependencyManager(new PathManager({ extension: ".js" }));
+  #methods;
+  #name;
+  #outputDir;
+  #owner;
+  constructor(name, owner, methods, outputDir) {
+    this.#name = name;
+    this.#owner = owner;
+    this.#methods = methods;
+    this.#outputDir = outputDir;
+  }
+  async process() {
+    this.#owner.logger.debug(`Processing endpoint: ${this.#name}`);
+    const statements = (await Promise.all(Array.from(this.#methods, async ([method, pathItem]) => this.#processMethod(method, pathItem)))).flatMap((item) => item);
+    const { exports, imports } = this.#dependencies;
+    return createSourceFile(
+      [...imports.toCode(), ...statements, ...exports.toCode()],
+      this.#createdFilePaths.createRelativePath(this.#name)
+    );
+  }
+  async #processMethod(method, pathItem) {
+    this.#owner.logger.debug(`Processing endpoint method: ${this.#name}.${method}`);
+    return (await Promise.all(
+      Object.values(OpenAPIV3.HttpMethods).filter((httpMethod) => pathItem[httpMethod]).map(
+        async (httpMethod) => EndpointMethodOperationProcessor.createProcessor(
+          httpMethod,
+          this.#name,
+          method,
+          pathItem[httpMethod],
+          this.#dependencies,
+          this.#owner
+        )?.process(this.#outputDir)
+      )
+    )).filter(Boolean);
+  }
+}
+export {
+  EndpointProcessor as default
+};
+//# sourceMappingURL=EndpointProcessor.js.map

package/EndpointProcessor.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["src/EndpointProcessor.ts"],
+  "sourcesContent": ["import type Plugin from '@vaadin/hilla-generator-core/Plugin.js';\nimport ClientPlugin from '@vaadin/hilla-generator-plugin-client';\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 { OpenAPIV3 } from 'openapi-types';\nimport type { ReadonlyDeep } from 'type-fest';\nimport type { SourceFile, Statement } from 'typescript';\nimport EndpointMethodOperationProcessor, {\n  HILLA_FRONTEND_NAME,\n  INIT_TYPE_NAME,\n} from './EndpointMethodOperationProcessor.js';\n\nexport default class EndpointProcessor {\n  static async create(\n    name: string,\n    owner: Plugin,\n    methods: Map<string, ReadonlyDeep<OpenAPIV3.PathItemObject>>,\n    outputDir?: string,\n  ): Promise<EndpointProcessor> {\n    const endpoint = new EndpointProcessor(name, owner, methods, outputDir);\n    endpoint.#dependencies.imports.default.add(\n      endpoint.#dependencies.paths.createRelativePath(await ClientPlugin.getClientFileName(outputDir)),\n      'client',\n    );\n    endpoint.#dependencies.imports.named.add(\n      endpoint.#dependencies.paths.createBareModulePath(HILLA_FRONTEND_NAME),\n      INIT_TYPE_NAME,\n    );\n    return endpoint;\n  }\n\n  readonly #createdFilePaths = new PathManager({ extension: 'ts' });\n  readonly #dependencies = new DependencyManager(new PathManager({ extension: '.js' }));\n  readonly #methods: Map<string, ReadonlyDeep<OpenAPIV3.PathItemObject>>;\n  readonly #name: string;\n  readonly #outputDir: string | undefined;\n  readonly #owner: Plugin;\n\n  private constructor(\n    name: string,\n    owner: Plugin,\n    methods: Map<string, ReadonlyDeep<OpenAPIV3.PathItemObject>>,\n    outputDir?: string,\n  ) {\n    this.#name = name;\n    this.#owner = owner;\n    this.#methods = methods;\n    this.#outputDir = outputDir;\n  }\n\n  async process(): Promise<SourceFile> {\n    this.#owner.logger.debug(`Processing endpoint: ${this.#name}`);\n\n    const statements = (\n      await Promise.all(Array.from(this.#methods, async ([method, pathItem]) => this.#processMethod(method, pathItem)))\n    ).flatMap((item) => item);\n\n    const { exports, imports } = this.#dependencies;\n\n    return createSourceFile(\n      [...imports.toCode(), ...statements, ...exports.toCode()],\n      this.#createdFilePaths.createRelativePath(this.#name),\n    );\n  }\n\n  async #processMethod(\n    method: string,\n    pathItem: ReadonlyDeep<OpenAPIV3.PathItemObject>,\n  ): Promise<readonly Statement[]> {\n    this.#owner.logger.debug(`Processing endpoint method: ${this.#name}.${method}`);\n\n    return (\n      await Promise.all(\n        Object.values(OpenAPIV3.HttpMethods)\n          .filter((httpMethod) => pathItem[httpMethod])\n          .map(\n            async (httpMethod) =>\n              EndpointMethodOperationProcessor.createProcessor(\n                httpMethod,\n                this.#name,\n                method,\n                pathItem[httpMethod]!,\n                this.#dependencies,\n                this.#owner,\n              )?.process(this.#outputDir),\n          ),\n      )\n    ).filter(Boolean) as readonly Statement[];\n  }\n}\n"],
+  "mappings": "AACA,OAAO,kBAAkB;AACzB,OAAO,sBAAsB;AAC7B,OAAO,uBAAuB;AAC9B,OAAO,iBAAiB;AACxB,SAAS,iBAAiB;AAG1B,OAAO;AAAA,EACL;AAAA,EACA;AAAA,OACK;AAEP,MAAO,kBAAgC;AAAA,EACrC,aAAa,OACX,MACA,OACA,SACA,WAC4B;AAC5B,UAAM,WAAW,IAAI,kBAAkB,MAAM,OAAO,SAAS,SAAS;AACtE,aAAS,cAAc,QAAQ,QAAQ;AAAA,MACrC,SAAS,cAAc,MAAM,mBAAmB,MAAM,aAAa,kBAAkB,SAAS,CAAC;AAAA,MAC/F;AAAA,IACF;AACA,aAAS,cAAc,QAAQ,MAAM;AAAA,MACnC,SAAS,cAAc,MAAM,qBAAqB,mBAAmB;AAAA,MACrE;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAAA,EAES,oBAAoB,IAAI,YAAY,EAAE,WAAW,KAAK,CAAC;AAAA,EACvD,gBAAgB,IAAI,kBAAkB,IAAI,YAAY,EAAE,WAAW,MAAM,CAAC,CAAC;AAAA,EAC3E;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAED,YACN,MACA,OACA,SACA,WACA;AACA,SAAK,QAAQ;AACb,SAAK,SAAS;AACd,SAAK,WAAW;AAChB,SAAK,aAAa;AAAA,EACpB;AAAA,EAEA,MAAM,UAA+B;AACnC,SAAK,OAAO,OAAO,MAAM,wBAAwB,KAAK,KAAK,EAAE;AAE7D,UAAM,cACJ,MAAM,QAAQ,IAAI,MAAM,KAAK,KAAK,UAAU,OAAO,CAAC,QAAQ,QAAQ,MAAM,KAAK,eAAe,QAAQ,QAAQ,CAAC,CAAC,GAChH,QAAQ,CAAC,SAAS,IAAI;AAExB,UAAM,EAAE,SAAS,QAAQ,IAAI,KAAK;AAElC,WAAO;AAAA,MACL,CAAC,GAAG,QAAQ,OAAO,GAAG,GAAG,YAAY,GAAG,QAAQ,OAAO,CAAC;AAAA,MACxD,KAAK,kBAAkB,mBAAmB,KAAK,KAAK;AAAA,IACtD;AAAA,EACF;AAAA,EAEA,MAAM,eACJ,QACA,UAC+B;AAC/B,SAAK,OAAO,OAAO,MAAM,+BAA+B,KAAK,KAAK,IAAI,MAAM,EAAE;AAE9E,YACE,MAAM,QAAQ;AAAA,MACZ,OAAO,OAAO,UAAU,WAAW,EAChC,OAAO,CAAC,eAAe,SAAS,UAAU,CAAC,EAC3C;AAAA,QACC,OAAO,eACL,iCAAiC;AAAA,UAC/B;AAAA,UACA,KAAK;AAAA,UACL;AAAA,UACA,SAAS,UAAU;AAAA,UACnB,KAAK;AAAA,UACL,KAAK;AAAA,QACP,GAAG,QAAQ,KAAK,UAAU;AAAA,MAC9B;AAAA,IACJ,GACA,OAAO,OAAO;AAAA,EAClB;AACF;",
+  "names": []
+}

package/EntityProcessor.d.ts

@@ -0,0 +1,9 @@
+import type Plugin from '@vaadin/hilla-generator-core/Plugin.js';
+import { type Schema } from '@vaadin/hilla-generator-core/Schema.js';
+import { type SourceFile } from 'typescript';
+export declare class EntityProcessor {
+    #private;
+    constructor(name: string, component: Schema, owner: Plugin);
+    process(): SourceFile;
+}
+//# sourceMappingURL=EntityProcessor.d.ts.map

package/EntityProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityProcessor.d.ts","sourceRoot":"","sources":["src/EntityProcessor.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,wCAAwC,CAAC;AACjE,OAAO,EAGL,KAAK,MAAM,EAWZ,MAAM,wCAAwC,CAAC;AAQhD,OAAW,EAGT,KAAK,UAAU,EAGhB,MAAM,YAAY,CAAC;AAGpB,qBAAa,eAAe;;gBASd,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAiB1D,OAAO,IAAI,UAAU;CA+GtB"}

package/EntityProcessor.js

@@ -0,0 +1,132 @@
+import { dirname } from "path/posix";
+import {
+  convertReferenceSchemaToPath,
+  convertReferenceSchemaToSpecifier,
+  decomposeSchema,
+  isComposedSchema,
+  isEmptyObject,
+  isEnumSchema,
+  isNullableSchema,
+  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 TypeSchemaProcessor from "./TypeSchemaProcessor.js";
+class EntityProcessor {
+  #component;
+  #dependencies;
+  #fullyQualifiedName;
+  #name;
+  #outputPathManager = new PathManager({ extension: "ts" });
+  #owner;
+  #path;
+  constructor(name, component, owner) {
+    this.#component = component;
+    this.#owner = owner;
+    this.#fullyQualifiedName = name;
+    this.#name = simplifyFullyQualifiedName(name);
+    this.#path = convertFullyQualifiedNameToRelativePath(name);
+    this.#dependencies = new DependencyManager(new PathManager({ extension: ".js", relativeTo: dirname(this.#path) }));
+  }
+  get #id() {
+    const id = ts.factory.createIdentifier(this.#name);
+    this.#dependencies.exports.default.set(id);
+    return id;
+  }
+  process() {
+    this.#owner.logger.debug(`Processing entity: ${this.#name}`);
+    const declaration = isEnumSchema(this.#component) ? this.#processEnum(this.#component) : this.#processExtendedClass(this.#component);
+    const statements = declaration ? [declaration] : [];
+    const { exports, imports } = this.#dependencies;
+    return createSourceFile(
+      [...imports.toCode(), ...statements, ...exports.toCode()],
+      this.#outputPathManager.createRelativePath(this.#path)
+    );
+  }
+  #processClass(schema) {
+    const { logger } = this.#owner;
+    if (!isObjectSchema(schema)) {
+      logger.debug(schema, `Component is not an object: '${this.#fullyQualifiedName}'`);
+      return void 0;
+    }
+    if (isEmptyObject(schema)) {
+      logger.debug(`Component has no properties:' ${this.#fullyQualifiedName}'`);
+    }
+    return ts.factory.createInterfaceDeclaration(
+      void 0,
+      this.#id,
+      void 0,
+      void 0,
+      this.#processTypeElements(schema)
+    );
+  }
+  #processEnum({ enum: members }) {
+    return ts.factory.createEnumDeclaration(
+      void 0,
+      this.#id,
+      members.map((member) => ts.factory.createEnumMember(member, ts.factory.createStringLiteral(member)))
+    );
+  }
+  #processExtendedClass(schema) {
+    const { logger } = this.#owner;
+    if (isComposedSchema(schema)) {
+      const decomposed = decomposeSchema(schema);
+      if (decomposed.length > 2) {
+        logger.debug(
+          schema,
+          `Schema for '${this.#fullyQualifiedName}' has more than two components. This plugin will ignore it.`
+        );
+        return void 0;
+      }
+      const [parent, child] = decomposed;
+      if (!isReferenceSchema(parent)) {
+        logger.debug(parent, "Only reference schema allowed for parent class");
+        return void 0;
+      }
+      const declaration = this.#processClass(child);
+      const identifier = this.#processParentClass(parent);
+      return declaration && ts.factory.updateInterfaceDeclaration(
+        declaration,
+        declaration.modifiers,
+        declaration.name,
+        void 0,
+        [
+          ts.factory.createHeritageClause(ts.SyntaxKind.ExtendsKeyword, [
+            ts.factory.createExpressionWithTypeArguments(identifier, void 0)
+          ])
+        ],
+        declaration.members
+      );
+    }
+    return this.#processClass(schema);
+  }
+  #processParentClass(schema) {
+    const { imports, paths } = this.#dependencies;
+    const specifier = convertReferenceSchemaToSpecifier(schema);
+    const path = paths.createRelativePath(convertReferenceSchemaToPath(schema));
+    return imports.default.getIdentifier(path) ?? imports.default.add(path, specifier, true);
+  }
+  #processTypeElements({ properties }) {
+    return Object.entries(properties ?? {}).map(([name, schema]) => {
+      const [type] = new TypeSchemaProcessor(schema, this.#dependencies).process();
+      return ts.factory.createPropertySignature(
+        void 0,
+        name,
+        isNullableSchema(schema) ? ts.factory.createToken(ts.SyntaxKind.QuestionToken) : void 0,
+        type
+      );
+    });
+  }
+}
+export {
+  EntityProcessor
+};
+//# sourceMappingURL=EntityProcessor.js.map

package/EntityProcessor.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["src/EntityProcessor.ts"],
+  "sourcesContent": ["import { dirname } from 'path/posix';\nimport type Plugin from '@vaadin/hilla-generator-core/Plugin.js';\nimport {\n  type EnumSchema,\n  type ReferenceSchema,\n  type Schema,\n  convertReferenceSchemaToPath,\n  convertReferenceSchemaToSpecifier,\n  decomposeSchema,\n  isComposedSchema,\n  isEmptyObject,\n  isEnumSchema,\n  isNullableSchema,\n  isObjectSchema,\n  isReferenceSchema,\n  type ObjectSchema,\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 Identifier,\n  type InterfaceDeclaration,\n  type SourceFile,\n  type Statement,\n  type TypeElement,\n} from 'typescript';\nimport TypeSchemaProcessor from './TypeSchemaProcessor.js';\n\nexport class EntityProcessor {\n  readonly #component: Schema;\n  readonly #dependencies;\n  readonly #fullyQualifiedName: string;\n  readonly #name: string;\n  readonly #outputPathManager = new PathManager({ extension: 'ts' });\n  readonly #owner: Plugin;\n  readonly #path: string;\n\n  constructor(name: string, component: Schema, owner: Plugin) {\n    this.#component = component;\n    this.#owner = owner;\n    this.#fullyQualifiedName = name;\n    this.#name = simplifyFullyQualifiedName(name);\n    this.#path = convertFullyQualifiedNameToRelativePath(name);\n    this.#dependencies = new DependencyManager(new PathManager({ extension: '.js', relativeTo: dirname(this.#path) }));\n  }\n\n  get #id(): Identifier {\n    const id = ts.factory.createIdentifier(this.#name);\n\n    this.#dependencies.exports.default.set(id);\n\n    return id;\n  }\n\n  process(): SourceFile {\n    this.#owner.logger.debug(`Processing entity: ${this.#name}`);\n\n    const declaration = isEnumSchema(this.#component)\n      ? this.#processEnum(this.#component)\n      : this.#processExtendedClass(this.#component);\n\n    const statements = declaration ? [declaration] : [];\n\n    const { exports, imports } = this.#dependencies;\n\n    return createSourceFile(\n      [...imports.toCode(), ...statements, ...exports.toCode()],\n      this.#outputPathManager.createRelativePath(this.#path),\n    );\n  }\n\n  #processClass(schema: Schema): InterfaceDeclaration | undefined {\n    const { logger } = this.#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.debug(`Component has no properties:' ${this.#fullyQualifiedName}'`);\n    }\n\n    return ts.factory.createInterfaceDeclaration(\n      undefined,\n      this.#id,\n      undefined,\n      undefined,\n      this.#processTypeElements(schema as ObjectSchema),\n    );\n  }\n\n  #processEnum({ enum: members }: EnumSchema): Statement {\n    return ts.factory.createEnumDeclaration(\n      undefined,\n      this.#id,\n      members.map((member) => ts.factory.createEnumMember(member, ts.factory.createStringLiteral(member))),\n    );\n  }\n\n  #processExtendedClass(schema: Schema): Statement | undefined {\n    const { logger } = this.#owner;\n\n    if (isComposedSchema(schema)) {\n      const decomposed = decomposeSchema(schema);\n\n      if (decomposed.length > 2) {\n        logger.debug(\n          schema,\n          `Schema for '${this.#fullyQualifiedName}' has more than two components. This plugin will ignore it.`,\n        );\n        return undefined;\n      }\n\n      const [parent, child] = decomposed;\n\n      if (!isReferenceSchema(parent)) {\n        logger.debug(parent, 'Only reference schema allowed for parent class');\n        return undefined;\n      }\n\n      const declaration = this.#processClass(child);\n      const identifier = this.#processParentClass(parent);\n\n      return (\n        declaration &&\n        ts.factory.updateInterfaceDeclaration(\n          declaration,\n          declaration.modifiers,\n          declaration.name,\n          undefined,\n          [\n            ts.factory.createHeritageClause(ts.SyntaxKind.ExtendsKeyword, [\n              ts.factory.createExpressionWithTypeArguments(identifier, undefined),\n            ]),\n          ],\n          declaration.members,\n        )\n      );\n    }\n\n    return this.#processClass(schema);\n  }\n\n  #processParentClass(schema: ReferenceSchema): Identifier {\n    const { imports, paths } = this.#dependencies;\n\n    const specifier = convertReferenceSchemaToSpecifier(schema);\n    const path = paths.createRelativePath(convertReferenceSchemaToPath(schema));\n\n    return imports.default.getIdentifier(path) ?? imports.default.add(path, specifier, true);\n  }\n\n  #processTypeElements({ properties }: ObjectSchema): readonly TypeElement[] {\n    return Object.entries(properties ?? {}).map(([name, schema]) => {\n      const [type] = new TypeSchemaProcessor(schema, this.#dependencies).process();\n\n      return ts.factory.createPropertySignature(\n        undefined,\n        name,\n        isNullableSchema(schema) ? ts.factory.createToken(ts.SyntaxKind.QuestionToken) : undefined,\n        type,\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/README.md

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

package/TypeSchemaProcessor.d.ts

@@ -0,0 +1,10 @@
+import { type Schema } from '@vaadin/hilla-generator-core/Schema.js';
+import type DependencyManager from '@vaadin/hilla-generator-utils/dependencies/DependencyManager.js';
+import { type TypeNode } from 'typescript';
+export default class TypeSchemaProcessor {
+    #private;
+    ['constructor']: typeof TypeSchemaProcessor;
+    constructor(schema: Schema, dependencies: DependencyManager);
+    process(): readonly TypeNode[];
+}
+//# sourceMappingURL=TypeSchemaProcessor.d.ts.map

package/TypeSchemaProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeSchemaProcessor.d.ts","sourceRoot":"","sources":["src/TypeSchemaProcessor.ts"],"names":[],"mappings":"AAAA,OAAO,EAiBL,KAAK,MAAM,EACZ,MAAM,wCAAwC,CAAC;AAChD,OAAO,KAAK,iBAAiB,MAAM,iEAAiE,CAAC;AACrG,OAAW,EAAE,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAgC/C,MAAM,CAAC,OAAO,OAAO,mBAAmB;;IAC9B,CAAC,aAAa,CAAC,EAAE,OAAO,mBAAmB,CAAC;gBAIxC,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,iBAAiB;IAK3D,OAAO,IAAI,SAAS,QAAQ,EAAE;CAwD/B"}

package/TypeSchemaProcessor.js

@@ -0,0 +1,93 @@
+import {
+  convertReferenceSchemaToPath,
+  convertReferenceSchemaToSpecifier,
+  decomposeSchema,
+  isArraySchema,
+  isBooleanSchema,
+  isComposedSchema,
+  isIntegerSchema,
+  isMapSchema,
+  isNullableSchema,
+  isNumberSchema,
+  isReferenceSchema,
+  isStringSchema
+} from "@vaadin/hilla-generator-core/Schema.js";
+import ts, {} from "typescript";
+function createBoolean() {
+  return ts.factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword);
+}
+function createNumber() {
+  return ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
+}
+function createString() {
+  return ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword);
+}
+function createUndefined() {
+  return ts.factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword);
+}
+function createUnknown() {
+  return ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
+}
+function unwrapPossiblyNullableSchema(schema) {
+  if (isComposedSchema(schema)) {
+    const [result] = decomposeSchema(schema);
+    return result;
+  }
+  return schema;
+}
+class TypeSchemaProcessor {
+  #dependencies;
+  #schema;
+  constructor(schema, dependencies) {
+    this.#schema = schema;
+    this.#dependencies = dependencies;
+  }
+  process() {
+    let node;
+    const unwrappedSchema = unwrapPossiblyNullableSchema(this.#schema);
+    if (isReferenceSchema(unwrappedSchema)) {
+      node = this.#processReference(unwrappedSchema);
+    } else if (isArraySchema(unwrappedSchema)) {
+      node = this.#processArray(unwrappedSchema);
+    } else if (isMapSchema(unwrappedSchema)) {
+      node = this.#processMap(unwrappedSchema);
+    } else if (isBooleanSchema(unwrappedSchema)) {
+      node = createBoolean();
+    } else if (isIntegerSchema(unwrappedSchema) || isNumberSchema(unwrappedSchema)) {
+      node = createNumber();
+    } else if (isStringSchema(unwrappedSchema)) {
+      node = createString();
+    } else {
+      node = createUnknown();
+    }
+    return isNullableSchema(this.#schema) ? [node, createUndefined()] : [node];
+  }
+  #processArray(schema) {
+    const nodes = new TypeSchemaProcessor(schema.items, this.#dependencies).process();
+    return ts.factory.createTypeReferenceNode("Array", [ts.factory.createUnionTypeNode(nodes)]);
+  }
+  #processMap({ additionalProperties: valuesType }) {
+    let valuesTypeNode;
+    if (typeof valuesType !== "boolean") {
+      const nodes = new TypeSchemaProcessor(valuesType, this.#dependencies).process();
+      valuesTypeNode = ts.factory.createUnionTypeNode(nodes);
+    } else {
+      valuesTypeNode = ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
+    }
+    return ts.factory.createTypeReferenceNode("Record", [
+      ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
+      valuesTypeNode
+    ]);
+  }
+  #processReference(schema) {
+    const { imports, paths } = this.#dependencies;
+    const specifier = convertReferenceSchemaToSpecifier(schema);
+    const path = paths.createRelativePath(convertReferenceSchemaToPath(schema));
+    const identifier = imports.default.getIdentifier(path) ?? imports.default.add(path, specifier, true);
+    return ts.factory.createTypeReferenceNode(identifier);
+  }
+}
+export {
+  TypeSchemaProcessor as default
+};
+//# sourceMappingURL=TypeSchemaProcessor.js.map

package/TypeSchemaProcessor.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["src/TypeSchemaProcessor.ts"],
+  "sourcesContent": ["import {\n  type ArraySchema,\n  convertReferenceSchemaToPath,\n  convertReferenceSchemaToSpecifier,\n  decomposeSchema,\n  isArraySchema,\n  isBooleanSchema,\n  isComposedSchema,\n  isIntegerSchema,\n  isMapSchema,\n  isNullableSchema,\n  isNumberSchema,\n  isReferenceSchema,\n  isStringSchema,\n  type MapSchema,\n  type NonComposedSchema,\n  type ReferenceSchema,\n  type Schema,\n} from '@vaadin/hilla-generator-core/Schema.js';\nimport type DependencyManager from '@vaadin/hilla-generator-utils/dependencies/DependencyManager.js';\nimport ts, { type TypeNode } from 'typescript';\n\nfunction createBoolean(): TypeNode {\n  return ts.factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword);\n}\n\nfunction createNumber(): TypeNode {\n  return ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);\n}\n\nfunction createString(): TypeNode {\n  return ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword);\n}\n\nfunction createUndefined(): TypeNode {\n  return ts.factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword);\n}\n\nfunction createUnknown(): TypeNode {\n  return ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);\n}\n\nfunction unwrapPossiblyNullableSchema(schema: Schema): NonComposedSchema {\n  if (isComposedSchema(schema)) {\n    const [result] = decomposeSchema(schema);\n\n    return result as NonComposedSchema;\n  }\n\n  return schema as NonComposedSchema;\n}\n\nexport default class TypeSchemaProcessor {\n  declare ['constructor']: typeof TypeSchemaProcessor;\n  readonly #dependencies: DependencyManager;\n  readonly #schema: Schema;\n\n  constructor(schema: Schema, dependencies: DependencyManager) {\n    this.#schema = schema;\n    this.#dependencies = dependencies;\n  }\n\n  process(): readonly TypeNode[] {\n    let node: TypeNode;\n\n    const unwrappedSchema = unwrapPossiblyNullableSchema(this.#schema);\n\n    if (isReferenceSchema(unwrappedSchema)) {\n      node = this.#processReference(unwrappedSchema);\n    } else if (isArraySchema(unwrappedSchema)) {\n      node = this.#processArray(unwrappedSchema);\n    } else if (isMapSchema(unwrappedSchema)) {\n      node = this.#processMap(unwrappedSchema);\n    } else if (isBooleanSchema(unwrappedSchema)) {\n      node = createBoolean();\n    } else if (isIntegerSchema(unwrappedSchema) || isNumberSchema(unwrappedSchema)) {\n      node = createNumber();\n    } else if (isStringSchema(unwrappedSchema)) {\n      node = createString();\n    } else {\n      node = createUnknown();\n    }\n\n    return isNullableSchema(this.#schema) ? [node, createUndefined()] : [node];\n  }\n\n  #processArray(schema: ArraySchema): TypeNode {\n    const nodes = new TypeSchemaProcessor(schema.items, this.#dependencies).process();\n\n    return ts.factory.createTypeReferenceNode('Array', [ts.factory.createUnionTypeNode(nodes)]);\n  }\n\n  #processMap({ additionalProperties: valuesType }: MapSchema): TypeNode {\n    let valuesTypeNode: TypeNode;\n\n    if (typeof valuesType !== 'boolean') {\n      const nodes = new TypeSchemaProcessor(valuesType, this.#dependencies).process();\n      valuesTypeNode = ts.factory.createUnionTypeNode(nodes);\n    } else {\n      valuesTypeNode = ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);\n    }\n\n    return ts.factory.createTypeReferenceNode('Record', [\n      ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),\n      valuesTypeNode,\n    ]);\n  }\n\n  #processReference(schema: ReferenceSchema): TypeNode {\n    const { imports, paths } = this.#dependencies;\n\n    const specifier = convertReferenceSchemaToSpecifier(schema);\n    const path = paths.createRelativePath(convertReferenceSchemaToPath(schema));\n\n    const identifier = imports.default.getIdentifier(path) ?? imports.default.add(path, specifier, true);\n\n    return ts.factory.createTypeReferenceNode(identifier);\n  }\n}\n"],
+  "mappings": "AAAA;AAAA,EAEE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAKK;AAEP,OAAO,YAA2B;AAElC,SAAS,gBAA0B;AACjC,SAAO,GAAG,QAAQ,sBAAsB,GAAG,WAAW,cAAc;AACtE;AAEA,SAAS,eAAyB;AAChC,SAAO,GAAG,QAAQ,sBAAsB,GAAG,WAAW,aAAa;AACrE;AAEA,SAAS,eAAyB;AAChC,SAAO,GAAG,QAAQ,sBAAsB,GAAG,WAAW,aAAa;AACrE;AAEA,SAAS,kBAA4B;AACnC,SAAO,GAAG,QAAQ,sBAAsB,GAAG,WAAW,gBAAgB;AACxE;AAEA,SAAS,gBAA0B;AACjC,SAAO,GAAG,QAAQ,sBAAsB,GAAG,WAAW,cAAc;AACtE;AAEA,SAAS,6BAA6B,QAAmC;AACvE,MAAI,iBAAiB,MAAM,GAAG;AAC5B,UAAM,CAAC,MAAM,IAAI,gBAAgB,MAAM;AAEvC,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAEA,MAAO,oBAAkC;AAAA,EAE9B;AAAA,EACA;AAAA,EAET,YAAY,QAAgB,cAAiC;AAC3D,SAAK,UAAU;AACf,SAAK,gBAAgB;AAAA,EACvB;AAAA,EAEA,UAA+B;AAC7B,QAAI;AAEJ,UAAM,kBAAkB,6BAA6B,KAAK,OAAO;AAEjE,QAAI,kBAAkB,eAAe,GAAG;AACtC,aAAO,KAAK,kBAAkB,eAAe;AAAA,IAC/C,WAAW,cAAc,eAAe,GAAG;AACzC,aAAO,KAAK,cAAc,eAAe;AAAA,IAC3C,WAAW,YAAY,eAAe,GAAG;AACvC,aAAO,KAAK,YAAY,eAAe;AAAA,IACzC,WAAW,gBAAgB,eAAe,GAAG;AAC3C,aAAO,cAAc;AAAA,IACvB,WAAW,gBAAgB,eAAe,KAAK,eAAe,eAAe,GAAG;AAC9E,aAAO,aAAa;AAAA,IACtB,WAAW,eAAe,eAAe,GAAG;AAC1C,aAAO,aAAa;AAAA,IACtB,OAAO;AACL,aAAO,cAAc;AAAA,IACvB;AAEA,WAAO,iBAAiB,KAAK,OAAO,IAAI,CAAC,MAAM,gBAAgB,CAAC,IAAI,CAAC,IAAI;AAAA,EAC3E;AAAA,EAEA,cAAc,QAA+B;AAC3C,UAAM,QAAQ,IAAI,oBAAoB,OAAO,OAAO,KAAK,aAAa,EAAE,QAAQ;AAEhF,WAAO,GAAG,QAAQ,wBAAwB,SAAS,CAAC,GAAG,QAAQ,oBAAoB,KAAK,CAAC,CAAC;AAAA,EAC5F;AAAA,EAEA,YAAY,EAAE,sBAAsB,WAAW,GAAwB;AACrE,QAAI;AAEJ,QAAI,OAAO,eAAe,WAAW;AACnC,YAAM,QAAQ,IAAI,oBAAoB,YAAY,KAAK,aAAa,EAAE,QAAQ;AAC9E,uBAAiB,GAAG,QAAQ,oBAAoB,KAAK;AAAA,IACvD,OAAO;AACL,uBAAiB,GAAG,QAAQ,sBAAsB,GAAG,WAAW,cAAc;AAAA,IAChF;AAEA,WAAO,GAAG,QAAQ,wBAAwB,UAAU;AAAA,MAClD,GAAG,QAAQ,sBAAsB,GAAG,WAAW,aAAa;AAAA,MAC5D;AAAA,IACF,CAAC;AAAA,EACH;AAAA,EAEA,kBAAkB,QAAmC;AACnD,UAAM,EAAE,SAAS,MAAM,IAAI,KAAK;AAEhC,UAAM,YAAY,kCAAkC,MAAM;AAC1D,UAAM,OAAO,MAAM,mBAAmB,6BAA6B,MAAM,CAAC;AAE1E,UAAM,aAAa,QAAQ,QAAQ,cAAc,IAAI,KAAK,QAAQ,QAAQ,IAAI,MAAM,WAAW,IAAI;AAEnG,WAAO,GAAG,QAAQ,wBAAwB,UAAU;AAAA,EACtD;AACF;",
+  "names": []
+}

package/index.d.ts

@@ -0,0 +1,14 @@
+import Plugin from '@vaadin/hilla-generator-core/Plugin.js';
+import type SharedStorage from '@vaadin/hilla-generator-core/SharedStorage.js';
+export declare enum BackbonePluginSourceType {
+    Endpoint = "endpoint",
+    Entity = "entity"
+}
+export default class BackbonePlugin extends Plugin {
+    #private;
+    static readonly BACKBONE_PLUGIN_FILE_TAGS = "BACKBONE_PLUGIN_FILE_TAGS";
+    ['constructor']: typeof BackbonePlugin;
+    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,wBAAwB;IAClC,QAAQ,aAAa;IACrB,MAAM,WAAW;CAClB;AAED,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,MAAM;;IAChD,MAAM,CAAC,QAAQ,CAAC,yBAAyB,+BAA+B;IAChE,CAAC,aAAa,CAAC,EAAE,OAAO,cAAc,CAAC;IAG/C,IAAa,IAAI,IAAI,MAAM,CAE1B;IAEc,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;CAkD9D"}

package/index.js

@@ -0,0 +1,55 @@
+import Plugin from "@vaadin/hilla-generator-core/Plugin.js";
+import EndpointProcessor from "./EndpointProcessor.js";
+import { EntityProcessor } from "./EntityProcessor.js";
+var BackbonePluginSourceType = /* @__PURE__ */ ((BackbonePluginSourceType2) => {
+  BackbonePluginSourceType2["Endpoint"] = "endpoint";
+  BackbonePluginSourceType2["Entity"] = "entity";
+  return BackbonePluginSourceType2;
+})(BackbonePluginSourceType || {});
+class BackbonePlugin extends Plugin {
+  static BACKBONE_PLUGIN_FILE_TAGS = "BACKBONE_PLUGIN_FILE_TAGS";
+  #tags = /* @__PURE__ */ new WeakMap();
+  get path() {
+    return import.meta.url;
+  }
+  async execute(storage) {
+    const endpointSourceFiles = await this.#processEndpoints(storage);
+    const entitySourceFiles = this.#processEntities(storage);
+    endpointSourceFiles.forEach((file) => this.#tags.set(file, "endpoint" /* Endpoint */));
+    entitySourceFiles.forEach((file) => this.#tags.set(file, "entity" /* Entity */));
+    storage.sources.push(...endpointSourceFiles, ...entitySourceFiles);
+    storage.pluginStorage.set(this.constructor.BACKBONE_PLUGIN_FILE_TAGS, this.#tags);
+  }
+  async #processEndpoints(storage) {
+    this.logger.debug("Processing endpoints");
+    const endpoints = /* @__PURE__ */ new Map();
+    Object.entries(storage.api.paths).filter(([, pathItem]) => !!pathItem).forEach(([path, pathItem]) => {
+      const [, endpointName, endpointMethodName] = path.split("/");
+      let methods;
+      if (endpoints.has(endpointName)) {
+        methods = endpoints.get(endpointName);
+      } else {
+        methods = /* @__PURE__ */ new Map();
+        endpoints.set(endpointName, methods);
+      }
+      methods.set(endpointMethodName, pathItem);
+    });
+    const processors = await Promise.all(
+      [...endpoints.entries()].map(
+        async ([endpointName, methods]) => EndpointProcessor.create(endpointName, this, methods, storage.outputDir)
+      )
+    );
+    return Promise.all(processors.map(async (processor) => processor.process()));
+  }
+  #processEntities(storage) {
+    this.logger.debug("Processing entities");
+    return storage.api.components?.schemas ? Object.entries(storage.api.components.schemas).map(
+      ([name, component]) => new EntityProcessor(name, component, this).process()
+    ) : [];
+  }
+}
+export {
+  BackbonePluginSourceType,
+  BackbonePlugin 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 EndpointProcessor from './EndpointProcessor.js';\nimport { EntityProcessor } from './EntityProcessor.js';\n\nexport enum BackbonePluginSourceType {\n  Endpoint = 'endpoint',\n  Entity = 'entity',\n}\n\nexport default class BackbonePlugin extends Plugin {\n  static readonly BACKBONE_PLUGIN_FILE_TAGS = 'BACKBONE_PLUGIN_FILE_TAGS';\n  declare ['constructor']: typeof BackbonePlugin;\n  readonly #tags = new WeakMap<SourceFile, BackbonePluginSourceType>();\n\n  override get path(): string {\n    return import.meta.url;\n  }\n\n  override async execute(storage: SharedStorage): Promise<void> {\n    const endpointSourceFiles = await this.#processEndpoints(storage);\n    const entitySourceFiles = this.#processEntities(storage);\n\n    endpointSourceFiles.forEach((file) => this.#tags.set(file, BackbonePluginSourceType.Endpoint));\n    entitySourceFiles.forEach((file) => this.#tags.set(file, BackbonePluginSourceType.Entity));\n\n    storage.sources.push(...endpointSourceFiles, ...entitySourceFiles);\n    storage.pluginStorage.set(this.constructor.BACKBONE_PLUGIN_FILE_TAGS, this.#tags);\n  }\n\n  async #processEndpoints(storage: SharedStorage): Promise<readonly SourceFile[]> {\n    this.logger.debug('Processing endpoints');\n    const endpoints = new Map<string, Map<string, ReadonlyDeep<OpenAPIV3.PathItemObject>>>();\n\n    Object.entries(storage.api.paths)\n      .filter(([, pathItem]) => !!pathItem)\n      .forEach(([path, pathItem]) => {\n        const [, endpointName, endpointMethodName] = path.split('/');\n\n        let methods: Map<string, ReadonlyDeep<OpenAPIV3.PathItemObject>>;\n\n        if (endpoints.has(endpointName)) {\n          methods = endpoints.get(endpointName)!;\n        } else {\n          methods = new Map();\n          endpoints.set(endpointName, methods);\n        }\n\n        methods.set(endpointMethodName, pathItem!);\n      });\n\n    const processors = await Promise.all(\n      [...endpoints.entries()].map(async ([endpointName, methods]) =>\n        EndpointProcessor.create(endpointName, this, methods, storage.outputDir),\n      ),\n    );\n\n    return Promise.all(processors.map(async (processor) => processor.process()));\n  }\n\n  #processEntities(storage: SharedStorage): readonly SourceFile[] {\n    this.logger.debug('Processing entities');\n\n    return storage.api.components?.schemas\n      ? Object.entries(storage.api.components.schemas).map(([name, component]) =>\n          new EntityProcessor(name, component, this).process(),\n        )\n      : [];\n  }\n}\n"],
+  "mappings": "AAAA,OAAO,YAAY;AAKnB,OAAO,uBAAuB;AAC9B,SAAS,uBAAuB;AAEzB,IAAK,2BAAL,kBAAKA,8BAAL;AACL,EAAAA,0BAAA,cAAW;AACX,EAAAA,0BAAA,YAAS;AAFC,SAAAA;AAAA,GAAA;AAKZ,MAAO,uBAAqC,OAAO;AAAA,EACjD,OAAgB,4BAA4B;AAAA,EAEnC,QAAQ,oBAAI,QAA8C;AAAA,EAEnE,IAAa,OAAe;AAC1B,WAAO,YAAY;AAAA,EACrB;AAAA,EAEA,MAAe,QAAQ,SAAuC;AAC5D,UAAM,sBAAsB,MAAM,KAAK,kBAAkB,OAAO;AAChE,UAAM,oBAAoB,KAAK,iBAAiB,OAAO;AAEvD,wBAAoB,QAAQ,CAAC,SAAS,KAAK,MAAM,IAAI,MAAM,yBAAiC,CAAC;AAC7F,sBAAkB,QAAQ,CAAC,SAAS,KAAK,MAAM,IAAI,MAAM,qBAA+B,CAAC;AAEzF,YAAQ,QAAQ,KAAK,GAAG,qBAAqB,GAAG,iBAAiB;AACjE,YAAQ,cAAc,IAAI,KAAK,YAAY,2BAA2B,KAAK,KAAK;AAAA,EAClF;AAAA,EAEA,MAAM,kBAAkB,SAAwD;AAC9E,SAAK,OAAO,MAAM,sBAAsB;AACxC,UAAM,YAAY,oBAAI,IAAiE;AAEvF,WAAO,QAAQ,QAAQ,IAAI,KAAK,EAC7B,OAAO,CAAC,CAAC,EAAE,QAAQ,MAAM,CAAC,CAAC,QAAQ,EACnC,QAAQ,CAAC,CAAC,MAAM,QAAQ,MAAM;AAC7B,YAAM,CAAC,EAAE,cAAc,kBAAkB,IAAI,KAAK,MAAM,GAAG;AAE3D,UAAI;AAEJ,UAAI,UAAU,IAAI,YAAY,GAAG;AAC/B,kBAAU,UAAU,IAAI,YAAY;AAAA,MACtC,OAAO;AACL,kBAAU,oBAAI,IAAI;AAClB,kBAAU,IAAI,cAAc,OAAO;AAAA,MACrC;AAEA,cAAQ,IAAI,oBAAoB,QAAS;AAAA,IAC3C,CAAC;AAEH,UAAM,aAAa,MAAM,QAAQ;AAAA,MAC/B,CAAC,GAAG,UAAU,QAAQ,CAAC,EAAE;AAAA,QAAI,OAAO,CAAC,cAAc,OAAO,MACxD,kBAAkB,OAAO,cAAc,MAAM,SAAS,QAAQ,SAAS;AAAA,MACzE;AAAA,IACF;AAEA,WAAO,QAAQ,IAAI,WAAW,IAAI,OAAO,cAAc,UAAU,QAAQ,CAAC,CAAC;AAAA,EAC7E;AAAA,EAEA,iBAAiB,SAA+C;AAC9D,SAAK,OAAO,MAAM,qBAAqB;AAEvC,WAAO,QAAQ,IAAI,YAAY,UAC3B,OAAO,QAAQ,QAAQ,IAAI,WAAW,OAAO,EAAE;AAAA,MAAI,CAAC,CAAC,MAAM,SAAS,MAClE,IAAI,gBAAgB,MAAM,WAAW,IAAI,EAAE,QAAQ;AAAA,IACrD,IACA,CAAC;AAAA,EACP;AACF;",
+  "names": ["BackbonePluginSourceType"]
+}

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "@vaadin/hilla-generator-plugin-backbone",
+  "version": "24.4.0-alpha1",
+  "description": "A Hilla TypeScript Generator plugin to generate basic code",
+  "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-backbone"
+  },
+  "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-generator-core": "24.4.0-alpha1",
+    "@vaadin/hilla-generator-plugin-client": "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,2 @@
+export declare const defaultMediaType = "application/json";
+//# 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,eAAO,MAAM,gBAAgB,qBAAqB,CAAC"}

package/utils.js

@@ -0,0 +1,5 @@
+const defaultMediaType = "application/json";
+export {
+  defaultMediaType
+};
+//# sourceMappingURL=utils.js.map

package/utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["src/utils.ts"],
+  "sourcesContent": ["export const defaultMediaType = 'application/json';\n"],
+  "mappings": "AAAO,MAAM,mBAAmB;",
+  "names": []
+}