private void MergeNextType(
            ISchemaMergeContext context,
            List <IDirectiveTypeInfo> notMerged)
        {
            IDirectiveTypeInfo left = notMerged[0];

            var readyToMerge = new List <IDirectiveTypeInfo>();

            readyToMerge.Add(left);

            for (int i = 1; i < notMerged.Count; i++)
            {
                if (CanBeMerged(left.Definition, notMerged[i].Definition))
                {
                    readyToMerge.Add(notMerged[i]);
                }
            }

            NameString name = readyToMerge[0].Definition.Name.Value;

            if (context.ContainsDirective(name))
            {
                throw new InvalidOperationException($"Unable to merge {name}, directive with this name already exists.");
            }

            MergeTypes(context, readyToMerge, name);
            notMerged.RemoveAll(readyToMerge.Contains);
        }
Ejemplo n.º 2
0
        public void Merge(
            ISchemaMergeContext context,
            IReadOnlyList <ITypeInfo> types)
        {
            if (types.OfType <UnionTypeInfo>().Any())
            {
                var  notMerged    = types.OfType <UnionTypeInfo>().ToList();
                bool hasLeftovers = types.Count > notMerged.Count;

                for (int i = 0; i < notMerged.Count; i++)
                {
                    context.AddType(notMerged[i].Definition.Rename(
                                        TypeMergeHelpers.CreateName(context, notMerged[i]),
                                        notMerged[i].Schema.Name));
                }

                if (hasLeftovers)
                {
                    _next.Invoke(context, types.NotOfType <UnionTypeInfo>());
                }
            }
            else
            {
                _next.Invoke(context, types);
            }
        }
Ejemplo n.º 3
0
        private void MergeNextType(
            ISchemaMergeContext context,
            List <T> notMerged)
        {
            T left = notMerged[0];

            var readyToMerge = new List <T>();

            readyToMerge.Add(left);

            for (int i = 1; i < notMerged.Count; i++)
            {
                if (CanBeMerged(left, notMerged[i]))
                {
                    readyToMerge.Add(notMerged[i]);
                }
            }

            NameString newTypeName =
                TypeMergeHelpers.CreateName <T>(
                    context, readyToMerge);

            MergeTypes(context, readyToMerge, newTypeName);
            notMerged.RemoveAll(readyToMerge.Contains);
        }
Ejemplo n.º 4
0
 public void Merge(
     ISchemaMergeContext context,
     IReadOnlyList <IDirectiveTypeInfo> directives)
 {
     context.AddDirective(
         directives.First(t =>
                          t.Definition.Arguments.Any()).Definition);
 }
        public void Merge(
            ISchemaMergeContext context,
            IReadOnlyList <IDirectiveTypeInfo> types)
        {
            var notMerged = types.ToList();

            while (notMerged.Count > 0)
            {
                MergeNextType(context, notMerged);
            }
        }
Ejemplo n.º 6
0
        public void Merge(
            ISchemaMergeContext context,
            IReadOnlyList <ITypeInfo> types)
        {
            IReadOnlyList <ITypeInfo> unhandled =
                types.OfType <ScalarTypeInfo>().Any()
                    ? types.NotOfType <ScalarTypeInfo>()
                    : types;

            _next.Invoke(context, unhandled);
        }
Ejemplo n.º 7
0
            public void Merge(
                ISchemaMergeContext context,
                IReadOnlyList <ITypeInfo> types)
            {
                var typeInfos = types.OfType <ObjectTypeInfo>().ToArray();
                var fields    = typeInfos[0].Definition.Fields.ToList();

                fields.AddRange(typeInfos[1].Definition.Fields);
                context.AddType(
                    typeInfos[0].Definition.WithFields(fields));
            }
