index int64 | repo_id string | file_path string | content string |
|---|---|---|---|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition/exceptions/CannotMapOperationDefinitionToStructureType.java | package ai.stapi.graphsystem.operationdefinition.exceptions;
public class CannotMapOperationDefinitionToStructureType extends RuntimeException {
public CannotMapOperationDefinitionToStructureType(
String operationName,
String parameterName,
String parameterType,
Throwable cause
) {
super(
String.format(
"Cannot map Operation Definition '%s' to Structure Type, " +
"because it had parameter '%s' of type '%s' which does not have Structure Schema.",
operationName,
parameterName,
parameterType
),
cause
);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition/exceptions/CannotMergeOperationDefinition.java | package ai.stapi.graphsystem.operationdefinition.exceptions;
public class CannotMergeOperationDefinition extends RuntimeException {
private CannotMergeOperationDefinition(String becauseMessage) {
super("Cannot merge Operation Definition, because " + becauseMessage);
}
public static CannotMergeOperationDefinition becauseSomeFieldIsNotSame(
String fieldName,
Object originalValue,
Object otherValue
) {
return new CannotMergeOperationDefinition(
String.format(
"field '%s' has different value, but they should be same.%nOriginal: '%s'%nOther: '%s'",
fieldName,
originalValue,
otherValue
)
);
}
public static CannotMergeOperationDefinition becauseSomeParameterHasSomeFieldWhichIsNotSame(
String parameterName,
String fieldName,
Object originalValue,
Object otherValue
) {
return new CannotMergeOperationDefinition(
String.format(
"parameter '%s' has field '%s' with different values, "
+ "but they should be same.%nOriginal: '%s'%nOther: '%s'",
parameterName,
fieldName,
originalValue,
otherValue
)
);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition/exceptions/CannotProvideOperationDefinition.java | package ai.stapi.graphsystem.operationdefinition.exceptions;
public class CannotProvideOperationDefinition extends RuntimeException {
public CannotProvideOperationDefinition(String operationDefinitionName) {
super(
String.format(
"Cannot Provide operation definition for: '%s', because it does not exists.",
operationDefinitionName
)
);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition/exceptions/CannotProvideOperationDefinitions.java | package ai.stapi.graphsystem.operationdefinition.exceptions;
public class CannotProvideOperationDefinitions extends RuntimeException {
public CannotProvideOperationDefinitions(String message) {
super(message);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition/exceptions/InvalidOperationDefinition.java | package ai.stapi.graphsystem.operationdefinition.exceptions;
public class InvalidOperationDefinition extends RuntimeException {
public InvalidOperationDefinition(String message) {
super(message);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition/infrastructure/AdHocOperationDefinitionProvider.java | package ai.stapi.graphsystem.operationdefinition.infrastructure;
import ai.stapi.schema.adHocLoaders.GenericAdHocModelDefinitionsLoader;
import ai.stapi.schema.scopeProvider.ScopeCacher;
import ai.stapi.schema.scopeProvider.ScopeOptions;
import ai.stapi.graphsystem.operationdefinition.exceptions.CannotProvideOperationDefinition;
import ai.stapi.graphsystem.operationdefinition.exceptions.CannotProvideOperationDefinitions;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionDTO;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionDTO.ParameterDTO;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionProvider;
import java.util.List;
import java.util.stream.Collectors;
import org.springframework.stereotype.Service;
public class AdHocOperationDefinitionProvider implements OperationDefinitionProvider {
private final GenericAdHocModelDefinitionsLoader genericAdHocModelDefinitionsLoader;
private final ScopeCacher scopeCacher;
public AdHocOperationDefinitionProvider(
GenericAdHocModelDefinitionsLoader genericAdHocModelDefinitionsLoader,
ScopeCacher scopeCacher
) {
this.genericAdHocModelDefinitionsLoader = genericAdHocModelDefinitionsLoader;
this.scopeCacher = scopeCacher;
}
@Override
public List<OperationDefinitionDTO> provideAll() {
return this.getOperationDefinitions();
}
@Override
public OperationDefinitionDTO provide(
String operationId
) throws CannotProvideOperationDefinition {
return this.getOperationDefinitions().stream()
.filter(operation -> operation.getId().equals(operationId))
.findFirst()
.orElseThrow(() -> new CannotProvideOperationDefinition(operationId));
}
@Override
public boolean contains(String operationId) {
return this.getOperationDefinitions().stream().anyMatch(
operation -> operation.getId().equals(operationId)
);
}
private List<OperationDefinitionDTO> getOperationDefinitions() {
return this.scopeCacher.getCachedOrCompute(
AdHocOperationDefinitionProvider.class,
this::load
);
}
private List<OperationDefinitionDTO> load(ScopeOptions scopeOptions) {
var createOperation = this.genericAdHocModelDefinitionsLoader.load(
scopeOptions,
"CreateOperationDefinition",
OperationDefinitionDTO.class
).stream()
.toList();
var addParameterOnOperation = this.genericAdHocModelDefinitionsLoader.load(
scopeOptions,
"AddParameterOnOperationDefinition",
AddParameterOnOperationDefinitionDTO.class
).stream()
.toList();
var addParameterWithoutTarget = addParameterOnOperation.stream()
.filter(map -> this.isContainedInFoundOperations(createOperation, map))
.toList();
if (!addParameterWithoutTarget.isEmpty()) {
throw new CannotProvideOperationDefinitions(
String.format(
"Cannot provide operation definitions for scope: %s with tags: %s.%n%s%n%s",
scopeOptions.getScopes(),
scopeOptions.getTags(),
"There were some AddParameterOnOperationDefinition JSONs which eiter did "
+ "not have id specified or it was missing in found OperationDefinitions.",
"Missing ids: " + addParameterWithoutTarget.stream()
.map(AddParameterOnOperationDefinitionDTO::getId)
.toList()
)
);
}
var groupedParams = addParameterOnOperation
.stream()
.collect(Collectors.groupingBy(AddParameterOnOperationDefinitionDTO::getId));
return createOperation.stream().map(operation -> {
var addedParameters = groupedParams.get(operation.getId());
if (addedParameters == null) {
return operation;
}
var newParameters = addedParameters.stream()
.map(AddParameterOnOperationDefinitionDTO::getParameter)
.flatMap(List::stream)
.toList();
operation.addParameters(newParameters);
return operation;
}).toList();
}
private boolean isContainedInFoundOperations(
List<OperationDefinitionDTO> createOperation,
AddParameterOnOperationDefinitionDTO addParameterDTO
) {
return addParameterDTO.getId() == null || createOperation.stream().noneMatch(
operation -> operation.getId().equals(addParameterDTO.getId())
);
}
private static class AddParameterOnOperationDefinitionDTO {
private String id;
private List<ParameterDTO> parameter;
private AddParameterOnOperationDefinitionDTO() {
}
public AddParameterOnOperationDefinitionDTO(String id, List<ParameterDTO> parameter) {
this.id = id;
this.parameter = parameter;
}
public String getId() {
return id;
}
public List<ParameterDTO> getParameter() {
return parameter;
}
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition/infrastructure/DatabaseOperationDefinitionProvider.java | package ai.stapi.graphsystem.operationdefinition.infrastructure;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.EdgeDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NodeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NodeDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.UuidIdentityDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.AttributeQueryDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.NodeQueryGraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.OutgoingEdgeQueryDescription;
import ai.stapi.graphoperations.graphLoader.GraphLoader;
import ai.stapi.graphoperations.graphLoader.search.SearchQueryParameters;
import ai.stapi.graphoperations.graphLoader.search.paginationOption.OffsetPaginationOption;
import ai.stapi.graphsystem.operationdefinition.exceptions.CannotProvideOperationDefinition;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionDTO;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionProvider;
import java.util.ArrayList;
import java.util.List;
public class DatabaseOperationDefinitionProvider implements OperationDefinitionProvider {
private final GraphLoader graphLoader;
private List<OperationDefinitionDTO> cachedOperations;
public DatabaseOperationDefinitionProvider(GraphLoader graphLoader) {
this.graphLoader = graphLoader;
this.cachedOperations = new ArrayList<>();
}
@Override
public List<OperationDefinitionDTO> provideAll() {
this.cacheOperations();
return this.cachedOperations;
}
@Override
public OperationDefinitionDTO provide(
String operationId
) throws CannotProvideOperationDefinition {
this.cacheOperations();
return this.cachedOperations.stream()
.filter(operation -> operation.getId().equals(operationId))
.findFirst()
.orElseThrow(() -> new CannotProvideOperationDefinition(operationId));
}
@Override
public boolean contains(String operationId) {
this.cacheOperations();
return this.cachedOperations.stream().anyMatch(
operation -> operation.getId().equals(operationId)
);
}
private void cacheOperations() {
if (this.cachedOperations.isEmpty()) {
this.cachedOperations = this.graphLoader.find(
this.getOperationGraphDescription(),
OperationDefinitionDTO.class
).getData();
}
}
public NodeQueryGraphDescription getOperationGraphDescription() {
return new NodeQueryGraphDescription(
new NodeDescriptionParameters("OperationDefinition"),
SearchQueryParameters.builder()
.setPaginationOption(new OffsetPaginationOption(0, 50000))
.build(),
new UuidIdentityDescription(),
new AttributeQueryDescription("name"),
new AttributeQueryDescription("status"),
new AttributeQueryDescription("kind"),
new AttributeQueryDescription("description"),
new AttributeQueryDescription("code"),
new AttributeQueryDescription("resource"),
new AttributeQueryDescription("system"),
new AttributeQueryDescription("type"),
new AttributeQueryDescription("instance"),
new OutgoingEdgeQueryDescription(
new EdgeDescriptionParameters("parameter"),
SearchQueryParameters.builder()
.setPaginationOption(new OffsetPaginationOption(0, 300))
.build(),
new NodeDescription(
new NodeDescriptionParameters("OperationDefinitionParameter"),
new AttributeQueryDescription("name"),
new AttributeQueryDescription("use"),
new AttributeQueryDescription("min"),
new AttributeQueryDescription("max"),
new AttributeQueryDescription("type"),
new OutgoingEdgeQueryDescription(
new EdgeDescriptionParameters("referencedFrom"),
SearchQueryParameters.builder()
.setPaginationOption(new OffsetPaginationOption(0, 300))
.build(),
new NodeDescription(
new NodeDescriptionParameters("OperationDefinitionParameterReferencedFrom"),
new AttributeQueryDescription("source")
)
),
new OutgoingEdgeQueryDescription(
new EdgeDescriptionParameters("targetProfile"),
SearchQueryParameters.builder()
.setPaginationOption(new OffsetPaginationOption(0, 300))
.build(),
new NodeDescription(
new NodeDescriptionParameters("StructureDefinition"),
new UuidIdentityDescription()
)
)
)
)
);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition/infrastructure/NullOperationDefinitionProvider.java | package ai.stapi.graphsystem.operationdefinition.infrastructure;
import ai.stapi.graphsystem.operationdefinition.exceptions.CannotProvideOperationDefinition;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionDTO;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionProvider;
import java.util.List;
public class NullOperationDefinitionProvider implements OperationDefinitionProvider {
@Override
public List<OperationDefinitionDTO> provideAll() {
return List.of();
}
@Override
public OperationDefinitionDTO provide(String operationId)
throws CannotProvideOperationDefinition {
throw new CannotProvideOperationDefinition(operationId);
}
@Override
public boolean contains(String operationId) {
return false;
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition/infrastructure/OnDemandOperationDefinitionProvider.java | package ai.stapi.graphsystem.operationdefinition.infrastructure;
import ai.stapi.schema.scopeProvider.ScopeCacher;
import ai.stapi.schema.scopeProvider.ScopeOptions;
import ai.stapi.graphsystem.operationdefinition.exceptions.CannotProvideOperationDefinition;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionDTO;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionProvider;
import ai.stapi.graphsystem.operationdefinition.model.resourceStructureTypeOperationsMapper.ResourceOperationsMapper;
import ai.stapi.schema.structureSchema.ResourceStructureType;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaProvider;
import java.util.List;
public class OnDemandOperationDefinitionProvider implements OperationDefinitionProvider {
private final List<ResourceOperationsMapper> resourceOperationsMappers;
private final StructureSchemaProvider structureSchemaProvider;
private final ScopeCacher scopeCacher;
public OnDemandOperationDefinitionProvider(
List<ResourceOperationsMapper> resourceOperationsMappers,
StructureSchemaProvider structureSchemaProvider,
ScopeCacher scopeCacher
) {
this.resourceOperationsMappers = resourceOperationsMappers;
this.structureSchemaProvider = structureSchemaProvider;
this.scopeCacher = scopeCacher;
}
@Override
public List<OperationDefinitionDTO> provideAll() {
return this.getOperations();
}
@Override
public OperationDefinitionDTO provide(
String operationId
) throws CannotProvideOperationDefinition {
return this.getOperations().stream()
.filter(operation -> operation.getId().equals(operationId))
.findFirst()
.orElseThrow(() -> new CannotProvideOperationDefinition(operationId));
}
@Override
public boolean contains(String operationId) {
return this.getOperations().stream().anyMatch(
operation -> operation.getId().equals(operationId)
);
}
private List<OperationDefinitionDTO> getOperations() {
return this.scopeCacher.getCachedOrCompute(
OnDemandOperationDefinitionProvider.class,
this::createOperations
);
}
private List<OperationDefinitionDTO> createOperations(ScopeOptions scopeOptions) {
var structureTypes = this.structureSchemaProvider.provideSchema()
.getStructureTypes()
.values();
return structureTypes
.stream()
.filter(ResourceStructureType.class::isInstance)
.map(ResourceStructureType.class::cast)
.flatMap(
resourceStructureType -> this.resourceOperationsMappers.stream().flatMap(
mapper -> mapper.map(resourceStructureType).getOperations().stream()
)
).toList();
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition/model/FieldDefinitionWithSource.java | package ai.stapi.graphsystem.operationdefinition.model;
import ai.stapi.schema.structureSchema.FieldDefinition;
import ai.stapi.schema.structureSchema.FieldType;
import com.fasterxml.jackson.annotation.JsonIgnore;
import java.util.List;
public class FieldDefinitionWithSource extends FieldDefinition {
private final String source;
public FieldDefinitionWithSource(
String name,
Integer min,
String max,
String description,
List<FieldType> types,
String parentDefinitionType,
String source
) {
super(name, min, max, description, types, parentDefinitionType);
this.source = source;
}
@JsonIgnore
public String getSource() {
return source;
}
@JsonIgnore
public String[] getSplitSource() {
return source.split("\\.");
}
@JsonIgnore
public int getSourceLength() {
return this.getSplitSource().length;
}
@JsonIgnore
public String getLastSourcePath() {
return this.getSplitSource()[this.getSourceLength() - 1];
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition/model/OperationDefinitionDTO.java | package ai.stapi.graphsystem.operationdefinition.model;
import ai.stapi.graphsystem.operationdefinition.exceptions.CannotMergeOperationDefinition;
import ai.stapi.graphsystem.operationdefinition.exceptions.InvalidOperationDefinition;
import ai.stapi.schema.structuredefinition.StructureDefinitionId;
import com.fasterxml.jackson.annotation.JsonIgnore;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import org.apache.commons.lang3.StringUtils;
public class OperationDefinitionDTO {
private String id;
private String name;
private String status;
private String kind;
private List<String> description;
private String code;
private List<String> resource;
private boolean system;
private boolean type;
private boolean instance;
private List<ParameterDTO> parameter;
private OperationDefinitionDTO() {
}
public OperationDefinitionDTO(
String id,
String name,
String status,
String kind,
String description,
String code,
List<String> resource,
boolean system,
boolean type,
boolean instance,
List<ParameterDTO> parameter
) {
this(
id,
name,
status,
kind,
List.of(description),
code,
resource,
system,
type,
instance,
parameter
);
}
private OperationDefinitionDTO(
String id,
String name,
String status,
String kind,
List<String> description,
String code,
List<String> resource,
boolean system,
boolean type,
boolean instance,
List<ParameterDTO> parameter
) {
this.id = id;
this.name = name;
this.status = status;
this.kind = kind;
this.description = description;
this.code = code;
this.resource = resource;
this.system = system;
this.type = type;
this.instance = instance;
this.parameter = parameter;
}
public static OperationDefinitionDTO bareBone(
String id,
List<ParameterDTO> parameter
) {
return new OperationDefinitionDTO(
id,
null,
null,
null,
"",
null,
List.of(),
false,
false,
false,
parameter
);
}
public void addParameters(List<ParameterDTO> parameters) {
this.parameter.addAll(parameters);
}
public OperationDefinitionDTO merge(OperationDefinitionDTO other) {
if (!Objects.equals(this.getId(), other.getId())) {
throw CannotMergeOperationDefinition.becauseSomeFieldIsNotSame(
"id",
this.getId(),
other.getId()
);
}
if (!Objects.equals(this.getCode(), other.getCode())) {
throw CannotMergeOperationDefinition.becauseSomeFieldIsNotSame(
"code",
this.getCode(),
other.getCode()
);
}
if (!Objects.equals(this.getName(), other.getName())) {
throw CannotMergeOperationDefinition.becauseSomeFieldIsNotSame(
"name",
this.getName(),
other.getName()
);
}
if (!Objects.equals(this.getStatus(), other.getStatus())) {
throw CannotMergeOperationDefinition.becauseSomeFieldIsNotSame(
"status",
this.getStatus(),
other.getStatus()
);
}
if (!Objects.equals(this.getKind(), other.getKind())) {
throw CannotMergeOperationDefinition.becauseSomeFieldIsNotSame(
"kind",
this.getKind(),
other.getKind()
);
}
var mergedResources = new HashSet<>(this.getResource());
mergedResources.addAll(other.getResource());
var mergedParameters = new ArrayList<>(this.getParameter());
mergedParameters.addAll(other.getParameter());
var deduplicatedParams = mergedParameters.stream()
.collect(Collectors.groupingBy(ParameterDTO::getName))
.values()
.stream()
.map(group -> group.stream().collect(Collectors.groupingBy(ParameterDTO::getType)))
.map(group -> group.values().stream().map(
typeGroup -> typeGroup.stream().reduce(ParameterDTO::merge).get()
).toList()
).flatMap(group -> {
if (group.size() == 1) {
return group.stream();
}
return group.stream().map(parameterDTO -> new ParameterDTO(
String.format(
"%s%s",
parameterDTO.getName(),
StringUtils.capitalize(parameterDTO.getType())
),
parameterDTO.getUse(),
parameterDTO.getMin(),
parameterDTO.getMax(),
parameterDTO.getType(),
parameterDTO.getReferencedFrom(),
parameterDTO.getTargetProfileRef()
));
}).toList();
var mergedDescriptions = new ArrayList<>(this.description);
mergedDescriptions.addAll(other.description);
return new OperationDefinitionDTO(
this.getId(),
this.getName(),
this.getStatus(),
this.getKind(),
mergedDescriptions,
this.getCode(),
mergedResources.stream().toList(),
this.isSystem() || other.isSystem(),
this.isType() || other.isType(),
this.isInstance() || other.isInstance(),
deduplicatedParams
);
}
public String getId() {
return id;
}
public String getName() {
return name;
}
public String getStatus() {
return status;
}
public String getKind() {
return kind;
}
public String getDescription() {
if (this.description.isEmpty()) {
return "";
}
if (this.description.size() == 1) {
return this.description.get(0);
}
return String.format(
"This automatic adding Operation was merged, because two ComplexType unionType members "
+ "had fieldName with same name, but different type. Original descriptions: %n%s",
String.join("\n", this.description)
);
}
private void setDescription(String description) {
this.description = List.of(description);
}
public String getCode() {
return code;
}
public List<String> getResource() {
return resource;
}
public boolean isSystem() {
return system;
}
public boolean isType() {
return type;
}
public boolean isInstance() {
return instance;
}
public List<ParameterDTO> getParameter() {
return parameter;
}
@JsonIgnore
public ParameterDTO getParameter(String parameterName) {
return this.getParameter().stream()
.filter(paramater -> paramater.getName().equals(parameterName))
.findAny()
.orElseThrow(
() -> new InvalidOperationDefinition(
"Parameter '%s' not found.".formatted(parameterName)
)
);
}
@Override
public String toString() {
return "OperationDefinitionDTO{" +
"id='" + id + '\'' +
", name='" + name + '\'' +
", status='" + status + '\'' +
", kind='" + kind + '\'' +
", description='" + description + '\'' +
", code='" + code + '\'' +
", resource=" + resource +
", system=" + system +
", type=" + type +
", instance=" + instance +
", parameter=" + parameter +
'}';
}
public static class ParameterDTO {
private String name;
private String use;
private Integer min;
private String max;
private String type;
private List<ReferencedFrom> referencedFrom;
private List<StructureDefinitionId> targetProfileRef;
private ParameterDTO() {
}
private ParameterDTO(
String name,
String use,
Integer min,
String max,
String type,
List<ReferencedFrom> referencedFrom,
List<StructureDefinitionId> targetProfileRef
) {
this.name = name;
this.use = use;
this.min = min;
this.max = max;
this.type = type;
this.referencedFrom = referencedFrom;
this.targetProfileRef = targetProfileRef;
}
public ParameterDTO(
String name,
String use,
Integer min,
String max,
String type,
ReferencedFrom referencedFrom,
List<StructureDefinitionId> targetProfileRef
) {
this.name = name;
this.use = use;
this.min = min;
this.max = max;
this.type = type;
this.referencedFrom = new ArrayList<>(List.of(referencedFrom));
this.targetProfileRef = targetProfileRef;
}
public ParameterDTO merge(ParameterDTO other) {
if (!Objects.equals(this.getName(), other.getName())) {
throw CannotMergeOperationDefinition.becauseSomeParameterHasSomeFieldWhichIsNotSame(
this.getName(),
"name",
this.getName(),
other.getName()
);
}
if (!Objects.equals(this.getUse(), other.getUse())) {
throw CannotMergeOperationDefinition.becauseSomeParameterHasSomeFieldWhichIsNotSame(
this.getName(),
"use",
this.getUse(),
other.getUse()
);
}
if (!Objects.equals(this.getMin(), other.getMin())) {
throw CannotMergeOperationDefinition.becauseSomeParameterHasSomeFieldWhichIsNotSame(
this.getName(),
"min",
this.getMin(),
other.getMin()
);
}
if (!Objects.equals(this.getMax(), other.getMax())) {
throw CannotMergeOperationDefinition.becauseSomeParameterHasSomeFieldWhichIsNotSame(
this.getName(),
"max",
this.getMax(),
other.getMax()
);
}
if (!Objects.equals(this.getType(), other.getType())) {
throw CannotMergeOperationDefinition.becauseSomeParameterHasSomeFieldWhichIsNotSame(
this.getName(),
"type",
this.getType(),
other.getType()
);
}
var mergedReferencedFrom = new ArrayList<>(this.getReferencedFrom());
mergedReferencedFrom.addAll(other.getReferencedFrom());
var mergedTargetProfileReferences = new ArrayList<>(this.getTargetProfileRef());
mergedTargetProfileReferences.addAll(other.getTargetProfileRef());
return new ParameterDTO(
this.getName(),
this.getUse(),
this.getMin(),
this.getMax(),
this.getType(),
mergedReferencedFrom.stream()
.collect(Collectors.groupingBy(ReferencedFrom::getSource))
.values()
.stream()
.map(group -> group.get(0))
.toList(),
new HashSet<>(mergedTargetProfileReferences).stream().toList()
);
}
public String getName() {
return name;
}
public String getUse() {
return use;
}
public Integer getMin() {
return min;
}
public String getMax() {
return max;
}
public String getType() {
return type;
}
public List<ReferencedFrom> getReferencedFrom() {
return referencedFrom;
}
@JsonIgnore
public ReferencedFrom getSingleReferencedFrom() {
if (this.referencedFrom.size() != 1) {
throw new InvalidOperationDefinition(
String.format(
"Every parameter should always have exactly one referencedFrom value.%n%s",
String.format("Operation name: '%s'", this.name)
)
);
}
return referencedFrom.get(0);
}
public List<StructureDefinitionId> getTargetProfileRef() {
return targetProfileRef;
}
@JsonIgnore
public boolean isList() {
try {
var number = Integer.parseInt(this.max);
return number > 1;
} catch (RuntimeException ignore) {
}
return this.max.equals("*");
}
@Override
public String toString() {
return "Parameter{" +
"name='" + name + '\'' +
", use='" + use + '\'' +
", min=" + min +
", max='" + max + '\'' +
", type=" + type +
'}';
}
public static class ReferencedFrom {
// Location in resource (into what the parameter gets mapped to) eg.: Patient.name
private String source;
private ReferencedFrom() {
}
public ReferencedFrom(String source) {
this.source = source;
}
public String getSource() {
return source;
}
}
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition/model/OperationDefinitionProvider.java | package ai.stapi.graphsystem.operationdefinition.model;
import ai.stapi.graphsystem.operationdefinition.exceptions.CannotProvideOperationDefinition;
import java.util.List;
public interface OperationDefinitionProvider {
List<OperationDefinitionDTO> provideAll();
OperationDefinitionDTO provide(String operationId) throws CannotProvideOperationDefinition;
boolean contains(String operationId);
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition/model/OperationDefinitionStructureTypeMapper.java | package ai.stapi.graphsystem.operationdefinition.model;
import ai.stapi.graphsystem.operationdefinition.exceptions.CannotMapOperationDefinitionToStructureType;
import ai.stapi.schema.structureSchema.AbstractStructureType;
import ai.stapi.schema.structureSchema.ComplexStructureType;
import ai.stapi.schema.structureSchema.FieldDefinition;
import ai.stapi.schema.structureSchema.FieldType;
import ai.stapi.schema.structureSchema.PrimitiveStructureType;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaProvider;
import ai.stapi.schema.structureSchemaProvider.exception.CannotProvideStructureSchema;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Stream;
import org.apache.commons.lang3.StringUtils;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class OperationDefinitionStructureTypeMapper {
private final StructureSchemaProvider structureSchemaProvider;
public OperationDefinitionStructureTypeMapper(StructureSchemaProvider structureSchemaProvider) {
this.structureSchemaProvider = structureSchemaProvider;
}
public List<ComplexStructureType> map(List<OperationDefinitionDTO> operationDefinitions) {
return operationDefinitions.stream().map(this::map).toList();
}
public ComplexStructureType map(OperationDefinitionDTO operationDefinition) {
var operationName = operationDefinition.getId();
var parameterGroups = this.createParameterGroups(operationDefinition);
var fakeFields = new HashMap<String, FieldDefinition>();
parameterGroups.forEach((parameterGroupIdentifier, parameters) -> {
var anyParameter = parameters.get(0);
var finalFieldName = parameters.size() == 1 ? anyParameter.getName() : parameterGroupIdentifier.fieldName();
var fakeField = new FieldDefinitionWithSource(
finalFieldName,
anyParameter.getMin(),
anyParameter.getMax(),
"",
parameters.stream().flatMap(
parameter -> this.fakeFieldType(
operationName,
parameter,
parameters.size() > 1
)
).toList(),
operationName,
anyParameter.getSingleReferencedFrom().getSource()
);
fakeFields.put(finalFieldName, fakeField);
});
return new ComplexStructureType(
operationName,
fakeFields,
operationDefinition.getDescription(),
null,
false
);
}
private Map<ParameterGroupIdentifier, List<OperationDefinitionDTO.ParameterDTO>> createParameterGroups(
OperationDefinitionDTO operationDefinition
) {
var parameterGroups = new HashMap<ParameterGroupIdentifier, List<OperationDefinitionDTO.ParameterDTO>>();
operationDefinition.getParameter().forEach(parameter -> {
if (!parameter.getUse().equals("in")) {
return;
}
var parameterName = parameter.getName();
var fieldName = this.createFieldName(
parameterName,
StringUtils.capitalize(parameter.getType())
);
var referencedFrom = parameter.getReferencedFrom();
var source = referencedFrom.size() > 0 ? referencedFrom.get(0).getSource() : null;
var key = new ParameterGroupIdentifier(fieldName, source);
var parameters = parameterGroups.getOrDefault(key, new ArrayList<>());
parameters.add(parameter);
parameterGroups.put(key, parameters);
});
return parameterGroups;
}
private String createFieldName(
String parameterName,
String parameterType
) {
int suffixLength = parameterType.length();
if (parameterName.length() < suffixLength + 1) {
return parameterName;
}
if (parameterName.equals(parameterType)) {
return parameterName;
}
if (!parameterName.endsWith(parameterType)) {
return parameterName;
}
return parameterName.substring(0, parameterName.length() - suffixLength);
}
@NotNull
private Stream<FieldType> fakeFieldType(
String operationName,
OperationDefinitionDTO.ParameterDTO parameterDTO,
boolean isInUnion
) {
var type = parameterDTO.getType();
if (type.equals("Reference")) {
return parameterDTO.getTargetProfileRef().stream().map(
targetProfile -> new FieldType(targetProfile.getId(), type)
);
}
AbstractStructureType structure;
try {
structure = this.structureSchemaProvider.provideSpecific(type);
} catch (CannotProvideStructureSchema exception) {
throw new CannotMapOperationDefinitionToStructureType(
operationName,
parameterDTO.getName(),
type,
exception
);
}
if (structure instanceof PrimitiveStructureType && isInUnion) {
return Stream.of(
new FieldType(
String.format("Boxed%s", StringUtils.capitalize(type)),
type
)
);
}
return Stream.of(new FieldType(type, type));
}
private record ParameterGroupIdentifier(String fieldName, @Nullable String referencedFrom) {
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof ParameterGroupIdentifier that)) {
return false;
}
if (!fieldName().equals(that.fieldName())) {
return false;
}
return referencedFrom() != null ? referencedFrom().equals(that.referencedFrom()) :
that.referencedFrom() == null;
}
@Override
public int hashCode() {
int result = fieldName().hashCode();
result = 31 * result + (referencedFrom() != null ? referencedFrom().hashCode() : 0);
return result;
}
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition/model | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition/model/resourceStructureTypeOperationsMapper/AbstractResourceOperationsMapper.java | package ai.stapi.graphsystem.operationdefinition.model.resourceStructureTypeOperationsMapper;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionDTO.ParameterDTO;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionDTO.ParameterDTO.ReferencedFrom;
import ai.stapi.schema.structureSchema.ComplexStructureType;
import ai.stapi.schema.structureSchema.FieldDefinition;
import ai.stapi.schema.structureSchema.FieldType;
import ai.stapi.schema.structureSchema.ResourceStructureType;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import ai.stapi.schema.structuredefinition.StructureDefinitionId;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.Collectors;
import org.apache.commons.lang3.StringUtils;
import org.jetbrains.annotations.NotNull;
public abstract class AbstractResourceOperationsMapper implements ResourceOperationsMapper {
protected final StructureSchemaFinder structureSchemaFinder;
protected AbstractResourceOperationsMapper(StructureSchemaFinder structureSchemaFinder) {
this.structureSchemaFinder = structureSchemaFinder;
}
protected abstract ResourceOperationsMapperResult mapNewFields(
ResourceStructureType rootResourceType,
ComplexStructureType modifiedStructureType,
List<String> newFieldNames
);
@Override
public Map<String, ResourceOperationsMapperResult> mapNewFields(
ComplexStructureType modifiedStructureType,
List<String> newFieldNames
) {
var resources = this.structureSchemaFinder.getAllResources()
.stream()
.toList();
var result = new HashMap<String, ResourceOperationsMapperResult>();
resources.forEach(resourceStructureType -> {
var resourceResult = this.mapNewFields(
resourceStructureType,
modifiedStructureType,
newFieldNames
);
if (!resourceResult.isEmpty()) {
result.put(
String.format("%sAggregate", resourceStructureType.getDefinitionType()),
resourceResult
);
}
});
return result;
}
@NotNull
protected List<ParameterDTO> createFieldParameters(
String resourceSourcePath,
FieldDefinition field,
Integer defaultMin,
String defaultMax
) {
if (field.getTypes().isEmpty()) {
var message = String.format(
"Field at path '%s' has no types.%n%s%n%s",
resourceSourcePath,
"Therefore it will not be included in Operation Definition for it.",
"Probably is caused by bug in resolving contentReference in its Structure Definition."
);
Logger.getLogger(this.getClass().getCanonicalName()).log(
Level.WARNING,
message
);
return List.of();
}
if (field.isUnionType()) {
var references = field.getTypes().stream()
.filter(FieldType::isReference)
.toList();
var rest = field.getTypes().stream()
.filter(fieldType -> !fieldType.isReference())
.map(fieldType -> fieldType.isBoxed() ? fieldType.getOriginalType() : fieldType.getType())
.map(fieldType ->
new ParameterDTO(
String.format("%s%s", field.getName(), StringUtils.capitalize(fieldType)),
"in",
defaultMin,
defaultMax,
fieldType,
new ReferencedFrom(resourceSourcePath),
List.of()
)
).collect(Collectors.toList());
if (!references.isEmpty()) {
rest.add(
new ParameterDTO(
rest.isEmpty() ? field.getName() : String.format("%sReference", field.getName()),
"in",
defaultMin,
defaultMax,
"Reference",
new ReferencedFrom(resourceSourcePath),
references.stream()
.map(FieldType::getType)
.map(StructureDefinitionId::new)
.toList()
)
);
}
return rest;
}
var type = field.getTypes().get(0);
return List.of(
new ParameterDTO(
field.getName(),
"in",
defaultMin,
defaultMax,
type.isReference() ? type.getOriginalType() : type.getType(),
new ReferencedFrom(resourceSourcePath),
type.isReference() ? List.of(new StructureDefinitionId(type.getType())) : List.of()
)
);
}
@NotNull
protected List<ParameterDTO> createFieldParameters(
String resourceSourcePath,
FieldDefinition field
) {
return this.createFieldParameters(
resourceSourcePath,
field,
field.getMin(),
field.getMax()
);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition/model | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition/model/resourceStructureTypeOperationsMapper/AddItemOnResourceOperationsMapper.java | package ai.stapi.graphsystem.operationdefinition.model.resourceStructureTypeOperationsMapper;
import ai.stapi.graph.attribute.attributeValue.IdAttributeValue;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionDTO;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionDTO.ParameterDTO;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionDTO.ParameterDTO.ReferencedFrom;
import ai.stapi.schema.structureSchema.ComplexStructureType;
import ai.stapi.schema.structureSchema.FieldDefinition;
import ai.stapi.schema.structureSchema.ResourceStructureType;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import org.apache.commons.lang3.StringUtils;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class AddItemOnResourceOperationsMapper extends AbstractResourceOperationsMapper {
public AddItemOnResourceOperationsMapper(StructureSchemaFinder structureSchemaFinder) {
super(structureSchemaFinder);
}
@Override
public ResourceOperationsMapperResult map(ResourceStructureType resourceStructureType) {
var resourceType = resourceStructureType.getDefinitionType();
return new ResourceOperationsMapperResult(
this.createOperationsRecursively(
new MapperContext(resourceType, List.of(resourceType)),
resourceStructureType
)
);
}
@Override
public ResourceOperationsMapperResult mapNewFields(
ResourceStructureType rootResourceType,
ComplexStructureType modifiedStructureType,
List<String> newFieldNames
) {
return newFieldNames.stream().map(fieldName -> {
var newField = modifiedStructureType.getField(fieldName);
if (newField.getName().equals("id")) {
return new ResourceOperationsMapperResult();
}
var type = rootResourceType.getDefinitionType();
var mapperContext = new MapperContext(type, List.of(type));
return new ResourceOperationsMapperResult(
this.processNewFieldOnComplexRecursively(
mapperContext,
rootResourceType,
modifiedStructureType,
newField
)
);
}).reduce(ResourceOperationsMapperResult::merge)
.orElse(new ResourceOperationsMapperResult());
}
@NotNull
private List<OperationDefinitionDTO> createOperationsRecursively(
MapperContext mapperContext,
ComplexStructureType structure
) {
var fields = structure.getOwnFields();
var operations = fields.values().stream()
.filter(FieldDefinition::isList)
.map(fieldDefinition -> this.createAddItemCommand(mapperContext, fieldDefinition))
.collect(Collectors.toList());
fields.values().forEach(fieldDefinition -> operations.addAll(
this.createDeeperOperations(
mapperContext,
fieldDefinition
)
));
return operations;
}
private List<OperationDefinitionDTO> processNewFieldOnComplexRecursively(
MapperContext mapperContext,
ComplexStructureType currentStructureType,
ComplexStructureType modifiedStructureType,
FieldDefinition newFieldDefinition
) {
var currentType = currentStructureType.getDefinitionType();
var modifiedType = modifiedStructureType.getDefinitionType();
if (currentType.equals(modifiedType)) {
var resultOperations = new ArrayList<OperationDefinitionDTO>();
if (newFieldDefinition.isList()) {
var newOperation = this.createAddItemCommand(
mapperContext,
newFieldDefinition
);
resultOperations.add(newOperation);
}
resultOperations.addAll(
this.createDeeperOperations(
mapperContext,
newFieldDefinition
)
);
return resultOperations;
}
return currentStructureType.getOwnFields()
.values()
.stream()
.flatMap(
fieldDefinition -> fieldDefinition.getTypes().stream()
.filter(type -> !type.isReference())
.filter(type -> !type.isContentReferenced())
.map(type -> this.structureSchemaFinder.getStructureType(type.getType()))
.filter(ComplexStructureType.class::isInstance)
.map(ComplexStructureType.class::cast)
.flatMap(
type -> this.doNewFieldRecursion(
mapperContext,
fieldDefinition,
type,
modifiedStructureType,
newFieldDefinition
).stream()
)
).toList();
}
@NotNull
private List<OperationDefinitionDTO> createDeeperOperations(
MapperContext mapperContext,
FieldDefinition fieldDefinition
) {
return fieldDefinition.getTypes().stream()
.filter(type -> !type.isReference())
.filter(type -> !type.isContentReferenced())
.map(type -> this.structureSchemaFinder.getStructureType(type.getType()))
.filter(ComplexStructureType.class::isInstance)
.map(ComplexStructureType.class::cast)
.flatMap(type -> this.doRecursion(mapperContext, fieldDefinition, type).stream())
.collect(Collectors.groupingBy(OperationDefinitionDTO::getId))
.values()
.stream()
.map(grouped -> grouped.stream().reduce(OperationDefinitionDTO::merge).get())
.toList();
}
private List<OperationDefinitionDTO> doRecursion(
MapperContext mapperContext,
FieldDefinition fieldDefinition,
ComplexStructureType type
) {
var newContext = mapperContext.addPath(fieldDefinition.getName());
if (fieldDefinition.isList()) {
return this.createOperationsRecursively(
newContext.setNewListParent(fieldDefinition.getName(), newContext.getPath()),
type
);
}
return this.createOperationsRecursively(newContext, type);
}
private List<OperationDefinitionDTO> doNewFieldRecursion(
MapperContext mapperContext,
FieldDefinition fieldDefinition,
ComplexStructureType type,
ComplexStructureType modifiedStructureType,
FieldDefinition newFieldDefinition
) {
var newContext = mapperContext.addPath(fieldDefinition.getName());
if (fieldDefinition.isList()) {
return this.processNewFieldOnComplexRecursively(
newContext.setNewListParent(fieldDefinition.getName(), newContext.getPath()),
type,
modifiedStructureType,
newFieldDefinition
);
}
return this.processNewFieldOnComplexRecursively(
newContext,
type,
modifiedStructureType,
newFieldDefinition
);
}
private OperationDefinitionDTO createAddItemCommand(
MapperContext mapperContext,
FieldDefinition fieldDefinition
) {
var fieldName = fieldDefinition.getName();
var commandId = this.createAddItemCommandId(mapperContext, fieldName);
var commandName = this.createAddItemCommandName(mapperContext, fieldName);
var generatedSourcePath = String.format(
"%s.%s",
String.join(".", mapperContext.getPath()),
fieldDefinition.getName()
);
var parameters = this.createFieldParameters(
generatedSourcePath,
fieldDefinition,
1,
"*"
);
var description = String.format(
"Generated command for adding %s(%s) on %s Aggregate",
fieldName,
parameters.stream().map(ParameterDTO::getType).collect(Collectors.joining(" | ")),
mapperContext.getResourceType()
);
if (mapperContext.getLastParentListPath() != null) {
parameters = new ArrayList<>(parameters);
var idParameter = new ParameterDTO(
String.format("%sId", mapperContext.getLastParentListName()),
"in",
1,
"1",
IdAttributeValue.SERIALIZATION_TYPE,
new ReferencedFrom(
String.format("%s.id", String.join(".", mapperContext.getLastParentListPath()))
),
List.of()
);
parameters.add(idParameter);
}
return new OperationDefinitionDTO(
commandId,
commandName,
"draft",
"operation",
description,
commandId,
List.of(mapperContext.getResourceType()),
false,
false,
true,
parameters
);
}
private String createAddItemCommandId(
MapperContext mapperContext,
String fieldName
) {
return String.format(
"Add%sOn%s",
StringUtils.capitalize(fieldName),
mapperContext.getPath().stream().map(StringUtils::capitalize).collect(Collectors.joining())
);
}
private String createAddItemCommandName(
MapperContext mapperContext,
String fieldName
) {
return String.format(
"Add %s on %s",
StringUtils.capitalize(fieldName),
String.join(".", mapperContext.getPath())
);
}
private static class MapperContext {
private final String resourceType;
private final List<String> path;
private final @Nullable String lastParentListName;
private final @Nullable List<String> lastParentListPath;
public MapperContext(
String resourceType,
List<String> path,
@Nullable String lastParentListName,
@Nullable List<String> lastParentListPath
) {
this.resourceType = resourceType;
this.path = path;
this.lastParentListName = lastParentListName;
this.lastParentListPath = lastParentListPath;
}
public MapperContext(String resourceType, List<String> path) {
this(resourceType, path, null, null);
}
public MapperContext addPath(String pathPart) {
var newPath = new ArrayList<>(this.path);
newPath.add(pathPart);
return new MapperContext(
this.resourceType,
newPath,
this.lastParentListName,
this.lastParentListPath
);
}
public MapperContext setNewListParent(
String lastParentListName,
List<String> lastParentListPath
) {
return new MapperContext(
this.resourceType,
this.path,
lastParentListName,
lastParentListPath
);
}
public String getResourceType() {
return resourceType;
}
public List<String> getPath() {
return path;
}
@Nullable
public String getLastParentListName() {
return lastParentListName;
}
@Nullable
public List<String> getLastParentListPath() {
return lastParentListPath;
}
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition/model | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition/model/resourceStructureTypeOperationsMapper/CreationalResourceOperationMapper.java | package ai.stapi.graphsystem.operationdefinition.model.resourceStructureTypeOperationsMapper;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionDTO;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionDTO.ParameterDTO;
import ai.stapi.schema.structureSchema.ComplexStructureType;
import ai.stapi.schema.structureSchema.FieldDefinition;
import ai.stapi.schema.structureSchema.ResourceStructureType;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import java.util.List;
import java.util.stream.Stream;
import org.jetbrains.annotations.NotNull;
public class CreationalResourceOperationMapper extends AbstractResourceOperationsMapper {
public CreationalResourceOperationMapper(StructureSchemaFinder structureSchemaFinder) {
super(structureSchemaFinder);
}
@Override
public ResourceOperationsMapperResult map(ResourceStructureType resourceStructureType) {
if (resourceStructureType.isAbstract()) {
return new ResourceOperationsMapperResult();
}
var resourceName = resourceStructureType.getDefinitionType();
var createCommandId = this.createCreateCommandId(resourceName);
var createCommandName = this.createCreateCommandName(resourceName);
return new ResourceOperationsMapperResult(
new OperationDefinitionDTO(
createCommandId,
createCommandName,
"draft",
"operation",
"Generated command for creating " + resourceName + " with all fields.",
createCommandName,
List.of(resourceName),
false,
true,
true,
this.createParameters(resourceStructureType)
)
);
}
@Override
public ResourceOperationsMapperResult mapNewFields(
ResourceStructureType rootResourceType,
ComplexStructureType modifiedStructureType,
List<String> newFieldNames
) {
if (rootResourceType.isAbstract()) {
return new ResourceOperationsMapperResult();
}
var rootType = rootResourceType.getDefinitionType();
var modifiedType = modifiedStructureType.getDefinitionType();
if (!(this.structureSchemaFinder.isEqualOrInherits(rootType, modifiedType))) {
return new ResourceOperationsMapperResult();
}
return newFieldNames.stream().map(fieldName -> {
var newField = rootResourceType.getField(fieldName);
if (newField.getName().equals("id")) {
return new ResourceOperationsMapperResult();
}
var definitionType = rootResourceType.getDefinitionType();
var commandId = this.createCreateCommandId(definitionType);
return new ResourceOperationsMapperResult(
new OperationDefinitionParameters(
commandId,
this.createParametersForField(definitionType, newField).toList()
)
);
}).reduce(ResourceOperationsMapperResult::merge)
.orElse(new ResourceOperationsMapperResult());
}
@NotNull
private List<ParameterDTO> createParameters(ResourceStructureType resourceStructureType) {
var definitionType = resourceStructureType.getDefinitionType();
return resourceStructureType.getAllFields().values().stream()
.filter(field -> !field.getName().equals("id"))
.flatMap(field -> this.createParametersForField(definitionType, field))
.toList();
}
private Stream<ParameterDTO> createParametersForField(
String definitionType,
FieldDefinition field
) {
var generatedPath = String.format(
"%s.%s",
definitionType,
field.getName()
);
return this.createFieldParameters(generatedPath, field).stream();
}
private String createCreateCommandId(String resourceType) {
return "Create" + resourceType;
}
private String createCreateCommandName(String resourceType) {
return "Create " + resourceType;
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition/model | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition/model/resourceStructureTypeOperationsMapper/OperationDefinitionParameters.java | package ai.stapi.graphsystem.operationdefinition.model.resourceStructureTypeOperationsMapper;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionDTO.ParameterDTO;
import java.util.List;
public class OperationDefinitionParameters {
private final String operationId;
private final List<ParameterDTO> parameters;
public OperationDefinitionParameters(String operationId, List<ParameterDTO> parameters) {
this.operationId = operationId;
this.parameters = parameters;
}
public String getOperationId() {
return operationId;
}
public List<ParameterDTO> getParameters() {
return parameters;
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition/model | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition/model/resourceStructureTypeOperationsMapper/ResourceOperationsMapper.java | package ai.stapi.graphsystem.operationdefinition.model.resourceStructureTypeOperationsMapper;
import ai.stapi.schema.structureSchema.ComplexStructureType;
import ai.stapi.schema.structureSchema.ResourceStructureType;
import java.util.List;
import java.util.Map;
public interface ResourceOperationsMapper {
ResourceOperationsMapperResult map(ResourceStructureType resourceStructureType);
Map<String, ResourceOperationsMapperResult> mapNewFields(
ComplexStructureType modifiedStructureType,
List<String> newFieldNames
);
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition/model | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition/model/resourceStructureTypeOperationsMapper/ResourceOperationsMapperResult.java | package ai.stapi.graphsystem.operationdefinition.model.resourceStructureTypeOperationsMapper;
import com.fasterxml.jackson.annotation.JsonIgnore;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionDTO;
import java.util.ArrayList;
import java.util.List;
public class ResourceOperationsMapperResult {
private final List<OperationDefinitionDTO> operations;
private final List<OperationDefinitionParameters> newParameters;
public ResourceOperationsMapperResult(
List<OperationDefinitionDTO> operations,
List<OperationDefinitionParameters> newParameters
) {
this.operations = operations;
this.newParameters = newParameters;
}
public ResourceOperationsMapperResult(
List<OperationDefinitionDTO> operations
) {
this(operations, List.of());
}
public ResourceOperationsMapperResult(
OperationDefinitionDTO operation
) {
this(List.of(operation));
}
public ResourceOperationsMapperResult(
OperationDefinitionParameters newParameter
) {
this(List.of(), List.of(newParameter));
}
public ResourceOperationsMapperResult() {
this(List.of(), List.of());
}
public ResourceOperationsMapperResult merge(ResourceOperationsMapperResult other) {
var mergedOperations = new ArrayList<>(this.operations);
mergedOperations.addAll(other.operations);
var mergedParameters = new ArrayList<>(this.newParameters);
mergedParameters.addAll(other.newParameters);
return new ResourceOperationsMapperResult(
mergedOperations,
mergedParameters
);
}
public List<OperationDefinitionDTO> getOperations() {
return operations;
}
public List<OperationDefinitionParameters> getNewParameters() {
return newParameters;
}
@JsonIgnore
public boolean isEmpty() {
return this.operations.isEmpty() && this.newParameters.isEmpty();
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition/model | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/operationdefinition/model/resourceStructureTypeOperationsMapper/UpdateResourceOperationMapper.java | package ai.stapi.graphsystem.operationdefinition.model.resourceStructureTypeOperationsMapper;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionDTO;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionDTO.ParameterDTO;
import ai.stapi.schema.structureSchema.ComplexStructureType;
import ai.stapi.schema.structureSchema.FieldDefinition;
import ai.stapi.schema.structureSchema.ResourceStructureType;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import java.util.List;
import java.util.stream.Stream;
import org.jetbrains.annotations.NotNull;
public class UpdateResourceOperationMapper extends AbstractResourceOperationsMapper {
public UpdateResourceOperationMapper(StructureSchemaFinder structureSchemaFinder) {
super(structureSchemaFinder);
}
@Override
public ResourceOperationsMapperResult map(ResourceStructureType resourceStructureType) {
if (resourceStructureType.isAbstract()) {
return new ResourceOperationsMapperResult();
}
var resourceName = resourceStructureType.getDefinitionType();
var createCommandId = this.createUpdateCommandId(resourceName);
var createCommandName = this.createUpdateCommandName(resourceName);
return new ResourceOperationsMapperResult(
new OperationDefinitionDTO(
createCommandId,
createCommandName,
"draft",
"operation",
"Generated command for updating " + resourceName + " with only primitive fields.",
createCommandName,
List.of(resourceName),
false,
true,
true,
this.createParameters(resourceStructureType)
)
);
}
@Override
public ResourceOperationsMapperResult mapNewFields(
ResourceStructureType rootResourceType,
ComplexStructureType modifiedStructureType,
List<String> newFieldNames
) {
if (rootResourceType.isAbstract()) {
return new ResourceOperationsMapperResult();
}
var rootType = rootResourceType.getDefinitionType();
var modifiedType = modifiedStructureType.getDefinitionType();
if (!(this.structureSchemaFinder.isEqualOrInherits(rootType, modifiedType))) {
return new ResourceOperationsMapperResult();
}
return newFieldNames.stream().map(fieldName -> {
var newField = rootResourceType.getField(fieldName);
if (newField.getName().equals("id")) {
return new ResourceOperationsMapperResult();
}
if (!newField.getMax().equals("1")) {
return new ResourceOperationsMapperResult();
}
if (!newField.getTypes().stream().allMatch(type -> type.isPrimitiveType() || type.isBoxed())) {
return new ResourceOperationsMapperResult();
}
var definitionType = rootResourceType.getDefinitionType();
var commandId = this.createUpdateCommandId(definitionType);
return new ResourceOperationsMapperResult(
new OperationDefinitionParameters(
commandId,
this.createParametersForField(definitionType, newField).toList()
)
);
}).reduce(ResourceOperationsMapperResult::merge)
.orElse(new ResourceOperationsMapperResult());
}
@NotNull
private List<ParameterDTO> createParameters(ResourceStructureType resourceStructureType) {
var definitionType = resourceStructureType.getDefinitionType();
return resourceStructureType.getAllFields().values().stream()
.filter(field -> !field.getName().equals("id"))
.filter(field -> field.getMax().equals("1"))
.filter(field -> field.getTypes().stream().allMatch(type -> type.isPrimitiveType() || type.isBoxed()))
.flatMap(field -> this.createParametersForField(definitionType, field))
.toList();
}
private Stream<ParameterDTO> createParametersForField(
String definitionType,
FieldDefinition field
) {
var generatedPath = String.format(
"%s.%s",
definitionType,
field.getName()
);
return this.createFieldParameters(generatedPath, field, 0, field.getMax()).stream();
}
private String createUpdateCommandId(String resourceType) {
return "Update" + resourceType;
}
private String createUpdateCommandName(String resourceType) {
return "Update " + resourceType;
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/structuredefinition | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/structuredefinition/classnameprovider/StructureDefinitionClassNameProvider.java | package ai.stapi.graphsystem.structuredefinition.classnameprovider;
import ai.stapi.schema.structuredefinition.StructureDefinitionData;
import ai.stapi.serialization.classNameProvider.specific.AbstractSerializableObjectClassNameProvider;
import java.util.Map;
public class StructureDefinitionClassNameProvider extends AbstractSerializableObjectClassNameProvider {
@Override
protected Map<String, Class<?>> getClassMap() {
return Map.of(
StructureDefinitionData.SERIALIZATION_TYPE, StructureDefinitionData.class
);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/structuredefinition/command | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/structuredefinition/command/importStructureDefinitionFromSource/FixedImportStructureDefinition.java | package ai.stapi.graphsystem.structuredefinition.command.importStructureDefinitionFromSource;
import ai.stapi.graphsystem.messaging.command.AbstractCommand;
import ai.stapi.schema.structuredefinition.StructureDefinitionData;
import ai.stapi.schema.structuredefinition.StructureDefinitionId;
public class FixedImportStructureDefinition extends AbstractCommand<StructureDefinitionId> {
public static final String SERIALIZATION_TYPE = "c53c63da-d465-4299-82f5-5e8c92b0cb2c";
private StructureDefinitionData structureDefinitionData;
protected FixedImportStructureDefinition() {
}
public FixedImportStructureDefinition(
StructureDefinitionId targetIdentifier,
StructureDefinitionData structureDefinitionData
) {
super(targetIdentifier, FixedImportStructureDefinition.SERIALIZATION_TYPE);
this.structureDefinitionData = structureDefinitionData;
}
public StructureDefinitionData getStructureDefinitionSource() {
return structureDefinitionData;
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/structuredefinition/command | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/structuredefinition/command/importStructureDefinitionFromSource/ImportStructureDefinition.java | package ai.stapi.graphsystem.structuredefinition.command.importStructureDefinitionFromSource;
import ai.stapi.graphsystem.messaging.command.AbstractCommand;
import ai.stapi.schema.structuredefinition.RawStructureDefinitionData;
import ai.stapi.schema.structuredefinition.StructureDefinitionId;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;
public class ImportStructureDefinition extends AbstractCommand<StructureDefinitionId> {
public static final String SERIALIZATION_TYPE = "ImportStructureDefinition";
private Map<String, Object> structureDefinitionSource;
protected ImportStructureDefinition() {
}
public ImportStructureDefinition(
StructureDefinitionId targetIdentifier,
Map<String, Object> structureDefinitionSource
) {
super(targetIdentifier, ImportStructureDefinition.SERIALIZATION_TYPE);
this.structureDefinitionSource = structureDefinitionSource;
}
public ImportStructureDefinition(
StructureDefinitionId targetIdentifier,
RawStructureDefinitionData structureDefinitionSource
) {
super(targetIdentifier, ImportStructureDefinition.SERIALIZATION_TYPE);
this.structureDefinitionSource = new ObjectMapper().convertValue(
structureDefinitionSource,
new TypeReference<>() {
}
);
}
public Map<String, Object> getStructureDefinitionSource() {
return structureDefinitionSource;
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/structuredefinition/command | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/structuredefinition/command/importStructureDefinitionFromSource/ImportStructureDefinitionOgmProvider.java | package ai.stapi.graphsystem.structuredefinition.command.importStructureDefinitionFromSource;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NullGraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.UuidIdentityDescription;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.GenericOGMBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm.ObjectGraphMappingBuilder;
import ai.stapi.graphoperations.objectLanguage.EntityIdentifier;
import ai.stapi.graphoperations.ogmProviders.GenericGraphMappingProvider;
import ai.stapi.graphsystem.commandEventGraphMappingProvider.specific.SpecificCommandEventGraphMappingProvider;
import ai.stapi.graphsystem.messaging.command.AbstractCommand;
import ai.stapi.graphsystem.messaging.event.AggregateGraphUpdatedEvent;
import ai.stapi.identity.UniqueIdentifier;
import java.util.HashMap;
import java.util.Map;
public class ImportStructureDefinitionOgmProvider implements SpecificCommandEventGraphMappingProvider {
private final GenericGraphMappingProvider genericGraphMappingProvider;
public ImportStructureDefinitionOgmProvider(
GenericGraphMappingProvider genericGraphMappingProvider
) {
this.genericGraphMappingProvider = genericGraphMappingProvider;
}
@Override
public Map<Class<? extends AggregateGraphUpdatedEvent<? extends UniqueIdentifier>>, ObjectGraphMapping> provideGraphMapping(
AbstractCommand<? extends UniqueIdentifier> command) {
var map =
new HashMap<Class<? extends AggregateGraphUpdatedEvent<? extends UniqueIdentifier>>, ObjectGraphMapping>();
this.addCreatedConceptEventToMap(map);
return map;
}
public void addCreatedConceptEventToMap(
Map<Class<? extends AggregateGraphUpdatedEvent<? extends UniqueIdentifier>>, ObjectGraphMapping> map) {
var definition = new ObjectGraphMappingBuilder();
definition
.addField("targetIdentifier")
.setRelation(new EntityIdentifier())
.addObjectAsObjectFieldMapping()
.setGraphDescription(
new GraphDescriptionBuilder().addNodeDescription("StructureDefinition")
).addField("id")
.setRelation(new EntityIdentifier())
.addLeafAsObjectFieldMapping()
.setGraphDescription(new UuidIdentityDescription());
var ogm = this.genericGraphMappingProvider.provideGraphMapping(
"StructureDefinition"
);
var builder = new GenericOGMBuilder().copyGraphMappingAsBuilder(ogm);
builder.setNewGraphDescription(new NullGraphDescription());
definition
.addField("structureDefinitionSource")
.setChild(builder);
map.put(StructureDefinitionImported.class, definition.build());
}
@Override
public boolean supports(String serializationType) {
return serializationType.equals(ImportStructureDefinition.SERIALIZATION_TYPE);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/structuredefinition/command | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/structuredefinition/command/importStructureDefinitionFromSource/StructureDefinitionImported.java | package ai.stapi.graphsystem.structuredefinition.command.importStructureDefinitionFromSource;
import ai.stapi.graph.Graph;
import ai.stapi.graphsystem.messaging.event.AggregateGraphUpdatedEvent;
import ai.stapi.schema.structuredefinition.StructureDefinitionId;
public class StructureDefinitionImported extends AggregateGraphUpdatedEvent<StructureDefinitionId> {
private StructureDefinitionImported() {
}
public StructureDefinitionImported(
StructureDefinitionId structureDefinitionId,
Graph synchronizedGraph
) {
super(structureDefinitionId, synchronizedGraph);
}
} |
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/structuredefinition/command | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/structuredefinition/command/importStructureDefinitionFromSource/StructureDefinitionImportedGraphEventFactory.java | package ai.stapi.graphsystem.structuredefinition.command.importStructureDefinitionFromSource;
import ai.stapi.graph.Graph;
import ai.stapi.graph.graphElementForRemoval.GraphElementForRemoval;
import ai.stapi.identity.UniqueIdentifier;
import ai.stapi.graphsystem.messaging.event.AggregateGraphUpdatedEvent;
import ai.stapi.graphsystem.genericGraphEventFactory.specific.SpecificGraphEventFactory;
import ai.stapi.schema.structuredefinition.StructureDefinitionId;
import java.util.List;
public class StructureDefinitionImportedGraphEventFactory implements SpecificGraphEventFactory {
@Override
public AggregateGraphUpdatedEvent<? extends UniqueIdentifier> createEvent(
UniqueIdentifier identity,
Graph graph,
List<GraphElementForRemoval> elementsForRemoval
) {
return new StructureDefinitionImported((StructureDefinitionId) identity, graph);
}
@Override
public boolean supports(
Class<? extends AggregateGraphUpdatedEvent<? extends UniqueIdentifier>> event) {
return event.equals(StructureDefinitionImported.class);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/structuredefinition | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/structuredefinition/identificatorProvider/ElementDefinitionIdentificatorProvider.java | package ai.stapi.graphsystem.structuredefinition.identificatorProvider;
import ai.stapi.graphoperations.synchronization.nodeIdentificator.NodeIdentificator;
import ai.stapi.graphoperations.synchronization.nodeIdentificator.NodeIdentificatorsProvider;
import java.util.List;
public class ElementDefinitionIdentificatorProvider implements NodeIdentificatorsProvider {
@Override
public List<NodeIdentificator> provide(String nodeType) {
return List.of(
new NodeIdentificator("path")
);
}
@Override
public boolean supports(String nodeType) {
return nodeType.equals("ElementDefinition");
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/structuredefinition | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/structuredefinition/identificatorProvider/StructureDefinitionDifferentialIdentificatorProvider.java | package ai.stapi.graphsystem.structuredefinition.identificatorProvider;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.EdgeDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.IngoingEdgeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NodeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.UuidIdentityDescription;
import ai.stapi.graphoperations.synchronization.nodeIdentificator.NodeIdentificator;
import ai.stapi.graphoperations.synchronization.nodeIdentificator.NodeIdentificatorsProvider;
import java.util.List;
public class StructureDefinitionDifferentialIdentificatorProvider implements NodeIdentificatorsProvider {
@Override
public List<NodeIdentificator> provide(String nodeType) {
return List.of(
new NodeIdentificator(
new IngoingEdgeDescription(
new EdgeDescriptionParameters("differential"),
new NodeDescription(
"StructureDefinition",
new UuidIdentityDescription()
)
)
)
);
}
@Override
public boolean supports(String nodeType) {
return nodeType.equals("StructureDefinitionDifferential");
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/structuredefinition | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/structuredefinition/loader/CombinedStructureDefinitionLoader.java | package ai.stapi.graphsystem.structuredefinition.loader;
import ai.stapi.schema.structuredefinition.StructureDefinitionData;
import ai.stapi.schema.structuredefinition.loader.StructureDefinitionLoader;
import java.util.ArrayList;
import java.util.List;
import org.springframework.stereotype.Service;
public class CombinedStructureDefinitionLoader implements StructureDefinitionLoader {
private final SystemAdHocStructureDefinitionLoader systemAdHocStructureDefinitionLoader;
private final DatabaseStructureDefinitionLoader databaseStructureDefinitionLoader;
public CombinedStructureDefinitionLoader(
SystemAdHocStructureDefinitionLoader systemAdHocStructureDefinitionLoader,
DatabaseStructureDefinitionLoader databaseStructureDefinitionLoader
) {
this.systemAdHocStructureDefinitionLoader = systemAdHocStructureDefinitionLoader;
this.databaseStructureDefinitionLoader = databaseStructureDefinitionLoader;
}
@Override
public List<StructureDefinitionData> load() {
var adHoc = this.systemAdHocStructureDefinitionLoader.load();
var db = this.databaseStructureDefinitionLoader.load();
var all = new ArrayList<>(db);
adHoc.stream().filter(structure ->
db.stream().noneMatch(
dbStructure -> dbStructure.getId().equals(structure.getId())
)
).forEach(all::add);
return all;
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/structuredefinition | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/structuredefinition/loader/DatabaseStructureDefinitionLoader.java | package ai.stapi.graphsystem.structuredefinition.loader;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.EdgeDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NodeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NodeDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.OutgoingEdgeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.UuidIdentityDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.AttributeQueryDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.NodeQueryGraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.OutgoingEdgeQueryDescription;
import ai.stapi.graphoperations.graphLoader.GraphLoader;
import ai.stapi.graphoperations.graphLoader.search.SearchQueryParameters;
import ai.stapi.graphoperations.graphLoader.search.paginationOption.OffsetPaginationOption;
import ai.stapi.graphsystem.systemfixtures.model.SystemModelDefinitionsLoader;
import ai.stapi.schema.scopeProvider.ScopeCacher;
import ai.stapi.schema.scopeProvider.ScopeOptions;
import ai.stapi.schema.scopeProvider.ScopeProvider;
import ai.stapi.schema.structuredefinition.StructureDefinitionData;
import ai.stapi.schema.structuredefinition.loader.StructureDefinitionLoader;
import java.util.List;
import org.springframework.context.annotation.Lazy;
public class DatabaseStructureDefinitionLoader implements StructureDefinitionLoader {
public static final NodeQueryGraphDescription STRUCTURE_DEFINITION_GRAPH_DESCRIPTION = new NodeQueryGraphDescription(
new NodeDescriptionParameters("StructureDefinition"),
SearchQueryParameters.builder()
.setPaginationOption(new OffsetPaginationOption(0, 300))
.build(),
new UuidIdentityDescription(),
new AttributeQueryDescription("url"),
new AttributeQueryDescription("status"),
new AttributeQueryDescription("description"),
new AttributeQueryDescription("kind"), new AttributeQueryDescription("abstract"),
new AttributeQueryDescription("type"),
new OutgoingEdgeDescription(
new EdgeDescriptionParameters("baseDefinitionRef"),
new NodeDescription(
new NodeDescriptionParameters("StructureDefinition"),
new UuidIdentityDescription()
)
),
new OutgoingEdgeDescription(
new EdgeDescriptionParameters("differential"),
new NodeDescription(
new NodeDescriptionParameters("StructureDefinitionDifferential"),
new OutgoingEdgeQueryDescription(
new EdgeDescriptionParameters("element"),
SearchQueryParameters.builder()
.setPaginationOption(new OffsetPaginationOption(0, 300))
.build(),
new NodeDescription(
new NodeDescriptionParameters("ElementDefinition"),
new AttributeQueryDescription("path"),
new AttributeQueryDescription("min"),
new AttributeQueryDescription("max"),
new AttributeQueryDescription("short"),
new AttributeQueryDescription("definition"),
new AttributeQueryDescription("comment"),
new AttributeQueryDescription("contentReference"),
new OutgoingEdgeQueryDescription(
new EdgeDescriptionParameters("type"),
SearchQueryParameters.builder()
.setPaginationOption(new OffsetPaginationOption(0, 300))
.build(),
new NodeDescription(
new NodeDescriptionParameters("ElementDefinitionType"),
new AttributeQueryDescription("code"),
new OutgoingEdgeDescription(
new EdgeDescriptionParameters("codeRef"),
new NodeDescription(
"StructureDefinition",
new UuidIdentityDescription()
)
),
new AttributeQueryDescription("targetProfile"),
new OutgoingEdgeDescription(
new EdgeDescriptionParameters("targetProfileRef"),
new NodeDescription(
"StructureDefinition",
new UuidIdentityDescription()
)
)
)
)
)
)
)
)
);
private final GraphLoader graphLoader;
private final SystemAdHocStructureDefinitionLoader systemAdHocStructureDefinitionLoader;
private final ScopeCacher scopeCacher;
private final ScopeProvider scopeProvider;
public DatabaseStructureDefinitionLoader(
@Lazy GraphLoader graphLoader,
SystemAdHocStructureDefinitionLoader systemAdHocStructureDefinitionLoader,
ScopeCacher scopeCacher,
ScopeProvider scopeProvider
) {
this.graphLoader = graphLoader;
this.systemAdHocStructureDefinitionLoader = systemAdHocStructureDefinitionLoader;
this.scopeCacher = scopeCacher;
this.scopeProvider = scopeProvider;
}
@Override
public List<StructureDefinitionData> load() {
var systemScope = new ScopeOptions(SystemModelDefinitionsLoader.SCOPE, SystemModelDefinitionsLoader.TAG);
if (this.scopeProvider.provide().equals(systemScope)) {
return this.systemAdHocStructureDefinitionLoader.load();
}
if (!this.scopeCacher.hasCached(DatabaseStructureDefinitionLoader.class)) {
var originalScope = this.scopeProvider.provide();
this.scopeProvider.set(systemScope);
var data = loadData();
this.scopeProvider.set(originalScope);
this.scopeCacher.cache(
DatabaseStructureDefinitionLoader.class,
data
);
return data;
}
return this.scopeCacher.getCachedOrCompute(
DatabaseStructureDefinitionLoader.class,
scope -> this.loadData()
);
}
private List<StructureDefinitionData> loadData() {
return this.graphLoader.find(
STRUCTURE_DEFINITION_GRAPH_DESCRIPTION,
StructureDefinitionData.class
).getData();
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/structuredefinition | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/structuredefinition/loader/SystemAdHocStructureDefinitionLoader.java | package ai.stapi.graphsystem.structuredefinition.loader;
import ai.stapi.graphsystem.structuredefinition.command.importStructureDefinitionFromSource.ImportStructureDefinition;
import ai.stapi.schema.adHocLoaders.GenericAdHocModelDefinitionsLoader;
import ai.stapi.schema.scopeProvider.ScopeCacher;
import ai.stapi.schema.scopeProvider.ScopeOptions;
import ai.stapi.schema.structureSchema.AbstractStructureType;
import ai.stapi.schema.structuredefinition.RawStructureDefinitionData;
import ai.stapi.schema.structuredefinition.RawStructureDefinitionElementDefinition;
import ai.stapi.schema.structuredefinition.StructureDefinitionData;
import ai.stapi.schema.structuredefinition.StructureDefinitionNormalizer;
import ai.stapi.schema.structuredefinition.loader.StructureDefinitionLoader;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import org.jetbrains.annotations.NotNull;
public class SystemAdHocStructureDefinitionLoader implements StructureDefinitionLoader {
private final GenericAdHocModelDefinitionsLoader genericAdHocModelDefinitionsLoader;
private final ObjectMapper objectMapper;
private final ScopeCacher scopeCacher;
public SystemAdHocStructureDefinitionLoader(
GenericAdHocModelDefinitionsLoader genericAdHocModelDefinitionsLoader,
ObjectMapper objectMapper,
ScopeCacher scopeCacher
) {
this.genericAdHocModelDefinitionsLoader = genericAdHocModelDefinitionsLoader;
this.objectMapper = objectMapper;
this.scopeCacher = scopeCacher;
}
@Override
public List<StructureDefinitionData> load() {
return this.scopeCacher.getCachedOrCompute(
SystemAdHocStructureDefinitionLoader.class,
this::load
);
}
private List<StructureDefinitionData> load(ScopeOptions scopeOptions) {
var importStructure = this.genericAdHocModelDefinitionsLoader.load(
scopeOptions,
ImportStructureDefinition.SERIALIZATION_TYPE,
RawStructureDefinitionData.class
).stream()
.map(StructureDefinitionNormalizer::normalize)
.toList();
var createStructure = this.genericAdHocModelDefinitionsLoader.load(
scopeOptions,
"CreateStructureDefinition",
RawStructureDefinitionData.class
).stream()
.map(StructureDefinitionNormalizer::normalize)
.toList();
var structureDefinition = this.genericAdHocModelDefinitionsLoader.load(
scopeOptions,
StructureDefinitionData.SERIALIZATION_TYPE,
StructureDefinitionData.class
);
var finalStructures = new ArrayList<>(importStructure);
finalStructures.addAll(createStructure);
finalStructures.addAll(structureDefinition);
var addElement = this.genericAdHocModelDefinitionsLoader.load(
scopeOptions,
"AddElementOnStructureDefinitionDifferential"
).stream()
.map(add -> this.fixAddElement(add, finalStructures))
.map(StructureDefinitionNormalizer::normalize)
.toList();
finalStructures.addAll(addElement);
return this.sortDefinitionsByKind(finalStructures);
}
@NotNull
private ArrayList<StructureDefinitionData> sortDefinitionsByKind(
List<StructureDefinitionData> definitionDTOs
) {
var sortedList = new ArrayList<StructureDefinitionData>();
sortedList.addAll(
definitionDTOs.stream()
.filter(dto -> dto.getKind().equals(AbstractStructureType.PRIMITIVE_TYPE))
.toList()
);
sortedList.addAll(
definitionDTOs.stream()
.filter(dto -> dto.getKind().equals(AbstractStructureType.COMPLEX_TYPE))
.toList()
);
sortedList.addAll(
definitionDTOs.stream()
.filter(dto -> dto.getKind().equals(AbstractStructureType.RESOURCE))
.toList()
);
return sortedList;
}
private RawStructureDefinitionData fixAddElement(
HashMap addElementMap,
ArrayList<StructureDefinitionData> finalStructures
) {
var id = (String) addElementMap.get("id");
var parentStructures = finalStructures.stream()
.filter(structure -> structure.getId().equals(id))
.toList();
if (parentStructures.isEmpty()) {
throw new RuntimeException(
String.format(
"You are trying to add ElementDefinition to StructureDefinition with id '%s'. "
+ "But it cant be found in requested scope.",
id
)
);
}
var element = addElementMap.get("element");
ArrayList<RawStructureDefinitionElementDefinition> castedElement = this.objectMapper.convertValue(
element,
new TypeReference<>() {
}
);
var parentStructure = parentStructures.get(0);
return new RawStructureDefinitionData(
id,
parentStructure.getUrl(),
parentStructure.getStatus(),
parentStructure.getDescription(),
parentStructure.getKind(),
parentStructure.getIsAbstract(),
parentStructure.getType(),
parentStructure.getBaseDefinition(),
new RawStructureDefinitionData.Differential(castedElement)
);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/systemfixtures | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/systemfixtures/model/SystemModelDefinitionsLoader.java | package ai.stapi.graphsystem.systemfixtures.model;
import ai.stapi.schema.adHocLoaders.FileLoader;
import ai.stapi.schema.adHocLoaders.AbstractFileModelDefinitionsLoader;
import ai.stapi.schema.scopeProvider.ScopeOptions;
import org.springframework.stereotype.Service;
public class SystemModelDefinitionsLoader extends AbstractFileModelDefinitionsLoader {
public static final String SCOPE = "system";
public static final String TAG = ScopeOptions.DOMAIN_TAG;
public SystemModelDefinitionsLoader(
FileLoader fileLoader
) {
super(fileLoader, SCOPE, TAG);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/systemfixtures | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/systemfixtures/model/SystemModelFixtureGenerator.java | package ai.stapi.graphsystem.systemfixtures.model;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import ai.stapi.graphsystem.fixtures.fixtureCommandsGenerator.AbstractModelFileFixtureGenerator;
import ai.stapi.schema.adHocLoaders.FileLoader;
import java.util.List;
import java.util.logging.Logger;
import org.springframework.stereotype.Service;
public class SystemModelFixtureGenerator extends AbstractModelFileFixtureGenerator {
public static final String TAG = "system-model";
public SystemModelFixtureGenerator(
FileLoader fileLoader
) {
super(
new ObjectMapper()
.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS)
.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES),
fileLoader
);
}
@Override
public float getPriority() {
return PRIORITY_STRUCTURES;
}
@Override
public List<String> getFixtureTags() {
return List.of(TAG);
}
}
|
0 | java-sources/ai/stapi/graphql-api/0.2.3/ai | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/Application.java | package ai.stapi;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
new SpringApplicationBuilder(Application.class).run(args);
}
}
|
0 | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql/GraphQlEndpoint.java | package ai.stapi.graphql;
import java.util.LinkedHashMap;
import java.util.Map;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class GraphQlEndpoint {
private final GraphQlExecutor graphQlExecutor;
public GraphQlEndpoint(
GraphQlExecutor graphQlExecutor
) {
this.graphQlExecutor = graphQlExecutor;
}
@PostMapping("/graphql")
@ResponseBody
public Map<String, Object> graphQl(@RequestBody GraphQlOperation graphQLOperation) {
var response = new LinkedHashMap<String, Object>();
response.put("data", this.graphQlExecutor.execute(graphQLOperation));
return response;
}
}
|
0 | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql/GraphQlExecutor.java | package ai.stapi.graphql;
import ai.stapi.graphql.graphqlJava.graphQLProvider.GraphQLProvider;
import graphql.ExecutionInput;
import java.util.Map;
public class GraphQlExecutor {
private final GraphQLProvider schemaProvider;
public GraphQlExecutor(GraphQLProvider schemaProvider) {
this.schemaProvider = schemaProvider;
}
public Map<Object, Object> execute(GraphQlOperation graphQLOperation) {
var executionInputBuilder = new ExecutionInput.Builder().query(graphQLOperation.getQuery());
if (graphQLOperation.getOperationName() != null) {
executionInputBuilder.operationName(graphQLOperation.getOperationName());
}
if (graphQLOperation.getVariables() != null) {
executionInputBuilder.variables(graphQLOperation.getVariables());
}
var executionResult = this.schemaProvider.getGraphQL().execute(executionInputBuilder);
return executionResult.getData();
}
}
|
0 | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql/GraphQlOperation.java | package ai.stapi.graphql;
import java.util.HashMap;
import java.util.Map;
public class GraphQlOperation {
private String operationName;
private String query;
private Map<String, Object> variables;
protected GraphQlOperation() {
}
public GraphQlOperation(String operationName, String query, Map<String, Object> variables) {
this.operationName = operationName;
this.query = query;
this.variables = variables;
}
public GraphQlOperation(String operationName, String query) {
this(operationName, query, new HashMap<>());
}
public String getQuery() {
return query;
}
public String getOperationName() {
return operationName;
}
public Map<String, Object> getVariables() {
return variables;
}
}
|
0 | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql/InitializeGraphQlCommandLineRunner.java | package ai.stapi.graphql;
import ai.stapi.graphql.graphqlJava.graphQLProvider.GraphQLProvider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
public class InitializeGraphQlCommandLineRunner implements CommandLineRunner {
private final GraphQLProvider graphQLProvider;
private final Logger logger;
public InitializeGraphQlCommandLineRunner(
GraphQLProvider graphQLProvider
) {
this.graphQLProvider = graphQLProvider;
this.logger = LoggerFactory.getLogger(InitializeGraphQlCommandLineRunner.class);
}
@Override
public void run(String... args) {
try {
this.graphQLProvider.initialize();
} catch (Exception exception) {
this.logger.error("unable to generate graphql schema", exception);
}
}
}
|
0 | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql/PrintGraphQLCommandLineRunner.java | package ai.stapi.graphql;
import ai.stapi.graphql.generateGraphQlSchema.PrintGraphQlSchema;
import java.util.Arrays;
import org.axonframework.commandhandling.gateway.CommandGateway;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.context.ApplicationContext;
public class PrintGraphQLCommandLineRunner implements CommandLineRunner {
private final CommandGateway commandGateway;
private final ApplicationContext applicationContext;
public PrintGraphQLCommandLineRunner(
CommandGateway commandGateway,
ApplicationContext applicationContext
) {
this.commandGateway = commandGateway;
this.applicationContext = applicationContext;
}
@Override
public void run(String... args) {
if (args.length == 0) {
throw new RuntimeException("Please specify path where to print schema as command line argument.");
}
var path = Arrays.stream(args)
.filter(arg -> arg.startsWith("_schemaOutputPath:"))
.map(arg -> arg.replace("_schemaOutputPath:", ""))
.findFirst();
var command = new PrintGraphQlSchema(path.orElse(args[0]));
this.commandGateway.sendAndWait(command);
var exitCode = SpringApplication.exit(this.applicationContext, () -> 0);
System.exit(exitCode);
}
}
|
0 | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql/configuration/GraphQLConfiguration.java | package ai.stapi.graphql.configuration;
import ai.stapi.graphoperations.graphLoader.GraphLoader;
import ai.stapi.graphoperations.graphLoader.search.filterOption.factory.FilterOptionFactory;
import ai.stapi.graphql.GraphQlExecutor;
import ai.stapi.graphql.InitializeGraphQlCommandLineRunner;
import ai.stapi.graphql.PrintGraphQLCommandLineRunner;
import ai.stapi.graphql.generateGraphQlSchema.GraphQlSchemaGenerator;
import ai.stapi.graphql.generateGraphQlSchema.PrintGraphQlSchemaCommandHandler;
import ai.stapi.graphql.graphqlJava.CommandGqlDataFetcher;
import ai.stapi.graphql.graphqlJava.GraphLoaderGqlDataFetcher;
import ai.stapi.graphql.graphqlJava.graphQLProvider.GraphQLProvider;
import ai.stapi.graphql.graphqlJava.graphQLProvider.SchemaGraphQlProvider;
import ai.stapi.graphql.graphqlJava.graphQlSchemaGenerator.GraphQlFilterInputGenerator;
import ai.stapi.graphql.graphqlJava.graphQlSchemaGenerator.GraphQlJavaSchemaGenerator;
import ai.stapi.graphql.graphqlJava.graphQlSchemaGenerator.GraphQlObjectTypeGenerator;
import ai.stapi.graphql.graphqlJava.graphQlSchemaGenerator.GraphQlScalarSchemaGenerator;
import ai.stapi.graphql.graphqlJava.graphQlSchemaGenerator.GraphQlSortInputGenerator;
import ai.stapi.graphsystem.aggregatedefinition.model.AggregateDefinitionProvider;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionProvider;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionStructureTypeMapper;
import ai.stapi.schema.scopeProvider.ScopeCacher;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaProvider;
import org.axonframework.commandhandling.gateway.CommandGateway;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Profile;
@AutoConfiguration
@ComponentScan("ai.stapi.graphql")
public class GraphQLConfiguration {
@Bean
public GraphQlExecutor graphQlExecutor(GraphQLProvider graphQLProvider) {
return new GraphQlExecutor(graphQLProvider);
}
@Bean
@ConditionalOnMissingBean(GraphQLProvider.class)
public SchemaGraphQlProvider schemaGraphQlProvider(
GraphQlJavaSchemaGenerator graphQlJavaSchemaGenerator,
StructureSchemaProvider structureSchemaProvider,
OperationDefinitionProvider operationDefinitionProvider,
OperationDefinitionStructureTypeMapper operationDefinitionStructureTypeMapper,
ScopeCacher scopeCacher
) {
return new SchemaGraphQlProvider(
graphQlJavaSchemaGenerator,
structureSchemaProvider,
operationDefinitionProvider,
operationDefinitionStructureTypeMapper,
scopeCacher
);
}
@Bean
@ConditionalOnMissingBean(GraphQlSchemaGenerator.class)
@ConditionalOnBean(SchemaGraphQlProvider.class)
public GraphQlJavaSchemaGenerator graphQlJavaSchemaGenerator(
GraphQlSortInputGenerator graphQlSortInputGenerator,
GraphQlFilterInputGenerator graphQlFilterInputGenerator,
GraphQlObjectTypeGenerator graphQlObjectTypeGenerator,
GraphQlScalarSchemaGenerator graphQlScalarSchemaGenerator,
GraphLoaderGqlDataFetcher graphLoaderGqlDataFetcher,
CommandGqlDataFetcher commandGqlDataFetcher
) {
return new GraphQlJavaSchemaGenerator(
graphQlSortInputGenerator,
graphQlFilterInputGenerator,
graphQlObjectTypeGenerator,
graphQlScalarSchemaGenerator,
graphLoaderGqlDataFetcher,
commandGqlDataFetcher
);
}
@Bean
@ConditionalOnBean(GraphQlJavaSchemaGenerator.class)
public GraphQlSortInputGenerator graphQlSortInputGenerator() {
return new GraphQlSortInputGenerator();
}
@Bean
@ConditionalOnBean(GraphQlJavaSchemaGenerator.class)
public GraphQlFilterInputGenerator graphQlFilterInputGenerator() {
return new GraphQlFilterInputGenerator();
}
@Bean
@ConditionalOnBean(GraphQlJavaSchemaGenerator.class)
public GraphQlObjectTypeGenerator graphQlObjectTypeGenerator(
GraphQlSortInputGenerator graphQLSortInputGenerator,
GraphQlFilterInputGenerator graphQlFilterInputGenerator
) {
return new GraphQlObjectTypeGenerator(
graphQLSortInputGenerator,
graphQlFilterInputGenerator
);
}
@Bean
@ConditionalOnBean(GraphQlJavaSchemaGenerator.class)
public GraphQlScalarSchemaGenerator graphQlScalarSchemaGenerator() {
return new GraphQlScalarSchemaGenerator();
}
@Bean
@ConditionalOnBean(GraphQlJavaSchemaGenerator.class)
public GraphLoaderGqlDataFetcher graphLoaderGqlDataFetcher(
GraphLoader graphLoader,
FilterOptionFactory filterOptionFactory
) {
return new GraphLoaderGqlDataFetcher(graphLoader, filterOptionFactory);
}
@Bean
@ConditionalOnBean(GraphQlJavaSchemaGenerator.class)
public CommandGqlDataFetcher commandGqlDataFetcher(
CommandGateway commandGateway,
AggregateDefinitionProvider aggregateDefinitionProvider,
StructureSchemaProvider graphDefinitionProvider,
OperationDefinitionStructureTypeMapper operationDefinitionStructureTypeMapper
) {
return new CommandGqlDataFetcher(
commandGateway,
aggregateDefinitionProvider,
graphDefinitionProvider,
operationDefinitionStructureTypeMapper
);
}
@Bean
public InitializeGraphQlCommandLineRunner initializeGraphQlCommandLineRunner(GraphQLProvider graphQLProvider) {
return new InitializeGraphQlCommandLineRunner(graphQLProvider);
}
@Bean
public PrintGraphQlSchemaCommandHandler printGraphQlSchemaCommandHandler(
GraphQlSchemaGenerator graphQlSchemaGenerator,
StructureSchemaProvider graphDefinitionProvider,
OperationDefinitionProvider operationDefinitionProvider,
OperationDefinitionStructureTypeMapper operationDefinitionStructureTypeMapper
) {
return new PrintGraphQlSchemaCommandHandler(
graphQlSchemaGenerator,
graphDefinitionProvider,
operationDefinitionProvider,
operationDefinitionStructureTypeMapper
);
}
@Bean
@Profile("print-graphql-schema")
public PrintGraphQLCommandLineRunner printGraphQLCommandLineRunner(
CommandGateway commandGateway,
ApplicationContext applicationContext
) {
return new PrintGraphQLCommandLineRunner(commandGateway, applicationContext);
}
}
|
0 | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql/generateGraphQlSchema/GraphQlSchemaGenerator.java | package ai.stapi.graphql.generateGraphQlSchema;
import ai.stapi.schema.structureSchema.ComplexStructureType;
import ai.stapi.schema.structureSchema.StructureSchema;
import java.util.List;
public interface GraphQlSchemaGenerator {
String generate(
StructureSchema graphDefinition,
List<ComplexStructureType> operationDefinitions
);
}
|
0 | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql/generateGraphQlSchema/PrintGraphQlSchema.java | package ai.stapi.graphql.generateGraphQlSchema;
import ai.stapi.graphsystem.messaging.command.AbstractCommand;
import ai.stapi.identity.UniqueIdentifier;
public class PrintGraphQlSchema extends AbstractCommand<UniqueIdentifier> {
public static final String SERIALIZATION_TYPE = "PrintGraphQlSchema";
public static final String TARGET_IDENTIFIER = "PrintGraphQlSchema";
private String outputPath;
protected PrintGraphQlSchema() {
super(new UniqueIdentifier(TARGET_IDENTIFIER), SERIALIZATION_TYPE);
}
public PrintGraphQlSchema(String outputPath) {
super(new UniqueIdentifier(TARGET_IDENTIFIER), SERIALIZATION_TYPE);
this.outputPath = outputPath;
}
public String getOutputPath() {
return outputPath;
}
}
|
0 | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql/generateGraphQlSchema/PrintGraphQlSchemaCommandHandler.java | package ai.stapi.graphql.generateGraphQlSchema;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionProvider;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionStructureTypeMapper;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaProvider;
import java.io.FileWriter;
import java.io.IOException;
import org.axonframework.commandhandling.CommandHandler;
public class PrintGraphQlSchemaCommandHandler {
private final GraphQlSchemaGenerator graphQlSchemaGenerator;
private final StructureSchemaProvider graphDefinitionProvider;
private final OperationDefinitionProvider operationDefinitionProvider;
private final OperationDefinitionStructureTypeMapper operationDefinitionStructureTypeMapper;
public PrintGraphQlSchemaCommandHandler(
GraphQlSchemaGenerator graphQlSchemaGenerator,
StructureSchemaProvider graphDefinitionProvider,
OperationDefinitionProvider operationDefinitionProvider,
OperationDefinitionStructureTypeMapper operationDefinitionStructureTypeMapper
) {
this.graphQlSchemaGenerator = graphQlSchemaGenerator;
this.graphDefinitionProvider = graphDefinitionProvider;
this.operationDefinitionProvider = operationDefinitionProvider;
this.operationDefinitionStructureTypeMapper = operationDefinitionStructureTypeMapper;
}
@CommandHandler
public void handle(PrintGraphQlSchema command) throws IOException {
var graphDefinition = this.graphDefinitionProvider.provideSchema();
var operationDefinitions = this.operationDefinitionProvider.provideAll();
var schema = this.graphQlSchemaGenerator.generate(
graphDefinition,
this.operationDefinitionStructureTypeMapper.map(operationDefinitions)
);
try (var writer = new FileWriter(command.getOutputPath())) {
writer.write(schema);
}
}
}
|
0 | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql/graphqlJava/CommandGqlDataFetcher.java | package ai.stapi.graphql.graphqlJava;
import ai.stapi.graphql.graphqlJava.exceptions.CannotLoadRequestedDataByGraphQL;
import ai.stapi.graphsystem.aggregatedefinition.model.AggregateDefinitionProvider;
import ai.stapi.graphsystem.aggregatedefinition.model.CommandHandlerDefinitionDTO;
import ai.stapi.graphsystem.messaging.command.DynamicCommand;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionStructureTypeMapper;
import ai.stapi.identity.UniqueIdentifier;
import ai.stapi.identity.UniversallyUniqueIdentifier;
import ai.stapi.schema.structureSchema.AbstractStructureType;
import ai.stapi.schema.structureSchema.ComplexStructureType;
import ai.stapi.schema.structureSchema.FieldType;
import ai.stapi.schema.structureSchema.PrimitiveStructureType;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaProvider;
import ai.stapi.schema.structureSchemaProvider.exception.CannotProvideStructureSchema;
import graphql.language.ArrayValue;
import graphql.language.BooleanValue;
import graphql.language.Field;
import graphql.language.FloatValue;
import graphql.language.IntValue;
import graphql.language.ObjectValue;
import graphql.language.OperationDefinition;
import graphql.language.StringValue;
import graphql.language.Value;
import graphql.schema.DataFetcher;
import graphql.schema.DataFetchingEnvironment;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.apache.commons.lang3.StringUtils;
import org.axonframework.commandhandling.gateway.CommandGateway;
public class CommandGqlDataFetcher implements DataFetcher<CommandGqlDataFetcher.MutationResponse> {
private final CommandGateway commandGateway;
private final AggregateDefinitionProvider aggregateDefinitionProvider;
private final StructureSchemaProvider graphDefinitionProvider;
private final OperationDefinitionStructureTypeMapper operationDefinitionStructureTypeMapper;
public CommandGqlDataFetcher(
CommandGateway commandGateway,
AggregateDefinitionProvider aggregateDefinitionProvider,
StructureSchemaProvider graphDefinitionProvider,
OperationDefinitionStructureTypeMapper operationDefinitionStructureTypeMapper
) {
this.commandGateway = commandGateway;
this.aggregateDefinitionProvider = aggregateDefinitionProvider;
this.graphDefinitionProvider = graphDefinitionProvider;
this.operationDefinitionStructureTypeMapper = operationDefinitionStructureTypeMapper;
}
@Override
public MutationResponse get(DataFetchingEnvironment environment) throws Exception {
var commandName = StringUtils.capitalize(environment.getFieldDefinition().getName());
var operationDefinition = this.aggregateDefinitionProvider.provideAll().stream()
.flatMap(aggregateDefinitionDTO -> aggregateDefinitionDTO.getCommand().stream())
.map(CommandHandlerDefinitionDTO::getOperation)
.filter(operation -> operation.getId().equals(commandName))
.findFirst();
if (operationDefinition.isEmpty()) {
throw CannotLoadRequestedDataByGraphQL.becauseProvidedMutationDidNotHaveCorrespondingOperationDefinition(
commandName
);
}
var documentDefinition = (OperationDefinition) environment.getDocument()
.getDefinitions()
.get(0);
var mainSelectionSet = documentDefinition.getSelectionSet();
var mainSelection = mainSelectionSet.getSelections().stream()
.filter(Field.class::isInstance)
.map(Field.class::cast)
.filter(selection -> selection.getName().equals(environment.getFieldDefinition().getName()))
.toList()
.get(0);
var arguments = mainSelection.getArguments();
var originalPayload = arguments.stream()
.filter(argument -> argument.getName().equals("payload"))
.findFirst()
.orElseThrow()
.getValue();
Map<?, ?> mapPayload;
if (originalPayload instanceof ObjectValue objectValue) {
mapPayload = this.transformToMap(objectValue);
} else {
mapPayload = (Map<?, ?>) environment.getVariables().get("payload");
}
var fakedType = this.operationDefinitionStructureTypeMapper.map(
operationDefinition.get()
);
var finalPayload = this.fixInnerPayload(
fakedType.getDefinitionType(),
fakedType,
mapPayload
);
String id = environment.getArgument("id");
UniqueIdentifier identifier;
if (id == null) {
identifier = UniversallyUniqueIdentifier.randomUUID();
} else {
identifier = UniqueIdentifier.fromString(id);
}
var command = new DynamicCommand(identifier, commandName, finalPayload);
this.commandGateway.send(command);
return new MutationResponse(true);
}
private Map<String, Object> fixInnerPayload(
String commandName,
ComplexStructureType parentStructureType,
Map<?, ?> originalPayload
) {
var finalPayload = new HashMap<String, Object>();
parentStructureType.getAllFields().values().forEach(fieldDefinition -> {
var fieldName = fieldDefinition.getName();
if (originalPayload.keySet().stream().noneMatch(key -> key.toString().equals(fieldName))) {
return;
}
var originalValue = originalPayload.entrySet().stream()
.filter(field -> field.getKey().equals(fieldName))
.findFirst()
.orElseThrow()
.getValue();
if (fieldDefinition.isUnionType()) {
if (originalValue instanceof List<?> listOriginalValue) {
finalPayload.put(
fieldName,
listOriginalValue.stream().map(valueItem ->
this.getUnionMember(
commandName,
parentStructureType.getDefinitionType(),
fieldDefinition.getName(),
fieldDefinition.getTypes(),
valueItem
)
).collect(Collectors.toList())
);
return;
} else {
var unionMemberValue = this.getUnionMember(
commandName,
parentStructureType.getDefinitionType(),
fieldDefinition.getName(),
fieldDefinition.getTypes(),
originalValue
);
finalPayload.put(fieldName, unionMemberValue);
return;
}
}
var fieldType = fieldDefinition.getTypes().get(0).getType();
AbstractStructureType structure;
try {
structure = this.graphDefinitionProvider.provideSpecific(fieldType);
} catch (CannotProvideStructureSchema e) {
throw CannotLoadRequestedDataByGraphQL.becauseProvidedMutationHadParameterOfComplexTypeWithSomeFieldWhichDoesNotHaveStructureSchema(
commandName,
parentStructureType.getDefinitionType(),
fieldName,
fieldType,
e
);
}
if (structure instanceof PrimitiveStructureType) {
if (originalValue instanceof List<?> listValue) {
finalPayload.put(fieldName, listValue);
return;
} else {
finalPayload.put(fieldName, originalValue);
return;
}
}
if (fieldDefinition.getTypes().get(0).isReference()) {
if (originalValue instanceof List<?> listValue) {
finalPayload.put(fieldName, listValue.stream().map(id -> Map.of("id", id)));
return;
} else {
finalPayload.put(fieldName, Map.of("id", originalValue));
return;
}
}
if (structure instanceof ComplexStructureType complexStructureType) {
if (originalValue instanceof Map<?, ?> objectOriginalParameter) {
finalPayload.put(
fieldName,
this.fixInnerPayload(commandName, complexStructureType, objectOriginalParameter)
);
return;
}
if (originalValue instanceof List<?> arrayValue) {
finalPayload.put(
fieldName,
arrayValue.stream().map(originalItem ->
this.fixInnerPayload(
commandName,
complexStructureType,
(Map<?, ?>) originalItem
)
).collect(Collectors.toList())
);
return;
}
}
throw CannotLoadRequestedDataByGraphQL.becauseProvidedMutationHadParameterOfComplexTypeWithSomeFieldOfUnknownType(
commandName,
parentStructureType.getDefinitionType(),
fieldName,
fieldType
);
});
return finalPayload;
}
private Object getUnionMember(
String commandName,
String parentTypeName,
String fieldName,
List<FieldType> fieldTypes,
Object originalFieldValue
) {
if (!(originalFieldValue instanceof Map<?, ?> objectValue)) {
throw CannotLoadRequestedDataByGraphQL.becauseProvidedMutationHadParameterOfComplexTypeWithSomeInvalidUnionValue(
commandName,
parentTypeName,
fieldName,
originalFieldValue
);
}
if (objectValue.keySet().size() != 1) {
throw CannotLoadRequestedDataByGraphQL.becauseUnionInputDidNotHaveExactlyOneMemberSpecified(
commandName,
parentTypeName,
fieldName,
originalFieldValue
);
}
var unionMemberField = objectValue.entrySet().stream()
.findFirst()
.orElseThrow();
var memberType = (String) unionMemberField.getKey();
var memberValue = unionMemberField.getValue();
var fieldStructureType = fieldTypes.stream()
.filter(fieldType -> fieldType.isBoxed() ? fieldType.getOriginalType().equals(memberType)
: fieldType.getType().equals(memberType))
.findFirst()
.orElseThrow();
AbstractStructureType structure;
try {
structure = this.graphDefinitionProvider.provideSpecific(memberType);
} catch (CannotProvideStructureSchema e) {
throw CannotLoadRequestedDataByGraphQL.becauseProvidedMutationHadParameterOfComplexTypeWithSomeFieldWhichDoesNotHaveStructureSchema(
commandName,
parentTypeName,
fieldName,
memberType,
e
);
}
if (structure instanceof PrimitiveStructureType) {
return Map.of(
DynamicCommand.SERIALIZATION_TYPE_FIELD_NAME,
String.format("Boxed%s", StringUtils.capitalize(memberType)),
"value", memberValue
);
}
if (fieldStructureType.isReference()) {
return Map.of(
DynamicCommand.SERIALIZATION_TYPE_FIELD_NAME, memberType,
"id", memberValue
);
}
if (structure instanceof ComplexStructureType complexStructureType) {
var resultingMap = new HashMap<String, Object>();
resultingMap.put(
DynamicCommand.SERIALIZATION_TYPE_FIELD_NAME,
memberType
);
resultingMap.putAll(
this.fixInnerPayload(
commandName,
complexStructureType,
(Map<?, ?>) memberValue
)
);
return resultingMap;
}
throw CannotLoadRequestedDataByGraphQL.becauseProvidedMutationHadParameterOfComplexTypeWithSomeFieldOfUnknownType(
commandName,
parentTypeName,
fieldName,
memberType
);
}
private Map<String, Object> transformToMap(ObjectValue originalPayload) {
var result = new HashMap<String, Object>();
for (var field : originalPayload.getObjectFields()) {
var fieldName = field.getName();
var fieldValue = field.getValue();
if (fieldValue instanceof ObjectValue objectValue) {
// recursively transform nested object values
result.put(fieldName, this.transformToMap(objectValue));
} else if (fieldValue instanceof ArrayValue arrayValue) {
// transform array values
var arrayResult = new ArrayList<Object>();
for (var itemValue : arrayValue.getValues()) {
if (itemValue instanceof ObjectValue itemObjectValue) {
arrayResult.add(this.transformToMap(itemObjectValue));
} else {
arrayResult.add(this.deserializeScalarValue(itemValue));
}
}
result.put(fieldName, arrayResult);
} else {
result.put(fieldName, this.deserializeScalarValue(fieldValue));
}
}
return result;
}
private Object deserializeScalarValue(Value<?> value) {
if (value instanceof StringValue stringValue) {
return stringValue.getValue();
}
if (value instanceof BooleanValue booleanValue) {
return booleanValue.isValue();
}
if (value instanceof FloatValue floatValue) {
return floatValue.getValue().floatValue();
}
if (value instanceof IntValue intValue) {
return intValue.getValue().intValue();
}
return value;
}
public static class MutationResponse {
private final boolean success;
public MutationResponse(boolean success) {
this.success = success;
}
public boolean getSuccess() {
return success;
}
}
}
|
0 | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql/graphqlJava/GraphLoaderGqlDataFetcher.java | package ai.stapi.graphql.graphqlJava;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.EdgeDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NodeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NodeDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.UuidIdentityDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.AttributeQueryDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.CollectionComparisonOperator;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.NodeQueryGraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.OutgoingEdgeQueryDescription;
import ai.stapi.graphoperations.graphLoader.GraphLoader;
import ai.stapi.graphoperations.graphLoader.search.SearchQueryParameters;
import ai.stapi.graphoperations.graphLoader.search.filterOption.AllMatchFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.FilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.NoneMatchFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.NotFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.factory.FilterOptionFactory;
import ai.stapi.graphoperations.graphLoader.search.paginationOption.OffsetPaginationOption;
import ai.stapi.graphoperations.graphLoader.search.sortOption.AscendingSortOption;
import ai.stapi.graphoperations.graphLoader.search.sortOption.DescendingSortOption;
import ai.stapi.graphoperations.graphLoader.search.sortOption.SortOption;
import ai.stapi.graphql.graphqlJava.exceptions.CannotLoadRequestedDataByGraphQL;
import ai.stapi.graphql.graphqlJava.graphQlSchemaGenerator.GraphQlFilterInputGenerator;
import ai.stapi.identity.UniqueIdentifier;
import graphql.language.Argument;
import graphql.language.ArrayValue;
import graphql.language.BooleanValue;
import graphql.language.EnumValue;
import graphql.language.Field;
import graphql.language.FloatValue;
import graphql.language.IntValue;
import graphql.language.ObjectValue;
import graphql.language.OperationDefinition;
import graphql.language.SelectionSet;
import graphql.language.StringValue;
import graphql.language.Value;
import graphql.schema.DataFetcher;
import graphql.schema.DataFetchingEnvironment;
import graphql.schema.GraphQLFieldDefinition;
import graphql.schema.GraphQLList;
import graphql.schema.GraphQLNonNull;
import graphql.schema.GraphQLObjectType;
import graphql.schema.GraphQLScalarType;
import graphql.schema.GraphQLType;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.lang3.StringUtils;
import org.jetbrains.annotations.NotNull;
public class GraphLoaderGqlDataFetcher implements DataFetcher<Object> {
public static final OffsetPaginationOption DEFAULT_MAIN_PAGINATION = new OffsetPaginationOption(0, 10);
public static final OffsetPaginationOption DEFAULT_INNER_PAGINATION = new OffsetPaginationOption(0, 100);
private final GraphLoader graphLoader;
private final FilterOptionFactory filterOptionFactory;
public GraphLoaderGqlDataFetcher(
GraphLoader graphLoader,
FilterOptionFactory filterOptionFactory
) {
this.graphLoader = graphLoader;
this.filterOptionFactory = filterOptionFactory;
}
@Override
public Object get(DataFetchingEnvironment environment) {
var graphDescription = this.createGraphDescription(environment);
var type = environment.getFieldDefinition().getType();
if (type instanceof GraphQLNonNull graphQLNonNull && (environment.containsArgument("id"))) {
var innerType = graphQLNonNull.getWrappedType();
if (innerType instanceof GraphQLObjectType) {
var id = (String) environment.getArgument("id");
var output = this.graphLoader.get(
new UniqueIdentifier(id),
graphDescription,
Object.class
);
return output.getData();
}
}
if (type instanceof GraphQLNonNull graphQLNonNull) {
var innerType = graphQLNonNull.getWrappedType();
if (innerType instanceof GraphQLList) {
var output = this.graphLoader.find(
graphDescription,
Object.class
);
return output.getData();
}
}
throw CannotLoadRequestedDataByGraphQL.becauseInvalidFieldInQuery(
environment.getFieldDefinition()
);
}
private NodeQueryGraphDescription createGraphDescription(DataFetchingEnvironment environment) {
var type = environment.getFieldDefinition().getType();
var unwrappedType = this.unwrapFromListOrNonnull(type);
var documentDefinition =
(OperationDefinition) environment.getDocument().getDefinitions().get(0);
var mainSelectionSet = documentDefinition.getSelectionSet();
var mainSelection = (Field) mainSelectionSet.getSelections().stream()
.filter(Field.class::isInstance)
.filter(selection -> ((Field) selection).getName()
.equals(environment.getFieldDefinition().getName()))
.toList().get(0);
var innerSelectionSet = mainSelection.getSelectionSet();
if (unwrappedType instanceof GraphQLObjectType graphQLObjectType) {
var childGraphDescriptions = this.createChildGraphDescriptions(
innerSelectionSet,
graphQLObjectType
);
var arguments = mainSelection.getArguments();
var searchQueryParameters = this.deserializeSearchQueryParameters(
arguments,
graphQLObjectType,
childGraphDescriptions,
GraphLoaderGqlDataFetcher.DEFAULT_MAIN_PAGINATION
);
return new NodeQueryGraphDescription(
new NodeDescriptionParameters(graphQLObjectType.getName()),
searchQueryParameters,
childGraphDescriptions
);
}
throw CannotLoadRequestedDataByGraphQL.becauseInvalidFieldInQuery(
environment.getFieldDefinition());
}
private List<GraphDescription> createChildGraphDescriptions(
SelectionSet selectionSet,
GraphQLObjectType type
) {
return selectionSet.getSelections().stream()
.filter(Field.class::isInstance)
.map(Field.class::cast)
.filter(field -> !field.getName().equals("__typename"))
.map(field -> this.createChildGraphDescription(field,
type.getFieldDefinition(field.getName())))
.toList();
}
private GraphDescription createChildGraphDescription(
Field field,
GraphQLFieldDefinition fieldDefinition
) {
var unwrappedType = this.unwrapFromListOrNonnull(fieldDefinition.getType());
if (unwrappedType instanceof GraphQLScalarType) {
if (fieldDefinition.getName().equals("id")) {
return new UuidIdentityDescription();
}
return new AttributeQueryDescription(field.getName());
}
if (unwrappedType instanceof GraphQLObjectType graphQLObjectType) {
var childGraphDescriptions = this.createChildGraphDescriptions(
field.getSelectionSet(),
graphQLObjectType
);
var arguments = field.getArguments();
var searchQueryParameters = this.deserializeSearchQueryParameters(
arguments,
graphQLObjectType,
childGraphDescriptions,
GraphLoaderGqlDataFetcher.DEFAULT_INNER_PAGINATION
);
var fixedSearchQueryParameters = this.fixChildSearchQueryParameters(
graphQLObjectType.getName(),
searchQueryParameters
);
var nodeQueryGraphDescription = new NodeQueryGraphDescription(
new NodeDescriptionParameters(graphQLObjectType.getName()),
SearchQueryParameters.from(),
childGraphDescriptions
);
return new OutgoingEdgeQueryDescription(
new EdgeDescriptionParameters(fieldDefinition.getName()),
fixedSearchQueryParameters,
nodeQueryGraphDescription
);
}
throw CannotLoadRequestedDataByGraphQL.becauseInnerFieldWasNotObjectOrScalar(fieldDefinition);
}
private SearchQueryParameters deserializeSearchQueryParameters(
List<Argument> arguments,
GraphQLObjectType type,
List<GraphDescription> childGraphDescriptions,
OffsetPaginationOption defaultPagination
) {
var optionalPagination = arguments.stream()
.filter(argument -> argument.getName().equals("pagination"))
.findFirst();
var optionalSort = arguments.stream()
.filter(argument -> argument.getName().equals("sort"))
.findFirst();
var optionalFilter = arguments.stream()
.filter(argument -> argument.getName().equals("filter"))
.findFirst();
var parametersBuilder = SearchQueryParameters.builder();
if (optionalPagination.isPresent()) {
var pagination = optionalPagination.get();
parametersBuilder.setPaginationOption(this.deserializeOffsetPaginationOption(pagination));
} else {
parametersBuilder.setPaginationOption(defaultPagination);
}
if (optionalSort.isPresent()) {
var sort = optionalSort.get();
parametersBuilder.addSortOptions(
this.deserializeSortOptions(sort, type, childGraphDescriptions)
);
}
if (optionalFilter.isPresent()) {
var filter = optionalFilter.get();
parametersBuilder.addFilterOptions(this.deserializeFilterOptions(filter, type));
}
return parametersBuilder.build();
}
@NotNull
private OffsetPaginationOption deserializeOffsetPaginationOption(Argument pagination) {
var paginationValue = (ObjectValue) pagination.getValue();
var fields = paginationValue.getObjectFields();
var limit = (IntValue) fields.stream()
.filter(paginationField -> paginationField.getName().equals("limit"))
.findFirst()
.orElseThrow()
.getValue();
var offset = (IntValue) fields.stream()
.filter(paginationField -> paginationField.getName().equals("offset"))
.findFirst()
.orElseThrow()
.getValue();
return new OffsetPaginationOption(offset.getValue().intValue(), limit.getValue().intValue());
}
private List<SortOption> deserializeSortOptions(
Argument sort,
GraphQLObjectType type,
List<GraphDescription> childGraphDescriptions
) {
var sortValue = (ArrayValue) sort.getValue();
return sortValue.getValues().stream()
.map(value -> this.deserializeSortOption((ObjectValue) value, type, childGraphDescriptions))
.toList();
}
private List<FilterOption<?>> deserializeFilterOptions(
Argument filter,
GraphQLObjectType type
) {
var filterValue = (ArrayValue) filter.getValue();
var filterOptions = new ArrayList<FilterOption<?>>();
filterValue.getValues().forEach(
value -> filterOptions.add(
this.deserializeFilterOption((ObjectValue) value, type)
)
);
return filterOptions;
}
private SortOption deserializeSortOption(
ObjectValue sortOptionValue,
GraphQLObjectType type,
List<GraphDescription> childGraphDescriptions
) {
var fields = sortOptionValue.getObjectFields();
if (fields.size() != 1) {
throw CannotLoadRequestedDataByGraphQL.becauseProvidedSortOptionDidNotHaveExactlyOneField(sortOptionValue);
}
var field = fields.get(0);
if (field.getValue() instanceof EnumValue enumValue) {
if (enumValue.getName().equals("ASC")) {
return new AscendingSortOption(field.getName());
} else {
return new DescendingSortOption(field.getName());
}
}
if (field.getValue() instanceof ObjectValue objectValue) {
var fieldName = field.getName();
var fieldType = type.getFieldDefinition(fieldName).getType();
var unwrappedType = (GraphQLObjectType) this.unwrapFromListOrNonnull(fieldType);
var maybeInnerEdgeDescription = childGraphDescriptions.stream()
.filter(OutgoingEdgeQueryDescription.class::isInstance)
.map(OutgoingEdgeQueryDescription.class::cast)
.filter(outgoingEdgeQueryDescription -> {
var params = (EdgeDescriptionParameters) outgoingEdgeQueryDescription.getParameters();
return params.getEdgeType().equals(fieldName);
})
.findFirst();
List<GraphDescription> newChildGraphDescriptions = new ArrayList<>();
var edgeSearchOptions = SearchQueryParameters.from();
var nodeSearchOptions = SearchQueryParameters.from();
if (maybeInnerEdgeDescription.isPresent()) {
var innerEdgeDescription = maybeInnerEdgeDescription.get();
edgeSearchOptions = innerEdgeDescription.getSearchQueryParameters();
var maybeInnerNodeDescription = innerEdgeDescription.getChildGraphDescriptions().stream()
.filter(NodeQueryGraphDescription.class::isInstance)
.map(NodeQueryGraphDescription.class::cast)
.findFirst();
if (maybeInnerNodeDescription.isPresent()) {
var innerNodeDescription = maybeInnerNodeDescription.get();
nodeSearchOptions = innerNodeDescription.getSearchQueryParameters();
newChildGraphDescriptions = innerNodeDescription.getChildGraphDescriptions();
}
}
var innerSort = this.deserializeSortOption(objectValue, unwrappedType, newChildGraphDescriptions);
var newGraphDescription = new OutgoingEdgeQueryDescription(
new EdgeDescriptionParameters(fieldName),
edgeSearchOptions,
new NodeQueryGraphDescription(
new NodeDescriptionParameters(unwrappedType.getName()),
nodeSearchOptions,
innerSort.getParameters()
)
);
if (innerSort instanceof DescendingSortOption) {
return new DescendingSortOption(newGraphDescription);
} else {
return new AscendingSortOption(newGraphDescription);
}
}
throw CannotLoadRequestedDataByGraphQL.becauseProvidedSortOptionWasOfUnknownType(field.getValue());
}
private FilterOption<?> deserializeFilterOption(
ObjectValue filterOptionValue,
GraphQLObjectType type
) {
var fields = filterOptionValue.getObjectFields();
if (fields.size() != 1) {
throw CannotLoadRequestedDataByGraphQL.becauseProvidedFilterOptionDidNotHaveExactlyOneField(
filterOptionValue);
}
var field = fields.get(0);
var fieldName = field.getName();
var fieldValue = field.getValue();
int underscoreIndex = fieldName.indexOf("_");
if (underscoreIndex == -1) {
if (StringUtils.isAllUpperCase(fieldName)) {
var filterStrategy = fieldName.toLowerCase();
if (GraphQlFilterInputGenerator.MULTI_LOGICAL_FILTER_STRATEGIES.contains(filterStrategy)) {
if (fieldValue instanceof ArrayValue arrayValue) {
var invalidValueItems = arrayValue.getValues().stream()
.filter(itemValue -> !(itemValue instanceof ObjectValue))
.toList();
if (!invalidValueItems.isEmpty()) {
throw CannotLoadRequestedDataByGraphQL.becauseProvidedLogicalFilterInputHadInvalidType(
filterStrategy,
invalidValueItems
);
}
var children = new ArrayList<FilterOption<?>>();
arrayValue.getValues().stream()
.map(ObjectValue.class::cast)
.map(itemValue -> this.deserializeFilterOption(itemValue, type))
.forEach(children::add);
return this.filterOptionFactory.createLogical(filterStrategy, children);
}
throw CannotLoadRequestedDataByGraphQL.becauseProvidedMultiLogicalFilterInputWasNotOfArrayValue(
filterStrategy,
fieldValue
);
}
if (filterStrategy.equals(NotFilterOption.STRATEGY)) {
if (fieldValue instanceof ObjectValue objectValue) {
var child = this.deserializeFilterOption(objectValue, type);
return this.filterOptionFactory.createLogical(filterStrategy, List.of(child));
}
throw CannotLoadRequestedDataByGraphQL.becauseProvidedLogicalFilterInputHadInvalidType(
filterStrategy,
List.of(fieldValue)
);
}
}
if (fieldValue instanceof ObjectValue objectValue) {
var fieldType = type.getFieldDefinition(fieldName).getType();
var unwrappedType = (GraphQLObjectType) this.unwrapFromListOrNonnull(fieldType);
var innerFilter = this.deserializeFilterOption(objectValue, unwrappedType);
var innerGraphDescription = this.filterOptionFactory.getAttributeNamePath(innerFilter);
var newGraphDescription = new OutgoingEdgeQueryDescription(
new EdgeDescriptionParameters(fieldName),
SearchQueryParameters.from(),
new NodeQueryGraphDescription(
new NodeDescriptionParameters(unwrappedType.getName()),
SearchQueryParameters.from(),
innerGraphDescription
)
);
return this.filterOptionFactory.copyWithNewAttributeNamePath(
innerFilter,
newGraphDescription
);
}
throw CannotLoadRequestedDataByGraphQL.becauseProvidedDeepFilterWasNotOfObjectValue(
fieldName,
fieldValue
);
} else {
var attributeName = fieldName.substring(0, underscoreIndex);
var filterStrategy = fieldName.substring(underscoreIndex + 1).toLowerCase();
if (GraphQlFilterInputGenerator.LEAF_FILTER_STRATEGIES.contains(filterStrategy)) {
return this.filterOptionFactory.createLeaf(
filterStrategy,
attributeName,
this.deserializeScalarValue(field.getValue())
);
}
if (GraphQlFilterInputGenerator.LIST_FILTER_STRATEGIES.contains(filterStrategy)) {
if (fieldValue instanceof ObjectValue objectValue) {
var innerFields = objectValue.getObjectFields();
if (innerFields.size() != 1) {
throw CannotLoadRequestedDataByGraphQL.becauseProvidedFilterOptionDidNotHaveExactlyOneField(objectValue);
}
var innerField = innerFields.get(0);
var innerFieldName = innerField.getName();
if (StringUtils.isAllUpperCase(innerFieldName.replace("_", ""))) {
var leafFilter = this.filterOptionFactory.createLeaf(
innerFieldName.toLowerCase(),
attributeName,
this.deserializeScalarValue(innerField.getValue())
);
return this.filterOptionFactory.createList(
filterStrategy,
leafFilter
);
}
var fieldType = type.getFieldDefinition(attributeName).getType();
var unwrappedType = (GraphQLObjectType) this.unwrapFromListOrNonnull(fieldType);
var innerFilter = this.deserializeFilterOption(objectValue, unwrappedType);
var innerGraphDescription = this.filterOptionFactory.getAttributeNamePath(innerFilter);
var newGraphDescription = new OutgoingEdgeQueryDescription(
new EdgeDescriptionParameters(attributeName),
SearchQueryParameters.from(),
this.getCollectionComparisonOperatorFromFilterStrategy(filterStrategy),
new NodeQueryGraphDescription(
new NodeDescriptionParameters(unwrappedType.getName()),
SearchQueryParameters.from(),
innerGraphDescription
)
);
return this.filterOptionFactory.copyWithNewAttributeNamePath(
innerFilter,
newGraphDescription
);
}
throw CannotLoadRequestedDataByGraphQL.becauseProvidedListFilterInputWasNotOfObjectValue(
filterStrategy,
attributeName,
fieldValue
);
}
throw CannotLoadRequestedDataByGraphQL.becauseProvidedFilterOptionWasOfUnknownStrategy(filterStrategy);
}
}
private SearchQueryParameters fixChildSearchQueryParameters(
String nodeType,
SearchQueryParameters searchQueryParameters
) {
var builder = SearchQueryParameters.builder();
builder.setPaginationOption(searchQueryParameters.getPaginationOption());
searchQueryParameters.getSortOptions().forEach(sort -> {
var newGraphDescription = new NodeDescription(
nodeType,
sort.getParameters()
);
if (sort instanceof DescendingSortOption) {
builder.addSortOption(new DescendingSortOption(newGraphDescription));
} else {
builder.addSortOption(new AscendingSortOption(newGraphDescription));
}
});
searchQueryParameters.getFilterOptions().forEach(filter -> {
var newGraphDescription = new NodeDescription(
nodeType,
this.filterOptionFactory.getAttributeNamePath(filter)
);
builder.addFilterOption(this.filterOptionFactory.copyWithNewAttributeNamePath(filter, newGraphDescription));
});
return builder.build();
}
private Object deserializeScalarValue(Value<?> value) {
if (value instanceof StringValue stringValue) {
return stringValue.getValue();
}
if (value instanceof BooleanValue booleanValue) {
return booleanValue.isValue();
}
if (value instanceof FloatValue floatValue) {
return floatValue.getValue().floatValue();
}
if (value instanceof IntValue intValue) {
return intValue.getValue().intValue();
}
return value;
}
@NotNull
private CollectionComparisonOperator getCollectionComparisonOperatorFromFilterStrategy(String filterStrategy) {
if (filterStrategy.equals(NoneMatchFilterOption.STRATEGY)) {
return CollectionComparisonOperator.NONE;
}
if (filterStrategy.equals(AllMatchFilterOption.STRATEGY)) {
return CollectionComparisonOperator.ALL;
}
return CollectionComparisonOperator.ANY;
}
private GraphQLType unwrapFromListOrNonnull(GraphQLType graphQLType) {
if (graphQLType instanceof GraphQLList graphQLList) {
return this.unwrapFromListOrNonnull(graphQLList.getWrappedType());
}
if (graphQLType instanceof GraphQLNonNull graphQLNonNull) {
return this.unwrapFromListOrNonnull(graphQLNonNull.getWrappedType());
}
return graphQLType;
}
private GraphQLType unwrapFromNonnull(GraphQLType graphQLType) {
if (graphQLType instanceof GraphQLNonNull graphQLNonNull) {
return this.unwrapFromNonnull(graphQLNonNull.getWrappedType());
}
return graphQLType;
}
}
|
0 | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql/graphqlJava | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql/graphqlJava/exceptions/CannotGenerateGraphQLSchema.java | package ai.stapi.graphql.graphqlJava.exceptions;
public class CannotGenerateGraphQLSchema extends RuntimeException {
private CannotGenerateGraphQLSchema(String becauseMessage) {
super("Cannot generate graphQl schema, because " + becauseMessage);
}
public static CannotGenerateGraphQLSchema becauseStructureSchemaFieldHadNoType(
String typeName,
String fieldName
) {
return new CannotGenerateGraphQLSchema(
"structure schema has some field which has no type." +
"\nType name: " + typeName +
"\nField name: " + fieldName
);
}
public static CannotGenerateGraphQLSchema becauseOperationReferencedTypeWhichDoesNotExistInStructureSchema(
String operationName,
String parameterTypeName
) {
return new CannotGenerateGraphQLSchema(
"operation has parameter of type which does not exist in structure schema." +
"\nOperation name: " + operationName +
"\nParameter Type name: " + parameterTypeName
);
}
}
|
0 | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql/graphqlJava | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql/graphqlJava/exceptions/CannotLoadRequestedDataByGraphQL.java | package ai.stapi.graphql.graphqlJava.exceptions;
import ai.stapi.schema.structureSchemaProvider.exception.CannotProvideStructureSchema;
import graphql.language.ObjectValue;
import graphql.language.Value;
import graphql.schema.GraphQLFieldDefinition;
import java.util.List;
public class CannotLoadRequestedDataByGraphQL extends RuntimeException {
private CannotLoadRequestedDataByGraphQL(String becauseMessage) {
super("Cannot load requested data by GraphQL, because " + becauseMessage);
}
private CannotLoadRequestedDataByGraphQL(String becauseMessage, Throwable e) {
super("Cannot load requested data by GraphQL, because " + becauseMessage, e);
}
public static CannotLoadRequestedDataByGraphQL becauseInvalidFieldInQuery(
GraphQLFieldDefinition fieldDefinition) {
return new CannotLoadRequestedDataByGraphQL(
"invalid field encountered in main Query object." +
"\nField should either return list and take search query parameters. Or return object and take string id parameter."
+
"\nGQL field definition: " + fieldDefinition.toString()
);
}
public static CannotLoadRequestedDataByGraphQL becauseInnerFieldWasNotObjectOrScalar(
GraphQLFieldDefinition fieldDefinition) {
return new CannotLoadRequestedDataByGraphQL(
"some inner field definition was not Object or Scalar." +
"\nDefinition: " + fieldDefinition.toString()
);
}
public static CannotLoadRequestedDataByGraphQL becauseProvidedSortOptionDidNotHaveExactlyOneField(
ObjectValue sortOptionValue) {
return new CannotLoadRequestedDataByGraphQL(
"provided sort option did not have exactly one field." +
"\nSort option: " + sortOptionValue.toString()
);
}
public static CannotLoadRequestedDataByGraphQL becauseProvidedFilterOptionDidNotHaveExactlyOneField(
ObjectValue filterOptionValue) {
return new CannotLoadRequestedDataByGraphQL(
"provided filter option did not have exactly one field." +
"\nFilter option: " + filterOptionValue.toString()
);
}
public static CannotLoadRequestedDataByGraphQL becauseProvidedSortOptionWasOfUnknownType(
Value<?> value) {
return new CannotLoadRequestedDataByGraphQL(
"provided sort option was of unknown type." +
"\nSort value: " + value.toString()
);
}
public static CannotLoadRequestedDataByGraphQL becauseProvidedFilterOptionWasOfUnknownStrategy(
String filterStrategy) {
return new CannotLoadRequestedDataByGraphQL(
"provided filter option was of unknown strategy." +
"\nStrategy: " + filterStrategy
);
}
public static CannotLoadRequestedDataByGraphQL becauseProvidedListFilterInputWasNotOfObjectValue(
String filterStrategy,
String attributeName,
Value<?> value
) {
return new CannotLoadRequestedDataByGraphQL(
"provided list filter input was not of object value." +
"\nActual value: " + value +
"\nStrategy: " + filterStrategy +
"\nAttribute name: " + attributeName
);
}
public static CannotLoadRequestedDataByGraphQL becauseProvidedMultiLogicalFilterInputWasNotOfArrayValue(
String filterStrategy,
Value<?> value
) {
return new CannotLoadRequestedDataByGraphQL(
"provided multi logical filter input was not of array value." +
"\nActual value: " + value +
"\nStrategy: " + filterStrategy
);
}
public static CannotLoadRequestedDataByGraphQL becauseProvidedLogicalFilterInputHadInvalidType(
String filterStrategy,
List<Value> invalidValueItems
) {
return new CannotLoadRequestedDataByGraphQL(
"provided logical filter input was not object value." +
"\nInvalid values: " + invalidValueItems +
"\nStrategy: " + filterStrategy
);
}
public static CannotLoadRequestedDataByGraphQL becauseProvidedDeepFilterWasNotOfObjectValue(
String edgeType,
Value<?> value
) {
return new CannotLoadRequestedDataByGraphQL(
"provided deep filter input was not of object value." +
"\nActual value: " + value +
"\nEdge type/Field name: " + edgeType
);
}
public static CannotLoadRequestedDataByGraphQL becauseProvidedMutationDidNotHaveCorrespondingOperationDefinition(
String commandName
) {
return new CannotLoadRequestedDataByGraphQL(
"provided mutation did not have corresponding operation definition." +
"\nCommand name: " + commandName
);
}
public static CannotLoadRequestedDataByGraphQL becauseProvidedMutationHadParameterOfUnknownType(
String commandName,
String parameterName,
String parameterType
) {
return new CannotLoadRequestedDataByGraphQL(
"provided mutation had parameter of unknown type." +
"\nCommand name: " + commandName +
"\nParameter name: " + parameterName +
"\nParameter type: " + parameterType
);
}
public static CannotLoadRequestedDataByGraphQL becauseProvidedMutationHadParameterOfComplexTypeWithSomeFieldOfUnknownType(
String commandName,
String complexTypeName,
String fieldName,
String fieldType
) {
return new CannotLoadRequestedDataByGraphQL(
"provided mutation had parameter of complex type with some field of unknown type." +
"\nCommand name: " + commandName +
"\nType name: " + complexTypeName +
"\nField name: " + fieldName +
"\nField type: " + fieldType
);
}
public static CannotLoadRequestedDataByGraphQL becauseProvidedMutationHadParameterOfComplexTypeWithSomeInvalidUnionValue(
String commandName,
String typeName,
String fieldName,
Object actualUnionValue
) {
return new CannotLoadRequestedDataByGraphQL(
"provided mutation had parameter of complex type with some field of invalid union type." +
"\nCommand name: " + commandName +
"\nType name: " + typeName +
"\nField name: " + fieldName +
"\nUnion value: " + actualUnionValue
);
}
public static CannotLoadRequestedDataByGraphQL becauseUnionInputDidNotHaveExactlyOneMemberSpecified(
String commandName,
String typeName,
String fieldName,
Object actualUnionValue
) {
return new CannotLoadRequestedDataByGraphQL(
"provided mutation had parameter of complex type with some invalid field of union type." +
"\nThe value of this type did not have exactly one union member specified." +
"\nCommand name: " + commandName +
"\nType name: " + typeName +
"\nField name: " + fieldName +
"\nUnion value: " + actualUnionValue
);
}
public static CannotLoadRequestedDataByGraphQL becauseProvidedMutationHadParameterWhichDoesNotHaveStructureSchema(
String commandName,
String fieldName,
String fieldType,
CannotProvideStructureSchema e
) {
return new CannotLoadRequestedDataByGraphQL(
"provided mutation had parameter which does not have Structure Schema." +
"\nCommand name: " + commandName +
"\nParameter name: " + fieldName +
"\nParameter type: " + fieldType,
e
);
}
public static CannotLoadRequestedDataByGraphQL becauseProvidedMutationHadParameterOfComplexTypeWithSomeFieldWhichDoesNotHaveStructureSchema(
String commandName,
String definitionType,
String fieldName,
String fieldType,
CannotProvideStructureSchema e
) {
return new CannotLoadRequestedDataByGraphQL(
"provided mutation had parameter of complex type with some field which does not have Structure Schema."
+
"\nCommand name: " + commandName +
"\nType name: " + definitionType +
"\nField name: " + fieldName +
"\nField type: " + fieldType,
e
);
}
}
|
0 | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql/graphqlJava | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql/graphqlJava/graphQLProvider/DummyGraphQLProvider.java | package ai.stapi.graphql.graphqlJava.graphQLProvider;
import graphql.GraphQL;
import graphql.schema.GraphQLSchema;
public class DummyGraphQLProvider implements GraphQLProvider {
@Override
public void initialize() {
}
@Override
public void reinitialize() {
}
@Override
public boolean isInitialized() {
return false;
}
@Override
public GraphQL getGraphQL() {
return GraphQL.newGraphQL(GraphQLSchema.newSchema().build()).build();
}
@Override
public GraphQLSchema getGraphQLSchema() {
return GraphQLSchema.newSchema().build();
}
}
|
0 | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql/graphqlJava | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql/graphqlJava/graphQLProvider/GraphQLProvider.java | package ai.stapi.graphql.graphqlJava.graphQLProvider;
import graphql.GraphQL;
import graphql.schema.GraphQLSchema;
public interface GraphQLProvider {
void initialize();
void reinitialize();
boolean isInitialized();
GraphQL getGraphQL();
GraphQLSchema getGraphQLSchema();
}
|
0 | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql/graphqlJava | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql/graphqlJava/graphQLProvider/SchemaGraphQlProvider.java | package ai.stapi.graphql.graphqlJava.graphQLProvider;
import ai.stapi.graphql.graphqlJava.graphQlSchemaGenerator.GraphQlJavaSchemaGenerator;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionProvider;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionStructureTypeMapper;
import ai.stapi.schema.scopeProvider.ScopeCacher;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaProvider;
import graphql.GraphQL;
import graphql.schema.GraphQLSchema;
import java.util.Timer;
import java.util.TimerTask;
import org.jetbrains.annotations.Nullable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SchemaGraphQlProvider implements GraphQLProvider {
private final GraphQlJavaSchemaGenerator graphQlJavaSchemaGenerator;
private final StructureSchemaProvider structureSchemaProvider;
private final OperationDefinitionProvider operationDefinitionProvider;
private final OperationDefinitionStructureTypeMapper operationDefinitionStructureTypeMapper;
private final Logger logger;
private final ScopeCacher scopeCacher;
private final Timer initializeGraphQlTimer = new Timer();
private TimerTask initializeGraphQlTask;
public SchemaGraphQlProvider(
GraphQlJavaSchemaGenerator graphQlJavaSchemaGenerator,
StructureSchemaProvider structureSchemaProvider,
OperationDefinitionProvider operationDefinitionProvider,
OperationDefinitionStructureTypeMapper operationDefinitionStructureTypeMapper,
ScopeCacher scopeCacher
) {
this.graphQlJavaSchemaGenerator = graphQlJavaSchemaGenerator;
this.structureSchemaProvider = structureSchemaProvider;
this.operationDefinitionProvider = operationDefinitionProvider;
this.operationDefinitionStructureTypeMapper = operationDefinitionStructureTypeMapper;
this.scopeCacher = scopeCacher;
this.logger = LoggerFactory.getLogger(SchemaGraphQlProvider.class);
}
@Override
public void initialize() {
this.scopeCacher.cache(
SchemaGraphQlProvider.class,
this.build()
);
}
@Override
public void reinitialize() {
if (this.initializeGraphQlTask != null) {
this.initializeGraphQlTask.cancel();
}
var dis = this;
this.initializeGraphQlTask = new TimerTask() {
@Override
public void run() {
dis.initialize();
}
};
this.initializeGraphQlTimer.schedule(this.initializeGraphQlTask, 5000);
}
@Override
public boolean isInitialized() {
return this.scopeCacher.hasCached(SchemaGraphQlProvider.class);
}
@Override
@Nullable
public GraphQL getGraphQL() {
return this.scopeCacher.getCachedOrCompute(
SchemaGraphQlProvider.class,
scope -> this.build()
).getGraphQL();
}
@Override
@Nullable
public GraphQLSchema getGraphQLSchema() {
return this.scopeCacher.getCachedOrCompute(
SchemaGraphQlProvider.class,
scope -> this.build()
).getGraphQLSchema();
}
private SchemaAndGraphQl build() {
var graphDefinition = this.structureSchemaProvider.provideSchema();
if (graphDefinition.getStructureTypes().size() == 0) {
this.logger.warn(
"There was no StructureTypes in GraphDefinition to be found when initializing GraphQL. " +
"Therefore GraphQL service and related endpoint will not work."
);
}
var operationDefinitions = this.operationDefinitionProvider.provideAll();
if (operationDefinitions.isEmpty()) {
this.logger.warn(
"There was no Operation Definitions to be found when starting Application. " +
"Therefore GraphQL mutations will not work."
);
}
var graphQLSchema = this.graphQlJavaSchemaGenerator.generateSchema(
graphDefinition,
this.operationDefinitionStructureTypeMapper.map(operationDefinitions)
);
var graphQl = GraphQL.newGraphQL(graphQLSchema).build();
return new SchemaAndGraphQl(graphQLSchema, graphQl);
}
private static class SchemaAndGraphQl {
private final GraphQLSchema graphQLSchema;
private final GraphQL graphQL;
public SchemaAndGraphQl(GraphQLSchema graphQLSchema, GraphQL graphQL) {
this.graphQLSchema = graphQLSchema;
this.graphQL = graphQL;
}
public GraphQLSchema getGraphQLSchema() {
return graphQLSchema;
}
public GraphQL getGraphQL() {
return graphQL;
}
}
}
|
0 | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql/graphqlJava | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql/graphqlJava/graphQlSchemaGenerator/GraphQlFilterInputGenerator.java | package ai.stapi.graphql.graphqlJava.graphQlSchemaGenerator;
import ai.stapi.graph.attribute.attributeValue.Base64BinaryAttributeValue;
import ai.stapi.graph.attribute.attributeValue.BooleanAttributeValue;
import ai.stapi.graph.attribute.attributeValue.CanonicalAttributeValue;
import ai.stapi.graph.attribute.attributeValue.CodeAttributeValue;
import ai.stapi.graph.attribute.attributeValue.DateAttributeValue;
import ai.stapi.graph.attribute.attributeValue.DateTimeAttributeValue;
import ai.stapi.graph.attribute.attributeValue.DecimalAttributeValue;
import ai.stapi.graph.attribute.attributeValue.IdAttributeValue;
import ai.stapi.graph.attribute.attributeValue.InstantAttributeValue;
import ai.stapi.graph.attribute.attributeValue.IntegerAttributeValue;
import ai.stapi.graph.attribute.attributeValue.MarkdownAttributeValue;
import ai.stapi.graph.attribute.attributeValue.OidAttributeValue;
import ai.stapi.graph.attribute.attributeValue.PositiveIntegerAttributeValue;
import ai.stapi.graph.attribute.attributeValue.StringAttributeValue;
import ai.stapi.graph.attribute.attributeValue.TimeAttributeValue;
import ai.stapi.graph.attribute.attributeValue.UnsignedIntegerAttributeValue;
import ai.stapi.graph.attribute.attributeValue.UriAttributeValue;
import ai.stapi.graph.attribute.attributeValue.UrlAttributeValue;
import ai.stapi.graph.attribute.attributeValue.UuidAttributeValue;
import ai.stapi.graphoperations.graphLoader.search.filterOption.AllMatchFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.AndFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.AnyMatchFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.ContainsFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.EndsWithFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.EqualsFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.GreaterThanFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.GreaterThanOrEqualFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.LowerThanFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.LowerThanOrEqualsFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.NoneMatchFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.NotEqualsFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.NotFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.OrFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.StartsWithFilterOption;
import ai.stapi.schema.structureSchema.AbstractStructureType;
import ai.stapi.schema.structureSchema.ComplexStructureType;
import ai.stapi.schema.structureSchema.FieldDefinition;
import ai.stapi.schema.structureSchema.FieldType;
import ai.stapi.schema.structureSchema.PrimitiveStructureType;
import ai.stapi.schema.structureSchema.StructureSchema;
import graphql.schema.GraphQLInputObjectField;
import graphql.schema.GraphQLInputObjectType;
import graphql.schema.GraphQLInputType;
import graphql.schema.GraphQLList;
import graphql.schema.GraphQLNonNull;
import graphql.schema.GraphQLType;
import graphql.schema.GraphQLTypeReference;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.commons.lang3.StringUtils;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class GraphQlFilterInputGenerator {
public static final List<String> LEAF_FILTER_STRATEGIES = List.of(
ContainsFilterOption.STRATEGY,
EndsWithFilterOption.STRATEGY,
EqualsFilterOption.STRATEGY,
GreaterThanFilterOption.STRATEGY,
GreaterThanOrEqualFilterOption.STRATEGY,
LowerThanFilterOption.STRATEGY,
LowerThanOrEqualsFilterOption.STRATEGY,
NotEqualsFilterOption.STRATEGY,
StartsWithFilterOption.STRATEGY
);
public static final List<String> LIST_FILTER_STRATEGIES = List.of(
AllMatchFilterOption.STRATEGY,
AnyMatchFilterOption.STRATEGY,
NoneMatchFilterOption.STRATEGY
);
public static final List<String> MULTI_LOGICAL_FILTER_STRATEGIES = List.of(
AndFilterOption.STRATEGY,
OrFilterOption.STRATEGY
);
private static final List<String> STRING_TYPES = List.of(
Base64BinaryAttributeValue.SERIALIZATION_TYPE,
CanonicalAttributeValue.SERIALIZATION_TYPE,
CodeAttributeValue.SERIALIZATION_TYPE,
IdAttributeValue.SERIALIZATION_TYPE,
MarkdownAttributeValue.SERIALIZATION_TYPE,
OidAttributeValue.SERIALIZATION_TYPE,
StringAttributeValue.SERIALIZATION_TYPE,
UriAttributeValue.SERIALIZATION_TYPE,
UrlAttributeValue.SERIALIZATION_TYPE,
UuidAttributeValue.SERIALIZATION_TYPE
);
private static final List<String> NUMBER_TYPES = List.of(
DateAttributeValue.SERIALIZATION_TYPE,
DateTimeAttributeValue.SERIALIZATION_TYPE,
DecimalAttributeValue.SERIALIZATION_TYPE,
InstantAttributeValue.SERIALIZATION_TYPE,
IntegerAttributeValue.SERIALIZATION_TYPE,
PositiveIntegerAttributeValue.SERIALIZATION_TYPE,
TimeAttributeValue.SERIALIZATION_TYPE,
UnsignedIntegerAttributeValue.SERIALIZATION_TYPE
);
private static final List<String> STRING_FILTER_STRATEGIES = List.of(
ContainsFilterOption.STRATEGY,
EndsWithFilterOption.STRATEGY,
EqualsFilterOption.STRATEGY,
GreaterThanFilterOption.STRATEGY,
GreaterThanOrEqualFilterOption.STRATEGY,
LowerThanFilterOption.STRATEGY,
LowerThanOrEqualsFilterOption.STRATEGY,
NotEqualsFilterOption.STRATEGY,
StartsWithFilterOption.STRATEGY
);
private static final List<String> NUMBER_FILTER_STRATEGIES = List.of(
EqualsFilterOption.STRATEGY,
GreaterThanFilterOption.STRATEGY,
GreaterThanOrEqualFilterOption.STRATEGY,
LowerThanFilterOption.STRATEGY,
LowerThanOrEqualsFilterOption.STRATEGY,
NotEqualsFilterOption.STRATEGY
);
private static final List<String> DEFAULT_FILTER_STRATEGIES = List.of(
EqualsFilterOption.STRATEGY,
NotEqualsFilterOption.STRATEGY
);
public Map<String, GraphQLInputObjectType> generateFilterInputs(StructureSchema structureSchema) {
var filterInputTypeMap = new HashMap<String, GraphQLInputObjectType>();
structureSchema.getStructureTypes().values().stream()
.filter(definition -> definition instanceof ComplexStructureType)
.map(definition -> (ComplexStructureType) definition)
.flatMap(definition -> this.generate(
definition,
structureSchema
).stream())
.forEach(filterInput -> {
filterInputTypeMap.put(filterInput.getName(), filterInput);
});
return filterInputTypeMap;
}
private List<GraphQLInputObjectType> generate(
ComplexStructureType structureType,
StructureSchema structureSchema
) {
var fieldsAndSubTypes = this.createFieldsAndSubTypes(
structureType,
structureSchema
);
var name = structureType.getDefinitionType();
var types = new ArrayList<GraphQLInputObjectType>();
var logicalFilterInputTypeName = this.createLogicalFilterInputTypeName(name);
var logicalBuilder = new GraphQLInputObjectType.Builder().name(logicalFilterInputTypeName);
var filterInputTypeName = this.createFilterInputTypeName(name);
var builder = new GraphQLInputObjectType.Builder().name(filterInputTypeName);
fieldsAndSubTypes.fields().forEach(logicalBuilder::field);
fieldsAndSubTypes.fields().forEach(builder::field);
if (!fieldsAndSubTypes.fields().isEmpty()) {
GraphQlFilterInputGenerator.MULTI_LOGICAL_FILTER_STRATEGIES.stream()
.map(strategy -> new GraphQLInputObjectField.Builder()
.name(strategy.toUpperCase())
.type(GraphQLList.list(
GraphQLNonNull.nonNull(new GraphQLTypeReference(logicalFilterInputTypeName))))
).forEach(logicalBuilder::field);
logicalBuilder.field(
new GraphQLInputObjectField.Builder()
.name(NotFilterOption.STRATEGY.toUpperCase())
.type(new GraphQLTypeReference(logicalFilterInputTypeName))
);
types.add(logicalBuilder.build());
types.add(builder.build());
}
types.addAll(fieldsAndSubTypes.subtypes());
return types;
}
private GraphQlFilterInputGenerator.FilterFieldsAndSubtypes createFieldsAndSubTypes(
ComplexStructureType structureType,
StructureSchema structureSchema
) {
var fields = new ArrayList<GraphQLInputObjectField>();
var subtypes = new ArrayList<GraphQLInputObjectType>();
structureType.getAllFields().values().forEach(
fieldDefinition -> {
var fieldAndSubtypes = this.createFieldsAndSubtypes(
structureType,
fieldDefinition,
structureSchema
);
if (fieldAndSubtypes != null) {
fields.addAll(fieldAndSubtypes.fields());
subtypes.addAll(fieldAndSubtypes.subtypes());
}
}
);
return new GraphQlFilterInputGenerator.FilterFieldsAndSubtypes(fields, subtypes);
}
@Nullable
private GraphQlFilterInputGenerator.FilterFieldsAndSubtypes createFieldsAndSubtypes(
ComplexStructureType structureType,
FieldDefinition fieldDefinition,
StructureSchema structureSchema
) {
var types = fieldDefinition.getTypes().stream()
.map(FieldType::getType)
.toList();
var subtypes = new ArrayList<GraphQLInputObjectType>();
if (types.isEmpty()) {
return null;
}
var typeGraphDefinitions = types.stream()
.map(structureSchema::getDefinition)
.toList();
if (types.size() > 1) {
return null;
}
var typeGraphDefinition = typeGraphDefinitions.get(0);
if (typeGraphDefinition instanceof PrimitiveStructureType) {
if (this.isFieldList(fieldDefinition)) {
var defaultFilterStrategiesFields =
GraphQlFilterInputGenerator.DEFAULT_FILTER_STRATEGIES.stream()
.map(strategy -> GraphQLInputObjectField.newInputObjectField()
.name(fieldDefinition.getName() + "_" + strategy.toUpperCase())
.type(GraphQLList.list(
GraphQLNonNull.nonNull(this.getSpecialOrDefaultType(types))))
.build()
).toList();
var innerFields = this.getFilterGraphQLInputObjectFields(
fieldDefinition,
types,
typeGraphDefinition,
true
);
var childFilterInputTypeName = this.createFilterInputTypeName(
structureType.getDefinitionType() +
StringUtils.capitalize(fieldDefinition.getName()) +
"Child"
);
var childOptionsBuilder = new GraphQLInputObjectType.Builder()
.name(childFilterInputTypeName);
innerFields.forEach(childOptionsBuilder::field);
subtypes.add(childOptionsBuilder.build());
var listFilterStrategiesFields = GraphQlFilterInputGenerator.LIST_FILTER_STRATEGIES.stream()
.map(strategy -> GraphQLInputObjectField.newInputObjectField()
.name(fieldDefinition.getName() + "_" + strategy.toUpperCase())
.type(new GraphQLTypeReference(childFilterInputTypeName))
.build()
).toList();
var finalFields = new ArrayList<>(defaultFilterStrategiesFields);
finalFields.addAll(listFilterStrategiesFields);
return new GraphQlFilterInputGenerator.FilterFieldsAndSubtypes(
finalFields,
subtypes
);
}
var fields = this.getFilterGraphQLInputObjectFields(
fieldDefinition,
types,
typeGraphDefinition,
false
);
return new GraphQlFilterInputGenerator.FilterFieldsAndSubtypes(
fields,
subtypes
);
}
if (this.isFieldList(fieldDefinition)) {
return new GraphQlFilterInputGenerator.FilterFieldsAndSubtypes(
GraphQlFilterInputGenerator.LIST_FILTER_STRATEGIES.stream()
.map(strategy -> GraphQLInputObjectField.newInputObjectField()
.name(fieldDefinition.getName() + "_" + strategy.toUpperCase())
.type(new GraphQLTypeReference(this.createFilterInputTypeName(types.get(0))))
.build()
).toList(),
subtypes
);
}
return new GraphQlFilterInputGenerator.FilterFieldsAndSubtypes(
List.of(
GraphQLInputObjectField.newInputObjectField()
.name(fieldDefinition.getName())
.type(new GraphQLTypeReference(this.createFilterInputTypeName(types.get(0))))
.build()
),
subtypes
);
}
private List<GraphQLInputObjectField> getFilterGraphQLInputObjectFields(
FieldDefinition fieldDefinition,
List<String> types,
AbstractStructureType typeGraphDefinition,
boolean withShortNames
) {
if (GraphQlFilterInputGenerator.STRING_TYPES.contains(
typeGraphDefinition.getDefinitionType())) {
return GraphQlFilterInputGenerator.STRING_FILTER_STRATEGIES.stream()
.map(strategy -> GraphQLInputObjectField.newInputObjectField()
.name(this.getFieldName(fieldDefinition, strategy, withShortNames))
.type((GraphQLInputType) this.getSpecialOrDefaultType(types))
.build()
).toList();
}
if (GraphQlFilterInputGenerator.NUMBER_TYPES.contains(
typeGraphDefinition.getDefinitionType())) {
return GraphQlFilterInputGenerator.NUMBER_FILTER_STRATEGIES.stream()
.map(strategy -> GraphQLInputObjectField.newInputObjectField()
.name(this.getFieldName(fieldDefinition, strategy, withShortNames))
.type((GraphQLInputType) this.getSpecialOrDefaultType(types))
.build()
).toList();
}
if (typeGraphDefinition.getDefinitionType().equals(BooleanAttributeValue.SERIALIZATION_TYPE)) {
return GraphQlFilterInputGenerator.DEFAULT_FILTER_STRATEGIES.stream()
.map(strategy -> GraphQLInputObjectField.newInputObjectField()
.name(this.getFieldName(fieldDefinition, strategy, withShortNames))
.type((GraphQLInputType) this.getSpecialOrDefaultType(types))
.build()
).toList();
}
return new ArrayList<>();
}
@NotNull
private String getFieldName(
FieldDefinition fieldDefinition,
String strategy,
boolean withShortNames
) {
if (withShortNames) {
return strategy.toUpperCase();
}
return fieldDefinition.getName() + "_" + strategy.toUpperCase();
}
@NotNull
private GraphQLType getSpecialOrDefaultType(List<String> types) {
var name = types.get(0);
return GraphQlObjectTypeGenerator.FIELD_TYPE_SPECIAL_CASES.getOrDefault(
name,
new GraphQLTypeReference(name)
);
}
public String createLogicalFilterInputTypeName(String originalTypeName) {
return originalTypeName + "LogicalFilterOption";
}
public String createFilterInputTypeName(String originalTypeName) {
return originalTypeName + "FilterOption";
}
private boolean isFieldList(FieldDefinition fieldDefinition) {
return fieldDefinition.getMax().equals("*") ||
Integer.parseInt(fieldDefinition.getMax()) > 1;
}
protected record FilterFieldsAndSubtypes(
List<GraphQLInputObjectField> fields,
List<GraphQLInputObjectType> subtypes
) {
}
}
|
0 | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql/graphqlJava | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql/graphqlJava/graphQlSchemaGenerator/GraphQlJavaSchemaGenerator.java | package ai.stapi.graphql.graphqlJava.graphQlSchemaGenerator;
import ai.stapi.graphql.generateGraphQlSchema.GraphQlSchemaGenerator;
import ai.stapi.graphql.graphqlJava.CommandGqlDataFetcher;
import ai.stapi.graphql.graphqlJava.GraphLoaderGqlDataFetcher;
import ai.stapi.graphql.graphqlJava.exceptions.CannotGenerateGraphQLSchema;
import ai.stapi.schema.structureSchema.BoxedPrimitiveStructureType;
import ai.stapi.schema.structureSchema.ComplexStructureType;
import ai.stapi.schema.structureSchema.FieldDefinition;
import ai.stapi.schema.structureSchema.FieldType;
import ai.stapi.schema.structureSchema.PrimitiveStructureType;
import ai.stapi.schema.structureSchema.ResourceStructureType;
import ai.stapi.schema.structureSchema.StructureSchema;
import graphql.Scalars;
import graphql.schema.FieldCoordinates;
import graphql.schema.GraphQLArgument;
import graphql.schema.GraphQLCodeRegistry;
import graphql.schema.GraphQLFieldDefinition;
import graphql.schema.GraphQLInputObjectField;
import graphql.schema.GraphQLInputObjectType;
import graphql.schema.GraphQLInputType;
import graphql.schema.GraphQLList;
import graphql.schema.GraphQLNonNull;
import graphql.schema.GraphQLObjectType;
import graphql.schema.GraphQLSchema;
import graphql.schema.GraphQLType;
import graphql.schema.GraphQLTypeReference;
import graphql.schema.GraphQLUnionType;
import graphql.schema.idl.SchemaPrinter;
import java.util.List;
import java.util.Map;
import org.apache.commons.lang3.StringUtils;
import org.jetbrains.annotations.NotNull;
public class GraphQlJavaSchemaGenerator implements GraphQlSchemaGenerator {
protected static final GraphQLInputObjectType OFFSET_PAGINATION = GraphQLInputObjectType.newInputObject()
.name("OffsetPaginationOption")
.field(
GraphQLInputObjectField.newInputObjectField()
.name("offset")
.type(GraphQLNonNull.nonNull(Scalars.GraphQLInt))
).field(
GraphQLInputObjectField.newInputObjectField()
.name("limit")
.type(GraphQLNonNull.nonNull(Scalars.GraphQLInt))
).build();
protected static final GraphQLObjectType MUTATION_RESPONSE = GraphQLObjectType.newObject()
.name("MutationResponse")
.field(
GraphQLFieldDefinition.newFieldDefinition()
.name("successes")
.type(Scalars.GraphQLBoolean)
.build()
).build();
protected static final String ANY_NODE = "AnyNode";
private final GraphQlSortInputGenerator graphQlSortInputGenerator;
private final GraphQlFilterInputGenerator graphQlFilterInputGenerator;
private final GraphQlObjectTypeGenerator graphQlObjectTypeGenerator;
private final GraphQlScalarSchemaGenerator graphQlScalarSchemaGenerator;
private final GraphLoaderGqlDataFetcher graphLoaderGqlDataFetcher;
private final CommandGqlDataFetcher commandGqlDataFetcher;
public GraphQlJavaSchemaGenerator(
GraphQlSortInputGenerator graphQlSortInputGenerator,
GraphQlFilterInputGenerator graphQlFilterInputGenerator,
GraphQlObjectTypeGenerator graphQlObjectTypeGenerator,
GraphQlScalarSchemaGenerator graphQlScalarSchemaGenerator,
GraphLoaderGqlDataFetcher graphLoaderGqlDataFetcher,
CommandGqlDataFetcher commandGqlDataFetcher
) {
this.graphQlSortInputGenerator = graphQlSortInputGenerator;
this.graphQlFilterInputGenerator = graphQlFilterInputGenerator;
this.graphQlObjectTypeGenerator = graphQlObjectTypeGenerator;
this.graphQlScalarSchemaGenerator = graphQlScalarSchemaGenerator;
this.graphLoaderGqlDataFetcher = graphLoaderGqlDataFetcher;
this.commandGqlDataFetcher = commandGqlDataFetcher;
}
@Override
public String generate(
StructureSchema graphDefinition,
List<ComplexStructureType> operationDefinitions
) {
var qlSchema = this.generateSchema(graphDefinition, operationDefinitions);
var printer = new SchemaPrinter(
SchemaPrinter.Options.defaultOptions()
.includeScalarTypes(true)
.includeIntrospectionTypes(false)
);
return printer.print(qlSchema);
}
public GraphQLSchema generateSchema(
StructureSchema graphDefinition,
List<ComplexStructureType> operationDefinitions
) {
var schema = GraphQLSchema.newSchema();
var codeRegistry = GraphQLCodeRegistry.newCodeRegistry();
this.generateQuery(graphDefinition, schema, codeRegistry);
this.generateMutations(operationDefinitions, graphDefinition, schema, codeRegistry);
return schema.codeRegistry(codeRegistry.build()).build();
}
private void generateQuery(
StructureSchema graphDefinition,
GraphQLSchema.Builder schema,
GraphQLCodeRegistry.Builder codeRegistry
) {
var sortInputs = this.graphQlSortInputGenerator.generateSortInputs(graphDefinition);
sortInputs.values().forEach(schema::additionalType);
var filterInputs = this.graphQlFilterInputGenerator.generateFilterInputs(graphDefinition);
filterInputs.values().forEach(schema::additionalType);
this.generateMainQueryObject(graphDefinition, schema, codeRegistry, sortInputs, filterInputs);
this.generateComplexTypes(graphDefinition, schema, sortInputs, filterInputs);
this.generatePrimitiveTypes(graphDefinition, schema);
this.generateAnyNodeUnion(graphDefinition, schema);
}
private void generateMainQueryObject(
StructureSchema graphDefinition,
GraphQLSchema.Builder schema,
GraphQLCodeRegistry.Builder codeRegistry,
Map<String, GraphQLInputObjectType> sortInputs,
Map<String, GraphQLInputObjectType> filterInputs
) {
var queryObjectBuilder = GraphQLObjectType.newObject().name("Query");
graphDefinition.getStructureTypes().values().stream()
.filter(definition -> definition instanceof ResourceStructureType)
.forEach(definition -> this.addResourceToQueryObjectAndCodeRegistry(
queryObjectBuilder,
codeRegistry,
definition.getDefinitionType(),
sortInputs,
filterInputs
));
schema.query(queryObjectBuilder);
}
private void generateComplexTypes(
StructureSchema graphDefinition,
GraphQLSchema.Builder schema,
Map<String, GraphQLInputObjectType> sortInputs,
Map<String, GraphQLInputObjectType> filterInputs
) {
graphDefinition.getStructureTypes().values().stream()
.filter(definition -> definition instanceof ComplexStructureType)
.map(definition -> this.graphQlObjectTypeGenerator.generateObjectType(
definition,
graphDefinition,
sortInputs,
filterInputs
)).flatMap(List::stream).forEach(schema::additionalType);
}
private void generatePrimitiveTypes(StructureSchema graphDefinition,
GraphQLSchema.Builder schema) {
graphDefinition.getStructureTypes().values().stream()
.filter(definition -> definition instanceof PrimitiveStructureType)
.map(definition -> (PrimitiveStructureType) definition)
.map(this.graphQlScalarSchemaGenerator::generateScalarType)
.forEach(schema::additionalType);
}
private void generateAnyNodeUnion(StructureSchema graphDefinition, GraphQLSchema.Builder schema) {
var anyNodeUnion = new GraphQLUnionType.Builder()
.name(ANY_NODE)
.description("High level Union type of all types in this schema.")
.typeResolver(env -> null);
var concreteStructureDefinitions = graphDefinition.getStructureTypes().values()
.stream()
.filter(definition -> !(definition instanceof PrimitiveStructureType))
.filter(definition -> !definition.isAbstract())
.toList();
if (!concreteStructureDefinitions.isEmpty()) {
concreteStructureDefinitions.forEach(definition ->
anyNodeUnion.possibleType(
new GraphQLTypeReference(definition.getDefinitionType())
)
);
schema.additionalType(anyNodeUnion.build());
}
}
private void addResourceToQueryObjectAndCodeRegistry(
GraphQLObjectType.Builder builder,
GraphQLCodeRegistry.Builder codeRegistry,
String typeName,
Map<String, GraphQLInputObjectType> sortInputTypes,
Map<String, GraphQLInputObjectType> filterInputTypes
) {
var getFieldName = "get" + typeName;
var findFieldName = "find" + typeName + "List";
builder.field(
GraphQLFieldDefinition.newFieldDefinition()
.name(getFieldName)
.type(GraphQLNonNull.nonNull(new GraphQLTypeReference(typeName)))
.argument(
GraphQLArgument.newArgument()
.name("id")
.type(GraphQLNonNull.nonNull(Scalars.GraphQLString))
.build()
)
);
var filterFieldDefinitionBuilder = GraphQLFieldDefinition.newFieldDefinition()
.name(findFieldName)
.type(GraphQLNonNull.nonNull(
GraphQLList.list(
GraphQLNonNull.nonNull(
new GraphQLTypeReference(typeName)
)
)
)
);
var sortInputType = sortInputTypes.get(
this.graphQlSortInputGenerator.createSortInputTypeName(typeName)
);
var filterInputType = filterInputTypes.get(
this.graphQlFilterInputGenerator.createLogicalFilterInputTypeName(typeName)
);
if (sortInputType != null) {
filterFieldDefinitionBuilder.argument(
GraphQLArgument.newArgument()
.name("sort")
.type(GraphQLList.list(GraphQLNonNull.nonNull(sortInputType)))
);
}
if (filterInputType != null) {
filterFieldDefinitionBuilder.argument(
GraphQLArgument.newArgument()
.name("filter")
.type(GraphQLList.list(GraphQLNonNull.nonNull(filterInputType)))
);
}
filterFieldDefinitionBuilder.argument(
GraphQLArgument.newArgument()
.name("pagination")
.type(GraphQlJavaSchemaGenerator.OFFSET_PAGINATION)
);
builder.field(filterFieldDefinitionBuilder);
codeRegistry.dataFetcher(
FieldCoordinates.coordinates("Query", getFieldName),
this.graphLoaderGqlDataFetcher
);
codeRegistry.dataFetcher(
FieldCoordinates.coordinates("Query", findFieldName),
this.graphLoaderGqlDataFetcher
);
}
private void generateMutations(
List<ComplexStructureType> operationDefinitions,
StructureSchema graphDefinition,
GraphQLSchema.Builder schema,
GraphQLCodeRegistry.Builder codeRegistry
) {
if (operationDefinitions.isEmpty()) {
return;
}
var mutationObjectBuilder = GraphQLObjectType.newObject().name("Mutation");
operationDefinitions.stream()
.filter(
type -> !type.getAllFields().values().stream().allMatch(FieldDefinition::isUnionType))
.forEach(
structureType -> this.generateCommand(
graphDefinition,
structureType,
mutationObjectBuilder,
codeRegistry
)
);
schema.mutation(mutationObjectBuilder);
this.generateComplexInputTypes(graphDefinition, schema);
}
private void generateCommand(
StructureSchema graphDefinition,
ComplexStructureType structureType,
GraphQLObjectType.Builder mutationBuilder,
GraphQLCodeRegistry.Builder codeRegistry
) {
var commandPayloadName = this.createCommandPayloadName(structureType.getDefinitionType());
var commandPayloadInputBuilder = GraphQLInputObjectType.newInputObject()
.name(commandPayloadName)
.description(structureType.getDescription());
structureType.getAllFields().values().stream()
.filter(field -> !field.getName().equals("id"))
.forEach(field -> {
if (field.getTypes().isEmpty()) {
throw CannotGenerateGraphQLSchema.becauseOperationReferencedTypeWhichDoesNotExistInStructureSchema(
structureType.getDefinitionType(),
"Any"
);
}
if (field.getTypes().size() > 1) {
var fakeUnionTypeBuilder = GraphQLInputObjectType.newInputObject()
.name(commandPayloadName + StringUtils.capitalize(field.getName()))
.description(
"Generated input object which works as a union type, "
+ "only exactly one field should be specified."
);
field.getTypes().forEach(fieldType -> {
var type = fieldType.getType();
var fieldStructureType = graphDefinition.getDefinition(type);
if (fieldStructureType == null) {
throw CannotGenerateGraphQLSchema.becauseOperationReferencedTypeWhichDoesNotExistInStructureSchema(
structureType.getDefinitionType(),
type
);
}
GraphQLType graphQLInputType;
if (fieldStructureType instanceof PrimitiveStructureType) {
graphQLInputType = GraphQlObjectTypeGenerator.FIELD_TYPE_SPECIAL_CASES.getOrDefault(
type,
new GraphQLTypeReference(type)
);
} else if (fieldType.isReference()) {
graphQLInputType = Scalars.GraphQLID;
} else if (fieldStructureType instanceof BoxedPrimitiveStructureType) {
var unboxed = this.unbox(type);
graphQLInputType = GraphQlObjectTypeGenerator.FIELD_TYPE_SPECIAL_CASES.getOrDefault(
unboxed,
new GraphQLTypeReference(unboxed)
);
} else {
graphQLInputType = new GraphQLTypeReference(this.createInputTypeName(type));
}
fakeUnionTypeBuilder.field(
GraphQLInputObjectField.newInputObjectField()
.name(
fieldStructureType instanceof BoxedPrimitiveStructureType ?
this.unbox(type) :
type
).type((GraphQLInputType) graphQLInputType)
);
});
GraphQLInputType fakeUnionType = fakeUnionTypeBuilder.build();
if (field.getMax().equals("*") || Integer.parseInt(field.getMax()) > 1) {
fakeUnionType = GraphQLList.list(GraphQLNonNull.nonNull(fakeUnionType));
}
if (field.getMin() > 0) {
fakeUnionType = GraphQLNonNull.nonNull(fakeUnionType);
}
commandPayloadInputBuilder.field(
GraphQLInputObjectField
.newInputObjectField()
.name(field.getName())
.type(fakeUnionType)
.build()
);
return;
}
var type = field.getTypes().get(0).getType();
var fieldStructureType = graphDefinition.getDefinition(type);
if (fieldStructureType == null) {
throw CannotGenerateGraphQLSchema.becauseOperationReferencedTypeWhichDoesNotExistInStructureSchema(
structureType.getDefinitionType(),
type
);
}
GraphQLType graphQLInputType;
if (fieldStructureType instanceof PrimitiveStructureType) {
graphQLInputType = GraphQlObjectTypeGenerator.FIELD_TYPE_SPECIAL_CASES.getOrDefault(
type,
new GraphQLTypeReference(type)
);
} else if (fieldStructureType instanceof ResourceStructureType) {
graphQLInputType = Scalars.GraphQLID;
} else {
graphQLInputType = new GraphQLTypeReference(this.createInputTypeName(type));
}
if (field.getMax().equals("*") || Integer.parseInt(field.getMax()) > 1) {
graphQLInputType = GraphQLList.list(GraphQLNonNull.nonNull(graphQLInputType));
}
if (field.getMin() > 0) {
graphQLInputType = GraphQLNonNull.nonNull(graphQLInputType);
}
commandPayloadInputBuilder.field(
GraphQLInputObjectField
.newInputObjectField()
.name(field.getName())
.type((GraphQLInputType) graphQLInputType)
.build()
);
});
var mutationFieldName = StringUtils.uncapitalize(structureType.getDefinitionType());
mutationBuilder.field(
GraphQLFieldDefinition
.newFieldDefinition()
.name(mutationFieldName)
.argument(GraphQLArgument.newArgument().name("id").type(Scalars.GraphQLID))
.argument(this.createPayloadArgument(commandPayloadInputBuilder))
.type(MUTATION_RESPONSE)
.build()
);
codeRegistry.dataFetcher(
FieldCoordinates.coordinates("Mutation", mutationFieldName),
this.commandGqlDataFetcher
);
}
private void generateComplexInputTypes(
StructureSchema graphDefinition,
GraphQLSchema.Builder schema
) {
//The only structure definition of kind Resource we need as input, is a resource itself
if (graphDefinition.containsDefinition("Resource")) {
var resourceType = graphDefinition.getDefinition("Resource");
var inputType = this.createInputType((ComplexStructureType) resourceType);
schema.additionalType(inputType);
}
graphDefinition.getStructureTypes().values().stream()
.filter(ComplexStructureType.class::isInstance)
.filter(abstractStructureType -> !abstractStructureType.getKind()
.equals(ResourceStructureType.KIND))
.map(ComplexStructureType.class::cast)
.map(this::createInputType)
.forEach(schema::additionalType);
}
private GraphQLInputObjectType createInputType(ComplexStructureType complexStructureType) {
var inputTypeName = this.createInputTypeName(complexStructureType.getDefinitionType());
var inputTypeBuilder = GraphQLInputObjectType.newInputObject().name(inputTypeName);
complexStructureType.getAllFields().values().forEach(
field -> createInputTypeField(inputTypeBuilder, field, inputTypeName)
);
return inputTypeBuilder.build();
}
private void createInputTypeField(
GraphQLInputObjectType.Builder inputTypeBuilder,
FieldDefinition field,
String parentTypeName
) {
if (field.isAnyType()) {
return;
// throw CannotGenerateGraphQLSchema.becauseStructureSchemaFieldHadNoType(
// parentTypeName,
// field.getName()
// );
}
if (!field.isUnionType()) {
var type = field.getTypes().get(0);
var graphQLInputType = this.createInputFieldType(type);
inputTypeBuilder.field(
new GraphQLInputObjectField.Builder()
.name(field.getName())
.type(this.makeInputTypeRequiredAndListIfNeeded(field, graphQLInputType))
);
return;
}
var fakeUnionType = GraphQLInputObjectType.newInputObject()
.name(parentTypeName + StringUtils.capitalize(field.getName()))
.description(
"Generated Input Type, which works as a Union type. Only one field should be filled.");
field.getTypes().forEach(
type -> {
var graphQLInputType = this.createInputFieldType(type);
fakeUnionType.field(
new GraphQLInputObjectField.Builder()
.name(type.isBoxed() ? type.getOriginalType() : type.getType())
.type(graphQLInputType)
);
}
);
inputTypeBuilder.field(
new GraphQLInputObjectField.Builder()
.name(field.getName())
.type(this.makeInputTypeRequiredAndListIfNeeded(field, fakeUnionType.build()))
);
}
private GraphQLInputType createInputFieldType(FieldType type) {
if (type.isReference()) {
return Scalars.GraphQLID;
} else {
var typeString = type.isBoxed() ? type.getOriginalType() : type.getType();
if (type.isPrimitiveType() || type.isBoxed()) {
return (GraphQLInputType) GraphQlObjectTypeGenerator.FIELD_TYPE_SPECIAL_CASES.getOrDefault(
typeString,
new GraphQLTypeReference(typeString)
);
}
return new GraphQLTypeReference(this.createInputTypeName(typeString));
}
}
private GraphQLInputType makeInputTypeRequiredAndListIfNeeded(
FieldDefinition field,
GraphQLInputType graphQLInputType
) {
if (field.isList()) {
graphQLInputType = GraphQLList.list(GraphQLNonNull.nonNull(graphQLInputType));
}
if (field.isRequired()) {
graphQLInputType = GraphQLNonNull.nonNull(graphQLInputType);
}
return graphQLInputType;
}
private GraphQLArgument.Builder createPayloadArgument(
GraphQLInputObjectType.Builder inputBuilder) {
return GraphQLArgument
.newArgument()
.name("payload")
.type(GraphQLNonNull.nonNull(inputBuilder.build()));
}
@NotNull
private String createCommandPayloadName(String operationName) {
return operationName + "CommandPayloadInput";
}
private String createInputTypeName(String type) {
return type + "CommandInput";
}
@NotNull
private String unbox(String type) {
return StringUtils.uncapitalize(type.replace("Boxed", ""));
}
}
|
0 | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql/graphqlJava | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql/graphqlJava/graphQlSchemaGenerator/GraphQlObjectTypeGenerator.java | package ai.stapi.graphql.graphqlJava.graphQlSchemaGenerator;
import ai.stapi.schema.structureSchema.AbstractStructureType;
import ai.stapi.schema.structureSchema.ComplexStructureType;
import ai.stapi.schema.structureSchema.FieldDefinition;
import ai.stapi.schema.structureSchema.FieldType;
import ai.stapi.schema.structureSchema.PrimitiveStructureType;
import ai.stapi.schema.structureSchema.StructureSchema;
import graphql.Scalars;
import graphql.schema.GraphQLArgument;
import graphql.schema.GraphQLFieldDefinition;
import graphql.schema.GraphQLInputObjectType;
import graphql.schema.GraphQLInterfaceType;
import graphql.schema.GraphQLList;
import graphql.schema.GraphQLNonNull;
import graphql.schema.GraphQLObjectType;
import graphql.schema.GraphQLOutputType;
import graphql.schema.GraphQLScalarType;
import graphql.schema.GraphQLType;
import graphql.schema.GraphQLTypeReference;
import graphql.schema.GraphQLUnionType;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.apache.commons.lang3.StringUtils;
public class GraphQlObjectTypeGenerator {
/*
FHIR has concept of any type. As defined at http://hl7.org/fhir/datatypes.html#open :
'Some elements do not have a specified type. The type is represented by the wildcard symbol "*".'
In Structure Definition this is defined as list of all 50 possible types. (as of current date 30.Nov.2022)
Therefore there is arbitrary count of types above which we interpret the type as '*'
*/
public static final Integer THE_ANSWER_TO_THE_ULTIMATE_QUESTION_OF_LIFE_THE_UNIVERSE_AND_EVERYTHING = 42;
protected static final Map<String, GraphQLType> FIELD_TYPE_SPECIAL_CASES = Map.of(
"string", Scalars.GraphQLString,
"boolean", Scalars.GraphQLBoolean,
"id", Scalars.GraphQLID,
"integer", Scalars.GraphQLInt,
"decimal", Scalars.GraphQLFloat
);
private final GraphQlSortInputGenerator graphQLSortInputGenerator;
private final GraphQlFilterInputGenerator graphQlFilterInputGenerator;
public GraphQlObjectTypeGenerator(
GraphQlSortInputGenerator graphQLSortInputGenerator,
GraphQlFilterInputGenerator graphQlFilterInputGenerator
) {
this.graphQLSortInputGenerator = graphQLSortInputGenerator;
this.graphQlFilterInputGenerator = graphQlFilterInputGenerator;
}
protected List<GraphQLType> generateObjectType(
AbstractStructureType structureType,
StructureSchema structureSchema,
Map<String, GraphQLInputObjectType> sortInputTypes,
Map<String, GraphQLInputObjectType> filterInputTypes
) {
var fieldsInterfacesAndSubTypes = this.createFieldsInterfacesAndSubTypes(
structureType,
structureSchema,
sortInputTypes,
filterInputTypes
);
var name = structureType.getDefinitionType();
if (structureType.isAbstract()) {
var builder = new GraphQLInterfaceType.Builder()
.name(name)
.description(
structureType.getDescription()
.replace("\r", "")
.replace("\n+", "\n")
).typeResolver(env -> null);
fieldsInterfacesAndSubTypes.fields().forEach(builder::field);
fieldsInterfacesAndSubTypes.interfaces()
.forEach(interfaceType -> builder.withInterface((GraphQLTypeReference) interfaceType));
var finalTypes = new ArrayList<GraphQLType>();
finalTypes.add(builder.build());
finalTypes.addAll(fieldsInterfacesAndSubTypes.subtypes);
return finalTypes;
} else {
var builder = new GraphQLObjectType.Builder()
.name(name)
.description(structureType.getDescription());
fieldsInterfacesAndSubTypes.fields().forEach(builder::field);
fieldsInterfacesAndSubTypes.interfaces()
.forEach(interfaceType -> builder.withInterface((GraphQLTypeReference) interfaceType));
var finalTypes = new ArrayList<GraphQLType>();
finalTypes.add(builder.build());
finalTypes.addAll(fieldsInterfacesAndSubTypes.subtypes);
return finalTypes;
}
}
protected GraphQlObjectTypeGenerator.FieldsInterfacesSubtypes createFieldsInterfacesAndSubTypes(
AbstractStructureType structureType,
StructureSchema structureSchema,
Map<String, GraphQLInputObjectType> sortInputTypes,
Map<String, GraphQLInputObjectType> filterInputTypes
) {
var graphQlFields = new ArrayList<GraphQLFieldDefinition.Builder>();
var interfaces = this.createInterfaces(
structureType,
structureSchema
);
var subtypes = new ArrayList<GraphQLType>();
Map<String, FieldDefinition> fields = new HashMap<>();
if (structureType instanceof ComplexStructureType complexStructureType) {
fields = complexStructureType.getAllFields();
}
fields.values().forEach(
definition -> {
var fieldAndSubtypes = this.createFieldAndSubtypes(
definition,
structureType,
structureSchema,
sortInputTypes,
filterInputTypes
);
graphQlFields.add(fieldAndSubtypes.field());
subtypes.addAll(fieldAndSubtypes.subtypes());
}
);
return new GraphQlObjectTypeGenerator.FieldsInterfacesSubtypes(graphQlFields, interfaces,
subtypes);
}
private List<GraphQLType> createInterfaces(
AbstractStructureType structureType,
StructureSchema structureSchema
) {
var interfaces = new ArrayList<GraphQLType>();
if (structureType instanceof ComplexStructureType complexStructureType
&& !complexStructureType.getParent().isBlank()) {
var parentStructureType = structureSchema.getDefinition(complexStructureType.getParent());
if (parentStructureType.isAbstract()) {
interfaces.add(new GraphQLTypeReference(parentStructureType.getDefinitionType()));
}
var restOfInterfaces = this.createInterfaces(parentStructureType, structureSchema);
interfaces.addAll(restOfInterfaces);
}
return interfaces;
}
private GraphQlObjectTypeGenerator.FieldAndSubtypes createFieldAndSubtypes(
FieldDefinition fieldDefinition,
AbstractStructureType structureType,
StructureSchema structureSchema,
Map<String, GraphQLInputObjectType> sortInputTypes,
Map<String, GraphQLInputObjectType> filterInputTypes
) {
var types = fieldDefinition.getTypes().stream()
.map(FieldType::getType)
.toList();
GraphQLType type;
String typeName;
var subtypes = new ArrayList<GraphQLType>();
//TODO: Change to this when we solve content reference in StructureDefinition to StructureSchema mapping
// if (types.size() == 0) {
// throw CannotGenerateGraphQLSchema.becauseStructureSchemaFieldHadNoType(
// structureType.getDefinitionType(),
// FieldDefinition.getName()
// );
// }
if (types.isEmpty()
|| types.size() > THE_ANSWER_TO_THE_ULTIMATE_QUESTION_OF_LIFE_THE_UNIVERSE_AND_EVERYTHING) {
type = new GraphQLTypeReference(GraphQlJavaSchemaGenerator.ANY_NODE);
typeName = GraphQlJavaSchemaGenerator.ANY_NODE;
} else if (types.size() == 1) {
typeName = types.get(0);
type = GraphQlObjectTypeGenerator.FIELD_TYPE_SPECIAL_CASES.getOrDefault(
typeName,
new GraphQLTypeReference(typeName)
);
} else {
typeName =
structureType.getDefinitionType() + StringUtils.capitalize(fieldDefinition.getName());
type = new GraphQLTypeReference(typeName);
var unionTypeBuilder = new GraphQLUnionType.Builder()
.name(typeName)
.description(
"Type for union type field contained in " + structureType.getDefinitionType())
.typeResolver(env -> null);
var allObjectTypes = this.getAllConcreteTypes(types, structureSchema);
allObjectTypes.forEach(
typeInUnion -> unionTypeBuilder.possibleType(new GraphQLTypeReference(typeInUnion)));
subtypes.add(unionTypeBuilder.build());
}
var typeStructureDefinition = structureSchema.getDefinition(typeName);
if (type instanceof GraphQLScalarType
|| typeStructureDefinition instanceof PrimitiveStructureType) {
return new GraphQlObjectTypeGenerator.FieldAndSubtypes(
this.createField(
fieldDefinition,
fieldDefinition.getName(),
type,
typeName,
sortInputTypes,
filterInputTypes,
true
),
subtypes
);
}
return new GraphQlObjectTypeGenerator.FieldAndSubtypes(
this.createField(
fieldDefinition,
fieldDefinition.getName(),
type,
typeName,
sortInputTypes,
filterInputTypes,
false
),
subtypes
);
}
private List<String> getAllConcreteTypes(List<String> types, StructureSchema structureSchema) {
return types.stream()
.map(type -> this.getConcreteTypes(type, structureSchema))
.flatMap(List::stream)
.collect(Collectors.toSet())
.stream().toList();
}
private List<String> getConcreteTypes(String type, StructureSchema structureSchema) {
var structureType = structureSchema.getDefinition(type);
if (!structureType.isAbstract()) {
return List.of(type);
} else {
var children = structureSchema.getChildDefinitions(type);
var childTypes = children.stream().map(AbstractStructureType::getDefinitionType).toList();
return this.getAllConcreteTypes(childTypes, structureSchema);
}
}
private GraphQLFieldDefinition.Builder createField(
FieldDefinition fieldDefinition,
String fieldName,
GraphQLType graphQLType,
String typeName,
Map<String, GraphQLInputObjectType> sortInputTypes,
Map<String, GraphQLInputObjectType> filterInputTypes,
boolean isScalar
) {
if (fieldDefinition.getMax().equals("*") || Integer.parseInt(fieldDefinition.getMax()) > 1) {
graphQLType = GraphQLNonNull.nonNull(
GraphQLList.list(
GraphQLNonNull.nonNull(graphQLType)
)
);
} else if (fieldDefinition.getMin() == 1) {
graphQLType = GraphQLNonNull.nonNull(graphQLType);
}
var elementBuilder = GraphQLFieldDefinition.newFieldDefinition()
.name(fieldName)
.type((GraphQLOutputType) graphQLType);
if (!fieldDefinition.getMax().equals("1")) {
var sortInputType =
sortInputTypes.get(this.graphQLSortInputGenerator.createSortInputTypeName(typeName));
var filterInputType = filterInputTypes.get(
this.graphQlFilterInputGenerator.createLogicalFilterInputTypeName(typeName));
if (sortInputType != null) {
elementBuilder.argument(
GraphQLArgument.newArgument()
.name("sort")
.type(GraphQLList.list(GraphQLNonNull.nonNull(sortInputType)))
);
}
if (filterInputType != null) {
elementBuilder.argument(
GraphQLArgument.newArgument()
.name("filter")
.type(GraphQLList.list(GraphQLNonNull.nonNull(filterInputType)))
);
}
if (!isScalar) {
elementBuilder.argument(
GraphQLArgument.newArgument()
.name("pagination")
.type(GraphQlJavaSchemaGenerator.OFFSET_PAGINATION)
);
}
}
if (fieldDefinition.getDescription() != null) {
elementBuilder.description(
fieldDefinition.getDescription()
.replace("\r", "")
.replace("\n+", "\n")
);
}
return elementBuilder;
}
protected record FieldsInterfacesSubtypes(
List<GraphQLFieldDefinition.Builder> fields,
List<GraphQLType> interfaces,
List<GraphQLType> subtypes
) {
}
private record FieldAndSubtypes(
GraphQLFieldDefinition.Builder field,
List<GraphQLType> subtypes
) {
}
}
|
0 | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql/graphqlJava | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql/graphqlJava/graphQlSchemaGenerator/GraphQlScalarSchemaGenerator.java | package ai.stapi.graphql.graphqlJava.graphQlSchemaGenerator;
import ai.stapi.schema.structureSchema.PrimitiveStructureType;
import graphql.schema.Coercing;
import graphql.schema.CoercingParseLiteralException;
import graphql.schema.CoercingParseValueException;
import graphql.schema.CoercingSerializeException;
import graphql.schema.GraphQLScalarType;
import org.jetbrains.annotations.NotNull;
public class GraphQlScalarSchemaGenerator {
public GraphQLScalarType generateScalarType(PrimitiveStructureType primitiveStructureType) {
return new GraphQLScalarType.Builder()
.name(primitiveStructureType.getDefinitionType())
.description(primitiveStructureType.getDescription())
.coercing(new Coercing<>() {
@Override
public Object serialize(@NotNull Object dataFetcherResult)
throws CoercingSerializeException {
return dataFetcherResult;
}
@Override
public @NotNull Object parseValue(@NotNull Object input)
throws CoercingParseValueException {
return input;
}
@Override
public @NotNull Object parseLiteral(@NotNull Object input)
throws CoercingParseLiteralException {
return input;
}
})
.build();
}
}
|
0 | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql/graphqlJava | java-sources/ai/stapi/graphql-api/0.2.3/ai/stapi/graphql/graphqlJava/graphQlSchemaGenerator/GraphQlSortInputGenerator.java | package ai.stapi.graphql.graphqlJava.graphQlSchemaGenerator;
import ai.stapi.schema.structureSchema.AbstractStructureType;
import ai.stapi.schema.structureSchema.ComplexStructureType;
import ai.stapi.schema.structureSchema.FieldDefinition;
import ai.stapi.schema.structureSchema.FieldType;
import ai.stapi.schema.structureSchema.StructureSchema;
import graphql.schema.GraphQLEnumType;
import graphql.schema.GraphQLInputObjectField;
import graphql.schema.GraphQLInputObjectType;
import graphql.schema.GraphQLTypeReference;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.jetbrains.annotations.Nullable;
public class GraphQlSortInputGenerator {
protected static final GraphQLEnumType SORT_DIRECTION_ENUM = GraphQLEnumType.newEnum()
.name("SortDirection")
.value("ASC")
.value("DESC")
.build();
public Map<String, GraphQLInputObjectType> generateSortInputs(StructureSchema structureSchema) {
var sortInputTypeMap = new HashMap<String, GraphQLInputObjectType>();
structureSchema.getStructureTypes().values().stream()
.filter(ComplexStructureType.class::isInstance)
.map(ComplexStructureType.class::cast)
.flatMap(definition -> this.generate(
definition,
structureSchema
).stream())
.forEach(sortInput -> sortInputTypeMap.put(sortInput.getName(), sortInput));
return sortInputTypeMap;
}
private List<GraphQLInputObjectType> generate(
ComplexStructureType structureType,
StructureSchema structureSchema
) {
var fieldsAndSubTypes = this.createFieldsAndSubTypes(
structureType,
structureSchema
);
var name = structureType.getDefinitionType();
var types = new ArrayList<GraphQLInputObjectType>();
var builder = new GraphQLInputObjectType.Builder().name(this.createSortInputTypeName(name));
fieldsAndSubTypes.fields().forEach(builder::field);
if (!fieldsAndSubTypes.fields().isEmpty()) {
types.add(builder.build());
}
types.addAll(fieldsAndSubTypes.subtypes());
return types;
}
private GraphQlSortInputGenerator.SortFieldsAndSubtypes createFieldsAndSubTypes(
ComplexStructureType structureType,
StructureSchema structureSchema
) {
var fields = new ArrayList<GraphQLInputObjectField>();
var subtypes = new ArrayList<GraphQLInputObjectType>();
structureType.getAllFields().values().forEach(
fieldDefinition -> {
var fieldAndSubtypes = this.createFieldAndSubtypes(
fieldDefinition,
structureSchema
);
if (fieldAndSubtypes != null) {
fields.add(fieldAndSubtypes.field());
subtypes.addAll(fieldAndSubtypes.subtypes());
}
}
);
return new GraphQlSortInputGenerator.SortFieldsAndSubtypes(fields, subtypes);
}
@Nullable
private GraphQlSortInputGenerator.SortFieldAndSubtypes createFieldAndSubtypes(
FieldDefinition fieldDefinition,
StructureSchema structureSchema
) {
var types = fieldDefinition.getTypes().stream()
.map(FieldType::getType)
.toList();
var subtypes = new ArrayList<GraphQLInputObjectType>();
if (types.isEmpty()) {
return new GraphQlSortInputGenerator.SortFieldAndSubtypes(
GraphQLInputObjectField.newInputObjectField()
.name(fieldDefinition.getName())
.type(SORT_DIRECTION_ENUM).build(),
subtypes
);
}
var size = types.size();
if (size > GraphQlObjectTypeGenerator.THE_ANSWER_TO_THE_ULTIMATE_QUESTION_OF_LIFE_THE_UNIVERSE_AND_EVERYTHING) {
return new GraphQlSortInputGenerator.SortFieldAndSubtypes(
GraphQLInputObjectField.newInputObjectField()
.name(fieldDefinition.getName())
.type(SORT_DIRECTION_ENUM).build(),
subtypes
);
}
var typeGraphDefinitions = types.stream()
.map(type -> {
var definition = structureSchema.getDefinition(type);
if (definition == null) {
throw new RuntimeException(
"Definition for type '" + type + "' does not exist in schema."
);
}
return definition;
})
.toList();
if (typeGraphDefinitions.stream().allMatch(
definition -> definition.getKind().equals(AbstractStructureType.PRIMITIVE_TYPE))) {
return new GraphQlSortInputGenerator.SortFieldAndSubtypes(
GraphQLInputObjectField.newInputObjectField()
.name(fieldDefinition.getName())
.type(SORT_DIRECTION_ENUM).build(),
subtypes
);
}
if (size > 1) {
return null;
}
var typeName = types.get(0);
return new GraphQlSortInputGenerator.SortFieldAndSubtypes(
GraphQLInputObjectField.newInputObjectField()
.name(fieldDefinition.getName())
.type(new GraphQLTypeReference(this.createSortInputTypeName(typeName)))
.build(),
subtypes
);
}
public String createSortInputTypeName(String originalTypeName) {
return originalTypeName + "SortOption";
}
protected record SortFieldsAndSubtypes(
List<GraphQLInputObjectField> fields,
List<GraphQLInputObjectType> subtypes
) {
}
protected record SortFieldAndSubtypes(
GraphQLInputObjectField field,
List<GraphQLInputObjectType> subtypes
) {
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/adHocLoaders/AbstractFileModelDefinitionsLoader.java | package ai.stapi.schema.adHocLoaders;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import java.io.IOException;
import java.io.InputStream;
import java.util.Comparator;
import java.util.List;
import org.apache.commons.io.IOUtils;
import org.springframework.core.io.Resource;
public abstract class AbstractFileModelDefinitionsLoader
implements SpecificAdHocModelDefinitionsLoader {
protected final String scope;
protected final String tag;
private final ObjectMapper objectMapper = new ObjectMapper()
.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS)
.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
private FileLoader fileLoader;
protected AbstractFileModelDefinitionsLoader(
FileLoader fileLoader,
String scope,
String tag
) {
this.fileLoader = fileLoader;
this.scope = scope;
this.tag = tag;
}
@Override
public <T> List<T> load(String serializationType, Class<T> returnClass) {
var resources = this.fileLoader.loadFixtureFiles(
this.getClass(),
serializationType
);
return resources.stream()
.sorted(Comparator.comparing(Resource::getFilename))
.map(resource -> this.deserializeJsonFile(resource, returnClass))
.toList();
}
private <R> R deserializeJsonFile(
Resource resource,
Class<R> returnClass
) {
byte[] content;
try {
InputStream input = resource.getInputStream();
content = IOUtils.toByteArray(input);
} catch (IOException exception) {
try {
throw new RuntimeException(
String.format(
"Unable to read resource file of URI %s",
resource.getURI()
),
exception
);
} catch (IOException ex) {
throw new RuntimeException(
"Unable to read resource file and not even its URI.",
exception
);
}
}
var info = FileLoader.getFixtureFileInfo(resource);
if (info == null) {
throw new RuntimeException("Please put fixture file in folder named by right command.");
}
try {
return objectMapper.readValue(content, returnClass);
} catch (IOException e) {
throw new RuntimeException(
"Failed while deserializing '" + info.getFullName() + "'.",
e
);
}
}
@Override
public String getScope() {
return scope;
}
@Override
public String getTag() {
return tag;
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/adHocLoaders/AbstractJavaModelDefinitionsLoader.java | package ai.stapi.schema.adHocLoaders;
import java.util.List;
public abstract class AbstractJavaModelDefinitionsLoader<T>
implements SpecificAdHocModelDefinitionsLoader {
protected final String scope;
protected final String tag;
protected final String serializationType;
protected AbstractJavaModelDefinitionsLoader(
String scope,
String tag,
String serializationType
) {
this.scope = scope;
this.tag = tag;
this.serializationType = serializationType;
}
protected abstract List<T> load();
@Override
public <R> List<R> load(String serializationType, Class<R> returnClass) {
if (!this.getSerializationType().equals(serializationType)) {
return List.of();
}
var loaded = this.load();
return loaded.stream()
.filter(loadedItem -> loadedItem.getClass().equals(returnClass))
.map(returnClass::cast)
.toList();
}
@Override
public String getScope() {
return scope;
}
@Override
public String getTag() {
return tag;
}
public String getSerializationType() {
return serializationType;
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/adHocLoaders/FileLoader.java | package ai.stapi.schema.adHocLoaders;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import org.jetbrains.annotations.Nullable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
public class FileLoader {
private final Logger logger;
public FileLoader() {
this.logger = LoggerFactory.getLogger(FileLoader.class);
}
@Nullable
public static FixtureFileInfo getFixtureFileInfo(Resource resource) {
String fileURI;
try {
fileURI = resource.getURI().toString();
} catch (IOException e) {
throw new RuntimeException(e);
}
String[] parts = fileURI.split("/");
if (parts.length < 2) {
return null;
}
String lastFolderName = parts[parts.length - 2];
String filename = lastFolderName + File.separator + parts[parts.length - 1];
return new FixtureFileInfo(filename, lastFolderName);
}
public List<Resource> loadFixtureFiles(Class<?> rootClass) {
return this.loadFixtureFiles(rootClass, Set.of());
}
public List<Resource> loadFixtureFiles(Class<?> rootClass, String lastFolderName) {
return this.loadFixtureFiles(rootClass, Set.of(), "json", lastFolderName);
}
public List<Resource> loadFixtureFiles(Class<?> rootClass, Set<String> processedFileNames) {
return this.loadFixtureFiles(rootClass, processedFileNames, "json", null);
}
private List<Resource> loadFixtureFiles(
Class<?> rootClass,
Set<String> processedFileNames,
String fileAppendix,
@Nullable String lastFolderName
) {
String relativePath = this.getRelativePath(rootClass);
// logger.info("Relative path full: " + this.getRelativePath(rootClass));
var resolver = new PathMatchingResourcePatternResolver(rootClass.getClassLoader());
Resource[] resources;
if (fileAppendix.startsWith(".")) {
fileAppendix = fileAppendix.substring(1);
}
String resourceLocation = String.format(
"classpath*:%s/**/*." + fileAppendix,
relativePath
);
// logger.info("Resource location: " + resourceLocation);
try {
resources = resolver.getResources(
resourceLocation
);
} catch (IOException e) {
this.logger.warn("Error at " + resourceLocation);
throw new RuntimeException(
String.format(
"Unable to reaf fixture files.\n"
+ "Relative Path: %s\n"
+ "Original error: %s",
relativePath,
e
)
);
}
Set<String> currentlyLoadedFixtureFiles = ConcurrentHashMap.newKeySet();
// logger.info("Resource classpath resolved to list of resources - " + resourceLocation);
return Arrays.stream(resources)
.filter(resource -> {
var fileInfo = getFixtureFileInfo(resource);
if (fileInfo == null) {
return false;
}
// logger.info(String.format(
// "Loading filename: %s\nIn path: %s",
// filename,
// resourceLocation
// ));
if (lastFolderName != null && !fileInfo.getLastFolderName().equals(lastFolderName)) {
return false;
}
var wasAlreadyProcessed = processedFileNames.contains(fileInfo.getFullName());
var wasCurrentlyLoaded = currentlyLoadedFixtureFiles.contains(
fileInfo.getFullName()
);
if (!wasAlreadyProcessed && !wasCurrentlyLoaded) {
currentlyLoadedFixtureFiles.add(fileInfo.getFullName());
}
return !wasAlreadyProcessed && !wasCurrentlyLoaded;
}
).toList();
}
private String getRelativePath(Class<?> rootClass) {
var relativeCanonicalPart = rootClass.getCanonicalName();
var partsOfRelativePart = relativeCanonicalPart.split("\\.");
return String.join(
File.separator,
Arrays.copyOfRange(
relativeCanonicalPart.split("\\."),
0,
partsOfRelativePart.length - 1
)
);
}
public static class FixtureFileInfo {
private final String fullName;
private final String lastFolderName;
public FixtureFileInfo(String fullName, String lastFolderName) {
this.fullName = fullName;
this.lastFolderName = lastFolderName;
}
public String getFullName() {
return fullName;
}
public String getLastFolderName() {
return lastFolderName;
}
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/adHocLoaders/GenericAdHocModelDefinitionsLoader.java | package ai.stapi.schema.adHocLoaders;
import ai.stapi.schema.scopeProvider.ScopeOptions;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class GenericAdHocModelDefinitionsLoader {
private List<SpecificAdHocModelDefinitionsLoader> specificAdHocModelDefinitionsLoaders;
public GenericAdHocModelDefinitionsLoader(
List<SpecificAdHocModelDefinitionsLoader> specificAdHocModelDefinitionsLoaders
) {
this.specificAdHocModelDefinitionsLoaders = specificAdHocModelDefinitionsLoaders;
}
public List<HashMap> load(
ScopeOptions scopeOptions,
String serializationType
) {
return this.load(
scopeOptions,
serializationType,
HashMap.class
);
}
public <T> List<T> load(
ScopeOptions scopeOptions,
String serializationType,
Class<T> returnClass
) {
var list = new ArrayList<T>();
specificAdHocModelDefinitionsLoaders.stream().filter(scopedStructureDefinitionLoader ->
scopeOptions.getTags().contains(scopedStructureDefinitionLoader.getTag())
&& scopeOptions.getScopes().contains(scopedStructureDefinitionLoader.getScope())
).forEach(
scopedStructureDefinitionLoader -> list.addAll(scopedStructureDefinitionLoader.load(
serializationType,
returnClass
))
);
return list;
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/adHocLoaders/SpecificAdHocModelDefinitionsLoader.java | package ai.stapi.schema.adHocLoaders;
import java.util.HashMap;
import java.util.List;
public interface SpecificAdHocModelDefinitionsLoader {
// Scope stands for the slice of application (module, package, class) that is responsible for the structure definition.
String getScope();
// Tag stands for the layer of application (domain, test) that is responsible for the structure definition.
String getTag();
default List<HashMap> load(String serializationType) {
return this.load(serializationType, HashMap.class);
}
<T> List<T> load(String serializationType, Class<T> returnClass);
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/configuration/AdHocLoaderConfiguration.java | package ai.stapi.schema.configuration;
import ai.stapi.schema.adHocLoaders.FileLoader;
import ai.stapi.schema.adHocLoaders.GenericAdHocModelDefinitionsLoader;
import ai.stapi.schema.adHocLoaders.SpecificAdHocModelDefinitionsLoader;
import ai.stapi.schema.scopeProvider.ScopeCacher;
import ai.stapi.schema.structuredefinition.loader.AdHocStructureDefinitionLoader;
import ai.stapi.schema.structuredefinition.loader.StructureDefinitionLoader;
import java.util.List;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
@AutoConfiguration
public class AdHocLoaderConfiguration {
@Bean
public FileLoader fileLoader() {
return new FileLoader();
}
@Bean
public GenericAdHocModelDefinitionsLoader genericAdHocModelDefinitionsLoader(
List<SpecificAdHocModelDefinitionsLoader> specificAdHocModelDefinitionsLoaders
) {
return new GenericAdHocModelDefinitionsLoader(specificAdHocModelDefinitionsLoaders);
}
@Bean
@ConditionalOnMissingBean(StructureDefinitionLoader.class)
public AdHocStructureDefinitionLoader adHocStructureDefinitionLoader(
GenericAdHocModelDefinitionsLoader genericAdHocModelDefinitionsLoader,
ScopeCacher scopeCacher
) {
return new AdHocStructureDefinitionLoader(genericAdHocModelDefinitionsLoader, scopeCacher);
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/configuration/ScopeProviderConfiguration.java | package ai.stapi.schema.configuration;
import ai.stapi.schema.scopeProvider.ScopeCacher;
import ai.stapi.schema.scopeProvider.ScopeOptions;
import ai.stapi.schema.scopeProvider.ScopeProvider;
import ai.stapi.schema.scopeProvider.SpringScopeProvider;
import java.util.List;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
@AutoConfiguration
public class ScopeProviderConfiguration {
@Bean
@ConditionalOnMissingBean
public ScopeProvider springScopeProvider(List<ScopeOptions> scopeOptions) {
return new SpringScopeProvider(scopeOptions);
}
@Bean
public ScopeCacher scopeCacher(ScopeProvider scopeProvider) {
return new ScopeCacher(scopeProvider);
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/configuration/StructureSchemaConfiguration.java | package ai.stapi.schema.configuration;
import ai.stapi.schema.scopeProvider.ScopeCacher;
import ai.stapi.schema.structureSchemaMapper.StructureDefinitionToSSMapper;
import ai.stapi.schema.structureSchemaProvider.DefaultStructureSchemaFinder;
import ai.stapi.schema.structureSchemaProvider.DefaultStructureSchemaProvider;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaProvider;
import ai.stapi.schema.structuredefinition.loader.StructureDefinitionLoader;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
@AutoConfiguration
public class StructureSchemaConfiguration {
@Bean
public StructureDefinitionToSSMapper structureDefinitionToSSMapper() {
return new StructureDefinitionToSSMapper();
}
@Bean
@ConditionalOnMissingBean
public StructureSchemaProvider defaultStructureSchemaProvider(
StructureDefinitionToSSMapper structureDefinitionToSSMapper,
StructureDefinitionLoader structureDefinitionLoader,
ScopeCacher scopeCacher
) {
return new DefaultStructureSchemaProvider(
structureDefinitionToSSMapper,
structureDefinitionLoader,
scopeCacher
);
}
@Bean
@ConditionalOnMissingBean
public StructureSchemaFinder defaultStructureSchemaFinder(
StructureSchemaProvider structureSchemaProvider
) {
return new DefaultStructureSchemaFinder(structureSchemaProvider);
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/scopeProvider/ScopeCacher.java | package ai.stapi.schema.scopeProvider;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class ScopeCacher {
private final ScopeProvider scopeProvider;
private final Map<ScopeOptions, Map<Class<?>, Object>> cache;
public ScopeCacher(ScopeProvider scopeProvider) {
this.scopeProvider = scopeProvider;
this.cache = new ConcurrentHashMap<>();
}
public void cache(Class<?> consumerClass, Object cachedData) {
var currentScope = this.scopeProvider.provide();
var scoped = this.getCurrentScopeCache(currentScope);
scoped.put(consumerClass, cachedData);
}
public boolean hasCached(Class<?> consumerClass) {
var currentScope = this.scopeProvider.provide();
var scoped = this.getCurrentScopeCache(currentScope);
return scoped.containsKey(consumerClass);
}
public <T> T getCachedOrCompute(
Class<?> consumerClass,
ComputeFunction<T> computeFunction
) {
var currentScope = this.scopeProvider.provide();
var scoped = this.getCurrentScopeCache(currentScope);
var current = (T) scoped.get(consumerClass);
if (current != null) {
return current;
}
var computed = computeFunction.compute(currentScope);
scoped.put(consumerClass, computed);
return computed;
}
@Nullable
public <T> T getCached(Class<?> consumerClass) {
var currentScope = this.scopeProvider.provide();
var scoped = this.getCurrentScopeCache(currentScope);
return (T) scoped.get(consumerClass);
}
public <T> T recompute(
Class<?> consumerClass,
T initialValue,
RecomputeWithInitialValueFunction<T> computeFunction
) {
var currentScope = this.scopeProvider.provide();
var scoped = this.getCurrentScopeCache(currentScope);
var previous = (T) scoped.get(consumerClass);
var newCache = computeFunction.compute(
currentScope,
previous == null ? initialValue : previous
);
scoped.put(consumerClass, newCache);
return newCache;
}
public <T> T recompute(
Class<?> consumerClass,
RecomputeFunction<T> computeFunction
) {
var currentScope = this.scopeProvider.provide();
var scoped = this.getCurrentScopeCache(currentScope);
var previous = (T) scoped.get(consumerClass);
var newCache = computeFunction.compute(
currentScope,
previous == null ? Optional.empty() : Optional.of(previous)
);
scoped.put(consumerClass, newCache);
return newCache;
}
@NotNull
private Map<Class<?>, Object> getCurrentScopeCache(ScopeOptions currentScope) {
return this.cache.computeIfAbsent(
currentScope,
key -> new ConcurrentHashMap<>()
);
}
public interface ComputeFunction<T> {
T compute(ScopeOptions scopeOptions);
}
public interface RecomputeFunction<T> {
T compute(ScopeOptions scopeOptions, Optional<T> previous);
}
public interface RecomputeWithInitialValueFunction<T> {
T compute(ScopeOptions scopeOptions, T previous);
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/scopeProvider/ScopeOptions.java | package ai.stapi.schema.scopeProvider;
import java.util.HashSet;
import java.util.List;
public class ScopeOptions {
public static final String DOMAIN_TAG = "domain";
public static final String TEST_TAG = "test";
private List<String> scopes;
private List<String> tags;
public ScopeOptions() {
this.scopes = List.of();
this.tags = List.of();
}
public ScopeOptions(List<String> scopes, List<String> tags) {
this.scopes = scopes;
this.tags = tags;
}
public ScopeOptions(String scope, String tag) {
this.scopes = List.of(scope);
this.tags = List.of(tag);
}
public ScopeOptions with(ScopeOptions scopeOptions) {
var newScopes = new HashSet<>(this.scopes);
newScopes.addAll(scopeOptions.getScopes());
var newTags = new HashSet<>(this.tags);
newTags.addAll(scopeOptions.getTags());
return new ScopeOptions(
newScopes.stream().toList(),
newTags.stream().toList()
);
}
public List<String> getScopes() {
return scopes;
}
public List<String> getTags() {
return tags;
}
public String getStringHash() {
return scopes.toString() + tags.toString();
}
public String toReadableString() {
return "ScopeOptions{" +
"scopes=" + scopes +
", tags=" + tags +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
ScopeOptions that = (ScopeOptions) o;
if (scopes != null ? !scopes.equals(that.scopes) : that.scopes != null) {
return false;
}
return tags != null ? tags.equals(that.tags) : that.tags == null;
}
@Override
public int hashCode() {
int result = scopes != null ? scopes.hashCode() : 0;
result = 31 * result + (tags != null ? tags.hashCode() : 0);
return result;
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/scopeProvider/ScopeProvider.java | package ai.stapi.schema.scopeProvider;
public interface ScopeProvider {
ScopeOptions provide();
void set(ScopeOptions scopeOptions);
default void set(String scope, String tag) {
this.set(new ScopeOptions(scope, tag));
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/scopeProvider/SpringScopeProvider.java | package ai.stapi.schema.scopeProvider;
import java.util.List;
public class SpringScopeProvider implements ScopeProvider {
private ScopeOptions scopeOptions;
public SpringScopeProvider(List<ScopeOptions> autowiredScopes) {
this.scopeOptions = autowiredScopes.stream()
.reduce(ScopeOptions::with)
.orElse(new ScopeOptions());
}
@Override
public ScopeOptions provide() {
return this.scopeOptions;
}
@Override
public void set(ScopeOptions scopeOptions) {
this.scopeOptions = scopeOptions;
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema/AbstractStructureType.java | package ai.stapi.schema.structureSchema;
import ai.stapi.serialization.AbstractSerializableObject;
public abstract class AbstractStructureType extends AbstractSerializableObject {
public static final String COMPLEX_TYPE = "complex-type";
public static final String PRIMITIVE_TYPE = "primitive-type";
public static final String RESOURCE = "resource";
protected String description;
protected String kind;
protected String definitionType;
protected boolean isAbstract;
protected String parent;
protected AbstractStructureType() {
super();
}
public AbstractStructureType(
String structureTypeSerializationType,
String kind,
String definitionType,
String description,
boolean isAbstract,
String parent
) {
super(structureTypeSerializationType);
this.kind = kind;
this.definitionType = definitionType;
this.description = description;
this.isAbstract = isAbstract;
this.parent = parent == null ? "" : parent;
}
public static boolean isComplexTypeOrResource(String kind) {
return kind.equals(RESOURCE) || kind.equals(COMPLEX_TYPE);
}
public static boolean isPrimitiveType(String kind) {
return kind.equals(PRIMITIVE_TYPE);
}
public String getKind() {
return kind;
}
public String getDefinitionType() {
return definitionType;
}
public String getDescription() {
return description;
}
public boolean isAbstract() {
return isAbstract;
}
public String getParent() {
return parent;
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema/BoxedPrimitiveStructureType.java | package ai.stapi.schema.structureSchema;
import java.util.Map;
import org.apache.commons.lang3.StringUtils;
public class BoxedPrimitiveStructureType extends ComplexStructureType {
public static final String SERIALIZATION_TYPE = "BoxedPrimitiveStructureType";
public static final String KIND = PRIMITIVE_TYPE;
private BoxedPrimitiveStructureType() {
super();
}
public BoxedPrimitiveStructureType(
String definitionType,
String description,
Map<String, FieldDefinition> fields,
boolean isAbstract,
String parent
) {
super(
SERIALIZATION_TYPE,
KIND,
definitionType,
fields,
description,
parent,
isAbstract
);
}
@Override
public BoxedPrimitiveStructureType copyWithNewFields(Map<String, FieldDefinition> newFields) {
return new BoxedPrimitiveStructureType(
definitionType,
description,
newFields,
isAbstract,
parent
);
}
public String getOriginalDefinitionType() {
return StringUtils.uncapitalize(this.definitionType.replace("Boxed", ""));
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema/ComplexStructureType.java | package ai.stapi.schema.structureSchema;
import ai.stapi.schema.structureSchema.exception.FieldDoesNotExist;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.stream.Collectors;
public class ComplexStructureType extends AbstractStructureType {
public static final String SERIALIZATION_TYPE = "ComplexStructureType";
public static final String KIND = AbstractStructureType.COMPLEX_TYPE;
private Map<String, FieldDefinition> fields;
protected ComplexStructureType() {
super();
}
protected ComplexStructureType(
String serializationType,
String kind,
String definitionType,
Map<String, FieldDefinition> fields,
String description,
String parent,
boolean isAbstract
) {
super(serializationType, kind, definitionType, description, isAbstract, parent);
this.fields = new HashMap<>(fields);
}
public ComplexStructureType(
String definitionType,
Map<String, FieldDefinition> fields,
String description,
String parent,
boolean isAbstract
) {
super(
SERIALIZATION_TYPE,
AbstractStructureType.COMPLEX_TYPE,
definitionType,
description,
isAbstract,
parent
);
this.fields = new HashMap<>(fields);
}
public Map<String, FieldDefinition> getAllFields() {
return fields;
}
public Map<String, FieldDefinition> getOwnFields() {
return fields.entrySet().stream()
.filter(entry -> entry.getValue().getParentDefinitionType().equals(this.definitionType))
.collect(Collectors.toMap(Entry::getKey, Entry::getValue));
}
public FieldDefinition getField(String fieldName) {
if (!this.fields.containsKey(fieldName)) {
throw new FieldDoesNotExist(
String.format(
"Field '%s' does not exist on '%s'.",
fieldName,
this.getDefinitionType()
)
);
}
return this.fields.get(fieldName);
}
public boolean hasField(String fieldName) {
return this.fields.containsKey(fieldName);
}
public ComplexStructureType copyWithNewFields(Map<String, FieldDefinition> newFields) {
return new ComplexStructureType(
definitionType,
newFields,
description,
parent,
isAbstract
);
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema/FieldDefinition.java | package ai.stapi.schema.structureSchema;
import ai.stapi.serialization.AbstractSerializableObject;
import java.util.Comparator;
import java.util.List;
public class FieldDefinition extends AbstractSerializableObject {
public static final String SERIALIZATION_TYPE = "FieldDefinition";
public static final String LIST_STRUCTURE_TYPE = "list";
public static final String LEAF_STRUCTURE_TYPE = "leaf";
private String name;
private Integer min;
private String max;
private String description;
private List<FieldType> types;
private String parentDefinitionType;
private FieldDefinition() {
super(SERIALIZATION_TYPE);
}
public FieldDefinition(
String name,
Integer min,
String max,
String description,
List<FieldType> types,
String parentDefinitionType
) {
super(SERIALIZATION_TYPE);
this.name = name;
this.min = min;
this.max = max;
this.description = description;
this.types = types.stream()
.sorted(Comparator.comparing(FieldType::getType))
.toList();
this.parentDefinitionType = parentDefinitionType;
}
public Integer getMin() {
return min;
}
public String getMax() {
return max;
}
public Float getFloatMax() {
if (this.max.equals("*")) {
return Float.POSITIVE_INFINITY;
}
return Float.parseFloat(this.max);
}
public List<FieldType> getTypes() {
return types;
}
public String getStructureType() {
return isList() ? LIST_STRUCTURE_TYPE : LEAF_STRUCTURE_TYPE;
}
public boolean isList() {
try {
var value = Integer.parseInt(this.max);
return value > 1;
} catch (NumberFormatException ignored) {
}
return this.max.equals("*");
}
public boolean isRequired() {
return this.min > 0;
}
public boolean isUnionType() {
return this.types.size() > 1;
}
public boolean isAnyType() {
return this.types.isEmpty();
}
public String getDescription() {
return description;
}
public String getName() {
return name;
}
public String getParentDefinitionType() {
return parentDefinitionType;
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema/FieldType.java | package ai.stapi.schema.structureSchema;
import org.apache.commons.lang3.StringUtils;
public class FieldType {
private final String type;
private final String originalType;
private final FieldTypeGroup typeGroup;
private final boolean isContentReferenced;
public FieldType(
String type,
String originalType
) {
this(type, originalType, FieldTypeGroup.STANDARD);
}
public FieldType(
String type,
String originalType,
FieldTypeGroup fieldTypeGroup
) {
this(type, originalType, fieldTypeGroup, false);
}
private FieldType(
String type,
String originalType,
FieldTypeGroup fieldTypeGroup,
boolean isContentReferenced
) {
this.type = type;
this.originalType = originalType;
this.typeGroup = fieldTypeGroup;
this.isContentReferenced = isContentReferenced;
}
public static FieldType asReferenceType(String type) {
return new FieldType(type, "Reference", FieldTypeGroup.REFERENCE);
}
public static FieldType asContentReferenced(String type, String originalName) {
return new FieldType(
type,
originalName,
FieldTypeGroup.ANONYMOUS,
true
);
}
public static FieldType asAnonymousType(String type, String originalName) {
if (!originalName.equals("Element") && !originalName.equals("BackboneElement")) {
throw new RuntimeException(
"Anonymous type's original name must be either Element or BackboneElement");
}
return new FieldType(type, originalName, FieldTypeGroup.ANONYMOUS);
}
public static FieldType asBoxedType(String type) {
String typeName;
String originalName;
if (type.startsWith("Boxed")) {
typeName = type;
originalName = type.replace("Boxed", "").toLowerCase();
} else {
typeName = "Boxed" + StringUtils.capitalize(type);
originalName = type;
}
return new FieldType(typeName, originalName, FieldTypeGroup.BOXED);
}
public static FieldType asPlainType(String type) {
return new FieldType(type, type);
}
public String getType() {
return type;
}
public String getOriginalType() {
return originalType;
}
public FieldTypeGroup getTypeGroup() {
return typeGroup;
}
public boolean isReference() {
return this.originalType.equals("Reference");
}
public boolean isAnonymous() {
return this.originalType.equals("Element") || this.originalType.equals("BackboneElement");
}
public boolean isBoxed() {
return this.type.startsWith("Boxed") && !this.type.equals(this.originalType);
}
public boolean isPrimitiveType() {
return this.type.equals(this.originalType) && Character.isLowerCase(this.type.charAt(0));
}
public boolean isContentReferenced() {
return isContentReferenced;
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema/FieldTypeGroup.java | package ai.stapi.schema.structureSchema;
public enum FieldTypeGroup {
STANDARD,
BOXED,
REFERENCE,
ANONYMOUS
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema/PrimitiveStructureType.java | package ai.stapi.schema.structureSchema;
public class PrimitiveStructureType extends AbstractStructureType {
public static final String SERIALIZATION_TYPE = "PrimitiveStructureType";
public static final String KIND = AbstractStructureType.PRIMITIVE_TYPE;
protected PrimitiveStructureType() {
super();
}
protected PrimitiveStructureType(
String serializationType,
String definitionType,
String description,
boolean isAbstract,
String parent
) {
super(serializationType, AbstractStructureType.PRIMITIVE_TYPE, definitionType, description,
isAbstract, parent);
}
public PrimitiveStructureType(
String definitionType,
String description,
boolean isAbstract,
String parent
) {
super(SERIALIZATION_TYPE, AbstractStructureType.PRIMITIVE_TYPE, definitionType, description,
isAbstract, parent);
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema/ResourceStructureType.java | package ai.stapi.schema.structureSchema;
import java.util.Map;
public class ResourceStructureType extends ComplexStructureType {
public static final String SERIALIZATION_TYPE = "ResourceStructureType";
public static final String KIND = AbstractStructureType.RESOURCE;
private ResourceStructureType() {
super();
}
public ResourceStructureType(
String definitionType,
Map<String, FieldDefinition> fields,
String description,
String parent,
boolean isAbstract
) {
super(
SERIALIZATION_TYPE,
AbstractStructureType.RESOURCE,
definitionType,
fields,
description,
parent,
isAbstract
);
}
@Override
public ResourceStructureType copyWithNewFields(Map<String, FieldDefinition> newFields) {
return new ResourceStructureType(
definitionType,
newFields,
description,
parent,
isAbstract
);
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema/StructureSchema.java | package ai.stapi.schema.structureSchema;
import ai.stapi.schema.structureSchema.builder.ComplexStructureTypeBuilder;
import ai.stapi.schema.structureSchema.builder.StructureSchemaBuilder;
import ai.stapi.schema.structureSchema.exception.StructureSchemaCreationException;
import ai.stapi.schema.structureSchema.exception.StructureSchemaException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
import org.jetbrains.annotations.NotNull;
public class StructureSchema {
private Map<String, AbstractStructureType> definitions;
public StructureSchema() {
this.definitions = new HashMap<>();
}
public StructureSchema(Map<String, AbstractStructureType> abstractStructureType) {
this.definitions = new HashMap<>(abstractStructureType);
var unresolvableTypes = new StructureSchemaBuilder(
this.definitions).getUnresolvableTypesWithFailingDependencyList();
if (unresolvableTypes.size() > 0) {
throw StructureSchemaCreationException.becauseItContainsUnresolvableTypes(unresolvableTypes);
}
}
public StructureSchema(AbstractStructureType... types) {
this(List.of(types));
}
public StructureSchema(List<AbstractStructureType> types) {
this(typesToMap(types));
}
public static StructureSchema createChecked(List<AbstractStructureType> types) {
var schema = new StructureSchema();
schema.definitions = types.stream()
.collect(Collectors.toMap(AbstractStructureType::getDefinitionType, Function.identity()));
return schema;
}
@NotNull
private static HashMap<String, AbstractStructureType> typesToMap(
List<AbstractStructureType> types) {
var definitions = new HashMap<String, AbstractStructureType>();
types.forEach(type -> definitions.put(type.getDefinitionType(), type));
return definitions;
}
public Map<String, AbstractStructureType> getStructureTypes() {
return definitions;
}
public AbstractStructureType getDefinition(String serializationType) {
return this.definitions.get(serializationType);
}
public boolean containsDefinition(String serializationType) {
return this.definitions.containsKey(serializationType);
}
public StructureSchema merge(StructureSchema other) {
var schemaBuilder = new StructureSchemaBuilder(this);
other.definitions.forEach(
(key, structureType) -> {
if (this.definitions.containsKey(key)
&& !this.definitions.get(key).equals(structureType)) {
var localStructure = this.definitions.get(key);
if (
localStructure instanceof ComplexStructureType complexStructureType
&& !(localStructure instanceof BoxedPrimitiveStructureType)) {
var otherStructure = (ComplexStructureType) structureType;
var otherFields = otherStructure.getAllFields();
var localFields = complexStructureType.getAllFields();
var combinedFields = new HashMap<String, FieldDefinition>();
combinedFields.putAll(localFields);
combinedFields.putAll(otherFields);
var newStructure = new ComplexStructureTypeBuilder().copyToBuilder(localStructure);
if (!otherStructure.getParent().isBlank()) {
newStructure.setParent(otherStructure.getParent());
}
newStructure.setParent(otherStructure.getParent());
combinedFields.forEach(
(fieldName, field) -> {
newStructure.addField(fieldName)
.setMin(field.getMin())
.setMax(field.getMax())
.setName(field.getName())
.setDescription(field.getDescription())
.setTypes(field.getTypes())
.setParentDefinitionType(field.getParentDefinitionType());
}
);
this.definitions.put(key, newStructure.build(schemaBuilder));
} else {
this.definitions.put(key, structureType);
}
} else {
this.definitions.put(key, structureType);
}
}
);
this.resolveParentFields();
return this;
}
private void resolveParentFields() {
var updatedDefinitions = new ArrayList<ComplexStructureType>();
definitions.forEach((key, definition) -> {
if (definition instanceof ComplexStructureType complexStructureType) {
var parentFields = this.collectParentFields(complexStructureType);
var definitionFields = complexStructureType.getAllFields();
parentFields.putAll(definitionFields);
if (complexStructureType instanceof BoxedPrimitiveStructureType boxed) {
updatedDefinitions.add(boxed.copyWithNewFields(parentFields));
} else if (complexStructureType instanceof ResourceStructureType resource) {
updatedDefinitions.add(resource.copyWithNewFields(parentFields));
} else {
updatedDefinitions.add(complexStructureType.copyWithNewFields(parentFields));
}
}
});
updatedDefinitions.forEach(
updatedDefinition -> this.definitions.put(updatedDefinition.getDefinitionType(),
updatedDefinition));
}
private Map<String, FieldDefinition> collectParentFields(
ComplexStructureType complexStructureType) {
var parent = complexStructureType.getParent();
if (parent.isBlank()) {
return new HashMap<>();
}
if (!this.definitions.containsKey(parent)) {
throw StructureSchemaException.becauseParentDefinitionIsMissing(
complexStructureType.getDefinitionType(), parent);
}
var parentDefinition = this.definitions.get(parent);
if (parentDefinition instanceof ComplexStructureType complexParent) {
var map = this.collectParentFields(complexParent);
map.putAll(complexParent.getAllFields());
return map;
}
return new HashMap<>();
}
public List<AbstractStructureType> getChildDefinitions(String parentSerializationType) {
return this.definitions.values().stream()
.filter(abstractStructureType -> abstractStructureType.getParent() != null)
.filter(abstractStructureType -> abstractStructureType.getParent()
.equals(parentSerializationType))
.toList();
}
public boolean has(String serializationType) {
return this.definitions.containsKey(serializationType);
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema/builder/AbstractComplexStructureTypeBuilder.java | package ai.stapi.schema.structureSchema.builder;
import ai.stapi.schema.structureSchema.FieldType;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public abstract class AbstractComplexStructureTypeBuilder extends AbstractStructureTypeBuilder {
protected final Map<String, FieldDefinitionBuilder> fields = new HashMap<>();
public Map<String, FieldDefinitionBuilder> getAllFields(
StructureSchemaBuilder structureSchemaBuilder
) {
var allFields = new HashMap<>(this.fields);
if (this.getParent() != null && !this.getParent().isBlank()) {
var parentBuilder = structureSchemaBuilder.getStructureTypeBuilder(this.getParent());
if (parentBuilder != null) {
var parentFields = parentBuilder.getAllFields(structureSchemaBuilder);
parentFields.forEach((fieldName, fieldDefinitionBuilder) -> {
if (!allFields.containsKey(fieldName)) {
allFields.put(
fieldName,
fieldDefinitionBuilder
);
}
});
}
}
return allFields;
}
public FieldDefinitionBuilder addField(String fieldName) {
var fieldBuilder = new FieldDefinitionBuilder()
.setName(fieldName)
.setParentDefinitionType(this.serializationType);
fields.put(
fieldName,
fieldBuilder
);
return fieldBuilder;
}
public List<FieldType> getAllFieldTypes() {
return this.fields.values().stream()
.map(FieldDefinitionBuilder::getTypes)
.flatMap(List::stream)
.distinct()
.toList();
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema/builder/AbstractStructureTypeBuilder.java | package ai.stapi.schema.structureSchema.builder;
import static ai.stapi.schema.structureSchema.AbstractStructureType.PRIMITIVE_TYPE;
import ai.stapi.schema.structureSchema.AbstractStructureType;
import ai.stapi.schema.structureSchema.FieldType;
import ai.stapi.schema.structureSchema.FieldTypeGroup;
import ai.stapi.schema.structureSchemaMapper.UnresolvableSerializationType;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.jetbrains.annotations.NotNull;
public abstract class AbstractStructureTypeBuilder {
protected boolean isAbstract = false;
protected String description = "";
protected String serializationType = "";
protected String parent = "";
protected String kind = "";
public AbstractStructureTypeBuilder() {
}
public abstract AbstractStructureType build(StructureSchemaBuilder structureSchemaBuilder);
public abstract AbstractStructureTypeBuilder copyToBuilder(
AbstractStructureType abstractStructureType);
public boolean isAbstract() {
return this.isAbstract;
}
public boolean isPrimitiveType() {
return this.kind.equals(PRIMITIVE_TYPE);
}
public String getDescription() {
return this.description;
}
public String getSerializationType() {
return this.serializationType;
}
public String getOriginalSerializationType() {
return this.serializationType;
}
public String getParent() {
return parent;
}
public AbstractStructureTypeBuilder setParent(String parent) {
this.parent = parent;
return this;
}
public String getKind() {
return kind;
}
// public abstract boolean isResolvableIn(StructureSchemaBuilder structureSchemaBuilder);
public List<UnresolvableSerializationType> getDirectlyUnresolvableTypesWithFailingDependencyList(
StructureSchemaBuilder structureSchemaBuilder) {
var missingDependencies =
new ArrayList<>(this.findMissingTypesForFields(structureSchemaBuilder));
if (missingDependencies.size() == 0) {
return List.of();
}
return List.of(new UnresolvableSerializationType(
this.getSerializationType(),
this.getOriginalSerializationType(),
missingDependencies
)
);
}
@NotNull
protected ArrayList<String> findMissingDependenciesForParent(
StructureSchemaBuilder structureSchemaBuilder) {
var missingFieldsOnParent = new ArrayList<String>();
if (this.getParent() != null && !this.getParent().isBlank()) {
var parentBuilder = structureSchemaBuilder.getStructureTypeBuilder(this.getParent());
if (parentBuilder == null) {
String originalParentName =
structureSchemaBuilder.getStructureTypeBuilder(this.getSerializationType()).getParent();
if (originalParentName == null || originalParentName.isBlank()) {
originalParentName = this.getParent();
}
missingFieldsOnParent.add(
originalParentName
);
} else {
var missingOnParents = parentBuilder.findMissingTypesForFields(structureSchemaBuilder);
missingFieldsOnParent.addAll(missingOnParents);
}
}
return missingFieldsOnParent;
}
public List<String> findMissingTypesForFields(StructureSchemaBuilder structureSchemaBuilder) {
var allMissingFields = new ArrayList<String>();
var allFieldTypes = this.getAllFieldTypes();
var missingFieldsOnCurrent = allFieldTypes.stream()
.filter(fieldType -> !structureSchemaBuilder.containsType(fieldType.getType()))
.map(fieldType1 -> fieldType1.getTypeGroup().equals(FieldTypeGroup.BOXED)
? fieldType1.getOriginalType()
: fieldType1.getType()
).toList();
var allAnonymousTypesOnFields = this.getAllFields(structureSchemaBuilder).values().stream()
.map(FieldDefinitionBuilder::getTypes)
.flatMap(List::stream).distinct()
.filter(type -> structureSchemaBuilder.getStructureTypeBuilder(type.getType()) != null
? structureSchemaBuilder.getStructureTypeBuilder(type.getType())
.getContainedInNonAnonymousType() != null
: false
).toList();
var missingFieldsOnAllAnonymousTypesOnFields = allAnonymousTypesOnFields.stream()
.filter(fieldType -> !fieldType.isContentReferenced())
.map(fieldType -> structureSchemaBuilder.getMissingFieldsOnType(fieldType.getType()))
.flatMap(List::stream).distinct()
.collect(Collectors.toList());
ArrayList<String> missingFieldsOnParent =
findMissingDependenciesForParent(structureSchemaBuilder);
allMissingFields.addAll(missingFieldsOnCurrent);
allMissingFields.addAll(missingFieldsOnAllAnonymousTypesOnFields);
allMissingFields.addAll(missingFieldsOnParent);
return allMissingFields;
}
public abstract List<FieldType> getAllFieldTypes();
public abstract String getContainedInNonAnonymousType();
public abstract AbstractStructureTypeBuilder setContainedInNonAnonymousType(
String containedInNonAnonymousType);
public AbstractStructureTypeBuilder mergeOverwrite(AbstractStructureTypeBuilder other) {
if (!other.getClass().equals(this.getClass())) {
throw new RuntimeException(
String.format(
"""
Merging incompatible builders!
This builder: %s
Other builder: %s
""",
this.getClass().getSimpleName(),
other.getClass().getSimpleName()
)
);
}
this.specificMergeOverwrite(other);
if (other.getDescription() != null && !other.getDescription().isBlank()) {
this.description = other.getDescription();
}
if (other.getParent() != null && !other.getParent().isBlank()) {
this.parent = other.getParent();
}
if (other.getKind() != null && !other.getParent().isBlank()) {
this.kind = other.getKind();
}
if (other.getSerializationType() != null && !other.getSerializationType().isBlank()) {
this.serializationType = other.getSerializationType();
}
this.isAbstract = other.isAbstract();
return this;
}
protected abstract AbstractStructureTypeBuilder specificMergeOverwrite(
AbstractStructureTypeBuilder other);
public abstract Map<String, FieldDefinitionBuilder> getAllFields(
StructureSchemaBuilder structureSchemaBuilder);
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema/builder/BoxedStructureTypeBuilder.java | package ai.stapi.schema.structureSchema.builder;
import ai.stapi.schema.structureSchema.AbstractStructureType;
import ai.stapi.schema.structureSchema.BoxedPrimitiveStructureType;
import ai.stapi.schema.structureSchema.FieldDefinition;
import ai.stapi.schema.structureSchema.FieldType;
import java.util.HashMap;
import org.apache.commons.lang3.StringUtils;
public class BoxedStructureTypeBuilder extends AbstractComplexStructureTypeBuilder {
protected String originalSerializationType = "";
private String containedInNonAnonymousType;
public BoxedStructureTypeBuilder() {
this.kind = BoxedPrimitiveStructureType.KIND;
}
public AbstractStructureType build(StructureSchemaBuilder structureSchemaBuilder) {
var builtFields = new HashMap<String, FieldDefinition>();
this.getAllFields(structureSchemaBuilder).forEach((key, value) -> builtFields.put(
key,
value.build()
));
return new BoxedPrimitiveStructureType(
this.boxifySerializationType(serializationType),
description,
builtFields,
isAbstract,
parent
);
}
public String getContainedInNonAnonymousType() {
return containedInNonAnonymousType;
}
public BoxedStructureTypeBuilder setContainedInNonAnonymousType(
String containedInNonAnonymousType) {
this.containedInNonAnonymousType = containedInNonAnonymousType;
return this;
}
@Override
public AbstractStructureTypeBuilder specificMergeOverwrite(AbstractStructureTypeBuilder other) {
return other;
}
public String getOriginalSerializationType() {
return this.originalSerializationType;
}
public BoxedStructureTypeBuilder copyToBuilder(AbstractStructureType abstractStructureType) {
if (!(abstractStructureType instanceof BoxedPrimitiveStructureType boxedPrimitiveStructureType)) {
throw new RuntimeException("Trying to copy AbstractStructureType with wrong builder.");
}
var boxed = new BoxedStructureTypeBuilder()
.setSerializationType(boxedPrimitiveStructureType.getOriginalDefinitionType())
.setIsAbstract(boxedPrimitiveStructureType.isAbstract())
.setDescription(boxedPrimitiveStructureType.getDescription())
.setParent(boxedPrimitiveStructureType.getParent());
boxedPrimitiveStructureType.getAllFields().forEach(
(key, value) -> boxed.addField(key)
.setDescription(value.getDescription())
.setMax(value.getMax())
.setMin(value.getMin())
.setTypes(value.getTypes())
.setName(value.getName())
.setParentDefinitionType(value.getParentDefinitionType())
);
return boxed;
}
public BoxedStructureTypeBuilder setSerializationType(String serializationType) {
this.serializationType = this.boxifySerializationType(serializationType);
this.originalSerializationType = serializationType;
this.addField("value")
.setMin(0)
.setMax("1")
.setDescription("Primitive value for " + this.boxifySerializationType(serializationType))
.addType(FieldType.asPlainType(originalSerializationType));
return this;
}
public BoxedStructureTypeBuilder setParent(String parent) {
if (parent != null && !parent.isBlank()) {
if (parent.equals("Element")) {
this.parent = parent;
} else {
this.parent = this.boxifySerializationType(parent);
}
} else {
this.parent = "Element";
}
return this;
}
public BoxedStructureTypeBuilder setDescription(String description) {
this.description = description;
return this;
}
public BoxedStructureTypeBuilder setIsAbstract(Boolean isAbstract) {
this.isAbstract = isAbstract;
return this;
}
private String boxifySerializationType(String serializationType) {
if (serializationType.startsWith("Boxed")) {
return serializationType;
}
return "Boxed" + StringUtils.capitalize(serializationType);
}
} |
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema/builder/ComplexStructureTypeBuilder.java | package ai.stapi.schema.structureSchema.builder;
import ai.stapi.schema.structureSchema.AbstractStructureType;
import ai.stapi.schema.structureSchema.ComplexStructureType;
import ai.stapi.schema.structureSchema.FieldDefinition;
import ai.stapi.schema.structureSchema.ResourceStructureType;
import java.util.HashMap;
public class ComplexStructureTypeBuilder extends AbstractComplexStructureTypeBuilder {
private String containedInNonAnonymousType;
public ComplexStructureTypeBuilder() {
super();
}
public ComplexStructureTypeBuilder setSerializationType(String serializationType) {
this.serializationType = serializationType;
return this;
}
public ComplexStructureTypeBuilder copyToBuilder(AbstractStructureType abstractStructureType) {
if (!(abstractStructureType instanceof ComplexStructureType complexStructureType)) {
throw new RuntimeException("Trying to copy AbstractStructureType with wrong builder.");
}
var complex = new ComplexStructureTypeBuilder()
.setSerializationType(complexStructureType.getDefinitionType())
.setIsAbstract(complexStructureType.isAbstract())
.setKind(complexStructureType.getKind())
.setDescription(complexStructureType.getDescription())
.setParent(complexStructureType.getParent());
complexStructureType.getAllFields().forEach(
(key, value) -> complex.addField(key)
.setDescription(value.getDescription())
.setMax(value.getMax())
.setMin(value.getMin())
.setTypes(value.getTypes())
.setName(value.getName())
.setParentDefinitionType(value.getParentDefinitionType())
);
return complex;
}
public AbstractStructureType build(StructureSchemaBuilder structureSchemaBuilder) {
var builtFields = new HashMap<String, FieldDefinition>();
this.getAllFields(structureSchemaBuilder).forEach((key, value) -> builtFields.put(
key,
value.build()
));
switch (kind) {
case ResourceStructureType.KIND -> {
return new ResourceStructureType(
serializationType,
builtFields,
description,
parent,
isAbstract
);
}
case ComplexStructureType.KIND -> {
return new ComplexStructureType(
serializationType,
builtFields,
description,
parent,
isAbstract
);
}
default -> throw new RuntimeException("FHIR kind '" + kind + "' is not recognizable.");
}
}
public ComplexStructureTypeBuilder setParent(String parent) {
this.parent = parent;
return this;
}
public ComplexStructureTypeBuilder setDescription(String description) {
this.description = description;
return this;
}
public ComplexStructureTypeBuilder setIsAbstract(Boolean isAbstract) {
this.isAbstract = isAbstract;
return this;
}
public ComplexStructureTypeBuilder setKind(String kind) {
this.kind = kind;
return this;
}
public String getContainedInNonAnonymousType() {
return containedInNonAnonymousType;
}
public ComplexStructureTypeBuilder setContainedInNonAnonymousType(
String containedInNonAnonymousType) {
this.containedInNonAnonymousType = containedInNonAnonymousType;
return this;
}
@Override
protected AbstractStructureTypeBuilder specificMergeOverwrite(
AbstractStructureTypeBuilder other) {
if (!(other instanceof ComplexStructureTypeBuilder otherComplex)) {
throw new RuntimeException("Merging incompatible builders!");
}
if (otherComplex.getContainedInNonAnonymousType() != null) {
this.containedInNonAnonymousType = otherComplex.getContainedInNonAnonymousType();
}
this.fields.putAll(otherComplex.fields);
return this;
}
} |
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema/builder/FieldDefinitionBuilder.java | package ai.stapi.schema.structureSchema.builder;
import ai.stapi.schema.structureSchema.FieldDefinition;
import ai.stapi.schema.structureSchema.FieldType;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
public class FieldDefinitionBuilder {
private Integer min;
private String max;
private String name;
private String description;
private String parentDefinitionType;
private List<FieldType> types = new ArrayList<>();
public FieldDefinitionBuilder setMin(Integer min) {
this.min = Objects.requireNonNullElse(min, 0);
return this;
}
public FieldDefinitionBuilder setMax(String max) {
this.max = Objects.requireNonNullElse(max, "*");
return this;
}
public FieldDefinitionBuilder setParentDefinitionType(String parentDefinitionType) {
this.parentDefinitionType = parentDefinitionType;
return this;
}
public FieldDefinitionBuilder addType(FieldType fieldType) {
if (this.types.stream().noneMatch(
type -> type.getType().equals(fieldType.getType())
&& type.getOriginalType().equals(fieldType.getOriginalType()))) {
this.types.add(fieldType);
}
return this;
}
public FieldDefinition build() {
return new FieldDefinition(name, min, max, description, types, parentDefinitionType);
}
public FieldDefinitionBuilder setName(String name) {
this.name = name;
return this;
}
public FieldDefinitionBuilder setDescription(String description) {
this.description = description;
return this;
}
public List<FieldType> getTypes() {
return types;
}
public FieldDefinitionBuilder setTypes(List<FieldType> types) {
this.types = types;
return this;
}
} |
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema/builder/PrimitiveStructureTypeBuilder.java | package ai.stapi.schema.structureSchema.builder;
import static ai.stapi.schema.structureSchema.AbstractStructureType.PRIMITIVE_TYPE;
import ai.stapi.schema.structureSchema.AbstractStructureType;
import ai.stapi.schema.structureSchema.FieldType;
import ai.stapi.schema.structureSchema.PrimitiveStructureType;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class PrimitiveStructureTypeBuilder extends AbstractStructureTypeBuilder {
private String containedInNonAnonymousType;
public PrimitiveStructureTypeBuilder() {
super();
this.kind = PRIMITIVE_TYPE;
}
public PrimitiveStructureTypeBuilder copyToBuilder(AbstractStructureType primitiveStructureType) {
if (!(primitiveStructureType instanceof PrimitiveStructureType)) {
throw new RuntimeException("Trying to copy AbstractStructureType with wrong builder.");
}
return new PrimitiveStructureTypeBuilder()
.setSerializationType(primitiveStructureType.getDefinitionType())
.setIsAbstract(primitiveStructureType.isAbstract())
.setDescription(primitiveStructureType.getDescription())
.setParent(primitiveStructureType.getParent());
}
public PrimitiveStructureTypeBuilder setParent(String parent) {
this.parent = parent;
return this;
}
@Override
public AbstractStructureTypeBuilder setContainedInNonAnonymousType(
String containedInNonAnonymousType) {
this.containedInNonAnonymousType = containedInNonAnonymousType;
return this;
}
@Override
public List<String> findMissingTypesForFields(StructureSchemaBuilder structureSchemaBuilder) {
return findMissingDependenciesForParent(structureSchemaBuilder);
}
@Override
public List<FieldType> getAllFieldTypes() {
return new ArrayList<>();
}
@Override
public String getContainedInNonAnonymousType() {
return this.containedInNonAnonymousType;
}
@Override
protected AbstractStructureTypeBuilder specificMergeOverwrite(
AbstractStructureTypeBuilder other) {
return this;
}
@Override
public Map<String, FieldDefinitionBuilder> getAllFields(
StructureSchemaBuilder structureSchemaBuilder) {
return new HashMap<>();
}
public PrimitiveStructureTypeBuilder setSerializationType(String serializationType) {
this.serializationType = serializationType;
return this;
}
public PrimitiveStructureTypeBuilder setDescription(String description) {
this.description = description;
return this;
}
public PrimitiveStructureTypeBuilder setIsAbstract(Boolean isAbstract) {
this.isAbstract = isAbstract;
return this;
}
public PrimitiveStructureType build(StructureSchemaBuilder structureSchemaBuilder) {
return new PrimitiveStructureType(serializationType, description, isAbstract, parent);
}
} |
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema/builder/StructureSchemaBuilder.java | package ai.stapi.schema.structureSchema.builder;
import ai.stapi.schema.structureSchema.AbstractStructureType;
import ai.stapi.schema.structureSchema.BoxedPrimitiveStructureType;
import ai.stapi.schema.structureSchema.ComplexStructureType;
import ai.stapi.schema.structureSchema.FieldType;
import ai.stapi.schema.structureSchema.PrimitiveStructureType;
import ai.stapi.schema.structureSchema.StructureSchema;
import ai.stapi.schema.structureSchemaMapper.UnresolvableSerializationType;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class StructureSchemaBuilder {
private LinkedHashMap<String, AbstractStructureTypeBuilder> definitions;
public StructureSchemaBuilder(StructureSchema context) {
this(context.getStructureTypes());
}
public StructureSchemaBuilder(Map<String, AbstractStructureType> definitions) {
this.definitions = new LinkedHashMap<>();
definitions.forEach((key, definition) -> {
if (definition instanceof BoxedPrimitiveStructureType) {
this.addStructureTypeBuilder(new BoxedStructureTypeBuilder().copyToBuilder(definition));
} else if (definition instanceof ComplexStructureType) {
this.addStructureTypeBuilder(new ComplexStructureTypeBuilder().copyToBuilder(definition));
} else if (definition instanceof PrimitiveStructureType) {
this.addStructureTypeBuilder(new PrimitiveStructureTypeBuilder().copyToBuilder(definition));
} else {
throw new RuntimeException(
"Unrecognizable structure type. Type: '" + definition.getClass().getSimpleName()
+ "'.");
}
});
}
public StructureSchemaBuilder() {
this.definitions = new LinkedHashMap<>();
}
public void addStructureTypeBuilder(AbstractStructureTypeBuilder structureTypeBuilder) {
if (this.definitions.containsKey(structureTypeBuilder.getSerializationType())) {
this.definitions.get(structureTypeBuilder.getSerializationType())
.mergeOverwrite(structureTypeBuilder);
if (structureTypeBuilder.isPrimitiveType()) {
var builder = this.createBoxedEquivalent(structureTypeBuilder);
this.definitions.get(builder.getSerializationType()).mergeOverwrite(builder);
}
} else {
this.definitions.put(
structureTypeBuilder.getSerializationType(),
structureTypeBuilder
);
if (structureTypeBuilder.isPrimitiveType()) {
var builder = this.createBoxedEquivalent(structureTypeBuilder);
definitions.put(
builder.getSerializationType(),
builder
);
}
}
}
private BoxedStructureTypeBuilder createBoxedEquivalent(
AbstractStructureTypeBuilder structureTypeBuilder) {
return new BoxedStructureTypeBuilder()
.setSerializationType(structureTypeBuilder.getOriginalSerializationType())
.setDescription(structureTypeBuilder.getDescription())
.setIsAbstract(structureTypeBuilder.isAbstract())
.setParent(structureTypeBuilder.getParent());
}
public void addStructureTypeBuilders(List<AbstractStructureTypeBuilder> structureTypeBuilders) {
structureTypeBuilders.forEach(this::addStructureTypeBuilder);
}
public boolean containsType(String serializationType) {
return this.definitions.containsKey(serializationType);
}
public StructureSchema build() {
var unresolvableFields = this.getUnresolvableTypesWithFailingDependencyList().stream()
.map(UnresolvableSerializationType::serializationType)
.collect(Collectors.toList());
var allUnresolvableFields = this.definitions.values().stream().filter(
structureTypeBuilder ->
unresolvableFields.contains(
structureTypeBuilder.getSerializationType()
) || unresolvableFields.contains(
structureTypeBuilder.getOriginalSerializationType()
)
).map(AbstractStructureTypeBuilder::getSerializationType).toList();
var builtStructureTypes = new ArrayList<AbstractStructureType>();
var successfulDefinition = this.definitions.entrySet()
.stream().filter(
abstractStructureTypeBuilderEntrySet ->
!allUnresolvableFields.contains(
abstractStructureTypeBuilderEntrySet.getValue().getSerializationType()
)
).collect(Collectors.toMap(
Map.Entry::getKey,
Map.Entry::getValue
)
);
successfulDefinition.values().stream().forEach((abstractStructureTypeBuilder) -> {
builtStructureTypes.add(abstractStructureTypeBuilder.build(this));
});
return StructureSchema.createChecked(builtStructureTypes);
}
public AbstractStructureTypeBuilder getStructureTypeBuilder(String type) {
return definitions.get(type);
}
public List<UnresolvableSerializationType> getUnresolvableTypesWithFailingDependencyList() {
var unresolvableTypes = this.definitions.values().stream()
.map(
abstractStructureTypeBuilder -> abstractStructureTypeBuilder.getDirectlyUnresolvableTypesWithFailingDependencyList(
this))
.flatMap(List::stream).distinct()
.collect(Collectors.toMap(
UnresolvableSerializationType::serializationType,
unresolvableSerializationType -> unresolvableSerializationType,
(x, y) -> y,
HashMap::new
));
var lastCount = 0;
do {
lastCount = unresolvableTypes.size();
this.definitions.values().stream()
.filter(abstractStructureTypeBuilder -> !unresolvableTypes.containsKey(
abstractStructureTypeBuilder.getSerializationType()))
.forEach(
abstractStructureTypeBuilder -> {
if (abstractStructureTypeBuilder instanceof ComplexStructureTypeBuilder complexStructureTypeBuilder) {
var failed = complexStructureTypeBuilder.getAllFieldTypes().stream()
.map(FieldType::getType)
.filter(unresolvableTypes::containsKey).collect(Collectors.toList());
if (
!abstractStructureTypeBuilder.getParent().isBlank()
&& unresolvableTypes.containsKey(abstractStructureTypeBuilder.getParent()
)
) {
failed.add(abstractStructureTypeBuilder.getParent());
}
if (failed.size() > 0) {
var missing = failed.stream()
.map(s -> {
var unresovableType = unresolvableTypes.get(s);
return unresovableType.missingDependencies();
})
.flatMap(List::stream).distinct().collect(Collectors.toList());
unresolvableTypes.put(
abstractStructureTypeBuilder.getSerializationType(),
new UnresolvableSerializationType(
abstractStructureTypeBuilder.getSerializationType(),
abstractStructureTypeBuilder.getOriginalSerializationType(),
missing
)
);
}
} else if (abstractStructureTypeBuilder instanceof PrimitiveStructureTypeBuilder primitiveBuilder) {
unresolvableTypes.values().stream()
.filter(unresolvableSerializationType ->
unresolvableSerializationType.originalSerializationType()
.equals(primitiveBuilder.getSerializationType())
).findAny()
.ifPresent(unresolvableSerializationType ->
unresolvableTypes.put(
primitiveBuilder.getSerializationType(),
new UnresolvableSerializationType(
abstractStructureTypeBuilder.getSerializationType(),
abstractStructureTypeBuilder.getOriginalSerializationType(),
unresolvableSerializationType.missingDependencies()
)
));
} else if (abstractStructureTypeBuilder instanceof BoxedStructureTypeBuilder boxedStructureTypeBuilder) {
var primitiveDependency =
boxedStructureTypeBuilder.getOriginalSerializationType();
var parentDependency = boxedStructureTypeBuilder.getParent();
var missingDependencies = unresolvableTypes.values().stream()
.filter(unresolvable ->
unresolvable.serializationType().equals(primitiveDependency)
|| unresolvable.serializationType().equals(parentDependency)
).map(UnresolvableSerializationType::missingDependencies)
.flatMap(List::stream)
.collect(Collectors.toList());
if (missingDependencies.size() > 0) {
unresolvableTypes.put(
abstractStructureTypeBuilder.getOriginalSerializationType(),
new UnresolvableSerializationType(
abstractStructureTypeBuilder.getOriginalSerializationType(),
abstractStructureTypeBuilder.getOriginalSerializationType(),
missingDependencies
)
);
unresolvableTypes.put(
abstractStructureTypeBuilder.getSerializationType(),
new UnresolvableSerializationType(
abstractStructureTypeBuilder.getSerializationType(),
abstractStructureTypeBuilder.getOriginalSerializationType(),
missingDependencies
)
);
}
}
}
);
} while (lastCount != unresolvableTypes.size());
return unresolvableTypes.values().stream().toList();
}
public List<String> getMissingFieldsOnType(String type) {
var abstractStructureTypeBuilder = this.definitions.get(type);
if (abstractStructureTypeBuilder == null) {
return List.of();
}
return abstractStructureTypeBuilder.findMissingTypesForFields(this);
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema/exception/FieldDoesNotExist.java | package ai.stapi.schema.structureSchema.exception;
public class FieldDoesNotExist extends RuntimeException {
public FieldDoesNotExist(String message) {
super(message);
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema/exception/FieldsNotFoundException.java | package ai.stapi.schema.structureSchema.exception;
import ai.stapi.schema.structureSchemaMapper.UnresolvableType;
import java.util.List;
public class FieldsNotFoundException extends RuntimeException {
private FieldsNotFoundException(
String message,
String serializationType,
List<String> fieldNames
) {
super(
String.format(
"%s not found at structure with serializationType '%s', %s",
fieldNames.size() == 1 ? String.format("Field '%s'", fieldNames.get(0)) :
String.format("Fields '%s'", fieldNames),
serializationType,
message
)
);
}
private FieldsNotFoundException(
String message,
String serializationType
) {
super(
String.format(
"Some fields not found at structure with serializationType '%s', %s",
serializationType,
message
)
);
}
public static FieldsNotFoundException becauseSerializationTypeDoesNotExistInSchema(
String serializationType,
List<String> fieldNames
) {
return new FieldsNotFoundException(
"because serializationType does not exist in schema.",
serializationType,
fieldNames
);
}
public static FieldsNotFoundException becauseSerializationTypeIsPrimitive(
String serializationType,
List<String> fieldNames
) {
return new FieldsNotFoundException(
"because serializationType is primitive.",
serializationType,
fieldNames
);
}
public static FieldsNotFoundException becauseSerializationTypeIsOfUnknownType(
String serializationType
) {
return new FieldsNotFoundException(
"because serializationType '%s' is of unknown type.",
serializationType
);
}
public static FieldsNotFoundException becauseSerializationTypeDoesNotExistInSchema(
String serializationType
) {
return new FieldsNotFoundException(
"because serializationType does not exist in schema.",
serializationType
);
}
public static FieldsNotFoundException becauseSerializationTypeDoesNotExistInSchema(
String serializationType,
UnresolvableType unresolvableType
) {
return new FieldsNotFoundException(
String.format(
"because serializationType does not exist in schema, but is unresolvable.%nMissing dependencies: '%s'",
unresolvableType.missingDependencies()
),
serializationType
);
}
public static FieldsNotFoundException becauseSerializationTypeIsPrimitive(
String serializationType
) {
return new FieldsNotFoundException(
"because serializationType is primitive.",
serializationType
);
}
public static FieldsNotFoundException becauseSerializationTypeIsOfUnknownType(
String serializationType,
List<String> fieldNames
) {
return new FieldsNotFoundException(
"because serializationType '%s' is of unknown type.",
serializationType,
fieldNames
);
}
public static FieldsNotFoundException becauseFinderIsRestricted(
String serializationType,
List<String> fieldNames
) {
return new FieldsNotFoundException(
"because Structure Schema Finder is restricted. You should use Test Case supporting Structure Schema.",
serializationType,
fieldNames
);
}
public static FieldsNotFoundException becauseFinderIsRestricted(
String serializationType
) {
return new FieldsNotFoundException(
"because Structure Schema Finder is restricted. You should use Test Case supporting Structure Schema.",
serializationType
);
}
public static FieldsNotFoundException becauseSomeFieldsAreMissing(
String serializationType,
List<String> fieldNames
) {
return new FieldsNotFoundException(
"because they are missing in found Complex Structure Type.",
serializationType,
fieldNames
);
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema/exception/StructureNotFoundException.java | package ai.stapi.schema.structureSchema.exception;
public class StructureNotFoundException extends RuntimeException {
private StructureNotFoundException(String message, String serializationType) {
super(String.format("Structure with serializationType '%s' not found, %s", serializationType,
message));
}
public static StructureNotFoundException becauseDoesNotExist(
String serializationType
) {
return new StructureNotFoundException(
String.format(
"because it does not exist"
),
serializationType
);
}
public static StructureNotFoundException becauseIsOfPrimitiveType(
String serializationType
) {
return new StructureNotFoundException(
String.format(
"because it is of primitive type"
),
serializationType
);
}
public static StructureNotFoundException becauseSerializationTypeIsOfUnknownType(
String serializationType
) {
return new StructureNotFoundException(
String.format(
"because it is of unknown type"
),
serializationType
);
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema/exception/StructureSchemaCreationException.java | package ai.stapi.schema.structureSchema.exception;
import ai.stapi.schema.structureSchemaMapper.UnresolvableSerializationType;
import java.util.List;
import org.apache.commons.lang3.StringUtils;
public class StructureSchemaCreationException extends RuntimeException {
private StructureSchemaCreationException(String message) {
super(message);
}
public static StructureSchemaCreationException becauseItContainsUnresolvableTypes(
List<UnresolvableSerializationType> unresolvableTypes
) {
var errorMessage = new StringBuilder();
errorMessage
.append("Structure schema cannot be created because it has missing dependencies. Details:'")
.append(System.lineSeparator());
unresolvableTypes.forEach(unresolvableSerializationType -> {
errorMessage
.append(System.lineSeparator())
.append("Failed type: '")
.append(unresolvableSerializationType.serializationType())
.append("', ")
.append("missing dependencies: [")
.append(StringUtils.join(unresolvableSerializationType.missingDependencies(), ", "))
.append("]");
});
return new StructureSchemaCreationException(errorMessage.toString());
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchema/exception/StructureSchemaException.java | package ai.stapi.schema.structureSchema.exception;
public class StructureSchemaException extends RuntimeException {
private final String parentDefinitionType;
private StructureSchemaException(String message, String parentDefinitionType) {
super(message);
this.parentDefinitionType = parentDefinitionType;
}
public static StructureSchemaException becauseCouldNotConstructDefinition(
String parentDefinitionType,
String fieldName,
String fieldType
) {
return new StructureSchemaException(
"GraphDefinition does not contain definition for type '" + fieldType + "'" +
System.lineSeparator() +
"Parent Object: " + parentDefinitionType +
System.lineSeparator() +
"Field: " + fieldName,
parentDefinitionType
);
}
public static StructureSchemaException becauseParentDefinitionIsMissing(
String definitionType,
String parentDefinitionType
) {
return new StructureSchemaException(
"StructureSchema does not contain definition of parent for type '" + definitionType + "'." +
System.lineSeparator() +
"Required parent: " + parentDefinitionType,
parentDefinitionType
);
}
public String getParentDefinitionType() {
return parentDefinitionType;
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchemaMapper/MappingOutcome.java | package ai.stapi.schema.structureSchemaMapper;
import ai.stapi.schema.structureSchema.StructureSchema;
import java.util.List;
public record MappingOutcome(
StructureSchema structureSchema,
List<UnresolvableType> unresolvableTypes,
List<String> successfullyMappedTypes
) {
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchemaMapper/StructureDefinitionToSSMapper.java | package ai.stapi.schema.structureSchemaMapper;
import ai.stapi.schema.structureSchema.AbstractStructureType;
import ai.stapi.schema.structureSchema.FieldType;
import ai.stapi.schema.structureSchema.PrimitiveStructureType;
import ai.stapi.schema.structureSchema.StructureSchema;
import ai.stapi.schema.structureSchema.builder.AbstractStructureTypeBuilder;
import ai.stapi.schema.structureSchema.builder.ComplexStructureTypeBuilder;
import ai.stapi.schema.structureSchema.builder.PrimitiveStructureTypeBuilder;
import ai.stapi.schema.structureSchema.builder.StructureSchemaBuilder;
import ai.stapi.schema.structureSchemaMapper.exception.UnresolvableTypeException;
import ai.stapi.schema.structuredefinition.ElementDefinition;
import ai.stapi.schema.structuredefinition.ElementDefinitionType;
import ai.stapi.schema.structuredefinition.StructureDefinitionData;
import ai.stapi.schema.structuredefinition.StructureDefinitionDataMerger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.stream.Collectors;
import org.apache.commons.lang3.StringUtils;
import org.jetbrains.annotations.Nullable;
public class StructureDefinitionToSSMapper {
public MappingOutcome map(StructureDefinitionData structureDefinitions) {
return this.map(List.of(structureDefinitions), new StructureSchema());
}
public MappingOutcome map(StructureDefinitionData structureDefinitions, StructureSchema context) {
return this.map(List.of(structureDefinitions), context);
}
public MappingOutcome map(List<StructureDefinitionData> structureDefinitions) {
return this.map(structureDefinitions, new StructureSchema());
}
public MappingOutcome map(
List<StructureDefinitionData> structureDefinitions,
StructureSchema context
) {
if (structureDefinitions.isEmpty()) {
return new MappingOutcome(context, new ArrayList<>(), new ArrayList<>());
}
var schemaBuilder = new StructureSchemaBuilder(context);
structureDefinitions.forEach(
definition -> {
if (definition.getKind() == null) {
throw new UnresolvableTypeException("Kind is null for " + definition.getId());
}
if (definition.getKind().equals(PrimitiveStructureType.KIND)) {
schemaBuilder.addStructureTypeBuilder(
this.createPrimitiveTypeBuilder(definition)
);
} else {
schemaBuilder.addStructureTypeBuilders(
this.createComplexTypeBuilders(definition)
);
}
});
var unresolvableSerializationTypesWithCause =
schemaBuilder.getUnresolvableTypesWithFailingDependencyList();
var unresolvableTypes = unresolvableSerializationTypesWithCause.stream()
.map(unresolvableSerializationType -> {
var structureDefinitionDTO = structureDefinitions.stream()
.filter(
definition -> definition.getId()
.equals(unresolvableSerializationType.serializationType())
)
.reduce(StructureDefinitionDataMerger::merge)
.orElse(null);
return new UnresolvableType(
structureDefinitionDTO, unresolvableSerializationType.missingDependencies()
);
})
.filter(unresolvableType -> unresolvableType.structureDefinitionData() != null)
.toList();
var unresolvableSerializationTypes = unresolvableTypes.stream().map(
UnresolvableType::structureDefinitionData
).map(StructureDefinitionData::getId).toList();
var successfullyResolvedTypes = structureDefinitions.stream()
.map(StructureDefinitionData::getId)
.filter(id -> !unresolvableSerializationTypes.contains(id))
.distinct()
.toList();
StructureSchema builtSchema = schemaBuilder.build();
return new MappingOutcome(
builtSchema,
unresolvableTypes,
successfullyResolvedTypes
);
}
public String createAnonymousComplexTypeNameFromElementPath(String elementDefinitionPath) {
var pathParts = elementDefinitionPath.split("\\.");
return Arrays.stream(pathParts)
.map(StringUtils::capitalize)
.collect(Collectors.joining());
}
private AbstractStructureTypeBuilder createPrimitiveTypeBuilder(
StructureDefinitionData definitionDTO
) {
var builder = new PrimitiveStructureTypeBuilder();
builder
.setSerializationType(definitionDTO.getId())
.setDescription(definitionDTO.getDescription())
.setIsAbstract(definitionDTO.getIsAbstract());
if (definitionDTO.getBaseDefinitionRef() != null) {
builder.setParent(definitionDTO.getBaseDefinitionRef().toString());
}
return builder;
}
private List<AbstractStructureTypeBuilder> createComplexTypeBuilders(
StructureDefinitionData structureDefinitionData
) {
var builder = new ComplexStructureTypeBuilder();
builder
.setSerializationType(structureDefinitionData.getId())
.setDescription(structureDefinitionData.getDescription())
.setIsAbstract(structureDefinitionData.getIsAbstract())
.setKind(structureDefinitionData.getKind());
if (structureDefinitionData.getBaseDefinitionRef() != null) {
builder.setParent(structureDefinitionData.getBaseDefinitionRef().toString());
}
var resultBuilders = new ArrayList<AbstractStructureTypeBuilder>();
resultBuilders.add(builder);
var differential = structureDefinitionData.getDifferential();
if (differential == null) {
return resultBuilders;
}
differential.getElement().stream()
.filter(definition -> definition.getPath().split("\\.").length == 2)
.forEach(elementDefinition -> {
var fieldName = elementDefinition.getPath().split("\\.")[1].replace("[x]", "");
var elementTypes = this.resolveElementTypes(elementDefinition);
var fieldBuilder = builder.addField(fieldName);
fieldBuilder.setMin(elementDefinition.getMin())
.setMax(elementDefinition.getMax())
.setDescription(elementDefinition.getDefinition());
if (elementDefinition.getContentReference() != null) {
var referencedType = this.createContentReferencedType(
structureDefinitionData,
elementDefinition.getContentReference()
);
if (referencedType != null) {
fieldBuilder.addType(referencedType);
} else {
//TODO: Add to failed types or something?
}
}
elementTypes.forEach(fieldBuilder::addType);
});
var anonymousBuilders = new HashMap<String, ComplexStructureTypeBuilder>();
differential.getElement().forEach(elementDefinition -> {
var splitPath = elementDefinition.getPath().split("\\.");
if (splitPath.length < 3) {
return;
}
var fieldName = splitPath[splitPath.length - 1].replace("[x]", "");
var anonymousSplitPath = Arrays.copyOfRange(splitPath, 0, splitPath.length - 1);
var anonymousPath = String.join(".", anonymousSplitPath);
var anonymousObjectName = this.createAnonymousComplexTypeNameFromElementPath(anonymousPath);
var anonymousBuilder = anonymousBuilders.computeIfAbsent(
anonymousObjectName,
key -> this.createAnonymousBuilder(structureDefinitionData, anonymousObjectName)
);
var maybeParent = differential.getElement().stream()
.filter(definition -> definition.getPath().equals(anonymousPath))
.findFirst();
maybeParent.ifPresent(
parent -> {
var type = parent.getType();
if (type.isEmpty()) {
return;
}
anonymousBuilder.setParent(type.get(0).getCodeRef().getId());
}
);
var fieldTypes = this.resolveElementTypes(elementDefinition);
var fieldBuilder = anonymousBuilder.addField(fieldName);
fieldBuilder.setMin(elementDefinition.getMin())
.setMax(elementDefinition.getMax())
.setDescription(elementDefinition.getDefinition());
if (elementDefinition.getContentReference() != null) {
var referencedType = this.createContentReferencedType(
structureDefinitionData,
elementDefinition.getContentReference()
);
if (referencedType != null) {
fieldBuilder.addType(referencedType);
} else {
//TODO: Add to failed types or something?
}
}
fieldTypes.forEach(fieldBuilder::addType);
});
resultBuilders.addAll(anonymousBuilders.values());
return resultBuilders;
}
private ComplexStructureTypeBuilder createAnonymousBuilder(
StructureDefinitionData containedInDefinition,
String anonymousObjectName
) {
return new ComplexStructureTypeBuilder()
.setSerializationType(anonymousObjectName)
.setKind(AbstractStructureType.COMPLEX_TYPE)
.setIsAbstract(false)
.setDescription("Type for anonymous field contained in " + containedInDefinition.getId())
.setContainedInNonAnonymousType(containedInDefinition.getId());
}
private List<FieldType> resolveElementTypes(
ElementDefinition elementDefinition
) throws UnresolvableTypeException {
var fixedTypes = new ArrayList<FieldType>();
if (elementDefinition.getType() == null) {
return fixedTypes;
}
elementDefinition.getType().forEach(type -> {
fixedTypes.addAll(this.createFieldType(elementDefinition, type));
});
return fixedTypes;
}
private List<FieldType> createFieldType(
ElementDefinition elementDefinition,
ElementDefinitionType type
) {
var code = type.getCodeRef().getId();
if (this.isAnonymousElement(code)) {
return List.of(
FieldType.asAnonymousType(
this.createAnonymousComplexTypeNameFromElementPath(elementDefinition.getPath()),
code
)
);
} else if (isPrimitiveType(code) && isUnionType(elementDefinition)) {
return List.of(FieldType.asBoxedType(code));
} else if (isReference(code)) {
if (type.getTargetProfileRef().isEmpty()) {
return List.of(FieldType.asReferenceType("Reference"));
}
return type.getTargetProfileRef().stream()
.map(targetProfile -> FieldType.asReferenceType(targetProfile.getId()))
.toList();
} else {
return List.of(FieldType.asPlainType(type.getCodeRef().getId()));
}
}
private boolean isAnonymousElement(String type) {
return type.equals("BackboneElement") || type.equals("Element");
}
private boolean isReference(String type) {
return type.equals("Reference");
}
private boolean isPrimitiveType(String type) {
return Character.isLowerCase(type.charAt(0));
}
private boolean isUnionType(ElementDefinition elementDefinition) {
return elementDefinition.getType().size() > 1;
}
@Nullable
private FieldType createContentReferencedType(
StructureDefinitionData containedInDefinition,
String referencedTypePath
) {
var trimmedPath = referencedTypePath.replace("#", "");
var referencedElementDefinition = containedInDefinition.getDifferential()
.getElement()
.stream()
.filter(definition -> definition.getPath().equals(trimmedPath))
.findFirst();
if (referencedElementDefinition.isPresent()) {
var anonymousTypeName = this.createAnonymousComplexTypeNameFromElementPath(
trimmedPath
);
return FieldType.asContentReferenced(
anonymousTypeName,
referencedElementDefinition.get().getType().get(0).getCodeRef().getId()
);
}
return null;
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchemaMapper/UnresolvableSerializationType.java | package ai.stapi.schema.structureSchemaMapper;
import java.util.List;
public record UnresolvableSerializationType(
String serializationType,
String originalSerializationType,
List<String> missingDependencies
) {
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchemaMapper/UnresolvableType.java | package ai.stapi.schema.structureSchemaMapper;
import ai.stapi.schema.structuredefinition.StructureDefinitionData;
import java.util.List;
public record UnresolvableType(StructureDefinitionData structureDefinitionData,
List<String> missingDependencies) {
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchemaMapper | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchemaMapper/exception/StructureDefinitionToSSMapperException.java | package ai.stapi.schema.structureSchemaMapper.exception;
public class StructureDefinitionToSSMapperException extends RuntimeException {
private final String failedStructureSerializationType;
private StructureDefinitionToSSMapperException(String message,
String failedStructureSerializationType) {
super(message);
this.failedStructureSerializationType = failedStructureSerializationType;
}
public static StructureDefinitionToSSMapperException becauseStructureDefinitionWasNotFound(
String structureDefinitionId,
String elementPath
) {
return new StructureDefinitionToSSMapperException(
"StructureDefinition of type '"
+ structureDefinitionId
+ "' on field '"
+ elementPath + "' was not found.",
structureDefinitionId
);
}
public static StructureDefinitionToSSMapperException becauseStructureDefinitionIsMissingKind(
String structureDefinitionId
) {
return new StructureDefinitionToSSMapperException(
"StructureDefinition of type '" + structureDefinitionId + "' has field 'kind' not defined.",
structureDefinitionId
);
}
public String getFailedStructureSerializationType() {
return failedStructureSerializationType;
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchemaMapper | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchemaMapper/exception/UnresolvableTypeException.java | package ai.stapi.schema.structureSchemaMapper.exception;
public class UnresolvableTypeException extends RuntimeException {
private final String fieldType;
public UnresolvableTypeException(String fieldType) {
super("Could not resolve field of type " + fieldType);
this.fieldType = fieldType;
}
public String getFieldType() {
return fieldType;
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchemaProvider/DefaultStructureSchemaFinder.java | package ai.stapi.schema.structureSchemaProvider;
import ai.stapi.schema.structureSchema.AbstractStructureType;
import ai.stapi.schema.structureSchema.ComplexStructureType;
import ai.stapi.schema.structureSchema.FieldDefinition;
import ai.stapi.schema.structureSchema.FieldType;
import ai.stapi.schema.structureSchema.PrimitiveStructureType;
import ai.stapi.schema.structureSchema.ResourceStructureType;
import ai.stapi.schema.structureSchema.exception.FieldsNotFoundException;
import ai.stapi.schema.structureSchemaProvider.exception.CannotProvideStructureSchema;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.jetbrains.annotations.NotNull;
public class DefaultStructureSchemaFinder implements StructureSchemaFinder {
public static final String UNKNOWN_FIELD_TYPE = "unknown";
private final StructureSchemaProvider structureSchemaProvider;
public DefaultStructureSchemaFinder(
StructureSchemaProvider structureSchemaProvider
) {
this.structureSchemaProvider = structureSchemaProvider;
}
@Override
public boolean isList(String serializationType, String fieldName) throws FieldsNotFoundException {
return this.getFieldDefinitionFor(serializationType, fieldName).isList();
}
@Override
public boolean containsType(String rootType, String typeToBeFound) {
var rootStructure = this.getStructureType(rootType);
if (!(rootStructure instanceof ComplexStructureType complexRootStructure)) {
return false;
}
return complexRootStructure.getOwnFields().values().stream().anyMatch(
fieldDefinition -> fieldDefinition.getTypes().stream().anyMatch(
type -> {
if (type.getType().equals(typeToBeFound)) {
return true;
}
return this.containsType(type.getType(), typeToBeFound);
}
)
);
}
@Override
public AbstractStructureType getStructureType(String serializationType) {
var schema = this.structureSchemaProvider.provideSchema();
if (!schema.has(serializationType)) {
var unresolvable = this.structureSchemaProvider.provideUnresolvableTypes();
var foundUnresolvable = unresolvable.stream()
.filter(type -> type.structureDefinitionData().getId().equals(serializationType))
.toList();
if (foundUnresolvable.isEmpty()) {
throw FieldsNotFoundException.becauseSerializationTypeDoesNotExistInSchema(
serializationType
);
}
throw FieldsNotFoundException.becauseSerializationTypeDoesNotExistInSchema(
serializationType,
foundUnresolvable.get(0)
);
}
return schema.getDefinition(serializationType);
}
@Override
public Map<String, FieldDefinition> getFieldDefinitionsFor(
String serializationType,
List<String> fieldNames
) throws FieldsNotFoundException {
if (fieldNames.isEmpty()) {
return new HashMap<>();
}
var structureType = this.getStructureType(serializationType);
if (structureType instanceof PrimitiveStructureType) {
throw FieldsNotFoundException.becauseSerializationTypeIsPrimitive(
serializationType,
fieldNames
);
}
if (structureType instanceof ComplexStructureType complexStructureType) {
var missingFields = fieldNames.stream()
.filter(fieldName -> !complexStructureType.getAllFields().containsKey(fieldName))
.toList();
if (!missingFields.isEmpty()) {
throw FieldsNotFoundException.becauseSomeFieldsAreMissing(serializationType, missingFields);
}
return complexStructureType.getAllFields().entrySet().stream()
.filter(entry -> fieldNames.contains(entry.getKey()))
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
}
throw FieldsNotFoundException.becauseSerializationTypeIsOfUnknownType(
serializationType,
fieldNames
);
}
@Override
public FieldDefinition getFieldDefinitionFor(
String serializationType,
String fieldName
) throws FieldsNotFoundException {
return this.getFieldDefinitionsFor(
serializationType,
List.of(fieldName)
).get(fieldName);
}
@Override
public Map<String, FieldDefinition> getAllFieldDefinitionsFor(
String serializationType
) throws FieldsNotFoundException {
var schema = this.structureSchemaProvider.provideSchema();
if (!schema.has(serializationType)) {
throw FieldsNotFoundException.becauseSerializationTypeIsPrimitive(serializationType);
}
var structureType = schema.getDefinition(serializationType);
if (structureType instanceof PrimitiveStructureType) {
throw FieldsNotFoundException.becauseSerializationTypeIsPrimitive(serializationType);
}
if (structureType instanceof ComplexStructureType complexStructureType) {
return complexStructureType.getAllFields();
}
throw FieldsNotFoundException.becauseSerializationTypeIsOfUnknownType(serializationType);
}
@NotNull
@Override
public HashMap<String, FieldDefinition> getFieldDefinitionHashMap(
Map<?, ?> attributes,
String structureId
) {
var fieldDefinitions = new HashMap<String, FieldDefinition>();
attributes.keySet().stream()
.filter(String.class::isInstance)
.map(String.class::cast)
.forEach(fieldName -> {
FieldDefinition fieldDefinitionFor = getFieldDefinitionOrFallback(
structureId,
fieldName
);
fieldDefinitions.put(
fieldName,
fieldDefinitionFor
);
});
return fieldDefinitions;
}
@Override
public boolean isResource(String serializationType) {
var schema = this.structureSchemaProvider.provideSchema();
if (!schema.containsDefinition(serializationType)) {
return false;
}
return schema.getDefinition(serializationType).getKind().equals(ResourceStructureType.KIND);
}
@Override
public boolean structureExists(String serializationType) {
return this.structureSchemaProvider.containsSchema(serializationType);
}
@Override
public AbstractStructureType getSchemaStructure(String serializationType) {
try {
return this.structureSchemaProvider.provideSpecific(serializationType);
} catch (CannotProvideStructureSchema e) {
throw new RuntimeException(e);
}
}
@Override
public FieldDefinition getFieldDefinitionOrFallback(String serializationType, String fieldName) {
FieldDefinition fieldDefinitionFor;
try {
fieldDefinitionFor = this.getFieldDefinitionFor(
serializationType,
fieldName
);
} catch (FieldsNotFoundException e) {
fieldDefinitionFor = new FieldDefinition(
fieldName,
0,
"*",
"",
List.of(
new FieldType(
UNKNOWN_FIELD_TYPE,
UNKNOWN_FIELD_TYPE
)
),
serializationType
);
}
return fieldDefinitionFor;
}
@Override
public List<ResourceStructureType> getAllResources() {
return this.structureSchemaProvider.provideSchema()
.getStructureTypes()
.values()
.stream()
.filter(ResourceStructureType.class::isInstance)
.map(ResourceStructureType.class::cast)
.toList();
}
@Override
public boolean inherits(String serializationType, String inheritedSerializationType) {
var inheriting = this.getStructureType(serializationType);
var parentType = inheriting.getParent();
if (parentType == null || parentType.isBlank()) {
return false;
}
if (parentType.equals(inheritedSerializationType)) {
return true;
}
return this.inherits(parentType, inheritedSerializationType);
}
@Override
public boolean isEqualOrInherits(String serializationType, String inheritedSerializationType) {
if (serializationType.equals(inheritedSerializationType)) {
return true;
}
return this.inherits(serializationType, inheritedSerializationType);
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchemaProvider/DefaultStructureSchemaProvider.java | package ai.stapi.schema.structureSchemaProvider;
import ai.stapi.schema.scopeProvider.ScopeCacher;
import ai.stapi.schema.structureSchema.AbstractStructureType;
import ai.stapi.schema.structureSchema.StructureSchema;
import ai.stapi.schema.structureSchemaMapper.MappingOutcome;
import ai.stapi.schema.structureSchemaMapper.StructureDefinitionToSSMapper;
import ai.stapi.schema.structureSchemaMapper.UnresolvableType;
import ai.stapi.schema.structureSchemaProvider.exception.CannotProvideStructureSchema;
import ai.stapi.schema.structuredefinition.StructureDefinitionData;
import ai.stapi.schema.structuredefinition.StructureDefinitionDataMerger;
import ai.stapi.schema.structuredefinition.loader.StructureDefinitionLoader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
public class DefaultStructureSchemaProvider implements StructureSchemaProvider {
private final StructureDefinitionToSSMapper structureDefinitionToSSMapper;
private final StructureDefinitionLoader structureDefinitionLoader;
private final ScopeCacher scopeCacher;
public DefaultStructureSchemaProvider(
StructureDefinitionToSSMapper structureDefinitionToSSMapper,
StructureDefinitionLoader structureDefinitionLoader,
ScopeCacher scopeCacher
) {
this.structureDefinitionToSSMapper = structureDefinitionToSSMapper;
this.structureDefinitionLoader = structureDefinitionLoader;
this.scopeCacher = scopeCacher;
}
@Override
public AbstractStructureType provideSpecific(String serializationType)
throws CannotProvideStructureSchema {
if (!this.getCurrentSchema().containsDefinition(serializationType)) {
throw new CannotProvideStructureSchema(serializationType, this.getCurrentUnresolvableTypes());
}
return this.getCurrentSchema().getDefinition(serializationType);
}
@Override
public StructureSchema provideSchema() {
return this.getCurrentSchema();
}
@Override
public boolean containsSchema(String serializationType) {
return this.getCurrentSchema().containsDefinition(serializationType);
}
@Override
public List<UnresolvableType> provideUnresolvableTypes() {
return this.getCurrentUnresolvableTypes();
}
@Override
public List<UnresolvableType> add(StructureDefinitionData structureDefinitionData) {
return this.add(List.of(structureDefinitionData));
}
@Override
public List<UnresolvableType> add(StructureDefinitionData... structureDefinitionData) {
return this.add(Arrays.stream(structureDefinitionData).toList());
}
@Override
public List<UnresolvableType> add(List<StructureDefinitionData> structureDefinitionData) {
var mixedDefinitions = this.mixItWithPreviouslyFailed(structureDefinitionData);
var outcome = this.structureDefinitionToSSMapper.map(
mixedDefinitions,
getCurrentSchema()
);
this.scopeCacher.recompute(
DefaultStructureSchemaProvider.class,
new MappingOutcome(
new StructureSchema(),
List.of(),
List.of()
),
(scope, previous) -> new MappingOutcome(
previous.structureSchema().merge(outcome.structureSchema()),
outcome.unresolvableTypes(),
outcome.successfullyMappedTypes()
)
);
this.tryAddFailedTypes(outcome.successfullyMappedTypes());
return this.getCurrentUnresolvableTypes();
}
public List<UnresolvableType> getCurrentFailedTypes() {
return this.getCurrentUnresolvableTypes();
}
private void tryAddFailedTypes(List<String> successfullyAddedTypes) {
if (this.getCurrentUnresolvableTypes().isEmpty()) {
return;
}
if (successfullyAddedTypes.isEmpty()) {
return;
}
var failed = this.getCurrentUnresolvableTypes().stream()
.map(UnresolvableType::structureDefinitionData)
.toList();
this.scopeCacher.recompute(
DefaultStructureSchemaProvider.class,
new MappingOutcome(
new StructureSchema(),
List.of(),
List.of()
),
(scope, previous) -> new MappingOutcome(
previous.structureSchema(),
new ArrayList<>(),
previous.successfullyMappedTypes()
)
);
this.add(failed);
}
private List<StructureDefinitionData> mixItWithPreviouslyFailed(
List<StructureDefinitionData> structureDefinitionData
) {
var joinedStructures = new ConcurrentHashMap<String, StructureDefinitionData>();
this.getCurrentUnresolvableTypes().stream()
.map(UnresolvableType::structureDefinitionData)
.forEach(
structureDefinitionDTO -> joinedStructures.put(structureDefinitionDTO.getId(),
structureDefinitionDTO)
);
structureDefinitionData.forEach(
structureDefinitionDTO -> {
if (joinedStructures.containsKey(structureDefinitionDTO.getId())) {
joinedStructures.put(structureDefinitionDTO.getId(),
StructureDefinitionDataMerger.merge(
joinedStructures.get(structureDefinitionDTO.getId()),
structureDefinitionDTO
)
);
} else {
joinedStructures.put(structureDefinitionDTO.getId(), structureDefinitionDTO);
}
}
);
return joinedStructures.values().stream().toList();
}
private MappingOutcome getCurrentOutcome() {
return this.scopeCacher.getCachedOrCompute(
DefaultStructureSchemaProvider.class,
scope -> this.structureDefinitionToSSMapper.map(
this.structureDefinitionLoader.load()
)
);
}
private StructureSchema getCurrentSchema() {
return this.getCurrentOutcome().structureSchema();
}
private List<UnresolvableType> getCurrentUnresolvableTypes() {
return this.getCurrentOutcome().unresolvableTypes();
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchemaProvider/RestrictedStructureSchemaFinder.java | package ai.stapi.schema.structureSchemaProvider;
import ai.stapi.schema.structureSchema.AbstractStructureType;
import ai.stapi.schema.structureSchema.FieldDefinition;
import ai.stapi.schema.structureSchema.ResourceStructureType;
import ai.stapi.schema.structureSchema.exception.FieldsNotFoundException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.jetbrains.annotations.NotNull;
public class RestrictedStructureSchemaFinder implements StructureSchemaFinder {
@Override
public boolean isList(String serializationType, String fieldName) throws FieldsNotFoundException {
return this.getFieldDefinitionFor(serializationType, fieldName).isList();
}
@Override
public boolean containsType(String rootType, String typeToBeFound) {
return false;
}
@Override
public AbstractStructureType getStructureType(String serializationType) {
throw FieldsNotFoundException.becauseFinderIsRestricted(serializationType);
}
@Override
public Map<String, FieldDefinition> getFieldDefinitionsFor(
String serializationType,
List<String> fieldNames
) throws FieldsNotFoundException {
throw FieldsNotFoundException.becauseFinderIsRestricted(serializationType, fieldNames);
}
@Override
public FieldDefinition getFieldDefinitionFor(
String serializationType,
String fieldName
) throws FieldsNotFoundException {
return this.getFieldDefinitionsFor(serializationType, List.of(fieldName)).get(fieldName);
}
@Override
public Map<String, FieldDefinition> getAllFieldDefinitionsFor(
String serializationType
) throws FieldsNotFoundException {
throw FieldsNotFoundException.becauseFinderIsRestricted(serializationType);
}
@NotNull
@Override
public HashMap<String, FieldDefinition> getFieldDefinitionHashMap(Map<?, ?> attributes,
String serializationType) {
throw FieldsNotFoundException.becauseFinderIsRestricted(serializationType);
}
@Override
public boolean isResource(String serializationType) {
throw FieldsNotFoundException.becauseFinderIsRestricted(serializationType);
}
@Override
public boolean structureExists(String serializationType) {
return false;
}
@Override
public AbstractStructureType getSchemaStructure(String serializationType) {
throw FieldsNotFoundException.becauseFinderIsRestricted(serializationType);
}
@Override
public FieldDefinition getFieldDefinitionOrFallback(String serializationType, String fieldName) {
throw FieldsNotFoundException.becauseFinderIsRestricted(serializationType);
}
@Override
public List<ResourceStructureType> getAllResources() {
return List.of();
}
@Override
public boolean inherits(String serializationType, String inheritedSerializationType) {
return false;
}
@Override
public boolean isEqualOrInherits(String serializationType, String inheritedSerializationType) {
return false;
}
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchemaProvider/StructureSchemaFinder.java | package ai.stapi.schema.structureSchemaProvider;
import ai.stapi.schema.structureSchema.AbstractStructureType;
import ai.stapi.schema.structureSchema.FieldDefinition;
import ai.stapi.schema.structureSchema.ResourceStructureType;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.jetbrains.annotations.NotNull;
public interface StructureSchemaFinder {
boolean isList(String serializationType, String fieldName);
boolean containsType(String rootType, String typeToBeFound);
AbstractStructureType getStructureType(String serializationType);
Map<String, FieldDefinition> getFieldDefinitionsFor(
String serializationType,
List<String> fieldNames
);
FieldDefinition getFieldDefinitionFor(
String serializationType,
String fieldName
);
Map<String, FieldDefinition> getAllFieldDefinitionsFor(
String serializationType
);
@NotNull
HashMap<String, FieldDefinition> getFieldDefinitionHashMap(
Map<?, ?> attributes,
String serializationType
);
boolean isResource(String serializationType);
boolean structureExists(String serializationType);
AbstractStructureType getSchemaStructure(String serializationType);
FieldDefinition getFieldDefinitionOrFallback(String serializationType, String fieldName);
List<ResourceStructureType> getAllResources();
boolean inherits(
String serializationType,
String inheritedSerializationType
);
boolean isEqualOrInherits(
String serializationType,
String inheritedSerializationType
);
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchemaProvider/StructureSchemaProvider.java | package ai.stapi.schema.structureSchemaProvider;
import ai.stapi.schema.structureSchema.AbstractStructureType;
import ai.stapi.schema.structureSchema.StructureSchema;
import ai.stapi.schema.structureSchemaMapper.UnresolvableType;
import ai.stapi.schema.structureSchemaProvider.exception.CannotProvideStructureSchema;
import ai.stapi.schema.structuredefinition.StructureDefinitionData;
import java.util.List;
public interface StructureSchemaProvider {
AbstractStructureType provideSpecific(String serializationType)
throws CannotProvideStructureSchema;
boolean containsSchema(String serializationType);
StructureSchema provideSchema();
List<UnresolvableType> provideUnresolvableTypes();
List<UnresolvableType> add(StructureDefinitionData structureDefinitionData);
List<UnresolvableType> add(List<StructureDefinitionData> structureDefinitionData);
List<UnresolvableType> add(StructureDefinitionData... structureDefinitionData);
}
|
0 | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchemaProvider | java-sources/ai/stapi/schema/0.3.2/ai/stapi/schema/structureSchemaProvider/exception/CannotProvideStructureSchema.java | package ai.stapi.schema.structureSchemaProvider.exception;
import ai.stapi.schema.structureSchemaMapper.UnresolvableType;
import java.util.List;
import org.apache.commons.lang3.StringUtils;
import org.jetbrains.annotations.NotNull;
public class CannotProvideStructureSchema extends Exception {
private final String missingSerializationType;
public CannotProvideStructureSchema(
String missingSerializationType,
List<UnresolvableType> unresolvableTypes
) {
super(createMessage(missingSerializationType, unresolvableTypes).toString());
this.missingSerializationType = missingSerializationType;
}
@NotNull
private static StringBuilder createMessage(
String missingSerializationType,
List<UnresolvableType> unresolvableTypes
) {
var errorMessage = new StringBuilder()
.append("Structure schema for serialization type '")
.append(missingSerializationType)
.append("' not found.")
.append(System.lineSeparator())
.append("Current pending unresolvable types: ");
unresolvableTypes.forEach(unresolvable -> {
errorMessage
.append(System.lineSeparator())
.append("Failed type: '")
.append(unresolvable.structureDefinitionData().getId())
.append("', ")
.append("missing dependencies: [")
.append(StringUtils.join(unresolvable.missingDependencies(), ", "))
.append("]");
});
return errorMessage;
}
public String getMissingSerializationType() {
return missingSerializationType;
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.