generator-jhipster 8.7.0 → 8.7.1

package/dist/lib/jdl/core/readers/jdl-reader.js

@@ -0,0 +1,125 @@
+/**
+ * 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 { readFileSync } from 'fs';
+import logger from '../utils/objects/logger.js';
+import * as parser from '../parsing/api.js';
+import performJDLPostParsingTasks from '../parsing/jdl-post-parsing-tasks.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 function parseFromFiles(files, runtime) {
+    checkFiles(files);
+    checkAllTheFilesAreJDLFiles(files);
+    return parse(getFilesContent(files), runtime);
+}
+/**
+ * Parses the given content and returns the resulting intermediate object.
+ * @param content the JDL content to parse.
+ * @returns {Object} the intermediate object.
+ */
+export function parseFromContent(content, runtime) {
+    if (!content) {
+        throw new Error('A valid JDL content must be passed so as to be parsed.');
+    }
+    return parse(content, runtime);
+}
+export function getCstFromContent(content, runtime) {
+    return getCst(content, runtime);
+}
+function checkFiles(files) {
+    if (!files || files.length === 0) {
+        throw new Error('The files must be passed to be parsed.');
+    }
+}
+function getFilesContent(files) {
+    try {
+        return files.length === 1 ? readFileSync(files[0], 'utf-8') : aggregateFiles(files);
+    }
+    catch (error) {
+        throw new Error(`The passed file '${files[0]}' must exist and must not be a directory to be read.`, { cause: error });
+    }
+}
+function checkAllTheFilesAreJDLFiles(files) {
+    for (let i = 0; i < files.length; i++) {
+        checkFileIsJDLFile(files[i]);
+    }
+}
+/**
+ * Parsed the stringified JDL content and returns an intermediate object from the Chevrotain parsers.
+ * @param content the JDL content.
+ * @returns the intermediate object.
+ */
+function parse(content, runtime) {
+    if (!content) {
+        throw new Error('File content must be passed, it is currently empty.');
+    }
+    try {
+        const processedInput = filterJDLDirectives(removeInternalJDLComments(content));
+        const parsedContent = parser.parse(processedInput, undefined, runtime);
+        return performJDLPostParsingTasks(parsedContent);
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            logger.error(`Syntax error message:\n\t${error.message}`);
+        }
+        throw error;
+    }
+}
+function getCst(content, runtime) {
+    if (!content) {
+        throw new Error('File content must be passed, it is currently empty.');
+    }
+    try {
+        const processedInput = filterJDLDirectives(removeInternalJDLComments(content));
+        return parser.getCst(processedInput, undefined, runtime);
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            logger.error(`Syntax error message:\n\t${error.message}`);
+        }
+        throw error;
+    }
+}
+function removeInternalJDLComments(content) {
+    // Removing an internal Comment will not affect line/column location info
+    // as no lines are removed and the comments consumes the rest of the line.
+    return content.replace(/\/\/[^\n\r]*/gm, '');
+}
+function filterJDLDirectives(content) {
+    // We are only removing the directive not the whole line to avoid modifying line/column
+    // location information in parsers errors.
+    return content.replace(/^\u0023.*/gm, '');
+}
+/**
+ * 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 function checkFileIsJDLFile(file) {
+    if (!file.endsWith('.jh') && !file.endsWith('.jdl')) {
+        throw new Error(`The passed file '${file}' must end with '.jh' or '.jdl' to be valid.`);
+    }
+}
+function aggregateFiles(files) {
+    return files.map(file => readFileSync(file, 'utf-8')).join('\n');
+}

package/dist/lib/jdl/core/runtime.d.ts

@@ -0,0 +1,4 @@
+import type { JDLRuntime } from './types/runtime.js';
+import type { JDLApplicationConfig } from './types/parsing.js';
+export declare const createRuntime: (definition: JDLApplicationConfig) => JDLRuntime;
+export declare const getDefaultRuntime: () => JDLRuntime;

package/dist/lib/jdl/core/runtime.js

@@ -0,0 +1,72 @@
+import { builtInJDLApplicationConfig } from '../../jhipster/application-options.js';
+import { getDefaultJDLApplicationConfig } from '../../command/jdl.js';
+import { buildTokens, createJDLLexer } from './parsing/lexer/lexer.js';
+import JDLParser from './parsing/jdl-parser.js';
+import { checkConfigKeys, checkTokens } from './parsing/self-checks/parsing-system-checker.js';
+import JDLApplicationDefinition from './built-in-options/jdl-application-definition.js';
+import { buildApplicationTokens } from './built-in-options/tokens/application-tokens.js';
+import { deploymentTokens } from './built-in-options/tokens/deployment-tokens.js';
+const mergeDefinition = (definition, defaultDefinition) => {
+    return {
+        validatorConfig: {
+            ...defaultDefinition.validatorConfig,
+            ...definition.validatorConfig,
+        },
+        optionsValues: {
+            ...defaultDefinition.optionsValues,
+            ...definition.optionsValues,
+        },
+        optionsTypes: {
+            ...defaultDefinition.optionsTypes,
+            ...definition.optionsTypes,
+        },
+        quotedOptionNames: [...defaultDefinition.quotedOptionNames, ...definition.quotedOptionNames],
+        tokenConfigs: [...defaultDefinition.tokenConfigs, ...definition.tokenConfigs],
+    };
+};
+export const createRuntime = (definition) => {
+    const newDefinition = mergeDefinition(definition, builtInJDLApplicationConfig);
+    const propertyValidations = newDefinition.validatorConfig;
+    const applicationDefinition = new JDLApplicationDefinition({
+        optionValues: newDefinition.optionsValues,
+        optionTypes: newDefinition.optionsTypes,
+        quotedOptionNames: newDefinition.quotedOptionNames,
+    });
+    let tokens;
+    let lexer;
+    let parser;
+    return {
+        get tokens() {
+            if (!tokens) {
+                const applicationTokens = buildApplicationTokens(newDefinition.tokenConfigs);
+                tokens = buildTokens({ applicationTokens, deploymentTokens });
+                checkConfigKeys(tokens, Object.keys(propertyValidations));
+            }
+            return tokens;
+        },
+        get lexer() {
+            if (!lexer) {
+                lexer = createJDLLexer(this.tokens);
+            }
+            return lexer;
+        },
+        get parser() {
+            if (!parser) {
+                parser = new JDLParser(this.tokens);
+                parser.parse();
+                const rules = parser.getGAstProductions();
+                checkTokens(Object.values(this.tokens), Object.values(rules));
+            }
+            return parser;
+        },
+        applicationDefinition,
+        propertyValidations,
+    };
+};
+let defaultRuntime;
+export const getDefaultRuntime = () => {
+    if (!defaultRuntime) {
+        defaultRuntime = createRuntime(getDefaultJDLApplicationConfig());
+    }
+    return defaultRuntime;
+};

package/dist/lib/jdl/core/types/exporter.d.ts

@@ -0,0 +1,61 @@
+/**
+ * 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 { GENERATOR_NAME } from '../../converters/exporters/export-utils.ts';
+import type { JSONEntity } from './json-config.js';
+
+export type JDLJSONApplicationContent = {
+  entities?: string[];
+  creationTimestamp?: number;
+} & Record<string, any>;
+
+export type JDLJSONApplication = {
+  [GENERATOR_NAME]: JDLJSONApplicationContent;
+  namespaceConfigs: Record<string, Record<string, any>>;
+};
+
+export type JDLJSONBlueprint = {
+  name: string;
+};
+
+export type JDLJSONMicrofrontend = {
+  baseName: string;
+};
+
+export type PostProcessedJDLJSONApplication = {
+  blueprints: JDLJSONBlueprint[];
+  microfrontends: JDLJSONMicrofrontend[];
+} & JDLJSONApplication;
+
+export type RawJDLJSONApplication = {
+  entityNames?: string;
+  frontEndBuilder?: string;
+  blueprints?: string;
+  microfrontends?: string;
+} & JDLJSONApplication;
+
+export type JhipsterJSONJDLApplicationExporter = {
+  forSeveralApplications?: boolean;
+  name: string;
+  type: string;
+};
+
+export type JhipsterJSONJDLExporterWrapper = {
+  entities: JSONEntity[];
+  application: JhipsterJSONJDLApplicationExporter;
+};

package/dist/lib/jdl/core/types/json-config.d.ts

@@ -0,0 +1,45 @@
+import type { ApplicationConfiguration, YoRcContent } from '../../../types/application/yo-rc.js';
+import type { Entity } from '../../../types/base/entity.js';
+import type { Field } from '../../../types/base/field.js';
+import type { Relationship } from '../../../types/base/relationship.js';
+
+export type JSONField = Field & Record<string, any>;
+
+export type JSONRelationship = Relationship & Record<string, any>;
+
+export type JSONEntity = Entity<JSONField, JSONRelationship> & Record<string, any>;
+
+type JSONBlueprint = {
+  name: string;
+  version?: string;
+} & Record<string, any>;
+
+type JSONGeneratorJhipsterContentDeployment = {
+  appsFolders?: string[];
+  clusteredDbApps?: string[];
+};
+
+type AbstractJSONGeneratorJhipsterContent = ApplicationConfiguration & JSONGeneratorJhipsterContentDeployment & Record<string, any>;
+
+type JSONGeneratorJhipsterContent = {
+  promptValues?: Partial<JSONGeneratorJhipsterContent>;
+  blueprints?: JSONBlueprint[] | null;
+} & AbstractJSONGeneratorJhipsterContent;
+
+type PostProcessedJSONGeneratorJhipsterContent = {
+  blueprints?: string[];
+  microfrontends?: string[];
+} & AbstractJSONGeneratorJhipsterContent;
+
+export type PostProcessedJSONRootObject = YoRcContent<
+  Omit<PostProcessedJSONGeneratorJhipsterContent, 'blueprints' | 'microfrontends'> & {
+    blueprints?: string[];
+    microfrontends?: string[];
+  }
+>;
+
+export type JHipsterYoRcContent = YoRcContent<JSONGeneratorJhipsterContent>;
+
+export type JHipsterYoRcContentWrapper = {
+  application?: PostProcessedJSONRootObject | JHipsterYoRcContent;
+};

package/dist/lib/jdl/core/types/parsed.d.ts

@@ -0,0 +1,124 @@
+/**
+ * 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 { RelationshipType } from '../basic-types/relationships.js';
+
+export type ParsedJDLAnnotation = {
+  optionName: string;
+  type: 'UNARY' | string;
+  optionValue?: boolean | string | number;
+};
+
+export type ParsedJDLValidation = {
+  key: string;
+  value?: string | number | RegExp | boolean;
+  constant?: boolean;
+};
+
+export type ParsedJDLEntityField = {
+  annotations?: ParsedJDLAnnotation[];
+  validations: ParsedJDLValidation[];
+  name: string;
+  type: string;
+  documentation?: string;
+};
+
+export type ParsedJDLEntity = {
+  name: string;
+  tableName?: string;
+  documentation?: string;
+  annotations?: ParsedJDLAnnotation[];
+  body?: ParsedJDLEntityField[];
+};
+export type ParsedJDLApplicationConfig = {
+  baseName: string;
+} & Record<string, any>;
+
+export type ParsedJDLEnumValue = {
+  key: string;
+  value?: string;
+  comment?: string;
+};
+
+export type ParsedJDLEnum = {
+  name: string;
+  values: ParsedJDLEnumValue[];
+  documentation?: string;
+};
+export type ParsedJDLOption = {
+  list: string[]; // entity names
+  excluded: string[]; // excluded entity names
+};
+
+export type ParsedJDLUseOption = {
+  optionValues: string[];
+} & ParsedJDLOption;
+
+export type ParsedJDLApplication = {
+  config: ParsedJDLApplicationConfig;
+  namespaceConfigs?: Record<string, Record<string, boolean | number | string[] | string>>;
+  entities?: string[];
+  options?: Record<string, ParsedJDLOption | Record<string, ParsedJDLOption>>;
+  useOptions?: ParsedJDLUseOption[];
+};
+
+export type ParsedJDLDeployment = {
+  deploymentType: string;
+  appsFolders?: string[];
+  dockerRepositoryName?: string;
+};
+
+export type ParsedJDLRelationshipSide = {
+  name: string;
+  injectedField?: string;
+  required: boolean;
+  documentation?: string;
+};
+
+export type ParsedJDLRelationshipOption = {
+  global: ParsedJDLAnnotation[];
+  source: ParsedJDLAnnotation[];
+  destination: ParsedJDLAnnotation[];
+};
+
+export type ParsedJDLRelationship = {
+  from: ParsedJDLRelationshipSide;
+  to: ParsedJDLRelationshipSide;
+  cardinality: RelationshipType;
+  options: ParsedJDLRelationshipOption;
+};
+
+export type ParsedJDLApplications = {
+  applications: ParsedJDLApplication[];
+  entities: ParsedJDLEntity[];
+  relationships: ParsedJDLRelationship[];
+  deployments: ParsedJDLDeployment[];
+  enums: ParsedJDLEnum[];
+  constants: Record<string, string>;
+  options: Record<string, ParsedJDLOption | Record<string, ParsedJDLOption>>;
+  useOptions: ParsedJDLUseOption[];
+};
+
+export type ParsedJDLRoot = {
+  parsedContent: ParsedJDLApplications;
+  document?: ParsedJDLApplications; // deprecated
+  entities?: ParsedJDLEntity[];
+  applicationType?: string;
+  applicationName?: string;
+  databaseType?: string;
+};

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

@@ -0,0 +1,49 @@
+/**
+ * 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 type JDLTokenConfig = Pick<ITokenConfig, 'name' | 'pattern'>;
+
+export type JDLValidatorOptionType = 'BOOLEAN' | 'INTEGER' | 'list' | 'NAME' | 'qualifiedName' | 'STRING' | 'quotedList';
+
+export type JDLValidatorOption = {
+  type: JDLValidatorOptionType;
+  pattern?: RegExp;
+  msg?: string;
+};
+
+export type JDLApplicationOptionValue = string | number | boolean | undefined | never[] | Record<string, string>;
+export type JDLApplicationOptionTypeValue = 'string' | 'integer' | 'boolean' | 'list' | 'quotedList';
+export type JDLApplicationOptionType = { type: JDLApplicationOptionTypeValue };
+
+export type JDLApplicationConfig = {
+  tokenConfigs: JDLTokenConfig[];
+  validatorConfig: Record<string, JDLValidatorOption>;
+  optionsValues: Record<string, JDLApplicationOptionValue>;
+  optionsTypes: Record<string, JDLApplicationOptionType>;
+  quotedOptionNames: string[];
+};
+
+export type JHipsterOptionDefinition = {
+  name: string;
+  type: JDLApplicationOptionTypeValue;
+  tokenType: JDLValidatorOptionType;
+  tokenValuePattern?: RegExp;
+  knownChoices?: string[];
+};

package/dist/lib/jdl/core/types/runtime.d.ts

@@ -0,0 +1,12 @@
+import type { Lexer, TokenType } from 'chevrotain';
+import type JDLParser from '../parsing/jdl-parser.ts';
+import type JDLApplicationDefinition from '../built-in-options/jdl-application-definition.ts';
+import type { JDLValidatorOption } from './parsing.js';
+
+export type JDLRuntime = {
+  applicationDefinition: JDLApplicationDefinition;
+  tokens: Record<string, TokenType>;
+  lexer: Lexer;
+  parser: JDLParser;
+  propertyValidations: Record<string, JDLValidatorOption>;
+};

package/dist/lib/jdl/core/utils/entity-table-name-creator.js

@@ -0,0 +1,49 @@
+/**
+ * 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 { snakeCase } from 'lodash-es';
+import { hibernateSnakeCase } from '../../../../generators/server/support/string.js';
+/**
+ * @deprecated TODO v9 drop this function and don't calculate entityTableName.
+ * Returns an entity table name based on the passed entity name.
+ * @param entityName - the entity's name
+ * @returns the corresponding table name.
+ */
+export default function getTableNameFromEntityName(entityName) {
+    if (!entityName) {
+        throw new Error('An entity name must be passed to get a table name.');
+    }
+    return snakeCase(entityName);
+}
+/**
+ * @deprecated TODO v9 drop this function and don't calculate entityTableName.
+ * Returns an entity table name based on the passed entity name if it conflicts with the default one.
+ */
+export const getTableNameFromEntityNameFallback = (entityName) => {
+    const snakeCasedEntityName = getTableNameFromEntityName(entityName);
+    if (snakeCasedEntityName !== hibernateSnakeCase(entityName)) {
+        return snakeCasedEntityName;
+    }
+    return undefined;
+};
+/**
+ * @deprecated TODO v9 drop this function and always write entityTableName if exists.
+ */
+export const shouldWriteEntityTableName = (entityName, entityTableName) => {
+    return entityTableName !== snakeCase(entityName) || entityTableName !== hibernateSnakeCase(entityName);
+};