Ejemplo n.º 8
0
 public void Merge(
     ISchemaMergeContext context,
     IReadOnlyList <HotChocolate.Stitching.Merge.ITypeInfo> types)
 {
     if (types.OfType <ITypeInfo <ScalarTypeDefinitionNode> >().Any())
     {
         ITypeInfo <ScalarTypeDefinitionNode> scalar =
             types.OfType <ITypeInfo <ScalarTypeDefinitionNode> >().FirstOrDefault();
         context.AddType(scalar.Definition);
         return;
     }
     _next(context, types);
 }
Ejemplo n.º 9
0
        private void MergeTypes(
            ISchemaMergeContext context,
            ISet <string> typeNames,
            IReadOnlyCollection <ISchemaInfo> schemas,
            MergeTypeRuleDelegate merge)
        {
            var types = new List <ITypeInfo>();

            foreach (string typeName in typeNames)
            {
                SetTypes(typeName, schemas, types);
                merge(context, types);
            }
        }
Ejemplo n.º 10
0
        private void MergeDirectives(
            ISchemaMergeContext context,
            ISet <string> typeNames,
            IEnumerable <ISchemaInfo> schemas,
            MergeDirectiveRuleDelegate merge)
        {
            var directives = new List <IDirectiveTypeInfo>();

            foreach (string typeName in typeNames)
            {
                SetDirectives(typeName, schemas, directives);
                merge(context, directives);
            }
        }
        protected override void MergeTypes(
            ISchemaMergeContext context,
            IReadOnlyList <InputObjectTypeInfo> types,
            NameString newTypeName)
        {
            List <InputObjectTypeDefinitionNode> definitions = types
                                                               .Select(t => t.Definition)
                                                               .ToList();

            InputObjectTypeDefinitionNode definition =
                definitions[0].Rename(
                    newTypeName,
                    types.Select(t => t.Schema.Name));

            context.AddType(definition);
        }
        protected void MergeTypes(
            ISchemaMergeContext context,
            IReadOnlyList <IDirectiveTypeInfo> types,
            NameString newTypeName)
        {
            var definitions = types
                              .Select(t => t.Definition)
                              .ToList();

            DirectiveDefinitionNode definition =
                definitions[0].Rename(
                    newTypeName,
                    types.Select(t => t.Schema.Name));

            context.AddDirective(definition);
        }
Ejemplo n.º 13
0
        private static void MergeType(
            ISchemaMergeContext context,
            IReadOnlyList <EnumTypeInfo> types)
        {
            var definition = types[0].Definition;

            EnumTypeDefinitionNode descriptionDef =
                types.Select(t => t.Definition)
                .FirstOrDefault(t => t.Description != null);

            if (descriptionDef != null)
            {
                definition = definition.WithDescription(
                    descriptionDef.Description);
            }

            context.AddType(definition.Rename(
                                TypeMergeHelpers.CreateName(context, types),
                                types.Select(t => t.Schema.Name)));
        }
Ejemplo n.º 14
0
        protected override void MergeTypes(
            ISchemaMergeContext context,
            IReadOnlyList <ObjectTypeInfo> types,
            NameString newTypeName)
        {
            List <ObjectTypeDefinitionNode> definitions = types
                                                          .Select(t => t.Definition)
                                                          .ToList();

            // ? : how do we handle the interfaces correctly
            var interfaces = new HashSet <string>(
                definitions.SelectMany(d =>
                                       d.Interfaces.Select(t => t.Name.Value)));

            ObjectTypeDefinitionNode definition = definitions[0]
                                                  .WithInterfaces(interfaces.Select(t =>
                                                                                    new NamedTypeNode(new NameNode(t))).ToList())
                                                  .Rename(newTypeName, types.Select(t => t.Schema.Name));

            context.AddType(definition);
        }
Ejemplo n.º 15
0
        private static void MergeRootType(
            ISchemaMergeContext context,
            OperationType operation,
            IEnumerable <ISchemaInfo> schemas,
            MergeTypeRuleDelegate merge)
        {
            var types = new List <TypeInfo>();

            foreach (ISchemaInfo schema in schemas)
            {
                ObjectTypeDefinitionNode rootType = schema.GetRootType(operation);
                if (rootType is not null)
                {
                    types.Add(new ObjectTypeInfo(rootType, schema));
                }
            }

            if (types.Count > 0)
            {
                merge(context, types);
            }
        }
