@gapi/core 1.8.177 → 1.8.179

package/dist/federation.controller.js

@@ -21,18 +21,13 @@ let FederationController = class FederationController {
             query: appSchema.graphqlOptions.schema.getQueryType(),
             mutation: appSchema.graphqlOptions.schema.getMutationType(),
         });
-        let replacer = tokens_1.FedarationReplacer;
-        try {
-            replacer = core_1.Container.get(tokens_1.GRAPHQL_FEDERATION_REPLACER);
-        }
-        catch (e) {
-            console.error(e);
-        }
         const sdl = (0, graphql_2.printSchema)(schema)
             .replace('_service: GraphqlFederation', '')
             .replace('status: StatusQueryType', '');
         return {
-            sdl: replacer(sdl),
+            sdl: core_1.Container.has(tokens_1.GRAPHQL_FEDERATION_REPLACER)
+                ? core_1.Container.get(tokens_1.GRAPHQL_FEDERATION_REPLACER)(sdl)
+                : (0, tokens_1.FedarationReplacer)(sdl),
         };
     }
 };

package/dist/geojson.types.d.ts

@@ -0,0 +1 @@
+export declare const GeoJSON: any;

package/dist/geojson.types.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeoJSON = void 0;
+const graphql_1 = require("graphql");
+exports.GeoJSON = {
+    TypeEnum: new graphql_1.GraphQLEnumType({
+        name: 'GeoJSONType',
+        description: 'Enumeration of all GeoJSON object types.',
+        values: {
+            Point: { value: 'Point' },
+            MultiPoint: { value: 'MultiPoint' },
+            LineString: { value: 'LineString' },
+            MultiLineString: { value: 'MultiLineString' },
+            Polygon: { value: 'Polygon' },
+            MultiPolygon: { value: 'MultiPolygon' },
+            GeometryCollection: { value: 'GeometryCollection' },
+            Feature: { value: 'Feature' },
+            FeatureCollection: { value: 'FeatureCollection' },
+        },
+    }),
+    CoordinatesScalar: new graphql_1.GraphQLScalarType({
+        name: 'GeoJSONCoordinates',
+        description: 'A (multidimensional) set of coordinates following x, y, z order.',
+        serialize: coerceCoordinates,
+        parseValue: coerceCoordinates,
+        parseLiteral: parseCoordinates,
+    }),
+    JsonScalar: new graphql_1.GraphQLScalarType({
+        name: 'JSONObject',
+        description: 'Arbitrary JSON value',
+        serialize: coerceObject,
+        parseValue: coerceObject,
+        parseLiteral: parseObject,
+    }),
+    PointObject: new graphql_1.GraphQLObjectType({
+        name: 'GeoJSONPoint',
+        description: 'Object describing a single geographical point.',
+        interfaces: () => [exports.GeoJSON.GeoJSONInterface, exports.GeoJSON.GeometryInterface],
+        fields: () => ({
+            type: { type: new graphql_1.GraphQLNonNull(exports.GeoJSON.TypeEnum) },
+            crs: {
+                type: new graphql_1.GraphQLNonNull(exports.GeoJSON.CoordinateReferenceSystemObject),
+            },
+            bbox: { type: new graphql_1.GraphQLList(graphql_1.GraphQLFloat) },
+            coordinates: { type: exports.GeoJSON.CoordinatesScalar },
+        }),
+    }),
+    MultiPointObject: new graphql_1.GraphQLObjectType({
+        name: 'GeoJSONMultiPoint',
+        description: 'Object describing multiple geographical points.',
+        interfaces: () => [exports.GeoJSON.GeoJSONInterface, exports.GeoJSON.GeometryInterface],
+        fields: () => ({
+            type: { type: new graphql_1.GraphQLNonNull(exports.GeoJSON.TypeEnum) },
+            crs: {
+                type: new graphql_1.GraphQLNonNull(exports.GeoJSON.CoordinateReferenceSystemObject),
+            },
+            bbox: { type: new graphql_1.GraphQLList(graphql_1.GraphQLFloat) },
+            coordinates: { type: exports.GeoJSON.CoordinatesScalar },
+        }),
+    }),
+    LineStringObject: new graphql_1.GraphQLObjectType({
+        name: 'GeoJSONLineString',
+        description: 'Object describing a single connected sequence of geographical points.',
+        interfaces: () => [exports.GeoJSON.GeoJSONInterface, exports.GeoJSON.GeometryInterface],
+        fields: () => ({
+            type: { type: new graphql_1.GraphQLNonNull(exports.GeoJSON.TypeEnum) },
+            crs: {
+                type: new graphql_1.GraphQLNonNull(exports.GeoJSON.CoordinateReferenceSystemObject),
+            },
+            bbox: { type: new graphql_1.GraphQLList(graphql_1.GraphQLFloat) },
+            coordinates: { type: exports.GeoJSON.CoordinatesScalar },
+        }),
+    }),
+    MultiLineStringObject: new graphql_1.GraphQLObjectType({
+        name: 'GeoJSONMultiLineString',
+        description: 'Object describing multiple connected sequences of geographical points.',
+        interfaces: () => [exports.GeoJSON.GeoJSONInterface, exports.GeoJSON.GeometryInterface],
+        fields: () => ({
+            type: { type: new graphql_1.GraphQLNonNull(exports.GeoJSON.TypeEnum) },
+            crs: {
+                type: new graphql_1.GraphQLNonNull(exports.GeoJSON.CoordinateReferenceSystemObject),
+            },
+            bbox: { type: new graphql_1.GraphQLList(graphql_1.GraphQLFloat) },
+            coordinates: { type: exports.GeoJSON.CoordinatesScalar },
+        }),
+    }),
+    PolygonObject: new graphql_1.GraphQLObjectType({
+        name: 'GeoJSONPolygon',
+        description: 'Object describing a single shape formed by a set of geographical points.',
+        interfaces: () => [exports.GeoJSON.GeoJSONInterface, exports.GeoJSON.GeometryInterface],
+        fields: () => ({
+            type: { type: new graphql_1.GraphQLNonNull(exports.GeoJSON.TypeEnum) },
+            crs: {
+                type: new graphql_1.GraphQLNonNull(exports.GeoJSON.CoordinateReferenceSystemObject),
+            },
+            bbox: { type: new graphql_1.GraphQLList(graphql_1.GraphQLFloat) },
+            coordinates: { type: exports.GeoJSON.CoordinatesScalar },
+        }),
+    }),
+    MultiPolygonObject: new graphql_1.GraphQLObjectType({
+        name: 'GeoJSONMultiPolygon',
+        description: 'Object describing multiple shapes formed by sets of geographical points.',
+        interfaces: () => [exports.GeoJSON.GeoJSONInterface, exports.GeoJSON.GeometryInterface],
+        fields: () => ({
+            type: { type: new graphql_1.GraphQLNonNull(exports.GeoJSON.TypeEnum) },
+            crs: {
+                type: new graphql_1.GraphQLNonNull(exports.GeoJSON.CoordinateReferenceSystemObject),
+            },
+            bbox: { type: new graphql_1.GraphQLList(graphql_1.GraphQLFloat) },
+            coordinates: { type: exports.GeoJSON.CoordinatesScalar },
+        }),
+    }),
+    GeometryCollectionObject: new graphql_1.GraphQLObjectType({
+        name: 'GeoJSONGeometryCollection',
+        description: 'A set of multiple geometries, possibly of various types.',
+        interfaces: () => [exports.GeoJSON.GeoJSONInterface],
+        fields: () => ({
+            type: { type: new graphql_1.GraphQLNonNull(exports.GeoJSON.TypeEnum) },
+            crs: {
+                type: new graphql_1.GraphQLNonNull(exports.GeoJSON.CoordinateReferenceSystemObject),
+            },
+            bbox: { type: new graphql_1.GraphQLList(graphql_1.GraphQLFloat) },
+            geometries: {
+                type: new graphql_1.GraphQLNonNull(new graphql_1.GraphQLList(new graphql_1.GraphQLNonNull(exports.GeoJSON.GeometryInterface))),
+            },
+        }),
+    }),
+    FeatureObject: new graphql_1.GraphQLObjectType({
+        name: 'GeoJSONFeature',
+        description: 'An object that links a geometry to properties in order to provide context.',
+        interfaces: () => [exports.GeoJSON.GeoJSONInterface],
+        fields: () => ({
+            type: { type: new graphql_1.GraphQLNonNull(exports.GeoJSON.TypeEnum) },
+            crs: {
+                type: new graphql_1.GraphQLNonNull(exports.GeoJSON.CoordinateReferenceSystemObject),
+            },
+            bbox: { type: new graphql_1.GraphQLList(graphql_1.GraphQLFloat) },
+            geometry: { type: exports.GeoJSON.GeometryInterface },
+            properties: { type: exports.GeoJSON.JsonScalar },
+            id: { type: graphql_1.GraphQLString },
+        }),
+    }),
+    FeatureCollectionObject: new graphql_1.GraphQLObjectType({
+        name: 'GeoJSONFeatureCollection',
+        description: 'A set of multiple features.',
+        interfaces: () => [exports.GeoJSON.GeoJSONInterface],
+        fields: () => ({
+            type: { type: new graphql_1.GraphQLNonNull(exports.GeoJSON.TypeEnum) },
+            crs: {
+                type: new graphql_1.GraphQLNonNull(exports.GeoJSON.CoordinateReferenceSystemObject),
+            },
+            bbox: { type: new graphql_1.GraphQLList(graphql_1.GraphQLFloat) },
+            features: {
+                type: new graphql_1.GraphQLNonNull(new graphql_1.GraphQLList(new graphql_1.GraphQLNonNull(exports.GeoJSON.FeatureObject))),
+            },
+        }),
+    }),
+    CRSTypeEnum: new graphql_1.GraphQLEnumType({
+        name: 'GeoJSONCRSType',
+        description: 'Enumeration of all GeoJSON CRS object types.',
+        values: {
+            name: { value: 'name' },
+            link: { value: 'link' },
+        },
+    }),
+    NamedCRSPropertiesObject: new graphql_1.GraphQLObjectType({
+        name: 'GeoJSONNamedCRSProperties',
+        description: 'Properties for name based CRS object.',
+        fields: () => ({
+            name: { type: new graphql_1.GraphQLNonNull(graphql_1.GraphQLString) },
+        }),
+    }),
+    LinkedCRSPropertiesObject: new graphql_1.GraphQLObjectType({
+        name: 'GeoJSONLinkedCRSProperties',
+        description: 'Properties for link based CRS object.',
+        fields: () => ({
+            href: { type: new graphql_1.GraphQLNonNull(graphql_1.GraphQLString) },
+            type: { type: graphql_1.GraphQLString },
+        }),
+    }),
+    CRSPropertiesUnion: new graphql_1.GraphQLUnionType({
+        name: 'GeoJSONCRSProperties',
+        description: 'CRS object properties.',
+        types: () => [
+            exports.GeoJSON.NamedCRSPropertiesObject,
+            exports.GeoJSON.LinkedCRSPropertiesObject,
+        ],
+        resolveType: (value) => {
+            if (value.name)
+                return exports.GeoJSON.NamedCRSPropertiesObject;
+            if (value.href)
+                return exports.GeoJSON.LinkedCRSPropertiesObject;
+        },
+    }),
+    CoordinateReferenceSystemObject: new graphql_1.GraphQLObjectType({
+        name: 'GeoJSONCoordinateReferenceSystem',
+        description: 'Coordinate Reference System (CRS) object.',
+        fields: () => ({
+            type: { type: new graphql_1.GraphQLNonNull(exports.GeoJSON.CRSTypeEnum) },
+            properties: { type: new graphql_1.GraphQLNonNull(exports.GeoJSON.CRSPropertiesUnion) },
+        }),
+    }),
+    GeoJSONInterface: new graphql_1.GraphQLInterfaceType({
+        name: 'GeoJSONInterface',
+        fields: () => ({
+            type: { type: new graphql_1.GraphQLNonNull(exports.GeoJSON.TypeEnum) },
+            crs: {
+                type: new graphql_1.GraphQLNonNull(exports.GeoJSON.CoordinateReferenceSystemObject),
+            },
+            bbox: { type: new graphql_1.GraphQLList(graphql_1.GraphQLFloat) },
+        }),
+        resolveType: (value) => exports.GeoJSON[`${value.type}Object`],
+    }),
+    GeometryInterface: new graphql_1.GraphQLInterfaceType({
+        name: 'GeoJSONGeometryInterface',
+        fields: () => ({
+            type: { type: new graphql_1.GraphQLNonNull(exports.GeoJSON.TypeEnum) },
+            crs: {
+                type: new graphql_1.GraphQLNonNull(exports.GeoJSON.CoordinateReferenceSystemObject),
+            },
+            bbox: { type: new graphql_1.GraphQLList(graphql_1.GraphQLFloat) },
+            coordinates: { type: exports.GeoJSON.CoordinatesScalar },
+        }),
+        resolveType: (value) => exports.GeoJSON[`${value.type}Object`],
+    }),
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function coerceCoordinates(value) {
+    return value;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function parseCoordinates(valueAST) {
+    return valueAST.value;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function coerceObject(value) {
+    return JSON.parse(value);
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function parseObject(valueAST) {
+    return JSON.stringify(valueAST.value);
+}

package/dist/index.d.ts

@@ -1,18 +1,10 @@
-import { DaemonConfig } from '@gapi/daemon';
 import { ModuleWithServices } from '@rxdi/core';
-import { GRAPHQL_PLUGIN_CONFIG } from '@rxdi/graphql';
-import { GRAPHQL_PUB_SUB_DI_CONFIG } from '@rxdi/graphql-pubsub';
-import { HapiConfigModel } from '@rxdi/hapi';
-export interface CoreModuleConfig {
-    server?: HapiConfigModel;
-    graphql?: GRAPHQL_PLUGIN_CONFIG;
-    pubsub?: GRAPHQL_PUB_SUB_DI_CONFIG;
-    daemon?: DaemonConfig;
-}
+import { CoreModuleConfig } from './tokens';
 export declare class CoreModule {
     static forRoot(config?: CoreModuleConfig): ModuleWithServices;
 }
 export * from './enum-to-gql';
+export { GeoJSON } from './geojson.types';
 export * from '@rxdi/core';
 export * from '@rxdi/graphql';
 export * from '@rxdi/graphql-pubsub';
@@ -20,6 +12,4 @@ export { withFilter } from '@rxdi/graphql-rabbitmq-subscriptions';
 export * from '@rxdi/hapi';
 export * from 'graphql';
 export { buildSchema, ExecutionResult, extendSchema, isSpecifiedScalarType, } from 'graphql';
-export * from 'graphql-geojson';
 export { FilterFn, PubSubEngine, PubSubOptions, ResolverFn, } from 'graphql-subscriptions';
-export * from 'graphql-tools';

package/dist/index.js

@@ -21,44 +21,23 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 var CoreModule_1;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PubSubEngine = exports.isSpecifiedScalarType = exports.extendSchema = exports.buildSchema = exports.withFilter = exports.CoreModule = void 0;
+exports.PubSubEngine = exports.isSpecifiedScalarType = exports.extendSchema = exports.buildSchema = exports.withFilter = exports.GeoJSON = exports.CoreModule = void 0;
 const daemon_1 = require("@gapi/daemon");
 const core_1 = require("@rxdi/core");
 const graphql_1 = require("@rxdi/graphql");
 const graphql_pubsub_1 = require("@rxdi/graphql-pubsub");
 const hapi_1 = require("@rxdi/hapi");
 const federation_controller_1 = require("./federation.controller");
-const DEFAULT_CONFIG = {
-    server: {
-        hapi: {
-            port: 9000,
-        },
-    },
-    graphql: {
-        path: '/graphql',
-        initQuery: true,
-        writeEffects: false,
-        watcherPort: '',
-        graphqlOptions: {
-            schema: null,
-        },
-        altair: {
-            enabled: true,
-        },
-    },
-    daemon: {
-        activated: false,
-    },
-};
+const tokens_1 = require("./tokens");
 let CoreModule = CoreModule_1 = class CoreModule {
     static forRoot(config) {
-        config = config || DEFAULT_CONFIG;
+        config = config || tokens_1.DEFAULT_CONFIG;
         return {
             module: CoreModule_1,
             controllers: [federation_controller_1.FederationController],
             frameworkImports: [
-                hapi_1.HapiModule.forRoot(Object.assign(Object.assign({}, DEFAULT_CONFIG.server), config.server)),
-                graphql_1.GraphQLModule.forRoot(Object.assign(Object.assign({}, DEFAULT_CONFIG.graphql), config.graphql)),
+                hapi_1.HapiModule.forRoot(Object.assign(Object.assign({}, tokens_1.DEFAULT_CONFIG.server), config.server)),
+                graphql_1.GraphQLModule.forRoot(Object.assign(Object.assign({}, tokens_1.DEFAULT_CONFIG.graphql), config.graphql)),
                 graphql_pubsub_1.GraphQLPubSubModule.forRoot(config.pubsub),
                 daemon_1.DaemonModule.forRoot(config.daemon),
             ],
@@ -70,6 +49,8 @@ exports.CoreModule = CoreModule = CoreModule_1 = __decorate([
     (0, core_1.Module)()
 ], CoreModule);
 __exportStar(require("./enum-to-gql"), exports);
+var geojson_types_1 = require("./geojson.types");
+Object.defineProperty(exports, "GeoJSON", { enumerable: true, get: function () { return geojson_types_1.GeoJSON; } });
 __exportStar(require("@rxdi/core"), exports);
 __exportStar(require("@rxdi/graphql"), exports);
 __exportStar(require("@rxdi/graphql-pubsub"), exports);
@@ -81,7 +62,5 @@ var graphql_2 = require("graphql");
 Object.defineProperty(exports, "buildSchema", { enumerable: true, get: function () { return graphql_2.buildSchema; } });
 Object.defineProperty(exports, "extendSchema", { enumerable: true, get: function () { return graphql_2.extendSchema; } });
 Object.defineProperty(exports, "isSpecifiedScalarType", { enumerable: true, get: function () { return graphql_2.isSpecifiedScalarType; } });
-__exportStar(require("graphql-geojson"), exports);
 var graphql_subscriptions_1 = require("graphql-subscriptions");
 Object.defineProperty(exports, "PubSubEngine", { enumerable: true, get: function () { return graphql_subscriptions_1.PubSubEngine; } });
-__exportStar(require("graphql-tools"), exports);

package/dist/tokens.d.ts

@@ -1,3 +1,14 @@
+import { DaemonConfig } from '@gapi/daemon';
 import { InjectionToken } from '@rxdi/core';
+import { GRAPHQL_PLUGIN_CONFIG } from '@rxdi/graphql';
+import { GRAPHQL_PUB_SUB_DI_CONFIG } from '@rxdi/graphql-pubsub';
+import { HapiConfigModel } from '@rxdi/hapi';
 export declare const FedarationReplacer: (v: string) => string;
 export declare const GRAPHQL_FEDERATION_REPLACER: InjectionToken<(v: string) => string>;
+export interface CoreModuleConfig {
+    server?: HapiConfigModel;
+    graphql?: GRAPHQL_PLUGIN_CONFIG;
+    pubsub?: GRAPHQL_PUB_SUB_DI_CONFIG;
+    daemon?: DaemonConfig;
+}
+export declare const DEFAULT_CONFIG: CoreModuleConfig;

package/dist/tokens.js

@@ -1,7 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GRAPHQL_FEDERATION_REPLACER = exports.FedarationReplacer = void 0;
+exports.DEFAULT_CONFIG = exports.GRAPHQL_FEDERATION_REPLACER = exports.FedarationReplacer = void 0;
 const core_1 = require("@rxdi/core");
 const FedarationReplacer = (v) => v;
 exports.FedarationReplacer = FedarationReplacer;
 exports.GRAPHQL_FEDERATION_REPLACER = new core_1.InjectionToken('GRAPHQL_FEDERATION_REPLACER');
+exports.DEFAULT_CONFIG = {
+    server: {
+        hapi: {
+            port: 9000,
+        },
+    },
+    graphql: {
+        path: '/graphql',
+        initQuery: true,
+        writeEffects: false,
+        watcherPort: '',
+        graphqlOptions: {
+            schema: null,
+        },
+        altair: {
+            enabled: true,
+        },
+    },
+    daemon: {
+        activated: false,
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gapi/core",
-  "version": "1.8.177",
+  "version": "1.8.179",
   "repository": {
     "type": "git",
     "url": "https://github.com/Stradivario/gapi.git"
@@ -25,14 +25,12 @@
     "url": "https://github.com/Stradivario/gapi/issues"
   },
   "dependencies": {
-    "@gapi/daemon": "^1.8.176",
+    "@gapi/daemon": "^1.8.178",
     "@rxdi/core": "^0.7.200",
     "@rxdi/graphql": "^0.7.200",
     "@rxdi/graphql-pubsub": "^0.7.200",
     "@rxdi/hapi": "^0.7.200",
-    "graphql": "^16.12.0",
-    "graphql-geojson": "^1.0.0",
-    "graphql-tools": "^5.0.0"
+    "graphql": "^16.12.0"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/federation.controller.ts

@@ -27,17 +27,13 @@ export class FederationController {
       query: appSchema.graphqlOptions.schema.getQueryType(),
       mutation: appSchema.graphqlOptions.schema.getMutationType(),
     });
-    let replacer = FedarationReplacer;
-    try {
-      replacer = Container.get(GRAPHQL_FEDERATION_REPLACER);
-    } catch (e) {
-      console.error(e);
-    }
     const sdl = printSchema(schema)
       .replace('_service: GraphqlFederation', '')
       .replace('status: StatusQueryType', '');
     return {
-      sdl: replacer(sdl),
+      sdl: Container.has(GRAPHQL_FEDERATION_REPLACER)
+        ? Container.get(GRAPHQL_FEDERATION_REPLACER)(sdl)
+        : FedarationReplacer(sdl),
     };
   }
 }

package/src/geojson.types.ts

@@ -0,0 +1,278 @@
+import {
+  GraphQLEnumType,
+  GraphQLFloat,
+  GraphQLInterfaceType,
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLObjectType,
+  GraphQLScalarType,
+  GraphQLString,
+  GraphQLUnionType,
+} from 'graphql';
+
+export const GeoJSON = {
+  TypeEnum: new GraphQLEnumType({
+    name: 'GeoJSONType',
+    description: 'Enumeration of all GeoJSON object types.',
+    values: {
+      Point: { value: 'Point' },
+      MultiPoint: { value: 'MultiPoint' },
+      LineString: { value: 'LineString' },
+      MultiLineString: { value: 'MultiLineString' },
+      Polygon: { value: 'Polygon' },
+      MultiPolygon: { value: 'MultiPolygon' },
+      GeometryCollection: { value: 'GeometryCollection' },
+      Feature: { value: 'Feature' },
+      FeatureCollection: { value: 'FeatureCollection' },
+    },
+  }),
+
+  CoordinatesScalar: new GraphQLScalarType({
+    name: 'GeoJSONCoordinates',
+    description:
+      'A (multidimensional) set of coordinates following x, y, z order.',
+    serialize: coerceCoordinates,
+    parseValue: coerceCoordinates,
+    parseLiteral: parseCoordinates,
+  }),
+
+  JsonScalar: new GraphQLScalarType({
+    name: 'JSONObject',
+    description: 'Arbitrary JSON value',
+    serialize: coerceObject,
+    parseValue: coerceObject,
+    parseLiteral: parseObject,
+  }),
+
+  PointObject: new GraphQLObjectType({
+    name: 'GeoJSONPoint',
+    description: 'Object describing a single geographical point.',
+    interfaces: () => [GeoJSON.GeoJSONInterface, GeoJSON.GeometryInterface],
+    fields: () => ({
+      type: { type: new GraphQLNonNull(GeoJSON.TypeEnum) },
+      crs: {
+        type: new GraphQLNonNull(GeoJSON.CoordinateReferenceSystemObject),
+      },
+      bbox: { type: new GraphQLList(GraphQLFloat) },
+      coordinates: { type: GeoJSON.CoordinatesScalar },
+    }),
+  }),
+
+  MultiPointObject: new GraphQLObjectType({
+    name: 'GeoJSONMultiPoint',
+    description: 'Object describing multiple geographical points.',
+    interfaces: () => [GeoJSON.GeoJSONInterface, GeoJSON.GeometryInterface],
+    fields: () => ({
+      type: { type: new GraphQLNonNull(GeoJSON.TypeEnum) },
+      crs: {
+        type: new GraphQLNonNull(GeoJSON.CoordinateReferenceSystemObject),
+      },
+      bbox: { type: new GraphQLList(GraphQLFloat) },
+      coordinates: { type: GeoJSON.CoordinatesScalar },
+    }),
+  }),
+
+  LineStringObject: new GraphQLObjectType({
+    name: 'GeoJSONLineString',
+    description:
+      'Object describing a single connected sequence of geographical points.',
+    interfaces: () => [GeoJSON.GeoJSONInterface, GeoJSON.GeometryInterface],
+    fields: () => ({
+      type: { type: new GraphQLNonNull(GeoJSON.TypeEnum) },
+      crs: {
+        type: new GraphQLNonNull(GeoJSON.CoordinateReferenceSystemObject),
+      },
+      bbox: { type: new GraphQLList(GraphQLFloat) },
+      coordinates: { type: GeoJSON.CoordinatesScalar },
+    }),
+  }),
+
+  MultiLineStringObject: new GraphQLObjectType({
+    name: 'GeoJSONMultiLineString',
+    description:
+      'Object describing multiple connected sequences of geographical points.',
+    interfaces: () => [GeoJSON.GeoJSONInterface, GeoJSON.GeometryInterface],
+    fields: () => ({
+      type: { type: new GraphQLNonNull(GeoJSON.TypeEnum) },
+      crs: {
+        type: new GraphQLNonNull(GeoJSON.CoordinateReferenceSystemObject),
+      },
+      bbox: { type: new GraphQLList(GraphQLFloat) },
+      coordinates: { type: GeoJSON.CoordinatesScalar },
+    }),
+  }),
+
+  PolygonObject: new GraphQLObjectType({
+    name: 'GeoJSONPolygon',
+    description:
+      'Object describing a single shape formed by a set of geographical points.',
+    interfaces: () => [GeoJSON.GeoJSONInterface, GeoJSON.GeometryInterface],
+    fields: () => ({
+      type: { type: new GraphQLNonNull(GeoJSON.TypeEnum) },
+      crs: {
+        type: new GraphQLNonNull(GeoJSON.CoordinateReferenceSystemObject),
+      },
+      bbox: { type: new GraphQLList(GraphQLFloat) },
+      coordinates: { type: GeoJSON.CoordinatesScalar },
+    }),
+  }),
+
+  MultiPolygonObject: new GraphQLObjectType({
+    name: 'GeoJSONMultiPolygon',
+    description:
+      'Object describing multiple shapes formed by sets of geographical points.',
+    interfaces: () => [GeoJSON.GeoJSONInterface, GeoJSON.GeometryInterface],
+    fields: () => ({
+      type: { type: new GraphQLNonNull(GeoJSON.TypeEnum) },
+      crs: {
+        type: new GraphQLNonNull(GeoJSON.CoordinateReferenceSystemObject),
+      },
+      bbox: { type: new GraphQLList(GraphQLFloat) },
+      coordinates: { type: GeoJSON.CoordinatesScalar },
+    }),
+  }),
+
+  GeometryCollectionObject: new GraphQLObjectType({
+    name: 'GeoJSONGeometryCollection',
+    description: 'A set of multiple geometries, possibly of various types.',
+    interfaces: () => [GeoJSON.GeoJSONInterface],
+    fields: () => ({
+      type: { type: new GraphQLNonNull(GeoJSON.TypeEnum) },
+      crs: {
+        type: new GraphQLNonNull(GeoJSON.CoordinateReferenceSystemObject),
+      },
+      bbox: { type: new GraphQLList(GraphQLFloat) },
+      geometries: {
+        type: new GraphQLNonNull(
+          new GraphQLList(new GraphQLNonNull(GeoJSON.GeometryInterface)),
+        ),
+      },
+    }),
+  }),
+
+  FeatureObject: new GraphQLObjectType({
+    name: 'GeoJSONFeature',
+    description:
+      'An object that links a geometry to properties in order to provide context.',
+    interfaces: () => [GeoJSON.GeoJSONInterface],
+    fields: () => ({
+      type: { type: new GraphQLNonNull(GeoJSON.TypeEnum) },
+      crs: {
+        type: new GraphQLNonNull(GeoJSON.CoordinateReferenceSystemObject),
+      },
+      bbox: { type: new GraphQLList(GraphQLFloat) },
+      geometry: { type: GeoJSON.GeometryInterface },
+      properties: { type: GeoJSON.JsonScalar },
+      id: { type: GraphQLString },
+    }),
+  }),
+
+  FeatureCollectionObject: new GraphQLObjectType({
+    name: 'GeoJSONFeatureCollection',
+    description: 'A set of multiple features.',
+    interfaces: () => [GeoJSON.GeoJSONInterface],
+    fields: () => ({
+      type: { type: new GraphQLNonNull(GeoJSON.TypeEnum) },
+      crs: {
+        type: new GraphQLNonNull(GeoJSON.CoordinateReferenceSystemObject),
+      },
+      bbox: { type: new GraphQLList(GraphQLFloat) },
+      features: {
+        type: new GraphQLNonNull(
+          new GraphQLList(new GraphQLNonNull(GeoJSON.FeatureObject)),
+        ),
+      },
+    }),
+  }),
+
+  CRSTypeEnum: new GraphQLEnumType({
+    name: 'GeoJSONCRSType',
+    description: 'Enumeration of all GeoJSON CRS object types.',
+    values: {
+      name: { value: 'name' },
+      link: { value: 'link' },
+    },
+  }),
+
+  NamedCRSPropertiesObject: new GraphQLObjectType({
+    name: 'GeoJSONNamedCRSProperties',
+    description: 'Properties for name based CRS object.',
+    fields: () => ({
+      name: { type: new GraphQLNonNull(GraphQLString) },
+    }),
+  }),
+
+  LinkedCRSPropertiesObject: new GraphQLObjectType({
+    name: 'GeoJSONLinkedCRSProperties',
+    description: 'Properties for link based CRS object.',
+    fields: () => ({
+      href: { type: new GraphQLNonNull(GraphQLString) },
+      type: { type: GraphQLString },
+    }),
+  }),
+
+  CRSPropertiesUnion: new GraphQLUnionType({
+    name: 'GeoJSONCRSProperties',
+    description: 'CRS object properties.',
+    types: () => [
+      GeoJSON.NamedCRSPropertiesObject,
+      GeoJSON.LinkedCRSPropertiesObject,
+    ],
+    resolveType: (value) => {
+      if (value.name) return GeoJSON.NamedCRSPropertiesObject;
+      if (value.href) return GeoJSON.LinkedCRSPropertiesObject;
+    },
+  }),
+
+  CoordinateReferenceSystemObject: new GraphQLObjectType({
+    name: 'GeoJSONCoordinateReferenceSystem',
+    description: 'Coordinate Reference System (CRS) object.',
+    fields: () => ({
+      type: { type: new GraphQLNonNull(GeoJSON.CRSTypeEnum) },
+      properties: { type: new GraphQLNonNull(GeoJSON.CRSPropertiesUnion) },
+    }),
+  }),
+
+  GeoJSONInterface: new GraphQLInterfaceType({
+    name: 'GeoJSONInterface',
+    fields: () => ({
+      type: { type: new GraphQLNonNull(GeoJSON.TypeEnum) },
+      crs: {
+        type: new GraphQLNonNull(GeoJSON.CoordinateReferenceSystemObject),
+      },
+      bbox: { type: new GraphQLList(GraphQLFloat) },
+    }),
+    resolveType: (value) => GeoJSON[`${value.type}Object`],
+  }),
+
+  GeometryInterface: new GraphQLInterfaceType({
+    name: 'GeoJSONGeometryInterface',
+    fields: () => ({
+      type: { type: new GraphQLNonNull(GeoJSON.TypeEnum) },
+      crs: {
+        type: new GraphQLNonNull(GeoJSON.CoordinateReferenceSystemObject),
+      },
+      bbox: { type: new GraphQLList(GraphQLFloat) },
+      coordinates: { type: GeoJSON.CoordinatesScalar },
+    }),
+    resolveType: (value) => GeoJSON[`${value.type}Object`],
+  }),
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function coerceCoordinates(value: any) {
+  return value;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function parseCoordinates(valueAST: any) {
+  return valueAST.value;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function coerceObject(value: any) {
+  return JSON.parse(value);
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function parseObject(valueAST: any) {
+  return JSON.stringify(valueAST.value);
+}

package/src/index.ts

@@ -1,43 +1,11 @@
-import { DaemonConfig, DaemonModule } from '@gapi/daemon';
+import { DaemonModule } from '@gapi/daemon';
 import { Module, ModuleWithServices } from '@rxdi/core';
-import { GRAPHQL_PLUGIN_CONFIG, GraphQLModule } from '@rxdi/graphql';
-import {
-  GRAPHQL_PUB_SUB_DI_CONFIG,
-  GraphQLPubSubModule,
-} from '@rxdi/graphql-pubsub';
-import { HapiConfigModel, HapiModule } from '@rxdi/hapi';
+import { GraphQLModule } from '@rxdi/graphql';
+import { GraphQLPubSubModule } from '@rxdi/graphql-pubsub';
+import { HapiModule } from '@rxdi/hapi';
 
 import { FederationController } from './federation.controller';
-
-export interface CoreModuleConfig {
-  server?: HapiConfigModel;
-  graphql?: GRAPHQL_PLUGIN_CONFIG;
-  pubsub?: GRAPHQL_PUB_SUB_DI_CONFIG;
-  daemon?: DaemonConfig;
-}
-
-const DEFAULT_CONFIG: CoreModuleConfig = {
-  server: {
-    hapi: {
-      port: 9000,
-    },
-  },
-  graphql: {
-    path: '/graphql',
-    initQuery: true,
-    writeEffects: false,
-    watcherPort: '',
-    graphqlOptions: {
-      schema: null,
-    },
-    altair: {
-      enabled: true,
-    },
-  },
-  daemon: {
-    activated: false,
-  },
-};
+import { CoreModuleConfig, DEFAULT_CONFIG } from './tokens';
 
 @Module()
 export class CoreModule {
@@ -57,6 +25,7 @@ export class CoreModule {
 }
 
 export * from './enum-to-gql';
+export { GeoJSON } from './geojson.types';
 export * from '@rxdi/core';
 export * from '@rxdi/graphql';
 export * from '@rxdi/graphql-pubsub';
@@ -69,11 +38,9 @@ export {
   extendSchema,
   isSpecifiedScalarType,
 } from 'graphql';
-export * from 'graphql-geojson';
 export {
   FilterFn,
   PubSubEngine,
   PubSubOptions,
   ResolverFn,
 } from 'graphql-subscriptions';
-export * from 'graphql-tools';

package/src/tokens.ts

@@ -1,6 +1,40 @@
+import { DaemonConfig } from '@gapi/daemon';
 import { InjectionToken } from '@rxdi/core';
+import { GRAPHQL_PLUGIN_CONFIG } from '@rxdi/graphql';
+import { GRAPHQL_PUB_SUB_DI_CONFIG } from '@rxdi/graphql-pubsub';
+import { HapiConfigModel } from '@rxdi/hapi';
 
 export const FedarationReplacer = (v: string) => v;
 export const GRAPHQL_FEDERATION_REPLACER = new InjectionToken<
   typeof FedarationReplacer
 >('GRAPHQL_FEDERATION_REPLACER');
+
+export interface CoreModuleConfig {
+  server?: HapiConfigModel;
+  graphql?: GRAPHQL_PLUGIN_CONFIG;
+  pubsub?: GRAPHQL_PUB_SUB_DI_CONFIG;
+  daemon?: DaemonConfig;
+}
+
+export const DEFAULT_CONFIG: CoreModuleConfig = {
+  server: {
+    hapi: {
+      port: 9000,
+    },
+  },
+  graphql: {
+    path: '/graphql',
+    initQuery: true,
+    writeEffects: false,
+    watcherPort: '',
+    graphqlOptions: {
+      schema: null,
+    },
+    altair: {
+      enabled: true,
+    },
+  },
+  daemon: {
+    activated: false,
+  },
+};