generator-jhipster 8.7.1 → 8.7.2

package/dist/lib/command/support/merge-union.d.ts

@@ -1,8 +1,19 @@
-type Compute<T> = { [K in keyof T]: T[K] } | never;
-type AllKeys<T> = T extends any ? keyof T : never;
 /**
- * Based on https://github.com/sindresorhus/type-fest/issues/610
+ * Based on https://github.com/sindresorhus/type-fest/issues/610#issuecomment-2398118998
  */
-export type MergeUnion<T, Keys extends keyof T = keyof T> = Compute<
-  { [K in Keys]: T[Keys] } & { [K in AllKeys<T>]?: T extends any ? (K extends keyof T ? T[K] : never) : never }
->;
+import type { EmptyObject, IsNever, KeysOfUnion, Simplify, UnionToIntersection } from 'type-fest';
+
+type _MergeUnionKnownKeys<BaseType, Keys extends keyof BaseType = keyof BaseType> = {
+  [K in Keys]: Keys extends K ? BaseType[Keys] : never;
+};
+
+type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
+
+export type MergeUnion<BaseType> =
+  IsNever<BaseType> extends false
+    ? Simplify<
+        _MergeUnionKnownKeys<BaseType> & {
+          [K in KeysOfUnion<BaseType>]?: BaseType extends object ? (K extends keyof BaseType ? BaseType[K] : never) : never;
+        }
+      >
+    : EmptyObject;

package/dist/lib/command/types.d.ts

