io.evitadb.api.requestResponse.schema.builder.ReferenceSchemaBuilder Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of evita_api Show documentation
Show all versions of evita_api Show documentation
Module contains external API of the evitaDB.
/*
*
* _ _ ____ ____
* _____ _(_) |_ __ _| _ \| __ )
* / _ \ \ / / | __/ _` | | | | _ \
* | __/\ V /| | || (_| | |_| | |_) |
* \___| \_/ |_|\__\__,_|____/|____/
*
* Copyright (c) 2023-2024
*
* Licensed under the Business Source License, Version 1.1 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://github.com/FgForrest/evitaDB/blob/master/LICENSE
*
* 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.
*/
package io.evitadb.api.requestResponse.schema.builder;
import io.evitadb.api.exception.AttributeAlreadyPresentInEntitySchemaException;
import io.evitadb.api.exception.InvalidSchemaMutationException;
import io.evitadb.api.exception.SortableAttributeCompoundSchemaException;
import io.evitadb.api.requestResponse.schema.AttributeSchemaContract;
import io.evitadb.api.requestResponse.schema.AttributeSchemaEditor;
import io.evitadb.api.requestResponse.schema.Cardinality;
import io.evitadb.api.requestResponse.schema.CatalogSchemaContract;
import io.evitadb.api.requestResponse.schema.EntitySchemaContract;
import io.evitadb.api.requestResponse.schema.ReferenceSchemaContract;
import io.evitadb.api.requestResponse.schema.ReferenceSchemaEditor;
import io.evitadb.api.requestResponse.schema.SortableAttributeCompoundSchemaContract;
import io.evitadb.api.requestResponse.schema.SortableAttributeCompoundSchemaContract.AttributeElement;
import io.evitadb.api.requestResponse.schema.dto.ReferenceSchema;
import io.evitadb.api.requestResponse.schema.mutation.EntitySchemaMutation;
import io.evitadb.api.requestResponse.schema.mutation.ReferenceSchemaMutation;
import io.evitadb.api.requestResponse.schema.mutation.attribute.RemoveAttributeSchemaMutation;
import io.evitadb.api.requestResponse.schema.mutation.reference.CreateReferenceSchemaMutation;
import io.evitadb.api.requestResponse.schema.mutation.reference.ModifyReferenceAttributeSchemaMutation;
import io.evitadb.api.requestResponse.schema.mutation.reference.ModifyReferenceSchemaDeprecationNoticeMutation;
import io.evitadb.api.requestResponse.schema.mutation.reference.ModifyReferenceSchemaDescriptionMutation;
import io.evitadb.api.requestResponse.schema.mutation.reference.ModifyReferenceSchemaRelatedEntityGroupMutation;
import io.evitadb.api.requestResponse.schema.mutation.reference.ModifyReferenceSortableAttributeCompoundSchemaMutation;
import io.evitadb.api.requestResponse.schema.mutation.reference.SetReferenceSchemaFacetedMutation;
import io.evitadb.api.requestResponse.schema.mutation.reference.SetReferenceSchemaIndexedMutation;
import io.evitadb.api.requestResponse.schema.mutation.sortableAttributeCompound.RemoveSortableAttributeCompoundSchemaMutation;
import io.evitadb.exception.GenericEvitaInternalError;
import io.evitadb.utils.Assert;
import lombok.experimental.Delegate;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.io.Serial;
import java.io.Serializable;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Optional;
import java.util.function.Consumer;
import static io.evitadb.utils.Assert.isTrue;
import static java.util.Optional.ofNullable;
/**
* Internal {@link ReferenceSchema} builder used solely from within {@link InternalEntitySchemaBuilder}.
*
* @author Jan Novotný ([email protected]), FG Forrest a.s. (c) 2021
*/
public final class ReferenceSchemaBuilder
implements ReferenceSchemaEditor.ReferenceSchemaBuilder, InternalSchemaBuilderHelper {
@Serial private static final long serialVersionUID = -6435272035844056999L;
private final CatalogSchemaContract catalogSchema;
private final EntitySchemaContract entitySchema;
private final ReferenceSchemaContract baseSchema;
private final List mutations = new LinkedList<>();
private MutationImpact updatedSchemaDirty = MutationImpact.NO_IMPACT;
private int lastMutationReflectedInSchema = 0;
private ReferenceSchemaContract updatedSchema;
ReferenceSchemaBuilder(
@Nonnull CatalogSchemaContract catalogSchema,
@Nonnull EntitySchemaContract entitySchema,
@Nullable ReferenceSchemaContract existingSchema,
@Nonnull String name,
@Nonnull String entityType,
boolean entityTypeRelatesToEntity,
@Nonnull Cardinality cardinality,
@Nonnull List mutations,
boolean createNew
) {
this.catalogSchema = catalogSchema;
this.entitySchema = entitySchema;
this.baseSchema = existingSchema == null ?
ReferenceSchema._internalBuild(
name, entityType, entityTypeRelatesToEntity, cardinality, null, false, false, false
) :
existingSchema;
if (createNew) {
this.mutations.add(
new CreateReferenceSchemaMutation(
baseSchema.getName(),
baseSchema.getDescription(),
baseSchema.getDeprecationNotice(),
cardinality,
entityType,
entityTypeRelatesToEntity,
baseSchema.getReferencedGroupType(),
baseSchema.isReferencedGroupTypeManaged(),
baseSchema.isIndexed(),
baseSchema.isFaceted()
)
);
}
mutations.stream()
.filter(it -> it instanceof ReferenceSchemaMutation referenceSchemaMutation &&
(name.equals(referenceSchemaMutation.getName()) && !(referenceSchemaMutation instanceof CreateReferenceSchemaMutation)))
.forEach(this.mutations::add);
}
@Override
@Nonnull
public ReferenceSchemaBuilder withDescription(@Nullable String description) {
this.updatedSchemaDirty = updateMutationImpact(
this.updatedSchemaDirty,
addMutations(
this.catalogSchema, this.entitySchema, this.mutations,
new ModifyReferenceSchemaDescriptionMutation(getName(), description)
)
);
return this;
}
@Override
@Nonnull
public ReferenceSchemaBuilder deprecated(@Nonnull String deprecationNotice) {
this.updatedSchemaDirty = updateMutationImpact(
this.updatedSchemaDirty,
addMutations(
this.catalogSchema, this.entitySchema, this.mutations,
new ModifyReferenceSchemaDeprecationNoticeMutation(getName(), deprecationNotice)
)
);
return this;
}
@Override
@Nonnull
public ReferenceSchemaBuilder notDeprecatedAnymore() {
this.updatedSchemaDirty = updateMutationImpact(
this.updatedSchemaDirty,
addMutations(
this.catalogSchema, this.entitySchema, this.mutations,
new ModifyReferenceSchemaDeprecationNoticeMutation(getName(), null)
)
);
return this;
}
@Override
public ReferenceSchemaBuilder withGroupType(@Nonnull String groupType) {
this.updatedSchemaDirty = updateMutationImpact(
this.updatedSchemaDirty,
addMutations(
this.catalogSchema, this.entitySchema, this.mutations,
new ModifyReferenceSchemaRelatedEntityGroupMutation(getName(), groupType, false)
)
);
return this;
}
@Override
public ReferenceSchemaBuilder withGroupTypeRelatedToEntity(@Nonnull String groupType) {
this.updatedSchemaDirty = updateMutationImpact(
this.updatedSchemaDirty,
addMutations(
this.catalogSchema, this.entitySchema, this.mutations,
new ModifyReferenceSchemaRelatedEntityGroupMutation(getName(), groupType, true)
)
);
return this;
}
@Override
public ReferenceSchemaBuilder withoutGroupType() {
this.updatedSchemaDirty = updateMutationImpact(
this.updatedSchemaDirty,
addMutations(
this.catalogSchema, this.entitySchema, this.mutations,
new ModifyReferenceSchemaRelatedEntityGroupMutation(getName(), null, false)
)
);
return this;
}
@Override
public ReferenceSchemaBuilder indexed() {
this.updatedSchemaDirty = updateMutationImpact(
this.updatedSchemaDirty,
addMutations(
this.catalogSchema, this.entitySchema, this.mutations,
new SetReferenceSchemaIndexedMutation(getName(), true)
)
);
return this;
}
@Override
public ReferenceSchemaBuilder nonIndexed() {
this.updatedSchemaDirty = updateMutationImpact(
this.updatedSchemaDirty,
addMutations(
this.catalogSchema, this.entitySchema, this.mutations,
new SetReferenceSchemaIndexedMutation(getName(), false)
)
);
return this;
}
@Override
public ReferenceSchemaBuilder faceted() {
if (toInstance().isIndexed()) {
this.updatedSchemaDirty = updateMutationImpact(
this.updatedSchemaDirty,
addMutations(
this.catalogSchema, this.entitySchema, this.mutations,
new SetReferenceSchemaFacetedMutation(getName(), true)
)
);
} else {
this.updatedSchemaDirty = updateMutationImpact(
this.updatedSchemaDirty,
addMutations(
this.catalogSchema, this.entitySchema, this.mutations,
new SetReferenceSchemaIndexedMutation(getName(), true),
new SetReferenceSchemaFacetedMutation(getName(), true)
)
);
}
return this;
}
@Override
public ReferenceSchemaBuilder nonFaceted() {
this.updatedSchemaDirty = updateMutationImpact(
this.updatedSchemaDirty,
addMutations(
this.catalogSchema, this.entitySchema, this.mutations,
new SetReferenceSchemaFacetedMutation(getName(), false)
)
);
return this;
}
@Override
@Nonnull
public ReferenceSchemaBuilder withAttribute(@Nonnull String attributeName, @Nonnull Class ofType) {
return withAttribute(attributeName, ofType, null);
}
@Nonnull
@Override
public ReferenceSchemaBuilder withAttribute(
@Nonnull String attributeName,
@Nonnull Class ofType,
@Nullable Consumer whichIs
) {
final Optional existingAttribute = getAttribute(attributeName);
final AttributeSchemaBuilder attributeSchemaBuilder =
existingAttribute
.map(it -> {
Assert.isTrue(
ofType.equals(it.getType()),
() -> new InvalidSchemaMutationException(
"Attribute " + attributeName + " has already assigned type " + it.getType() +
", cannot change this type to: " + ofType + "!"
)
);
return new AttributeSchemaBuilder(entitySchema, it);
})
.orElseGet(() -> new AttributeSchemaBuilder(entitySchema, attributeName, ofType));
ofNullable(whichIs).ifPresent(it -> it.accept(attributeSchemaBuilder));
final AttributeSchemaContract attributeSchema = attributeSchemaBuilder.toInstance();
checkSortableTraits(attributeName, attributeSchema);
// check the names in all naming conventions are unique in the catalog schema
checkNamesAreUniqueInAllNamingConventions(
this.getAttributes().values(),
this.getSortableAttributeCompounds().values(),
attributeSchema
);
if (existingAttribute.map(it -> !it.equals(attributeSchema)).orElse(true)) {
this.updatedSchemaDirty = updateMutationImpact(
this.updatedSchemaDirty,
addMutations(
this.catalogSchema, this.entitySchema, this.mutations,
attributeSchemaBuilder
.toReferenceMutation(getName())
.stream()
.map(it -> (EntitySchemaMutation) it)
.toArray(EntitySchemaMutation[]::new)
)
);
}
return this;
}
@Override
@Nonnull
public ReferenceSchemaBuilder withoutAttribute(@Nonnull String attributeName) {
checkSortableAttributeCompoundsWithoutAttribute(
attributeName, this.getSortableAttributeCompounds().values()
);
this.updatedSchemaDirty = updateMutationImpact(
this.updatedSchemaDirty,
addMutations(
this.catalogSchema, this.entitySchema, this.mutations,
new ModifyReferenceAttributeSchemaMutation(
this.getName(),
new RemoveAttributeSchemaMutation(attributeName)
)
)
);
return this;
}
@Nonnull
@Override
public ReferenceSchemaBuilder withSortableAttributeCompound(
@Nonnull String name,
@Nonnull AttributeElement... attributeElements
) {
return withSortableAttributeCompound(
name, attributeElements, null
);
}
@Override
public ReferenceSchemaBuilder withSortableAttributeCompound(
@Nonnull String name,
@Nonnull AttributeElement[] attributeElements,
@Nullable Consumer whichIs
) {
final Optional existingCompound = getSortableAttributeCompound(name);
final SortableAttributeCompoundSchemaBuilder builder = new SortableAttributeCompoundSchemaBuilder(
catalogSchema,
entitySchema,
this,
this.baseSchema.getSortableAttributeCompound(name).orElse(null),
name,
Arrays.asList(attributeElements),
Collections.emptyList(),
true
);
final SortableAttributeCompoundSchemaBuilder schemaBuilder =
existingCompound
.map(it -> {
Assert.isTrue(
it.getAttributeElements().equals(Arrays.asList(attributeElements)),
() -> new AttributeAlreadyPresentInEntitySchemaException(
it, builder.toInstance(), null, name
)
);
return builder;
})
.orElse(builder);
ofNullable(whichIs).ifPresent(it -> it.accept(schemaBuilder));
final SortableAttributeCompoundSchemaContract compoundSchema = schemaBuilder.toInstance();
isTrue(
compoundSchema.getAttributeElements().size() > 1,
() -> new SortableAttributeCompoundSchemaException(
"Sortable attribute compound requires more than one attribute element!",
compoundSchema
)
);
isTrue(
compoundSchema.getAttributeElements().size() ==
compoundSchema.getAttributeElements()
.stream()
.map(AttributeElement::attributeName)
.distinct()
.count(),
() -> new SortableAttributeCompoundSchemaException(
"Attribute names of elements in sortable attribute compound must be unique!",
compoundSchema
)
);
checkSortableTraits(name, compoundSchema, this.getAttributes());
// check the names in all naming conventions are unique in the catalog schema
checkNamesAreUniqueInAllNamingConventions(
this.getAttributes().values(),
this.getSortableAttributeCompounds().values(),
compoundSchema
);
if (existingCompound.map(it -> !it.equals(compoundSchema)).orElse(true)) {
this.updatedSchemaDirty = updateMutationImpact(
this.updatedSchemaDirty,
addMutations(
this.catalogSchema, this.entitySchema, this.mutations,
schemaBuilder
.toReferenceMutation(getName())
.stream()
.map(it -> (EntitySchemaMutation) it)
.toArray(EntitySchemaMutation[]::new)
)
);
}
return this;
}
@Nonnull
@Override
public ReferenceSchemaBuilder withoutSortableAttributeCompound(@Nonnull String name) {
this.updatedSchemaDirty = updateMutationImpact(
this.updatedSchemaDirty,
addMutations(
this.catalogSchema, this.entitySchema, this.mutations,
new ModifyReferenceSortableAttributeCompoundSchemaMutation(
this.getName(),
new RemoveSortableAttributeCompoundSchemaMutation(name)
)
)
);
return this;
}
/**
* Builds new instance of immutable {@link ReferenceSchemaContract} filled with updated configuration.
*/
@Delegate(types = ReferenceSchemaContract.class)
@Nonnull
public ReferenceSchemaContract toInstance() {
if (this.updatedSchema == null || this.updatedSchemaDirty != MutationImpact.NO_IMPACT) {
// if the dirty flat is set to modified previous we need to start from the base schema again
// and reapply all mutations
if (this.updatedSchemaDirty == MutationImpact.MODIFIED_PREVIOUS) {
this.lastMutationReflectedInSchema = 0;
}
// if the last mutation reflected in the schema is zero we need to start from the base schema
// else we can continue modification last known updated schema by adding additional mutations
ReferenceSchemaContract currentSchema = this.lastMutationReflectedInSchema == 0 ?
this.baseSchema : this.updatedSchema;
// apply the mutations not reflected in the schema
for (int i = lastMutationReflectedInSchema; i < this.mutations.size(); i++) {
final EntitySchemaMutation mutation = this.mutations.get(i);
currentSchema = ((ReferenceSchemaMutation) mutation).mutate(entitySchema, currentSchema);
if (currentSchema == null) {
throw new GenericEvitaInternalError("Attribute unexpectedly removed from inside!");
}
}
this.updatedSchema = currentSchema;
this.updatedSchemaDirty = MutationImpact.NO_IMPACT;
this.lastMutationReflectedInSchema = this.mutations.size();
}
return this.updatedSchema;
}
@Override
@Nonnull
public Collection toMutation() {
return this.mutations;
}
}