generator-jhipster 8.7.0 → 8.7.2

package/dist/generators/base/support/jhipster7-context.d.ts

@@ -0,0 +1,371 @@
+import { hibernateSnakeCase } from '../../server/support/index.js';
+import { getJdbcUrl, getR2dbcUrl } from '../../spring-data-relational/support/database-url.js';
+import { upperFirstCamelCase } from '../../../lib/utils/string.js';
+export declare const jhipster7deprecatedProperties: {
+    devDatabaseType: {
+        behaviorOnlyReason: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    prodDatabaseType: {
+        behaviorOnlyReason: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    GRADLE_VERSION: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    NODE_VERSION: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    NPM_VERSION: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    JHIPSTER_DEPENDENCIES_VERSION: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    JAVA_VERSION: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    JAVA_COMPATIBLE_VERSIONS: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    SPRING_BOOT_VERSION: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    DOCKER_DIR: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    CLIENT_MAIN_SRC_DIR: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    CLIENT_TEST_SRC_DIR: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    CLIENT_DIST_DIR: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    BUILD_DIR: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    MAIN_SRC_DIR: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    DIST_DIR: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    userPrimaryKeyTypeString: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    userPrimaryKeyTypeUUID: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    _getClientTranslation: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    _getEntityClientTranslation: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    testsNeedCsrf: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    haveFieldWithJavadoc: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    fieldsContainBigDecimal: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    fieldsContainBlob: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    fieldsContainDate: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    fieldsContainDuration: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    fieldsContainInstant: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    fieldsContainLocalDate: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    fieldsContainTimed: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    fieldsContainUUID: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    fieldsContainZonedDateTime: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    fieldsContainImageBlob: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    fieldsContainTextBlob: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    fieldsContainBlobOrImage: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    validation: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    dependabotPackageJson: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => {
+            dependencies: any;
+            devDependencies: any;
+        };
+    };
+    cacheManagerIsAvailable: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    enableLiquibase: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    databaseTypePostgres: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    prodDatabaseTypePostgres: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    databaseTypeMariadb: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    databaseTypeMysql: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    databaseTypeOracle: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    databaseTypeMssql: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    cacheProviderEhCache: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    getJDBCUrl: {
+        replacement: string;
+        get: () => typeof getJdbcUrl;
+    };
+    getR2DBCUrl: {
+        replacement: string;
+        get: () => typeof getR2dbcUrl;
+    };
+    getDBCExtraOption: {
+        replacement: string;
+        get: () => (databaseType: any) => string;
+    };
+    getPrimaryKeyValue: {
+        replacement: string;
+        get: () => (primaryKey: any, databaseType: any, defaultValue?: number) => string;
+    };
+    getJoinTableName: {
+        replacement: string;
+        get: () => (...args: any[]) => string;
+    };
+    getJavaValueGeneratorForType: {
+        replacement: string;
+        get: () => (type: any) => string;
+    };
+    asEntity: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => (name: any) => string;
+    };
+    asDto: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => (name: any) => string;
+    };
+    upperFirstCamelCase: {
+        replacement: string;
+        get: () => typeof upperFirstCamelCase;
+    };
+    hasOauthUser: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => any;
+    };
+    getPrettierExtensions: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => () => any;
+    };
+    _generateSqlSafeName: {
+        replacement: string;
+        get: () => (name: any) => any;
+    };
+    isFilterableType: {
+        replacement: string;
+        get: () => (fieldType: any) => boolean;
+    };
+    getSpecificationBuilder: {
+        replacement: string;
+        get: () => (fieldType: import("../../../lib/application/field-types.js").FieldType) => "buildRangeSpecification" | "buildStringSpecification" | "buildSpecification";
+    };
+    getColumnName: {
+        replacement: string;
+        get: () => typeof hibernateSnakeCase;
+    };
+    isUsingBuiltInUser: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => () => any;
+    };
+    isUsingBuiltInAuthority: {
+        replacement: string;
+        get: ({ data }: {
+            data: any;
+        }) => () => any;
+    };
+    jhipsterConfig: {
+        replacement: string;
+        get: ({ generator }: {
+            generator: any;
+        }) => any;
+    };
+    configOptions: {
+        replacement: string;
+        get: () => {};
+    };
+};
+export declare function createJHipster7Context(generator: any, data: any, options: {
+    log: (msg: string) => void;
+}): any;