@@ -31,19 +31,24 @@ export type PromptSpec = {
 
 type JHipsterArgumentConfig = SetOptional<ArgumentSpec, 'name'> & { scope?: CommandConfigScope };
 
+type CliSpec = Omit<SetOptional<CliOptionSpec, 'name'>, 'storage'> & {
+  env?: string;
+  /**
+   * Imply other options.
+   */
+  implies?: Record<string, any>;
+};
+
 export type ConfigSpec<ConfigContext> = {
   readonly description?: string;
   readonly choices?: JHispterChoices;
-
-  readonly cli?: SetOptional<CliOptionSpec, 'name'> & { env?: string };
+  readonly cli?: CliSpec;
   readonly argument?: JHipsterArgumentConfig;
+  readonly internal?: true;
   readonly prompt?:
     | PromptSpec
     | ((gen: ConfigContext & { jhipsterConfigWithDefaults: Record<string, any> }, config: ConfigSpec<ConfigContext>) => PromptSpec);
   readonly jdl?: Omit<JHipsterOptionDefinition, 'name' | 'knownChoices'>;
-  readonly storage?: {
-    readonly type?: typeof Boolean | typeof String | typeof Number | typeof Array;
-  };
   readonly scope?: CommandConfigScope;
   /**
    * The callback receives the generator as input for 'generator' scope.
@@ -69,7 +74,10 @@ export type JHipsterArguments = Record<string, JHipsterArgumentConfig>;
 
 export type JHipsterOptions = Record<string, JHipsterOption>;
 
-export type JHipsterConfig<ConfigContext = any> = RequireAtLeastOne<ConfigSpec<ConfigContext>, 'argument' | 'cli' | 'prompt' | 'storage'>;
+export type JHipsterConfig<ConfigContext = any> = RequireAtLeastOne<
+  ConfigSpec<ConfigContext>,
+  'argument' | 'cli' | 'prompt' | 'jdl' | 'internal'
+>;
 
 export type JHipsterConfigs<ConfigContext = any> = Record<string, JHipsterConfig<ConfigContext>>;
 
@@ -194,6 +202,12 @@ type DerivedPropertiesWithInferenceUnionFromParseableConfigs<U extends Parseable
     : never;
 };
 
+/**
+ * @example
+ * ```ts
+ * type ExplodedCommandChoices = ExplodeCommandChoicesNoInference<{ clientFramework: { choices: ['angular', 'no'], scope: 'storage' }, clientTestFramework: { choices: ['cypress', 'no'], scope: 'storage' } }>
+ * ```
+ */
 type ExplodeCommandChoicesNoInference<U extends ParseableConfigs> = {
   [K in keyof U]: U[K] extends infer RequiredChoices
     ? RequiredChoices extends { choices: any }
@@ -222,19 +236,32 @@ type PrepareConfigsWithType<U extends ParseableConfigs> = Simplify<{
 /** Keep Options/Config filtered by choices */
 type OnlyChoices<D, C extends boolean> = D extends { choices: JHispterChoices } ? (C extends true ? D : never) : C extends true ? never : D;
 
-/** Keep Options/Config filtered by choices */
-type OnlyCofigsWithChoice<D extends ParseableConfigs, C extends boolean> = {
+/**
+ * Keep Options/Config filtered by choices
+ *
+ * @example
+ * ```ts
+ * type ConfigsWithChoice = OnlyConfigsWithChoice<{ clientFramework: { choices: ['angular', 'no'], scope: 'storage' }, clientTestFramework: { choices: ['cypress', 'no'], scope: 'storage' } }>
+ * ```
+ */
+type OnlyConfigsWithChoice<D extends ParseableConfigs, C extends boolean> = {
   [K in keyof D as OnlyChoices<D[K], C> extends never ? never : K]: D[K];
 };
 
+/**
+ * @example
+ * ```
+ * type Prop = ExportApplicationPropertiesFromCommand<{ configs: { clientFramework: { choices: ['angular', 'no'], scope: 'storage' }, bar: { scope: 'storage' } } }>;
+ * ```
+ */
 export type ExportApplicationPropertiesFromCommand<C extends ParseableCommand> =
   MergeConfigsOptions<C, 'storage'> extends infer Merged
     ? Merged extends ParseableConfigs
       ? // Add value inference to properties with choices
-        // ? PrepareConfigsWithType<OnlyCofigsWithChoice<F, false>> & ValueOf<ExplodeCommandChoicesWithInference<OnlyCofigsWithChoice<F, true>>>
+        // ? PrepareConfigsWithType<OnlyConfigsWithChoice<F, false>> & ValueOf<ExplodeCommandChoicesWithInference<OnlyConfigsWithChoice<F, true>>>
         Simplify<
-          PrepareConfigsWithType<OnlyCofigsWithChoice<Merged, false>> &
-            MergeUnion<ValueOf<ExplodeCommandChoicesNoInference<OnlyCofigsWithChoice<Merged, true>>>>
+          PrepareConfigsWithType<OnlyConfigsWithChoice<Merged, false>> &
+            MergeUnion<ValueOf<ExplodeCommandChoicesNoInference<OnlyConfigsWithChoice<Merged, true>>>>
         >
       : never
     : never;

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

@@ -1,15 +1,7 @@
-declare const _default: {
-    recommended: import("typescript-eslint").ConfigWithExtends;
-    base: import("typescript-eslint").ConfigWithExtends;
-    extends?: import("@typescript-eslint/utils/ts-eslint").FlatConfig.ConfigArray;
-    files?: (string[] | string)[];
-    ignores?: string[];
-    languageOptions?: import("@typescript-eslint/utils/ts-eslint").FlatConfig.LanguageOptions;
-    linterOptions?: import("@typescript-eslint/utils/ts-eslint").FlatConfig.LinterOptions;
-    name?: string;
-    plugins?: import("@typescript-eslint/utils/ts-eslint").FlatConfig.Plugins;
-    processor?: import("@typescript-eslint/utils/ts-eslint").FlatConfig.Processor | string;
-    rules?: import("@typescript-eslint/utils/ts-eslint").FlatConfig.Rules;
-    settings?: import("@typescript-eslint/utils/ts-eslint").FlatConfig.Settings;
-};
+declare namespace _default {
+    export { recommended };
+    export { base };
+}
 export default _default;
+import recommended from './recommended.js';
+import base from './base.js';

package/dist/lib/eslint/index.js

@@ -1,4 +1,3 @@
 import recommended from './recommended.js';
 import base from './base.js';
-recommended.recommended = recommended;
-export default { ...recommended, recommended, base };
+export default { recommended, base };

package/dist/lib/index.d.ts

@@ -1,3 +1,4 @@
 export declare const isDistFolder: () => boolean;
 export declare const getPackageRoot: (relativePath?: string) => string;
+export declare const getSourceRoot: (relativePath?: string) => string;
 export declare const packageJson: any;

package/dist/lib/index.js

@@ -4,11 +4,15 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 export const isDistFolder = () => {
-    return basename(join(__dirname, '..')) === 'dist';
+    return basename(dirname(__dirname)) === 'dist';
 };
 export const getPackageRoot = (relativePath) => {
-    const sourceRoot = join(__dirname, '..');
-    const packageDirectory = isDistFolder() ? join(sourceRoot, '..') : sourceRoot;
+    const sourceRoot = dirname(__dirname);
+    const packageDirectory = isDistFolder() ? dirname(sourceRoot) : sourceRoot;
     return relativePath ? join(packageDirectory, relativePath) : packageDirectory;
 };
+export const getSourceRoot = (relativePath) => {
+    const sourceRoot = dirname(__dirname);
+    return relativePath ? join(sourceRoot, relativePath) : sourceRoot;
+};
 export const packageJson = JSON.parse(readFileSync(getPackageRoot('package.json')).toString());

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

@@ -17,7 +17,7 @@
  * limitations under the License.
  */
 /* eslint-disable no-useless-escape */
-import { first, flatten, includes, values } from 'lodash-es';
+import { first, flatten, includes } 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_]+$/;
@@ -352,7 +352,7 @@ export default function performAdditionalSyntaxChecks(cst, runtime) {
             this.visit(context.deploymentConfigValue, context.DEPLOYMENT_KEY[0]);
         }
         deploymentConfigValue(context, configKey) {
-            const configValue = first(first(values(context)));
+            const configValue = first(first(Object.values(context)));
             this.checkDeploymentConfigPropSyntax(configKey, configValue);
         }
     }

package/dist/lib/jhipster/default-application-options.d.ts

@@ -16,18 +16,86 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export declare function getConfigWithDefaults(customOptions?: string | Record<string, any>): any;
-export declare function getConfigForClientApplication(options?: any): any;
-export declare function getConfigForAuthenticationType(options?: any): any;
-export declare function getConfigForPackageName(options?: any): any;
-export declare function getConfigForCacheProvider(options?: any): any;
-export declare function getConfigForReactive(options?: any): any;
-export declare function getConfigForTranslation(options?: any): any;
-export declare function getConfigForDatabaseType(options?: any): any;
-export declare function getServerConfigForMonolithApplication(customOptions?: any): any;
-export declare function getConfigForMonolithApplication(customOptions?: any): any;
-export declare function getServerConfigForGatewayApplication(customOptions?: any): any;
-export declare function getConfigForGatewayApplication(customOptions?: any): any;
-export declare function getServerConfigForMicroserviceApplication(customOptions?: any): any;
-export declare function getConfigForMicroserviceApplication(customOptions?: any): any;
-export declare function getDefaultConfigForNewApplication(customOptions?: any): any;
+import type { ApplicationConfiguration } from '../types/application/yo-rc.js';
+type ApplicationDefaults = Partial<ApplicationConfiguration>;
+export declare function getConfigWithDefaults(customOptions?: ApplicationDefaults): Partial<{
+    jhipsterVersion?: string | undefined;
+    baseName: string;
+    creationTimestamp?: number | undefined;
+    lastLiquibaseTimestamp?: number | undefined;
+    blueprints?: {
+        name: string;
+    }[] | undefined;
+    testFrameworks?: string[] | undefined;
+    microfrontends?: {
+        baseName: string;
+    }[] | undefined;
+    skipClient?: boolean | undefined;
+    skipServer?: boolean | undefined;
+    jhiPrefix?: string | undefined;
+    entitySuffix?: string | undefined;
+    dtoSuffix?: string | undefined;
+    pkType?: string | undefined;
+    clientPackageManager?: string | undefined;
+    jdlStore?: string | undefined;
+    skipJhipsterDependencies?: boolean | undefined;
+    clientFramework?: "no" | "angular" | "react" | "vue" | undefined;
+    clientTheme?: string | undefined;
+    clientThemeVariant?: string | undefined;
+    clientBundler?: "webpack" | "vite" | undefined;
+    microfrontend?: boolean | undefined;
+    clientTestFrameworks?: "cypress" | undefined;
+    withAdminUi?: boolean | undefined;
+    clientRootDir?: string | undefined;
+    monorepository?: boolean | undefined;
+    packageName?: string | undefined;
+    packageFolder?: string | undefined;
+    withGeneratedFlag?: boolean | undefined;
+    buildTool?: string | undefined;
+    packageJsonNodeEngine?: unknown;
+    packageJsonType?: "commonjs" | "module" | undefined;
+    prettierTabWidth?: number | undefined;
+    languages?: unknown[] | undefined;
+    enableTranslation?: boolean | undefined;
+    nativeLanguage?: string | undefined;
+    incrementalChangelog?: boolean | undefined;
+    skipFakeData?: boolean | undefined;
+    applicationType?: "monolith" | "microservice" | "gateway" | undefined;
+    skipUserManagement?: boolean | undefined;
+    cacheProvider?: string | undefined;
+    enableSwaggerCodegen?: boolean | undefined;
+    enableHibernateCache?: boolean | undefined;
+    searchEngine?: string | undefined;
+    skipCheckLengthOfIdentifier?: boolean | undefined;
+    websocket?: string | undefined;
+    reactive?: boolean | undefined;
+    serverPort?: unknown;
+    serviceDiscoveryType?: "no" | "eureka" | "consul" | undefined;
+    jwtSecretKey?: string | undefined;
+    authenticationType?: "session" | "jwt" | "oauth2" | undefined;
+    feignClient?: boolean | undefined;
+    syncUserWithIdp?: boolean | undefined;
+    defaultPackaging?: "jar" | "war" | undefined;
+    databaseType?: "sql" | "mongodb" | "cassandra" | "couchbase" | "neo4j" | "no" | undefined;
+    messageBroker?: "no" | "kafka" | "pulsar" | undefined;
+    databaseMigration?: "liquibase" | undefined;
+    graalvmSupport?: boolean | undefined;
+    routes?: unknown[] | undefined;
+    prodDatabaseType?: "mysql" | "mariadb" | "postgresql" | "mssql" | "oracle" | undefined;
+    devDatabaseType?: string | undefined;
+}>;
+export declare function getConfigForClientApplication(options?: ApplicationDefaults): ApplicationDefaults;
+export declare function getConfigForAuthenticationType(options?: ApplicationDefaults): ApplicationDefaults;
+export declare function getConfigForPackageName(options?: ApplicationDefaults): ApplicationDefaults;
+export declare function getConfigForCacheProvider(options?: ApplicationDefaults): ApplicationDefaults;
+export declare function getConfigForReactive(options?: ApplicationDefaults): ApplicationDefaults;
+export declare function getConfigForTranslation(options?: ApplicationDefaults): ApplicationDefaults;
+export declare function getConfigForDatabaseType(options?: ApplicationDefaults): ApplicationDefaults;
+export declare function getServerConfigForMonolithApplication(customOptions?: ApplicationDefaults): ApplicationDefaults;
+export declare function getConfigForMonolithApplication(customOptions?: ApplicationDefaults): ApplicationDefaults;
+export declare function getServerConfigForGatewayApplication(customOptions?: ApplicationDefaults): ApplicationDefaults;
+export declare function getConfigForGatewayApplication(customOptions?: ApplicationDefaults): ApplicationDefaults;
+export declare function getServerConfigForMicroserviceApplication(customOptions?: ApplicationDefaults): ApplicationDefaults;
+export declare function getConfigForMicroserviceApplication(customOptions?: ApplicationDefaults): ApplicationDefaults;
+export declare function getDefaultConfigForNewApplication(customOptions?: ApplicationDefaults): ApplicationDefaults;
+export {};

package/dist/lib/jhipster/default-application-options.js

@@ -26,8 +26,7 @@ import clientFrameworkTypes from './client-framework-types.js';
 import buildToolTypes from './build-tool-types.js';
 const { MONOLITH, MICROSERVICE, GATEWAY } = applicationTypes;
 const { CONSUL } = serviceDiscoveryTypes;
-const { COUCHBASE, CASSANDRA, MONGODB, NEO4J, SQL, POSTGRESQL } = databaseTypes;
-const NO_DATABASE_TYPE = databaseTypes.NO;
+const { SQL, POSTGRESQL } = databaseTypes;
 const { OptionNames, OptionValues } = applicationOptions;
 const { JWT, OAUTH2 } = authenticationTypes;
 const { ANGULAR, NO: NO_CLIENT_FRAMEWORK } = clientFrameworkTypes;
@@ -49,7 +48,7 @@ const commonDefaultOptions = {
     [WEBSOCKET]: OptionValues[WEBSOCKET].no,
 };
 export function getConfigWithDefaults(customOptions = {}) {
-    const applicationType = typeof customOptions === 'string' ? customOptions : customOptions.applicationType;
+    const applicationType = customOptions.applicationType;
     if (applicationType === GATEWAY) {
         return getConfigForGatewayApplication(customOptions);
     }
@@ -62,18 +61,28 @@ export function getConfigForClientApplication(options = {}) {
     if (options[SKIP_CLIENT]) {
         options[CLIENT_FRAMEWORK] = NO_CLIENT_FRAMEWORK;
     }
+    const clientFramework = options[CLIENT_FRAMEWORK];
+    if (clientFramework === NO_CLIENT_FRAMEWORK) {
+        return options;
+    }
     if (options[OptionNames.MICROFRONTEND] === undefined) {
         options[OptionNames.MICROFRONTEND] = Boolean(options[OptionNames.MICROFRONTENDS]?.length);
     }
-    const clientFramework = options[CLIENT_FRAMEWORK];
-    if (clientFramework !== NO_CLIENT_FRAMEWORK) {
-        if (!options[CLIENT_THEME]) {
-            options[CLIENT_THEME] = OptionValues[CLIENT_THEME];
-            options[CLIENT_THEME_VARIANT] = '';
-        }
-        else if (options[CLIENT_THEME] !== OptionValues[CLIENT_THEME] && !options[CLIENT_THEME_VARIANT]) {
-            options[CLIENT_THEME_VARIANT] = 'primary';
-        }
+    if (!options[CLIENT_THEME]) {
+        options[CLIENT_THEME] = OptionValues[CLIENT_THEME];
+        options[CLIENT_THEME_VARIANT] = '';
+    }
+    else if (options[CLIENT_THEME] !== OptionValues[CLIENT_THEME] && !options[CLIENT_THEME_VARIANT]) {
+        options[CLIENT_THEME_VARIANT] = 'primary';
+    }
+    if (clientFramework === 'vue') {
+        options.clientBundler = options.microfrontend || options.applicationType === 'microservice' ? 'webpack' : 'vite';
+    }
+    else if (clientFramework === 'react') {
+        options.clientBundler = 'webpack';
+    }
+    else if (clientFramework === 'angular') {
+        options.clientBundler = 'webpack';
     }
     return options;
 }
@@ -101,9 +110,10 @@ export function getConfigForPackageName(options = {}) {
     return options;
 }
 export function getConfigForCacheProvider(options = {}) {
-    if (options[REACTIVE]) {
+    if (options[REACTIVE] || options[CACHE_PROVIDER] === undefined) {
         options[CACHE_PROVIDER] = NO_CACHE_PROVIDER;
     }
+    options[ENABLE_HIBERNATE_CACHE] ??= options[DATABASE_TYPE] === SQL && !options[REACTIVE] && options[CACHE_PROVIDER] !== NO_CACHE_PROVIDER;
     return options;
 }
 export function getConfigForReactive(options = {}) {
@@ -136,17 +146,6 @@ export function getConfigForDatabaseType(options = {}) {
             options[DEV_DATABASE_TYPE] = options[PROD_DATABASE_TYPE];
         }
     }
-    else if ([MONGODB, COUCHBASE, CASSANDRA, NEO4J, NO_DATABASE_TYPE].includes(options[DATABASE_TYPE])) {
-        if (NO_DATABASE_TYPE !== options[DATABASE_TYPE]) {
-            options[ENABLE_HIBERNATE_CACHE] = false;
-        }
-    }
-    if (options[REACTIVE]) {
-        options[ENABLE_HIBERNATE_CACHE] = false;
-    }
-    if (options[ENABLE_HIBERNATE_CACHE] === undefined) {
-        options[ENABLE_HIBERNATE_CACHE] = true;
-    }
     return options;
 }
 export function getServerConfigForMonolithApplication(customOptions = {}) {
@@ -168,8 +167,8 @@ export function getConfigForMonolithApplication(customOptions = {}) {
     let options = getServerConfigForMonolithApplication(customOptions);
     options = getConfigForClientApplication(options);
     options = getConfigForPackageName(options);
-    options = getConfigForCacheProvider(options);
     options = getConfigForDatabaseType(options);
+    options = getConfigForCacheProvider(options);
     options = getConfigForReactive(options);
     options = getConfigForTranslation(options);
     return getConfigForAuthenticationType(options);
@@ -195,8 +194,8 @@ export function getConfigForGatewayApplication(customOptions = {}) {
     let options = getServerConfigForGatewayApplication(customOptions);
     options = getConfigForClientApplication(options);
     options = getConfigForPackageName(options);
-    options = getConfigForCacheProvider(options);
     options = getConfigForDatabaseType(options);
+    options = getConfigForCacheProvider(options);
     options = getConfigForReactive(options);
     options = getConfigForTranslation(options);
     return getConfigForAuthenticationType(options);
@@ -222,8 +221,8 @@ export function getConfigForMicroserviceApplication(customOptions = {}) {
     let options = getServerConfigForMicroserviceApplication(customOptions);
     options = getConfigForClientApplication(options);
     options = getConfigForPackageName(options);
-    options = getConfigForCacheProvider(options);
     options = getConfigForDatabaseType(options);
+    options = getConfigForCacheProvider(options);
     options = getConfigForReactive(options);
     options = getConfigForTranslation(options);
     return getConfigForAuthenticationType(options);

package/dist/lib/testing/get-generator.d.ts

@@ -1,3 +1,4 @@
+export declare const getGeneratorRelativeFolder: (generatorName: string) => string;
 export declare const getGeneratorFolder: (generatorName: string) => string;
 declare const getGenerator: (generatorName: string) => string;
 export default getGenerator;

package/dist/lib/testing/get-generator.js

@@ -1,10 +1,14 @@
-import { dirname, resolve } from 'path';
+import { dirname, join, resolve } from 'path';
 import { existsSync } from 'fs';
 import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
+export const getGeneratorRelativeFolder = (generatorName) => {
+    generatorName = generatorName.replace('jhipster:', '');
+    return join('generators', generatorName.split(':').join('/generators/'));
+};
 export const getGeneratorFolder = (generatorName) => {
-    return resolve(__dirname, '../../generators', generatorName.split(':').join('/generators/'));
+    return resolve(__dirname, '../..', getGeneratorRelativeFolder(generatorName));
 };
 const getGenerator = (generatorName) => {
     const generatorFolder = getGeneratorFolder(generatorName);

package/dist/lib/testing/github-group.d.ts

@@ -0,0 +1,6 @@
+import type { GitHubMatrixGroup } from './github-matrix.js';
+export declare const getGithubSamplesGroups: (samplesGroupFolder: string) => Promise<string[]>;
+export declare const getGithubSamplesGroup: (samplesGroupFolder: string, group: string) => Promise<{
+    samples: GitHubMatrixGroup;
+    warnings: string[];
+}>;

package/dist/lib/testing/github-group.js

@@ -0,0 +1,56 @@
+import { readFile, readdir } from 'node:fs/promises';
+import { extname, join } from 'node:path';
+import { getUnknownGitHubMatrixGroupProperties } from './github-matrix.js';
+export const getGithubSamplesGroups = async (samplesGroupFolder) => {
+    const samplesFolderContent = await readdir(samplesGroupFolder);
+    return samplesFolderContent.filter(sample => ['.json', '.js', '.ts', ''].includes(extname(sample)));
+};
+export const getGithubSamplesGroup = async (samplesGroupFolder, group) => {
+    const warnings = [];
+    let samples = {};
+    const samplesFolderContent = await getGithubSamplesGroups(samplesGroupFolder);
+    if (samplesFolderContent.includes(`${group}.js`) || samplesFolderContent.includes(`${group}.ts`)) {
+        const jsGroup = await import(join(samplesGroupFolder, `${group}.js`));
+        samples = Object.fromEntries(Object.entries(jsGroup.default).map(([sample, value]) => [sample, { ...value, 'samples-group': group }]));
+    }
+    else if (samplesFolderContent.includes(`${group}.json`)) {
+        const jsonFile = await readFile(join(samplesGroupFolder, `${group}.json`));
+        samples = Object.fromEntries(Object.entries(JSON.parse(jsonFile.toString())).map(([sample, value]) => [
+            sample,
+            { ...value, 'samples-group': group },
+        ]));
+    }
+    else if (samplesFolderContent.includes(group)) {
+        const samplesFolderContent = await readdir(join(samplesGroupFolder, group));
+        if (samplesFolderContent.length > 0) {
+            // Support jdl files and folder (with .yo-rc.json files)
+            samples = Object.fromEntries(samplesFolderContent
+                .filter(sample => ['', '.jdl'].includes(extname(sample)))
+                .map(sample => [
+                sample.replace('.jdl', ''),
+                {
+                    'samples-group': group,
+                    'sample-type': extname(sample) === '.jdl' ? 'jdl' : 'yo-rc',
+                },
+            ]));
+            if (samplesFolderContent.includes('samples.json')) {
+                const jsonFile = await readFile(join(samplesGroupFolder, group, 'samples.json'));
+                const jsonSamples = JSON.parse(jsonFile.toString());
+                for (const [sample, value] of Object.entries(jsonSamples)) {
+                    if (!samples[sample]) {
+                        throw new Error(`Sample ${sample} not found in ${group}`);
+                    }
+                    samples[sample] = { ...samples[sample], ...value };
+                }
+            }
+        }
+    }
+    if (!samples) {
+        throw new Error();
+    }
+    const unknownProperties = getUnknownGitHubMatrixGroupProperties(samples);
+    if (unknownProperties.length) {
+        warnings.push(`Unknown properties in ${group}: ${unknownProperties.join(', ')}`);
+    }
+    return { samples, warnings };
+};

package/dist/lib/testing/github-matrix.d.ts

@@ -0,0 +1,38 @@
+export type GitHubMatrix = {
+    os: string;
+    'node-version': string;
+    'java-version': string;
+    'default-environment': string;
+    'job-name': string;
+    sample: string;
+    'samples-group'?: string;
+    'sample-type'?: string;
+    args?: string;
+    'jwt-secret-key'?: string;
+    jdl?: string;
+};
+export type GitHubMatrixGroup = Record<string, Partial<Omit<GitHubMatrix, 'job-name'>> & {
+    disabled?: boolean;
+}>;
+export type GitHubMatrixOutput = {
+    include: GitHubMatrix[];
+};
+export declare const getUnknownGitHubMatrixProperties: (matrix: Partial<GitHubMatrix>) => string[];
+export declare const getUnknownGitHubMatrixGroupProperties: (matrixRecord: GitHubMatrixGroup) => string[];
+export declare const defaultGithubEnvironment: {
+    os: string;
+    'node-version': string;
+    'java-version': string;
+    'npm-version': any;
+    'default-environment': string;
+    'jwt-secret-key': string;
+};
+type RandomEnvironmentOptions = {
+    useVersionPlaceholders?: boolean;
+    javaVersions?: string[];
+    nodeVersions?: string[];
+};
+export declare const convertToGitHubMatrix: (matrix: GitHubMatrixGroup, options?: {
+    randomEnvironment?: boolean;
+} & RandomEnvironmentOptions) => GitHubMatrixOutput;
+export {};

package/dist/lib/testing/github-matrix.js

@@ -0,0 +1,72 @@
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { RECOMMENDED_JAVA_VERSION, RECOMMENDED_NODE_VERSION } from '../../generators/index.js';
+import { getPackageRoot } from '../index.js';
+import { JAVA_COMPATIBLE_VERSIONS, JAVA_VERSION, NODE_VERSION } from '../../generators/generator-constants.js';
+const knwonGitHubMatrixProperties = [
+    'os',
+    'node-version',
+    'java-version',
+    'default-environment',
+    'job-name',
+    'sample',
+    'samples-group',
+    'sample-type',
+    'args',
+    'jwt-secret',
+    'jdl',
+];
+export const getUnknownGitHubMatrixProperties = (matrix) => {
+    return Object.keys(matrix).filter(key => !knwonGitHubMatrixProperties.includes(key));
+};
+export const getUnknownGitHubMatrixGroupProperties = (matrixRecord) => {
+    let unknownProperties = [];
+    for (const matrix of Object.values(matrixRecord)) {
+        unknownProperties = [...new Set([...unknownProperties, ...getUnknownGitHubMatrixProperties(matrix)])];
+    }
+    return unknownProperties;
+};
+const NPM_VERSION = JSON.parse(readFileSync(join(getPackageRoot(), 'generators/common/resources/package.json'), 'utf-8')).devDependencies
+    .npm;
+export const defaultGithubEnvironment = {
+    os: 'ubuntu-latest',
+    'node-version': RECOMMENDED_NODE_VERSION,
+    'java-version': RECOMMENDED_JAVA_VERSION,
+    'npm-version': NPM_VERSION,
+    'default-environment': 'prod',
+    'jwt-secret-key': 'ZjY4MTM4YjI5YzMwZjhjYjI2OTNkNTRjMWQ5Y2Q0Y2YwOWNmZTE2NzRmYzU3NTMwM2NjOTE3MTllOTM3MWRkMzcyYTljMjVmNmQ0Y2MxOTUzODc0MDhhMTlkMDIxMzI2YzQzZDM2ZDE3MmQ3NjVkODk3OTVmYzljYTQyZDNmMTQ=',
+};
+const randomReproducibleValue = (seed, choices, options) => {
+    const { useVersionPlaceholders } = options ?? {};
+    const index = createHash('shake256', { outputLength: 1 }).update(seed, 'utf8').digest('binary').charCodeAt(0) % choices.length;
+    if (useVersionPlaceholders) {
+        return `[${index}]`;
+    }
+    return choices[index];
+};
+const randomEnvironmentMatrix = (key, options) => {
+    const { useVersionPlaceholders, javaVersions = [JAVA_VERSION, ...JAVA_COMPATIBLE_VERSIONS], nodeVersions = [NODE_VERSION, '18', '20'], } = options;
+    const javaVersion = randomReproducibleValue(`java-${key}`, javaVersions, { useVersionPlaceholders });
+    const nodeVersion = randomReproducibleValue(`node-${key}`, nodeVersions, { useVersionPlaceholders });
+    return {
+        'job-name': `${key} (n${nodeVersion}/j${javaVersion})`,
+        'java-version': javaVersion,
+        'node-version': nodeVersion,
+    };
+};
+export const convertToGitHubMatrix = (matrix, options) => {
+    const { randomEnvironment, useVersionPlaceholders, ...randomEnvironmentOptions } = options ?? {};
+    return {
+        include: Object.entries(matrix)
+            .filter(([_key, value]) => !value.disabled)
+            .map(([key, value]) => ({
+            'job-name': key,
+            sample: key,
+            ...defaultGithubEnvironment,
+            ...(useVersionPlaceholders ? { 'java-version': 'JAVA-VERSION', 'node-version': 'NODE-VERSION', 'npm-version': 'NPM-VERSION' } : {}),
+            ...value,
+            ...(randomEnvironment ? randomEnvironmentMatrix(key, { useVersionPlaceholders, ...randomEnvironmentOptions }) : {}),
+        })),
+    };
+};

package/dist/lib/testing/github.d.ts

@@ -3,6 +3,7 @@ export declare const parseIssue: (issue: string) => undefined | {
     repository: string;
     issue: string;
 };
+export declare const getGithubOutputFile: () => string | undefined;
 export declare const setGithubTaskOutput: (name: string, value: string | boolean | number) => void;
 export declare const getGithubIssue: ({ owner, repository, issue }: {
     owner: string;

package/dist/lib/testing/github.js

@@ -10,11 +10,15 @@ export const parseIssue = (issue) => {
     }
     return undefined;
 };
+export const getGithubOutputFile = () => {
+    const filePath = process.env.GITHUB_OUTPUT;
+    return filePath && existsSync(filePath) ? filePath : undefined;
+};
 export const setGithubTaskOutput = (name, value) => {
     const delimiter = `delimiter_${randomUUID()}`;
     const output = `${name}<<${delimiter}${EOL}${value}${EOL}${delimiter}${EOL}`;
-    const filePath = process.env.GITHUB_OUTPUT;
-    if (filePath && existsSync(filePath)) {
+    const filePath = getGithubOutputFile();
+    if (filePath) {
         appendFileSync(filePath, output, { encoding: 'utf8' });
     }
     else {