generator-begcode
Version:
Spring Boot + Angular/React/Vue in one handy generator
147 lines (146 loc) • 7.76 kB
JavaScript
import BaseApplicationGenerator from '../base-application/index.js';
import writeTask from './files.js';
import cleanupTask from './cleanup.js';
import { createNeedleCallback } from '../base/support/needles.js';
import { getCacheProviderMavenDefinition } from './internal/dependencies.js';
export default class SpringCacheGenerator extends BaseApplicationGenerator {
async beforeQueue() {
if (!this.fromBlueprint) {
await this.composeWithBlueprints();
}
if (!this.delegateToBlueprint) {
await this.dependsOnBootstrapApplication();
}
}
get preparing() {
return this.asPreparingTaskGroup({
loadDependabot({ application }) {
this.loadJavaDependenciesFromGradleCatalog(application.javaDependencies, true);
},
addNeedles({ source, application }) {
if (application.cacheProviderEhcache ||
application.cacheProviderCaffeine ||
application.cacheProviderRedis) {
const cacheConfigurationFile = `${application.javaPackageSrcDir}config/CacheConfiguration.java`;
const needle = `${application.cacheProvider}-add-entry`;
const useJcacheConfiguration = application.cacheProviderRedis;
const addEntryToCacheCallback = entry => createNeedleCallback({
needle,
contentToAdd: `createCache(cm, ${entry}${useJcacheConfiguration ? ', jcacheConfiguration' : ''});`,
});
source.addEntryToCache = ({ entry }) => this.editFile(cacheConfigurationFile, addEntryToCacheCallback(entry));
source.addEntityToCache = ({ entityAbsoluteClass, relationships }) => {
const entry = `${entityAbsoluteClass}.class.getName()`;
this.editFile(cacheConfigurationFile, addEntryToCacheCallback(entry), ...(relationships ?? [])
.filter(rel => rel.collection)
.map(rel => addEntryToCacheCallback(`${entry} + ".${rel.propertyName}"`)));
};
}
else {
source.addEntryToCache = () => { };
source.addEntityToCache = () => { };
}
},
});
}
get [BaseApplicationGenerator.PREPARING]() {
return this.delegateTasksToBlueprint(() => this.preparing);
}
get writing() {
return this.asWritingTaskGroup({
cleanupTask,
writeTask,
});
}
get [BaseApplicationGenerator.WRITING]() {
return this.delegateTasksToBlueprint(() => this.writing);
}
get postWriting() {
return this.asPostWritingTaskGroup({
addTestSpringFactory({ source, application }) {
if (application.cacheProviderRedis) {
source.addTestSpringFactory?.({
key: 'org.springframework.test.context.ContextCustomizerFactory',
value: `${application.packageName}.config.RedisTestContainersSpringContextCustomizerFactory`,
});
}
},
applyGradleScript({ source, application }) {
if (application.buildToolGradle) {
const applicationAny = application;
if (applicationAny.cacheProviderCaffeine) {
source.addGradleDependencyCatalogVersion?.({ name: 'typesafe', version: application.javaDependencies?.typesafe });
source.addGradleBuildSrcDependencyCatalogVersion?.({ name: 'typesafe', version: application.javaDependencies?.typesafe });
}
if (applicationAny.cacheProviderHazelcast) {
source.addGradleDependencyCatalogVersion?.({
name: 'hazelcast-spring',
version: application.javaDependencies?.['hazelcast-spring'],
});
source.addGradleBuildSrcDependencyCatalogVersion?.({
name: 'hazelcast-spring',
version: application.javaDependencies?.['hazelcast-spring'],
});
if (applicationAny.enableHibernateCache) {
source.addGradleDependencyCatalogVersion?.({
name: 'hazelcast-hibernate53',
version: application.javaDependencies?.['hazelcast-hibernate53'],
});
source.addGradleBuildSrcDependencyCatalogVersion?.({
name: 'hazelcast-hibernate53',
version: application.javaDependencies?.['hazelcast-hibernate53'],
});
}
}
source.addGradlePlugin?.({ id: 'jhipster.spring-cache-conventions' });
}
},
addDependencies({ application, source }) {
if (!application.javaDependencies) {
throw new Error('Some application fields are be mandatory');
}
const { javaDependencies } = application;
const { cacheProvider, enableHibernateCache, javaVersion, ormTool } = application;
const dependencies = [{ groupId: 'org.springframework.boot', artifactId: 'spring-boot-starter-cache' }];
const versions = [];
const definition = getCacheProviderMavenDefinition(cacheProvider, javaDependencies, javaVersion, ormTool);
versions.push(...(definition.base.versions ?? []));
dependencies.push(...definition.base.dependencies);
if (enableHibernateCache && definition.hibernateCache) {
versions.push(...(definition.hibernateCache.versions ?? []));
dependencies.push(...definition.hibernateCache.dependencies);
}
source.addJavaDefinition?.({ dependencies, versions }, { gradleFile: 'buildSrc/src/main/groovy/jhipster.spring-cache-conventions.gradle' });
},
});
}
get [BaseApplicationGenerator.POST_WRITING]() {
return this.delegateTasksToBlueprint(() => this.postWriting);
}
get postWritingEntities() {
return this.asPostWritingEntitiesTaskGroup({
customizeFiles({ application, entities, source }) {
if (application.databaseTypeSql) {
for (const entity of entities.filter(entity => !entity.skipServer && !entity.builtIn)) {
const relationships = [...(entity.relationships || [])];
if (entity.name?.toLowerCase() === 'user' && application.authenticationTypeSession) {
relationships.push({
collection: true,
propertyName: 'persistentTokens',
relationshipName: 'persistentTokens',
persistableRelationship: false,
});
}
source.addEntityToCache?.({
entityAbsoluteClass: entity.entityAbsoluteClass,
relationships,
});
}
}
},
});
}
get [BaseApplicationGenerator.POST_WRITING_ENTITIES]() {
return this.delegateTasksToBlueprint(() => this.postWritingEntities);
}
}