generator-jhipster 8.7.0 → 8.7.1

package/dist/lib/jdl/core/linters/entity-linter.js

@@ -0,0 +1,85 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * 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
+ *
+ *      https://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.
+ */
+import { shouldWriteEntityTableName } from '../utils/entity-table-name-creator.js';
+import EntityIssue from './issues/entity-issue.js';
+import { rulesNames } from './rules.js';
+let issues;
+/**
+ * Check entities for lint issues.
+ * That is done by passing the list of entity declarations from the CST (from the JDLReader output).
+ * @param entityDeclarations - the list of entity declarations
+ * @return the found entity issues.
+ */
+export function checkEntities(entityDeclarations) {
+    if (!entityDeclarations) {
+        return [];
+    }
+    issues = [];
+    checkForDuplicatedEntities(entityDeclarations);
+    entityDeclarations.forEach(entityDeclaration => {
+        checkForUselessEntityBraces(entityDeclaration);
+        checkForUselessTableName(entityDeclaration);
+    });
+    return issues;
+}
+function checkForDuplicatedEntities(entityDeclarations) {
+    const entityNames = new Set();
+    const duplicatedEntityIssues = new Map(); // key: entityName, value: issue
+    entityDeclarations.forEach(entityDeclaration => {
+        const entityName = entityDeclaration.children.NAME[0].image;
+        if (entityNames.has(entityName)) {
+            if (!duplicatedEntityIssues.has(entityName)) {
+                duplicatedEntityIssues.set(entityName, new EntityIssue({
+                    ruleName: rulesNames.ENT_DUPLICATED,
+                    entityName,
+                }));
+            }
+        }
+        else {
+            entityNames.add(entityName);
+        }
+    });
+    duplicatedEntityIssues.forEach(issue => {
+        issues.push(issue);
+    });
+}
+function checkForUselessEntityBraces(entityDeclaration) {
+    const entityBody = entityDeclaration.children.entityBody;
+    const nextTokensAfterRelationshipType = entityBody?.[0].children;
+    const onlyCurlyBracesAsRelationshipBody = entityBody && Object.keys(nextTokensAfterRelationshipType).length === 2;
+    if (onlyCurlyBracesAsRelationshipBody) {
+        issues.push(new EntityIssue({
+            ruleName: rulesNames.ENT_SHORTER_DECL,
+            entityName: entityDeclaration.children.NAME[0].image,
+        }));
+    }
+}
+function checkForUselessTableName(entityDeclaration) {
+    const entityName = entityDeclaration.children.NAME[0].image;
+    const entityTableNameDeclaration = entityDeclaration.children.entityTableNameDeclaration;
+    if (entityTableNameDeclaration) {
+        const tableName = entityTableNameDeclaration[0].children.NAME[0].image;
+        if (!shouldWriteEntityTableName(entityName, tableName)) {
+            issues.push(new EntityIssue({
+                ruleName: rulesNames.ENT_OPTIONAL_TABLE_NAME,
+                entityName,
+            }));
+        }
+    }
+}

package/dist/lib/jdl/core/linters/enum-linter.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * 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
+ *
+ *      https://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.
+ */
+import EnumIssue from './issues/enum-issue.js';
+import type { FieldDeclaration } from './field-linter.js';
+export type EnumDeclaration = {
+    children: {
+        NAME: any[];
+    };
+};
+/**
+ * Check enums for lint issues.
+ * That is done by passing the list of enum declarations from the CST (from the JDLReader output).
+ * @param enumDeclarations - the list of enum declarations
+ * @param fieldDeclarations - the list of field declarations, to check for unused enums
+ * @return the found entity issues.
+ */
+export declare function checkEnums(enumDeclarations: EnumDeclaration[], fieldDeclarations: FieldDeclaration[]): EnumIssue[];

package/dist/lib/jdl/core/linters/issues/abstract-issue.js

@@ -0,0 +1,27 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * 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
+ *
+ *      https://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.
+ */
+export default class AbstractIssue {
+    ruleName;
+    constructor(args) {
+        if (!args?.ruleName) {
+            throw new Error('An issue must at least have a rule name.');
+        }
+        this.ruleName = args.ruleName;
+    }
+}