package/dist/generators/base/support/jhipster7-context.js

@@ -1,12 +1,12 @@
 /* eslint-disable no-console */
 import chalk from 'chalk';
 import { camelCase } from 'lodash-es';
-import { isReservedTableName } from '../../../jdl/jhipster/reserved-keywords.js';
+import { isReservedTableName } from '../../../lib/jhipster/reserved-keywords.js';
 import { getJavaValueGeneratorForType, getJoinTableName, getPrimaryKeyValue, getSpecificationBuildForType, hibernateSnakeCase, } from '../../server/support/index.js';
 import { getDBCExtraOption } from '../../spring-data-relational/support/database-data.js';
 import { getJdbcUrl, getR2dbcUrl } from '../../spring-data-relational/support/database-url.js';
-import { fieldTypes } from '../../../jdl/index.js';
-import { upperFirstCamelCase } from './string.js';
+import { fieldTypes } from '../../../lib/jhipster/index.js';
+import { upperFirstCamelCase } from '../../../lib/utils/string.js';
 const { BYTES, BYTE_BUFFER } = fieldTypes.RelationalOnlyDBTypes;
 export const jhipster7deprecatedProperties = {
     devDatabaseType: {
@@ -218,7 +218,9 @@ export const jhipster7deprecatedProperties = {
     },
     getJoinTableName: {
         replacement: 'joinTable property',
-        get: () => (...args) => getJoinTableName(...args).value,
+        get: () => (...args) => 
+        // @ts-expect-error
+        getJoinTableName(...args).value,
     },
     getJavaValueGeneratorForType: {
         replacement: 'javaValueGenerator property',
@@ -314,7 +316,7 @@ const getPropertBuilder = ({ log = msg => console.log(msg) } = {}) => (context,
     }
     return undefined;
 };
-const createHandler = ({ log } = {}) => {
+const createHandler = ({ log } = { log: msg => console.log(msg) }) => {
     const getProperty = getPropertBuilder({ log });
     return {
         ...Object.fromEntries([

package/dist/generators/base/support/needles.d.ts

@@ -0,0 +1,78 @@
+import type CoreGenerator from '../../base-core/index.js';
+import type { CascatedEditFileCallback, EditFileCallback, NeedleCallback } from '../api.js';
+export type NeedleInsertion = {
+    needle: string;
+    /**
+     * Content to add.
+     */
+    contentToAdd: string | string[] | ((content: string, options: {
+        needleIndent: number;
+        indentPrefix: string;
+    }) => string);
+    contentToCheck?: string | RegExp;
+    /**
+     * check existing content ignoring white spaces and new lines.
+     */
+    ignoreWhitespaces?: boolean;
+    /**
+     * throw error if needle was not found
+     */
+    optional?: boolean;
+    /**
+     * Detect and apply indent
+     */
+    autoIndent?: boolean;
+};
+type NeedleFileInsertion = NeedleInsertion & {
+    /**
+     * Path to file.
+     * The generator context must be passed.
+     */
+    filePath?: string;
+    /**
+     * Common needle prefix
+     */
+    needlesPrefix?: string;
+};
+type NeedleContentInsertion = NeedleInsertion & {
+    content: string;
+};
+/**
+ * Change spaces sequences and '>' to allow any number of spaces or new line prefix
+ */
+export declare const convertToPrettierExpressions: (str: string) => string;
+/**
+ * Check if contentToCheck existing in content
+ *
+ * @param contentToCheck
+ * @param content
+ * @param [ignoreWhitespaces=true]
+ */
+export declare const checkContentIn: (contentToCheck: string | RegExp, content: any, ignoreWhitespaces?: boolean) => boolean;
+/**
+ * Write content before needle applying indentation
+ *
+ * @param args
+ * @returns null if needle was not found, new content otherwise
+ */
+export declare const insertContentBeforeNeedle: ({ content, contentToAdd, needle, autoIndent }: NeedleContentInsertion) => string | null;
+/**
+ * Create an callback to insert the new content into existing content.
+ *
+ * A `contentToAdd` of string type will remove leading `\n`.
+ * Leading `\n` allows a prettier template formatting.
+ *
+ * @param options
+ */
+export declare const createNeedleCallback: <Generator extends CoreGenerator = CoreGenerator>({ needle, contentToAdd, contentToCheck, optional, ignoreWhitespaces, autoIndent, }: NeedleInsertion) => EditFileCallback<Generator>;
+/**
+ * Inject content before needle or create a needle insertion callback.
+ *
+ * @param this - generator if provided, editFile will be executed
+ */
+export declare function createBaseNeedle(options: Omit<NeedleFileInsertion, 'filePath' | 'needle' | 'contentToAdd'>, needles: Record<string, string>): NeedleCallback;
+export declare function createBaseNeedle(needles: Record<string, string>): NeedleCallback;
+export declare function createBaseNeedle<Generator extends CoreGenerator = CoreGenerator>(this: Generator, options: Omit<NeedleFileInsertion, 'filePath' | 'needle' | 'contentToAdd'> & {
+    filePath: string;
+}, needles: Record<string, string>): CascatedEditFileCallback<Generator>;
+export {};

package/dist/generators/base/support/needles.js

@@ -148,28 +148,23 @@ export const createNeedleCallback = ({ needle, contentToAdd, contentToCheck, opt
             return newContent;
         }
         const message = `Missing ${optional ? 'optional' : 'required'} jhipster-needle ${needle} not found at '${filePath}'`;
-        if (optional) {
+        if (optional && this) {
             this.log.warn(message);
             return content;
         }
         throw new Error(message);
     };
 };
-/**
- * Inject content before needle or create a needle insertion callback.
- *
- * @param this - generator if provided, editFile will be executed
- */
 export function createBaseNeedle(options, needles) {
     const actualNeedles = needles === undefined ? options : needles;
     const actualOptions = needles === undefined ? {} : options;
     assert(actualNeedles, 'needles is required');
-    const { filePath, optional = false, ignoreWhitespaces = true } = actualOptions;
-    let { needlesPrefix } = actualOptions;
-    needlesPrefix = needlesPrefix ? `${needlesPrefix}-` : '';
+    const { needlesPrefix, filePath, ...needleOptions } = actualOptions;
+    needleOptions.optional = needleOptions.optional ?? false;
+    needleOptions.ignoreWhitespaces = needleOptions.ignoreWhitespaces ?? true;
     const callbacks = Object.entries(actualNeedles)
         .filter(([_key, contentToAdd]) => contentToAdd)
-        .map(([key, contentToAdd]) => createNeedleCallback({ needle: `${needlesPrefix}${kebabCase(key)}`, contentToAdd, optional, ignoreWhitespaces }));
+        .map(([key, contentToAdd]) => createNeedleCallback({ ...needleOptions, needle: `${needlesPrefix ? `${needlesPrefix}-` : ''}${kebabCase(key)}`, contentToAdd }));
     assert(callbacks.length > 0, 'At least 1 needle is required');
     const callback = callbacks.length === 1 ? callbacks[0] : joinCallbacks(...callbacks);
     if (filePath) {

package/dist/generators/base/support/remote.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @private
+ * Function to issue a https get request, and process the result
+ *
+ *  @param {string} url - the url to fetch
+ *  @param {function} onSuccess - function, which gets called when the request succeeds, with the body of the response
+ *  @param {function} onFail - callback when the get failed.
+ */
+declare const httpsGet: (url: any, onSuccess: any, onFail: any) => void;
+export default httpsGet;

package/dist/generators/base/support/secret.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Get a random hex string
+ * @param {number} len the length to use, defaults to 50
+ */
+export declare function createSecret(len?: number): string;
+/**
+ * Generates a base64 secret from given string or random hex
+ * @param secret the value used to get base64 secret
+ */
+export declare function convertSecretToBase64(secret: string): string;
+/**
+ * Generates a base64 secret from given string or random hex
+ * @param len the length to use for random hex, defaults to 50
+ * @param reproducible generate a reproducible content
+ */
+export declare function createBase64Secret(len?: number, reproducible?: boolean): any;
+export declare function createBase64Secret(reproducible?: boolean): any;
+/**
+ * Create a strong secret from a timestamp and a base name
+ */
+export declare function createSafeSecret(timestamp: number, baseName: string): string;

package/dist/generators/base/support/secret.js

@@ -42,3 +42,9 @@ export function createBase64Secret(len, reproducible = false) {
     }
     return Buffer.from(createSecret(len)).toString('base64');
 }
+/**
+ * Create a strong secret from a timestamp and a base name
+ */
+export function createSafeSecret(timestamp, baseName) {
+    return Buffer.from(`${timestamp}-${baseName}`).toString('base64');
+}

package/dist/generators/base/support/timestamp.js

@@ -51,8 +51,16 @@ export function parseChangelog(changelogDate) {
     if (changelogDate.length !== 14) {
         throw new Error(`changelogDate ${changelogDate} is not a valid changelogDate.`);
     }
-    const formattedDate = `${changelogDate.substring(0, 4)}-${changelogDate.substring(4, 6)}-${changelogDate.substring(6, 8)}T${changelogDate.substring(8, 10)}:${changelogDate.substring(10, 12)}:${changelogDate.substring(12, 14)}+00:00`;
-    return new Date(Date.parse(formattedDate));
+    const zeroFallback = (val, fallback) => (/^0+$/.test(val) ? fallback : val);
+    const year = zeroFallback(changelogDate.substring(0, 4), '2024');
+    const month = zeroFallback(changelogDate.substring(4, 6), '01');
+    const day = zeroFallback(changelogDate.substring(6, 8), '01');
+    const formattedDate = `${year}-${month}-${day}T${changelogDate.substring(8, 10)}:${changelogDate.substring(10, 12)}:${changelogDate.substring(12, 14)}+00:00`;
+    const parsedTimestamp = Date.parse(formattedDate);
+    if (isNaN(parsedTimestamp)) {
+        throw new Error(`changelogDate ${changelogDate} is not a valid date.`);
+    }
+    return new Date(parsedTimestamp);
 }
 /**
  * Parse creationTimestamp option

package/dist/generators/base/support/write-files.js

@@ -25,7 +25,7 @@ const isWin32 = platform() === 'win32';
  */
 export function joinCallbacks(...callbacks) {
     return function (content, filePath) {
-        if (isWin32 && content.match(/\r\n/)) {
+        if (isWin32 && /\r\n/.exec(content)) {
             const removeSlashRSlashN = ct => normalizeLineEndings(ct, '\n');
             const addSlashRSlashN = ct => normalizeLineEndings(ct, '\r\n');
             callbacks = [removeSlashRSlashN, ...callbacks, addSlashRSlashN];

package/dist/generators/base/types-export.d.ts

@@ -0,0 +1,4 @@
+import type Generator from './index.js';
+
+// Remove generics support
+export type BaseGenerator = Generator;

package/dist/generators/base/types.d.ts

@@ -0,0 +1,28 @@
+import type { Entity } from '../base-application/index.js';
+import type { ExportControlPropertiesFromCommand } from '../../lib/command/index.js';
+import type command from './command.ts';
+
+type BaseApplicationControlProperties = ExportControlPropertiesFromCommand<typeof command>;
+
+export type Control = BaseApplicationControlProperties & {
+  existingProject: boolean;
+  ignoreNeedlesError: boolean;
+  jhipsterOldVersion: string | null;
+  useVersionPlaceholders?: boolean;
+  /**
+   * Configure blueprints once per application.
+   */
+  blueprintConfigured?: boolean;
+  reproducibleLiquibaseTimestamp?: Date;
+  filterEntitiesForClient?: (entity: Entity[]) => Entity[];
+  filterEntitiesAndPropertiesForClient?: (entity: Entity[]) => Entity[];
+  customizeRemoveFiles: ((file: string) => string | undefined)[];
+  removeFiles: (options: { removedInVersion: string } | string, ...files: string[]) => Promise<void>;
+  /**
+   * Cleanup files conditionally based on version and condition.
+   * @example
+   * cleanupFiles({ '6.0.0': ['file1', 'file2', [application.shouldRemove, 'file3']] })
+   */
+  cleanupFiles: (cleanup: Record<string, (string | [boolean, ...string[]])[]>) => Promise<void>;
+  getWebappTranslation?: (s: string, data?: Record<string, any>) => string;
+};