package/dist/lib/jdl/core/utils/format-utils.js

@@ -0,0 +1,43 @@
+/**
+ * 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 { formatComment };
+/**
+ * formats a comment
+ * @param comment string.
+ * @returns formatted comment string
+ */
+export default function formatComment(comment) {
+    if (!comment) {
+        return undefined;
+    }
+    const parts = comment.trim().split('\n');
+    if (parts.length === 1 && !parts[0].startsWith('*')) {
+        return parts[0];
+    }
+    return parts.reduce((previousValue, currentValue) => {
+        // newlines in the middle of the comment should stay to achieve:
+        // multiline comments entered by user drive unchanged from JDL
+        // studio to generated domain class
+        let delimiter = '';
+        if (previousValue !== '') {
+            delimiter = '\\n';
+        }
+        return previousValue.concat(delimiter, currentValue.trim().replace(/[*]*\s*/, ''));
+    }, '');
+}

package/dist/lib/jdl/core/utils/objects/logger.js

@@ -0,0 +1,26 @@
+/**
+ * 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 { createJHipsterLogger } from '../../../../utils/logger.js';
+const logger = createJHipsterLogger({ namespace: 'jhipster:jdl' });
+export default {
+    info: (message) => logger.verboseInfo(message),
+    error: (message) => logger.error(message),
+    warn: (message) => logger.warn(message),
+    debug: (message) => logger.debug(message),
+};

package/dist/lib/jdl/index.d.ts

@@ -0,0 +1,4 @@
+export * from './jdl-importer.js';
+export * from './core/parsing/api.js';
+export * from '../jhipster/index.js';
+export * from '../utils/yo-rc.js';

package/dist/lib/jdl/index.js

@@ -0,0 +1,4 @@
+export * from './jdl-importer.js';
+export * from './core/parsing/api.js';
+export * from '../jhipster/index.js';
+export * from '../utils/yo-rc.js';