package/dist/lib/jdl/core/linters/issues/entity-issue.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * 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
+ *
+ *      https://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.
+ */
+import type { AbstractIssueArgs } from './abstract-issue.js';
+import AbstractIssue from './abstract-issue.js';
+type EntityIssueArgs = AbstractIssueArgs & {
+    entityName: string;
+};
+export default class EntityIssue extends AbstractIssue {
+    entityName: string;
+    constructor(args: EntityIssueArgs);
+}
+export {};

package/dist/lib/jdl/core/linters/issues/enum-issue.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * 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
+ *
+ *      https://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.
+ */
+import type { AbstractIssueArgs } from './abstract-issue.js';
+import AbstractIssue from './abstract-issue.js';
+type EntityIssueArgs = AbstractIssueArgs & {
+    enumName: string;
+};
+export default class EnumIssue extends AbstractIssue {
+    enumName: string;
+    constructor(args: EntityIssueArgs);
+}
+export {};

package/dist/lib/jdl/core/linters/issues/field-issue.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * 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
+ *
+ *      https://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.
+ */
+import type { AbstractIssueArgs } from './abstract-issue.js';
+import AbstractIssue from './abstract-issue.js';
+type FieldIssueArgs = AbstractIssueArgs & {
+    fieldName: string;
+    entityName: string;
+};
+export default class FieldIssue extends AbstractIssue {
+    entityName: string;
+    fieldName: string;
+    constructor(args: FieldIssueArgs);
+}
+export {};

package/dist/lib/jdl/core/linters/issues/issues.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * 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
+ *
+ *      https://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.
+ */
+import type EntityIssue from './entity-issue.js';
+import type FieldIssue from './field-issue.js';
+import type EnumIssue from './enum-issue.js';
+import type RelationshipIssue from './relationship-issue.js';
+export default class Issues {
+    entityIssues: EntityIssue[];
+    fieldIssues: FieldIssue[];
+    enumIssues: EnumIssue[];
+    relationshipIssues: RelationshipIssue[];
+    constructor();
+    addEntityIssues(issues?: EntityIssue[]): void;
+    addFieldIssues(issues?: FieldIssue[]): void;
+    addEnumIssues(issues?: EnumIssue[]): void;
+    addRelationshipIssues(issues?: RelationshipIssue[]): void;
+    getNumberOfIssues(): number;
+    getNumberOfEntityIssues(): number;
+    getNumberOfFieldIssues(): number;
+    getNumberOfEnumIssues(): number;
+    getNumberOfRelationshipIssues(): number;
+    getIssues(): {
+        entities: EntityIssue[];
+        enums: EnumIssue[];
+        fields: FieldIssue[];
+        relationships: RelationshipIssue[];
+    };
+}

package/dist/lib/jdl/core/linters/issues/relationship-issue.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * 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
+ *
+ *      https://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.
+ */
+import type { AbstractIssueArgs } from './abstract-issue.js';
+import AbstractIssue from './abstract-issue.js';
+type RelationshipIssueArgs = AbstractIssueArgs & {
+    from: string;
+    to: string;
+    type: string;
+};
+export default class RelationshipIssue extends AbstractIssue {
+    from: string;
+    to: string;
+    type: string;
+    constructor(args: RelationshipIssueArgs);
+}
+export {};

package/dist/lib/jdl/core/linters/jdl-linter.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * 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
+ *
+ *      https://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.
+ */
+import type { JDLRuntime } from '../types/runtime.js';
+import Issues from './issues/issues.js';
+export type JDLLinter = {
+    check: () => Issues;
+};
+/**
+ * Creates a new JDL linters from a JDL string content.
+ * @param jdlString - the JDL string content to lint.
+ * @return {Object} the JDL linters.
+ * @throws {Error} if the content isn't passed.
+ */
+export declare function createJDLLinterFromContent(jdlString: string, runtime: JDLRuntime): {
+    check: () => Issues;
+};

package/dist/lib/jdl/core/linters/jdl-linter.js