Ejemplo n.º 16
0
        public void Merge(
            ISchemaMergeContext context,
            IReadOnlyList <ITypeInfo> types)
        {
            if (types.Count > 0)
            {
                if (types[0].IsRootType)
                {
                    var names  = new HashSet <string>();
                    var fields = new List <FieldDefinitionNode>();

                    foreach (ObjectTypeInfo type in
                             types.OfType <ObjectTypeInfo>())
                    {
                        IntegrateFields(type.Definition, type, names, fields);
                    }

                    if (types[0].Schema.TryGetOperationType(
                            (ObjectTypeDefinitionNode)types[0].Definition,
                            out OperationType operationType))
                    {
                        var mergedRootType = new ObjectTypeDefinitionNode
                                             (
                            null,
                            new NameNode(operationType.ToString()),
                            null,
                            Array.Empty <DirectiveNode>(),
                            Array.Empty <NamedTypeNode>(),
                            fields
                                             );
                        context.AddType(mergedRootType);
                    }
                }
                else
                {
                    _next.Invoke(context, types);
                }
            }
        }
Ejemplo n.º 17
0
        private static void MergeNextType(
            ISchemaMergeContext context,
            List <EnumTypeInfo> notMerged)
        {
            EnumTypeInfo left = notMerged[0];

            var leftValueSet = new HashSet <string>(
                left.Definition.Values.Select(t => t.Name.Value));

            var readyToMerge = new List <EnumTypeInfo>();

            readyToMerge.Add(left);

            for (int i = 1; i < notMerged.Count; i++)
            {
                if (CanBeMerged(leftValueSet, notMerged[i].Definition))
                {
                    readyToMerge.Add(notMerged[i]);
                }
            }

            MergeType(context, readyToMerge);
            notMerged.RemoveAll(readyToMerge.Contains);
        }
Ejemplo n.º 18
0
        public void Merge(
            ISchemaMergeContext context,
            IReadOnlyList <ITypeInfo> types)
        {
            if (types.OfType <EnumTypeInfo>().Any())
            {
                var  notMerged    = types.OfType <EnumTypeInfo>().ToList();
                bool hasLeftovers = types.Count > notMerged.Count;

                while (notMerged.Count > 0)
                {
                    MergeNextType(context, notMerged);
                }

                if (hasLeftovers)
                {
                    _next.Invoke(context, types.NotOfType <EnumTypeInfo>());
                }
            }
            else
            {
                _next.Invoke(context, types);
            }
        }
Ejemplo n.º 19
0
        public static NameString CreateName <T>(
            ISchemaMergeContext context,
            IReadOnlyList <T> types)
            where T : ITypeInfo
        {
            NameString name = types[0].Definition.Name.Value;

            if (context.ContainsType(name))
            {
                for (int i = 0; i < types.Count; i++)
                {
                    name = types[i].CreateUniqueName();
                    if (!context.ContainsType(name))
                    {
                        break;
                    }
                }

                if (context.ContainsType(name))
                {
                    name = types[0].Definition.Name.Value;

                    for (int i = 0; i < _maxRetries; i++)
                    {
                        NameString n = name + $"_{i}";
                        if (!context.ContainsType(name))
                        {
                            name = n;
                            break;
                        }
                    }
                }
            }

            return(name);
        }
Ejemplo n.º 20
0
 public static NameString CreateName <T>(
     ISchemaMergeContext context,
     params T[] types)
     where T : ITypeInfo =>
 CreateName(context, (IReadOnlyList <T>)types);
Ejemplo n.º 21
0
 protected abstract void MergeTypes(
     ISchemaMergeContext context,
     IReadOnlyList <T> types,
     NameString newTypeName);