generator-jhipster 8.7.0 → 8.7.1

package/dist/lib/jdl/core/parsing/lexer/lexer.js

@@ -0,0 +1,137 @@
+/**
+ * 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 { Lexer } from 'chevrotain';
+import { relationshipOptions } from '../../built-in-options/index.js';
+import { BINARY_OPTION, NAME, UNARY_OPTION } from './shared-tokens.js';
+import ValidationTokens from './validation-tokens.js';
+import RelationshipTypeTokens from './relationship-type-tokens.js';
+import OptionTokens from './option-tokens.js';
+import createTokenFromConfigCreator from './token-creator.js';
+export const buildTokens = (tokens) => {
+    const { applicationTokens, deploymentTokens } = tokens;
+    const _tokens = {};
+    const { BUILT_IN_ENTITY } = relationshipOptions;
+    function createTokenFromConfig(config) {
+        const newToken = createTokenFromConfigCreator(config);
+        _tokens[config.name] = newToken;
+        return newToken;
+    }
+    // Some categories to make the grammar easier to read
+    const BOOLEAN = createTokenFromConfig({
+        name: 'BOOLEAN',
+        pattern: Lexer.NA,
+    });
+    // Category for the Application Configuration key names
+    const CONFIG_KEY = applicationTokens.categoryToken;
+    // Category For the Application deployment key names
+    const DEPLOYMENT_KEY = deploymentTokens.categoryToken;
+    createTokenFromConfig({
+        name: 'WHITESPACE',
+        pattern: /[\n\t\r \u2028\u2029]+/,
+        // Whitespace insensitivity for the win.
+        group: Lexer.SKIPPED,
+    });
+    // Comments
+    createTokenFromConfig({
+        name: 'JAVADOC',
+        pattern: /\/\*\*([\s\S]*?)\*\//,
+    });
+    // Comments
+    createTokenFromConfig({
+        name: 'BLOCK_COMMENT',
+        pattern: /\/\*([\s\S]*?)\*\//,
+        group: Lexer.SKIPPED,
+    });
+    // Constants
+    // Application constants
+    createTokenFromConfig({ name: 'CONFIG', pattern: 'config' });
+    createTokenFromConfig({ name: 'ENTITIES', pattern: 'entities' });
+    applicationTokens.tokens.forEach(token => {
+        _tokens[token.name] = token;
+    });
+    // application must appear AFTER "applicationType" due to shorter common prefix.
+    createTokenFromConfig({ name: 'APPLICATION', pattern: 'application' });
+    // this is used in application config and deployment
+    createTokenFromConfig({
+        name: 'SERVICE_DISCOVERY_TYPE',
+        pattern: 'serviceDiscoveryType',
+        categories: [CONFIG_KEY, DEPLOYMENT_KEY],
+    });
+    deploymentTokens.tokens.forEach(token => {
+        _tokens[token.name] = token;
+    });
+    createTokenFromConfig({ name: 'DEPLOYMENT', pattern: 'deployment' });
+    // boolean value constants
+    createTokenFromConfig({ name: 'TRUE', pattern: 'true', categories: [BOOLEAN] });
+    createTokenFromConfig({ name: 'FALSE', pattern: 'false', categories: [BOOLEAN] });
+    // Entity constants
+    createTokenFromConfig({ name: 'ENTITY', pattern: 'entity' });
+    createTokenFromConfig({ name: 'ENUM', pattern: 'enum' });
+    // Relationship-related
+    createTokenFromConfig({ name: 'RELATIONSHIP', pattern: 'relationship' });
+    createTokenFromConfig({ name: 'BUILT_IN_ENTITY', pattern: BUILT_IN_ENTITY });
+    // Category For the relationship type key names
+    RelationshipTypeTokens.tokens.forEach(token => {
+        _tokens[token.name] = token;
+    });
+    createTokenFromConfig({ name: 'STAR', pattern: '*' });
+    // Options
+    OptionTokens.tokens.forEach(token => {
+        _tokens[token.name] = token;
+    });
+    // validations
+    ValidationTokens.tokens.forEach(token => {
+        _tokens[token.name] = token;
+    });
+    createTokenFromConfig({ name: 'REGEX', pattern: /\/[^\n\r]*\// });
+    createTokenFromConfig({ name: 'DECIMAL', pattern: /-?\d+\.\d+/ });
+    createTokenFromConfig({ name: 'INTEGER', pattern: /-?\d+/ });
+    // No escaping, no unicode, just a plain string literal
+    createTokenFromConfig({ name: 'STRING', pattern: /"(?:[^"])*"/ });
+    // punctuation
+    createTokenFromConfig({ name: 'LPAREN', pattern: '(' });
+    createTokenFromConfig({ name: 'RPAREN', pattern: ')' });
+    createTokenFromConfig({ name: 'LCURLY', pattern: '{' });
+    createTokenFromConfig({ name: 'RCURLY', pattern: '}' });
+    createTokenFromConfig({ name: 'LSQUARE', pattern: '[' });
+    createTokenFromConfig({ name: 'RSQUARE', pattern: ']' });
+    createTokenFromConfig({ name: 'COMMA', pattern: ',' });
+    createTokenFromConfig({ name: 'COMMA_WITHOUT_NEWLINE', pattern: /,[^\n\r]/ });
+    createTokenFromConfig({ name: 'EQUALS', pattern: '=' });
+    createTokenFromConfig({ name: 'DOT', pattern: '.' });
+    createTokenFromConfig({ name: 'TO', pattern: 'to' });
+    // annotations
+    createTokenFromConfig({ name: 'AT', pattern: '@' });
+    const typedTokens = {
+        UNARY_OPTION,
+        BINARY_OPTION,
+        // Imperative the "NAME" token will be added after all the keywords to resolve keywords vs identifier conflict.
+        NAME,
+    };
+    return {
+        ..._tokens,
+        ...typedTokens,
+    };
+};
+// with 'ensureOptimizations' the lexer initialization will throw a descriptive error
+// instead of silently reverting to an unoptimized algorithm.
+// This will avoid performance regressions.
+export const createJDLLexer = (tokens) => {
+    return new Lexer(Object.values(tokens), { ensureOptimizations: true });
+};

package/dist/lib/jdl/core/parsing/lexer/token-creator.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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 { ITokenConfig } from 'chevrotain';
+export default function createTokenFromConfig(config: ITokenConfig): import("chevrotain").TokenType;

package/dist/lib/jdl/core/parsing/self-checks/token-collector-visitor.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 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 { Alternation, Alternative, NonTerminal, Option, Repetition, RepetitionMandatory, Rule } from 'chevrotain';
+import { GAstVisitor } from 'chevrotain';
+export default class TokenCollectorVisitor extends GAstVisitor {
+    visitNonTerminal(_node: NonTerminal): void;
+    visitAlternative(_node: Alternative): void;
+    visitOption(_node: Option): void;
+    visitRepetition(_node: Repetition): void;
+    visitRepetitionMandatory(_node: RepetitionMandatory): void;
+    visitAlternation(_node: Alternation): void;
+    visitRule(_node: Rule): void;
+    actualTokens: any[];
+    constructor();
+    visitTerminal(node: any): void;
+    visitRepetitionMandatoryWithSeparator(node: any): void;
+    visitRepetitionWithSeparator(node: any): void;
+}

package/dist/lib/jdl/core/parsing/validator.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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';
+export default function performAdditionalSyntaxChecks(cst: any, runtime: JDLRuntime): any[];

package/dist/lib/jdl/core/parsing/validator.js

@@ -0,0 +1,372 @@
+/**
+ * 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.
+ */
+/* eslint-disable no-useless-escape */
+import { first, flatten, includes, values } from 'lodash-es';
+import { tokenMatcher as matchesToken } from 'chevrotain';
+import { ALPHABETIC, ALPHABETIC_DASH_LOWER, ALPHABETIC_LOWER, ALPHANUMERIC, ALPHANUMERIC_DASH, ALPHANUMERIC_SPACE, ALPHANUMERIC_UNDERSCORE, } from '../built-in-options/validation-patterns.js';
+const CONSTANT_PATTERN = /^[A-Z_]+$/;
+const ENTITY_NAME_PATTERN = /^[A-Z][A-Za-z0-9]*$/;
+const TYPE_NAME_PATTERN = /^[A-Z][A-Za-z0-9]*$/;
+const ENUM_NAME_PATTERN = /^[A-Z][A-Za-z0-9]*$/;
+const ENUM_PROP_NAME_PATTERN = /^[A-Z][A-Za-z0-9_]*$/;
+const ENUM_PROP_VALUE_PATTERN = /^[A-Za-z][A-Za-z0-9_]*$/;
+const METHOD_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9-_]*$/;
+// const PASSWORD_PATTERN = /^(.+)$/;
+const REPONAME_PATTERN = /^"((?:http(s)?:\/\/)?[\w.-]+(?:\.[\w.-]+)+[\w\-._~:\/?#[\]@!$&'()*+,;=]+|[a-zA-Z0-9]+)"$/;
+const KUBERNETES_STORAGE_CLASS_NAME = /^"[A-Za-z]*"$/;
+const PATH_PATTERN = /^"([^\/]+).*"$/;
+const deploymentConfigPropsValidations = {
+    DEPLOYMENT_TYPE: {
+        type: 'NAME',
+        pattern: ALPHABETIC_DASH_LOWER,
+        msg: 'deploymentType property',
+    },
+    GATEWAY_TYPE: {
+        type: 'NAME',
+        pattern: ALPHABETIC,
+        msg: 'gatewayType property',
+    },
+    MONITORING: {
+        type: 'NAME',
+        pattern: ALPHABETIC_LOWER,
+        msg: 'monitoring property',
+    },
+    DIRECTORY_PATH: {
+        type: 'STRING',
+        pattern: PATH_PATTERN,
+        msg: 'directoryPath property',
+    },
+    APPS_FOLDERS: {
+        type: 'list',
+        pattern: ALPHANUMERIC_UNDERSCORE,
+        msg: 'appsFolders property',
+    },
+    CLUSTERED_DB_APPS: {
+        type: 'list',
+        pattern: ALPHANUMERIC,
+        msg: 'clusteredDbApps property',
+    },
+    // This is not secure, need to find a better way
+    /*   ADMIN_PASSWORD: {
+      type: 'STRING',
+      pattern: PASSWORD_PATTERN,
+      msg: 'adminPassword property'
+    }, */
+    SERVICE_DISCOVERY_TYPE: {
+        type: 'NAME',
+        pattern: ALPHABETIC_LOWER,
+        msg: 'serviceDiscoveryType property',
+    },
+    DOCKER_REPOSITORY_NAME: {
+        type: 'STRING',
+        pattern: REPONAME_PATTERN,
+        msg: 'dockerRepositoryName property',
+    },
+    DOCKER_PUSH_COMMAND: {
+        type: 'STRING',
+        pattern: ALPHANUMERIC_SPACE,
+        msg: 'dockerPushCommand property',
+    },
+    KUBERNETES_NAMESPACE: {
+        type: 'NAME',
+        pattern: ALPHANUMERIC_DASH,
+        msg: 'kubernetesNamespace property',
+    },
+    KUBERNETES_SERVICE_TYPE: {
+        type: 'NAME',
+        pattern: ALPHABETIC,
+        msg: 'kubernetesServiceType property',
+    },
+    KUBERNETES_STORAGE_CLASS_NAME: {
+        type: 'STRING',
+        pattern: KUBERNETES_STORAGE_CLASS_NAME,
+        msg: 'kubernetesStorageClassName property',
+    },
+    KUBERNETES_USE_DYNAMIC_STORAGE: { type: 'BOOLEAN' },
+    INGRESS_DOMAIN: {
+        type: 'STRING',
+        pattern: REPONAME_PATTERN,
+        msg: 'ingressDomain property',
+    },
+    INGRESS_TYPE: {
+        type: 'NAME',
+        pattern: ALPHABETIC,
+        msg: 'ingressType property',
+    },
+    ISTIO: {
+        type: 'BOOLEAN',
+        msg: 'istio property',
+    },
+    REGISTRY_REPLICAS: { type: 'INTEGER' },
+    STORAGE_TYPE: {
+        type: 'NAME',
+        pattern: ALPHABETIC_LOWER,
+        msg: 'storageType property',
+    },
+};
+export default function performAdditionalSyntaxChecks(cst, runtime) {
+    const parser = runtime.parser;
+    parser.parse();
+    const BaseJDLCSTVisitorWithDefaults = parser.getBaseCstVisitorConstructorWithDefaults();
+    class JDLSyntaxValidatorVisitor extends BaseJDLCSTVisitorWithDefaults {
+        errors;
+        tokens;
+        constructor(runtime) {
+            super();
+            this.tokens = runtime.tokens;
+            this.validateVisitor();
+            this.errors = [];
+        }
+        validateVisitor() { }
+        checkNameSyntax(token, expectedPattern, errorMessagePrefix) {
+            if (!expectedPattern.test(token.image)) {
+                this.errors.push({
+                    message: `The ${errorMessagePrefix} name must match: ${trimAnchors(expectedPattern.toString())}, got ${token.image}.`,
+                    token,
+                });
+            }
+        }
+        checkIsSingleName(fqnCstNode) {
+            // A Boolean is allowed as a single name as it is a keyword.
+            // Other keywords do not need special handling as they do not explicitly appear in the rule
+            // of config values
+            if (fqnCstNode.tokenType?.CATEGORIES.includes(this.tokens.BOOLEAN)) {
+                return false;
+            }
+            const dots = fqnCstNode.children.DOT;
+            if (dots && dots.length >= 1) {
+                this.errors.push({
+                    message: 'A single name is expected, but found a fully qualified name.',
+                    token: getFirstToken(fqnCstNode),
+                });
+                return false;
+            }
+            return true;
+        }
+        checkExpectedValueType(expected, actual) {
+            switch (expected) {
+                case 'NAME':
+                    if (actual.name !== 'qualifiedName' &&
+                        // a Boolean (true/false) is also a valid name.
+                        actual.tokenType &&
+                        !includes(actual.tokenType.CATEGORIES, this.tokens.BOOLEAN)) {
+                        this.errors.push({
+                            message: `A name is expected, but found: "${getFirstToken(actual).image}"`,
+                            token: getFirstToken(actual),
+                        });
+                        return false;
+                    }
+                    return this.checkIsSingleName(actual);
+                case 'qualifiedName':
+                    if (actual.name !== 'qualifiedName') {
+                        this.errors.push({
+                            message: `A fully qualified name is expected, but found: "${getFirstToken(actual).image}"`,
+                            token: getFirstToken(actual),
+                        });
+                        return false;
+                    }
+                    return true;
+                case 'list':
+                    if (actual.name !== 'list') {
+                        this.errors.push({
+                            message: `An array of names is expected, but found: "${getFirstToken(actual).image}"`,
+                            token: getFirstToken(actual),
+                        });
+                        return false;
+                    }
+                    return true;
+                case 'quotedList':
+                    if (actual.name !== 'quotedList') {
+                        this.errors.push({
+                            message: `An array of names is expected, but found: "${getFirstToken(actual).image}"`,
+                            token: getFirstToken(actual),
+                        });
+                        return false;
+                    }
+                    return true;
+                case 'INTEGER':
+                    if (actual.tokenType !== this.tokens.INTEGER) {
+                        this.errors.push({
+                            message: `An integer literal is expected, but found: "${getFirstToken(actual).image}"`,
+                            token: getFirstToken(actual),
+                        });
+                        return false;
+                    }
+                    return true;
+                case 'STRING':
+                    if (actual.tokenType !== this.tokens.STRING) {
+                        this.errors.push({
+                            message: `A string literal is expected, but found: "${getFirstToken(actual).image}"`,
+                            token: getFirstToken(actual),
+                        });
+                        return false;
+                    }
+                    return true;
+                case 'BOOLEAN':
+                    if (!matchesToken(actual, this.tokens.BOOLEAN)) {
+                        this.errors.push({
+                            message: `A boolean literal is expected, but found: "${getFirstToken(actual).image}"`,
+                            token: getFirstToken(actual),
+                        });
+                        return false;
+                    }
+                    return true;
+                default:
+                    throw Error(`Expected a boolean, a string, an integer, a list or a (qualified) name, got '${expected}'.`);
+            }
+        }
+        checkConfigPropSyntax(key, value) {
+            const propertyName = key.tokenType.name;
+            const validation = runtime.propertyValidations[propertyName];
+            if (!validation) {
+                throw Error(`Got an invalid application config property: '${propertyName}'.`);
+            }
+            if (this.checkExpectedValueType(validation.type, value) && validation.pattern && value.children) {
+                if (value.children.NAME) {
+                    value.children.NAME.forEach(nameTok => this.checkNameSyntax(nameTok, validation.pattern, validation.msg));
+                }
+                if (value.children.STRING) {
+                    value.children.STRING.forEach(nameTok => this.checkNameSyntax(nameTok, validation.pattern, validation.msg));
+                }
+            }
+        }
+        checkDeploymentConfigPropSyntax(key, value) {
+            const propertyName = key.tokenType.name;
+            const validation = deploymentConfigPropsValidations[propertyName];
+            if (!validation) {
+                throw Error(`Got an invalid deployment config property: '${propertyName}'.`);
+            }
+            if (this.checkExpectedValueType(validation.type, value) && validation.pattern && value.children?.NAME) {
+                value.children.NAME.forEach(nameTok => this.checkNameSyntax(nameTok, validation.pattern, validation.msg));
+            }
+            else if (value.image && validation.pattern) {
+                this.checkNameSyntax(value, validation.pattern, validation.msg);
+            }
+        }
+        constantDeclaration(context) {
+            super.constantDeclaration(context);
+            this.checkNameSyntax(context.NAME[0], CONSTANT_PATTERN, 'constant');
+        }
+        entityDeclaration(context) {
+            super.entityDeclaration(context);
+            this.checkNameSyntax(context.NAME[0], ENTITY_NAME_PATTERN, 'entity');
+        }
+        fieldDeclaration(context) {
+            super.fieldDeclaration(context);
+            this.checkNameSyntax(context.NAME[0], ALPHANUMERIC, 'fieldName');
+        }
+        type(context) {
+            super.type(context);
+            this.checkNameSyntax(context.NAME[0], TYPE_NAME_PATTERN, 'typeName');
+        }
+        minMaxValidation(context) {
+            super.minMaxValidation(context);
+            if (context.NAME) {
+                this.checkNameSyntax(context.NAME[0], CONSTANT_PATTERN, 'constant');
+            }
+        }
+        relationshipSide(context) {
+            super.relationshipSide(context);
+            this.checkNameSyntax(context.NAME[0], ENTITY_NAME_PATTERN, 'entity');
+            if (Array.isArray(context.injectedField)) {
+                this.checkNameSyntax(context.injectedField[0], ALPHANUMERIC, 'injectedField');
+                if (context.injectedFieldParam) {
+                    this.checkNameSyntax(context.injectedFieldParam[0], ALPHANUMERIC, 'injectedField');
+                }
+            }
+        }
+        enumDeclaration(context) {
+            super.enumDeclaration(context);
+            this.checkNameSyntax(context.NAME[0], ENUM_NAME_PATTERN, 'enum');
+        }
+        enumPropList(context) {
+            super.enumPropList(context);
+            context.enumProp.forEach(nameToken => {
+                const propKey = nameToken.children.enumPropKey[0];
+                this.checkNameSyntax(propKey, ENUM_PROP_NAME_PATTERN, 'enum property name');
+                const propValue = nameToken.children.enumPropValue;
+                if (propValue) {
+                    this.checkNameSyntax(propValue[0], ENUM_PROP_VALUE_PATTERN, 'enum property value');
+                }
+            });
+        }
+        entityList(context) {
+            super.entityList(context);
+            if (context.NAME) {
+                context.NAME.forEach(nameToken => {
+                    // we don't want this validated as it's an alias for '*'
+                    if (nameToken.image === 'all') {
+                        return;
+                    }
+                    this.checkNameSyntax(nameToken, ENTITY_NAME_PATTERN, 'entity');
+                });
+            }
+            if (context.method) {
+                this.checkNameSyntax(context.method[0], METHOD_NAME_PATTERN, 'method');
+            }
+            if (context.methodPath) {
+                this.checkNameSyntax(context.methodPath[0], PATH_PATTERN, 'methodPath');
+            }
+        }
+        exclusion(context) {
+            super.exclusion(context);
+            context.NAME.forEach(nameToken => {
+                this.checkNameSyntax(nameToken, ENTITY_NAME_PATTERN, 'entity');
+            });
+        }
+        filterDef(context) {
+            if (context.NAME) {
+                context.NAME.forEach(nameToken => {
+                    // we don't want this validated as it's an alias for '*'
+                    if (nameToken.image === 'all') {
+                        return;
+                    }
+                    this.checkNameSyntax(nameToken, ENTITY_NAME_PATTERN, 'entity');
+                });
+            }
+        }
+        applicationConfigDeclaration(context) {
+            this.visit(context.configValue, context.CONFIG_KEY[0]);
+        }
+        configValue(context, configKey) {
+            const configValue = first(first(Object.values(context)));
+            this.checkConfigPropSyntax(configKey, configValue);
+        }
+        deploymentConfigDeclaration(context) {
+            this.visit(context.deploymentConfigValue, context.DEPLOYMENT_KEY[0]);
+        }
+        deploymentConfigValue(context, configKey) {
+            const configValue = first(first(values(context)));
+            this.checkDeploymentConfigPropSyntax(configKey, configValue);
+        }
+    }
+    const syntaxValidatorVisitor = new JDLSyntaxValidatorVisitor(runtime);
+    syntaxValidatorVisitor.visit(cst);
+    return syntaxValidatorVisitor.errors;
+}
+function trimAnchors(str) {
+    return str.replace(/^\^/, '').replace(/\$$/, '');
+}
+function getFirstToken(tokOrCstNode) {
+    if (tokOrCstNode.tokenType) {
+        return tokOrCstNode;
+    }
+    // CST Node - - assumes no nested CST Nodes, only terminals
+    return flatten(Object.values(tokOrCstNode.children)).reduce((firstTok, nextTok) => (firstTok.startOffset > nextTok.startOffset ? nextTok : firstTok), { startOffset: Infinity });
+}

package/dist/lib/jdl/core/readers/jdl-reader.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 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';
+/**
+ * Parses the given files and returns the resulting intermediate object.
+ * If one file is passed, the file will be read and its parsed content returned.
+ * If more than one are passed, they will be assembled and only parsed once.
+ * @param files the files to parse.
+ * @returns {Object} the intermediate object.
+ */
+export declare function parseFromFiles(files: string[], runtime: JDLRuntime): any;
+/**
+ * Parses the given content and returns the resulting intermediate object.
+ * @param content the JDL content to parse.
+ * @returns {Object} the intermediate object.
+ */
+export declare function parseFromContent(content: string, runtime: JDLRuntime): any;
+export declare function getCstFromContent(content: string, runtime: JDLRuntime): any;
+/**
+ * Checks whether the given file is a JDL file, only from the extension.
+ * Doesn't return anything, but fails if the extension doesn't match.
+ * @param file the file to check.
+ */
+export declare function checkFileIsJDLFile(file: string): void;