@@ -0,0 +1,98 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * 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
+ *
+ *      https://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.
+ */
+import { getCstFromContent } from '../readers/jdl-reader.js';
+import Issues from './issues/issues.js';
+import { checkEntities } from './entity-linter.js';
+import { checkFields } from './field-linter.js';
+import { checkEnums } from './enum-linter.js';
+import { checkRelationships } from './relationship-linter.js';
+/**
+ * Creates a new JDL linters from a JDL string content.
+ * @param jdlString - the JDL string content to lint.
+ * @return {Object} the JDL linters.
+ * @throws {Error} if the content isn't passed.
+ */
+export function createJDLLinterFromContent(jdlString, runtime) {
+    if (!jdlString) {
+        throw new Error('A JDL content must be passed to create a new JDL linter.');
+    }
+    return makeJDLLinter(jdlString, runtime);
+}
+let cst;
+let issues;
+function makeJDLLinter(content, runtime) {
+    cst = getCstFromContent(content, runtime);
+    issues = new Issues();
+    return {
+        check: () => {
+            checkForEntityDeclarationIssues();
+            checkForFieldDeclarationIssues();
+            checkForEnumDeclarationIssues();
+            checkForRelationshipIssues();
+            return issues;
+        },
+    };
+}
+function checkForEntityDeclarationIssues() {
+    const entityDeclarations = cst.children.entityDeclaration;
+    const entityIssues = checkEntities(entityDeclarations);
+    issues.addEntityIssues(entityIssues);
+}
+function checkForFieldDeclarationIssues() {
+    const entityDeclarations = cst.children.entityDeclaration;
+    if (!entityDeclarations) {
+        return;
+    }
+    entityDeclarations.forEach(entityDeclaration => {
+        const entityName = entityDeclaration.children.NAME[0].image;
+        const fieldDeclarations = getFieldDeclarationsFromEntity(entityDeclaration);
+        if (fieldDeclarations.length !== 0) {
+            const fieldIssues = checkFields(entityName, fieldDeclarations);
+            issues.addFieldIssues(fieldIssues);
+        }
+    });
+}
+function checkForEnumDeclarationIssues() {
+    const enumDeclarations = cst.children.enumDeclaration;
+    const entityDeclarations = cst.children.entityDeclaration;
+    const fieldDeclarations = getAllFieldDeclarations(entityDeclarations);
+    const enumIssues = checkEnums(enumDeclarations, fieldDeclarations);
+    issues.addEnumIssues(enumIssues);
+}
+function checkForRelationshipIssues() {
+    const relationshipDeclarations = cst.children.relationDeclaration;
+    const relationshipIssues = checkRelationships(relationshipDeclarations);
+    issues.addRelationshipIssues(relationshipIssues);
+}
+function getAllFieldDeclarations(entityDeclarations) {
+    if (!entityDeclarations) {
+        return [];
+    }
+    return entityDeclarations.reduce((fieldDeclarations, entityDeclaration) => {
+        return fieldDeclarations.concat(getFieldDeclarationsFromEntity(entityDeclaration));
+    }, []);
+}
+function getFieldDeclarationsFromEntity(entityDeclaration) {
+    const entityBody = entityDeclaration.children.entityBody;
+    const entityFields = entityBody?.[0].children.fieldDeclaration;
+    if (entityBody && entityFields) {
+        return entityFields;
+    }
+    return [];
+}

package/dist/lib/jdl/core/linters/relationship-linter.js

@@ -0,0 +1,65 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * 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
+ *
+ *      https://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.
+ */
+import { relationshipTypes } from '../basic-types/index.js';
+import RelationshipIssue from './issues/relationship-issue.js';
+import { rulesNames } from './rules.js';
+let issues;
+export default {
+    checkRelationships,
+};
+/**
+ * Check relationships for lint issues.
+ * That is done by passing the list of relationship declarations from the CST (from the JDLReader output).
+ * @param {Array} relationshipDeclarations - the list of relationship declarations
+ * @return the found relationship issues.
+ */
+export function checkRelationships(relationshipDeclarations) {
+    if (!relationshipDeclarations || relationshipDeclarations.length === 0) {
+        return [];
+    }
+    issues = [];
+    checkForCollapsibleRelationships(relationshipDeclarations);
+    return issues;
+}
+function checkForCollapsibleRelationships(relationshipDeclarations) {
+    const sortedRelationships = {
+        [relationshipTypes.ONE_TO_ONE]: [],
+        [relationshipTypes.ONE_TO_MANY]: [],
+        [relationshipTypes.MANY_TO_ONE]: [],
+        [relationshipTypes.MANY_TO_MANY]: [],
+    };
+    relationshipDeclarations.forEach((relationshipDeclaration) => {
+        const type = relationshipDeclaration.children.relationshipType[0].children.RELATIONSHIP_TYPE[0].image;
+        const from = relationshipDeclaration.children.relationshipBody[0].children.from[0].children.NAME[0].image;
+        const to = relationshipDeclaration.children.relationshipBody[0].children.to[0].children.NAME[0].image;
+        sortedRelationships[type].push({ from, to });
+    });
+    Object.keys(sortedRelationships).forEach(type => {
+        if (sortedRelationships[type].length > 1) {
+            sortedRelationships[type].forEach(relationship => {
+                issues.push(new RelationshipIssue({
+                    ruleName: rulesNames.REL_INDIVIDUAL_DECL,
+                    from: relationship.from,
+                    to: relationship.to,
+                    type,
+                }));
+            });
+        }
+    });
+}

package/dist/lib/jdl/core/linters/rule.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * 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
+ *
+ *      https://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.
+ */
+import type { RuleLevel } from './rule-levels.js';
+/**
+ * Represents a rule for the linters.
+ */
+export default class Rule {
+    name: any;
+    level: RuleLevel;
+    comment: any;
+    /**
+     * Creates a new rule from an arg object.
+     * @param args the argument object, keys:
+     *               - name: the rule's name
+     *               - level: the rule's level (INFO, WARNING, etc.), default: RuleLevels.INFO
+     *               - comment: a possible comment for the rule
+     */
+    constructor(args: {
+        name: any;
+        level: RuleLevel;
+        comment: any;
+    });
+    /**
+     * Compares this rule to another.
+     * @param otherRule the other rule.
+     * @returns 1 if this rule has a higher priority, 0 if they are equal, -1 otherwise.
+     */
+    compareTo(otherRule: Rule): number;
+}

package/dist/lib/jdl/core/linters/rule.js

@@ -0,0 +1,66 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * 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
+ *
+ *      https://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.
+ */
+import { merge } from '../utils/object-utils.js';
+import { INFO } from './rule-levels.js';
+/**
+ * Represents a rule for the linters.
+ */
+export default class Rule {
+    name;
+    level;
+    comment;
+    /**
+     * Creates a new rule from an arg object.
+     * @param args the argument object, keys:
+     *               - name: the rule's name
+     *               - level: the rule's level (INFO, WARNING, etc.), default: RuleLevels.INFO
+     *               - comment: a possible comment for the rule
+     */
+    constructor(args) {
+        if (!args?.name) {
+            throw new Error('A rule must at least have a name.');
+        }
+        const merged = merge(defaults(), args);
+        this.name = merged.name;
+        this.level = merged.level;
+        this.comment = merged.comment;
+    }
+    /**
+     * Compares this rule to another.
+     * @param otherRule the other rule.
+     * @returns 1 if this rule has a higher priority, 0 if they are equal, -1 otherwise.
+     */
+    compareTo(otherRule) {
+        if (!otherRule) {
+            throw new Error('A rule has to be passed so as to be compared.');
+        }
+        if (this.level.priority === otherRule.level.priority) {
+            return 0;
+        }
+        if (this.level.priority > otherRule.level.priority) {
+            return 1;
+        }
+        return -1;
+    }
+}
+function defaults() {
+    return {
+        level: INFO,
+    };
+}

package/dist/lib/jdl/core/matchers/entity-matcher.js

@@ -0,0 +1,3 @@
+export default function matchEntity(jdlEntity) {
+    return jdlEntity?.name && jdlEntity.fields;
+}

package/dist/lib/jdl/core/matchers/field-matcher.js

@@ -0,0 +1,3 @@
+export default function matchField(jdlField) {
+    return jdlField?.name && jdlField.type && jdlField.validations && jdlField.options;
+}

package/dist/lib/jdl/core/models/jdl-application-configuration-factory.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * 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
+ *
+ *      https://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.
+ */
+import type { JDLRuntime } from '../types/runtime.js';
+import JDLApplicationConfiguration from './jdl-application-configuration.js';
+export default function createApplicationConfigurationFromObject(configurationObject: {} | undefined, runtime: JDLRuntime): JDLApplicationConfiguration;
+export declare function createApplicationNamespaceConfigurationFromObject(parsedNamespaceConfigs: Record<string, Record<string, boolean | number | string[] | string>> | undefined, runtime: JDLRuntime): JDLApplicationConfiguration[];